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 membaca data dari tabel
<a name="SQLtoNoSQL.ReadData"></a>

Dengan SQL, Anda menggunakan pernyataan `SELECT` untuk mengambil satu baris atau lebih dari tabel. Anda menggunakan klausul `WHERE` untuk menentukan data yang dikembalikan kepada Anda.

Ini berbeda dengan menggunakan Amazon DynamoDB yang menyediakan operasi berikut untuk membaca data:
+ `ExecuteStatement` mengambil satu atau beberapa item dari tabel. `BatchExecuteStatement`mengambil beberapa item dari tabel yang berbeda dalam satu operasi. Kedua operasi ini menggunakan [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), bahasa kueri yang kompatibel dengan SQL.
+ `GetItem` – Mengambil satu item dari tabel. Ini adalah cara yang paling efisien untuk membaca satu item karena ini menyediakan akses langsung ke lokasi fisik item. (DynamoDB juga menyediakan operasi `BatchGetItem`, memungkinkan Anda untuk melakukan hingga 100 panggilan `GetItem` dalam satu operasi.)
+ `Query` – Mengambil semua item yang memiliki kunci partisi tertentu. Dalam item tersebut, Anda dapat menerapkan syarat untuk kunci urutan dan mengambil hanya subset dari data. `Query` menyediakan akses cepat dan efisien ke partisi tempat data disimpan. (Untuk informasi selengkapnya, lihat [Partisi dan distribusi data di DynamoDB](HowItWorks.Partitions.md).)
+ `Scan` – Mengambil semua item dalam tabel yang ditentukan. (Operasi ini tidak boleh digunakan dengan tabel besar karena dapat mengkonsumsi sejumlah besar sumber daya sistem.)

**catatan**  
Dengan basis data relasional, Anda dapat menggunakan pernyataan `SELECT` untuk menggabungkan data dari beberapa tabel dan mengembalikan hasil. Gabungan sangat penting untuk model relasional. Untuk memastikan bahwa gabungan berjalan efisien, basis data dan aplikasi harus disetel performanya secara berkelanjutan. DynamoDB adalah basis data NoSQL non-relasional yang tidak mendukung gabungan tabel. Sebaliknya, aplikasi membaca data dari satu tabel pada satu waktu. 

Bagian berikut menjelaskan kasus penggunaan yang berbeda untuk membaca data, dan cara melakukan tugas-tugas ini dengan basis data relasional dan dengan DynamoDB.

**Topics**
+ [Perbedaan dalam membaca item menggunakan kunci utamanya](SQLtoNoSQL.ReadData.SingleItem.md)
+ [Perbedaan dalam menanyakan tabel](SQLtoNoSQL.ReadData.Query.md)
+ [Perbedaan dalam memindai tabel](SQLtoNoSQL.ReadData.Scan.md)

# Perbedaan dalam membaca item menggunakan kunci utamanya
<a name="SQLtoNoSQL.ReadData.SingleItem"></a>

Salah satu pola akses umum untuk basis data adalah untuk membaca satu item dari tabel. Anda harus menentukan kunci primer dari item yang Anda inginkan.

