---
title: "Tindakan perpindahan basisdata"
version: 3.2
locale: id
source: https://docs.djangoproject.com/id/3.2/ref/contrib/postgres/operations/
canonical: https://djangodocs.dev/id/3.2/ref/contrib/postgres/operations/
---
# Tindakan perpindahan basisdata

Semua [operations](/id/3.2/ref/migration-operations/) ini tersedia dari modul `django.contrib.postgres.operations`.

## Membuat tambahan menggunakan perpindahan

Anda dapat membuat tambahan PostgreSQL dalam basisdata anda menggunakan berkas pemindahan. Contoh ini membuat sebuah tambahan hstore, tetapi prinsip-prinsip sama berlaku untuk tambahan-tambahan lain.

Setel tambahan hstore dalam PostgreSQL sebelum tindakan pertama `CreateModel` atau `AddField` yang melibatkan [`HStoreField`](/id/3.2/ref/contrib/postgres/fields/#django.contrib.postgres.fields.HStoreField) dengan menambahkan perpindahan dengan tindakan [`HStoreExtension`](#django.contrib.postgres.operations.HStoreExtension). Sebagai contoh:

```
from django.contrib.postgres.operations import HStoreExtension

class Migration(migrations.Migration):
    ...

    operations = [
        HStoreExtension(),
        ...
    ]
```

The operation skips adding the extension if it already exists.

For most extensions, this requires a database user with superuser privileges.
If the Django database user doesn't have the appropriate privileges, you'll
have to create the extension outside of Django migrations with a user that has
them. In that case, connect to your Django database and run the query
`CREATE EXTENSION IF NOT EXISTS hstore;`.

> **Changed in Django 3.2**
>
> In older versions, the pre-existence of the extension isn't checked.

## `CreateExtension`

#### `class CreateExtension(name)`

An `Operation` subclass which installs a PostgreSQL extension. For common
extensions, use one of the more specific subclasses below.

#### `name`

Ini adalah argumen wajib. Nama dari tambahan untuk dipasang.

## `BloomExtension`

#### `class BloomExtension`

> **New in Django 3.1**

Installs the `bloom` extension.

## `BtreeGinExtension`

#### `class BtreeGinExtension`

Installs the `btree_gin` extension.

## `BtreeGistExtension`

#### `class BtreeGistExtension`

Installs the `btree_gist` extension.

## `CITextExtension`

#### `class CITextExtension`

Pasang tambahan `citext`.

## `CryptoExtension`

#### `class CryptoExtension`

Pasang tambahan `pgcrypto`.

## `HStoreExtension`

#### `class HStoreExtension`

Pasang tambahan `hstore` dan juga setel hubungan pada penterjemah data hstore untuk kemungkinan penggunaan dalam perpindahaan selanjutnya.

## `TrigramExtension`

#### `class TrigramExtension`

Pasang tambahan `pg_trm`.

## `UnaccentExtension`

#### `class UnaccentExtension`

Pasang tambahan `unaccent`.

## Managing collations using migrations

> **New in Django 3.2**

If you need to filter or order a column using a particular collation that your
operating system provides but PostgreSQL does not, you can manage collations in
your database using a migration file. These collations can then be used with
the `db_collation` parameter on [`CharField`](/id/3.2/ref/models/fields/#django.db.models.CharField),
[`TextField`](/id/3.2/ref/models/fields/#django.db.models.TextField), and their subclasses.

For example, to create a collation for German phone book ordering:

```
from django.contrib.postgres.operations import CreateCollation

class Migration(migrations.Migration):
    ...

    operations = [
        CreateCollation(
            'german_phonebook',
            provider='icu',
            locale='und-u-ks-level2',
        ),
        ...
    ]
```

#### `class CreateCollation(name, locale, * (Keyword-only parameters separator (PEP 3102)), provider='libc', deterministic=True)`

Creates a collation with the given `name`, `locale` and `provider`.

Set the `deterministic` parameter to `False` to create a
non-deterministic collation, such as for case-insensitive filtering.

#### `class RemoveCollation(name, locale, * (Keyword-only parameters separator (PEP 3102)), provider='libc', deterministic=True)`

Removes the collations named `name`.

When reversed this is creating a collation with the provided `locale`,
`provider`, and `deterministic` arguments. Therefore, `locale` is
required to make this operation reversible.

> **Restrictions**
>
> PostgreSQL 9.6 only supports the `'libc'` provider.
>
> Non-deterministic collations are supported only on PostgreSQL 12+.

## Concurrent index operations

PostgreSQL supports the `CONCURRENTLY` option to `CREATE INDEX` and
`DROP INDEX` statements to add and remove indexes without locking out writes.
This option is useful for adding or removing an index in a live production
database.

#### `class AddIndexConcurrently(model_name, index)`

Like [`AddIndex`](/id/3.2/ref/migration-operations/#django.db.migrations.operations.AddIndex), but creates an
index with the `CONCURRENTLY` option. This has a few caveats to be aware
of when using this option, see [the PostgreSQL documentation of building
indexes concurrently](https://www.postgresql.org/docs/current/sql-createindex.html#SQL-CREATEINDEX-CONCURRENTLY).

#### `class RemoveIndexConcurrently(model_name, name)`

Like [`RemoveIndex`](/id/3.2/ref/migration-operations/#django.db.migrations.operations.RemoveIndex), but removes the
index with the `CONCURRENTLY` option. This has a few caveats to be aware
of when using this option, see [the PostgreSQL documentation](https://www.postgresql.org/docs/current/sql-dropindex.html).

> **Note**
>
> The `CONCURRENTLY` option is not supported inside a transaction (see
> [non-atomic migration](/id/3.2/howto/writing-migrations/#non-atomic-migrations)).