Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Perbedaan antara database relasional (SQL) dan DynamoDB saat mengelola indeks
<a name="SQLtoNoSQL.Indexes"></a>

Indeks memberikan Anda akses ke pola kueri alternatif, dan dapat mempercepat kueri. Bagian ini membandingkan dan mengontraskan pembuatan indeks dan penggunaan dalam SQL dan Amazon DynamoDB.

Entah Anda menggunakan basis data relasional atau DynamoDB, Anda harus bijaksana dengan pembuatan indeks. Setiap kali sebuah peristiwa tulis terjadi pada tabel, semua indeks tabel harus diperbarui. Dalam lingkungan yang banyak menulis dengan tabel besar, hal ini dapat menghabiskan banyak sumber daya sistem. Dalam lingkungan read-only atau read-mostly, hal ini tidak terlalu menjadi perhatian. Namun, Anda harus memastikan bahwa indeks tersebut benar-benar digunakan oleh aplikasi Anda, dan tidak hanya menghabiskan ruang.

**Topics**
+ [Perbedaan antara database relasional (SQL) dan DynamoDB saat membuat indeks](#SQLtoNoSQL.Indexes.Creating)
+ [Perbedaan antara database relasional (SQL) dan DynamoDB saat menanyakan dan memindai indeks](#SQLtoNoSQL.Indexes.QueryAndScan)

## Perbedaan antara database relasional (SQL) dan DynamoDB saat membuat indeks
<a name="SQLtoNoSQL.Indexes.Creating"></a>

Bandingkan pernyataan `CREATE INDEX` di SQL dengan operasi `UpdateTable` di Amazon DynamoDB.

**Topics**
+ [Membuat indeks dengan SQL](#SQLtoNoSQL.Indexes.Creating.SQL)
+ [Membuat indeks di DynamoDB](#SQLtoNoSQL.Indexes.Creating.DynamoDB)

### Membuat indeks dengan SQL
<a name="SQLtoNoSQL.Indexes.Creating.SQL"></a>

Dalam basis data relasional, indeks adalah struktur data yang memungkinkan Anda melakukan kueri cepat pada kolom yang berbeda dalam sebuah tabel. Anda dapat menggunakan pernyataan SQL `CREATE INDEX` untuk menambahkan indeks ke tabel yang ada, menentukan kolom yang akan diindeks. Setelah indeks dibuat, Anda dapat melakukan kueri data di tabel seperti biasa, tetapi sekarang basis data dapat menggunakan indeks untuk menemukan baris yang ditentukan dengan cepat di tabel alih-alih memindai keseluruhan tabel.

Setelah Anda membuat indeks, basis data mengelolanya untuk Anda. Setiap kali Anda memodifikasi data dalam tabel, indeks secara otomatis dimodifikasi untuk mencerminkan perubahan dalam tabel.

Dalam MySQL, Anda akan membuat indeks seperti berikut.

```
CREATE INDEX GenreAndPriceIndex
ON Music (genre, price);
```

### Membuat indeks di DynamoDB
<a name="SQLtoNoSQL.Indexes.Creating.DynamoDB"></a>

Dalam DynamoDB, Anda dapat membuat dan menggunakan *indeks sekunder* untuk tujuan yang serupa.

Indeks di DynamoDB berbeda dari rekan-rekan relasional mereka. Ketika Anda membuat indeks sekunder, Anda harus menentukan atribut kunci—kunci partisi dan kunci urutan. Setelah membuat indeks sekunder, Anda dapat melakukan `Query` atau `Scan` padanya seperti yang Anda lakukan dengan tabel. DynamoDB tidak memiliki pengoptimal kueri, sehingga indeks sekunder hanya digunakan ketika Anda melakukan `Query` atau `Scan` padanya.

DynamoDB mendukung dua jenis indeks yang berbeda:
+ Indeks sekunder global - Kunci primer dari indeks dapat berupa setiap dua atribut dari tabel. 
+ Indeks sekunder lokal - Kunci partisi indeks harus sama dengan kunci partisi dari tabel. Namun, kunci urutan dapat berupa atribut lainnya.

DynamoDB memastikan bahwa data dalam indeks sekunder akhirnya konsisten dengan tabel. Anda dapat meminta operasi `Query` atau `Scan` yang sangat konsisten pada tabel atau indeks sekunder lokal. Namun, indeks sekunder global hanya mendukung konsistensi akhir.

Anda dapat menambahkan indeks sekunder global ke tabel yang ada, menggunakan operasi `UpdateTable` dan menentukan `GlobalSecondaryIndexUpdates`.

```
{
    TableName: "Music",
    AttributeDefinitions:[
        {AttributeName: "Genre", AttributeType: "S"},
        {AttributeName: "Price", AttributeType: "N"}
    ],
    GlobalSecondaryIndexUpdates: [
        {
            Create: {
                IndexName: "GenreAndPriceIndex",
                KeySchema: [
                    {AttributeName: "Genre", KeyType: "HASH"}, //Partition key
                    {AttributeName: "Price", KeyType: "RANGE"}, //Sort key
                ],
                Projection: {
                    "ProjectionType": "ALL"
                },
                ProvisionedThroughput: {                                // Only specified if using provisioned mode
                    "ReadCapacityUnits": 1,"WriteCapacityUnits": 1
                }
            }
        }
    ]
}
```

Anda harus memberikan parameter berikut untuk `UpdateTable`:
+ `TableName` – Tabel yang akan dikaitkan dengan indeks.
+ `AttributeDefinitions` – Jenis data untuk atribut skema kunci dari indeks.
+ `GlobalSecondaryIndexUpdates` – Detail tentang indeks yang ingin Anda buat:
  + `IndexName` – Nama untuk indeks.
  + `KeySchema` – Atribut yang digunakan untuk kunci primer indeks.
  + `Projection` – Atribut dari tabel yang disalin ke indeks. Dalam kasus ini, `ALL` berarti bahwa semua atribut disalin.
  + `ProvisionedThroughput (for provisioned tables)` – Jumlah baca dan tulis per detik yang Anda butuhkan untuk tabel ini. (Ini terpisah dari pengaturan throughput yang ditetapkan pada tabel.) 

Bagian dari operasi ini melibatkan pengisian data dari tabel ke indeks baru. Selama pengisian, tabel tetap tersedia. Namun, indeks tidak siap hingga atribut `Backfilling` miliknya berubah dari true ke false. Anda dapat menggunakan operasi `DescribeTable` untuk melihat atribut ini.

## Perbedaan antara database relasional (SQL) dan DynamoDB saat menanyakan dan memindai indeks
<a name="SQLtoNoSQL.Indexes.QueryAndScan"></a>

Bandingkan mengkueri dan memindai indeks menggunakan pernyataan SELECT dalam SQL dengan operasi `Query` dan `Scan` di Amazon DynamoDB.

**Topics**
+ [Mengkueri dan memindai indeks dengan SQL](#SQLtoNoSQL.Indexes.QueryAndScan.SQL)
+ [Mengkueri dan memindai indeks di DynamoDB](#SQLtoNoSQL.Indexes.QueryAndScan.DynamoDB)

### Mengkueri dan memindai indeks dengan SQL
<a name="SQLtoNoSQL.Indexes.QueryAndScan.SQL"></a>

Dalam basis data relasional, Anda tidak bekerja secara langsung dengan indeks. Sebaliknya, Anda membuat kueri tabel dengan menerbitkan pernyataan `SELECT`, dan pengoptimal kueri dapat menggunakan setiap indeks.

*Pengoptimal kueri* adalah komponen sistem manajemen basis data relasional (RDBMS) yang mengevaluasi indeks yang tersedia dan menentukan apakah komponen dapat digunakan untuk mempercepat kueri. Jika indeks dapat digunakan untuk mempercepat kueri, RDBMS mengakses indeks pertama kemudian menggunakannya untuk menemukan data dalam tabel.

Berikut adalah beberapa pernyataan SQL yang dapat digunakan *GenreAndPriceIndex*untuk meningkatkan kinerja. Kami berasumsi bahwa tabel *Music* memiliki cukup data di dalamnya hingga pengoptimal kueri memutuskan untuk menggunakan indeks ini, alih-alih memindai seluruh tabel.

```
/* All of the rock songs */

SELECT * FROM Music
WHERE Genre = 'Rock';
```

```
/* All of the cheap country songs */

SELECT Artist, SongTitle, Price FROM Music
WHERE Genre = 'Country' AND Price < 0.50;
```

### Mengkueri dan memindai indeks di DynamoDB
<a name="SQLtoNoSQL.Indexes.QueryAndScan.DynamoDB"></a>

Dalam DynamoDB, Anda melakukan operasi `Query` dan `Scan` secara langsung pada indeks, dengan cara yang sama seperti yang Anda lakukan pada tabel. Anda dapat menggunakan DynamoDB API atau [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (bahasa kueri yang kompatibel dengan SQL) untuk mengkueri atau memindai indeks. Anda harus menentukan baik `TableName` dan `IndexName`.

Berikut ini adalah beberapa pertanyaan *GenreAndPriceIndex*di DynamoDB. (Skema kunci untuk indeks ini terdiri dari *Genre* dan *Price*.)

------
#### [ DynamoDB API ]

```
// All of the rock songs

{
    TableName: "Music",
    IndexName: "GenreAndPriceIndex",
    KeyConditionExpression: "Genre = :genre",
    ExpressionAttributeValues: {
        ":genre": "Rock"
    },
};
```

Contoh ini menggunakan `ProjectionExpression` untuk menunjukkan bahwa Anda hanya ingin beberapa atribut, bukan semuanya, untuk muncul dalam hasil.

```
// All of the cheap country songs

{
    TableName: "Music",
    IndexName: "GenreAndPriceIndex",
    KeyConditionExpression: "Genre = :genre and Price < :price",
    ExpressionAttributeValues: {
        ":genre": "Country",
        ":price": 0.50
    },
    ProjectionExpression: "Artist, SongTitle, Price"
};
```

Berikut ini adalah pemindaian *GenreAndPriceIndex*.

```
// Return all of the data in the index

{
    TableName:  "Music",
    IndexName: "GenreAndPriceIndex"
}
```

------
#### [ PartiQL for DynamoDB ]

Dengan PartiQL, Anda menggunakan pernyataan PartiQL `Select` untuk melakukan kueri dan pemindaian pada indeks.

```
// All of the rock songs

SELECT * 
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock'
```

```
// All of the cheap country songs

SELECT * 
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock' AND Price < 0.50
```

Berikut ini adalah pemindaian *GenreAndPriceIndex*.

```
// Return all of the data in the index

SELECT *
FROM Music.GenreAndPriceIndex
```

**catatan**  
Untuk contoh kode menggunakan `Select`, lihat [Pernyataan pemilihan PartiQL untuk DynamoDB](ql-reference.select.md).

------