Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Amazon DynamoDB: Cara kerjanya
Bagian berikut memberikan gambaran umum tentang komponen layanan Amazon DynamoDB dan bagaimana mereka berinteraksi.
**Topics**
+ [Kisi-kisi untuk DynamoDB](CheatSheet.md)
+ [Komponen inti dari Amazon DynamoDB](HowItWorks.CoreComponents.md)
+ [DynamoDB API](HowItWorks.API.md)
+ [Jenis data dan aturan penamaan yang didukung di Amazon DynamoDB](HowItWorks.NamingRulesDataTypes.md)
+ [Kelas tabel DynamoDB](HowItWorks.TableClasses.md)
+ [Partisi dan distribusi data di DynamoDB](HowItWorks.Partitions.md)
+ [Pelajari cara beralih dari SQL ke NoSQL](SQLtoNoSQL.md)
+ [Sumber daya dan alat pembelajaran Amazon DynamoDB](AdditionalResources.md)
# Kisi-kisi untuk DynamoDB
Lembar contekan ini memberikan referensi cepat untuk bekerja dengan Amazon DynamoDB dan berbagai nya. AWS SDKs
## Pengaturan awal
1. [Mendaftar untuk AWS](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.SignUpForAWS).
1. [Dapatkan kunci akses AWS](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.GetCredentials) untuk mengakses DynamoDB secara terprogram.
1. [Konfigurasikan kredenal DynamoDB](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.ConfigureCredentials) Anda.
**Lihat juga:**
+ [Menyiapkan DynamoDB (layanan web)](SettingUp.DynamoWebService.html)
+ [Mulai menggunakan DynamoDB](GettingStartedDynamoDB.html)
+ [Gambaran umum dasar komponen inti](HowItWorks.CoreComponents.html)
## SDK atau CLI
Pilih [SDK](sdk-general-information-section.html) pilihan Anda, atau atur [AWS CLI](/cli/latest/index.html).
**catatan**
Saat Anda menggunakan AWS CLI on Windows, garis miring terbalik (\$1) yang tidak ada di dalam kutipan diperlakukan sebagai carriage return. Selain itu, Anda harus menghilangkan tanda kutip dan kurung kurawal apa pun di dalam tanda kutip lainnya. Sebagai contoh, lihat tab **Windows** di “Buat tabel” di bagian berikutnya.
**Lihat juga:**
+ [AWS CLI dengan DynamoDB](Tools.CLI.html)
+ [Mulai menggunakan DynamoDB - langkah 2](getting-started-step-2.html)
## Tindakan dasar
Bagian ini menyediakan kode untuk tugas DynamoDB dasar. Untuk informasi selengkapnya tentang tugas ini, lihat [Memulai DynamoDB dan file](GettingStarted.html). AWS SDKs
### Membuat tabel
------
#### [ Default ]
```
aws dynamodb create-table \
--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--billing-mode PAY_PER_REQUEST \
--table-class STANDARD
```
------
#### [ Windows ]
```
aws dynamodb create-table ^
--table-name Music ^
--attribute-definitions ^
AttributeName=Artist,AttributeType=S ^
AttributeName=SongTitle,AttributeType=S ^
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE ^
--billing-mode PAY_PER_REQUEST ^
--table-class STANDARD
```
------
### Tulis item ke tabel
```
aws dynamodb put-item \ --table-name Music \ --item file://item.json
```
### Baca item dari tabel
```
aws dynamodb get-item \ --table-name Music \ --item file://item.json
```
### Hapus item dari tabel
```
aws dynamodb delete-item --table-name Music --key file://key.json
```
### Mengkueri Tabel
```
aws dynamodb query --table-name Music
--key-condition-expression "ArtistName=:Artist and SongName=:Songtitle"
```
### Menghapus tabel
```
aws dynamodb delete-table --table-name Music
```
### Daftar nama tabel
```
aws dynamodb list-tables
```
## Peraturan penamaan
+ Semua nama harus dikodekan menggunakan UTF-8 dan peka huruf besar-kecil.
+ Nama tabel dan nama indeks panjangnya harus antara 3 hingga 255 karakter, dan hanya dapat berisi karakter berikut:
+ `a-z`
+ `A-Z`
+ `0-9`
+ `_`(garis bawah)
+ `-`(tanda hubung)
+ `.`(titik)
+ Nama atribut harus memiliki panjang minimal satu karakter dan berukuran kurang dari 64 KB.
Untuk informasi selengkapnya, lihat [Aturan penamaan](HowItWorks.NamingRulesDataTypes.html).
## Dasar-dasar kuota layanan
**Membaca dan menulis unit**
+ **Unit kapasitas baca (RCU)** – Satu pembacaan sangat konsisten per detik, atau dua pembacaan akhirnya konsisten per detik, untuk item berukuran hingga 4 KB.
+ **Unit kapasitas tulis (WCU)** – Satu tulis per detik, untuk item berukuran hingga 1 KB.
**Batasan tabel**
+ **Ukuran tabel** — Tidak ada batas praktis pada ukuran tabel. Tabel tidak dibatasi dalam jumlah item atau jumlah byte.
+ **Jumlah tabel** — Untuk AWS akun apa pun, ada kuota awal 2.500 tabel per AWS Wilayah.
+ **Batas ukuran halaman untuk kueri dan pemindaian** – Ada batas 1 MB per halaman, per kueri atau pemindaian. Jika parameter kueri atau operasi pemindaian Anda pada tabel menghasilkan lebih dari 1 MB data, DynamoDB mengembalikan item awal yang cocok. Ini juga mengembalikan properti `LastEvaluatedKey` yang dapat Anda gunakan dalam permintaan baru untuk membaca halaman berikutnya.
**Indeks**
+ **Indeks sekunder lokal (LSIs)** - Anda dapat menentukan maksimum lima indeks sekunder lokal. LSIs terutama berguna ketika indeks harus memiliki konsistensi yang kuat dengan tabel dasar.
+ **Indeks sekunder global (GSIs)** — Ada kuota default 20 indeks sekunder global per tabel.
+ **Atribut indeks sekunder yang diproyeksikan per tabel** – Anda dapat memproyeksikan total hingga 100 atribut ke semua indeks lokal tabel dan sekunder global. Ini hanya berlaku untuk atribut proyeksi yang ditentukan pengguna.
**Kunci partisi**
+ Panjang minimum nilai kunci partisi adalah 1 byte. Panjang maksimum adalah 2048 byte.
+ Tidak ada batasan praktis untuk jumlah nilai kunci partisi yang berbeda, untuk tabel atau indeks sekunder.
+ Panjang minimum nilai kunci urutan adalah 1 byte. Panjang maksimum adalah 1024 byte.
+ Secara umum, tidak ada batas praktis pada jumlah nilai kunci urutan berbeda per nilai kunci partisi. Pengecualian ini adalah untuk tabel dengan indeks sekunder.
Untuk informasi selengkapnya tentang indeks sekunder, desain kunci partisi, dan desain kunci urutan, lihat [Praktik terbaik](best-practices.html).
**Batas untuk jenis data yang umum digunakan**
+ **String** – Panjang string dibatasi oleh ukuran item maksimum 400 KB. String adalah Unicode dengan pengodean biner UTF-8.
+ **Angka** – Angka dapat memiliki hingga 38 digit presisi, dan dapat positif, negatif, atau nol.
+ **Binary** – Panjang biner dibatasi oleh ukuran item maksimum 400 KB. Aplikasi yang bekerja dengan atribut binari harus mengodekan data dalam pengodean base64 sebelum mengirimnya ke DynamoDB.
Untuk daftar jenis daya yang didukung, lihat [Jenis data](HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). Untuk informasi selengkapnya, lihat [Kuota layanan](ServiceQuotas.html#limits-items).
### Item, atribut, dan parameter ekspresi
Ukuran item maksimum di DynamoDB adalah 400 KB, yang mencakup panjang biner nama atribut (UTF-8 panjang) dan panjang biner nilai atribut (UTF-8 panjang). Nama atribut dihitung terhadap batas ukuran.
Tidak ada batas pada jumlah nilai dalam daftar, peta, atau set, selama item yang berisi nilai-nilai cocok dalam batas ukuran item 400-KB.
Untuk parameter ekspresi, panjang maksimum string ekspresi adalah 4 KB.
Untuk informasi selengkapnya tentang ukuran item, atribut, dan parameter ekspresi, lihat [Kuota layanan](ServiceQuotas.html#limits-items).
## Informasi lain
+ [Keamanan](security.html)
+ [Pencatatan dan pemantauan](monitoring.html)
+ [Bekerja dengan stream](streamsmain.html)
+ [Cadangan](Backup-and-Restore.html) [dan pemulihan Point-in-time ](Point-in-time-recovery.html)
+ [Integrasi dengan layanan lain AWS](OtherServices.html)
+ [Referensi API](/amazondynamodb/latest/APIReference/Welcome.html)
+ [Pusat Arsitektur: Praktik Terbaik Basis Data](https://aws.amazon.com/architecture/databases/)
+ [Tutorial video](https://youtu.be/Mw8wCj0gkRc)
+ [Forum DynamoDB](https://repost.aws/search/questions?globalSearch=dynamodb)
# Komponen inti dari Amazon DynamoDB
Dalam DynamoDB, tabel, item, dan atribut adalah komponen inti yang Anda kerjakan. Sebuah *tabel* adalah koleksi *item*, dan setiap item adalah koleksi *atribut*. DynamoDB menggunakan kunci utama untuk mengidentifikasi secara unik setiap item dalam tabel. Anda dapat menggunakan DynamoDB Streams untuk menangkap peristiwa modifikasi data dalam tabel DynamoDB.
Ada batas dalam DynamoDB. Untuk informasi selengkapnya, lihat [Kuota di Amazon DynamoDB](ServiceQuotas.md).
Video berikut ini akan memberi Anda tampilan pengantar tabel, item, dan atribut.
[Tabel, item, dan atribut](https://www.youtube.com/embed/Mw8wCj0gkRc)
## Tabel, item, dan atribut
![\[Setiap tabel DynamoDB berisi nol atau lebih item yang terbuat dari satu atau lebih atribut.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/HowItWorksTables-2024.png)
Berikut ini adalah komponen DynamoDB dasar:
+ **Tabel** – Mirip dengan sistem basis data lainnya, DynamoDB menyimpan data dalam tabel. Sebuah *tabel* adalah koleksi data. Misalnya, lihat tabel contoh yang disebut *Orang* yang dapat Anda gunakan untuk menyimpan informasi kontak pribadi tentang teman, keluarga, atau orang lain yang menarik. Anda juga dapat memiliki tabel *Mobil* untuk menyimpan informasi tentang kendaraan yang dikendarai orang.
+ **Item** — Setiap tabel berisi nol item atau lebih. Sebuah *item* adalah sekelompok atribut yang dapat diidentifikasi secara unik di antara semua item lainnya. Dalam tabel *Orang*, setiap item mewakili satu orang. Untuk tabel *Mobil*, setiap item mewakili satu kendaraan. Item dalam DynamoDB serupa dalam banyak hal dengan baris, catatan, atau tupel dalam sistem basis data lain. Dalam DynamoDB, tidak ada batasan jumlah item yang dapat Anda simpan dalam tabel.
+ **Atribut** — Setiap item terdiri dari satu atau beberapa atribut. Sebuah *atribut* adalah elemen data fundamental, sesuatu yang tidak perlu dipecah lebih jauh. Misalnya, item dalam tabel *People* berisi atribut yang disebut *personId*,, *LastName*FirstName**, dan sebagainya. Untuk tabel *Departemen*, item mungkin memiliki atribut seperti *DepartmentID*, *Name*, *Manager*, dan sebagainya. Atribut di DynamoDB serupa dalam banyak hal dengan bidang atau kolom dalam sistem basis data lain.
Diagram berikut menunjukkan tabel bernama *Orang* dengan beberapa item dan atribut contoh.
```
People
{
"PersonID": 101,
"LastName": "Smith",
"FirstName": "Fred",
"Phone": "555-4321"
}
{
"PersonID": 102,
"LastName": "Jones",
"FirstName": "Mary",
"Address": {
"Street": "123 Main",
"City": "Anytown",
"State": "OH",
"ZIPCode": 12345
}
}
{
"PersonID": 103,
"LastName": "Stephens",
"FirstName": "Howard",
"Address": {
"Street": "123 Main",
"City": "London",
"PostalCode": "ER3 5K8"
},
"FavoriteColor": "Blue"
}
```
Perhatikan hal berikut tentang tabel *Orang*:
+ Setiap item dalam tabel memiliki pengidentifikasi unik, atau kunci primer, yang membedakan item dari semua hal lain dalam tabel. Dalam tabel *Orang*, kunci primer terdiri dari satu atribut (*PersonID*).
+ Selain kunci primer, tabel *Orang* tidak berskema, yang berarti bahwa baik atribut maupun jenis datanya perlu didefinisikan terlebih dahulu. Setiap item dapat memiliki atribut tersendiri.
+ Sebagian besar atribut *skalar*, yang berarti bahwa mereka hanya dapat memiliki satu nilai. String dan angka adalah contoh umum dari skalar.
+ Beberapa item memiliki atribut bersarang (*Alamat*). DynamoDB mendukung atribut bersarang hingga sedalam 32 tingkat.
Berikut ini adalah tabel contoh lain bernama *Musik* yang dapat Anda gunakan untuk melacak koleksi musik Anda.
```
Music
{
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle": "Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
{
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle": "Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
{
"Artist": "The Acme Band",
"SongTitle": "Still in Love",
"AlbumTitle": "The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying": [
"KHCR",
"KQBX",
"WTNR",
"WJJH"
],
"TourDates": {
"Seattle": "20150622",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
{
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle": "The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
```
Perhatikan hal berikut tentang tabel *Musik*:
+ Kunci utama untuk *Musik* terdiri dari dua atribut (*Artis* dan *SongTitle*). Setiap item dalam tabel harus memiliki dua atribut ini. Kombinasi *Artis* dan *SongTitle*membedakan setiap item dalam tabel dari yang lainnya.
+ Selain kunci primer, tabel *Musik* tidak berskema, yang berarti bahwa baik atribut maupun jenis datanya perlu didefinisikan terlebih dahulu. Setiap item dapat memiliki atribut tersendiri.
+ Salah satu item memiliki atribut bersarang (*PromotionInfo*), yang berisi atribut bersarang lainnya. DynamoDB mendukung atribut bersarang hingga sedalam 32 tingkat.
Untuk informasi selengkapnya, lihat [Bekerja dengan tabel dan data di DynamoDB](WorkingWithTables.md).
## Kunci primer
Ketika Anda membuat tabel, selain nama tabel, Anda harus menentukan kunci primer dari tabel. Kunci utama secara unik mengidentifikasi setiap item dalam tabel, sehingga tidak ada dua item dapat memiliki kunci yang sama.
DynamoDB mendukung dua jenis kunci primer:
+ **Kunci partisi** — Sebuah kunci primer sederhana, terdiri dari satu atribut yang dikenal sebagai *kunci partisi*.
DynamoDB menggunakan nilai kunci partisi sebagai masukan untuk fungsi hash internal. Output dari fungsi hash menentukan partisi (penyimpanan fisik internal pada DynamoDB) di mana item akan disimpan.
Dalam tabel yang hanya memiliki kunci partisi, tidak ada dua item dapat memiliki nilai kunci partisi yang sama.
Tabel *Orang* yang dijelaskan dalam [Tabel, item, dan atribut](#HowItWorks.CoreComponents.TablesItemsAttributes) adalah contoh dari sebuah tabel dengan kunci primer sederhana (*PersonID*). Anda dapat mengakses item apa pun di tabel *Orang* secara langsung dengan memberikan *PersonId*nilai untuk item tersebut.
+ **Kunci partisi dan kunci urutan** – Disebut sebagai *kunci primer komposit*, jenis kunci ini terdiri dari dua atribut. Atribut pertama adalah *kunci partisi*, dan atribut kedua adalah *kunci urutan*.
DynamoDB menggunakan nilai kunci partisi sebagai input untuk fungsi hash internal. Output dari fungsi hash menentukan partisi (penyimpanan fisik internal pada DynamoDB) di mana item akan disimpan. Semua item dengan nilai kunci partisi yang sama disimpan bersama-sama, dalam urutan yang diurutkan berdasarkan nilai kunci urutan.
Dalam tabel yang memiliki kunci partisi dan kunci urutan, mungkin bagi beberapa item memiliki nilai kunci partisi yang sama. Namun, item tersebut harus memiliki nilai kunci urutan yang berbeda.
Tabel *Musik* yang dijelaskan dalam [Tabel, item, dan atribut](#HowItWorks.CoreComponents.TablesItemsAttributes) adalah contoh tabel dengan kunci primer komposit (*Artis* dan *SongTitle*). Anda dapat mengakses item apa pun di tabel *Musik* secara langsung, jika Anda memberikan *Artis* dan *SongTitle*nilai untuk item tersebut.
Kunci primer komposit memberi Anda fleksibilitas tambahan saat mengkueri data. Misalnya, jika Anda hanya memberikan nilai untuk *Artist*, DynamoDB mengambil semua lagu oleh penyanyi tersebut. Untuk mengambil hanya subset lagu oleh artis tertentu, Anda dapat memberikan nilai untuk *Artis* bersama dengan berbagai nilai untuk. *SongTitle*
**catatan**
Kunci partisi dari item juga dikenal sebagai *atribut hash*. Istilah *atribut hash* berasal dari penggunaan fungsi hash internal di DynamoDB yang mendistribusikan item data secara merata di seluruh partisi, berdasarkan nilai kunci partisi mereka.
Kunci urutan item juga dikenal sebagai *atribut rentang*. Istilah *atribut rentang* berasal dari cara DynamoDB menyimpan item dengan kunci partisi yang sama yang secara fisik berdekatan, dalam urutan berdasarkan nilai kunci urutan.
Setiap atribut kunci primer harus skalar (yang berarti bahwa atribut itu hanya dapat menyimpan nilai tunggal). Satu-satunya jenis data yang diperbolehkan untuk atribut kunci primer adalah string, nomor, atau biner. Tidak ada batasan seperti itu untuk atribut non-kunci lainnya.
## Indeks sekunder
Anda dapat membuat satu atau beberapa indeks sekunder pada tabel. *Indeks sekunder* memungkinkan Anda mengkueri data dalam tabel menggunakan kunci alternatif, selain kueri terhadap kunci primer. DynamoDB tidak mengharuskan Anda menggunakan indeks, tetapi mereka memberikan aplikasi Anda fleksibilitas lebih ketika mengkueri pada data Anda. Setelah Anda membuat indeks sekunder pada tabel, Anda bisa membaca data dari indeks dengan cara yang sama seperti yang Anda lakukan dari tabel.
DynamoDB mendukung dua jenis indeks:
+ Indeks sekunder global – Indeks dengan kunci partisi dan kunci urutan yang mungkin berbeda dari yang ada di tabel. Nilai kunci primer dalam indeks sekunder global tidak perlu unik.
+ Indeks sekunder lokal – Indeks yang memiliki kunci partisi yang sama dengan tabel, namun kunci urutan berbeda.
Di DynamoDB, indeks sekunder global GSIs () adalah indeks yang menjangkau seluruh tabel, memungkinkan Anda untuk melakukan kueri di semua kunci partisi. Indeks sekunder lokal (LSIs) adalah indeks yang memiliki kunci partisi yang sama dengan tabel dasar tetapi kunci pengurutan yang berbeda.
Setiap tabel di DynamoDB memiliki kuota 20 indeks sekunder global (kuota default) dan 5 indeks sekunder lokal.
Dalam contoh tabel *Musik* yang ditampilkan sebelumnya, Anda dapat meminta item data berdasarkan *Artis* (kunci partisi) atau oleh *Artis* dan *SongTitle*(kunci partisi dan kunci sortir). Bagaimana jika Anda juga ingin menanyakan data berdasarkan *Genre* dan *AlbumTitle*? Untuk melakukan ini, Anda dapat membuat indeks pada *Genre* dan *AlbumTitle*, lalu menanyakan indeks dengan cara yang sama seperti Anda menanyakan tabel *Musik*.
Diagram berikut menunjukkan contoh tabel *Musik*, dengan indeks baru yang disebut *GenreAlbumTitle*. Dalam indeks, *Genre* adalah kunci partisi dan *AlbumTitle*merupakan kunci sortir.
| Tabel Musik | *GenreAlbumTitle* |
| --- | --- |
|
{
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle": "Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
|
{
"Genre": "Country",
"AlbumTitle": "Hey Now",
"Artist": "No One You Know",
"SongTitle": "My Dog Spot"
}
|
|
{
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle": "Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
|
{
"Genre": "Country",
"AlbumTitle": "Somewhat Famous",
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road"
}
|
|
{
"Artist": "The Acme Band",
"SongTitle": "Still in Love",
"AlbumTitle": "The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying": {
"KHCR",
"KQBX",
"WTNR",
"WJJH"
},
"TourDates": {
"Seattle": "20150622",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
|
{
"Genre": "Rock",
"AlbumTitle": "The Buck Starts Here",
"Artist": "The Acme Band",
"SongTitle": "Still In Love"
}
|
|
{
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle": "The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
|
{
"Genre": "Rock",
"AlbumTitle": "The Buck Starts Here",
"Artist": "The Acme Band",
"SongTitle": "Look Out, World"
}
|
Perhatikan hal berikut tentang *GenreAlbumTitle*indeks:
+ Setiap indeks adalah milik sebuah tabel, yang disebut *tabel dasar* untuk indeks. Dalam contoh sebelumnya, *Musik* adalah tabel dasar untuk indeks. *GenreAlbumTitle*
+ DynamoDB mengelola indeks secara otomatis. Saat Anda menambahkan, memperbarui, atau menghapus item di tabel dasar, DynamoDB menambahkan, memperbarui, atau menghapus item terkait di indeks mana pun yang termasuk dalam tabel tersebut.
+ Saat Anda membuat indeks, Anda menentukan atribut mana yang akan disalin, atau *diproyeksikan*, dari tabel dasar ke indeks. Minimal, DynamoDB memproyeksikan atribut kunci dari tabel dasar ke indeks. Hal ini terjadi pada `GenreAlbumTitle`, dimana hanya atribut kunci dari tabel yang `Music` diproyeksikan ke dalam indeks.
Anda dapat menanyakan *GenreAlbumTitle*indeks untuk menemukan semua album dari genre tertentu (misalnya, semua album *Rock*). Anda juga dapat menanyakan indeks untuk menemukan semua album dalam genre tertentu yang memiliki judul album tertentu (misalnya, semua album *Country* dengan judul yang dimulai dengan huruf H).
Untuk informasi selengkapnya, lihat [Meningkatkan akses data dengan indeks sekunder di DynamoDB](SecondaryIndexes.md).
## DynamoDB Streams
DynamoDB Streams adalah fitur opsional yang menangkap peristiwa modifikasi data dalam tabel DynamoDB. Data tentang peristiwa ini muncul di aliran hampir dalam waktu nyata, dan sesuai urutan terjadinya peristiwa tersebut.
Setiap acara diwakili oleh *catatan aliran*. Jika Anda mengaktifkan aliran pada tabel, DynamoDB Streams menulis catatan aliran setiap kali salah satu peristiwa berikut terjadi:
+ Item baru ditambahkan ke tabel: Aliran mengambil gambar keseluruhan item, termasuk semua atributnya.
+ Item diperbarui: Aliran menangkap gambar "sebelum" dan "sesudah" dari setiap atribut yang diubah dalam item.
+ Item dihapus dari tabel: Aliran mengambil gambar keseluruhan item sebelum dihapus.
Setiap rekaman aliran juga berisi nama tabel, stempel waktu peristiwa, dan metadata lainnya. Rekaman streaming memiliki masa pakai 24 jam; setelah itu, mereka secara otomatis dihapus dari aliran.
Anda dapat menggunakan DynamoDB Streams AWS Lambda bersama-sama untuk membuat pemicu —kode *yang* berjalan secara otomatis setiap kali peristiwa yang diinginkan muncul dalam aliran. Misalnya, pertimbangkan tabel *Pelanggan* yang berisi informasi pelanggan untuk sebuah perusahaan. Misalkan Anda ingin mengirim email "selamat datang" ke setiap pelanggan baru. Anda dapat mengaktifkan aliran pada tabel itu, dan kemudian mengaitkan aliran tersebut dengan fungsi Lambda. Fungsi Lambda akan berjalan setiap kali rekaman aliran baru muncul, namun hanya memproses item baru yang ditambahkan ke tabel *Pelanggan*. Untuk item apa pun yang memiliki atribut `EmailAddress`, fungsi Lambda akan memanggil Amazon Simple Email Service (Amazon SES) untuk mengirim email ke alamat tersebut.
![\[Integrasi DynamoDB Streams dan Lambda untuk secara otomatis mengirim email selamat datang ke pelanggan baru.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/HowItWorksStreams.png)
**catatan**
Dalam contoh ini, pelanggan terakhir, Craig Roe, tidak akan menerima email karena dia tidak memiliki `EmailAddress`.
Selain pemicu, DynamoDB Streams memungkinkan solusi canggih seperti replikasi data di dalam dan AWS di seluruh Wilayah, tampilan data yang terwujud dalam tabel DynamoDB, analisis data menggunakan tampilan terwujud Kinesis, dan banyak lagi.
Untuk informasi selengkapnya, lihat [Tangkapan data perubahan DynamoDB Streams](Streams.md).
# DynamoDB API
Untuk bekerja dengan Amazon DynamoDB, aplikasi Anda harus menggunakan beberapa operasi API sederhana. Berikut ini adalah ringkasan operasi-operasi ini, yang disusun berdasarkan kategori.
**catatan**
Untuk daftar lengkap operasi API, lihat [Referensi API Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/Welcome.html).
**Topics**
+ [Bidang kontrol](#HowItWorks.API.ControlPlane)
+ [Bidang data](#HowItWorks.API.DataPlane)
+ [DynamoDB Streams](#HowItWorks.API.Streams)
+ [Transaksi](#HowItWorks.API.Transactions)
## Bidang kontrol
Operasi *bidang kontrol* memungkinkan Anda membuat dan mengelola tabel DynamoDB. Operasi ini juga memungkinkan Anda bekerja dengan indeks, aliran, dan objek lain yang tergantung pada tabel.
+ `CreateTable` — Membuat tabel baru. Selain itu, Anda dapat membuat satu atau beberapa indeks sekunder, dan mengaktifkan DynamoDB Streams untuk tabel.
+ `DescribeTable` — Mengembalikan informasi tentang tabel, seperti skema kunci primer, pengaturan throughput, dan informasi indeks.
+ `ListTables` — Mengembalikan nama semua tabel Anda dalam daftar.
+ `UpdateTable` — Memodifikasi pengaturan tabel atau indeks, menciptakan atau menghapus indeks baru pada tabel, atau memodifikasi pengaturan DynamoDB Streams untuk tabel.
+ `DeleteTable` — Menghapus meja dan semua objek yang bergantung dari DynamoDB.
## Bidang data
Operasi *bidang data* memungkinkan Anda membuat, membaca, memperbarui, dan menghapus tindakan (juga disebut *CRUD*) pada data dalam tabel. Beberapa operasi bidang data juga memungkinkan Anda membaca data dari indeks sekunder.
Anda dapat menggunakan[PartiQL - Bahasa kueri yang kompatibel dengan SQL untuk Amazon DynamoDB](ql-reference.md), untuk melakukan operasi CRUD ini atau Anda dapat menggunakan CRUD klasik DynamoDB APIs yang memisahkan setiap operasi menjadi panggilan API yang berbeda.
### PartiQL - Bahasa kueri yang kompatibel dengan SQL
+ `ExecuteStatement` – Membaca beberapa item dari tabel. Anda juga dapat menulis atau memperbarui satu item dari tabel. Saat menulis atau memperbarui satu item, Anda harus menentukan atribut kunci primer.
+ `BatchExecuteStatement` – Menulis, memperbarui, atau membaca beberapa item dari tabel. Ini lebih efisien dari `ExecuteStatement` karena aplikasi Anda hanya memerlukan satu jaringan bolak-balik untuk menulis atau membaca item.
### Klasik APIs
#### Membuat data
+ `PutItem` – Menulis satu item pada tabel. Anda harus menentukan atribut kunci primer, tetapi Anda tidak perlu menentukan atribut lainnya.
+ `BatchWriteItem` – Menulis hingga 25 item pada tabel. Ini lebih efisien dari menjalankan `PutItem` beberapa kali karena aplikasi Anda hanya memerlukan satu jaringan bolak-balik untuk menulis item.
#### Membaca data
+ `GetItem` – Mengambil satu item dari tabel. Anda harus menentukan kunci primer untuk item yang Anda inginkan. Anda dapat mengambil seluruh item, atau hanya sebagian dari atributnya.
+ `BatchGetItem` – Mengambil hingga 100 item dari satu atau beberapa tabel. Ini lebih efisien dari menjalankan `GetItem` beberapa kali karena aplikasi Anda hanya memerlukan satu jaringan bolak-balik untuk membaca item.
+ `Query` – Mengambil semua item yang memiliki kunci partisi tertentu. Anda harus menentukan nilai kunci partisi. Anda dapat mengambil seluruh item, atau hanya sebagian dari atributnya. Secara opsional, Anda dapat menerapkan ketentuan pada nilai kunci urutan sehingga Anda hanya mengambil subkumpulan data yang memiliki kunci partisi yang sama. Anda dapat menggunakan operasi ini pada tabel, asalkan tabel tersebut memiliki kunci partisi dan kunci urutan. Anda juga dapat menggunakan operasi ini pada indeks, asalkan indeks tersebut memiliki kunci partisi dan kunci urutan.
+ `Scan` – Mengambil semua item dalam tabel atau indeks yang ditentukan. Anda dapat mengambil seluruh item, atau hanya sebagian dari atributnya. Secara opsional, Anda dapat menerapkan kondisi pemfilteran untuk hanya mengembalikan nilai yang Anda minati dan membuang sisanya.
#### Memperbarui data
+ `UpdateItem` — Memodifikasi satu atau beberapa atribut dalam item. Memodifikasi satu atau lebih atribut dalam suatu item. Anda harus menentukan kunci primer untuk item yang ingin Anda ubah. Anda dapat menambahkan atribut baru dan mengubah atau menghapus atribut yang sudah ada. Anda juga dapat melakukan pembaruan bersyarat, sehingga pembaruan hanya berhasil bila kondisi yang ditentukan pengguna terpenuhi. Secara opsional, Anda dapat menerapkan penghitung atom, yang menambah atau mengurangi atribut numerik tanpa mengganggu permintaan tulis lainnya.
#### Menghapus data
+ `DeleteItem` – Menghapus satu item dari tabel. Anda harus menentukan kunci primer untuk item yang ingin Anda hapus.
+ `BatchWriteItem` – Menghapus hingga 25 item dari satu atau beberapa tabel. Ini lebih efisien dari menjalankan `DeleteItem` beberapa kali karena aplikasi Anda hanya memerlukan satu jaringan bolak-balik untuk menghapus item.
**catatan**
Anda dapat menggunakan `BatchWriteItem` untuk membuat data dan menghapus data.
## DynamoDB Streams
Operasi *DynamoDB Streams* memungkinkan Anda mengaktifkan atau menonaktifkan stream pada tabel, dan memungkinkan akses ke catatan modifikasi data yang terkandung dalam aliran.
+ `ListStreams` – Menampilkan daftar semua stream Anda, atau hanya stream untuk tabel tertentu.
+ `DescribeStream` – Menampilkan informasi tentang stream, seperti Amazon Resource Name (ARN) dan di mana aplikasi Anda dapat mulai membaca beberapa catatan stream pertama.
+ `GetShardIterator` – Menampilkan *iterator serpihan*, yang merupakan struktur data yang menggunakan aplikasi Anda untuk mengambil catatan dari stream.
+ `GetRecords` – Mengambil satu atau lebih catatan stream, menggunakan iterator serpihan yang diberikan.
## Transaksi
*Transaksi* memberikan atomisitas, konsistensi, isolasi, dan daya tahan (ACID) yang memungkinkan Anda menjaga kebenaran data dalam aplikasi Anda dengan lebih mudah.
Anda dapat menggunakan[PartiQL - Bahasa kueri yang kompatibel dengan SQL untuk Amazon DynamoDB](ql-reference.md), untuk melakukan operasi transaksional atau Anda dapat menggunakan CRUD klasik DynamoDB APIs yang memisahkan setiap operasi menjadi panggilan API yang berbeda.
### PartiQL - Bahasa kueri yang kompatibel dengan SQL
+ `ExecuteTransaction`— Operasi batch yang memungkinkan operasi CRUD ke beberapa item baik di dalam maupun di seluruh tabel dengan all-or-nothing hasil yang dijamin.
### Klasik APIs
+ `TransactWriteItems`— Operasi batch yang memungkinkan`Put`,`Update`, dan `Delete` operasi ke beberapa item baik di dalam maupun di seluruh tabel dengan all-or-nothing hasil yang dijamin.
+ `TransactGetItems` – Sebuah operasi batch yang memungkinkan operasi `Get` untuk mengambil beberapa item dari satu atau beberapa tabel.
# Jenis data dan aturan penamaan yang didukung di Amazon DynamoDB
Bagian ini menjelaskan aturan penamaan Amazon DynamoDB dan berbagai jenis daya yang didukung DynamoDB. Ada batasan yang berlaku untuk jenis daya. Untuk informasi selengkapnya, lihat [Jenis Data](Constraints.md#limits-data-types).
**Topics**
+ [Peraturan penamaan](#HowItWorks.NamingRules)
+ [Jenis Data](#HowItWorks.DataTypes)
+ [Deskriptor jenis daya](#HowItWorks.DataTypeDescriptors)
## Peraturan penamaan
Tabel, atribut, dan objek lain di DynamoDB harus memiliki nama. Nama harus bermakna dan ringkas-misalnya, nama-nama seperti *Produk*, *Buku*, dan *Penulis* sudah cukup jelas.
Berikut ini adalah aturan penamaan untuk DynamoDB:
+ Semua nama harus dikodekan menggunakan UTF-8, dan peka huruf kapital.
+ Nama tabel dan nama indeks panjangnya harus antara 3 hingga 255 karakter, dan hanya dapat berisi karakter berikut:
+ `a-z`
+ `A-Z `
+ ` 0-9 `
+ `_` (garis bawah)
+ `-` (dasbor)
+ `.` (titik)
+ Nama atribut harus memiliki panjang minimal satu karakter dan berukuran kurang dari 64 KB. Hal ini dianggap sebagai praktik terbaik untuk menjaga nama atribut Anda sesingkat mungkin. Hal ini membantu mengurangi penggunaan unit permintaan baca, karena nama atribut disertakan dalam pengukuran penyimpanan dan penggunaan throughput.
Berikut ini adalah pengecualiannya. Panjang nama atribut berikut tidak boleh lebih dari 255 karakter:
+ Nama kunci partisi indeks sekunder
+ Nama kunci urutan indeks sekunder
+ Nama atribut proyeksi yang ditentukan pengguna (hanya berlaku untuk indeks sekunder lokal)
### Kata-kata khusus dan karakter khusus
DynamoDB memiliki daftar kata-kata khusus dan karakter khusus. Untuk daftar lengkap, lihat [Kata-kata penggunaan khusus di DynamoDB](ReservedWords.md). Selain itu, karakter berikut memiliki arti khusus dalam DynamoDB: **\$1** (hash) dan **:**(titik dua).
Meskipun DynamoDB mengizinkan Anda menggunakan kata-kata khusus dan karakter khusus ini untuk nama, kami menyarankan agar Anda menghindari melakukannya karena Anda harus menentukan variabel placeholder setiap kali Anda menggunakan nama-nama ini dalam sebuah ekspresi. Untuk informasi selengkapnya, lihat [Nama atribut ekspresi (alias) di DynamoDB](Expressions.ExpressionAttributeNames.md).
## Jenis Data
DynamoDB mendukung banyak jenis data berbeda untuk atribut dalam tabel. Hal tersebut dapat dikategorikan sebagai berikut:
+ **Jenis Skalar** - Jenis skalar dapat mewakili tepat satu nilai. Jenis skalar adalah angka, string, biner, Boolean, dan null.
+ **Jenis Dokumen** — Jenis dokumen dapat mewakili struktur kompleks dengan atribut bertingkat, seperti yang Anda temukan di dokumen JSON. Jenis dokumen adalah daftar dan peta.
+ **Jenis Set** - Jenis set dapat mewakili beberapa nilai skalar. Jenis set adalah set string, set angka, dan set biner.
Saat Anda membuat tabel atau indeks sekunder, Anda harus menentukan nama dan jenis data dari setiap atribut kunci primer (kunci partisi dan kunci urutan). Selanjutnya, setiap atribut kunci primer harus didefinisikan sebagai jenis string, angka, atau biner.
DynamoDB adalah basis data NoSQL dan *tidak berskema*. Artinya, selain atribut kunci primer, Anda tidak perlu mendefinisikan atribut atau jenis data apa pun saat membuat tabel. Sebagai perbandingan, basis data relasional mengharuskan Anda menentukan nama dan jenis data setiap kolom saat Anda membuat tabel.
Berikut penjelasan masing-masing jenis data beserta contohnya dalam format JSON.
### Jenis skalar
Jenis skalar adalah angka, string, biner, Boolean, dan null.
#### Angka
Angka bisa positif, negatif, atau nol. Angka dapat memiliki hingga 38 digit presisi. Melebihi hasil ini dalam pengecualian. Jika Anda membutuhkan presisi lebih dari 38 digit, Anda dapat menggunakan string.
+ Kisaran positif: 1E-130 hingga 9,9999999999999999999999999999999999999E\$1125
+ Kisaran negatif: -9,9999999999999999999999999999999999999E\$1125 hingga -1E-130
Di DynamoDB, angka direpresentasikan sebagai panjang variabel. Angka nol di depan dan di belakang dipangkas.
Semua angka dikirim melalui jaringan untuk DynamoDB sebagai string, untuk memaksimalkan kompatibilitas di seluruh bahasa dan pustaka. Namun, DynamoDB memperlakukannya sebagai atribut jenis angka untuk operasi matematika.
Anda dapat menggunakan jenis data angka untuk mewakili tanggal atau stempel waktu. Salah satu cara untuk melakukannya adalah dengan menggunakan epoch time—jumlah detik sejak 00:00:00 UTC pada tanggal 1 Januari 1970. Sebagai contoh, jangka waktu `1437136300` mewakili 12:31:40 PM UTC pada tanggal 17 Juli 2015.
Untuk informasi lebih lanjut, lihat [http://en.wikipedia. org/wiki/Unix\$1waktu](http://en.wikipedia.org/wiki/Unix_time).
#### String
String adalah Unicode dengan pengodean biner UTF-8. Panjang minimum string bisa nol, jika atribut tidak digunakan sebagai kunci untuk indeks atau tabel, dan dibatasi oleh batas ukuran item DynamoDB maksimum sebesar 400 KB.
Batasan tambahan berikut berlaku untuk atribut kunci primer yang didefinisikan sebagai jenis string:
+ Untuk kunci primer sederhana, panjang maksimum nilai atribut pertama (kunci partisi) adalah 2048 byte.
+ Untuk kunci primer komposit, panjang maksimum nilai atribut kedua (kunci urutan) adalah 1024 byte.
DynamoDB menyusun dan membandingkan string menggunakan byte pengodean string UTF-8 yang mendasarinya. Misalnya, "`a`" (0x61) lebih besar dari "`A`" (0x41), dan "`¿`" (0xC2BF) lebih besar dari "`z`" (0x7A).
Anda dapat menggunakan jenis data string untuk mewakili tanggal atau stempel waktu. Salah satu cara untuk melakukannya adalah dengan menggunakan string ISO 8601, seperti yang ditunjukkan dalam contoh berikut:
+ `2016-02-15`
+ `2015-12-21T17:42:34Z`
+ `20150311T122706Z`
Untuk informasi lebih lanjut, lihat [http://en.wikipedia. org/wiki/ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601).
**catatan**
Tidak seperti basis data relasional konvensional, DynamoDB tidak mendukung jenis daya tanggal dan waktu. Akan lebih berguna jika menyimpan data tanggal dan waktu sebagai jenis data angka, menggunakan jangka waktu Unix.
#### Biner
Atribut jenis biner dapat menyimpan data biner apa pun, seperti teks terkompresi, data terenkripsi, atau gambar. Setiap kali DynamoDB membandingkan nilai biner, DynamoDB memperlakukan setiap byte data biner sebagai tidak terdaftar.
Panjang atribut binari bisa nol, jika atribut tersebut tidak digunakan sebagai kunci untuk indeks atau tabel, dan dibatasi oleh batas ukuran item DynamoDB maksimum sebesar 400 KB.
Jika Anda mendefinisikan atribut kunci primer sebagai atribut jenis biner, batasan tambahan berikut akan berlaku:
+ Untuk kunci primer sederhana, panjang maksimum nilai atribut pertama (kunci partisi) adalah 2048 byte.
+ Untuk kunci primer komposit, panjang maksimum nilai atribut kedua (kunci urutan) adalah 1024 byte.
Aplikasi Anda harus mengodekan nilai biner dalam format yang dikodekan base64 sebelum mengirimkannya ke DynamoDB. Setelah menerima nilai-nilai ini, DynamoDB mendekodekan data ke dalam array byte yang tidak ditandatangani dan menggunakannya sebagai panjang atribut binari.
Contoh berikut adalah atribut binari, menggunakan teks berkode base64.
```
dGhpcyB0ZXh0IGlzIGJhc2U2NC1lbmNvZGVk
```
#### Boolean
Atribut jenis Boolean dapat menyimpan salah satu `true` atau `false`.
#### Null
Null melambangkan atribut dengan status tidak diketahui atau tidak ditentukan.
### Jenis dokumen
Jenis dokumen adalah daftar dan peta. Jenis data ini dapat disarangkan satu sama lain, untuk mewakili struktur data kompleks hingga sedalam 32.
Tidak ada batasan jumlah nilai dalam daftar atau peta, selama item yang berisi nilai tersebut sesuai dengan batas ukuran item DynamoDB (400 KB).
Nilai atribut dapat berupa string kosong atau nilai biner kosong jika atribut tersebut tidak digunakan untuk tabel atau kunci indeks. Nilai atribut tidak boleh berupa set kosong (set string, set angka, atau set biner), namun daftar dan peta kosong diperbolehkan. String kosong dan nilai biner diperbolehkan dalam daftar dan peta. Untuk informasi selengkapnya, lihat [Atribut](Constraints.md#limits-attributes).
#### Daftar
Atribut jenis daftar dapat menyimpan kumpulan nilai yang diurutkan. Daftar diapit tanda kurung siku: `[ ... ]`
Daftar mirip dengan array JSON. Tidak ada batasan pada jenis daya yang dapat disimpan dalam elemen daftar, dan elemen dalam elemen daftar tidak harus berjenis sama.
Contoh berikut memperlihatkan daftar yang berisi dua string dan sebuah angka.
```
FavoriteThings: ["Cookies", "Coffee", 3.14159]
```
**catatan**
DynamoDB memungkinkan Anda bekerja dengan elemen individual dalam daftar, meskipun elemen tersebut sangat bersarang. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md).
#### Peta
Atribut jenis peta dapat menyimpan kumpulan pasangan nama-nilai yang tidak berurutan. Peta diapit kurung kurawal: `{ ... }`
Peta serupa dengan objek JSON. Tidak ada batasan pada jenis data yang dapat disimpan dalam elemen peta, dan elemen dalam peta tidak harus berjenis sama.
Peta ideal untuk menyimpan dokumen JSON di DynamoDB. Contoh berikut memperlihatkan peta yang berisi string, angka, dan daftar bertumpuk yang berisi peta lain.
```
{
Day: "Monday",
UnreadEmails: 42,
ItemsOnMyDesk: [
"Coffee Cup",
"Telephone",
{
Pens: { Quantity : 3},
Pencils: { Quantity : 2},
Erasers: { Quantity : 1}
}
]
}
```
**catatan**
DynamoDB memungkinkan Anda bekerja dengan elemen individual dalam peta, meskipun elemen tersebut sangat bersarang. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md).
### Set
DynamoDB mendukung jenis yang mewakili set angka, string, atau nilai-nilai biner. Semua elemen di dalam set harus dari jenis yang sama. Misalnya, Set Angka hanya dapat berisi angka dan Set String hanya dapat berisi string.
Tidak ada batasan jumlah nilai dalam set, selama item yang berisi nilai tersebut sesuai dengan batas ukuran item DynamoDB (400 KB).
Setiap nilai dalam suatu set harus unik. Urutan nilai dalam suatu set tidak dipertahankan. Oleh karena itu, aplikasi Anda tidak boleh bergantung pada urutan elemen tertentu dalam set tersebut. DynamoDB tidak mendukung set kosong, namun string kosong dan nilai biner diperbolehkan dalam satu set.
Contoh berikut menunjukkan set string, set angka, dan set biner:
```
["Black", "Green", "Red"]
[42.2, -19, 7.5, 3.14]
["U3Vubnk=", "UmFpbnk=", "U25vd3k="]
```
## Deskriptor jenis daya
Protokol API DynamoDB tingkat rendah menggunakan *Deskriptor jenis data* sebagai token yang memberi tahu DynamoDB cara menafsirkan setiap atribut.
Berikut ini adalah daftar lengkap deskriptor jenis data DynamoDB:
+ **`S`** – String
+ **`N`** – Nomor
+ **`B`** – Biner
+ **`BOOL`** – Boolean
+ **`NULL`** – Null
+ **`M`** – Peta
+ **`L`** – Daftar
+ **`SS`** – Set String
+ **`NS`** – Set Nomor
+ **`BS`** – Set Biner
# Kelas tabel DynamoDB
DynamoDB menawarkan dua kelas tabel yang dirancang untuk membantu Anda mengoptimalkan biaya. Kelas tabel Standar DynamoDB adalah defaultnya, dan direkomendasikan untuk sebagian besar beban kerja. Kelas tabel DynamoDB Standard-Infrequent Access (DynamoDB Standard-IA) dioptimalkan untuk tabel yang biayanya didominasi oleh penyimpanan. Misalnya, tabel yang menyimpan data yang jarang diakses, seperti log aplikasi, postingan media sosial lama, riwayat pesanan e-niaga, dan pencapaian game sebelumnya, merupakan kandidat yang baik untuk kelas tabel Standard-IA. Lihat [Harga Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/on-demand/) untuk mendapatkan detail harga.
Setiap tabel DynamoDB dikaitkan dengan kelas tabel (DynamoDB Standard secara default). Semua indeks sekunder yang terkait dengan tabel menggunakan kelas tabel yang sama. Setiap kelas tabel menawarkan harga berbeda untuk penyimpanan data serta permintaan baca dan tulis. Anda dapat memilih kelas tabel yang paling hemat biaya untuk tabel Anda berdasarkan pola penggunaan penyimpanan dan throughputnya.
Pilihan kelas tabel tidak permanen—Anda dapat mengubah pengaturan ini menggunakan, Konsol Manajemen AWS AWS CLI, atau SDK. AWS DynamoDB juga mendukung pengelolaan kelas tabel Anda AWS CloudFormation menggunakan tabel Single-region dan tabel global. Untuk mempelajari selengkapnya tentang memilih kelas tabel Anda, lihat [Pertimbangan saat memilih kelas tabel di DynamoDB](WorkingWithTables.tableclasses.md).
# Partisi dan distribusi data di DynamoDB
Amazon DynamoDB menyimpan data dalam partisi. *Partisi* adalah alokasi penyimpanan untuk tabel, didukung oleh solid state drive (SSDs) dan secara otomatis direplikasi di beberapa Availability Zone dalam suatu AWS Region. Manajemen partisi ditangani sepenuhnya oleh DynamoDB—Anda tidak perlu mengelola partisi sendiri.
Saat Anda membuat tabel, status awal tabel tersebut adalah `CREATING`. Selama fase ini, DynamoDB mengalokasikan partisi yang memadai ke tabel sehingga dapat menangani persyaratan throughput yang Anda sediakan. Anda dapat mulai menulis dan membaca data tabel setelah status tabel berubah menjadi `ACTIVE`.
DynamoDB mengalokasikan partisi tambahan ke tabel dalam situasi berikut:
+ Jika Anda meningkatkan pengaturan throughput tabel yang tersedia melebihi apa yang dapat didukung oleh partisi yang ada.
+ Jika partisi yang ada memenuhi kapasitas dan diperlukan lebih banyak ruang penyimpanan.
Manajemen partisi terjadi secara otomatis di latar belakang dan transparan bagi aplikasi Anda. Tabel Anda tetap tersedia dan sepenuhnya mendukung persyaratan throughput yang Anda sediakan.
Untuk rincian selengkapnya, lihat [Desain kunci partisi](bp-partition-key-design.md).
Indeks sekunder global di DynamoDB juga terdiri dari partisi. Data dalam indeks sekunder global disimpan secara terpisah dari data dalam tabel dasarnya, namun partisi indeks berperilaku sama seperti partisi tabel.
## Distribusi data: Kunci partisi
Jika tabel Anda memiliki kunci primer sederhana (hanya kunci partisi), DynamoDB menyimpan dan mengambil setiap item berdasarkan nilai kunci partisinya.
Untuk menulis item ke tabel, DynamoDB menggunakan nilai kunci partisi sebagai input ke fungsi hash internal. Nilai keluaran dari fungsi hash menentukan partisi tempat item akan disimpan.
Untuk membaca item dari tabel, Anda harus menentukan nilai kunci partisi untuk item tersebut. DynamoDB menggunakan nilai ini sebagai masukan ke fungsi hashnya, menghasilkan partisi tempat item dapat ditemukan.
Diagram berikut menunjukkan tabel bernama *Pets*, yang mencakup beberapa partisi. Kunci utama tabel adalah *AnimalType*(hanya atribut kunci ini yang ditampilkan). DynamoDB menggunakan fungsi hashnya untuk menentukan tempat menyimpan item baru, dalam hal ini berdasarkan nilai hash string *Dog*. Perhatikan bahwa item tidak disimpan dalam urutan yang diurutkan. Lokasi setiap item ditentukan oleh nilai hash kunci partisinya.
![\[Distribusi item tabel DynamoDB di seluruh partisi berdasarkan nilai hash kunci partisi.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKey.png)
**catatan**
DynamoDB dioptimalkan untuk distribusi item yang seragam di seluruh partisi tabel, tidak peduli berapa banyak partisi yang ada. Kami menyarankan Anda memilih kunci partisi yang dapat memiliki sejumlah besar nilai berbeda yang berhubungan dengan jumlah item dalam tabel.
## Distribusi data: Kunci partisi dan kunci urutan
Jika tabel memiliki kunci primer gabungan (kunci partisi dan kunci urutan), DynamoDB menghitung nilai hash kunci partisi dengan cara yang sama seperti yang dijelaskan dalam[Distribusi data: Kunci partisi](#HowItWorks.Partitions.SimpleKey). Namun, ia cenderung menjaga item yang memiliki nilai kunci partisi yang sama berdekatan dan diurutkan berdasarkan nilai atribut kunci sortir. Kumpulan item yang memiliki nilai kunci partisi yang sama disebut koleksi item. Koleksi item dioptimalkan untuk pengambilan rentang item yang efisien dalam koleksi. Jika tabel Anda tidak memiliki indeks sekunder lokal, DynamoDB akan secara otomatis membagi koleksi item Anda menjadi partisi sebanyak yang diperlukan untuk menyimpan data dan menyajikan throughput baca dan tulis.
Untuk menulis item ke tabel, DynamoDB menghitung nilai hash kunci partisi untuk menentukan partisi mana yang harus berisi item tersebut. Di partisi itu, beberapa item mungkin memiliki nilai kunci partisi yang sama. Jadi DynamoDB menyimpan item tersebut di antara item lainnya dengan kunci partisi yang sama, dalam urutan menaik berdasarkan kunci urutan.
Untuk membaca item dari tabel, Anda harus menentukan nilai kunci partisi dan nilai kunci urutan. DynamoDB menghitung nilai hash kunci partisi, menghasilkan partisi tempat item dapat ditemukan.
Anda dapat membaca beberapa item dari tabel dalam satu operasi (`Query`) jika item yang Anda inginkan memiliki nilai kunci partisi yang sama. DynamoDB mengembalikan semua item dengan nilai kunci partisi tersebut. Secara opsional, Anda dapat menerapkan ketentuan pada kunci urutan sehingga hanya mengembalikan item dalam rentang nilai tertentu.
Misalkan tabel *Pets* memiliki kunci primer komposit yang terdiri dari *AnimalType*(kunci partisi) dan *Nama* (kunci sortir). Diagram berikut menunjukkan DynamoDB menulis item dengan nilai kunci partisi *Dog* dan nilai kunci urutan *Fido*.
![\[DynamoDB menyimpan item dengan kunci partisi komposit dan mengurutkan item menggunakan nilai atribut kunci sortir.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKeySortKey.png)
Untuk membaca item yang sama dari tabel *Pets*, DynamoDB menghitung nilai hash dari *Dog*, menghasilkan partisi tempat item tersebut disimpan. DynamoDB kemudian memindai nilai atribut kunci urutan hingga menemukan *Fido*.
Untuk membaca semua item dengan *Dog*, Anda dapat mengeluarkan `Query` operasi tanpa menentukan kondisi kunci pengurutan. *AnimalType* Secara default, item dikembalikan dalam urutan penyimpanannya (yaitu, dalam urutan naik oleh kunci urutan). Atau, Anda dapat meminta urutan menurun.
Untuk mengkueri hanya beberapa item *Dog*, Anda dapat menerapkan syarat untuk kunci urutan (misalnya, hanya item *Dog* di mana *Name* dimulai dengan huruf yang berada dalam rentang `A` hingga `K`).
**catatan**
Dalam tabel DynamoDB, tidak ada batasan atas jumlah nilai kunci urutan yang berbeda per nilai kunci partisi. Jika Anda perlu untuk menyimpan jutaan item *Dog* di tabel *Pets*, DynamoDB akan mengalokasikan cukup penyimpanan untuk menangani persyaratan ini secara otomatis.
# 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"
}
```
# Sumber daya dan alat pembelajaran Amazon DynamoDB
Anda dapat menggunakan sumber daya tambahan berikut untuk memahami dan menggunakan DynamoDB.
**Topics**
+ [Alat untuk pengodean dan visualisasi](#AdditionalResources.Tools)
+ [Artikel Panduan Preskriptif](#AdditionalResources.PrescriptiveGuidance)
+ [Artikel Pusat Pengetahuan](#AdditionalResources.KnowledgeCenter)
+ [Posting blog, repositori, dan panduan](#AdditionalResources.Guides)
+ [Pemodelan data dan presentasi pola desain](#AdditionalResources.DataModeling)
+ [Kursus pelatihan](#AdditionalResources.Training)
## Alat untuk pengodean dan visualisasi
Anda dapat menggunakan alat pengodean dan visualisasi berikut ketika menggunakan DynamoDB:
+ [NoSQL Workbench untuk Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) — Alat visual terpadu yang membantu Anda merancang, membuat, mengirim kueri, dan mengelola tabel DynamoDB. Alat ini menyediakan fitur pemodelan data, visualisasi data, dan pengembangan kueri.
+ [Dynobase](https://dynobase.dev/) – Alat desktop yang memudahkan Anda melihat tabel DynamoDB Anda dan menggunakannya, membuat kode aplikasi, dan mengedit catatan dengan validasi waktu nyata.
+ [DynamoDB](https://github.com/jeremydaly/dynamodb-toolbox) Toolbox — Sebuah proyek dari Jeremy Daly yang menyediakan utilitas yang berguna untuk bekerja dengan pemodelan data dan dan Node.js. JavaScript
+ [DynamoDB Streams Processor](https://github.com/jeremydaly/dynamodb-streams-processor) – Alat sederhana yang dapat Anda gunakan untuk bekerja dengan [aliran DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html).
## Artikel Panduan Preskriptif
AWS Panduan Preskriptif menyediakan strategi, panduan, dan pola yang telah teruji waktu untuk membantu mempercepat proyek Anda. Sumber daya ini dikembangkan oleh para ahli AWS teknologi dan komunitas global AWS Mitra, berdasarkan pengalaman bertahun-tahun mereka membantu pelanggan mencapai tujuan bisnis mereka.
**Pemodelan dan migrasi data**
+ [Model data hierarkis di DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-hierarchical-data-model/introduction.html)
+ [Pemodelan data dengan DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/welcome.html)
+ [Migrasi database Oracle ke DynamoDB menggunakan AWS DMS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)
**Tabel global**
+ [Menggunakan tabel global Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-global-tables/introduction.html)
**Nirserver**
+ [Menerapkan pola saga tanpa server dengan AWS Step Functions](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/implement-the-serverless-saga-pattern-by-using-aws-step-functions.html)
**Arsitektur SaaS**
+ [Mengelola penghuni di beberapa produk SaaS pada satu bidang kontrol](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/manage-tenants-across-multiple-saas-products-on-a-single-control-plane.html)
+ [Orientasi penghuni dalam arsitektur SaaS untuk model silo menggunakan C\$1 dan AWS CDK](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)
**Perlindungan data dan pergerakan data**
+ [Mengonfigurasikan akses lintas akun ke Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)
+ [Opsi salinan tabel lengkap untuk DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-full-table-copy-options/)
+ [Strategi pemulihan bencana untuk basis data di AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/)
**Lain-lain**
+ [Membantu menegakkan penandaan di DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/help-enforce-dynamodb-tagging.html)
**Video panduan preskriptif**
+ [Menggunakan Arsitektur Nirserver untuk Membuat Alur Data](https://youtu.be/JiWHomdh1oI?)
+ [Novartis - Buying Engine: Portal Pengadaan Berkemampuan AI](https://youtu.be/vp8oPiHN4cA)
+ [Veritiv: Aktifkan Wawasan untuk Memprediksi Permintaan Penjualan di Data Lakes AWS](https://youtu.be/jg85DzUZ9Ac)
+ [Mimik: Hybrid Edge Cloud Memanfaatkan untuk AWS Mendukung Edge Microservice Mesh](https://youtu.be/-S-R7MWRpaI)
+ [Tangkapan data perubahan dengan Amazon DynamoDB](https://youtu.be/6YVjzD-70p4)
Artikel dan video Panduan Preskriptif lainnya untuk DynamoDB bisa dilihat di [Panduan Preskriptif](https://tiny.amazon.com/fiui3cog/ForinternaldemoofnewpageExternalURLwillbeneededforlive).
## Artikel Pusat Pengetahuan
Artikel dan video Pusat AWS Pengetahuan mencakup pertanyaan dan permintaan yang paling sering kami terima dari AWS pelanggan. Berikut ini adalah beberapa artikel Pusat Pengetahuan saat ini tentang tugas-tugas tertentu yang berhubungan dengan DynamoDB:
**Optimasi biaya**
+ [Bagaimana cara mengoptimalkan biaya dengan Amazon DynamoDB?](https://repost.aws/knowledge-center/dynamodb-optimize-costs)
**Throttling dan latensi**
+ [Bagaimana saya bisa memecahkan masalah latensi tinggi pada tabel Amazon DynamoDB?](https://repost.aws/knowledge-center/dynamodb-high-latency)
+ [Mengapa tabel DynamoDB saya dikenakan throttling?](https://repost.aws/knowledge-center/dynamodb-table-throttled)
+ [Mengapa tabel DynamoDB sesuai permintaan saya dikenakan throttling?](https://repost.aws/knowledge-center/on-demand-table-throttling-dynamodb)
**Paginasi**
+ [Bagaimana cara menerapkan paginasi di DynamoDB](https://repost.aws/knowledge-center/dynamodb-implement-pagination)
**Transaksi**
+ [Mengapa panggilan API `TransactWriteItems` saya gagal di DynamoDB](https://repost.aws/knowledge-center/dynamodb-transactwriteitems)
**Pemecahan Masalah**
[]()
+ [Bagaimana cara mengatasi masalah penskalaan otomatis DynamoDB?](https://repost.aws/knowledge-center/dynamodb-auto-scaling)
+ [Bagaimana cara memecahkan masalah kesalahan HTTP 4XX di DynamoDB](https://repost.aws/knowledge-center/usererrors-dynamodb-table)
Artikel dan video lainnya untuk DynamoDB bisa dilihat di [artikel Pusat Pengetahuan](https://repost.aws/search/knowledge-center?globalSearch=dynamodb).
## Posting blog, repositori, dan panduan
Selain [Panduan Developer DynamoDB](Introduction.md), ada banyak sumber daya yang berguna terkait bekerja dengan DynamoDB. Berikut adalah beberapa posting blog, repositori, dan panduan pilihan untuk bekerja dengan DynamoDB:
+ AWS [https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/dotnet](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/dotnet)
+ Buku [DynamoDB — Panduan komprehensif [dari DeBrie](https://twitter.com/alexbdebrie) Alex yang mengajarkan pendekatan berbasis strategi untuk pemodelan data dengan DynamoDB](https://www.dynamodbbook.com/).
+ Panduan [DynamoDB](https://www.dynamodbguide.com/) — Panduan terbuka [dari DeBrie](https://twitter.com/alexbdebrie) Alex yang berjalan melalui konsep dasar dan fitur-fitur canggih dari database DynamoDB NoSQL.
+ [How to switch from RDBMS to DynamoDB in 20 easy steps](https://www.jeremydaly.com/how-to-switch-from-rdbms-to-dynamodb-in-20-easy-steps/) – Daftar langkah-langkah yang berguna untuk mempelajari pemodelan data dari [Jeremy Daly](https://twitter.com/jeremy_daly).
+ Lembar [contekan JavaScript DocumentClient DynamoDB](https://github.com/dabit3/dynamodb-documentclient-cheat-sheet) - Lembar contekan untuk membantu Anda mulai membangun aplikasi dengan DynamoDB di Node.js atau lingkungan. JavaScript
+ [DynamoDB Core Concept Videos](https://www.youtube.com/playlist?list=PLJo-rJlep0EDNtcDeHDMqsXJcuKMcrC5F) – Daftar putar ini membahas banyak konsep inti DynamoDB.
## Pemodelan data dan presentasi pola desain
Anda dapat menggunakan sumber daya berikut tentang pemodelan data dan pola desain untuk membantu Anda mendapatkan hasil maksimal dari DynamoDB:
+ [AWS Re:invent 2019: Pemodelan data dengan DynamoDB](https://www.youtube.com/watch?v=DIQVJqiSUkE)
+ Pembicaraan oleh [Alex DeBrie](https://twitter.com/alexbdebrie) yang membantu Anda memulai dengan prinsip-prinsip pemodelan data DynamoDB.
+ [AWS RE: Invent 2020: Pemodelan data dengan DynamoDB - Bagian 1](https://www.youtube.com/watch?v=fiP2e-g-r4g)
+ [AWS RE: Invent 2020: Pemodelan data dengan DynamoDB - Bagian 2](https://www.youtube.com/watch?v=0uLF1tjI_BI)
+ [AWS re: invent 2017: pola desain canggih](https://www.youtube.com/watch?v=jzeKPKpucS0)
+ [AWS re: invent 2018: pola desain canggih](https://www.youtube.com/watch?v=HaEPXoXVf2k)
+ [AWS Re: invent 2019: Pola desain lanjutan](https://www.youtube.com/watch?v=6yqfmXiZTlM)
+ Jeremy Daly membagikan [12 poin penting](https://www.jeremydaly.com/takeaways-from-dynamodb-deep-dive-advanced-design-patterns-dat403/) lewat sesi ini.
+ [AWS re:Invent 2020: DynamoDB advanced design patterns – Part 1](https://www.youtube.com/watch?v=MF9a1UNOAQo&index=1)
+ [AWS RE: invent 2020: pola desain lanjutan DynamoDB - Bagian 2](https://www.youtube.com/watch?v=_KNrRdWD25M&index=2)
+ [DynamoDB Office Hours di Twitch](https://amazondynamodbofficehrs.splashthat.com/)
**catatan**
Setiap sesi membahas contoh dan kasus penggunaan yang berbeda.
## Kursus pelatihan
Ada banyak opsi kursus pelatihan dan edukasi yang berbeda untuk mempelajari DynamoDB lebih lanjut. Berikut ini contoh yang terbaru:
+ [Berkembang dengan Amazon DynamoDB](https://www.aws.training/Details/Curriculum?id=65583) - Dirancang AWS oleh untuk membawa Anda dari pemula hingga ahli dalam mengembangkan aplikasi dunia nyata dengan pemodelan data untuk Amazon DynamoDB.
+ [DynamoDB deep dive](https://www.pluralsight.com/courses/aws-dynamodb-deep-dive-2019) course — Kursus dari Pluralsight.
+ [Amazon DynamoDB: Membangun aplikasi berbasis database NoSQL — Kursus dari tim Pelatihan dan Sertifikasi yang diselenggarakan di edX](https://www.edx.org/course/amazon-dynamodb-building-nosql-database-driven-app). AWS