**Topics**
+ [Membaca item menggunakan kunci primernya dengan SQL](#SQLtoNoSQL.ReadData.SingleItem.SQL)
+ [Membaca item menggunakan kunci primernya di DynamoDB](#SQLtoNoSQL.ReadData.SingleItem.DynamoDB)

## Membaca item menggunakan kunci primernya dengan SQL
<a name="SQLtoNoSQL.ReadData.SingleItem.SQL"></a>

Dalam SQL, Anda akan menggunakan pernyataan `SELECT` untuk mengambil data dari tabel. Anda dapat meminta satu kolom atau lebih dalam hasil (atau semuanya, jika Anda menggunakan operator `*`). Klausa `WHERE` menentukan baris mana yang dikembalikan.

Berikut ini adalah pernyataan `SELECT` untuk mengambil satu baris dari tabel *Music*. Klausa `WHERE` menentukan nilai-nilai kunci primer.

```
SELECT *
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```

Anda dapat memodifikasi kueri ini untuk mengambil hanya subset dari kolom.

```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```

Perhatikan bahwa kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*.

## Membaca item menggunakan kunci primernya di DynamoDB
<a name="SQLtoNoSQL.ReadData.SingleItem.DynamoDB"></a>

Di Amazon DynamoDB, 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 membaca item dari tabel.

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

Dengan DynamoDB API, Anda menggunakan operasi `PutItem` untuk menambahkan item ke tabel.

DynamoDB menyediakan operasi `GetItem` untuk mengambil item dengan kunci primernya. `GetItem` sangat efisien karena menyediakan akses langsung ke lokasi fisik item. (Untuk informasi selengkapnya, lihat [Partisi dan distribusi data di DynamoDB](HowItWorks.Partitions.md).)

Secara default, `GetItem` mengembalikan seluruh item dengan semua atribut.

```
{
    TableName: "Music",
    Key: {
        "Artist": "No One You Know",
        "SongTitle": "Call Me Today"
    }
}
```

Anda dapat menambahkan parameter `ProjectionExpression` untuk mengembalikan hanya beberapa atribut.

```
{
    TableName: "Music",
    Key: {
        "Artist": "No One You Know",
        "SongTitle": "Call Me Today"
    },
    "ProjectionExpression": "AlbumTitle, Year, Price"
}
```

Perhatikan bahwa kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*.

Operasi `GetItem` DynamoDB sangat efisien. Ini menggunakan nilai-nilai kunci primer untuk menentukan lokasi penyimpanan yang tepat dari item yang bersangkutan, dan mengambilnya langsung dari sana. Pernyataan `SELECT` SQL sama efisiennya, dalam hal mengambil item dengan nilai-nilai kunci primer.

Pernyataan `SELECT` mendukung berbagai jenis tabel kueri dan pindai. DynamoDB menyediakan fungsionalitas serupa dengan operasi `Query` dan `Scan`, yang dijelaskan dalam [Perbedaan dalam menanyakan tabel](SQLtoNoSQL.ReadData.Query.md) dan [Perbedaan dalam memindai tabel](SQLtoNoSQL.ReadData.Scan.md).

Pernyataan `SELECT` SQL dapat melakukan gabungan tabel, memungkinkan Anda untuk mengambil data dari beberapa tabel pada waktu yang sama. Gabungan paling efektif di mana tabel basis data dinormalisasi dan hubungan antara tabel jelas. Namun, jika Anda menggabungkan terlalu banyak tabel dalam satu performa aplikasi pernyataan `SELECT` dapat terpengaruh. Anda dapat mengatasi masalah tersebut dengan menggunakan replikasi basis data, tampilan terwujud, atau penulisan ulang kueri.

DynamoDB adalah basis data non-relasional dan tidak mendukung gabungan tabel. Jika Anda memigrasikan aplikasi yang ada dari basis data relasional ke DynamoDB, Anda perlu mendenormalisasi model data Anda untuk menghapus kebutuhan gabungan.

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

Dengan PartiQL, Anda menggunakan operasi `ExecuteStatement` untuk membaca item dari tabel, menggunakan pernyataan `Select` PartiQL.

```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```

Perhatikan bahwa kunci utama untuk tabel ini terdiri dari Artis dan SongTitle. 

**catatan**  
 Pernyataan pilih PartiQL dapat digunakan juga pada tabel Kueri atau Pindai DynamoDB

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

------

# Perbedaan dalam menanyakan tabel
<a name="SQLtoNoSQL.ReadData.Query"></a>

Pola akses umum lainnya adalah membaca beberapa item dari tabel, berdasarkan kriteria kueri Anda.

**Topics**
+ [Mengkueri tabel dengan SQL](#SQLtoNoSQL.ReadData.Query.SQL)
+ [Mengkueri tabel di DynamoDB](#SQLtoNoSQL.ReadData.Query.DynamoDB)

## Mengkueri tabel dengan SQL
<a name="SQLtoNoSQL.ReadData.Query.SQL"></a>

Saat menggunakan SQL, pernyataan `SELECT` memungkinkan Anda melakukan kueri pada kolom kunci, kolom non-kunci, atau kombinasi apa pun. Klausa `WHERE` menentukan baris mana yang dikembalikan, seperti yang ditunjukkan dalam contoh berikut.

```
/* Return a single song, by primary key */

SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today';
```

```
/* Return all of the songs by an artist */

SELECT * FROM Music
WHERE Artist='No One You Know';
```

```
/* Return all of the songs by an artist, matching first part of title */

SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle LIKE 'Call%';
```

```
/* Return all of the songs by an artist, only if the price is less than 1.00 */

SELECT * FROM Music
WHERE Artist='No One You Know'
AND Price < 1.00;
```

Perhatikan bahwa kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*.

## Mengkueri tabel di DynamoDB
<a name="SQLtoNoSQL.ReadData.Query.DynamoDB"></a>

Di Amazon DynamoDB, 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 menanyakan item dari tabel.

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

Dengan Amazon DynamoDB, Anda dapat menggunakan operasi `Query` untuk mengambil data dengan cara yang serupa. Operasi `Query` ini menyediakan akses cepat dan efisien ke lokasi fisik di mana data disimpan. Untuk informasi selengkapnya, lihat [Partisi dan distribusi data di DynamoDB](HowItWorks.Partitions.md).

Anda dapat menggunakan `Query` dengan tabel atau indeks sekunder apa pun. Anda harus menentukan syarat kesetaraan untuk nilai kunci partisi, dan secara opsional Anda dapat menyediakan syarat lain untuk atribut kunci urutan jika ditentukan.

Parameter `KeyConditionExpression` menentukan nilai kunci yang ingin Anda kueri. Anda dapat menggunakan opsi `FilterExpression` untuk menghapus item tertentu dari hasil sebelum item dikembalikan kepada Anda.

Di DynamoDB, Anda harus menggunakan `ExpressionAttributeValues` sebagai placeholder dalam parameter ekspresi (seperti `KeyConditionExpression` dan `FilterExpression`). Hal ini analog dengan penggunaan *variabel pengikatan* dalam basis data relasional, di mana Anda mengganti nilai-nilai aktual ke pernyataan `SELECT` pada saat runtime.

Perhatikan bahwa kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*.

Berikut adalah beberapa contoh `Query` DynamoDB.

```
// Return a single song, by primary key

{
    TableName: "Music",
    KeyConditionExpression: "Artist = :a and SongTitle = :t",
    ExpressionAttributeValues: {
        ":a": "No One You Know",
        ":t": "Call Me Today"
    }
}
```

```
// Return all of the songs by an artist

{
    TableName: "Music",
    KeyConditionExpression: "Artist = :a",
    ExpressionAttributeValues: {
        ":a": "No One You Know"
    }
}
```

```
// Return all of the songs by an artist, matching first part of title

{
    TableName: "Music",
    KeyConditionExpression: "Artist = :a and begins_with(SongTitle, :t)",
    ExpressionAttributeValues: {
        ":a": "No One You Know",
        ":t": "Call"
    }
}
```

```
// Return all of the songs by an artist, only if the price is less than 1.00

{
    TableName: "Music",
    KeyConditionExpression: "Artist = :a",
    FilterExpression: "Price < :p",
    ExpressionAttributeValues: {
        ":a": "No One You Know",
        ":p": 1.00
    }
}
```

**catatan**  
A `FilterExpression` diterapkan setelah `Query` membaca item yang cocok, sehingga tidak mengurangi kapasitas baca yang dikonsumsi. Jika memungkinkan, modelkan data Anda sehingga kondisi rentang digunakan `KeyConditionExpression` pada kunci pengurutan untuk kueri yang efisien. Untuk informasi selengkapnya, lihat [Menanyakan tabel di DynamoDB](Query.md).

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

Dengan PartiQL, Anda dapat melakukan kueri dengan menggunakan operasi `ExecuteStatement` dan pernyataan `Select` pada kunci partisi.

```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know'
```

Menggunakan pernyataan `SELECT` dengan cara ini mengembalikan semua lagu yang terkait dengan `Artist` tertentu.

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

------

# Perbedaan dalam memindai tabel
<a name="SQLtoNoSQL.ReadData.Scan"></a>

Dalam SQL, pernyataan `SELECT` tanpa sebuah klausul `WHERE` akan mengembalikan setiap baris dalam sebuah tabel. Di Amazon DynamoDB, operasi `Scan` melakukan hal yang sama. Dalam kedua kasus, Anda dapat mengambil semua item atau hanya beberapa item.

Entah Anda menggunakan basis data SQL atau NoSQL, pindaian tidak boleh sering digunakan karena pindaian dapat mengonsumsi sejumlah besar sumber daya sistem. Terkadang pemindaian layak digunakan (seperti memindai tabel kecil) atau tidak dapat dihindari (seperti melakukan ekspor data secara massal). Namun, sebagai aturan umum, Anda harus merancang aplikasi Anda agar tidak melakukan pemindaian. Untuk informasi selengkapnya, lihat [Menanyakan tabel di DynamoDB](Query.md).

**catatan**  
Melakukan ekspor massal juga membuat setidaknya 1 file per partisi. Semua item di setiap file berasal dari keyspace hash partisi tertentu.

**Topics**
+ [Memindai tabel dengan SQL](#SQLtoNoSQL.ReadData.Scan.SQL)
+ [Memindai tabel di DynamoDB](#SQLtoNoSQL.ReadData.Scan.DynamoDB)

## Memindai tabel dengan SQL
<a name="SQLtoNoSQL.ReadData.Scan.SQL"></a>

Saat menggunakan SQL Anda dapat memindai tabel dan mengambil semua data dengan menggunakan pernyataan `SELECT` tanpa menentukan klausul `WHERE`. Anda dapat meminta satu kolom atau lebih dalam hasil. Atau, Anda dapat meminta semuanya jika Anda menggunakan karakter wildcard (\$1).

Berikut ini adalah contoh-contoh penggunaan pernyataan `SELECT`.

```
/* Return all of the data in the table */
SELECT * FROM Music;
```

```
/* Return all of the values for Artist and Title */
SELECT Artist, Title FROM Music;
```

## Memindai tabel di DynamoDB
<a name="SQLtoNoSQL.ReadData.Scan.DynamoDB"></a>

Di Amazon DynamoDB, 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 melakukan pemindaian pada tabel.

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

Dengan DynamoDB API, Anda menggunakan operasi `Scan` untuk mengembalikan satu atribut item dan item dengan mengakses setiap item dalam tabel atau indeks sekunder.

```
// Return all of the data in the table
{
    TableName:  "Music"
}
```

```
// Return all of the values for Artist and Title
{
    TableName:  "Music",
    ProjectionExpression: "Artist, Title"
}
```

Operasi `Scan` ini juga menyediakan parameter `FilterExpression`, yang dapat Anda gunakan untuk membuang item yang tidak ingin Anda tampilkan di hasil. Sebuah `FilterExpression` diterapkan setelah pemindaian dilakukan, namun sebelum hasilnya dikembalikan kepada Anda. (Ini tidak dianjurkan dengan tabel besar. Anda masih dikenakan biaya untuk seluruh `Scan`, bahkan jika hanya beberapa item yang cocok dikembalikan.)

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

Dengan PartiQL, Anda melakukan pemindaian dengan menggunakan operasi `ExecuteStatement` untuk mengembalikan semua konten untuk tabel menggunakan pernyataan `Select`.

```
SELECT AlbumTitle, Year, Price
FROM Music
```

Ingat bahwa pernyataan ini akan mengembalikan semua item untuk dalam tabel Music. 

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

------