Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Pelajari cara beralih dari SQL ke NoSQL
Jika Anda seorang developer aplikasi, Anda mungkin memiliki beberapa pengalaman menggunakan sistem manajemen basis data relasional (RDBMS) dan Structured Kueri Language (SQL). Ketika Anda mulai bekerja dengan Amazon DynamoDB, Anda akan menemukan banyak kesamaan, tetapi juga banyak hal yang berbeda. *NoSQL* adalah istilah yang digunakan untuk menggambarkan sistem basis data nonrelational yang sangat tersedia, dapat diskalakan, dan dioptimalkan untuk performa tinggi. Alih-alih model relasional, basis data NoSQL (seperti DynamoDB) menggunakan model alternatif untuk manajemen data, seperti pasangan nilai kunci atau penyimpanan dokumen. Untuk informasi selengkapnya, lihat [Apa itu NoSQL?](https://aws.amazon.com/nosql).
Amazon DynamoDB mendukung [PartiQL](https://partiql.org/), bahasa kueri open-source yang kompatibel dengan SQL yang memudahkan Anda untuk melakukan kueri data secara efisien, terlepas dari di mana atau dalam format apa itu disimpan. Dengan PartiQL, Anda dapat dengan mudah memproses data terstruktur dari basis data relasional, data semi-terstruktur dan bersarang dalam format data terbuka, dan bahkan data tanpa skema di NoSQL atau basis data dokumen yang memungkinkan atribut berbeda untuk baris yang berbeda. Untuk informasi selengkapnya, lihat [bahasa kueri PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html).
Bagian berikut menjelaskan tugas basis data umum, membandingkan dan mengontraskan pernyataan SQL dengan operasi DynamoDB setara mereka.
**catatan**
Contoh SQL di bagian ini kompatibel dengan MySQL RDBMS.
Contoh DynamoDB di bagian ini menunjukkan nama operasi DynamoDB, bersama dengan parameter untuk operasi dalam format JSON.
**Topics**
+ [Memilih antara relasional (SQL) dan NoSQL](SQLtoNoSQL.WhyDynamoDB.md)
+ [Perbedaan dalam mengakses database relasional (SQL) dan DynamoDB](SQLtoNoSQL.Accessing.md)
+ [Perbedaan antara database relasional (SQL) dan DynamoDB saat membuat tabel](SQLtoNoSQL.CreateTable.md)
+ [Perbedaan antara mendapatkan informasi tabel dari database relasional (SQL) dan DynamoDB](SQLtoNoSQL.GetTableInfo.md)
+ [Perbedaan antara database relasional (SQL) dan DynamoDB saat menulis data ke tabel](SQLtoNoSQL.WriteData.md)
+ [Perbedaan antara database relasional (SQL) dan DynamoDB saat membaca data dari tabel](SQLtoNoSQL.ReadData.md)
+ [Perbedaan antara database relasional (SQL) dan DynamoDB saat mengelola indeks](SQLtoNoSQL.Indexes.md)
+ [Perbedaan antara database relasional (SQL) dan DynamoDB saat memodifikasi data dalam tabel](SQLtoNoSQL.UpdateData.md)
+ [Perbedaan antara database relasional (SQL) dan DynamoDB saat menghapus data dari tabel](SQLtoNoSQL.DeleteData.md)
+ [Perbedaan antara database relasional (SQL) dan DynamoDB saat menghapus tabel](SQLtoNoSQL.RemoveTable.md)
# Memilih antara relasional (SQL) dan NoSQL
Aplikasi masa kini memiliki persyaratan yang lebih menuntut daripada sebelumnya. Misalnya, game online mungkin dimulai dengan hanya beberapa pengguna dan jumlah data yang sangat kecil. Namun, jika game menjadi sukses, itu dapat dengan mudah melampaui sumber daya dari sistem manajemen basis data yang mendasarinya. Sudah biasa bagi aplikasi berbasis web untuk memiliki ratusan, ribuan, atau jutaan pengguna bersamaan, dengan data baru seukuran terabyte atau lebih yang dihasilkan per hari. Basis data untuk aplikasi tersebut harus menangani puluhan (atau ratusan) dari ribuan baca dan tulis per detik.
Amazon DynamoDB sangat cocok untuk jenis beban kerja tersebut. Sebagai developer, Anda dapat memulai dari kecil dan secara bertahap meningkatkan pemanfaatan Anda seiring aplikasi Anda menjadi lebih populer. DynamoDB menskalakan tanpa hambatan untuk menangani jumlah data yang sangat besar dan jumlah pengguna yang sangat besar.
Untuk informasi lebih lanjut tentang pemodelan basis data relasional tradisional dan cara menyesuaikannya untuk DynamoDB, lihat [Praktik terbaik untuk memodelkan data relasional di DynamoDB](bp-relational-modeling.md).
Tabel berikut menunjukkan beberapa perbedaan tingkat tinggi antara sistem manajemen basis data relasional (RDBMS) dan DynamoDB.
****
| Karakteristik | Sistem manajemen basis data relasional (RDBMS) | Amazon DynamoDB |
| --- | --- | --- |
| Beban Kerja Optimal | Kueri ad hoc; pergudangan data; OLAP (pemrosesan analitis online). | Aplikasi berskala web, termasuk jejaring sosial, game, berbagi media, dan Internet untuk Segala (IoT). |
| Model Data | Model relasional membutuhkan skema yang didefinisikan dengan baik, di mana data dinormalisasi ke dalam tabel, baris, dan kolom. Selain itu, semua hubungan didefinisikan antara tabel, kolom, indeks, dan elemen basis data lainnya. | DynamoDB tidak memiliki skema. Setiap tabel harus memiliki kunci primer untuk secara unik mengidentifikasi setiap item data, tetapi tidak ada kendala yang sama pada atribut non-kunci lainnya. DynamoDB dapat mengelola data terstruktur atau semi terstruktur, termasuk dokumen JSON. |
| Akses Data | SQL adalah standar untuk menyimpan dan mengambil data. Basis data relasional menawarkan seperangkat alat untuk menyederhanakan pengembangan aplikasi yang didorong basis data, tetapi semua alat ini menggunakan SQL. | Anda dapat menggunakan Konsol Manajemen AWS, the AWS CLI, atau WorkBench NoSQL untuk bekerja dengan DynamoDB dan melakukan tugas ad hoc. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), bahasa kueri yang kompatibel dengan SQL, memungkinkan Anda memilih, menyisipkan, memperbarui, dan menghapus data di DynamoDB. Aplikasi dapat menggunakan kit pengembangan AWS perangkat lunak (SDKs) untuk bekerja dengan DynamoDB menggunakan antarmuka berbasis objek, berpusat pada dokumen, atau tingkat rendah. |
| Performa | Basis data relasional dioptimalkan untuk penyimpanan, sehingga performa umumnya tergantung pada subsistem disk. Developer dan administrator basis data harus mengoptimalkan permintaan, indeks, dan struktur tabel untuk mencapai puncak performa. | DynamoDB dioptimalkan untuk melakukan komputasi, sehingga performa utamanya adalah fungsi dari hardware yang mendasari dan latensi jaringan. Sebagai layanan terkelola, DynamoDB mengisolasi Anda dan aplikasi Anda dari detail implementasi ini, sehingga Anda dapat fokus pada merancang dan membangun aplikasi yang kuat dan berperforma tinggi. |
| Penskalaan | Paling mudah untuk menaikkan skala dengan perangkat keras yang lebih cepat. Mungkin juga bagi tabel basis data untuk menjangkau beberapa host dalam sistem terdistribusi, tetapi ini memerlukan investasi tambahan. basis data relasional memiliki ukuran maksimum untuk jumlah dan ukuran file, yang membebankan batas atas pada skalabilitas. | DynamoDB dirancang untuk diperluas menggunakan klaster perangkat keras terdistribusi. Desain ini memungkinkan peningkatan throughput tanpa peningkatan latensi. Pelanggan menentukan persyaratan throughput mereka, dan DynamoDB mengalokasikan sumber daya yang cukup untuk memenuhi persyaratan tersebut. Tidak ada batas atas pada jumlah item per tabel, atau ukuran total tabel tersebut. |
# Perbedaan dalam mengakses database relasional (SQL) dan DynamoDB
Sebelum aplikasi Anda dapat mengakses basis data, aplikasi harus *diautentikasi* untuk memastikan bahwa aplikasi diperbolehkan untuk menggunakan basis data. Aplikasi harus *diotorisasi* sehingga aplikasi hanya dapat melakukan tindakan yang memiliki izin.
Diagram berikut menunjukkan interaksi klien dengan basis data relasional dan dengan Amazon DynamoDB.
![\[Interaksi dengan basis data relasional dan NoSQL.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/SQLtoNoSQL.png)
Tabel berikut memiliki lebih banyak detail tentang tugas interaksi klien.
****
| Karakteristik | Sistem manajemen basis data relasional (RDBMS) | Amazon DynamoDB |
| --- | --- | --- |
| Alat untuk Mengakses Basis Data | Kebanyakan basis data relasional menyediakan antarmuka baris perintah (CLI) sehingga Anda dapat memasukkan pernyataan SQL ad hoc dan melihat hasilnya segera. | Dalam sebagian besar kasus, Anda menulis kode aplikasi. Anda juga dapat menggunakan Workbench Konsol Manajemen AWS, the AWS Command Line Interface (AWS CLI), atau NoSQL untuk mengirim permintaan ad hoc ke DynamoDB dan melihat hasilnya. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), bahasa kueri yang kompatibel dengan SQL, memungkinkan Anda memilih, menyisipkan, memperbarui, dan menghapus data di DynamoDB. |
| Menghubungkan ke Basis Data | Program aplikasi menetapkan dan memelihara koneksi jaringan dengan basis data. Ketika aplikasi selesai, aplikasi mengakhiri koneksi. | DynamoDB adalah layanan web, dan interaksi dengannya adalah stateless. Aplikasi tidak perlu mempertahankan koneksi jaringan yang persisten. Sebaliknya, interaksi dengan DynamoDB terjadi menggunakan permintaan dan respons HTTP(S). |
| Autentikasi | Aplikasi tidak dapat terhubung ke basis data hingga diautentikasi. RDBMS dapat melakukan autentikasi itu sendiri, atau RDBMS dapat mengirimkan tugas ini ke sistem operasi host atau directory service. | Setiap permintaan untuk DynamoDB harus disertai dengan tanda tangan kriptografi, yang mengautentikasi permintaan tertentu. AWS SDKsMenyediakan semua logika yang diperlukan untuk membuat tanda tangan dan permintaan penandatanganan. Untuk informasi selengkapnya, lihat [Menandatangani permintaan AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) di bagian Referensi Umum AWS. |
| Otorisasi | Aplikasi hanya dapat melakukan tindakan yang telah mendapatkan otorisasi. Administrator basis data atau pemilik aplikasi dapat menggunakan SQL GRANT dan REVOKE pernyataan untuk mengontrol akses ke objek basis data (misalnya tabel), data (misalnya baris dalam tabel), atau kemampuan untuk menerbitkan pernyataan SQL tertentu. | Di DynamoDB, otorisasi ditangani AWS Identity and Access Management oleh (IAM). Anda dapat menulis kebijakan IAM untuk memberikan izin pada sumber daya DynamoDB (misalnya tabel), dan kemudian megizinkan pengguna dan peran IAM untuk menggunakan kebijakan tersebut. IAM juga dilengkapi kontrol akses terperinci untuk item data individual dalam tabel DynamoDB. Untuk informasi selengkapnya, lihat [Manajemen Identitas dan Akses untuk Amazon DynamoDB](security-iam.md). |
| Mengirim Permintaan | Aplikasi menerbitkan pernyataan SQL untuk setiap operasi basis data yang ingin dilakukan. Sebelum penerimaan pernyataan SQL, RDBMS memeriksa sintaks, membuat rencana untuk melakukan operasi, kemudian menjalankan rencana. | Aplikasi mengirimkan permintaan HTTP(S) untuk DynamoDB. Permintaan berisi nama operasi DynamoDB untuk dilakukan, bersama dengan parameter. DynamoDB menjalankan permintaan segera. |
| Menerima Respons | RDBMS mengembalikan hasil dari pernyataan SQL. Jika ada kesalahan, RDBMS mengembalikan status dan pesan kesalahan. | DynamoDB mengembalikan respons HTTP(S) yang berisi hasil operasi. Jika ada kesalahan, DynamoDB mengembalikan status dan pesan kesalahan HTTP. |
# Perbedaan antara database relasional (SQL) dan DynamoDB saat membuat tabel
Tabel adalah struktur data mendasar dalam basis data relasional dan di Amazon DynamoDB. Sistem manajemen basis data relasional (RDBMS) mengharuskan Anda untuk menentukan skema tabel ketika Anda membuatnya. Sebaliknya, tabel DynamoDB tidak memiliki skema-selain kunci primer, Anda tidak perlu mendefinisikan atribut tambahan atau jenis data ketika Anda membuat tabel.
Bagian berikut membandingkan bagaimana Anda akan membuat tabel dengan SQL dengan bagaimana Anda akan membuatnya dengan DynamoDB.
**Topics**
+ [Membuat tabel dengan SQL](#SQLtoNoSQL.CreateTable.SQL)
+ [Membuat tabel dengan DynamoDB](#SQLtoNoSQL.CreateTable.DynamoDB)
## Membuat tabel dengan SQL
Dengan SQL Anda akan menggunakan pernyataan `CREATE TABLE` untuk membuat tabel, seperti yang ditunjukkan pada contoh berikut.
```
CREATE TABLE Music (
Artist VARCHAR(20) NOT NULL,
SongTitle VARCHAR(30) NOT NULL,
AlbumTitle VARCHAR(25),
Year INT,
Price FLOAT,
Genre VARCHAR(10),
Tags TEXT,
PRIMARY KEY(Artist, SongTitle)
);
```
Kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*.
Anda harus menentukan semua kolom tabel dan jenis data, serta kunci primer tabel. (Anda dapat menggunakan pernyataan `ALTER TABLE` untuk mengubah definisi ini nanti, jika perlu.)
Banyak implementasi SQL memungkinkan Anda menentukan spesifikasi penyimpanan untuk tabel Anda, sebagai bagian dari pernyataan `CREATE TABLE`. Kecuali jika Anda mengindikasikan sebaliknya, tabel dibuat dengan pengaturan penyimpanan default. Dalam lingkungan produksi, administrator basis data dapat membantu menentukan parameter penyimpanan optimal.
## Membuat tabel dengan DynamoDB
Gunakan operasi `CreateTable` untuk membuat tabel mode yang ditetapkan, menentukan parameter seperti yang ditunjukkan berikut:
```
{
TableName : "Music",
KeySchema: [
{
AttributeName: "Artist",
KeyType: "HASH" //Partition key
},
{
AttributeName: "SongTitle",
KeyType: "RANGE" //Sort key
}
],
AttributeDefinitions: [
{
AttributeName: "Artist",
AttributeType: "S"
},
{
AttributeName: "SongTitle",
AttributeType: "S"
}
],
ProvisionedThroughput: { // Only specified if using provisioned mode
ReadCapacityUnits: 1,
WriteCapacityUnits: 1
}
}
```
Kunci utama untuk tabel ini terdiri dari *Artist* (partition key) dan *SongTitle*(sort key).
Anda harus memberikan parameter berikut untuk `CreateTable`:
+ `TableName` — Nama tabel.
+ `KeySchema` — Atribut yang digunakan untuk kunci primer. Untuk informasi selengkapnya, lihat [Tabel, item, dan atribut](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.TablesItemsAttributes) dan [Kunci primer](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.PrimaryKey).
+ `AttributeDefinitions` — Jenis data untuk atribut skema kunci.
+ `ProvisionedThroughput (for provisioned tables)` — Jumlah baca dan tulis per detik yang Anda butuhkan untuk tabel ini. DynamoDB mencadangkan cukup penyimpanan dan sumber daya sistem sehingga persyaratan throughput Anda selalu dipenuhi. Anda dapat menggunakan operasi `UpdateTable` untuk mengubah ini nanti, jika perlu. Anda tidak perlu menentukan persyaratan penyimpanan tabel karena alokasi penyimpanan terkelola sepenuhnya oleh DynamoDB.
# Perbedaan antara mendapatkan informasi tabel dari database relasional (SQL) dan DynamoDB
Anda dapat memverifikasi bahwa tabel telah dibuat sesuai dengan spesifikasi Anda. Dalam basis data relasional, semua skema tabel ditampilkan. Tabel Amazon DynamoDB tidak memiliki skema, sehingga hanya atribut kunci primer yang ditampilkan.
**Topics**
+ [Mendapatkan informasi tentang tabel dengan SQL](#SQLtoNoSQL.GetTableInfo.SQL)
+ [Dapatkan informasi tentang tabel DynamoDB](#SQLtoNoSQL.GetTableInfo.DynamoDB)
## Mendapatkan informasi tentang tabel dengan SQL
Sebagian besar sistem manajemen basis data relasional (RDBMS) memungkinkan Anda untuk menggambarkan struktur tabel - kolom, jenis data, definisi kunci primer, dan sebagainya. Tidak ada cara standar untuk melakukan hal ini di SQL. Namun, banyak sistem basis data menyediakan perintah `DESCRIBE`. Berikut adalah contoh dari MySQL.
```
DESCRIBE Music;
```
Ini mengembalikan struktur tabel Anda, dengan semua nama kolom, jenis data, dan ukuran.
```
+------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| Artist | varchar(20) | NO | PRI | NULL | |
| SongTitle | varchar(30) | NO | PRI | NULL | |
| AlbumTitle | varchar(25) | YES | | NULL | |
| Year | int(11) | YES | | NULL | |
| Price | float | YES | | NULL | |
| Genre | varchar(10) | YES | | NULL | |
| Tags | text | YES | | NULL | |
+------------+-------------+------+-----+---------+-------+
```
Kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*.
## Dapatkan informasi tentang tabel DynamoDB
DynamoDB memiliki operasi, `DescribeTable` yang serupa. Satu-satunya parameter adalah nama tabel.
```
{
TableName : "Music"
}
```
Balasan dari `DescribeTable` terlihat seperti berikut ini.
```
{
"Table": {
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"TableName": "Music",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH" //Partition key
},
{
"AttributeName": "SongTitle",
"KeyType": "RANGE" //Sort key
}
],
...
```
`DescribeTable` juga mengembalikan informasi tentang indeks pada tabel, pengaturan throughput yang ditetapkan, jumlah item perkiraan, dan metadata lainnya.
# Perbedaan antara database relasional (SQL) dan DynamoDB saat menulis data ke tabel
Tabel basis data relasional berisi *barisan* data. Baris terdiri dari *kolom*. Tabel Amazon DynamoDB berisi *item*. Item terdiri dari *atribut*.
Bagian ini menjelaskan cara menulis satu baris (atau item) ke tabel.
**Topics**
+ [Menulis data ke tabel dengan SQL](#SQLtoNoSQL.WriteData.SQL)
+ [Menulis data ke tabel di DynamoDB](#SQLtoNoSQL.WriteData.DynamoDB)
## Menulis data ke tabel dengan SQL
Sebuah tabel dalam basis data relasional adalah struktur data dua dimensi yang terdiri dari baris dan kolom. Beberapa sistem manajemen basis data juga menyediakan dukungan untuk data semi terstruktur, biasanya dengan JSON asli atau jenis data XML. Namun, detail implementasi bervariasi antara vendor.
Dalam SQL, Anda akan menggunakan pernyataan `INSERT` untuk menambahkan baris ke tabel.
```
INSERT INTO Music
(Artist, SongTitle, AlbumTitle,
Year, Price, Genre,
Tags)
VALUES(
'No One You Know', 'Call Me Today', 'Somewhat Famous',
2015, 2.14, 'Country',
'{"Composers": ["Smith", "Jones", "Davis"],"LengthInSeconds": 214}'
);
```
Kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*. Anda harus menentukan nilai untuk kolom ini.
**catatan**
Contoh ini menggunakan kolom *Tanda* untuk menyimpan data semi terstruktur tentang lagu di tabel *Music*. Kolom *Tanda* didefinisikan sebagai jenis TEXT, yang dapat menyimpan hingga 65.535 karakter di MySQL.
## Menulis data ke tabel di DynamoDB
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 menambahkan item ke tabel.
------
#### [ DynamoDB API ]
Dengan DynamoDB API, Anda menggunakan operasi `PutItem` untuk menambahkan item ke tabel.
```
{
TableName: "Music",
Item: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today",
"AlbumTitle":"Somewhat Famous",
"Year": 2015,
"Price": 2.14,
"Genre": "Country",
"Tags": {
"Composers": [
"Smith",
"Jones",
"Davis"
],
"LengthInSeconds": 214
}
}
}
```
Kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*. Anda harus menentukan nilai untuk atribut ini.
Berikut adalah beberapa hal penting untuk diketahui tentang contoh `PutItem`:
+ DynamoDB menyediakan dukungan asli untuk dokumen, menggunakan JSON. Hal ini membuat DynamoDB ideal untuk menyimpan data semi terstruktur, seperti *Tag*. Anda juga dapat mengambil dan memanipulasi data dari dalam dokumen JSON.
+ Tabel *Musik* tidak memiliki atribut yang telah ditentukan sebelumnya, selain kunci utama (*Artis* dan *SongTitle*).
+ Sebagian besar basis data SQL berorientasi transaksi. Ketika Anda menerbitkan pernyataan `INSERT`, modifikasi data tidak permanen sampai Anda menerbitkan pernyataan `COMMIT`. Dengan Amazon DynamoDB, efek operasi `PutItem` bersifat permanen ketika DynamoDB membalas dengan kode status HTTP 200 (`OK`).
Berikut adalah beberapa contoh `PutItem` lainnya.
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle":"Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle":"Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Still In Love",
"AlbumTitle":"The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying":[
"KHCR", "KBQX", "WTNR", "WJJH"
],
"TourDates": {
"Seattle": "20150625",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle":"The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
}
```
**catatan**
Selain itu`PutItem`, DynamoDB mendukung operasi `BatchWriteItem` untuk menulis beberapa item pada saat yang sama.
------
#### [ PartiQL for DynamoDB ]
Dengan PartiQL, Anda menggunakan operasi `ExecuteStatement` untuk menambahkan item ke tabel, menggunakan pernyataan `Insert` PartiQL.
```
INSERT into Music value {
'Artist': 'No One You Know',
'SongTitle': 'Call Me Today',
'AlbumTitle': 'Somewhat Famous',
'Year' : '2015',
'Genre' : 'Acme'
}
```
Kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*. Anda harus menentukan nilai untuk atribut ini.
**catatan**
Untuk contoh kode menggunakan `Insert` dan `ExecuteStatement`, lihat [Pernyataan sisipkan PartiQL untuk DynamoDB](ql-reference.insert.md).
------
# Perbedaan antara database relasional (SQL) dan DynamoDB saat membaca data dari tabel
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
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
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
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
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
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
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
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
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
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).
------
# Perbedaan antara database relasional (SQL) dan DynamoDB saat mengelola indeks
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
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
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
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
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
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
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).
------
# Perbedaan antara database relasional (SQL) dan DynamoDB saat memodifikasi data dalam tabel
Bahasa SQL menyediakan pernyataan `UPDATE` untuk memodifikasi data. Amazon DynamoDB menggunakan operasi `UpdateItem` untuk menyelesaikan tugas yang serupa.
**Topics**
+ [Memodifikasi data dalam tabel dengan SQL](#SQLtoNoSQL.UpdateData.SQL)
+ [Memodifikasi data dalam tabel di DynamoDB](#SQLtoNoSQL.UpdateData.DynamoDB)
## Memodifikasi data dalam tabel dengan SQL
Dalam SQL, Anda akan menggunakan pernyataan `UPDATE` untuk memodifikasi satu baris atau lebih. Klausa `SET` menentukan nilai-nilai baru untuk satu kolom atau lebih, dan klausul `WHERE` menentukan baris yang dimodifikasi. Berikut adalah contohnya.
```
UPDATE Music
SET RecordLabel = 'Global Records'
WHERE Artist = 'No One You Know' AND SongTitle = 'Call Me Today';
```
Jika tidak ada baris yang cocok dengan klausul `WHERE`, pernyataan `UPDATE` tidak berpengaruh.
## Memodifikasi data dalam tabel di DynamoDB
Di 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 modifikasi satu item. Jika Anda ingin memodifikasi beberapa item, Anda harus menggunakan beberapa operasi.
------
#### [ DynamoDB API ]
Dengan DynamoDB API, Anda menggunakan operasi `UpdateItem` untuk memodifikasi satu item.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ExpressionAttributeValues: {
":label": "Global Records"
}
}
```
Anda harus menentukan atribut `Key` item yang akan dimodifikasi dan `UpdateExpression` untuk menentukan nilai atribut. `UpdateItem` berperilaku seperti operasi “upsert”. Item diperbarui jika ada di tabel, tetapi jika tidak, item baru ditambahkan (disisipkan).
`UpdateItem` mendukung *tulis bersyarat*, di mana operasi hanya berhasil jika `ConditionExpression` tertentu bernilai true. Misalnya, operasi `UpdateItem` berikut tidak melakukan pembaruan kecuali jika harga lagu lebih besar dari atau sama dengan 2,00.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ConditionExpression: "Price >= :p",
ExpressionAttributeValues: {
":label": "Global Records",
":p": 2.00
}
}
```
`UpdateItem` juga mendukung *penghitung atom*, atau atribut jenis `Number` yang dapat ditambahkan atau dikurangi. Penghitung atom serupa dalam banyak hal dengan generator urutan, kolom identitas, atau bidang penambahan otomatis dalam basis data SQL.
Berikut ini adalah contoh operasi `UpdateItem` untuk menginisialisasi atribut baru (*Play*) untuk melacak berapa kali lagu telah diputar.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = :val",
ExpressionAttributeValues: {
":val": 0
},
ReturnValues: "UPDATED_NEW"
}
```
Parameter `ReturnValues` diatur ke `UPDATED_NEW`, yang mengembalikan nilai-nilai baru dari setiap atribut yang diperbarui. Dalam hal ini, parameter mengembalikan 0 (nol).
Setiap kali seseorang memutar lagu ini, kita dapat menggunakan operasi `UpdateItem` berikut untuk menambahkan *Play* sebanyak satu.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = Plays + :incr",
ExpressionAttributeValues: {
":incr": 1
},
ReturnValues: "UPDATED_NEW"
}
```
------
#### [ PartiQL for DynamoDB ]
Dengan PartiQL, Anda menggunakan operasi `ExecuteStatement` untuk memodifikasi item pada tabel, menggunakan pernyataan `Update` PartiQL.
Kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*. Anda harus menentukan nilai untuk atribut ini.
```
UPDATE Music
SET RecordLabel ='Global Records'
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Anda juga dapat memodifikasi beberapa bidang sekaligus, seperti pada contoh berikut.
```
UPDATE Music
SET RecordLabel = 'Global Records'
SET AwardsWon = 10
WHERE Artist ='No One You Know' AND SongTitle='Call Me Today'
```
`Update` juga mendukung *penghitung atom*, atau atribut jenis `Number` yang dapat ditambahkan atau dikurangi. Penghitung atom serupa dalam banyak hal dengan generator urutan, kolom identitas, atau bidang penambahan otomatis dalam basis data SQL.
Berikut ini adalah contoh pernyataan `Update` untuk menginisialisasi atribut baru (*Play*) untuk melacak berapa kali lagu telah diputar.
```
UPDATE Music
SET Plays = 0
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Setiap kali seseorang memutar lagu ini, kita dapat menggunakan pernyataan `Update` berikut untuk menambahkan *Play* sebanyak satu.
```
UPDATE Music
SET Plays = Plays + 1
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
**catatan**
Untuk contoh kode menggunakan `Update` dan `ExecuteStatement`, lihat [Pernyataan pembaruan PartiQL untuk DynamoDB](ql-reference.update.md).
------
# Perbedaan antara database relasional (SQL) dan DynamoDB saat menghapus data dari tabel
Di SQL, pernyataan `DELETE` menghapus satu baris atau lebih dari tabel. Amazon DynamoDB menggunakan operasi `DeleteItem` untuk menghapus satu item pada satu waktu.
**Topics**
+ [Menghapus data dari tabel dengan SQL](#SQLtoNoSQL.DeleteData.SQL)
+ [Menghapus data dari tabel di DynamoDB](#SQLtoNoSQL.DeleteData.DynamoDB)
## Menghapus data dari tabel dengan SQL
Dalam SQL, Anda menggunakan pernyataan `DELETE` untuk menghapus satu baris atau lebih. Klausa `WHERE` menentukan baris yang ingin Anda modifikasi. Berikut adalah contohnya.
```
DELETE FROM Music
WHERE Artist = 'The Acme Band' AND SongTitle = 'Look Out, World';
```
Anda dapat memodifikasi klausul `WHERE` untuk menghapus beberapa baris. Misalnya, Anda dapat menghapus semua lagu dari artis tertentu, seperti yang ditunjukkan dalam contoh berikut.
```
DELETE FROM Music WHERE Artist = 'The Acme Band'
```
## Menghapus data dari tabel di DynamoDB
Di DynamoDB, Anda dapat menggunakan DynamoDB API [atau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) PartiQL (bahasa kueri yang kompatibel dengan SQL) untuk menghapus satu item. Jika Anda ingin memodifikasi beberapa item, Anda harus menggunakan beberapa operasi.
------
#### [ DynamoDB API ]
Dengan DynamoDB API, Anda menggunakan operasi `DeleteItem` untuk menghapus data dari tabel, satu item pada satu waktu. Anda harus menentukan nilai kunci primer item.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
}
}
```
**catatan**
Selain itu`DeleteItem`, Amazon DynamoDB mendukung operasi `BatchWriteItem` untuk menghapus beberapa item pada saat yang sama.
`DeleteItem` mendukung *tulis bersyarat*, di mana operasi hanya berhasil jika `ConditionExpression` tertentu bernilai true. Misalnya, `DeleteItem` operasi berikut menghapus item hanya jika memiliki *RecordLabel*atribut.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
},
ConditionExpression: "attribute_exists(RecordLabel)"
}
```
------
#### [ PartiQL for DynamoDB ]
Dengan PartiQL, Anda menggunakan pernyataan `Delete` melalui operasi `ExecuteStatement` untuk menghapus data dari tabel, satu item pada satu waktu. Anda harus menentukan nilai kunci primer item.
Kunci utama untuk tabel ini terdiri dari *Artis* dan *SongTitle*. Anda harus menentukan nilai untuk atribut ini.
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'
```
Anda juga dapat menentukan kondisi tambahan untuk operasi. Operasi `DELETE` berikut hanya menghapus item jika memiliki lebih dari 11 *Penghargaan*.
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' AND Awards > 11
```
**catatan**
Untuk contoh kode menggunakan `DELETE` dan `ExecuteStatement`, lihat [Pernyataan hapus PartiQL untuk DynamoDB](ql-reference.delete.md).
------
# Perbedaan antara database relasional (SQL) dan DynamoDB saat menghapus tabel
Dalam SQL, Anda menggunakan pernyataan `DROP TABLE` untuk menghapus tabel. Di Amazon DynamoDB, Anda menggunakan operasi `DeleteTable`.
**Topics**
+ [Menghapus tabel dengan SQL](#SQLtoNoSQL.RemoveTable.SQL)
+ [Menghapus tabel di DynamoDB](#SQLtoNoSQL.RemoveTable.DynamoDB)
## Menghapus tabel dengan SQL
Ketika Anda tidak lagi membutuhkan tabel dan ingin membuangnya secara permanen, Anda akan menggunakan `DROP TABLE` pernyataan dalam SQL.
```
DROP TABLE Music;
```
Setelah tabel dilepaskan, tabel tidak dapat dipulihkan. (Beberapa basis data relasional memungkinkan Anda untuk membatalkan operasi `DROP TABLE`, tetapi ini adalah fungsionalitas khusus vendor dan tidak diterapkan secara luas.)
## Menghapus tabel di DynamoDB
Pada DynamoDB, `DeleteTable` adalah operasi yang serupa. Pada contoh berikut, tabel dihapus secara permanen.
```
{
TableName: "Music"
}
```