Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Bekerja dengan item dan atribut di DynamoDB
Di Amazon DynamoDB, *item* adalah koleksi atribut. Setiap atribut mempunyai nama dan nilai. Nilai atribut dapat berupa skalar, himpunan, atau jenis dokumen. Untuk informasi selengkapnya, lihat [Amazon DynamoDB: Cara kerjanya](HowItWorks.md).
DynamoDB menyediakan empat operasi untuk fungsionalitas dasar buat, baca, perbarui, dan hapus (CRUD). Semua operasi ini bersifat atom.
+ `PutItem` — Membuat item.
+ `GetItem` — Membaca item.
+ `UpdateItem` — Memperbarui item.
+ `DeleteItem` — Menghapus item.
Setiap operasi ini mengharuskan Anda menentukan kunci primer item yang ingin Anda gunakan. Misalnya, untuk membaca item menggunakan `GetItem`, Anda harus menentukan kunci partisi dan kunci urutan (jika ada) untuk item tersebut.
Selain empat operasi CRUD dasar, DynamoDB juga menyediakan hal berikut ini:
+ `BatchGetItem` — Membaca hingga 100 item dari satu tabel atau lebih.
+ `BatchWriteItem` — Membuat atau menghapus hingga 25 item dalam satu atau beberapa tabel.
Operasi batch ini menggabungkan beberapa operasi CRUD ke dalam satu permintaan. Selain itu, operasi batch membaca dan menulis item secara paralel untuk meminimalkan latensi respons.
Bagian ini menjelaskan cara menggunakan operasi ini dan mencakup topik terkait, seperti pembaruan bersyarat dan penghitung atom. Bagian ini juga mencakup contoh kode yang menggunakan file AWS SDKs.
**Topics**
+ [Ukuran dan format item DynamoDB](CapacityUnitCalculations.md)
+ [Membaca item](#WorkingWithItems.ReadingData)
+ [Menulis item](#WorkingWithItems.WritingData)
+ [Nilai yang dikembalikan](#WorkingWithItems.ReturnValues)
+ [Operasi batch](#WorkingWithItems.BatchOperations)
+ [Penghitung atom](#WorkingWithItems.AtomicCounters)
+ [Penulisan bersyarat](#WorkingWithItems.ConditionalUpdate)
+ [Menggunakan ekspresi di DynamoDB](Expressions.md)
+ [Menggunakan time to live (TTL) di DynamoDB](TTL.md)
+ [Menanyakan tabel di DynamoDB](Query.md)
+ [Memindai tabel di DynamoDB](Scan.md)
+ [PartiQL - Bahasa kueri yang kompatibel dengan SQL untuk Amazon DynamoDB](ql-reference.md)
+ [Bekerja dengan item: Java](JavaDocumentAPIItemCRUD.md)
+ [Bekerja dengan item: .NET](LowLevelDotNetItemCRUD.md)
# Ukuran dan format item DynamoDB
Tabel DynamoDB tidak memiliki skema, kecuali kunci primer, sehingga semua item dalam tabel dapat memiliki atribut, ukuran, dan jenis data yang berbeda.
Ukuran total suatu item adalah jumlah panjang nama dan nilai atributnya, ditambah overhead yang berlaku seperti dijelaskan di bawah. Anda dapat menggunakan panduan berikut untuk memperkirakan ukuran atribut:
+ String adalah Unicode dengan pengodean biner UTF-8. Ukuran string adalah *(jumlah byte UTF-8 yang dikodekan dari nama atribut) \$1 (jumlah byte yang dikodekan UTF-8)*.
+ Angka memiliki panjang yang bervariasi, hingga 38 angka penting. Angka nol di depan dan di belakang dipangkas. Ukuran angka kira-kira *(jumlah byte yang dikodekan UTF-8 dari nama atribut) \$1 (1 byte per dua digit signifikan) \$1 (1 byte*).
+ Nilai biner harus dikodekan dalam format base64 sebelum dapat dikirim ke DynamoDB, namun panjang byte mentah nilai tersebut digunakan untuk menghitung ukuran. Ukuran atribut biner adalah *(jumlah byte UTF-8 yang dikodekan dari nama atribut) \$1 (jumlah byte mentah)*.
+ Ukuran atribut null atau atribut Boolean adalah *(jumlah byte UTF-8 yang dikodekan dari nama atribut) \$1 (1 byte*).
+ Atribut jenis `List` atau `Map` memerlukan overhead 3 byte, apa pun kontennya. Ukuran a `List` or `Map` is *(jumlah byte UTF-8 yang dikodekan dari nama atribut) \$1 jumlah (ukuran elemen bersarang) \$1 (3 byte*). Ukuran kosong `List` atau `Map` is *(jumlah byte UTF-8 yang dikodekan dari nama atribut) \$1 (3 byte)*.
+ Masing-masing elemen `List` atau `Map` juga membutuhkan 1 byte overhead.
**catatan**
Sebaiknya Anda memilih nama atribut yang lebih pendek. Ini membantu Anda mengurangi jumlah penyimpanan yang dibutuhkan, tetapi juga dapat menurunkan jumlah yang RCU/WCUs Anda gunakan.
Untuk tujuan penagihan penyimpanan, setiap item mencakup overhead penyimpanan per item yang bergantung pada fitur yang telah Anda aktifkan.
+ Semua item di DynamoDB memerlukan overhead penyimpanan sebesar 100 byte untuk pengindeksan.
+ Beberapa fitur DynamoDB (tabel global, transaksi, perubahan pengambilan data untuk Kinesis Data Streams dengan DynamoDB) memerlukan overhead penyimpanan tambahan untuk memperhitungkan atribut yang dibuat sistem akibat pengaktifan fitur tersebut. Misalnya, tabel global memerlukan tambahan overhead penyimpanan sebesar 48 byte.
## Membaca item
Untuk membaca item dari tabel DynamoDB, gunakan operasi `GetItem`. Anda harus memberikan nama tabel, beserta kunci primer item yang Anda inginkan.
**Example**
AWS CLI Contoh berikut menunjukkan cara membaca item dari `ProductCatalog` tabel.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}'
```
**catatan**
Dengan `GetItem`, Anda harus menentukan *seluruh* kunci primer, bukan hanya sebagian darinya. Misalnya, jika tabel memiliki kunci primer gabungan (kunci partisi dan kunci urutan), Anda harus menyediakan nilai untuk kunci partisi dan nilai untuk kunci urutan.
Pada akhirnya, permintaan `GetItem` melakukan pembacaan konsisten secara default. Sebagai gantinya, Anda dapat menggunakan parameter `ConsistentRead` untuk meminta bacaan sangat konsisten. (Ini mengkonsumsi unit kapasitas baca tambahan, tetapi mengembalikan sebagian besar up-to-date versi item.)
`GetItem` mengembalikan semua atribut item. Anda dapat menggunakan *ekspresi proyeksi* untuk mengembalikan sebagian atribut saja. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi proyeksi di DynamoDB](Expressions.ProjectionExpressions.md).
Untuk mengembalikan jumlah unit kapasitas baca yang dikonsumsi oleh `GetItem`, tetapkan parameter `ReturnConsumedCapacity` menjadi `TOTAL`.
**Example**
Berikut AWS Command Line Interface (AWS CLI) contoh menunjukkan beberapa `GetItem` parameter opsional.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}' \
--consistent-read \
--projection-expression "Description, Price, RelatedItems" \
--return-consumed-capacity TOTAL
```
## Menulis item
Untuk membuat, memperbarui, atau menghapus item dalam tabel DynamoDB, gunakan salah satu operasi berikut:
+ `PutItem`
+ `UpdateItem`
+ `DeleteItem`
Untuk setiap operasi ini, Anda harus menentukan seluruh kunci primer, bukan hanya sebagian saja. Misalnya, jika tabel memiliki kunci primer gabungan (kunci partisi dan kunci urutan), Anda harus memberikan nilai untuk kunci partisi dan nilai untuk kunci urutan.
Untuk mengembalikan jumlah unit kapasitas tulis yang digunakan oleh salah satu operasi ini, atur parameter `ReturnConsumedCapacity` ke salah satu dari berikut ini:
+ `TOTAL` — Mengembalikan jumlah total unit kapasitas tulis yang dikonsumsi.
+ `INDEXES` — Mengembalikan jumlah total unit kapasitas tulis yang digunakan, dengan subtotal untuk tabel dan indeks sekunder apa pun yang terpengaruh oleh operasi.
+ `NONE` — Tidak ada detail kapasitas tulis dikembalikan. (Ini adalah pengaturan default.)
### PutItem
`PutItem` membuat item baru. Jika item dengan kunci yang sama sudah ada di tabel, item tersebut akan diganti dengan item baru.
**Example**
Tulis item baru ke tabel `Thread`. Kunci primer untuk `Thread` terdiri dari `ForumName` (kunci partisi) dan `Subject` (kunci urutan).
```
aws dynamodb put-item \
--table-name Thread \
--item file://item.json
```
Argumen untuk `--item` disimpan dalam file `item.json`.
```
{
"ForumName": {"S": "Amazon DynamoDB"},
"Subject": {"S": "New discussion thread"},
"Message": {"S": "First post in this thread"},
"LastPostedBy": {"S": "fred@example.com"},
"LastPostDateTime": {"S": "201603190422"}
}
```
### UpdateItem
Jika item dengan kunci tertentu tidak ada, `UpdateItem` akan membuat item baru. Jika tidak, ini akan mengubah atribut item yang sudah ada.
Anda menggunakan *ekspresi pembaruan* untuk menentukan atribut yang ingin Anda ubah dan nilai barunya. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi pembaruan di DynamoDB](Expressions.UpdateExpressions.md).
Dalam ekspresi pembaruan, Anda menggunakan nilai atribut ekspresi sebagai pengganti nilai aktual. Untuk informasi selengkapnya, lihat [Menggunakan nilai atribut ekspresi di DynamoDB](Expressions.ExpressionAttributeValues.md).
**Example**
Modifikasi berbagai atribut dalam item `Thread`. Parameter `ReturnValues` opsional menunjukkan item seperti yang muncul setelah pembaruan. Untuk informasi selengkapnya, lihat [Nilai yang dikembalikan](#WorkingWithItems.ReturnValues).
```
aws dynamodb update-item \
--table-name Thread \
--key file://key.json \
--update-expression "SET Answered = :zero, Replies = :zero, LastPostedBy = :lastpostedby" \
--expression-attribute-values file://expression-attribute-values.json \
--return-values ALL_NEW
```
Argumen untuk `--key` disimpan dalam file `key.json`.
```
{
"ForumName": {"S": "Amazon DynamoDB"},
"Subject": {"S": "New discussion thread"}
}
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `expression-attribute-values.json`.
```
{
":zero": {"N":"0"},
":lastpostedby": {"S":"barney@example.com"}
}
```
### DeleteItem
`DeleteItem` menghapus item dengan kunci tertentu.
**Example**
AWS CLI Contoh berikut menunjukkan cara menghapus `Thread` item.
```
aws dynamodb delete-item \
--table-name Thread \
--key file://key.json
```
## Nilai yang dikembalikan
Dalam beberapa kasus, Anda mungkin ingin DynamoDB mengembalikan nilai-nilai atribut tertentu seperti nilai yang muncul sebelum atau setelah Anda memodifikasi mereka. Operasi `PutItem`, `UpdateItem`, dan `DeleteItem` memiliki parameter `ReturnValues` yang dapat Anda gunakan untuk mengembalikan nilai atribut sebelum atau setelah dimodifikasi.
Nilai default untuk `ReturnValues` adalah `NONE`, yang berarti DynamoDB tidak mengembalikan informasi apa pun tentang atribut yang dimodifikasi.
Berikut ini adalah pengaturan valid lainnya untuk `ReturnValues`, yang diatur oleh operasi DynamoDB API.
### PutItem
+ `ReturnValues`: `ALL_OLD`
+ Jika Anda menimpa item yang ada, `ALL_OLD` akan mengembalikan seluruh item seperti item yang muncul sebelum penimpaan.
+ Jika Anda menulis item yang tidak ada, `ALL_OLD` tidak akan berpengaruh.
### UpdateItem
Penggunaan yang paling umum untuk `UpdateItem` adalah untuk memperbarui item yang ada. Namun, `UpdateItem` benar-benar melakukan *upsert*, yang berarti bahwa ini secara otomatis membuat item jika sudah tidak ada.
+ `ReturnValues`: `ALL_OLD`
+ Jika Anda memperbarui item yang ada, `ALL_OLD` akan mengembalikan seluruh item seperti item yang muncul sebelum pembaruan.
+ Jika Anda memperbarui item yang tidak ada (upsert), `ALL_OLD` tidak akan berpengaruh.
+ `ReturnValues`: `ALL_NEW`
+ Jika Anda memperbarui item yang ada, `ALL_NEW` menampilkan seluruh item seperti item yang muncul setelah pembaruan.
+ Jika Anda memperbarui item tidak ada (upsert), `ALL_NEW` akan mengembalikan seluruh item.
+ `ReturnValues`: `UPDATED_OLD`
+ Jika Anda memperbarui item yang ada, `UPDATED_OLD` hanya mengembalikan atribut yang diperbarui seperti atribut yang muncul sebelum pembaruan.
+ Jika Anda memperbarui item yang tidak ada (upsert), `UPDATED_OLD` tidak akan berpengaruh.
+ `ReturnValues`: `UPDATED_NEW`
+ Jika Anda memperbarui item yang ada, `UPDATED_NEW` hanya menampilkan atribut yang terpengaruh, seperti yang muncul setelah pembaruan.
+ Jika Anda memperbarui item tidak ada (upsert), `UPDATED_NEW` hanya mengembalikan atribut diperbarui, seperti yang muncul setelah pembaruan.
### DeleteItem
+ `ReturnValues`: `ALL_OLD`
+ Jika Anda menghapus item yang ada, `ALL_OLD` akan mengembalikan seluruh item seperti yang muncul sebelum Anda menghapusnya.
+ Jika Anda menghapus item yang tidak ada, `ALL_OLD` tidak akan menampilkan data apa pun.
## Operasi batch
Untuk aplikasi yang memerlukan membaca atau menulis beberapa item, DynamoDB menyediakan operasi `BatchGetItem` dan `BatchWriteItem`. Dengan menggunakan operasi ini, Anda dapat mengurangi jumlah perjalanan bolak-balik jaringan dari aplikasi Anda ke DynamoDB. Selain itu, DynamoDB melakukan operasi baca atau tulis individu secara paralel. Aplikasi Anda mendapatkan keuntungan dari paralelisme ini tanpa perlu mengelola konkurensi atau threading.
Operasi batch pada dasarnya merupakan pembungkus di sekitar beberapa permintaan baca atau tulis. Misalnya, jika permintaan `BatchGetItem` berisi lima item, DynamoDB melakukan lima operasi `GetItem` atas nama Anda. Demikian pula, jika permintaan `BatchWriteItem` berisi dua permintaan put dan empat permintaan penghapusan, DynamoDB akan melakukan dua permintaan `PutItem` dan empat `DeleteItem`.
Secara umum, operasi batch tidak gagal kecuali *semua* permintaan dalam batch mengalami kegagalan. Misalnya, bayangkan Anda melakukan operasi `BatchGetItem`, tetapi salah satu permintaan `GetItem` individu dalam batch mengalami kegagalan. Dalam kasus ini, `BatchGetItem` mengembalikan kunci dan data dari permintaan `GetItem` yang gagal. Permintaan `GetItem` lainnya dalam batch tidak akan terpengaruh.
### BatchGetItem
Satu operasi `BatchGetItem` dapat berisi hingga 100 permintaan `GetItem` individu dapat mengambil data hingga 16 MB. Selain itu, operasi `BatchGetItem` dapat mengambil item dari beberapa tabel.
**Example**
Ambil dua item dari tabel `Thread`, menggunakan ekspresi proyeksi untuk mengembalikan beberapa atribut saja.
```
aws dynamodb batch-get-item \
--request-items file://request-items.json
```
Argumen untuk `--request-items` disimpan dalam file `request-items.json`.
```
{
"Thread": {
"Keys": [
{
"ForumName":{"S": "Amazon DynamoDB"},
"Subject":{"S": "DynamoDB Thread 1"}
},
{
"ForumName":{"S": "Amazon S3"},
"Subject":{"S": "S3 Thread 1"}
}
],
"ProjectionExpression":"ForumName, Subject, LastPostedDateTime, Replies"
}
}
```
### BatchWriteItem
Operasi `BatchWriteItem` dapat berisi hingga 25 permintaan `PutItem` dan `DeleteItem` individu, serta dapat menulis data hingga 16 MB. (Ukuran maksimum item individu adalah sebesar 400 KB.) Selain itu, operasi `BatchWriteItem` dapat menempatkan atau menghapus item dalam beberapa tabel.
**catatan**
`BatchWriteItem` tidak mendukung permintaan `UpdateItem`.
**Example**
Tulis dua item ke tabel `ProductCatalog`.
```
aws dynamodb batch-write-item \
--request-items file://request-items.json
```
Argumen untuk `--request-items` disimpan dalam file `request-items.json`.
```
{
"ProductCatalog": [
{
"PutRequest": {
"Item": {
"Id": { "N": "601" },
"Description": { "S": "Snowboard" },
"QuantityOnHand": { "N": "5" },
"Price": { "N": "100" }
}
}
},
{
"PutRequest": {
"Item": {
"Id": { "N": "602" },
"Description": { "S": "Snow shovel" }
}
}
}
]
}
```
## Penghitung atom
Anda dapat menggunakan operasi `UpdateItem` untuk mengimplementasikan *penghitung atom*—atribut numerik yang bertambah, tanpa syarat, tanpa mengganggu permintaan tulis lainnya. (Semua permintaan tulis diterapkan sesuai urutan penerimaannya.) Dengan penghitung atom, pembaruan tidak idempotent. Dengan kata lain, nilai numerik bertambah atau berkurang setiap kali Anda menelepon. `UpdateItem` Jika nilai kenaikan yang digunakan untuk memperbarui penghitung atom positif, maka itu dapat menyebabkan penghitungan berlebihan. Jika nilai kenaikan negatif, maka dapat menyebabkan kekurangan perhitungan.
Anda dapat menggunakan penghitung atom untuk melacak jumlah pengunjung ke situs web. Dalam hal ini, aplikasi Anda akan menaikkan nilai numerik, terlepas dari nilai saat ini. Jika operasi `UpdateItem` gagal, aplikasi hanya dapat mencoba ulang operasi. Tindakan ini akan berisiko memperbarui penghitung dua kali, tetapi Anda mungkin bisa menoleransi sedikit kelebihan penghitungan atau kekurangan penghitungan dari pengunjung situs web.
Penghitung atom tidak akan cocok ketika kelebihan penghitungan atau kekurangan penghitungan tidak dapat ditoleransi (misalnya, dalam aplikasi perbankan). Dalam kasus ini, lebih aman menggunakan pembaruan bersyarat, bukannya penghitung atom.
Untuk informasi selengkapnya, lihat [Menambahkan dan mengurangi atribut numerik](Expressions.UpdateExpressions.md#Expressions.UpdateExpressions.SET.IncrementAndDecrement).
**Example**
AWS CLI Contoh berikut menambah produk `Price` sebesar 5. Untuk contoh ini, item diketahui ada sebelum penghitung diperbarui. Karena `UpdateItem` tidak idempotent, `Price` meningkat setiap kali Anda menjalankan kode ini.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id": { "N": "601" }}' \
--update-expression "SET Price = Price + :incr" \
--expression-attribute-values '{":incr":{"N":"5"}}' \
--return-values UPDATED_NEW
```
## Penulisan bersyarat
*Secara default, operasi penulisan DynamoDB `PutItem` (`DeleteItem`,) tidak bersyarat: Setiap operasi menimpa item yang ada yang memiliki kunci primer yang ditentukan.*
DynamoDB secara opsional mendukung penulisan bersyarat untuk operasi ini. Penulisan bersyarat akan berhasil hanya jika atribut item memenuhi satu atau beberapa kondisi yang diharapkan. Jika tidak, operasi ini akan mengembalikan kesalahan.
Penulisan bersyarat memeriksa kondisinya terhadap versi item yang terbaru diperbarui. Perhatikan bahwa jika item sebelumnya tidak ada atau jika operasi sukses terbaru terhadap item tersebut adalah penghapusan, maka penulisan bersyarat tidak akan menemukan item sebelumnya.
Penulisan bersyarat sangat membantu dalam banyak situasi. Misalnya, Anda mungkin ingin operasi `PutItem` bisa berhasil hanya jika sudah tidak ada item dengan kunci primer yang sama. Atau Anda dapat mencegah operasi `UpdateItem` memodifikasi item jika salah satu atributnya memiliki nilai tertentu.
Penulisan bersyarat berguna jika beberapa pengguna mencoba mengubah item yang sama. Perhatikan diagram berikut, di mana dua pengguna (Alice dan Bob) bekerja dengan item yang sama dari tabel DynamoDB.
![\[Pengguna Alice dan Bob mencoba memodifikasi item dengan Id 1, menunjukkan perlunya penulisan bersyarat.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/update-no-condition.png)
Misalkan Alice menggunakan AWS CLI untuk memperbarui `Price` atribut ke 8.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}' \
--update-expression "SET Price = :newval" \
--expression-attribute-values file://expression-attribute-values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `expression-attribute-values.json`:
```
{
":newval":{"N":"8"}
}
```
Sekarang anggaplah Bob mengeluarkan permintaan `UpdateItem` yang serupa kemudian, tetapi mengubah `Price` menjadi 12. Untuk Bob, parameter `--expression-attribute-values` akan terlihat seperti berikut ini.
```
{
":newval":{"N":"12"}
}
```
Permintaan Bob berhasil, tetapi pembaruan Alice sebelumnya hilang.
Untuk meminta `PutItem`, `DeleteItem`, atau `UpdateItem` bersyarat, Andalah yang menentukan ekspresi kondisi. *Ekspresi kondisi* adalah string yang berisi nama atribut, operator bersyarat, dan fungsi bawaan. Seluruh ekspresi harus bernilai benar. Jika tidak, operasi gagal.
Sekarang pertimbangkan diagram berikut yang menunjukkan bagaimana penulisan bersyarat akan mencegah pembaruan Alice ditimpa.
![\[Penulisan bersyarat mencegah pembaruan pengguna Bob menimpa perubahan pengguna Alice ke item yang sama.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/update-yes-condition.png)
Alice mencoba pertama kali untuk memperbarui `Price` menjadi 8, tetapi hanya jika `Price` saat ini adalah 10.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"1"}}' \
--update-expression "SET Price = :newval" \
--condition-expression "Price = :currval" \
--expression-attribute-values file://expression-attribute-values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `expression-attribute-values.json`.
```
{
":newval":{"N":"8"},
":currval":{"N":"10"}
}
```
Pembaruan Alice berhasil karena kondisi bernilai benar.
Berikutnya, Bob mencoba memperbarui `Price` menjadi 12, tetapi hanya jika `Price` saat ini adalah 10. Untuk Bob, parameter `--expression-attribute-values` akan terlihat seperti berikut ini.
```
{
":newval":{"N":"12"},
":currval":{"N":"10"}
}
```
Karena Alice sebelumnya telah mengubah `Price` ke 8, ekspresi kondisi bernilai SALAH, dan pembaruan Bob mengalami kegagalan.
Untuk informasi selengkapnya, lihat [Contoh CLI ekspresi kondisi DynamoDB](Expressions.ConditionExpressions.md).
### Idempotensi penulisan bersyarat
Penulisan bersyarat dapat menjadi *idempotent* jika pemeriksaan bersyarat berada pada atribut yang sama dan sedang diperbarui. Ini berarti bahwa DynamoDB melakukan permintaan tulis yang diberikan hanya jika nilai atribut tertentu dalam item cocok dengan tempat mereka berada pada saat permintaan sesuai harapan Anda.
Misalnya, misalnya Anda mengeluarkan permintaan `UpdateItem` untuk meningkatkan `Price` dari item sebesar 3, tetapi hanya jika `Price` saat ini adalah 20. Setelah Anda mengirimkan permintaan, tetapi sebelum Anda mendapatkan hasil kembali, terjadi kesalahan jaringan, dan Anda tidak tahu apakah permintaan tersebut berhasil. Karena penulisan bersyarat ini idempotent, Anda dapat mencoba kembali permintaan `UpdateItem` yang sama, dan DynamoDB memperbarui item hanya jika `Price` saat ini adalah 20.
### Unit kapasitas yang digunakan oleh penulisan bersyarat
Jika `ConditionExpression` bernilai false selama penulisan bersyarat, DynamoDB masih menggunakan kapasitas tulis dari tabel. Jumlah yang dikonsumsi tergantung dari besar kecilnya barang yang ada (atau minimal 1). Misalnya, jika item yang ada berukuran 300kb dan item baru yang Anda coba buat atau perbarui berukuran 310kb, unit kapasitas tulis yang digunakan akan menjadi 300 jika kondisi gagal, dan 310 jika kondisi berhasil. Jika ini adalah item baru (belum ada item yang ada), maka unit kapasitas tulis yang digunakan adalah 1 jika kondisi gagal dan 310 jika kondisi berhasil.
**catatan**
Operasi tulis hanya mengonsumsi unit kapasitas *tulis*. Operasi tersebut tidak pernah mengonsumsi unit kapasitas *baca*.
Penulisan bersyarat yang gagal akan menampilkan `ConditionalCheckFailedException`. Ketika ini terjadi, Anda tidak menerima informasi apa pun dalam tanggapan tentang kapasitas tulis yang dikonsumsi.
Untuk mengembalikan jumlah unit kapasitas tulis yang dikonsumsi selama penulisan bersyarat, Anda menggunakan parameter `ReturnConsumedCapacity`:
+ `TOTAL` — Mengembalikan jumlah total unit kapasitas tulis yang dikonsumsi.
+ `INDEXES` — Mengembalikan jumlah total unit kapasitas tulis yang digunakan, dengan subtotal untuk tabel dan indeks sekunder apa pun yang terpengaruh oleh operasi.
+ `NONE` — Tidak ada detail kapasitas tulis dikembalikan. (Ini menjadi opsi default.)
**catatan**
Tidak seperti indeks sekunder global, indeks sekunder lokal berbagi kapasitas throughput yang disediakan dengan tabelnya. Aktivitas baca dan tulis pada indeks sekunder lokal mengonsumsi kapasitas throughput yang disediakan dari tabel.
# Menggunakan ekspresi di DynamoDB
Di Amazon DynamoDB, Anda dapat *menggunakan* ekspresi untuk menentukan atribut mana yang akan dibaca dari item, menulis data saat kondisi terpenuhi, menentukan cara memperbarui item, menentukan kueri, dan memfilter hasil kueri.
Tabel ini menjelaskan tata bahasa ekspresi dasar dan jenis ekspresi yang tersedia.
| Jenis ekspresi | Deskripsi |
| --- | --- |
| Ekspresi proyeksi | Ekspresi proyeksi mengidentifikasi atribut yang ingin Anda ambil dari item saat Anda menggunakan operasi seperti GetItem, Kueri, atau Pindai. |
| Ekspresi kondisi | Ekspresi kondisi menentukan item mana yang harus dimodifikasi saat Anda menggunakan PutItem, UpdateItem, dan DeleteItem operasi. |
| Perbarui ekspresi | Ekspresi pembaruan menentukan bagaimana UpdateItem akan memodifikasi atribut item— misalnya, menetapkan nilai skalar atau menghapus elemen dari daftar atau peta. |
| Ekspresi kondisi kunci | Ekspresi kondisi kunci menentukan item mana yang akan dibaca kueri dari tabel atau indeks. |
| Ekspresi filter | Ekspresi filter menentukan item mana di antara hasil Query yang harus dikembalikan kepada Anda. Semua hasil lainnya dibuang. |
Untuk informasi tentang sintaks ekspresi dan informasi lebih rinci tentang setiap jenis ekspresi, lihat bagian berikut.
**Topics**
+ [Mengacu pada atribut item saat menggunakan ekspresi di DynamoDB](Expressions.Attributes.md)
+ [Nama atribut ekspresi (alias) di DynamoDB](Expressions.ExpressionAttributeNames.md)
+ [Menggunakan nilai atribut ekspresi di DynamoDB](Expressions.ExpressionAttributeValues.md)
+ [Menggunakan ekspresi proyeksi di DynamoDB](Expressions.ProjectionExpressions.md)
+ [Menggunakan ekspresi pembaruan di DynamoDB](Expressions.UpdateExpressions.md)
+ [Kondisi dan filter ekspresi, operator, dan fungsi di DynamoDB](Expressions.OperatorsAndFunctions.md)
+ [Contoh CLI ekspresi kondisi DynamoDB](Expressions.ConditionExpressions.md)
**catatan**
Untuk kompatibilitas ke belakang, DynamoDB juga mendukung parameter bersyarat yang tidak menggunakan ekspresi. Untuk informasi selengkapnya, lihat [Parameter bersyarat DynamoDB lama](LegacyConditionalParameters.md).
Aplikasi baru harus menggunakan ekspresi, bukan parameter warisan.
# Mengacu pada atribut item saat menggunakan ekspresi di DynamoDB
Bagian ini menjelaskan cara merujuk ke atribut item dalam suatu ekspresi di Amazon DynamoDB. Anda dapat bekerja dengan atribut apa pun, meskipun itu sangat bersarang dalam beberapa daftar dan peta.
**Topics**
+ [Atribut tingkat atas](#Expressions.Attributes.TopLevelAttributes)
+ [Atribut bersarang](#Expressions.Attributes.NestedAttributes)
+ [Jalur dokumen](#Expressions.Attributes.NestedElements.DocumentPathExamples)
**Item Sampel: ProductCatalog**
Contoh di halaman ini menggunakan item contoh berikut dalam `ProductCatalog` tabel. (Tabel ini dijelaskan dalam [Contoh tabel dan data untuk digunakan di DynamoDB](AppendixSampleTables.md).)
```
{
"Id": 123,
"Title": "Bicycle 123",
"Description": "123 description",
"BicycleType": "Hybrid",
"Brand": "Brand-Company C",
"Price": 500,
"Color": ["Red", "Black"],
"ProductCategory": "Bicycle",
"InStock": true,
"QuantityOnHand": null,
"RelatedItems": [
341,
472,
649
],
"Pictures": {
"FrontView": "http://example.com/products/123_front.jpg",
"RearView": "http://example.com/products/123_rear.jpg",
"SideView": "http://example.com/products/123_left_side.jpg"
},
"ProductReviews": {
"FiveStar": [
"Excellent! Can't recommend it highly enough! Buy it!",
"Do yourself a favor and buy this."
],
"OneStar": [
"Terrible product! Do not buy this."
]
},
"Comment": "This product sells out quickly during the summer",
"Safety.Warning": "Always wear a helmet"
}
```
Perhatikan hal-hal berikut:
+ Nilai kunci partisi (`Id`) adalah `123`. Tidak ada kunci urutan.
+ Sebagian besar atribut memiliki jenis daya skalar, seperti `String`, `Number`, `Boolean`, dan `Null`.
+ Satu atribut (`Color`) adalah `String Set`.
+ Atribut berikut adalah jenis daya dokumen:
+ Daftar dari `RelatedItems`. Setiap elemen adalah `Id` untuk produk terkait.
+ Peta dari `Pictures`. Setiap elemen adalah deskripsi singkat dari gambar, bersama dengan URL untuk file gambar yang sesuai.
+ Peta dari `ProductReviews`. Setiap elemen mewakili penilaian dan daftar ulasan yang sesuai dengan penilaian tersebut. Awalnya, peta ini diisi dengan ulasan bintang lima dan bintang satu.
## Atribut tingkat atas
Suatu atribut dikatakan *tingkat atas* jika tidak melekat pada atribut lain. Untuk item `ProductCatalog`, atribut tingkat atas adalah sebagai berikut:
+ `Id`
+ `Title`
+ `Description`
+ `BicycleType`
+ `Brand`
+ `Price`
+ `Color`
+ `ProductCategory`
+ `InStock`
+ `QuantityOnHand`
+ `RelatedItems`
+ `Pictures`
+ `ProductReviews`
+ `Comment`
+ `Safety.Warning`
Semua atribut tingkat atas ini bersifat skalar, kecuali untuk `Color` (daftar), `RelatedItems` (daftar), `Pictures` (peta), dan `ProductReviews` (peta).
## Atribut bersarang
Suatu atribut dikatakan *bersarang* jika melekat pada atribut lain. Untuk mengakses atribut bersarang, Anda menggunakan *operator dereferensi*:
+ `[n]` — untuk elemen daftar
+ `.` (titik) — untuk elemen peta
### Mengakses elemen daftar
Operator dereferensi untuk elemen daftar adalah **[*N*]**, dengan *n* adalah nomor elemen. Elemen daftar berbasis nol, sehingga [0] mewakili elemen pertama dalam daftar, [1] mewakili elemen kedua, dan seterusnya. Berikut ini adalah beberapa contohnya:
+ `MyList[0]`
+ `AnotherList[12]`
+ `ThisList[5][11]`
Elemen `ThisList[5]` itu sendiri adalah daftar bersarang. Karena itu, `ThisList[5][11]` merujuk pada elemen ke-12 dalam daftar itu.
Angka di dalam tanda kurung siku harus berupa angka bulat bukan negatif. Oleh karena itu, ekspresi berikut ini tidak valid:
+ `MyList[-1]`
+ `MyList[0.4]`
### Mengakses elemen peta
Operator dereferensi untuk elemen peta adalah **.** (titik). Gunakan satu titik sebagai pemisah antara unsur-unsur dalam peta:
+ `MyMap.nestedField`
+ `MyMap.nestedField.deeplyNestedField`
## Jalur dokumen
Dalam sebuah ekspresi, Anda menggunakan *jalur dokumen* untuk memberi tahu DynamoDB lokasi penemuan atribut. Untuk atribut tingkat atas, jalur dokumen hanyalah nama atribut. Untuk atribut bersarang, Anda mengonstruksi jalur dokumen menggunakan operator dereferensi.
Berikut adalah beberapa contoh dari jalur dokumen. (Lihat item yang ditampilkan dalam [Mengacu pada atribut item saat menggunakan ekspresi di DynamoDB](#Expressions.Attributes).)
+ Atribut skalar tingkat atas.
`Description`
+ Atribut daftar tingkat atas. (Ini mengembalikan seluruh daftar, bukan hanya beberapa elemen.)
`RelatedItems`
+ Elemen ketiga dari daftar `RelatedItems`. (Ingat bahwa elemen daftar berbasis nol.)
`RelatedItems[2]`
+ Gambar tampilan depan produk.
`Pictures.FrontView`
+ Semua ulasan bintang lima.
`ProductReviews.FiveStar`
+ Yang pertama dari ulasan bintang lima.
`ProductReviews.FiveStar[0]`
**catatan**
Kedalaman maksimum untuk jalur dokumen adalah 32. Oleh karena itu, jumlah operator dereferensi dalam suatu jalur tidak dapat melebihi batas ini.
Anda dapat menggunakan nama atribut apa pun di jalur dokumen asalkan memenuhi persyaratan berikut:
+ Karakter pertama adalah `a-z` atau `A-Z` dan atau `0-9`
+ Karakter kedua (jika ada) adalah`a-z`, `A-Z`
**catatan**
Jika nama atribut tidak memenuhi persyaratan ini, Anda harus menentukan nama atribut ekspresi sebagai placeholder.
Untuk informasi selengkapnya, lihat [Nama atribut ekspresi (alias) di DynamoDB](Expressions.ExpressionAttributeNames.md).
# Nama atribut ekspresi (alias) di DynamoDB
*Nama atribut ekspresi* adalah alias (atau placeholder) yang Anda gunakan dalam ekspresi Amazon DynamoDB sebagai alternatif dari nama atribut yang sebenarnya. Nama atribut ekspresi harus dimulai dengan tanda pound (`#`) dan diikuti oleh satu atau lebih karakter alfanumerik. Karakter underscore (`_`) juga diperbolehkan.
Bagian ini menjelaskan beberapa situasi ketika Anda harus menggunakan nama atribut ekspresi.
**catatan**
Contoh di bagian ini menggunakan AWS Command Line Interface (AWS CLI).
**Topics**
+ [Kata yang dicadangkan](#Expressions.ExpressionAttributeNames.ReservedWords)
+ [Nama atribut yang berisi karakter khusus](#Expressions.ExpressionAttributeNames.AttributeNamesContainingSpecialCharacters)
+ [Atribut bersarang](#Expressions.ExpressionAttributeNames.NestedAttributes)
+ [Berulang kali mereferensikan nama atribut](#Expressions.ExpressionAttributeNames.RepeatingAttributeNames)
## Kata yang dicadangkan
Terkadang Anda mungkin perlu menulis ekspresi yang berisi nama atribut yang bertentangan dengan kata terpesan DynamoDB. (Untuk daftar lengkap kata-kata yang dicadangkan, lihat [Kata-kata penggunaan khusus di DynamoDB](ReservedWords.md).)
Misalnya, AWS CLI contoh berikut akan gagal karena `COMMENT` merupakan kata yang dicadangkan.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "Comment"
```
Untuk mengatasi hal ini, Anda dapat mengganti `Comment` dengan nama atribut ekspresi seperti `#c`. `#` (tanda pagar) diperlukan dan menunjukkan bahwa ini adalah placeholder untuk nama atribut. AWS CLI Contohnya sekarang akan terlihat seperti berikut.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#c" \
--expression-attribute-names '{"#c":"Comment"}'
```
**catatan**
Jika nama atribut dimulai dengan nomor, berisi spasi, atau berisi kata terpesan, Anda *harus* menggunakan nama atribut ekspresi untuk menggantikan nama atribut dalam ekspresi tersebut.
## Nama atribut yang berisi karakter khusus
Dalam suatu ekspresi, titik (".") ditafsirkan sebagai karakter pemisah pada jalur dokumen. Namun, DynamoDB juga memungkinkan Anda menggunakan karakter titik dan karakter khusus lainnya, seperti tanda hubung (“-”) sebagai bagian dari nama atribut. Dalam beberapa kasus, ini bisa menjadi ambigu. Untuk menggambarkan, misalkan bahwa Anda ingin mengambil atribut `Safety.Warning` dari item `ProductCatalog` (lihat [Mengacu pada atribut item saat menggunakan ekspresi di DynamoDB](Expressions.Attributes.md)).
Misalkan Anda ingin mengakses `Safety.Warning` menggunakan ekspresi proyeksi.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "Safety.Warning"
```
DynamoDB akan mengembalikan hasil kosong, bukan string yang diharapkan ("`Always wear a helmet`"). Hal ini karena DynamoDB menafsirkan titik dalam ekspresi sebagai pemisah jalur dokumen. Dalam hal ini, Anda harus menentukan nama atribut ekspresi (seperti `#sw`) sebagai pengganti untuk `Safety.Warning`. Anda kemudian dapat menggunakan ekspresi proyeksi berikut.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#sw" \
--expression-attribute-names '{"#sw":"Safety.Warning"}'
```
DynamoDB kemudian akan mengembalikan hasil yang benar.
**catatan**
Jika nama atribut berisi titik (".") atau tanda hubung ("-"), Anda *harus* menggunakan nama atribut ekspresi untuk menggantikan nama atribut dalam ekspresi tersebut.
## Atribut bersarang
Misalkan Anda ingin mengakses atribut `ProductReviews.OneStar` bersarang. Dalam nama atribut ekspresi, DynamoDB memperlakukan titik (“.”) sebagai karakter dalam nama atribut. Untuk mereferensikan atribut bersarang, tentukan nama atribut ekspresi untuk setiap elemen di jalur dokumen:
+ `#pr — ProductReviews`
+ `#1star — OneStar`
Anda kemudian dapat menggunakan `#pr.#1star` untuk ekspresi proyeksi.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#pr.#1star" \
--expression-attribute-names '{"#pr":"ProductReviews", "#1star":"OneStar"}'
```
DynamoDB kemudian akan mengembalikan hasil yang benar.
## Berulang kali mereferensikan nama atribut
Nama atribut ekspresi sangat membantu ketika Anda perlu merujuk ke nama atribut yang sama berulang-ulang. Misalnya, pertimbangkan ekspresi berikut untuk mengambil beberapa ulasan dari item `ProductCatalog`.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "ProductReviews.FiveStar, ProductReviews.ThreeStar, ProductReviews.OneStar"
```
Untuk membuat hal ini lebih jelas, Anda dapat mengganti `ProductReviews` dengan nama atribut ekspresi seperti `#pr`. Ekspresi yang direvisi kini akan terlihat seperti berikut ini.
+ `#pr.FiveStar, #pr.ThreeStar, #pr.OneStar`
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#pr.FiveStar, #pr.ThreeStar, #pr.OneStar" \
--expression-attribute-names '{"#pr":"ProductReviews"}'
```
Jika Anda menentukan nama atribut ekspresi, Anda harus menggunakannya secara konsisten di seluruh ekspresi. Selain itu, Anda tidak dapat menghilangkan simbol `#`.
# Menggunakan nilai atribut ekspresi di DynamoDB
*Nilai atribut ekspresi* di Amazon DynamoDB bertindak sebagai variabel. Mereka adalah pengganti nilai aktual yang ingin Anda bandingkan — nilai yang mungkin tidak Anda ketahui sampai runtime. Nilai atribut ekspresi harus dimulai dengan titik dua (`:`) dan diikuti oleh satu atau beberapa karakter alfanumerik.
Misalnya, anggaplah Anda ingin menampilkan semua item `ProductCatalog` yang tersedia dalam `Black` dan berbiaya `500` atau lebih sedikit. Anda dapat menggunakan operasi `Scan` dengan ekspresi filter, seperti dalam contoh AWS Command Line Interface (AWS CLI).
```
aws dynamodb scan \
--table-name ProductCatalog \
--filter-expression "contains(Color, :c) and Price <= :p" \
--expression-attribute-values file://values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":c": { "S": "Black" },
":p": { "N": "500" }
}
```
Jika Anda menentukan nilai atribut ekspresi, Anda harus menggunakannya secara konsisten di seluruh ekspresi. Selain itu, Anda tidak dapat menghilangkan simbol `:`.
Nilai atribut ekspresi digunakan dengan ekspresi kondisi kunci, ekspresi kondisi, ekspresi pembaruan, dan ekspresi filter.
# Menggunakan ekspresi proyeksi di DynamoDB
Untuk membaca data dari tabel, Anda menggunakan operasi seperti `GetItem`, `Query`, atau `Scan`. Amazon DynamoDB mengembalikan semua atribut item secara default. Untuk mendapatkan beberapa saja, bukan semua atribut, gunakan ekspresi proyeksi.
*Ekspresi proyeksi* adalah string yang mengidentifikasi atribut yang Anda inginkan. Untuk mengambil atribut tunggal, tentukan namanya. Untuk beberapa atribut, nama harus dipisahkan koma.
Berikut adalah beberapa contoh ekspresi proyeksi, berdasarkan item `ProductCatalog` dari [Mengacu pada atribut item saat menggunakan ekspresi di DynamoDB](Expressions.Attributes.md):
+ Atribut tingkat atas tunggal.
`Title `
+ Tiga atribut tingkat atas. DynamoDB mengambil seluruh set `Color`.
`Title, Price, Color`
+ Empat atribut tingkat atas. DynamoDB mengembalikan seluruh konten `RelatedItems` dan `ProductReviews`.
`Title, Description, RelatedItems, ProductReviews`
**catatan**
Ekspresi proyeksi tidak berpengaruh pada konsumsi throughput yang disediakan. DynamoDB menentukan unit kapasitas yang dikonsumsi berdasarkan ukuran item, bukan jumlah data yang dikembalikan ke aplikasi.
**Kata-kata yang dicadangkan dan karakter khusus**
DynamoDB telah memesan kata-kata dan karakter khusus. DynamoDB memungkinkan Anda untuk menggunakan kata-kata yang dicadangkan ini dan karakter khusus untuk nama, tetapi kami menyarankan Anda menghindari melakukannya karena Anda harus menggunakan alias untuk mereka setiap kali Anda menggunakan nama-nama ini dalam sebuah ekspresi. Untuk daftar lengkap, lihat [Kata-kata penggunaan khusus di DynamoDB](ReservedWords.md).
Anda harus menggunakan nama atribut ekspresi sebagai pengganti nama sebenarnya jika:
+ Nama atribut ada di daftar kata-kata yang dicadangkan di DynamoDB.
+ Nama atribut tidak memenuhi persyaratan bahwa karakter pertama adalah `a-z` atau `A-Z` dan bahwa karakter kedua (jika ada) adalah`a-Z`,`A-Z`, atau`0-9`.
+ Nama atribut berisi **\$1** (hash) atau**:** (titik dua).
AWS CLI Contoh berikut menunjukkan bagaimana menggunakan ekspresi proyeksi dengan `GetItem` operasi. Ekspresi proyeksi ini mengambil atribut skalar tingkat atas (`Description`), elemen pertama dalam daftar (`RelatedItems[0]`), dan daftar bersarang dalam peta (`ProductReviews.FiveStar`).
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '"Id": { "N": "123" } \
--projection-expression "Description, RelatedItems[0], ProductReviews.FiveStar"
```
JSON berikut akan dikembalikan untuk contoh ini.
```
{
"Item": {
"Description": {
"S": "123 description"
},
"ProductReviews": {
"M": {
"FiveStar": {
"L": [
{
"S": "Excellent! Can't recommend it highly enough! Buy it!"
},
{
"S": "Do yourself a favor and buy this."
}
]
}
}
},
"RelatedItems": {
"L": [
{
"N": "341"
}
]
}
}
}
```
# Menggunakan ekspresi pembaruan di DynamoDB
Operasi `UpdateItem` memperbarui item yang sudah ada, atau menambahkan item baru ke tabel jika belum ada. Anda harus memberikan kunci item yang ingin Anda perbarui. Anda juga harus menyediakan ekspresi pembaruan, yang menunjukkan atribut yang ingin Anda ubah dan nilai yang ingin Anda tetapkan padanya.
*Ekspresi pembaruan* menentukan cara `UpdateItem` mengubah atribut item—misalnya, menetapkan nilai skalar atau menghapus elemen dari daftar atau peta.
Berikut ini adalah ringkasan sintaksis untuk ekspresi pembaruan.
```
update-expression ::=
[ SET action [, action] ... ]
[ REMOVE action [, action] ...]
[ ADD action [, action] ... ]
[ DELETE action [, action] ...]
```
Ekspresi pembaruan terdiri dari satu atau lebih klausa. Setiap klausa dimulai dengan kata kunci `SET`, `REMOVE`, `ADD`, atau `DELETE`. Anda dapat memasukkan salah satu klausa ini dalam ekspresi pembaruan, dalam urutan apa pun. Namun, setiap kata kunci tindakan hanya dapat muncul satu kali.
Dalam setiap klausa, ada satu atau lebih tindakan yang dipisahkan dengan koma. Setiap tindakan mewakili modifikasi data.
Contoh dalam bagian ini didasarkan pada item `ProductCatalog` yang ditampilkan dalam [Menggunakan ekspresi proyeksi di DynamoDB](Expressions.ProjectionExpressions.md).
Topik di bawah ini mencakup beberapa kasus penggunaan yang berbeda untuk `SET` tindakan tersebut.
**Topics**
+ [SET — mengubah atau menambahkan atribut item](#Expressions.UpdateExpressions.SET)
+ [REMOVE—menghapus atribut dari item](#Expressions.UpdateExpressions.REMOVE)
+ [ADD — memperbarui nomor dan set](#Expressions.UpdateExpressions.ADD)
+ [DELETE — menghapus elemen dari set](#Expressions.UpdateExpressions.DELETE)
+ [Menggunakan beberapa ekspresi pembaruan](#Expressions.UpdateExpressions.Multiple)
## SET — mengubah atau menambahkan atribut item
Gunakan tindakan `SET` dalam ekspresi pembaruan untuk menambahkan satu atau beberapa atribut ke item. Jika salah satu atribut ini sudah ada, atribut tersebut akan ditimpa dengan nilai baru. Jika Anda ingin menghindari penimpaan atribut yang ada, Anda dapat menggunakan `SET` dengan fungsi `if_not_exists`. Fungsi `if_not_exists` khusus untuk tindakan `SET` dan hanya dapat digunakan dalam ekspresi pembaruan.
Saat Anda menggunakan `SET` untuk memperbarui elemen daftar, konten elemen akan diganti dengan data baru yang Anda tentukan. Jika elemen tersebut belum ada, `SET` menambahkan elemen baru pada akhir daftar.
Jika Anda menambahkan beberapa elemen dalam satu operasi `SET`, elemen diurutkan berdasarkan nomor elemen.
Anda juga dapat menggunakan `SET` untuk menambahkan atau mengurangi dari atribut yang berjenis `Number`. Untuk melakukan beberapa tindakan `SET`, pisahkan dengan koma.
Dalam ringkasan sintaks berikut:
+ *path*Elemen adalah jalur dokumen ke item.
+ **operand**Elemen dapat berupa jalur dokumen ke item atau fungsi.
```
set-action ::=
path = value
value ::=
operand
| operand '+' operand
| operand '-' operand
operand ::=
path | function
function ::=
if_not_exists (path, value)
```
Jika item tidak berisi atribut di jalur yang ditentukan, `if_not_exists` evaluasi ke`value`. Kalau tidak, itu mengevaluasi. `path`
Operasi `PutItem` berikut membuat item sampel yang dirujuk oleh contoh.
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item file://item.json
```
Argumen untuk `--item` disimpan dalam file `item.json`. (Untuk kemudahan, hanya beberapa atribut item yang digunakan.)
```
{
"Id": {"N": "789"},
"ProductCategory": {"S": "Home Improvement"},
"Price": {"N": "52"},
"InStock": {"BOOL": true},
"Brand": {"S": "Acme"}
}
```
**Topics**
+ [Memodifikasi atribut](#Expressions.UpdateExpressions.SET.ModifyingAttributes)
+ [Menambahkan daftar dan peta](#Expressions.UpdateExpressions.SET.AddingListsAndMaps)
+ [Menambahkan elemen ke daftar](#Expressions.UpdateExpressions.SET.AddingListElements)
+ [Menambahkan atribut peta bersarang](#Expressions.UpdateExpressions.SET.AddingNestedMapAttributes)
+ [Menambahkan dan mengurangi atribut numerik](#Expressions.UpdateExpressions.SET.IncrementAndDecrement)
+ [Melekatkan elemen ke daftar](#Expressions.UpdateExpressions.SET.UpdatingListElements)
+ [Mencegah penimpaan atribut yang ada](#Expressions.UpdateExpressions.SET.PreventingAttributeOverwrites)
### Memodifikasi atribut
**Example**
Perbarui atribut `ProductCategory` dan `Price`.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET ProductCategory = :c, Price = :p" \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":c": { "S": "Hardware" },
":p": { "N": "60" }
}
```
**catatan**
Dalam operasi `UpdateItem`, `--return-values ALL_NEW` menyebabkan DynamoDB untuk mengembalikan item seperti yang muncul setelah pembaruan.
### Menambahkan daftar dan peta
**Example**
Tambahkan daftar baru dan peta baru.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET RelatedItems = :ri, ProductReviews = :pr" \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":ri": {
"L": [
{ "S": "Hammer" }
]
},
":pr": {
"M": {
"FiveStar": {
"L": [
{ "S": "Best product ever!" }
]
}
}
}
}
```
### Menambahkan elemen ke daftar
**Example**
Tambahkan atribut baru ke daftar `RelatedItems`. (Ingatlah bahwa elemen daftar berbasis nol, sehingga [0] mewakili elemen pertama dalam daftar, [1] mewakili elemen kedua, dan seterusnya.)
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET RelatedItems[1] = :ri" \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":ri": { "S": "Nails" }
}
```
**catatan**
Saat Anda menggunakan `SET` untuk memperbarui elemen daftar, konten elemen akan diganti dengan data baru yang Anda tentukan. Jika elemen tersebut belum ada, `SET` menambahkan elemen baru pada akhir daftar.
Jika Anda menambahkan beberapa elemen dalam satu operasi `SET`, elemen diurutkan berdasarkan nomor elemen.
### Menambahkan atribut peta bersarang
**Example**
Tambahkan beberapa atribut peta bersarang.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET #pr.#5star[1] = :r5, #pr.#3star = :r3" \
--expression-attribute-names file://names.json \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Argumen untuk `--expression-attribute-names` disimpan dalam file `names.json`.
```
{
"#pr": "ProductReviews",
"#5star": "FiveStar",
"#3star": "ThreeStar"
}
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":r5": { "S": "Very happy with my purchase" },
":r3": {
"L": [
{ "S": "Just OK - not that great" }
]
}
}
```
**penting**
Anda tidak dapat memperbarui atribut peta bersarang jika peta induk tidak ada. Jika Anda mencoba memperbarui atribut bersarang (misalnya,`ProductReviews.FiveStar`) ketika peta induk (`ProductReviews`) tidak ada, DynamoDB mengembalikan *pesan “Jalur dokumen `ValidationException` yang disediakan dalam ekspresi pembaruan tidak valid untuk pembaruan*.”
Saat membuat item yang akan memiliki atribut peta bersarang diperbarui nanti, inisialisasi peta kosong untuk atribut induk. Contoh:
```
{
"Id": {"N": "789"},
"ProductReviews": {"M": {}},
"Metadata": {"M": {}}
}
```
Ini memungkinkan Anda memperbarui atribut bersarang seperti `ProductReviews.FiveStar` tanpa kesalahan.
### Menambahkan dan mengurangi atribut numerik
Anda dapat menambahkan atau mengurangi dari atribut numerik yang sudah ada. Untuk melakukannya, gunakan operator `+` (plus) dan `-` (minus).
**Example**
Kurangi `Price` dari item.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET Price = Price - :p" \
--expression-attribute-values '{":p": {"N":"15"}}' \
--return-values ALL_NEW
```
Untuk meningkatkan `Price`, Anda akan menggunakan operator `+` dalam ekspresi pembaruan.
### Melekatkan elemen ke daftar
Anda dapat menambahkan elemen ke akhir daftar. Untuk melakukannya, gunakan `SET` dengan fungsi `list_append`. (Nama fungsi ini peka huruf besar/kecil.) Fungsi `list_append` khusus untuk tindakan `SET` dan hanya dapat digunakan dalam ekspresi pembaruan. Sintaksnya adalah sebagai berikut.
+ `list_append (list1, list2)`
Fungsi ini mengambil dua daftar sebagai input dan menambahkan semua elemen dari `list2` ke ` list1`.
**Example**
Dalam [Menambahkan elemen ke daftar](#Expressions.UpdateExpressions.SET.AddingListElements), Anda mencantumkan `RelatedItems` dan mengisinya dengan dua elemen: `Hammer` dan `Nails`. Sekarang Anda menambahkan dua elemen lagi ke akhir `RelatedItems`.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET #ri = list_append(#ri, :vals)" \
--expression-attribute-names '{"#ri": "RelatedItems"}' \
--expression-attribute-values file://values.json \
--return-values ALL_NEW
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":vals": {
"L": [
{ "S": "Screwdriver" },
{"S": "Hacksaw" }
]
}
}
```
Akhirnya, Anda menambahkan satu elemen lagi ke *awal* dari `RelatedItems`. Untuk melakukan hal ini, tukar urutan elemen `list_append`. (Ingatlah bahwa `list_append` mengambil dua daftar sebagai input dan menambahkan daftar kedua ke yang pertama.)
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET #ri = list_append(:vals, #ri)" \
--expression-attribute-names '{"#ri": "RelatedItems"}' \
--expression-attribute-values '{":vals": {"L": [ { "S": "Chisel" }]}}' \
--return-values ALL_NEW
```
Atribut `RelatedItems` yang dihasilkan sekarang berisi lima elemen, dalam urutan berikut: `Chisel`, `Hammer`, `Nails`, `Screwdriver`, `Hacksaw`.
### Mencegah penimpaan atribut yang ada
**Example**
Tetapkan `Price` dari suatu item, tetapi hanya jika item tersebut belum memiliki atribut `Price`. (Jika `Price` sudah ada, tidak ada yang terjadi.)
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET Price = if_not_exists(Price, :p)" \
--expression-attribute-values '{":p": {"N": "100"}}' \
--return-values ALL_NEW
```
## REMOVE—menghapus atribut dari item
Gunakan tindakan `REMOVE` dalam ekspresi pembaruan untuk menghapus satu atau beberapa atribut dari item di Amazon DynamoDB. Untuk melakukan beberapa tindakan `REMOVE`, pisahkan dengan koma.
Berikut ini adalah ringkasan sintaks untuk `REMOVE` dalam ekspresi pembaruan. Satu-satunya operand adalah jalur dokumen untuk atribut yang ingin Anda hapus.
```
remove-action ::=
path
```
**Example**
Hapus beberapa atribut dari item. (Jika atribut tidak ada, tidak ada yang terjadi.)
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "REMOVE Brand, InStock, QuantityOnHand" \
--return-values ALL_NEW
```
### Menghapus elemen dari daftar
Anda dapat menggunakan `REMOVE` untuk menghapus elemen individu dari daftar.
**Example**
Dalam [Melekatkan elemen ke daftar](#Expressions.UpdateExpressions.SET.UpdatingListElements), Anda mengubah atribut daftar (`RelatedItems`) sehingga berisi lima elemen:
+ `[0]`—`Chisel`
+ `[1]`—`Hammer`
+ `[2]`—`Nails`
+ `[3]`—`Screwdriver`
+ `[4]`—`Hacksaw`
Berikut AWS Command Line Interface (AWS CLI) contoh menghapus `Hammer` dan `Nails` dari daftar.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "REMOVE RelatedItems[1], RelatedItems[2]" \
--return-values ALL_NEW
```
Setelah `Hammer` dan `Nails` dihapus, elemen yang tersisa digeser. Daftarnya sekarang berisi hal-hal berikut:
+ `[0]`—`Chisel`
+ `[1]`—`Screwdriver`
+ `[2]`—`Hacksaw`
## ADD — memperbarui nomor dan set
**catatan**
Secara umum, kami merekomendasikan penggunaan `SET` daripada `ADD` untuk memastikan operasi idempoten.
Gunakan tindakan `ADD` dalam ekspresi pembaruan untuk menambahkan atribut baru dan nilainya untuk item.
Jika atribut sudah ada, perilaku `ADD` bergantung pada jenis daya atribut ini:
+ Jika atribut adalah angka, dan nilai yang Anda tambahkan juga angka, nilai matematis ditambahkan ke atribut yang ada. (Jika nilai adalah angka negatif, nilai tersebut dikurangi dari atribut yang ada.)
+ Jika atribut adalah suatu set, dan nilai yang Anda tambahkan juga suatu set, nilai ditambahkan ke set yang ada.
**catatan**
Tindakan `ADD` hanya mendukung jenis daya angka dan set.
Untuk melakukan beberapa tindakan `ADD`, pisahkan dengan koma.
Dalam ringkasan sintaks berikut:
+ *path*Elemen adalah jalur dokumen ke atribut. Atribut harus berupa `Number` atau jenis daya set.
+ *value*Elemen adalah angka yang ingin Anda tambahkan ke atribut (untuk tipe `Number` data), atau set untuk ditambahkan ke atribut (untuk jenis set).
```
add-action ::=
path value
```
Topik di bawah ini mencakup beberapa kasus penggunaan yang berbeda untuk `ADD` tindakan tersebut.
**Topics**
+ [Menambahkan nomor](#Expressions.UpdateExpressions.ADD.Number)
+ [Menambahkan elemen ke set](#Expressions.UpdateExpressions.ADD.Set)
### Menambahkan nomor
Anggaplah atribut `QuantityOnHand` tidak ada. AWS CLI Contoh berikut ditetapkan `QuantityOnHand` ke 5.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "ADD QuantityOnHand :q" \
--expression-attribute-values '{":q": {"N": "5"}}' \
--return-values ALL_NEW
```
Kini setelah `QuantityOnHand` ada, Anda dapat menjalankan kembali contoh untuk menaikkan `QuantityOnHand` sebesar 5 setiap kali melakukannya.
### Menambahkan elemen ke set
Anggaplah atribut `Color` tidak ada. Contoh AWS CLI berikut menetapkan `Color` untuk satu set string dengan dua elemen.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "ADD Color :c" \
--expression-attribute-values '{":c": {"SS":["Orange", "Purple"]}}' \
--return-values ALL_NEW
```
Kini setelah `Color` ada, Anda dapat menambahkan lebih banyak elemen untuknya.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "ADD Color :c" \
--expression-attribute-values '{":c": {"SS":["Yellow", "Green", "Blue"]}}' \
--return-values ALL_NEW
```
## DELETE — menghapus elemen dari set
**penting**
Tindakan `DELETE` hanya mendukung jenis daya `Set`.
Gunakan tindakan `DELETE` dalam ekspresi pembaruan untuk menghapus satu atau beberapa elemen dari satu set. Untuk melakukan beberapa tindakan `DELETE`, pisahkan dengan koma.
Dalam ringkasan sintaks berikut:
+ *path*Elemen adalah jalur dokumen ke atribut. Atribut harus berupa jenis daya set.
+ *subset*Ini adalah satu atau lebih elemen yang ingin Anda hapus*path*. Anda harus menentukan *subset* sebagai tipe set.
```
delete-action ::=
path subset
```
**Example**
Dalam [Menambahkan elemen ke set](#Expressions.UpdateExpressions.ADD.Set), Anda membuat set string `Color`. Contoh ini akan menghapus beberapa elemen dari set tersebut.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "DELETE Color :p" \
--expression-attribute-values '{":p": {"SS": ["Yellow", "Purple"]}}' \
--return-values ALL_NEW
```
## Menggunakan beberapa ekspresi pembaruan
Anda dapat menggunakan beberapa tindakan dalam satu ekspresi pembaruan. Semua referensi atribut diselesaikan terhadap status item sebelum tindakan apa pun diterapkan.
**Example**
Diberikan item`{"id": "1", "a": 1, "b": 2, "c": 3}`, ekspresi berikut menghapus `a` dan menggeser nilai `b` dan`c`:
```
aws dynamodb update-item \
--table-name test \
--key '{"id":{"S":"1"}}' \
--update-expression "REMOVE a SET b = a, c = b" \
--return-values ALL_NEW
```
Hasilnya adalah`{"id": "1", "b": 1, "c": 2}`. Meskipun `a` dihapus dan `b` ditugaskan kembali dalam ekspresi yang sama, kedua referensi menyelesaikan nilai aslinya.
**Example**
Jika Anda ingin mengubah nilai atribut dan menghapus atribut lain sepenuhnya, Anda dapat menggunakan tindakan SET dan REMOVE dalam satu pernyataan. Operasi ini akan mengurangi `Price` nilai menjadi 15 sekaligus menghapus `InStock` atribut dari item.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET Price = Price - :p REMOVE InStock" \
--expression-attribute-values '{":p": {"N":"15"}}' \
--return-values ALL_NEW
```
**Example**
Jika Anda ingin menambahkan ke daftar sambil juga mengubah nilai atribut lain, Anda bisa menggunakan dua tindakan SET dalam satu pernyataan. Operasi ini akan menambahkan “Nails” ke atribut daftar `RelatedItems` dan juga menetapkan nilai `Price` ke 21.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "SET RelatedItems[1] = :newValue, Price = :newPrice" \
--expression-attribute-values '{":newValue": {"S":"Nails"}, ":newPrice": {"N":"21"}}' \
--return-values ALL_NEW
```
# Kondisi dan filter ekspresi, operator, dan fungsi di DynamoDB
Untuk memanipulasi data dalam tabel DynamoDB, Anda menggunakan,, dan operasi`PutItem`. `UpdateItem` `DeleteItem` Untuk operasi manipulasi data ini, Anda dapat menentukan ekspresi kondisi untuk menentukan item mana yang harus dimodifikasi. Jika ekspresi kondisi dievaluasi ke true, operasi berhasil. Jika tidak, operasi gagal.
Bagian ini mencakup fungsi dan kata kunci bawaan untuk menulis ekspresi filter dan ekspresi kondisi di Amazon DynamoDB. Untuk informasi lebih rinci mengenai fungsi dan pemrograman dengan DynamoDB, lihat [Pemrograman dengan DynamoDB dan AWS SDKs](Programming.md) dan [Referensi API DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/).
**Topics**
+ [Sintaks untuk ekspresi filter dan kondisi](#Expressions.OperatorsAndFunctions.Syntax)
+ [Membuat perbandingan](#Expressions.OperatorsAndFunctions.Comparators)
+ [Fungsi](#Expressions.OperatorsAndFunctions.Functions)
+ [Evaluasi logika](#Expressions.OperatorsAndFunctions.LogicalEvaluations)
+ [Tanda kurung](#Expressions.OperatorsAndFunctions.Parentheses)
+ [Prioritas dalam kondisi](#Expressions.OperatorsAndFunctions.Precedence)
## Sintaks untuk ekspresi filter dan kondisi
Dalam ringkasan sintaks berikut, *operand* dapat berupa sebagai berikut:
+ Nama atribut tingkat atas, seperti `Id`, `Title`, `Description`, atau `ProductCategory`
+ Jalur dokumen yang mereferensikan atribut bersarang
```
condition-expression ::=
operand comparator operand
| operand BETWEEN operand AND operand
| operand IN ( operand (',' operand (, ...) ))
| function
| condition AND condition
| condition OR condition
| NOT condition
| ( condition )
comparator ::=
=
| <>
| <
| <=
| >
| >=
function ::=
attribute_exists (path)
| attribute_not_exists (path)
| attribute_type (path, type)
| begins_with (path, substr)
| contains (path, operand)
| size (path)
```
## Membuat perbandingan
Gunakan komparator ini untuk membandingkan operan dengan nilai tunggal:
+ `a = b`Benar jika *a* sama dengan*b*.
+ `a <> b`Benar jika *a* tidak sama dengan*b*.
+ `a < b`Benar jika *a* kurang dari*b*.
+ `a <= b`Benar jika *a* kurang dari atau sama dengan*b*.
+ `a > b`Benar jika *a* lebih besar dari*b*.
+ `a >= b`Benar jika *a* lebih besar dari atau sama dengan*b*.
Gunakan kata kunci `BETWEEN` dan `IN` untuk membandingkan operan dengan rentang nilai atau daftar nilai yang disebutkan:
+ `a BETWEEN b AND c`Benar jika *a* lebih besar dari atau sama dengan*b*, dan kurang dari atau sama dengan*c*.
+ `a IN (b, c, d) `— Benar jika *a* sama dengan nilai apa pun dalam daftar—misalnya, salah satu dari, *b**c*, atau. *d* Daftar ini dapat berisi hingga 100 nilai, dipisahkan dengan koma.
## Fungsi
Gunakan fungsi berikut untuk menentukan apakah atribut berada dalam item, atau untuk mengevaluasi nilai atribut. Nama fungsi ini peka huruf besar/kecil. Untuk atribut bersarang, Anda harus menyediakan jalur dokumen yang lengkap.
****
| Fungsi | Deskripsi |
| --- | --- |
| `attribute_exists (path)` | True jika item berisi atribut yang ditentukan oleh `path`. Contoh: Periksa apakah item dalam tabel `Product` memiliki tampilan tampak samping. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) |
| `attribute_not_exists (path)` | True jika atribut yang ditentukan oleh `path` tidak ada dalam item. Contoh: Periksa apakah item memiliki atribut `Manufacturer`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) |
| `attribute_type (path, type)` | True jika atribut di jalur yang ditentukan merupakan jenis daya tertentu. Parameter `type` harus salah satu dari hal berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Anda harus menggunakan nilai atribut ekspresi untuk parameter `type`. Contoh: Periksa apakah atribut `QuantityOnHand` berjenis Daftar. Dalam contoh ini, `:v_sub` adalah placeholder untuk string `L`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Anda harus menggunakan nilai atribut ekspresi untuk parameter `type`. |
| `begins_with (path, substr)` | True jika atribut yang ditentukan oleh `path` dimulai dengan substring tertentu. Contoh: Periksa apakah beberapa karakter pertama dari URL gambar tampilan depan adalah `http://`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Nilai atribut ekspresi `:v_sub` adalah placeholder untuk `http://`. |
| `contains (path, operand)` | True jika atribut yang ditentukan oleh `path` adalah salah satu hal berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Jika atribut yang ditentukan oleh `path` adalah `String`, `operand` harus `String`. Jika atribut yang ditentukan oleh `path` adalah `Set`, `operand` harus merupakan jenis elemen set. Jalan dan operan harus berbeda. Artinya, `contains (a, a)` mengembalikan kesalahan. Contoh: Periksa apakah atribut `Brand` berisi substring `Company`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Nilai atribut ekspresi `:v_sub` adalah placeholder untuk `Company`. Contoh: Periksa apakah produk tersedia dalam warna merah. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Nilai atribut ekspresi `:v_sub` adalah placeholder untuk `Red`. |
| `size (path)` | Mengembalikan angka yang mewakili ukuran atribut ini. Berikut ini adalah jenis daya yang valid untuk digunakan dengan `size`. Jika atribut adalah jenis `String`, `size` menampilkan panjang string. Contoh: Periksa apakah string `Brand` kurang dari atau sama dengan 20 karakter. Nilai atribut ekspresi `:v_sub` adalah placeholder untuk `20`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Jika atribut adalah jenis `Binary`, `size` menghasilkan jumlah byte dalam nilai atribut. Contoh: Misalkan item `ProductCatalog` memiliki atribut binari yang disebut `VideoClip` yang berisi video singkat dari produk yang digunakan. Ekspresi berikut memeriksa apakah `VideoClip` melebihi 64.000 byte. Nilai atribut ekspresi `:v_sub` adalah placeholder untuk `64000`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Jika atribut adalah jenis daya `Set`, `size` menghasilkan jumlah elemen dalam set. Contoh: Periksa apakah produk tersedia dalam lebih dari satu warna. Nilai atribut ekspresi `:v_sub` adalah placeholder untuk `1`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Jika atribut adalah jenis `List` atau `Map`, `size` menghasilkan jumlah elemen turunan. Contoh: Periksa apakah jumlah ulasan `OneStar` telah melampaui ambang batas tertentu. Nilai atribut ekspresi `:v_sub` adalah placeholder untuk `3`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) |
## Evaluasi logika
Gunakan kata kunci `AND`, `OR`, dan `NOT` untuk melakukan evaluasi logika. Dalam daftar berikut, *a* dan *b* mewakili kondisi yang akan dievaluasi.
+ `a AND b`Benar jika *a* dan *b* keduanya benar.
+ `a OR b`Benar jika salah satu *a* atau *b* (atau keduanya) benar.
+ `NOT a`Benar jika *a* salah. Salah jika *a* benar.
Berikut ini adalah contoh kode AND dalam suatu operasi.
`dynamodb-local (*)> select * from exprtest where a > 3 and a < 5;`
## Tanda kurung
Gunakan tanda kurung untuk mengubah prioritas evaluasi logis. Misalnya, anggaplah bahwa kondisi *a* dan *b* benar, dan kondisi *c* itu salah. Ekspresi berikut bernilai True:
+ `a OR b AND c`
Namun, jika Anda mengapit kondisi dalam tanda kurung, kondisi tersebut akan dievaluasi terlebih dahulu. Misalnya, nilai berikut bernilai false:
+ `(a OR b) AND c`
**catatan**
Anda dapat menyarangkan tanda kurung dalam sebuah ekspresi. Bagian paling dalam akan dievaluasi terlebih dahulu.
Berikut ini adalah contoh kode dengan tanda kurung dalam evaluasi logis.
`dynamodb-local (*)> select * from exprtest where attribute_type(b, string) or ( a = 5 and c = “coffee”);`
## Prioritas dalam kondisi
DynamoDB mengevaluasi kondisi dari kiri ke kanan menggunakan aturan prioritas berikut:
+ `= <> < <= > >=`
+ `IN`
+ `BETWEEN`
+ `attribute_exists attribute_not_exists begins_with contains`
+ Tanda kurung
+ `NOT`
+ `AND`
+ `OR`
# Contoh CLI ekspresi kondisi DynamoDB
Berikut ini adalah beberapa AWS Command Line Interface (AWS CLI) contoh penggunaan ekspresi kondisi. Contoh-contoh ini berdasarkan tabel `ProductCatalog`, yang diperkenalkan dalam [Mengacu pada atribut item saat menggunakan ekspresi di DynamoDB](Expressions.Attributes.md). Kunci partisi untuk tabel ini adalah `Id`, dan tidak ada kunci urutan. Operasi `PutItem` berikut membuat item `ProductCatalog` sampel yang dirujuk oleh contoh.
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item file://item.json
```
Argumen untuk `--item` disimpan dalam file `item.json`. (Untuk kemudahan, hanya beberapa atribut item yang digunakan.)
```
{
"Id": {"N": "456" },
"ProductCategory": {"S": "Sporting Goods" },
"Price": {"N": "650" }
}
```
**Topics**
+ [Put bersyarat](#Expressions.ConditionExpressions.PreventingOverwrites)
+ [Penghapusan bersyarat](#Expressions.ConditionExpressions.AdvancedComparisons)
+ [Pembaruan bersyarat](#Expressions.ConditionExpressions.SimpleComparisons)
+ [Contoh ekspresi bersyarat](#Expressions.ConditionExpressions.ConditionalExamples)
## Put bersyarat
Operasi `PutItem` menimpa item dengan kunci primer yang sama (jika ada). Jika Anda ingin menghindari hal ini, gunakan ekspresi kondisi. Hal ini memungkinkan penulisan untuk dilanjutkan hanya jika item yang dimaksud belum memiliki kunci primer yang sama.
Contoh berikut digunakan `attribute_not_exists()` untuk memeriksa apakah kunci primer ada dalam tabel sebelum mencoba operasi tulis.
**catatan**
Jika kunci utama Anda terdiri dari kedua kunci partisi (pk) dan kunci sortir (sk), parameter akan memeriksa apakah `attribute_not_exists(pk)` DAN `attribute_not_exists(sk)` mengevaluasi menjadi benar atau salah sebagai pernyataan keseluruhan sebelum mencoba operasi tulis.
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item file://item.json \
--condition-expression "attribute_not_exists(Id)"
```
Jika ekspresi kondisi bernilai false, DynamoDB mengembalikan pesan kesalahan berikut: Permintaan bersyarat gagal.
**catatan**
Untuk informasi selengkapnya tentang fungsi `attribute_not_exists` dan lainnya, lihat [Kondisi dan filter ekspresi, operator, dan fungsi di DynamoDB](Expressions.OperatorsAndFunctions.md).
## Penghapusan bersyarat
Untuk melakukan penghapusan bersyarat, Anda menggunakan operasi `DeleteItem` dengan ekspresi kondisi. Ekspresi kondisi harus bernilai true agar operasi berhasil; jika tidak, operasi akan gagal.
Pertimbangkan item yang didefinisikan di atas.
Misalkan Anda ingin menghapus item, tetapi hanya dalam kondisi berikut:
+ `ProductCategory` adalah "Alat Olahraga" atau "Perlengkapan Berkebun."
+ `Price` adalah antara 500 dan 600.
Contoh berikut mencoba menghapus versi item.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"456"}}' \
--condition-expression "(ProductCategory IN (:cat1, :cat2)) and (Price between :lo and :hi)" \
--expression-attribute-values file://values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":cat1": {"S": "Sporting Goods"},
":cat2": {"S": "Gardening Supplies"},
":lo": {"N": "500"},
":hi": {"N": "600"}
}
```
**catatan**
Dalam ekspresi kondisi, `:` (karakter titik dua) menunjukkan *nilai atribut ekspresi*—placeholder untuk nilai aktual. Untuk informasi selengkapnya, lihat [Menggunakan nilai atribut ekspresi di DynamoDB](Expressions.ExpressionAttributeValues.md).
Untuk informasi selengkapnya tentang `IN`, `AND`, dan kata kunci lainnya, lihat [Kondisi dan filter ekspresi, operator, dan fungsi di DynamoDB](Expressions.OperatorsAndFunctions.md).
Dalam contoh ini, perbandingan `ProductCategory` bernilai true, tetapi perbandingan `Price` bernilai false. Hal ini menyebabkan ekspresi kondisi untuk bernilai false dan operasi `DeleteItem` gagal.
## Pembaruan bersyarat
Untuk melakukan pembaruan bersyarat, Anda menggunakan operasi `UpdateItem` dengan ekspresi kondisi. Ekspresi kondisi harus bernilai true agar operasi berhasil; jika tidak, operasi akan gagal.
**catatan**
`UpdateItem` juga mendukung *ekspresi pembaruan*, di mana Anda menentukan modifikasi yang ingin Anda buat ke item. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi pembaruan di DynamoDB](Expressions.UpdateExpressions.md).
Misalkan Anda mulai dengan item yang didefinisikan di atas.
Contoh berikut melakukan operasi `UpdateItem`. Operasi ini mencoba untuk mengurangi `Price` dari produk sebesar 75—tetapi ekspresi kondisi mencegah pembaruan jika `Price` saat ini kurang dari atau sama dengan 500.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--update-expression "SET Price = Price - :discount" \
--condition-expression "Price > :limit" \
--expression-attribute-values file://values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":discount": { "N": "75"},
":limit": {"N": "500"}
}
```
Jika `Price` awal adalah 650, operasi `UpdateItem` mengurangi `Price` menjadi 575. Jika Anda menjalankan operasi `UpdateItem` lagi, `Price` berkurang menjadi 500. Jika Anda menjalankannya untuk kali ketiga, ekspresi kondisi bernilai false, dan pembaruan gagal.
**catatan**
Dalam ekspresi kondisi, `:` (karakter titik dua) menunjukkan *nilai atribut ekspresi*—placeholder untuk nilai aktual. Untuk informasi selengkapnya, lihat [Menggunakan nilai atribut ekspresi di DynamoDB](Expressions.ExpressionAttributeValues.md).
Untuk informasi selengkapnya tentang "*>*" dan operator lainnya, lihat [Kondisi dan filter ekspresi, operator, dan fungsi di DynamoDB](Expressions.OperatorsAndFunctions.md).
## Contoh ekspresi bersyarat
Untuk informasi selengkapnya tentang fungsi yang digunakan dalam contoh berikut, lihat [Kondisi dan filter ekspresi, operator, dan fungsi di DynamoDB](Expressions.OperatorsAndFunctions.md). Jika Anda ingin tahu lebih banyak tentang cara menentukan jenis atribut yang berbeda dalam suatu ekspresi, lihat [Mengacu pada atribut item saat menggunakan ekspresi di DynamoDB](Expressions.Attributes.md).
### Memeriksa atribut dalam item
Anda dapat memeriksa keberadaan (atau ketiadaan) atribut apa pun. Jika ekspresi kondisi bernilai true, operasi berhasil; jika tidak, operasi akan gagal.
Contoh berikut menggunakan `attribute_not_exists` untuk menghapus produk hanya jika operasi tidak memiliki atribut `Price`.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_not_exists(Price)"
```
DynamoDB juga menyediakan fungsi `attribute_exists`. Contoh berikut menghapus produk hanya jika operasi telah menerima ulasan buruk.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_exists(ProductReviews.OneStar)"
```
### Memeriksa jenis atribut
Anda dapat memeriksa jenis daya nilai atribut dengan menggunakan fungsi `attribute_type`. Jika ekspresi kondisi bernilai true, operasi berhasil; jika tidak, operasi akan gagal.
Contoh berikut menggunakan `attribute_type` untuk menghapus produk hanya jika memiliki atribut `Color` jenis Set String.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_type(Color, :v_sub)" \
--expression-attribute-values file://expression-attribute-values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam expression-attribute-values file.json.
```
{
":v_sub":{"S":"SS"}
}
```
### Memeriksa nilai awal string
Anda dapat memeriksa apakah nilai atribut String dimulai dengan substring tertentu dengan menggunakan fungsi `begins_with`. Jika ekspresi kondisi bernilai true, operasi berhasil; jika tidak, operasi akan gagal.
Contoh berikut menggunakan `begins_with` untuk menghapus produk hanya jika elemen `FrontView` dari peta `Pictures` dimulai dengan nilai tertentu.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "begins_with(Pictures.FrontView, :v_sub)" \
--expression-attribute-values file://expression-attribute-values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam expression-attribute-values file.json.
```
{
":v_sub":{"S":"http://"}
}
```
### Memeriksa elemen dalam set
Anda dapat memeriksa elemen dalam set atau mencari substring dalam string dengan menggunakan fungsi `contains`. Jika ekspresi kondisi bernilai true, operasi berhasil; jika tidak, operasi akan gagal.
Contoh berikut menggunakan `contains` untuk menghapus produk hanya jika elemen Set String `Color` memiliki elemen dengan nilai tertentu.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "contains(Color, :v_sub)" \
--expression-attribute-values file://expression-attribute-values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam expression-attribute-values file.json.
```
{
":v_sub":{"S":"Red"}
}
```
### Memeriksa ukuran nilai atribut
Anda dapat memeriksa ukuran nilai atribut dengan menggunakan fungsi `size`. Jika ekspresi kondisi bernilai true, operasi berhasil; jika tidak, operasi akan gagal.
Contoh berikut menggunakan `size` untuk menghapus produk hanya jika ukuran atribut Binari `VideoClip` lebih besar dari `64000` byte.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "size(VideoClip) > :v_sub" \
--expression-attribute-values file://expression-attribute-values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam expression-attribute-values file.json.
```
{
":v_sub":{"N":"64000"}
}
```
# Menggunakan time to live (TTL) di DynamoDB
Time To Live (TTL) untuk DynamoDB adalah metode hemat biaya untuk menghapus item yang tidak lagi relevan. TTL memungkinkan Anda untuk menentukan stempel waktu kedaluwarsa per item yang menunjukkan kapan item tidak lagi diperlukan. DynamoDB secara otomatis menghapus item yang kedaluwarsa dalam beberapa hari dari waktu kedaluwarsa, tanpa menghabiskan throughput penulisan.
Untuk menggunakan TTL, pertama-tama aktifkan pada tabel dan kemudian tentukan atribut tertentu untuk menyimpan stempel waktu kedaluwarsa TTL. Stempel waktu harus disimpan sebagai tipe data [Angka](HowItWorks.NamingRulesDataTypes.md#HowItWorks.DataTypes) dalam [format waktu epoch Unix](https://en.wikipedia.org/wiki/Unix_time) pada perincian detik. Item dengan atribut TTL yang bukan tipe Number diabaikan oleh proses TTL. Setiap kali item dibuat atau diperbarui, Anda dapat menghitung waktu kedaluwarsa dan menyimpannya di atribut TTL.
Item dengan atribut TTL yang valid dan kedaluwarsa dapat dihapus oleh sistem kapan saja, biasanya dalam beberapa hari setelah kedaluwarsa. Anda masih dapat memperbarui item kedaluwarsa yang menunggu penghapusan, termasuk mengubah atau menghapus atribut TTL mereka. Saat memperbarui item yang kedaluwarsa, kami menyarankan Anda menggunakan ekspresi kondisi untuk memastikan item tersebut belum dihapus selanjutnya. Gunakan ekspresi filter untuk menghapus item kedaluwarsa dari hasil [Pindai](Scan.md#Scan.FilterExpression) dan [Kueri](Query.FilterExpression.md).
Item yang dihapus bekerja sama dengan yang dihapus melalui operasi penghapusan tipikal. Setelah dihapus, item masuk ke DynamoDB Streams sebagai penghapusan layanan, bukan penghapusan pengguna, dan dihapus dari indeks sekunder lokal dan indeks sekunder global seperti operasi penghapusan lainnya.
Jika Anda menggunakan [Tabel Global versi 2019.11.21 (Saat ini)](GlobalTables.md) dari tabel global dan Anda juga menggunakan fitur TTL, DynamoDB mereplikasi penghapusan TTL ke semua tabel replika. Penghapusan TTL awal tidak menggunakan Write Capacity Units (WCU) di wilayah di mana TTL kedaluwarsa terjadi. Namun, penghapusan TTL yang direplikasi ke tabel replika menggunakan Unit Kapasitas Tulis yang direplikasi saat menggunakan kapasitas yang disediakan, atau Unit Tulis Replikasi saat menggunakan mode kapasitas sesuai permintaan, di setiap wilayah replika dan biaya yang berlaku akan berlaku.
Untuk informasi selengkapnya tentang TTL, lihat topik berikut:
**Topics**
+ [Aktifkan waktu untuk hidup (TTL) di DynamoDB](time-to-live-ttl-how-to.md)
+ [Menghitung waktu untuk hidup (TTL) di DynamoDB](time-to-live-ttl-before-you-start.md)
+ [Bekerja dengan item kedaluwarsa dan waktu untuk hidup (TTL)](ttl-expired-items.md)
# Aktifkan waktu untuk hidup (TTL) di DynamoDB
**catatan**
Untuk membantu debugging dan verifikasi pengoperasian fitur TTL yang benar, nilai yang disediakan untuk item TTL dicatat dalam plaintext di log diagnostik DynamoDB.
Anda dapat mengaktifkan TTL di Amazon DynamoDB Console AWS Command Line Interface , (), atau menggunakan AWS CLI Referensi [Amazon DynamoDB API dengan salah satu yang seharusnya](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/). AWS SDKs Dibutuhkan sekitar satu jam untuk mengaktifkan TTL di semua partisi.
## Aktifkan DynamoDB TTL menggunakan konsol AWS
1. Masuk ke Konsol Manajemen AWS dan buka konsol DynamoDB di. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Pilih **Tabel**, lalu pilih tabel yang ingin Anda ubah.
1. Di tab **Pengaturan tambahan**, di bagian **Time to Live (TTL)**, pilih Aktifkan untuk **mengaktifkan** TTL.
1. Saat mengaktifkan TTL pada tabel, DynamoDB mengharuskan Anda mengidentifikasi nama atribut tertentu yang akan dicari layanan saat menentukan apakah suatu item memenuhi syarat untuk kedaluwarsa. Nama atribut TTL, yang ditunjukkan di bawah ini, peka huruf besar/kecil dan harus cocok dengan atribut yang ditentukan dalam operasi baca dan tulis Anda. Ketidakcocokan akan menyebabkan item yang kedaluwarsa tidak dihapus. Mengganti nama atribut TTL mengharuskan Anda untuk menonaktifkan TTL dan kemudian mengaktifkannya kembali dengan atribut baru di masa mendatang. TTL akan terus memproses penghapusan selama kurang lebih 30 menit setelah dinonaktifkan. TTL harus dikonfigurasi ulang pada tabel yang dipulihkan.
![\[Nama atribut TTL case-sensitive yang DynamoDB gunakan untuk menentukan kelayakan item untuk kedaluwarsa.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/EnableTTL-Settings.png)
1. (Opsional) Anda dapat melakukan tes dengan mensimulasikan tanggal dan waktu kedaluwarsa dan mencocokkan beberapa item. Ini memberi Anda daftar sampel item dan mengonfirmasi bahwa ada item yang berisi nama atribut TTL yang disediakan bersama dengan waktu kedaluwarsa.
Setelah TTL diaktifkan, atribut TTL ditandai **TTL** saat Anda melihat item di konsol DynamoDB. Anda dapat melihat tanggal dan waktu kedaluwarsa suatu item dengan mengarahkan kursor ke atribut tersebut.
## Aktifkan DynamoDB TTL menggunakan API
------
#### [ Python ]
Anda dapat mengaktifkan TTL dengan kode, menggunakan [UpdateTimeToLive](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/update_time_to_live.html)operasi.
```
import boto3
def enable_ttl(table_name, ttl_attribute_name):
"""
Enables TTL on DynamoDB table for a given attribute name
on success, returns a status code of 200
on error, throws an exception
:param table_name: Name of the DynamoDB table
:param ttl_attribute_name: The name of the TTL attribute being provided to the table.
"""
try:
dynamodb = boto3.client('dynamodb')
# Enable TTL on an existing DynamoDB table
response = dynamodb.update_time_to_live(
TableName=table_name,
TimeToLiveSpecification={
'Enabled': True,
'AttributeName': ttl_attribute_name
}
)
# In the returned response, check for a successful status code.
if response['ResponseMetadata']['HTTPStatusCode'] == 200:
print("TTL has been enabled successfully.")
else:
print(f"Failed to enable TTL, status code {response['ResponseMetadata']['HTTPStatusCode']}")
except Exception as ex:
print("Couldn't enable TTL in table %s. Here's why: %s" % (table_name, ex))
raise
# your values
enable_ttl('your-table-name', 'expirationDate')
```
Anda dapat mengonfirmasi TTL diaktifkan dengan menggunakan [DescribeTimeToLive](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/describe_time_to_live.html)operasi, yang menggambarkan status TTL di atas meja. `TimeToLive`Statusnya adalah salah satu `ENABLED` atau`DISABLED`.
```
# create a DynamoDB client
dynamodb = boto3.client('dynamodb')
# set the table name
table_name = 'YourTable'
# describe TTL
response = dynamodb.describe_time_to_live(TableName=table_name)
```
------
#### [ JavaScript ]
Anda dapat mengaktifkan TTL dengan kode, menggunakan [UpdateTimeToLiveCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-dynamodb/Class/UpdateTimeToLiveCommand/)operasi.
```
import { DynamoDBClient, UpdateTimeToLiveCommand } from "@aws-sdk/client-dynamodb";
const enableTTL = async (tableName, ttlAttribute) => {
const client = new DynamoDBClient({});
const params = {
TableName: tableName,
TimeToLiveSpecification: {
Enabled: true,
AttributeName: ttlAttribute
}
};
try {
const response = await client.send(new UpdateTimeToLiveCommand(params));
if (response.$metadata.httpStatusCode === 200) {
console.log(`TTL enabled successfully for table ${tableName}, using attribute name ${ttlAttribute}.`);
} else {
console.log(`Failed to enable TTL for table ${tableName}, response object: ${response}`);
}
return response;
} catch (e) {
console.error(`Error enabling TTL: ${e}`);
throw e;
}
};
// call with your own values
enableTTL('ExampleTable', 'exampleTtlAttribute');
```
------
## Aktifkan Waktu untuk Hidup menggunakan AWS CLI
1. Aktifkan TTL pada tabel `TTLExample`.
```
aws dynamodb update-time-to-live --table-name TTLExample --time-to-live-specification "Enabled=true, AttributeName=ttl"
```
1. Jelaskan TTL pada tabel `TTLExample`.
```
aws dynamodb describe-time-to-live --table-name TTLExample
{
"TimeToLiveDescription": {
"AttributeName": "ttl",
"TimeToLiveStatus": "ENABLED"
}
}
```
1. Tambahkan item ke tabel `TTLExample` dengan atribut Waktu untuk Tayang yang diatur menggunakan shell BASH dan AWS CLI.
```
EXP=`date -d '+5 days' +%s`
aws dynamodb put-item --table-name "TTLExample" --item '{"id": {"N": "1"}, "ttl": {"N": "'$EXP'"}}'
```
Contoh ini dimulai dengan tanggal saat ini dan menambahkan 5 hari untuk membuat waktu kedaluwarsa. Kemudian, contoh ini mengubah waktu kedaluwarsa menjadi format jangka waktu yang pada akhirnya menambahkan item ke "`TTLExample`".
**catatan**
Salah satu cara untuk menetapkan nilai kedaluwarsa Waktu untuk Tayang adalah dengan menghitung jumlah detik yang ditambahkan ke waktu kedaluwarsa. Misalnya, 5 hari adalah 432.000 detik. Namun, seringkali lebih baik memulai dengan suatu tanggal dan bekerja dari sana.
Cukup mudah untuk mendapatkan waktu saat ini dalam format jangka waktu, seperti pada contoh berikut.
+ Terminal Linux: `date +%s`
+ Python: `import time; int(time.time())`
+ Java: `System.currentTimeMillis() / 1000L`
+ JavaScript: `Math.floor(Date.now() / 1000)`
## Aktifkan DynamoDB TTL menggunakan CloudFormation
```
AWSTemplateFormatVersion: "2010-09-09"
Resources:
TTLExampleTable:
Type: AWS::DynamoDB::Table
Description: "A DynamoDB table with TTL Specification enabled"
Properties:
AttributeDefinitions:
- AttributeName: "Album"
AttributeType: "S"
- AttributeName: "Artist"
AttributeType: "S"
KeySchema:
- AttributeName: "Album"
KeyType: "HASH"
- AttributeName: "Artist"
KeyType: "RANGE"
ProvisionedThroughput:
ReadCapacityUnits: "5"
WriteCapacityUnits: "5"
TimeToLiveSpecification:
AttributeName: "TTLExampleAttribute"
Enabled: true
```
Detail tambahan tentang penggunaan TTL dalam CloudFormation template Anda dapat ditemukan [di sini](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-dynamodb-table-timetolivespecification.html).
# Menghitung waktu untuk hidup (TTL) di DynamoDB
Cara umum untuk mengimplementasikan TTL adalah dengan menetapkan waktu kedaluwarsa untuk item berdasarkan kapan mereka dibuat atau terakhir diperbarui. Ini dapat dilakukan dengan menambahkan waktu ke `createdAt` dan `updatedAt` stempel waktu. Misalnya, TTL untuk item yang baru dibuat dapat diatur `createdAt` ke\$190 hari. Saat item diperbarui, TTL dapat dihitung ulang menjadi \$190 hari. `updatedAt`
Waktu kedaluwarsa yang dihitung harus dalam format epoch, dalam hitungan detik. Untuk dipertimbangkan untuk kedaluwarsa dan penghapusan, TTL tidak boleh lebih dari lima tahun yang lalu. Jika Anda menggunakan format lain, proses TTL akan mengabaikan item. Jika Anda mengatur waktu kedaluwarsa ke sometime in the future ketika Anda ingin item kedaluwarsa, item akan kedaluwarsa setelah waktu itu. Misalnya, Anda menetapkan waktu kedaluwarsa ke 1724241326 (yaitu Senin, 21 Agustus 2024 11:55:26 (UTC)). Item kedaluwarsa setelah waktu yang ditentukan. Tidak ada durasi TTL minimum. Anda dapat mengatur waktu kedaluwarsa ke waktu masa depan, seperti 5 menit dari waktu saat ini. Namun, DynamoDB biasanya menghapus item kedaluwarsa dalam waktu 48 jam setelah waktu kedaluwarsa, tidak segera ketika item kedaluwarsa.
**Topics**
+ [Buat item dan atur Waktu ke Hidup](#time-to-live-ttl-before-you-start-create)
+ [Perbarui item dan segarkan Waktu untuk Hidup](#time-to-live-ttl-before-you-start-update)
## Buat item dan atur Waktu ke Hidup
Contoh berikut menunjukkan bagaimana menghitung waktu kedaluwarsa saat membuat item baru, menggunakan `expireAt` sebagai nama atribut TTL. Pernyataan penugasan memperoleh waktu saat ini sebagai variabel. Dalam contoh, waktu kedaluwarsa dihitung sebagai 90 hari dari waktu saat ini. Waktu kemudian dikonversi ke format epoch dan disimpan sebagai tipe data integer dalam atribut TTL.
Contoh kode berikut menunjukkan cara membuat item dengan TTL.
------
#### [ Java ]
**SDK untuk Java 2.x**
```
package com.amazon.samplelib.ttl;
import com.amazon.samplelib.CodeSampleUtils;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.PutItemResponse;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
/**
* Creates an item in a DynamoDB table with TTL attributes.
* This class demonstrates how to add TTL expiration timestamps to DynamoDB items.
*/
public class CreateTTL {
private static final String USAGE =
"""
Usage:
Where:
tableName - The Amazon DynamoDB table being queried.
primaryKey - The name of the primary key. Also known as the hash or partition key.
sortKey - The name of the sort key. Also known as the range attribute.
region (optional) - The AWS region that the Amazon DynamoDB table is located in. (Default: us-east-1)
""";
private static final int DAYS_TO_EXPIRE = 90;
private static final int SECONDS_PER_DAY = 24 * 60 * 60;
private static final String PRIMARY_KEY_ATTR = "primaryKey";
private static final String SORT_KEY_ATTR = "sortKey";
private static final String CREATION_DATE_ATTR = "creationDate";
private static final String EXPIRE_AT_ATTR = "expireAt";
private static final String SUCCESS_MESSAGE = "%s PutItem operation with TTL successful.";
private static final String TABLE_NOT_FOUND_ERROR = "Error: The Amazon DynamoDB table \"%s\" can't be found.";
private final DynamoDbClient dynamoDbClient;
/**
* Constructs a CreateTTL instance with the specified DynamoDB client.
*
* @param dynamoDbClient The DynamoDB client to use
*/
public CreateTTL(final DynamoDbClient dynamoDbClient) {
this.dynamoDbClient = dynamoDbClient;
}
/**
* Constructs a CreateTTL with a default DynamoDB client.
*/
public CreateTTL() {
this.dynamoDbClient = null;
}
/**
* Main method to demonstrate creating an item with TTL.
*
* @param args Command line arguments
*/
public static void main(final String[] args) {
try {
int result = new CreateTTL().processArgs(args);
System.exit(result);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
/**
* Process command line arguments and create an item with TTL.
*
* @param args Command line arguments
* @return 0 if successful, non-zero otherwise
* @throws ResourceNotFoundException If the table doesn't exist
* @throws DynamoDbException If an error occurs during the operation
* @throws IllegalArgumentException If arguments are invalid
*/
public int processArgs(final String[] args) {
// Argument validation (remove or replace this line when reusing this code)
CodeSampleUtils.validateArgs(args, new int[] {3, 4}, USAGE);
final String tableName = args[0];
final String primaryKey = args[1];
final String sortKey = args[2];
final Region region = Optional.ofNullable(args.length > 3 ? args[3] : null)
.map(Region::of)
.orElse(Region.US_EAST_1);
try (DynamoDbClient ddb = dynamoDbClient != null
? dynamoDbClient
: DynamoDbClient.builder().region(region).build()) {
final CreateTTL createTTL = new CreateTTL(ddb);
createTTL.createItemWithTTL(tableName, primaryKey, sortKey);
return 0;
} catch (Exception e) {
throw e;
}
}
/**
* Creates an item in the specified table with TTL attributes.
*
* @param tableName The name of the table
* @param primaryKeyValue The value for the primary key
* @param sortKeyValue The value for the sort key
* @return The response from the PutItem operation
* @throws ResourceNotFoundException If the table doesn't exist
* @throws DynamoDbException If an error occurs during the operation
*/
public PutItemResponse createItemWithTTL(
final String tableName, final String primaryKeyValue, final String sortKeyValue) {
// Get current time in epoch second format
final long createDate = System.currentTimeMillis() / 1000;
// Calculate expiration time 90 days from now in epoch second format
final long expireDate = createDate + (DAYS_TO_EXPIRE * SECONDS_PER_DAY);
final Map itemMap = new HashMap<>();
itemMap.put(
PRIMARY_KEY_ATTR, AttributeValue.builder().s(primaryKeyValue).build());
itemMap.put(SORT_KEY_ATTR, AttributeValue.builder().s(sortKeyValue).build());
itemMap.put(
CREATION_DATE_ATTR,
AttributeValue.builder().n(String.valueOf(createDate)).build());
itemMap.put(
EXPIRE_AT_ATTR,
AttributeValue.builder().n(String.valueOf(expireDate)).build());
final PutItemRequest request =
PutItemRequest.builder().tableName(tableName).item(itemMap).build();
try {
final PutItemResponse response = dynamoDbClient.putItem(request);
System.out.println(String.format(SUCCESS_MESSAGE, tableName));
return response;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
}
}
```
+ Untuk detail API, lihat [PutItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/PutItem)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
```
import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";
export function createDynamoDBItem(table_name, region, partition_key, sort_key) {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
// Get the current time in epoch second format
const current_time = Math.floor(new Date().getTime() / 1000);
// Calculate the expireAt time (90 days from now) in epoch second format
const expire_at = Math.floor((new Date().getTime() + 90 * 24 * 60 * 60 * 1000) / 1000);
// Create DynamoDB item
const item = {
'partitionKey': {'S': partition_key},
'sortKey': {'S': sort_key},
'createdAt': {'N': current_time.toString()},
'expireAt': {'N': expire_at.toString()}
};
const putItemCommand = new PutItemCommand({
TableName: table_name,
Item: item,
ProvisionedThroughput: {
ReadCapacityUnits: 1,
WriteCapacityUnits: 1,
},
});
client.send(putItemCommand, function(err, data) {
if (err) {
console.log("Exception encountered when creating item %s, here's what happened: ", data, err);
throw err;
} else {
console.log("Item created successfully: %s.", data);
return data;
}
});
}
// Example usage (commented out for testing)
// createDynamoDBItem('your-table-name', 'us-east-1', 'your-partition-key-value', 'your-sort-key-value');
```
+ Untuk detail API, lihat [PutItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/PutItemCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
```
from datetime import datetime, timedelta
import boto3
def create_dynamodb_item(table_name, region, primary_key, sort_key):
"""
Creates a DynamoDB item with an attached expiry attribute.
:param table_name: Table name for the boto3 resource to target when creating an item
:param region: string representing the AWS region. Example: `us-east-1`
:param primary_key: one attribute known as the partition key.
:param sort_key: Also known as a range attribute.
:return: Void (nothing)
"""
try:
dynamodb = boto3.resource("dynamodb", region_name=region)
table = dynamodb.Table(table_name)
# Get the current time in epoch second format
current_time = int(datetime.now().timestamp())
# Calculate the expiration time (90 days from now) in epoch second format
expiration_time = int((datetime.now() + timedelta(days=90)).timestamp())
item = {
"primaryKey": primary_key,
"sortKey": sort_key,
"creationDate": current_time,
"expireAt": expiration_time,
}
response = table.put_item(Item=item)
print("Item created successfully.")
return response
except Exception as e:
print(f"Error creating item: {e}")
raise e
# Use your own values
create_dynamodb_item(
"your-table-name", "us-west-2", "your-partition-key-value", "your-sort-key-value"
)
```
+ Untuk detail API, lihat [PutItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem)di *AWS SDK for Python (Boto3) Referensi* API.
------
## Perbarui item dan segarkan Waktu untuk Hidup
Contoh ini merupakan kelanjutan dari yang dari [bagian sebelumnya](#time-to-live-ttl-before-you-start-create). Waktu kedaluwarsa dapat dihitung ulang jika item diperbarui. Contoh berikut menghitung ulang `expireAt` stempel waktu menjadi 90 hari dari waktu saat ini.
Contoh kode berikut menunjukkan cara memperbarui TTL item.
------
#### [ Java ]
**SDK untuk Java 2.x**
Perbarui TTL pada item DynamoDB yang ada dalam tabel.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemResponse;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
public UpdateItemResponse updateItemWithTTL(
final String tableName, final String primaryKeyValue, final String sortKeyValue) {
// Get current time in epoch second format
final long currentTime = System.currentTimeMillis() / 1000;
// Calculate expiration time 90 days from now in epoch second format
final long expireDate = currentTime + (DAYS_TO_EXPIRE * SECONDS_PER_DAY);
// Create the key map for the item to update
final Map keyMap = new HashMap<>();
keyMap.put(PRIMARY_KEY_ATTR, AttributeValue.builder().s(primaryKeyValue).build());
keyMap.put(SORT_KEY_ATTR, AttributeValue.builder().s(sortKeyValue).build());
// Create the expression attribute values
final Map expressionAttributeValues = new HashMap<>();
expressionAttributeValues.put(
":c", AttributeValue.builder().n(String.valueOf(currentTime)).build());
expressionAttributeValues.put(
":e", AttributeValue.builder().n(String.valueOf(expireDate)).build());
final UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(keyMap)
.updateExpression(UPDATE_EXPRESSION)
.expressionAttributeValues(expressionAttributeValues)
.build();
try {
final UpdateItemResponse response = dynamoDbClient.updateItem(request);
System.out.println(String.format(SUCCESS_MESSAGE, tableName));
return response;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
}
```
+ Untuk detail API, lihat [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
```
import { DynamoDBClient, UpdateItemCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
export const updateItem = async (tableName, partitionKey, sortKey, region = 'us-east-1') => {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
const currentTime = Math.floor(Date.now() / 1000);
const expireAt = Math.floor((Date.now() + 90 * 24 * 60 * 60 * 1000) / 1000);
const params = {
TableName: tableName,
Key: marshall({
partitionKey: partitionKey,
sortKey: sortKey
}),
UpdateExpression: "SET updatedAt = :c, expireAt = :e",
ExpressionAttributeValues: marshall({
":c": currentTime,
":e": expireAt
}),
};
try {
const data = await client.send(new UpdateItemCommand(params));
const responseData = unmarshall(data.Attributes);
console.log("Item updated successfully: %s", responseData);
return responseData;
} catch (err) {
console.error("Error updating item:", err);
throw err;
}
}
// Example usage (commented out for testing)
// updateItem('your-table-name', 'your-partition-key-value', 'your-sort-key-value');
```
+ Untuk detail API, lihat [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
```
from datetime import datetime, timedelta
import boto3
def update_dynamodb_item(table_name, region, primary_key, sort_key):
"""
Update an existing DynamoDB item with a TTL.
:param table_name: Name of the DynamoDB table
:param region: AWS Region of the table - example `us-east-1`
:param primary_key: one attribute known as the partition key.
:param sort_key: Also known as a range attribute.
:return: Void (nothing)
"""
try:
# Create the DynamoDB resource.
dynamodb = boto3.resource("dynamodb", region_name=region)
table = dynamodb.Table(table_name)
# Get the current time in epoch second format
current_time = int(datetime.now().timestamp())
# Calculate the expireAt time (90 days from now) in epoch second format
expire_at = int((datetime.now() + timedelta(days=90)).timestamp())
table.update_item(
Key={"partitionKey": primary_key, "sortKey": sort_key},
UpdateExpression="set updatedAt=:c, expireAt=:e",
ExpressionAttributeValues={":c": current_time, ":e": expire_at},
)
print("Item updated successfully.")
except Exception as e:
print(f"Error updating item: {e}")
# Replace with your own values
update_dynamodb_item(
"your-table-name", "us-west-2", "your-partition-key-value", "your-sort-key-value"
)
```
+ Untuk detail API, lihat [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)di *AWS SDK for Python (Boto3) Referensi* API.
------
Contoh TTL yang dibahas dalam pendahuluan ini menunjukkan metode untuk memastikan hanya item yang baru diperbarui disimpan dalam tabel. Item yang diperbarui memiliki masa pakainya diperpanjang, sedangkan item yang tidak diperbarui pasca-pembuatan kedaluwarsa dan dihapus tanpa biaya, mengurangi penyimpanan dan mempertahankan tabel bersih.
# Bekerja dengan item kedaluwarsa dan waktu untuk hidup (TTL)
Item kedaluwarsa yang tertunda penghapusan dapat difilter dari operasi baca dan tulis. Ini berguna dalam skenario ketika data kedaluwarsa tidak lagi valid dan tidak boleh digunakan. Jika tidak difilter, mereka akan terus ditampilkan dalam operasi baca dan tulis sampai dihapus oleh proses latar belakang.
**catatan**
Barang-barang ini masih diperhitungkan untuk penyimpanan dan biaya baca sampai dihapus.
Penghapusan TTL dapat diidentifikasi di DynamoDB Streams, tetapi hanya di Wilayah tempat penghapusan terjadi. Penghapusan TTL yang direplikasi ke wilayah tabel global tidak dapat diidentifikasi dalam aliran DynamoDB di wilayah tempat penghapusan direplikasi.
## Filter item kedaluwarsa dari operasi baca
Untuk operasi baca seperti [Pindai](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html) dan [Kueri](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html), ekspresi filter dapat memfilter item kedaluwarsa yang menunggu penghapusan. Seperti yang ditunjukkan dalam cuplikan kode berikut, ekspresi filter dapat menyaring item di mana waktu TTL sama dengan atau kurang dari waktu saat ini. Misalnya, kode SDK Python menyertakan pernyataan penugasan yang memperoleh waktu saat ini sebagai variabel (`now`), dan mengubahnya menjadi format waktu epoch. `int`
Contoh kode berikut menunjukkan cara query untuk item TTL.
------
#### [ Java ]
**SDK untuk Java 2.x**
Query Filtered Expression untuk mengumpulkan item TTL dalam tabel DynamoDB menggunakan. AWS SDK for Java 2.x
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.QueryRequest;
import software.amazon.awssdk.services.dynamodb.model.QueryResponse;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.Map;
import java.util.Optional;
final QueryRequest request = QueryRequest.builder()
.tableName(tableName)
.keyConditionExpression(KEY_CONDITION_EXPRESSION)
.filterExpression(FILTER_EXPRESSION)
.expressionAttributeNames(expressionAttributeNames)
.expressionAttributeValues(expressionAttributeValues)
.build();
try (DynamoDbClient ddb = dynamoDbClient != null
? dynamoDbClient
: DynamoDbClient.builder().region(region).build()) {
final QueryResponse response = ddb.query(request);
System.out.println("Query successful. Found " + response.count() + " items that have not expired yet.");
// Print each item
response.items().forEach(item -> {
System.out.println("Item: " + item);
});
return 0;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
```
+ Untuk detail API, lihat [Kueri](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/Query) di *Referensi API AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Query Filtered Expression untuk mengumpulkan item TTL dalam tabel DynamoDB menggunakan. AWS SDK untuk JavaScript
```
import { DynamoDBClient, QueryCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
export const queryFiltered = async (tableName, primaryKey, region = 'us-east-1') => {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
const currentTime = Math.floor(Date.now() / 1000);
const params = {
TableName: tableName,
KeyConditionExpression: "#pk = :pk",
FilterExpression: "#ea > :ea",
ExpressionAttributeNames: {
"#pk": "primaryKey",
"#ea": "expireAt"
},
ExpressionAttributeValues: marshall({
":pk": primaryKey,
":ea": currentTime
})
};
try {
const { Items } = await client.send(new QueryCommand(params));
Items.forEach(item => {
console.log(unmarshall(item))
});
return Items;
} catch (err) {
console.error(`Error querying items: ${err}`);
throw err;
}
}
// Example usage (commented out for testing)
// queryFiltered('your-table-name', 'your-partition-key-value');
```
+ Untuk detail API, lihat [Kueri](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/QueryCommand) di *Referensi API AWS SDK untuk JavaScript *.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Query Filtered Expression untuk mengumpulkan item TTL dalam tabel DynamoDB menggunakan. AWS SDK untuk Python (Boto3)
```
from datetime import datetime
import boto3
def query_dynamodb_items(table_name, partition_key):
"""
:param table_name: Name of the DynamoDB table
:param partition_key:
:return:
"""
try:
# Initialize a DynamoDB resource
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
# Specify your table
table = dynamodb.Table(table_name)
# Get the current time in epoch format
current_time = int(datetime.now().timestamp())
# Perform the query operation with a filter expression to exclude expired items
# response = table.query(
# KeyConditionExpression=boto3.dynamodb.conditions.Key('partitionKey').eq(partition_key),
# FilterExpression=boto3.dynamodb.conditions.Attr('expireAt').gt(current_time)
# )
response = table.query(
KeyConditionExpression=dynamodb.conditions.Key("partitionKey").eq(partition_key),
FilterExpression=dynamodb.conditions.Attr("expireAt").gt(current_time),
)
# Print the items that are not expired
for item in response["Items"]:
print(item)
except Exception as e:
print(f"Error querying items: {e}")
# Call the function with your values
query_dynamodb_items("Music", "your-partition-key-value")
```
+ Untuk detail API, lihat [Kueri](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/Query) di *Referensi API AWS SDK untuk Python (Boto3)*.
------
## Menulis secara kondisional ke item yang kedaluwarsa
Ekspresi kondisi dapat digunakan untuk menghindari penulisan terhadap item yang kedaluwarsa. Cuplikan kode di bawah ini adalah pembaruan bersyarat yang memeriksa apakah waktu kedaluwarsa lebih besar dari waktu saat ini. Jika benar, operasi tulis akan berlanjut.
Contoh kode berikut menunjukkan cara memperbarui TTL item secara kondisional.
------
#### [ Java ]
**SDK untuk Java 2.x**
Perbarui TTL pada Item DynamoDB yang ada dalam tabel, dengan kondisi.
```
package com.amazon.samplelib.ttl;
import com.amazon.samplelib.CodeSampleUtils;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.ConditionalCheckFailedException;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemResponse;
import java.util.Map;
import java.util.Optional;
/**
* Updates an item in a DynamoDB table with TTL attributes using a conditional expression.
* This class demonstrates how to conditionally update TTL expiration timestamps.
*/
public class UpdateTTLConditional {
private static final String USAGE =
"""
Usage:
Where:
tableName - The Amazon DynamoDB table being queried.
primaryKey - The name of the primary key. Also known as the hash or partition key.
sortKey - The name of the sort key. Also known as the range attribute.
region (optional) - The AWS region that the Amazon DynamoDB table is located in. (Default: us-east-1)
""";
private static final int DAYS_TO_EXPIRE = 90;
private static final int SECONDS_PER_DAY = 24 * 60 * 60;
private static final String PRIMARY_KEY_ATTR = "primaryKey";
private static final String SORT_KEY_ATTR = "sortKey";
private static final String UPDATED_AT_ATTR = "updatedAt";
private static final String EXPIRE_AT_ATTR = "expireAt";
private static final String UPDATE_EXPRESSION = "SET " + UPDATED_AT_ATTR + "=:c, " + EXPIRE_AT_ATTR + "=:e";
private static final String CONDITION_EXPRESSION = "attribute_exists(" + PRIMARY_KEY_ATTR + ")";
private static final String SUCCESS_MESSAGE = "%s UpdateItem operation with TTL successful.";
private static final String CONDITION_FAILED_MESSAGE = "Condition check failed. Item does not exist.";
private static final String TABLE_NOT_FOUND_ERROR = "Error: The Amazon DynamoDB table \"%s\" can't be found.";
private final DynamoDbClient dynamoDbClient;
/**
* Constructs an UpdateTTLConditional with a default DynamoDB client.
*/
public UpdateTTLConditional() {
this.dynamoDbClient = null;
}
/**
* Constructs an UpdateTTLConditional with the specified DynamoDB client.
*
* @param dynamoDbClient The DynamoDB client to use
*/
public UpdateTTLConditional(final DynamoDbClient dynamoDbClient) {
this.dynamoDbClient = dynamoDbClient;
}
/**
* Main method to demonstrate conditionally updating an item with TTL.
*
* @param args Command line arguments
*/
public static void main(final String[] args) {
try {
int result = new UpdateTTLConditional().processArgs(args);
System.exit(result);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
/**
* Process command line arguments and conditionally update an item with TTL.
*
* @param args Command line arguments
* @return 0 if successful, non-zero otherwise
* @throws ResourceNotFoundException If the table doesn't exist
* @throws DynamoDbException If an error occurs during the operation
* @throws IllegalArgumentException If arguments are invalid
*/
public int processArgs(final String[] args) {
// Argument validation (remove or replace this line when reusing this code)
CodeSampleUtils.validateArgs(args, new int[] {3, 4}, USAGE);
final String tableName = args[0];
final String primaryKey = args[1];
final String sortKey = args[2];
final Region region = Optional.ofNullable(args.length > 3 ? args[3] : null)
.map(Region::of)
.orElse(Region.US_EAST_1);
// Get current time in epoch second format
final long currentTime = System.currentTimeMillis() / 1000;
// Calculate expiration time 90 days from now in epoch second format
final long expireDate = currentTime + (DAYS_TO_EXPIRE * SECONDS_PER_DAY);
// Create the key map for the item to update
final Map keyMap = Map.of(
PRIMARY_KEY_ATTR, AttributeValue.builder().s(primaryKey).build(),
SORT_KEY_ATTR, AttributeValue.builder().s(sortKey).build());
// Create the expression attribute values
final Map expressionAttributeValues = Map.of(
":c", AttributeValue.builder().n(String.valueOf(currentTime)).build(),
":e", AttributeValue.builder().n(String.valueOf(expireDate)).build());
final UpdateItemRequest request = UpdateItemRequest.builder()
.tableName(tableName)
.key(keyMap)
.updateExpression(UPDATE_EXPRESSION)
.conditionExpression(CONDITION_EXPRESSION)
.expressionAttributeValues(expressionAttributeValues)
.build();
try (DynamoDbClient ddb = dynamoDbClient != null
? dynamoDbClient
: DynamoDbClient.builder().region(region).build()) {
final UpdateItemResponse response = ddb.updateItem(request);
System.out.println(String.format(SUCCESS_MESSAGE, tableName));
return 0;
} catch (ConditionalCheckFailedException e) {
System.err.println(CONDITION_FAILED_MESSAGE);
throw e;
} catch (ResourceNotFoundException e) {
System.err.format(TABLE_NOT_FOUND_ERROR, tableName);
throw e;
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
throw e;
}
}
}
```
+ Untuk detail API, lihat [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Perbarui TTL pada Item DynamoDB yang ada dalam tabel, dengan kondisi.
```
import { DynamoDBClient, UpdateItemCommand } from "@aws-sdk/client-dynamodb";
import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
export const updateItemConditional = async (tableName, partitionKey, sortKey, region = 'us-east-1', newAttribute = 'default-value') => {
const client = new DynamoDBClient({
region: region,
endpoint: `https://dynamodb.${region}.amazonaws.com`
});
const currentTime = Math.floor(Date.now() / 1000);
const params = {
TableName: tableName,
Key: marshall({
artist: partitionKey,
album: sortKey
}),
UpdateExpression: "SET newAttribute = :newAttribute",
ConditionExpression: "expireAt > :expiration",
ExpressionAttributeValues: marshall({
':newAttribute': newAttribute,
':expiration': currentTime
}),
ReturnValues: "ALL_NEW"
};
try {
const response = await client.send(new UpdateItemCommand(params));
const responseData = unmarshall(response.Attributes);
console.log("Item updated successfully: ", responseData);
return responseData;
} catch (error) {
if (error.name === "ConditionalCheckFailedException") {
console.log("Condition check failed: Item's 'expireAt' is expired.");
} else {
console.error("Error updating item: ", error);
}
throw error;
}
};
// Example usage (commented out for testing)
// updateItemConditional('your-table-name', 'your-partition-key-value', 'your-sort-key-value');
```
+ Untuk detail API, lihat [UpdateItem](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/command/UpdateItemCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Perbarui TTL pada Item DynamoDB yang ada dalam tabel, dengan kondisi.
```
from datetime import datetime, timedelta
import boto3
from botocore.exceptions import ClientError
def update_dynamodb_item_ttl(table_name, region, primary_key, sort_key, ttl_attribute):
"""
Updates an existing record in a DynamoDB table with a new or updated TTL attribute.
:param table_name: Name of the DynamoDB table
:param region: AWS Region of the table - example `us-east-1`
:param primary_key: one attribute known as the partition key.
:param sort_key: Also known as a range attribute.
:param ttl_attribute: name of the TTL attribute in the target DynamoDB table
:return:
"""
try:
dynamodb = boto3.resource("dynamodb", region_name=region)
table = dynamodb.Table(table_name)
# Generate updated TTL in epoch second format
updated_expiration_time = int((datetime.now() + timedelta(days=90)).timestamp())
# Define the update expression for adding/updating a new attribute
update_expression = "SET newAttribute = :val1"
# Define the condition expression for checking if 'expireAt' is not expired
condition_expression = "expireAt > :val2"
# Define the expression attribute values
expression_attribute_values = {":val1": ttl_attribute, ":val2": updated_expiration_time}
response = table.update_item(
Key={"primaryKey": primary_key, "sortKey": sort_key},
UpdateExpression=update_expression,
ConditionExpression=condition_expression,
ExpressionAttributeValues=expression_attribute_values,
)
print("Item updated successfully.")
return response["ResponseMetadata"]["HTTPStatusCode"] # Ideally a 200 OK
except ClientError as e:
if e.response["Error"]["Code"] == "ConditionalCheckFailedException":
print("Condition check failed: Item's 'expireAt' is expired.")
else:
print(f"Error updating item: {e}")
except Exception as e:
print(f"Error updating item: {e}")
# replace with your values
update_dynamodb_item_ttl(
"your-table-name",
"us-east-1",
"your-partition-key-value",
"your-sort-key-value",
"your-ttl-attribute-value",
)
```
+ Untuk detail API, lihat [UpdateItem](https://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/UpdateItem)di *AWS SDK for Python (Boto3) Referensi* API.
------
## Mengidentifikasi item yang dihapus di DynamoDB Streams
Catatan stream berisi bidang identitas pengguna `Records[].userIdentity`. Item yang dihapus oleh proses TTL memiliki bidang berikut:
```
Records[].userIdentity.type
"Service"
Records[].userIdentity.principalId
"dynamodb.amazonaws.com"
```
JSON berikut menunjukkan bagian yang relevan dari catatan aliran tunggal:
```
"Records": [
{
...
"userIdentity": {
"type": "Service",
"principalId": "dynamodb.amazonaws.com"
}
...
}
]
```
# Menanyakan tabel di DynamoDB
Anda dapat menggunakan operasi API `Query` di Amazon DynamoDB untuk menemukan item berdasarkan nilai kunci primer.
Anda harus memberikan nama atribut kunci partisi dan satu nilai untuk atribut tersebut. `Query` mengembalikan semua item dengan nilai kunci partisi tersebut. Secara opsional, Anda dapat memberikan atribut kunci urutan dan menggunakan operator perbandingan untuk menyaring hasil pencarian.
Untuk informasi selengkapnya tentang cara menggunakan `Query`, seperti sintaks permintaan, parameter respons, dan contoh tambahan, lihat [Kueri](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html) di *Referensi API Amazon DynamoDB*.
**Topics**
+ [Ekspresi kondisi kunci untuk operasi Query di DynamoDB](Query.KeyConditionExpressions.md)
+ [Ekspresi filter untuk operasi Query di DynamoDB](Query.FilterExpression.md)
+ [Hasil query tabel paginasi di DynamoDB](Query.Pagination.md)
+ [Aspek lain dari bekerja dengan operasi Query di DynamoDB](Query.Other.md)
# Ekspresi kondisi kunci untuk operasi Query di DynamoDB
Anda dapat menggunakan nama atribut apa pun dalam ekspresi kondisi kunci, asalkan karakter pertama adalah `a-z` atau `A-Z` dan karakter lainnya (mulai dari karakter kedua, jika ada) adalah `a-z`, `A-Z`, or `0-9`. Selain itu, nama atribut tidak boleh berupa kata khusus DynamoDB. (Untuk daftar lengkapnya, lihat [Kata-kata penggunaan khusus di DynamoDB](ReservedWords.md).) Jika nama atribut tidak memenuhi persyaratan ini, Anda harus menentukan nama atribut ekspresi sebagai placeholder. Untuk informasi selengkapnya, lihat [Nama atribut ekspresi (alias) di DynamoDB](Expressions.ExpressionAttributeNames.md).
Untuk item dengan nilai kunci partisi tertentu, DynamoDB menyimpan item ini berdekatan, dalam urutan berdasarkan nilai kunci urutan. Dalam operasi `Query`, DynamoDB mengambil item dalam urutan yang diurutkan, lalu memproses item menggunakan `KeyConditionExpression` dan `FilterExpression` apa pun yang mungkin ada. Baru setelah itu hasil `Query` dikirim kembali ke klien.
Operasi `Query` selalu mengembalikan kumpulan hasil. Jika tidak ditemukan item yang cocok, set hasil kosong.
Hasil `Query` selalu diurutkan berdasarkan nilai kunci urutan. Jika jenis daya kunci urutan adalah `Number`, hasilnya dikembalikan dalam urutan numerik. Jika tidak, hasilnya akan dikembalikan dalam urutan UTF-8 byte. Secara default, urutannya menaik. Untuk membalikkan urutan, atur parameter `ScanIndexForward` ke `false`.
Operasi `Query` tunggal dapat mengambil data maksimum 1 MB. Batas ini berlaku sebelum `FilterExpression` atau `ProjectionExpression` diterapkan pada hasil. Jika `LastEvaluatedKey` ada dalam respons dan bukan null, Anda harus memberi nomor halaman pada kumpulan hasil (lihat [Hasil query tabel paginasi di DynamoDB](Query.Pagination.md)).
## Contoh ekspresi kondisi kunci
Untuk menentukan kriteria pencarian, Anda menggunakan *ekspresi kondisi kunci*—string yang menentukan item yang akan dibaca dari tabel atau indeks.
Anda harus menentukan nama dan nilai kunci partisi sebagai syarat kesetaraan. Anda tidak dapat menggunakan atribut bukan kunci dalam ekspresi kondisi kunci.
Anda juga dapat memberikan kondisi kedua untuk kunci urutan (jika ada). Kondisi kunci urutan harus menggunakan salah satu operator perbandingan berikut:
+ `a = b`— true jika atribut *a* sama dengan nilai *b*
+ `a < b`— benar *a* jika kurang dari *b*
+ `a <= b`— benar jika *a* kurang dari atau sama dengan *b*
+ `a > b`Benar jika *a* lebih besar dari *b*
+ `a >= b`— benar jika *a* lebih besar dari atau sama dengan *b*
+ `a BETWEEN b AND c`— benar jika *a* lebih besar dari atau sama dengan*b*, dan kurang dari atau sama dengan*c*.
Fungsi berikut ini juga didukung:
+ `begins_with (a, substr)`— true jika nilai atribut `a` dimulai dengan substring tertentu.
Contoh berikut AWS Command Line Interface (AWS CLI) menunjukkan penggunaan ekspresi kondisi kunci. Ekspresi ini menggunakan placeholder (seperti `:name` dan `:sub`) dan bukan nilai aktual. Untuk informasi selengkapnya, lihat [Nama atribut ekspresi (alias) di DynamoDB](Expressions.ExpressionAttributeNames.md) dan [Menggunakan nilai atribut ekspresi di DynamoDB](Expressions.ExpressionAttributeValues.md).
**Example**
Ajukan kueri tabel `Thread` untuk `ForumName` (kunci partisi) tertentu. Semua item dengan nilai `ForumName` tersebut dibaca oleh kueri karena kunci urutan (`Subject`) tidak termasuk dalam`KeyConditionExpression`.
```
aws dynamodb query \
--table-name Thread \
--key-condition-expression "ForumName = :name" \
--expression-attribute-values '{":name":{"S":"Amazon DynamoDB"}}'
```
**Example**
Ajukan kueri tabel `Thread` untuk `ForumName` kunci partisi), tetapi kali ini hanya mengembalikan item dengan `Subject`(kunci urutan) tertentu.
```
aws dynamodb query \
--table-name Thread \
--key-condition-expression "ForumName = :name and Subject = :sub" \
--expression-attribute-values file://values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":name":{"S":"Amazon DynamoDB"},
":sub":{"S":"DynamoDB Thread 1"}
}
```
**Example**
Kueri tabel `Reply` untuk `Id` tertentu (kunci partisi), tetapi hanya kembalikan item yang `ReplyDateTime` (kunci urutan) dimulai dengan karakter tertentu.
```
aws dynamodb query \
--table-name Reply \
--key-condition-expression "Id = :id and begins_with(ReplyDateTime, :dt)" \
--expression-attribute-values file://values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":id":{"S":"Amazon DynamoDB#DynamoDB Thread 1"},
":dt":{"S":"2015-09"}
}
```
# Ekspresi filter untuk operasi Query di DynamoDB
Jika Anda perlu menyempurnakan hasil `Query` lebih lanjut, Anda dapat memberikan ekspresi filter secara opsional. *Ekspresi filter* menentukan item mana dalam hasil `Query` yang harus dikembalikan kepada Anda. Semua hasil lainnya dibuang.
Filter ekspresi diterapkan setelah `Query` selesai, namun sebelum hasilnya dikembalikan. Oleh karena itu, `Query` menggunakan jumlah kapasitas baca yang sama, terlepas dari apakah ada ekspresi filter.
Operasi `Query` dapat mengambil data maksimal 1 MB. Batasan ini berlaku sebelum ekspresi filter dievaluasi.
Filter ekspresi tidak boleh berisi atribut kunci partisi atau kunci urutan. Anda perlu menentukan atribut tersebut dalam ekspresi kondisi kunci, bukan ekspresi filter.
Sintaks untuk ekspresi filter mirip dengan ekspresi kondisi kunci. Ekspresi filter dapat menggunakan pembanding, fungsi, dan operator logika yang sama sebagai ekspresi kondisi utama. Selain itu, ekspresi filter dapat menggunakan operator tak sama dengan `<>`(), operator `OR`, operator `CONTAINS`, operator `IN`, operator `BEGINS_WITH`, operator `BETWEEN`, operator `EXISTS`, dan operator `SIZE`. Untuk informasi selengkapnya, lihat [Ekspresi kondisi kunci untuk operasi Query di DynamoDB](Query.KeyConditionExpressions.md) dan [Sintaks untuk ekspresi filter dan kondisi](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.Syntax).
**Example**
AWS CLI Contoh berikut query `Thread` tabel untuk tertentu `ForumName` (kunci partisi) dan `Subject` (sort key). Dari item yang ditemukan, hanya rangkaian diskusi terpopuler yang dikembalikan—dengan kata lain, hanya rangkaian diskusi yang memiliki jumlah `Views` lebih dari tertentu.
```
aws dynamodb query \
--table-name Thread \
--key-condition-expression "ForumName = :fn and Subject begins_with :sub" \
--filter-expression "#v >= :num" \
--expression-attribute-names '{"#v": "Views"}' \
--expression-attribute-values file://values.json
```
Argumen untuk `--expression-attribute-values` disimpan dalam file `values.json`.
```
{
":fn":{"S":"Amazon DynamoDB"},
":sub":{"S":"DynamoDB Thread 1"},
":num":{"N":"3"}
}
```
Perhatikan bahwa `Views` adalah kata yang dicadangkan di DynamoDB (lihat [Kata-kata penggunaan khusus di DynamoDB](ReservedWords.md)), sehingga contoh ini menggunakan `#v` sebagai placeholder. Untuk informasi selengkapnya, lihat [Nama atribut ekspresi (alias) di DynamoDB](Expressions.ExpressionAttributeNames.md).
**catatan**
Ekspresi filter menghapus item dari set hasil `Query`. Jika memungkinkan, hindari penggunaan `Query` saat Anda ingin mengambil item dalam jumlah besar namun juga harus membuang sebagian besar item tersebut.
# Hasil query tabel paginasi di DynamoDB
DynamoDB *memberi nomor halaman* hasil dari operasi `Query`. Dengan pemberian nomor halaman, hasil `Query` dibagi menjadi "halaman" data berukuran 1 MB (atau kurang). Aplikasi bisa memproses halaman pertama hasil, lalu halaman kedua, dan seterusnya.
`Query` tunggal hanya mengembalikan set hasil yang sesuai dalam batas ukuran 1 MB. Untuk menentukan apakah terdapat lebih banyak hasil, dan untuk mengambilkan satu halaman sekaligus, aplikasi harus melakukan hal berikut:
1. Periksa hasil `Query` tingkat rendah:
+ Jika hasilnya berisi elemen `LastEvaluatedKey` dan elemen tersebut non-null, lanjutkan ke langkah 2.
+ Jika *tidak ada* `LastEvaluatedKey` pada hasilnya, tidak ada lagi item yang dapat diambil.
1. Membangun `Query` dengan yang sama`KeyConditionExpression`. Namun, kali ini, ambil nilai `LastEvaluatedKey` dari langkah 1 dan gunakan sebagai parameter `ExclusiveStartKey` dalam permintaan `Query` baru.
1. Jalankan permintaan `Query` baru.
1. Lanjutkan ke langkah 1.
Dengan kata lain, `LastEvaluatedKey` dari respons `Query` harus digunakan sebagai `ExclusiveStartKey` untuk permintaan `Query` berikutnya. Jika tidak ada elemen `LastEvaluatedKey` dalam respons `Query`, maka Anda telah mengambil halaman hasil akhir. Jika `LastEvaluatedKey` tidak kosong, bukan berarti ada lebih banyak data di set hasil. Satu-satunya cara untuk mengetahui kapan Anda telah mencapai akhir kumpulan hasil adalah ketika `LastEvaluatedKey` kosong.
Anda dapat menggunakan AWS CLI untuk melihat perilaku ini. AWS CLI Mengirimkan `Query` permintaan tingkat rendah ke DynamoDB berulang kali, `LastEvaluatedKey` hingga tidak ada lagi dalam hasil. Perhatikan AWS CLI contoh berikut yang mengambil judul film dari tahun tertentu.
```
aws dynamodb query --table-name Movies \
--projection-expression "title" \
--key-condition-expression "#y = :yyyy" \
--expression-attribute-names '{"#y":"year"}' \
--expression-attribute-values '{":yyyy":{"N":"1993"}}' \
--page-size 5 \
--debug
```
Biasanya, AWS CLI menangani pagination secara otomatis. Namun, dalam contoh ini, AWS CLI `--page-size` parameter membatasi jumlah item per halaman. Parameter `--debug` mencetak informasi tingkat rendah tentang permintaan dan respons.
Jika Anda menjalankan contoh ini, respons pertama dari DynamoDB terlihat serupa dengan yang berikut ini.
```
2017-07-07 11:13:15,603 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":5,"Items":[{"title":{"S":"A Bronx Tale"}},
{"title":{"S":"A Perfect World"}},{"title":{"S":"Addams Family Values"}},
{"title":{"S":"Alive"}},{"title":{"S":"Benny & Joon"}}],
"LastEvaluatedKey":{"year":{"N":"1993"},"title":{"S":"Benny & Joon"}},
"ScannedCount":5}'
```
`LastEvaluatedKey` dalam responsnya menunjukkan bahwa tidak semua item telah diambil. AWS CLI Kemudian mengeluarkan `Query` permintaan lain ke DynamoDB. Pola permintaan dan respons ini berlanjut hingga respons akhir.
```
2017-07-07 11:13:16,291 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":1,"Items":[{"title":{"S":"What\'s Eating Gilbert Grape"}}],"ScannedCount":1}'
```
Tidak adanya `LastEvaluatedKey` menunjukkan bahwa tidak ada lagi item yang dapat diambil.
**catatan**
AWS SDKs Menangani respons DynamoDB tingkat rendah (termasuk ada atau tidak adanya) dan memberikan berbagai `LastEvaluatedKey` abstraksi untuk hasil paginasi. `Query` Misalnya, antarmuka dokumen SDK untuk Java menyediakan dukungan `java.util.Iterator` sehingga Anda dapat mempelajari hasilnya satu per satu.
Untuk contoh kode dalam berbagai bahasa pemrograman, lihat [Panduan Memulai Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/) dan dokumentasi AWS SDK untuk bahasa Anda.
Anda juga dapat mengurangi ukuran halaman dengan membatasi jumlah item dalam set hasil, dengan parameter `Limit` operasi `Query`.
Untuk informasi selengkapnya tentang pembuatan kueri dengan DynamoDB, lihat [Menanyakan tabel di DynamoDB](Query.md).
# Aspek lain dari bekerja dengan operasi Query di DynamoDB
Bagian ini mencakup aspek tambahan dari operasi Query DynamoDB, termasuk membatasi ukuran hasil, menghitung item yang dipindai vs. dikembalikan, memantau konsumsi kapasitas baca, dan mengontrol konsistensi baca.
## Membatasi jumlah item dalam set hasil
Dengan operasi `Query`, Anda dapat membatasi jumlah item yang dibaca. Untuk melakukannya, tetapkan parameter `Limit` ke jumlah maksimum item yang Anda inginkan.
Misalnya, anggaplah bahwa Anda `Query` tabel, dengan nilai `Limit` dari `6`, dan tanpa ekspresi filter. Hasil `Query` berisi enam item pertama dari tabel yang cocok dengan ekspresi kondisi kunci dari permintaan.
Sekarang anggap bahwa Anda menambahkan ekspresi filter ke `Query`. Dalam kasus ini, DynamoDB membaca hingga enam item, lalu hanya mengembalikan item yang cocok dengan ekspresi filter. Hasil `Query` akhir berisi enam item atau lebih sedikit, meskipun lebih banyak item akan cocok dengan ekspresi filter jika DynamoDB terus membaca lebih banyak item.
## Menghitung item dalam hasil
Selain item yang sesuai dengan kriteria Anda, respons `Query` berisi elemen berikut:
+ `ScannedCount` — Jumlah item yang cocok dengan ekspresi kondisi kunci *sebelum* ekspresi filter (jika ada) diterapkan.
+ `Count` — Jumlah item yang tersisa *setelah* ekspresi filter (jika ada) diterapkan.
**catatan**
Jika Anda tidak menggunakan ekspresi filter, `ScannedCount` dan `Count` memiliki nilai yang sama.
Jika ukuran set hasil `Query` lebih besar dari 1 MB, `ScannedCount` dan `Count` mewakili hanya jumlah parsial dari total item. Anda harus melakukan beberapa operasi `Query` untuk mengambil semua hasil (lihat [Hasil query tabel paginasi di DynamoDB](Query.Pagination.md)).
Setiap respons `Query` berisi `ScannedCount` dan `Count` untuk item yang diproses oleh permintaan `Query` khusus. Untuk mendapatkan total keseluruhan untuk semua permintaan `Query`, Anda dapat menyimpan penghitungan `ScannedCount` dan `Count`.
## Unit kapasitas yang digunakan oleh kueri
Anda dapat melakukan `Query` tabel atau indeks sekunder apa pun, selama Anda memberikan nama atribut kunci partisi dan satu nilai untuk atribut tersebut. `Query` mengembalikan semua item dengan nilai kunci partisi tersebut. Secara opsional, Anda dapat memberikan atribut kunci urutan dan menggunakan operator perbandingan untuk menyaring hasil pencarian. `Query` Operasi API menggunakan unit kapasitas baca, sebagai berikut.
****
| Jika Anda `Query`... | DynamoDB menggunakan unit kapasitas baca dari... |
| --- | --- |
| Tabel | Kapasitas baca yang ditetapkan tabel. |
| Indeks sekunder global | Kapasitas baca yang ditetapkan indeks. |
| Indeks sekunder lokal | Kapasitas baca yang ditetapkan tabel dasar. |
Secara default, operasi `Query` tidak menampilkan data tentang berapa banyak kapasitas baca yang digunakan. Namun, Anda dapat menentukan parameter `ReturnConsumedCapacity` dalam sebuah permintaan `Query` untuk mendapatkan informasi ini. Berikut ini adalah pengaturan yang valid untuk `ReturnConsumedCapacity`:
+ `NONE` — Tidak ada penggunaan data kapasitas yang ditampilkan. (Ini menjadi opsi default.)
+ `TOTAL` — Respons mencakup jumlah agregat unit kapasitas baca yang digunakan.
+ `INDEXES` — Respons menunjukkan jumlah agregat unit kapasitas baca yang digunakan, beserta dengan kapasitas yang digunakan untuk setiap tabel dan indeks yang diakses.
DynamoDB menghitung jumlah unit kapasitas baca yang dikonsumsi berdasarkan jumlah item dan ukuran item tersebut, bukan pada jumlah data yang dikembalikan ke aplikasi. Dengan alasan ini, jumlah unit kapasitas yang digunakan adalah sama, entah Anda meminta semua atribut (perilaku default) atau hanya beberapa dari atribut tersebut (menggunakan ekspresi proyeksi). Jumlahnya juga sama apakah Anda menggunakan ekspresi filter atau tidak. `Query`mengkonsumsi unit kapasitas baca minimum untuk melakukan satu pembacaan yang sangat konsisten per detik, atau dua pembacaan yang konsisten per detik untuk item hingga 4 KB. Jika Anda perlu membaca item yang lebih besar dari 4 KB, DynamoDB memerlukan unit permintaan baca tambahan. Tabel kosong dan tabel yang sangat besar yang memiliki jumlah kunci partisi yang jarang mungkin melihat beberapa tambahan RCUs dibebankan di luar jumlah data yang ditanyakan. Ini mencakup biaya melayani `Query` permintaan, bahkan jika tidak ada data.
## Konsistensi baca untuk kueri
Operasi `Query` melakukan bacaan akhir konsisten, secara default. Ini berarti bahwa hasil `Query` mungkin tidak mencerminkan perubahan karena operasi `PutItem` atau `UpdateItem` baru saja selesai. Untuk informasi selengkapnya, lihat [DynamoDB membaca konsistensi](HowItWorks.ReadConsistency.md).
Jika Anda memerlukan bacaan sangat konsisten, atur parameter `ConsistentRead` ke `true` dalam permintaan `Query`.
# Memindai tabel di DynamoDB
Operasi `Scan` di Amazon DynamoDB membaca setiap item dalam tabel atau indeks sekunder. Secara default, operasi `Scan` mengembalikan semua atribut data untuk setiap item dalam tabel atau indeks. Anda dapat menggunakan parameter `ProjectionExpression` sehingga `Scan` hanya mengembalikan beberapa atribut, bukan semuanya.
`Scan` selalu mengembalikan set hasil. Jika tidak ditemukan item yang cocok, set hasil kosong.
Permintaan `Scan` tunggal dapat mengambil data maksimum 1 MB. Atau, DynamoDB dapat menerapkan ekspresi filter pada data ini, mengerucutkan hasil sebelum dikembalikan ke pengguna.
**Topics**
+ [Ekspresi filter untuk pemindaian](#Scan.FilterExpression)
+ [Membatasi jumlah item dalam set hasil](#Scan.Limit)
+ [Memberi nomor halaman hasil](#Scan.Pagination)
+ [Menghitung item dalam hasil](#Scan.Count)
+ [Unit kapasitas dikonsumsi oleh pemindaian](#Scan.CapacityUnits)
+ [Konsistensi baca untuk kueri](#Scan.ReadConsistency)
+ [Pemindaian paralel](#Scan.ParallelScan)
## Ekspresi filter untuk pemindaian
Jika Anda perlu menyempurnakan hasil `Scan` lebih lanjut, Anda dapat memberikan ekspresi filter secara opsional. *Ekspresi filter* menentukan item mana dalam hasil `Scan` yang harus dikembalikan kepada Anda. Semua hasil lainnya dibuang.
Filter ekspresi diterapkan setelah `Scan` selesai, tetapi sebelum hasilnya dikembalikan. Oleh karena itu, `Scan` menggunakan jumlah kapasitas baca yang sama, terlepas dari apakah ada ekspresi filter.
Operasi `Scan` dapat mengambil data maksimal 1 MB. Batasan ini berlaku sebelum ekspresi filter dievaluasi.
Dengan `Scan`, Anda dapat menentukan atribut apa pun dalam ekspresi filter, termasuk atribut kunci partisi dan kunci urutan.
Sintaks untuk ekspresi filter mirip dengan ekspresi kondisi kunci. Ekspresi filter dapat menggunakan pembanding, fungsi, dan operator logika yang sama sebagai ekspresi kondisi utama. Lihat [Kondisi dan filter ekspresi, operator, dan fungsi di DynamoDB](Expressions.OperatorsAndFunctions.md) untuk informasi selengkapnya tentang operator logika.
**Example**
Contoh berikut AWS Command Line Interface (AWS CLI) memindai `Thread` tabel dan hanya mengembalikan item yang terakhir diposting oleh pengguna tertentu.
```
aws dynamodb scan \
--table-name Thread \
--filter-expression "LastPostedBy = :name" \
--expression-attribute-values '{":name":{"S":"User A"}}'
```
## Membatasi jumlah item dalam set hasil
Operasi `Scan` memungkinkan Anda membatasi jumlah item yang dikembalikan dalam hasil. Untuk melakukannya, tetapkan parameter `Limit` pada jumlah maksimum item yang Anda inginkan untuk dikembalikan operasi `Scan`, sebelum evaluasi ekspresi filter.
Misalnya, anggaplah bahwa Anda melakukan `Scan` pada tabel, dengan nilai `Limit` adalah `6`, dan tanpa ekspresi filter. Hasil `Scan` berisi enam item pertama dari tabel.
Sekarang anggap bahwa Anda menambahkan ekspresi filter ke `Scan`. Dalam kasus ini, DynamoDB menerapkan ekspresi filter untuk enam item yang dikembalikan, membuang item yang tidak cocok. Hasil `Scan` akhir berisi enam item atau lebih sedikit, tergantung jumlah item yang disaring.
## Memberi nomor halaman hasil
DynamoDB *memberi nomor halaman* hasil dari operasi `Scan`. Dengan pemberian nomor halaman, hasil `Scan` dibagi menjadi "halaman" data berukuran 1 MB (atau kurang). Aplikasi bisa memproses halaman pertama hasil, lalu halaman kedua, dan seterusnya.
`Scan` tunggal hanya mengembalikan set hasil yang sesuai dalam batas ukuran 1 MB.
Untuk menentukan apakah terdapat lebih banyak hasil, dan untuk mengambilkan satu halaman sekaligus, aplikasi harus melakukan hal berikut:
1. Periksa hasil `Scan` tingkat rendah:
+ Jika hasilnya berisi elemen `LastEvaluatedKey`, lanjutkan ke langkah 2.
+ Jika *tidak ada* `LastEvaluatedKey` pada hasilnya, tidak ada lagi item yang dapat diambil.
1. Buat permintaan `Scan` baru, dengan parameter yang sama seperti yang sebelumnya. Namun, kali ini, ambil nilai `LastEvaluatedKey` dari langkah 1 dan gunakan sebagai parameter `ExclusiveStartKey` dalam permintaan `Scan` baru.
1. Jalankan permintaan `Scan` baru.
1. Lanjutkan ke langkah 1.
Dengan kata lain, `LastEvaluatedKey` dari respons `Scan` harus digunakan sebagai `ExclusiveStartKey` untuk permintaan `Scan` berikutnya. Jika tidak ada elemen `LastEvaluatedKey` dalam respons `Scan`, Anda telah mengambil halaman hasil akhir. (Tidak adanya `LastEvaluatedKey` adalah satu-satunya cara untuk mengetahui bahwa Anda telah mencapai akhir set hasil.)
Anda dapat menggunakan AWS CLI untuk melihat perilaku ini. AWS CLI Mengirimkan `Scan` permintaan tingkat rendah ke DynamoDB, berulang kali, `LastEvaluatedKey` hingga tidak lagi hadir dalam hasil. Perhatikan AWS CLI contoh berikut yang memindai seluruh `Movies` tabel tetapi hanya mengembalikan film dari genre tertentu.
```
aws dynamodb scan \
--table-name Movies \
--projection-expression "title" \
--filter-expression 'contains(info.genres,:gen)' \
--expression-attribute-values '{":gen":{"S":"Sci-Fi"}}' \
--page-size 100 \
--debug
```
Biasanya, AWS CLI menangani pagination secara otomatis. Namun, dalam contoh ini, AWS CLI `--page-size` parameter membatasi jumlah item per halaman. Parameter `--debug` mencetak informasi tingkat rendah tentang permintaan dan respons.
**catatan**
Hasil pemberian nomor halaman Anda juga akan berbeda berdasarkan parameter input yang Anda lewati.
Menggunakan `aws dynamodb scan --table-name Prices --max-items 1` mengembalikan `NextToken`
Menggunakan `aws dynamodb scan --table-name Prices --limit 1` mengembalikan `LastEvaluatedKey`.
Ketahuilah juga bahwa menggunakan `--starting-token` khususnya membutuhkan nilai `NextToken`.
Jika Anda menjalankan contoh ini, respons pertama dari DynamoDB terlihat serupa dengan yang berikut ini.
```
2017-07-07 12:19:14,389 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":7,"Items":[{"title":{"S":"Monster on the Campus"}},{"title":{"S":"+1"}},
{"title":{"S":"100 Degrees Below Zero"}},{"title":{"S":"About Time"}},{"title":{"S":"After Earth"}},
{"title":{"S":"Age of Dinosaurs"}},{"title":{"S":"Cloudy with a Chance of Meatballs 2"}}],
"LastEvaluatedKey":{"year":{"N":"2013"},"title":{"S":"Curse of Chucky"}},"ScannedCount":100}'
```
`LastEvaluatedKey` dalam responsnya menunjukkan bahwa tidak semua item telah diambil. AWS CLI Kemudian mengeluarkan `Scan` permintaan lain ke DynamoDB. Pola permintaan dan respons ini berlanjut hingga respons akhir.
```
2017-07-07 12:19:17,830 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":1,"Items":[{"title":{"S":"WarGames"}}],"ScannedCount":6}'
```
Tidak adanya `LastEvaluatedKey` menunjukkan bahwa tidak ada lagi item yang dapat diambil.
**catatan**
AWS SDKs Menangani respons DynamoDB tingkat rendah (termasuk ada atau tidak adanya) dan memberikan berbagai `LastEvaluatedKey` abstraksi untuk hasil paginasi. `Scan` Misalnya, antarmuka dokumen SDK untuk Java menyediakan dukungan `java.util.Iterator` sehingga Anda dapat mempelajari hasilnya satu per satu.
Untuk contoh kode dalam berbagai bahasa pemrograman, lihat [Panduan Memulai Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/) dan dokumentasi AWS SDK untuk bahasa Anda.
## Menghitung item dalam hasil
Selain item yang sesuai dengan kriteria Anda, respons `Scan` berisi elemen berikut:
+ `ScannedCount` — Jumlah item yang dievaluasi, sebelum `ScanFilter` diterapkan. Nilai `ScannedCount` yang tinggi dengan sedikit, atau tanpa hasil, `Count` hasil menunjukkan operasi `Scan` yang tidak efisien. Jika Anda tidak menggunakan filter dalam permintaan, `ScannedCount` sama dengan `Count`.
+ `Count` — Jumlah item yang tersisa *setelah* ekspresi filter (jika ada) diterapkan.
**catatan**
Jika Anda tidak menggunakan ekspresi filter, `ScannedCount` dan `Count` memiliki nilai yang sama.
Jika ukuran set hasil `Scan` lebih besar dari 1 MB, `ScannedCount` dan `Count` mewakili hanya jumlah parsial dari total item. Anda harus melakukan beberapa operasi `Scan` untuk mengambil semua hasil (lihat [Memberi nomor halaman hasil](#Scan.Pagination)).
Setiap respons `Scan` berisi `ScannedCount` dan `Count` untuk item yang diproses oleh permintaan `Scan` khusus. Untuk mendapatkan total keseluruhan untuk semua permintaan `Scan`, Anda dapat menyimpan penghitungan `ScannedCount` dan `Count`.
## Unit kapasitas dikonsumsi oleh pemindaian
Anda dapat melakukan `Scan` pada setiap tabel atau indeks sekunder. Operasi `Scan` mengonsumsi unit kapasitas baca, sebagai berikut.
****
| Jika Anda `Scan`... | DynamoDB menggunakan unit kapasitas baca dari... |
| --- | --- |
| Tabel | Kapasitas baca yang ditetapkan tabel. |
| Indeks sekunder global | Kapasitas baca yang ditetapkan indeks. |
| Indeks sekunder lokal | Kapasitas baca yang ditetapkan tabel dasar. |
**catatan**
Akses lintas akun untuk operasi pemindaian indeks sekunder saat ini tidak didukung dengan kebijakan berbasis [sumber daya](access-control-resource-based.md).
Secara default, operasi `Scan` tidak menampilkan data tentang berapa banyak kapasitas baca yang digunakan. Namun, Anda dapat menentukan parameter `ReturnConsumedCapacity` dalam sebuah permintaan `Scan` untuk mendapatkan informasi ini. Berikut ini adalah pengaturan yang valid untuk `ReturnConsumedCapacity`:
+ `NONE` — Tidak ada penggunaan data kapasitas yang ditampilkan. (Ini menjadi opsi default.)
+ `TOTAL` — Respons mencakup jumlah agregat unit kapasitas baca yang digunakan.
+ `INDEXES` — Respons menunjukkan jumlah agregat unit kapasitas baca yang digunakan, beserta dengan kapasitas yang digunakan untuk setiap tabel dan indeks yang diakses.
DynamoDB menghitung jumlah unit kapasitas baca yang dikonsumsi berdasarkan jumlah item dan ukuran item tersebut, bukan pada jumlah data yang dikembalikan ke aplikasi. Dengan alasan ini, jumlah unit kapasitas yang digunakan adalah sama, entah Anda meminta semua atribut (perilaku default) atau hanya beberapa dari atribut tersebut (menggunakan ekspresi proyeksi). Jumlahnya juga sama apakah Anda menggunakan ekspresi filter atau tidak. `Scan`mengkonsumsi unit kapasitas baca minimum untuk melakukan satu pembacaan yang sangat konsisten per detik, atau dua pembacaan yang konsisten per detik untuk item hingga 4 KB. Jika Anda perlu membaca item yang lebih besar dari 4 KB, DynamoDB memerlukan unit permintaan baca tambahan. Tabel kosong dan tabel yang sangat besar yang memiliki jumlah kunci partisi yang jarang mungkin melihat beberapa tambahan yang RCUs dibebankan melebihi jumlah data yang dipindai. Ini mencakup biaya melayani `Scan` permintaan, bahkan jika tidak ada data.
## Konsistensi baca untuk kueri
Operasi `Scan` melakukan bacaan akhir konsisten, secara default. Ini berarti bahwa hasil `Scan` mungkin tidak mencerminkan perubahan karena operasi `PutItem` atau `UpdateItem` baru saja selesai. Untuk informasi selengkapnya, lihat [DynamoDB membaca konsistensi](HowItWorks.ReadConsistency.md).
Jika Anda memerlukan bacaan sangat konsisten, pada saat `Scan` dimulai, atur parameter `ConsistentRead` menjadi `true` dalam permintaan `Scan`. Hal ini memastikan bahwa semua operasi tulis yang diselesaikan sebelum `Scan` dimulai termasuk dalam respons `Scan`.
Mengatur `ConsistentRead` ke `true` dapat berguna dalam skenario pencadangan atau replikasi tabel, dalam hubungannya dengan [DynamoDB Streams](./Streams.html). Anda pertama kali menggunakan `Scan` dengan `ConsistentRead` yang diatur ke true untuk mendapatkan salinan data yang konsisten dalam tabel. Selama `Scan`, DynamoDB Streams mencatat aktivitas tulis tambahan yang terjadi pada tabel. Setelah `Scan` selesai, Anda dapat menerapkan aktivitas tulis dari stream ke table.
**catatan**
Operasi `Scan` dengan `ConsistentRead` yang diatue ke `true` mengonsumsi dua kali lebih banyak unit kapasitas baca dibandingkan dengan meninggalkan `ConsistentRead` pada nilai defaultnya (`false`).
## Pemindaian paralel
Secara default, operasi `Scan` memproses data secara berurutan. Amazon DynamoDB mengembalikan data ke aplikasi dalam kenaikan 1 MB, dan aplikasi melakukan operasi `Scan` tambahan untuk mengambil 1 MB data berikutnya.
Makin besar tabel atau indeks yang dipindai, makin banyak waktu yang diperlukan untuk menyelesaikan `Scan`. Selain itu, `Scan` berurutan mungkin tidak selalu dapat sepenuhnya menggunakan kapasitas throughput baca yang disediakan: Meskipun DynamoDB mendistribusikan data tabel besar ke beberapa partisi fisik, operasi `Scan` hanya dapat membaca satu partisi dalam satu waktu. Karena alasan ini, throughput `Scan` dibatasi oleh throughput maksimum dari satu partisi.
Untuk mengatasi masalah ini, operasi `Scan` dapat secara logis membagi tabel atau indeks sekunder menjadi beberapa *segmen*, dengan beberapa pekerja aplikasi memindai segmen tersebut secara paralel. Setiap pekerja dapat berupa thread (dalam bahasa pemrograman yang mendukung multithreading) atau proses sistem operasi. Untuk melakukan pemindaian paralel, setiap pekerja mengeluarkan permintaan `Scan`-nya sendiri dengan parameter berikut:
+ `Segment` — Segmen yang akan dipindai oleh pekerja tertentu. Setiap pekerja harus menggunakan nilai yang berbeda untuk `Segment`.
+ `TotalSegments` — Jumlah total segmen untuk pemindaian paralel. Nilai ini harus sama dengan jumlah pekerja yang akan digunakan aplikasi Anda.
Diagram berikut menunjukkan bagaimana aplikasi multithreaded melakukan `Scan` paralel dengan tiga derajat paralelisme.
![\[Aplikasi multithreaded yang melakukan pemindaian paralel dengan membagi tabel menjadi tiga segmen.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/ParallelScan.png)
Dalam diagram ini, aplikasi memunculkan tiga thread dan memberikan angka pada setiap thread. (Segmen berbasis nol, sehingga angka pertama selalu 0.) Setiap thread menerbitkan permintaan `Scan`, mengatur `Segment` ke angka yang ditunjuk dan mengatur `TotalSegments` ke 3. Setiap thread memindai segmen yang ditunjuk, mengambil data 1 MB pada satu waktu, dan mengembalikan data ke thread utama aplikasi.
DynamoDB menetapkan item *ke* segmen dengan menerapkan fungsi hash ke kunci partisi setiap item. Untuk `TotalSegments` nilai yang diberikan, semua item dengan kunci partisi yang sama selalu ditetapkan untuk yang sama`Segment`. Ini berarti bahwa dalam tabel di mana *Item 1*, *Item 2*, dan *Item 3* semuanya berbagi `pk="account#123"` (tetapi memiliki kunci pengurutan yang berbeda), item ini akan diproses oleh pekerja yang sama, terlepas dari nilai kunci pengurutan atau ukuran *koleksi item*.
Karena penetapan *segmen* hanya didasarkan pada hash kunci partisi, segmen dapat didistribusikan secara tidak merata. Beberapa segmen mungkin tidak berisi item, sementara yang lain mungkin berisi banyak kunci partisi dengan koleksi item besar. Akibatnya, peningkatan jumlah segmen tidak menjamin kinerja pemindaian yang lebih cepat, terutama ketika kunci partisi tidak didistribusikan secara merata di seluruh ruang kunci.
Nilai untuk `Segment` dan `TotalSegments` diterapkan untuk permintaan `Scan` individual, dan Anda dapat menggunakan nilai yang berbeda setiap saat. Anda mungkin perlu bereksperimen dengan nilai-nilai ini, dan jumlah pekerja yang Anda gunakan, sampai aplikasi Anda mencapai performa terbaiknya.
**catatan**
Pemindaian paralel dengan sejumlah besar pekerja dapat dengan mudah menggunakan semua throughput yang disediakan untuk tabel atau indeks yang sedang dipindai. Sebaiknya hindari pemindaian seperti itu jika tabel atau indeks juga mengalami aktivitas baca atau tulis yang berat dari aplikasi lain.
Untuk mengontrol jumlah data yang dikembalikan per permintaan, gunakan parameter `Limit`. Hal ini dapat membantu mencegah situasi di mana satu pekerja mengkonsumsi semua throughput yang ditetapkan, dengan mengorbankan semua pekerja lainnya.
# PartiQL - Bahasa kueri yang kompatibel dengan SQL untuk Amazon DynamoDB
Amazon DynamoDB mendukung [PartiQL](https://partiql.org/), bahasa kueri yang kompatibel dengan SQL untuk memilih, menyisipkan, memperbarui, dan menghapus data di Amazon DynamoDB. Menggunakan PartiQL, Anda dapat dengan mudah berinteraksi dengan tabel DynamoDB dan menjalankan kueri ad hoc menggunakan, Konsol Manajemen AWS NoSQL Workbench,, dan DynamoDB untuk PartiQL. AWS Command Line Interface APIs
Operasi PartiQL memberikan ketersediaan, latensi, dan performa yang sama seperti operasi bidang data DynamoDB lainnya.
Bagian berikut menjelaskan implementasi DynamoDB PartiQL.
**Topics**
+ [Apa yang dimaksud dengan PartiQL?](#ql-reference.what-is)
+ [PartiQL di Amazon DynamoDB](#ql-reference.what-is)
+ [Memulai](ql-gettingstarted.md)
+ [Jenis data](ql-reference.data-types.md)
+ [Pernyataan](ql-reference.statements.md)
+ [Fungsi](ql-functions.md)
+ [Operator](ql-operators.md)
+ [Transaksi](ql-reference.multiplestatements.transactions.md)
+ [Operasi batch](ql-reference.multiplestatements.batching.md)
+ [Kebijakan IAM](ql-iam.md)
## Apa yang dimaksud dengan PartiQL?
*PartiQL* menyediakan akses kueri yang kompatibel dengan SQL di beberapa penyimpanan data yang berisi data terstruktur, data semi terstruktur, dan data bersarang. Ini banyak digunakan di Amazon dan sekarang tersedia sebagai bagian dari banyak AWS layanan, termasuk DynamoDB.
Untuk spesifikasi PartiQL dan tutorial tentang bahasa kueri inti, lihat [Dokumentasi PartiQL](https://partiql.org/docs.html).
**catatan**
Amazon DynamoDB mendukung *subset* dari bahasa kueri [PartiQL](https://partiql.org/).
Amazon DynamoDB tidak mendukung format data [Amazon ion](http://amzn.github.io/ion-docs/) atau literal Amazon Ion.
## PartiQL di Amazon DynamoDB
Untuk menjalankan kueri PartiQL di DynamoDB, Anda dapat menggunakan:
+ Konsol DynamoDB
+ NoSQL Workbench
+ AWS Command Line Interface (AWS CLI)
+ DynamoDB APIs
Untuk informasi tentang cara menggunakan metode ini guna mengakses DynamoDB, lihat [Mengakses DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html).
# Mulai menggunakan PartiQL untuk DynamoDB
Bagian ini menjelaskan cara menggunakan PartiQL untuk DynamoDB dari konsol Amazon DynamoDB, (), dan DynamoDB. AWS Command Line Interface AWS CLI APIs
Dalam contoh berikut, tabel DynamoDB yang ditentukan dalam tutorial [Mulai menggunakan DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) adalah prasyarat.
[Untuk informasi tentang menggunakan konsol DynamoDB, AWS Command Line Interface, atau DynamoDB untuk mengakses DynamoDB, lihat Mengakses APIs DynamoDB.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html)
Untuk [mengunduh](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.settingup.html) dan menggunakan [NoSQL workbench](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) untuk membuat pernyataan [PartiQL untuk DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), pilih **operasi PartiQL** di sudut kanan atas [pembangun Operasi](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.querybuilder.operationbuilder.html) NoSQL Workbench untuk DynamoDB.
------
#### [ Console ]
![\[Antarmuka editor PartiQL yang menunjukkan hasil menjalankan operasi Query pada tabel Musik.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/partiqlgettingstarted.png)
1. Masuk ke Konsol Manajemen AWS dan buka konsol DynamoDB di. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Di panel navigasi di sisi kiri konsol, pilih **editor PartiQL**.
1. Pilih tabel **Musik**.
1. Pilih **tabel Kueri**. Tindakan ini menghasilkan kueri yang tidak akan menghasilkan pemindaian tabel penuh.
1. Ganti `partitionKeyValue` dengan nilai string `Acme Band`. Ganti `sortKeyValue` dengan nilai string `Happy Day`.
1. Pilih tombol **Jalankan**.
1. Anda dapat melihat hasil kueri dengan memilih tombol **Tampilan tabel** atau **Tampilan JSON**.
------
#### [ NoSQL workbench ]
![\[Antarmuka meja kerja NoSQL. Ini menunjukkan pernyataan PartiQL SELECT yang dapat Anda jalankan di tabel Musik.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/workbench/partiql.single.png)
1. Pilih **pernyataan PartiQL**.
1. Masukkan [pernyataan SELECT](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html) PartiQL berikut
```
SELECT *
FROM Music
WHERE Artist=? and SongTitle=?
```
1. Untuk menentukan nilai parameter `Artist` dan `SongTitle`:
1. Pilih **Parameter permintaan opsional**.
1. Pilih **Tambahkan parameter baru**.
1. Pilih jenis atribut **string** dan nilai `Acme Band`.
1. Ulangi langkah b dan c, lalu pilih jenis **string** dan nilai `PartiQL Rocks`.
1. Jika Anda ingin membuat kode, pilih **Buat kode**.
Pilih bahasa yang Anda inginkan dari tab yang ditampilkan. Sekarang Anda dapat menyalin kode ini dan menggunakannya dalam aplikasi Anda.
1. Jika Anda ingin operasi segera dijalankan, pilih **Jalankan**.
------
#### [ AWS CLI ]
1. Buat item dalam tabel `Music` menggunakan pernyataan PartiQL INSERT.
```
aws dynamodb execute-statement --statement "INSERT INTO Music \
VALUE \
{'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}"
```
1. Ambil item dari tabel Musik menggunakan pernyataan PartiQL SELECT.
```
aws dynamodb execute-statement --statement "SELECT * FROM Music \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
1. Perbarui item dalam tabel `Music` menggunakan pernyataan PartiQL UPDATE.
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET AwardsWon=1 \
SET AwardDetail={'Grammys':[2020, 2018]} \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Tambahkan nilai daftar untuk item dalam tabel `Music`.
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Hapus nilai daftar untuk item dalam tabel `Music`.
```
aws dynamodb execute-statement --statement "UPDATE Music \
REMOVE AwardDetail.Grammys[2] \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Tambahkan anggota peta baru untuk item dalam tabel `Music`.
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET AwardDetail.BillBoard=[2020] \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Tambahkan atribut set string baru untuk item dalam tabel `Music`.
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET BandMembers =<<'member1', 'member2'>> \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
Perbarui atribut set string untuk item dalam tabel `Music`.
```
aws dynamodb execute-statement --statement "UPDATE Music \
SET BandMembers =set_add(BandMembers, <<'newmember'>>) \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
1. Hapus item dari tabel `Music` menggunakan pernyataan PartiQL DELETE.
```
aws dynamodb execute-statement --statement "DELETE FROM Music \
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
```
------
#### [ Java ]
```
import java.util.ArrayList;
import java.util.List;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import software.amazon.dynamodb.AmazonDynamoDB;
import software.amazon.dynamodb.AmazonDynamoDBClientBuilder;
import software.amazon.dynamodb.model.AttributeValue;
import software.amazon.dynamodb.model.ConditionalCheckFailedException;
import software.amazon.dynamodb.model.ExecuteStatementRequest;
import software.amazon.dynamodb.model.ExecuteStatementResult;
import software.amazon.dynamodb.model.InternalServerErrorException;
import software.amazon.dynamodb.model.ItemCollectionSizeLimitExceededException;
import software.amazon.dynamodb.model.ProvisionedThroughputExceededException;
import software.amazon.dynamodb.model.RequestLimitExceededException;
import software.amazon.dynamodb.model.ResourceNotFoundException;
import software.amazon.dynamodb.model.TransactionConflictException;
public class DynamoDBPartiQGettingStarted {
public static void main(String[] args) {
// Create the DynamoDB Client with the region you want
AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-1");
try {
// Create ExecuteStatementRequest
ExecuteStatementRequest executeStatementRequest = new ExecuteStatementRequest();
List parameters= getPartiQLParameters();
//Create an item in the Music table using the INSERT PartiQL statement
processResults(executeStatementRequest(dynamoDB, "INSERT INTO Music value {'Artist':?,'SongTitle':?}", parameters));
//Retrieve an item from the Music table using the SELECT PartiQL statement.
processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters));
//Update an item in the Music table using the UPDATE PartiQL statement.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist=? and SongTitle=?", parameters));
//Add a list value for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) where Artist=? and SongTitle=?", parameters));
//Remove a list value for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music REMOVE AwardDetail.Grammys[2] where Artist=? and SongTitle=?", parameters));
//Add a new map member for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music set AwardDetail.BillBoard=[2020] where Artist=? and SongTitle=?", parameters));
//Add a new string set attribute for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =<<'member1', 'member2'>> where Artist=? and SongTitle=?", parameters));
//update a string set attribute for an item in the Music table.
processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =set_add(BandMembers, <<'newmember'>>) where Artist=? and SongTitle=?", parameters));
//Retrieve an item from the Music table using the SELECT PartiQL statement.
processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters));
//delete an item from the Music Table
processResults(executeStatementRequest(dynamoDB, "DELETE FROM Music where Artist=? and SongTitle=?", parameters));
} catch (Exception e) {
handleExecuteStatementErrors(e);
}
}
private static AmazonDynamoDB createDynamoDbClient(String region) {
return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}
private static List getPartiQLParameters() {
List parameters = new ArrayList();
parameters.add(new AttributeValue("Acme Band"));
parameters.add(new AttributeValue("PartiQL Rocks"));
return parameters;
}
private static ExecuteStatementResult executeStatementRequest(AmazonDynamoDB client, String statement, List parameters ) {
ExecuteStatementRequest request = new ExecuteStatementRequest();
request.setStatement(statement);
request.setParameters(parameters);
return client.executeStatement(request);
}
private static void processResults(ExecuteStatementResult executeStatementResult) {
System.out.println("ExecuteStatement successful: "+ executeStatementResult.toString());
}
// Handles errors during ExecuteStatement execution. Use recommendations in error messages below to add error handling specific to
// your application use-case.
private static void handleExecuteStatementErrors(Exception exception) {
try {
throw exception;
} catch (ConditionalCheckFailedException ccfe) {
System.out.println("Condition check specified in the operation failed, review and update the condition " +
"check before retrying. Error: " + ccfe.getErrorMessage());
} catch (TransactionConflictException tce) {
System.out.println("Operation was rejected because there is an ongoing transaction for the item, generally " +
"safe to retry with exponential back-off. Error: " + tce.getErrorMessage());
} catch (ItemCollectionSizeLimitExceededException icslee) {
System.out.println("An item collection is too large, you\'re using Local Secondary Index and exceeded " +
"size limit of items per partition key. Consider using Global Secondary Index instead. Error: " + icslee.getErrorMessage());
} catch (Exception e) {
handleCommonErrors(e);
}
}
private static void handleCommonErrors(Exception exception) {
try {
throw exception;
} catch (InternalServerErrorException isee) {
System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage());
} catch (RequestLimitExceededException rlee) {
System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " +
"retrying. Error: " + rlee.getErrorMessage());
} catch (ProvisionedThroughputExceededException ptee) {
System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " +
"Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " +
ptee.getErrorMessage());
} catch (ResourceNotFoundException rnfe) {
System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage());
} catch (AmazonServiceException ase) {
System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " +
"service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " +
"configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage());
} catch (AmazonClientException ace) {
System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " +
"service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+
"Error: " + ace.getMessage());
} catch (Exception e) {
System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage());
}
}
}
```
------
## Menggunakan pernyataan berparameter
Alih-alih menyematkan nilai secara langsung dalam string pernyataan PartiQL, Anda dapat menggunakan placeholder tanda tanya `?` () dan memberikan nilai secara terpisah di bidang. `Parameters` Masing-masing `?` diganti dengan nilai parameter yang sesuai, sesuai urutan yang disediakan.
Menggunakan pernyataan berparameter adalah praktik terbaik karena memisahkan struktur pernyataan dari nilai data, membuat pernyataan lebih mudah dibaca dan digunakan kembali. Ini juga menghindari kebutuhan untuk secara manual memformat dan melarikan diri nilai atribut dalam string pernyataan.
Pernyataan parameter didukung dalam`ExecuteStatement`,`BatchExecuteStatement`, dan `ExecuteTransaction` operasi.
Contoh berikut mengambil item dari `Music` tabel menggunakan nilai parameter untuk kunci partisi dan kunci sortir.
------
#### [ AWS CLI parameterized ]
```
aws dynamodb execute-statement \
--statement "SELECT * FROM \"Music\" WHERE Artist=? AND SongTitle=?" \
--parameters '[{"S": "Acme Band"}, {"S": "PartiQL Rocks"}]'
```
------
#### [ Java parameterized ]
```
List parameters = new ArrayList<>();
parameters.add(new AttributeValue("Acme Band"));
parameters.add(new AttributeValue("PartiQL Rocks"));
ExecuteStatementRequest request = new ExecuteStatementRequest()
.withStatement("SELECT * FROM Music WHERE Artist=? AND SongTitle=?")
.withParameters(parameters);
ExecuteStatementResult result = dynamoDB.executeStatement(request);
```
------
#### [ Python parameterized ]
```
response = dynamodb_client.execute_statement(
Statement="SELECT * FROM Music WHERE Artist=? AND SongTitle=?",
Parameters=[
{'S': 'Acme Band'},
{'S': 'PartiQL Rocks'}
]
)
```
------
**catatan**
Contoh Java di bagian memulai sebelumnya menggunakan pernyataan berparameter di seluruh. `getPartiQLParameters()`Metode ini membangun daftar parameter, dan setiap pernyataan menggunakan `?` placeholder alih-alih nilai inline.
# Jenis data PartiQL untuk DynamoDB
Tabel berikut mencantumkan jenis data yang dapat Anda gunakan dengan PartiQL untuk DynamoDB.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/ql-reference.data-types.html)
## Contoh
Pernyataan berikut menunjukkan cara memasukkan jenis data berikut: `String`, `Number`, `Map`, `List`, `Number Set`, dan `String Set`.
```
INSERT INTO TypesTable value {'primarykey':'1',
'NumberType':1,
'MapType' : {'entryname1': 'value', 'entryname2': 4},
'ListType': [1,'stringval'],
'NumberSetType':<<1,34,32,4.5>>,
'StringSetType':<<'stringval','stringval2'>>
}
```
Pernyataan berikut menunjukkan cara menyisipkan elemen baru ke dalam jenis `Map`, `List`, `Number Set`, and `String Set` serta mengubah nilai jenis `Number`.
```
UPDATE TypesTable
SET NumberType=NumberType + 100
SET MapType.NewMapEntry=[2020, 'stringvalue', 2.4]
SET ListType = LIST_APPEND(ListType, [4, <<'string1', 'string2'>>])
SET NumberSetType= SET_ADD(NumberSetType, <<345, 48.4>>)
SET StringSetType = SET_ADD(StringSetType, <<'stringsetvalue1', 'stringsetvalue2'>>)
WHERE primarykey='1'
```
Pernyataan berikut menunjukkan cara menghapus elemen dari jenis `Map`, `List`, `Number Set`, and `String Set` serta mengubah nilai jenis `Number`.
```
UPDATE TypesTable
SET NumberType=NumberType - 1
REMOVE ListType[1]
REMOVE MapType.NewMapEntry
SET NumberSetType = SET_DELETE( NumberSetType, <<345>>)
SET StringSetType = SET_DELETE( StringSetType, <<'stringsetvalue1'>>)
WHERE primarykey='1'
```
Untuk informasi selengkapnya, lihat [jenis data DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes).
# Pernyataan PartiQL untuk DynamoDB
Amazon DynamoDB mendukung pernyataan PartiQL berikut.
**catatan**
DynamoDB tidak mendukung semua pernyataan PartiQL.
Referensi ini memberikan sintaks dasar dan contoh penggunaan pernyataan PartiQL yang Anda jalankan secara manual menggunakan or. AWS CLI APIs
*Bahasa manipulasi data* (DML) adalah kumpulan pernyataan PartiQL yang Anda gunakan untuk mengelola data dalam tabel DynamoDB. Anda menggunakan pernyataan DML untuk menambah, mengubah, atau menghapus data dalam sebuah tabel.
Berikut DML dan kueri bahasa pernyataan yang didukung:
+ [Pernyataan pemilihan PartiQL untuk DynamoDB](ql-reference.select.md)
+ [Pernyataan pembaruan PartiQL untuk DynamoDB](ql-reference.update.md)
+ [Pernyataan sisipkan PartiQL untuk DynamoDB](ql-reference.insert.md)
+ [Pernyataan hapus PartiQL untuk DynamoDB](ql-reference.delete.md)
[Melakukan transaksi dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.transactions.md) and [Menjalankan operasi batch dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.batching.md) juga didukung oleh PartiQL untuk DynamoDB.
# Pernyataan pemilihan PartiQL untuk DynamoDB
Gunakan pernyataan `SELECT` untuk mengambil data dari tabel di Amazon DynamoDB.
Menggunakan `SELECT` pernyataan dapat menghasilkan pemindaian tabel lengkap jika kondisi kesetaraan atau IN dengan kunci partisi tidak disediakan dalam klausa WHERE. Operasi pemindaian memeriksa setiap item untuk nilai yang diminta dan dapat menggunakan throughput yang disediakan untuk indeks atau tabel besar dalam satu operasi.
Jika ingin menghindari pemindaian tabel secara lengkap di PartiQL, Anda dapat:
+ Menulis pernyataan `SELECT` Anda agar tidak memindai tabel secara lengkap dengan memastikan [ketentuan klausul WHERE](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html#ql-reference.select.parameters) Anda dikonfigurasi dengan semestinya.
+ Menonaktifkan pemindaian tabel lengkap menggunakan kebijakan IAM yang ditentukan di [Contoh: Mengizinkan pernyataan pilihan dan menolak pernyataan pemindaian tabel lengkap di PartiQL untuk DynamoDB](ql-iam.md#access-policy-ql-iam-example6), dalam panduan developer DynamoDB.
Untuk informasi selengkapnya, lihat [Praktik terbaik untuk Mengkueri dan memindai data](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-query-scan.html), dalam panduan developer DynamoDB.
**Topics**
+ [Sintaks](#ql-reference.select.syntax)
+ [Parameter](#ql-reference.select.parameters)
+ [Contoh](#ql-reference.select.examples)
## Sintaks
```
SELECT expression [, ...]
FROM table[.index]
[ WHERE condition ] [ [ORDER BY key [DESC|ASC] , ...]
```
## Parameter
***expression***
(Diperlukan) Proyeksi yang terbentuk dari wildcard `*` atau daftar proyeksi dari satu nama atribut atau lebih atau jalur dokumen dari set hasil. Ekspresi dapat terdiri dari panggilan ke [Gunakan fungsi PartiQL dengan DynamoDB](ql-functions.md) atau bidang yang diubah oleh [Aritmatika PartiQL, perbandingan, dan operator logika untuk DynamoDB](ql-operators.md).
***table***
(Diperlukan) Nama tabel untuk kueri.
***index***
(Opsional) Nama indeks untuk kueri.
Anda harus menambahkan tanda kutip ganda ke nama tabel dan nama indeks saat mengkueri indeks.
```
SELECT *
FROM "TableName"."IndexName"
```
***condition***
(Opsional) Kriteria seleksi untuk kueri.
Untuk memastikan bahwa pernyataan `SELECT` tidak menghasilkan pemindaian tabel secara lengkap, kondisi klausul `WHERE` harus menentukan kunci partisi. Gunakan kesetaraan atau operator IN.
Misalnya, jika Anda memiliki tabel `Orders` dengan kunci partisi `OrderID` dan atribut non-kunci lainnya, termasuk `Address`, pernyataan berikut tidak akan menghasilkan pemindaian tabel secara lengkap:
```
SELECT *
FROM "Orders"
WHERE OrderID = 100
SELECT *
FROM "Orders"
WHERE OrderID = 100 and Address='some address'
SELECT *
FROM "Orders"
WHERE OrderID = 100 or OrderID = 200
SELECT *
FROM "Orders"
WHERE OrderID IN [100, 300, 234]
```
Namun, pernyataan `SELECT` berikut akan menghasilkan pemindaian tabel secara lengkap:
```
SELECT *
FROM "Orders"
WHERE OrderID > 1
SELECT *
FROM "Orders"
WHERE Address='some address'
SELECT *
FROM "Orders"
WHERE OrderID = 100 OR Address='some address'
```
***key***
(Opsional) Kunci hash atau kunci urutan untuk digunakan dalam mengurutkan hasil yang dikembalikan. Urutan defaultnya adalah naik (`ASC`) tentukan `DESC` jika Anda ingin hasil dikembalikan dalam urutan turun.
**catatan**
Jika Anda menghapus klausul `WHERE`, semua item dalam tabel akan diambil.
## Contoh
Kueri berikut mengembalikan satu item, jika ada, dari tabel `Orders` dengan menentukan kunci partisi, `OrderID`, dan menggunakan operator kesetaraan.
```
SELECT OrderID, Total
FROM "Orders"
WHERE OrderID = 1
```
Kueri berikut mengembalikan semua item dalam tabel `Orders` yang memiliki kunci partisi spesifik, `OrderID`, nilai menggunakan operator OR.
```
SELECT OrderID, Total
FROM "Orders"
WHERE OrderID = 1 OR OrderID = 2
```
Kueri berikut mengembalikan semua item dalam tabel `Orders` yang memiliki kunci partisi spesifik, `OrderID`, nilai menggunakan operator IN. Hasil yang dikembalikan dalam urutan turun, berdasarkan nilai atribut kunci `OrderID`.
```
SELECT OrderID, Total
FROM "Orders"
WHERE OrderID IN [1, 2, 3] ORDER BY OrderID DESC
```
Kueri berikut menunjukkan pemindaian tabel secara lengkap yang mengembalikan semua item dari tabel `Orders` yang memiliki `Total` lebih dari 500, dengan `Total` adalah atribut non-kunci.
```
SELECT OrderID, Total
FROM "Orders"
WHERE Total > 500
```
Kueri berikut menunjukkan pemindaian tabel secara lengkap yang mengembalikan semua item dari tabel `Orders` di dalam rentang urutan `Total` tertentu, menggunakan operator IN dan atribut non-kunci `Total`.
```
SELECT OrderID, Total
FROM "Orders"
WHERE Total IN [500, 600]
```
Kueri berikut menunjukkan pemindaian tabel secara lengkap yang mengembalikan semua item dari tabel `Orders` di dalam rentang urutan `Total` tertentu, menggunakan operator BETWEEN dan atribut non-kunci `Total`.
```
SELECT OrderID, Total
FROM "Orders"
WHERE Total BETWEEN 500 AND 600
```
Kueri berikut mengembalikan tanggal pertama perangkat firestick digunakan untuk menonton dengan menentukan kunci partisi `CustomerID` dan kunci urutan `MovieID` dalam kondisi klausul WHERE dan menggunakan jalur dokumen dalam klausul SELECT.
```
SELECT Devices.FireStick.DateWatched[0]
FROM WatchList
WHERE CustomerID= 'C1' AND MovieID= 'M1'
```
Kueri berikut menunjukkan pemindaian tabel secara penuh yang mengembalikan daftar item tempat perangkat firestick pertama kali digunakan setelah 24/12/19 menggunakan jalur dokumen dalam kondisi klausul WHERE.
```
SELECT Devices
FROM WatchList
WHERE Devices.FireStick.DateWatched[0] >= '12/24/19'
```
# Pernyataan pembaruan PartiQL untuk DynamoDB
Gunakan pernyataan `UPDATE` untuk mengubah nilai dari satu atribut atau lebih dalam item dalam tabel Amazon DynamoDB.
**catatan**
Anda hanya dapat memperbarui satu item pada satu waktu; Anda tidak dapat mengeluarkan pernyataan DynamoDB PartiQL tunggal yang memperbarui beberapa item. Untuk informasi tentang memperbarui beberapa item, lihat [Melakukan transaksi dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.transactions.md) atau [Menjalankan operasi batch dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.batching.md).
**Topics**
+ [Sintaks](#ql-reference.update.syntax)
+ [Parameter](#ql-reference.update.parameters)
+ [Nilai yang dikembalikan](#ql-reference.update.return)
+ [Contoh](#ql-reference.update.examples)
## Sintaks
```
UPDATE table
[SET | REMOVE] path [= data] […]
WHERE condition [RETURNING returnvalues]
::= [ALL OLD | MODIFIED OLD | ALL NEW | MODIFIED NEW] *
```
## Parameter
***table***
(Diperlukan) Tabel yang berisi data yang akan diubah.
***path***
(Diperlukan) Nama atribut atau jalur dokumen yang akan dibuat atau diubah.
***data***
(Diperlukan) Nilai atribut atau hasil operasi.
Operasi yang didukung untuk digunakan bersama SET:
+ LIST\$1APPEND: menambahkan nilai ke jenis daftar.
+ SET\$1ADD: menambahkan nilai ke set angka atau string.
+ SET\$1DELETE: menghapus nilai dari set angka atau string.
***condition***
(Diperlukan) Kriteria pemilihan untuk item yang akan diubah. Syarat ini harus diselesaikan untuk satu nilai kunci primer.
***returnvalues***
(Opsional) Gunakan `returnvalues` jika Anda ingin mendapatkan atribut item seperti yang muncul sebelum atau setelah diperbarui. Nilai yang valid adalah:
+ `ALL OLD *`- Mengembalikan semua atribut item, saat atribut item tersebut muncul sebelum operasi pembaruan.
+ `MODIFIED OLD *`- Mengembalikan hanya atribut yang diperbarui, saat atribut item tersebut muncul sebelum operasi pembaruan.
+ `ALL NEW *`- Mengembalikan semua atribut item, seperti yang muncul setelah operasi pembaruan.
+ `MODIFIED NEW *`- Hanya mengembalikan atribut yang diperbarui, seperti yang muncul setelah operasi `UpdateItem`.
## Nilai yang dikembalikan
Pernyataan ini tidak mengembalikan nilai kecuali parameter `returnvalues` ditentukan.
**catatan**
Jika klausul WHERE pernyataan UPDATE tidak dinilai true untuk item apa pun dalam tabel DynamoDB, `ConditionalCheckFailedException` akan dikembalikan.
## Contoh
Memperbarui nilai atribut dalam item yang sudah ada. Jika atribut tersebut tidak ada, atribut tersebut akan dibuat.
Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan atribut dari nomor jenis (`AwardsWon`) dan atribut dari jenis peta (`AwardDetail`).
```
UPDATE "Music"
SET AwardsWon=1
SET AwardDetail={'Grammys':[2020, 2018]}
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Anda dapat menambahkan `RETURNING ALL OLD *` untuk mengembalikan atribut seperti yang muncul sebelum operasi `Update`.
```
UPDATE "Music"
SET AwardsWon=1
SET AwardDetail={'Grammys':[2020, 2018]}
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
RETURNING ALL OLD *
```
Ini akan menghasilkan hal berikut:
```
{
"Items": [
{
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "PartiQL Rocks"
}
}
]
}
```
Anda dapat menambahkan `RETURNING ALL NEW *` untuk mengembalikan atribut seperti yang muncul setelah operasi `Update`.
```
UPDATE "Music"
SET AwardsWon=1
SET AwardDetail={'Grammys':[2020, 2018]}
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
RETURNING ALL NEW *
```
Ini akan menghasilkan hal berikut:
```
{
"Items": [
{
"AwardDetail": {
"M": {
"Grammys": {
"L": [
{
"N": "2020"
},
{
"N": "2018"
}
]
}
}
},
"AwardsWon": {
"N": "1"
}
}
]
}
```
Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan ke daftar `AwardDetail.Grammys`.
```
UPDATE "Music"
SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016])
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Kueri berikut memperbarui item dalam tabel `"Music"` dengan menghapus dari daftar `AwardDetail.Grammys`.
```
UPDATE "Music"
REMOVE AwardDetail.Grammys[2]
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan `BillBoard` ke peta `AwardDetail`.
```
UPDATE "Music"
SET AwardDetail.BillBoard=[2020]
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan atribut set string `BandMembers`.
```
UPDATE "Music"
SET BandMembers =<<'member1', 'member2'>>
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan `newbandmember` ke set string `BandMembers`.
```
UPDATE "Music"
SET BandMembers =set_add(BandMembers, <<'newbandmember'>>)
WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'
```
# Pernyataan hapus PartiQL untuk DynamoDB
Gunakan pernyataan `DELETE` untuk menghapus item yang sudah ada dari tabel Amazon DynamoDB Anda.
**catatan**
Anda hanya dapat menghapus satu item dalam satu waktu. Anda tidak dapat mengeluarkan pernyataan DynamoDB PartiQL tunggal yang menghapus beberapa item. Untuk informasi tentang menghapus beberapa item, lihat [Melakukan transaksi dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.transactions.md) atau [Menjalankan operasi batch dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.batching.md).
**Topics**
+ [Sintaks](#ql-reference.delete.syntax)
+ [Parameter](#ql-reference.delete.parameters)
+ [Nilai yang dikembalikan](#ql-reference.delete.return)
+ [Contoh](#ql-reference.delete.examples)
## Sintaks
```
DELETE FROM table
WHERE condition [RETURNING returnvalues]
::= ALL OLD *
```
## Parameter
***table***
(Diperlukan) Tabel DynamoDB yang berisi item yang akan dihapus.
***condition***
(Diperlukan) Kriteria seleksi untuk item yang akan dihapus; syarat ini harus diselesaikan untuk nilai kunci primer tunggal.
***returnvalues***
(Opsional) Gunakan `returnvalues` jika Anda ingin mendapatkan atribut item seperti yang muncul sebelum atribut item tersebut dihapus. Nilai yang valid adalah:
+ `ALL OLD *`- Konten dari item lama akan dikembalikan.
## Nilai yang dikembalikan
Pernyataan ini tidak mengembalikan nilai kecuali parameter `returnvalues` ditentukan.
**catatan**
Jika tabel DynamoDB tidak memiliki item dengan kunci primer yang sama seperti yang item yang DELETE-nya dikeluarkan, SUCCESS dikembalikan dengan 0 item dihapus. Jika tabel memiliki item dengan kunci primer yang sama, tetapi syarat dalam klausul WHERE pernyataan dari DELETE bernilai false, `ConditionalCheckFailedException` akan dikembalikan.
## Contoh
Kueri berikut akan menghapus item dalam tabel `"Music"`.
```
DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks'
```
Anda dapat menambahkan parameter `RETURNING ALL OLD *` untuk mengembalikan data yang telah dihapus.
```
DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' RETURNING ALL OLD *
```
Pernyataan `Delete` sekarang mengembalikan yang berikut:
```
{
"Items": [
{
"Artist": {
"S": "Acme Band"
},
"SongTitle": {
"S": "PartiQL Rocks"
}
}
]
}
```
# Pernyataan sisipkan PartiQL untuk DynamoDB
Gunakan pernyataan `INSERT` untuk menambahkan item ke tabel di Amazon DynamoDB.
**catatan**
Anda hanya dapat menyisipkan satu item pada satu waktu; Anda tidak dapat mengeluarkan pernyataan DynamoDB PartiQL tunggal yang menyisipkan beberapa item. Untuk informasi tentang cara menyisipkan beberapa item, lihat [Melakukan transaksi dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.transactions.md) atau [Menjalankan operasi batch dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.batching.md).
**Topics**
+ [Sintaksis](#ql-reference.insert.syntax)
+ [Parameter](#ql-reference.insert.parameters)
+ [Nilai yang dikembalikan](#ql-reference.insert.return)
+ [Contoh](#ql-reference.insert.examples)
## Sintaksis
Sisipkan satu item.
```
INSERT INTO table VALUE item
```
## Parameter
***table***
(Diperlukan) Tabel tempat Anda ingin menyisipkan data. Tabel harus sudah ada.
***item***
(Diperlukan) Item DynamoDB yang valid diwakili sebagai [tupel PartiQL](https://partiql.org/docs.html). Anda harus menentukan hanya *satu* item dan setiap nama atribut dalam item adalah peka huruf besar-kecil dan dapat dilambangkan dengan tanda petik *tunggal* (`'...'`) di PartiQL.
Nilai string juga dilambangkan dengan tanda petik *tunggal* (`'...'`) di PartiQL.
## Nilai yang dikembalikan
Pernyataan ini tidak mengembalikan nilai apa pun.
**catatan**
Jika tabel DynamoDB sudah memiliki item dengan kunci primer yang sama sebagai kunci primer dari item yang sedang disisipkan, `DuplicateItemException` dikembalikan.
## Contoh
```
INSERT INTO "Music" value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'}
```
# Gunakan fungsi PartiQL dengan DynamoDB
PartiQL di Amazon DynamoDB mendukung varian bawaan fungsi standar SQL berikut.
**catatan**
Fungsi SQL apa pun yang tidak termasuk dalam daftar ini saat ini tidak didukung di DynamoDB.
## Fungsi agregat
+ [Menggunakan Fungsi SIZE dengan PartiQL untuk Amazon DynamoDB](ql-functions.size.md)
## Fungsi kondisional
+ [Menggunakan fungsi EXISTS dengan PartiQL untuk DynamoDB](ql-functions.exists.md)
+ [Menggunakan Fungsi ATTRIBUTE\$1TYPE dengan PartiQL untuk DynamoDB](ql-functions.attribute_type.md)
+ [Menggunakan Fungsi BEGINS\$1WITH dengan PartiQL untuk DynamoDB](ql-functions.beginswith.md)
+ [Menggunakan fungsi COUNTAINS dengan PartiQL untuk DynamoDB](ql-functions.contains.md)
+ [Menggunakan fungsi MISSING dengan PartiQL untuk DynamoDB](ql-functions.missing.md)
# Menggunakan fungsi EXISTS dengan PartiQL untuk DynamoDB
Anda dapat menggunakan EXISTS untuk melakukan fungsi yang sama seperti `ConditionCheck` di [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)API. Fungsi EXISTS hanya dapat digunakan dalam transaksi.
Dengan nilai, mengembalikan `TRUE` jika nilai adalah kumpulan yang tidak kosong. Jika tidak, mengembalikan `FALSE`.
**catatan**
Fungsi ini hanya dapat digunakan dalam operasi transaksional.
## Sintaks
```
EXISTS ( statement )
```
## Pendapat
*statement*
(Diperlukan) Pernyataan SELECT yang dievaluasi oleh fungsi.
Pernyataan SELECT harus menentukan kunci primer lengkap dan satu kondisi lainnya.
## Jenis pengembalian
`bool`
## Contoh
```
EXISTS(
SELECT * FROM "Music"
WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks')
```
# Menggunakan Fungsi BEGINS\$1WITH dengan PartiQL untuk DynamoDB
Mengembalikan `TRUE` jika atribut yang ditentukan dimulai dengan substring tertentu.
## Sintaks
```
begins_with(path, value )
```
## Pendapat
*path*
(Diperlukan) Nama atribut atau jalur dokumen yang akan digunakan.
*value*
(Diperlukan) String untuk mencari.
## Jenis pengembalian
`bool`
## Contoh
```
SELECT * FROM "Orders" WHERE "OrderID"=1 AND begins_with("Address", '7834 24th')
```
# Menggunakan fungsi MISSING dengan PartiQL untuk DynamoDB
Mengembalikan `TRUE` jika item tidak berisi atribut yang ditentukan. Hanya operator kesetaraan dan ketidaksetaraan yang dapat digunakan dengan fungsi ini.
## Sintaks
```
attributename IS | IS NOT MISSING
```
## Pendapat
*attributename*
(Diperlukan) Nama atribut yang akan dicari.
## Jenis pengembalian
`bool`
## Contoh
```
SELECT * FROM Music WHERE "Awards" is MISSING
```
# Menggunakan Fungsi ATTRIBUTE\$1TYPE dengan PartiQL untuk DynamoDB
Mengembalikan `TRUE` jika atribut pada jalur yang ditentukan adalah jenis data tertentu.
## Sintaks
```
attribute_type( attributename, type )
```
## Pendapat
*attributename*
(Diperlukan) Nama atribut yang digunakan.
*type*
(Wajib) Jenis atribut yang akan diperiksa. Untuk daftar nilai yang valid, lihat [attribute\$1type](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB.
## Jenis pengembalian
`bool`
## Contoh
```
SELECT * FROM "Music" WHERE attribute_type("Artist", 'S')
```
# Menggunakan fungsi COUNTAINS dengan PartiQL untuk DynamoDB
Mengembalikan `TRUE` jika atribut yang ditentukan oleh jalur tersebut adalah salah satu dari hal berikut:
+ String yang berisi substring tertentu.
+ Set yang berisi elemen tertentu dalam set.
Untuk informasi selengkapnya, lihat fungsi [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB.
## Sintaks
```
contains( path, substring )
```
## Pendapat
*path*
(Diperlukan) Nama atribut atau jalur dokumen yang akan digunakan.
*substring*
(Diperlukan) Substring atribut atau anggota yang ditetapkan yang akan diperiksa. Untuk informasi selengkapnya, lihat fungsi [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB.
## Jenis pengembalian
`bool`
## Contoh
```
SELECT * FROM "Orders" WHERE "OrderID"=1 AND contains("Address", 'Kirkland')
```
# Menggunakan Fungsi SIZE dengan PartiQL untuk Amazon DynamoDB
Mengembalikan angka yang mewakili ukuran atribut dalam byte. Berikut ini adalah jenis daya yang valid untuk digunakan dengan size. Untuk informasi selengkapnya, lihat fungsi [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB.
## Sintaks
```
size( path)
```
## Pendapat
*path*
(Diperlukan) Nama atribut atau jalur dokumen.
Untuk jenis yang didukung, lihat fungsi [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB.
## Jenis pengembalian
`int`
## Contoh
```
SELECT * FROM "Orders" WHERE "OrderID"=1 AND size("Image") >300
```
# Aritmatika PartiQL, perbandingan, dan operator logika untuk DynamoDB
PartiQL di Amazon DynamoDB mendukung [Operator standar SQL](https://www.w3schools.com/sql/sql_operators.asp) berikut.
**catatan**
Operator SQL apa pun yang tidak termasuk dalam daftar ini saat ini tidak didukung di DynamoDB.
## Operator aritmatika
****
| Operator | Deskripsi |
| --- | --- |
| \$1 | Tambahkan |
| - | Kurangi |
## Operator perbandingan
****
| Operator | Deskripsi |
| --- | --- |
| = | Sama dengan |
| <> | Tidak Sama dengan |
| \$1= | Tidak Sama dengan |
| > | Lebih besar dari |
| < | Kurang dari |
| >= | Lebih besar dari atau sama dengan |
| <= | Kurang dari atau sama dengan |
## Operator logis
****
| Operator | Deskripsi |
| --- | --- |
| AND | TRUE jika semua kondisi yang dipisahkan oleh AND adalah TRUE |
| BETWEEN | `TRUE`jika operan berada dalam kisaran perbandingan. Operator ini termasuk batas bawah dan atas operan tempat Anda menerapkannya. |
| IN | `TRUE`jika operan sama dengan salah satu daftar ekspresi (maksimal 50 nilai atribut hash atau maksimal 100 nilai atribut non-kunci). Hasil dikembalikan dalam halaman hingga 10 item. Jika `IN` daftar berisi lebih banyak nilai, Anda harus menggunakan yang `NextToken` dikembalikan dalam respons untuk mengambil halaman berikutnya. |
| IS | TRUE jika operannya adalah jenis data PartiQL tertentu, termasuk NULL atau MISSING |
| NOT | Membalikkan nilai ekspresi Boolean yang diberikan |
| OR | TRUE jika semua kondisi yang dipisahkan oleh OR adalah TRUE |
Untuk informasi selengkapnya tentang menggunakan operator logika, lihat [Membuat perbandingan](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.Comparators) dan[Evaluasi logika](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.LogicalEvaluations).
# Melakukan transaksi dengan PartiQL untuk DynamoDB
Bagian ini menjelaskan cara menggunakan transaksi dengan PartiQL untuk DynamoDB. Transaksi PartiQL dibatasi hingga 100 total pernyataan (tindakan).
Untuk informasi lebih lanjut tentang transaksi DynamoDB, lihat [Mengelola alur kerja kompleks dengan transaksi DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html).
**catatan**
Seluruh transaksi harus terdiri dari pernyataan baca atau pernyataan tulis. Anda tidak dapat menggabungkan keduanya dalam satu transaksi. Fungsi EXISTS merupakan pengecualian. Anda dapat menggunakannya untuk memeriksa kondisi atribut tertentu dari item dengan cara yang mirip `ConditionCheck` dengan operasi [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)API.
**Topics**
+ [Sintaks](#ql-reference.multiplestatements.transactions.syntax)
+ [Parameter](#ql-reference.multiplestatements.transactions.parameters)
+ [Nilai yang dikembalikan](#ql-reference.multiplestatements.transactions.return)
+ [Contoh](#ql-reference.multiplestatements.transactions.examples)
## Sintaks
```
[
{
"Statement":" statement ",
"Parameters":[
{
" parametertype " : " parametervalue "
}, ...]
} , ...
]
```
## Parameter
***statement***
(Diperlukan) Pernyataan yang didukung PartiQL untuk DynamoDB.
Seluruh transaksi harus terdiri dari pernyataan baca atau pernyataan tulis. Anda tidak dapat menggabungkan keduanya dalam satu transaksi.
***parametertype***
(Opsional) Jenis DynamoDB, jika parameter digunakan saat menentukan pernyataan PartiQL.
***parametervalue***
(Opsional) Nilai parameter jika parameter digunakan saat menentukan pernyataan PartiQL.
## Nilai yang dikembalikan
Pernyataan ini tidak mengembalikan nilai apa pun untuk operasi Tulis (INSERT, UPDATE, atau DELETE). Namun, ia mengembalikan nilai yang berbeda untuk operasi Baca (SELECT) berdasarkan kondisi yang ditentukan dalam klausul WHERE.
**catatan**
Jika salah satu operasi INSERT, UPDATE, atau DELETE singleton mengembalikan kesalahan, transaksi dibatalkan dengan pengecualian `TransactionCanceledException`, dan kode alasan pembatalan termasuk kesalahan dari operasi singleton individual.
## Contoh
Contoh berikut menjalankan beberapa pernyataan sebagai sebuah transaksi.
------
#### [ AWS CLI ]
1. Simpan kode JSON berikut ke file bernama partiql.json.
```
[
{
"Statement": "EXISTS(SELECT * FROM \"Music\" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)"
},
{
"Statement": "INSERT INTO Music value {'Artist':?,'SongTitle':'?'}",
"Parameters": [{\"S\": \"Acme Band\"}, {\"S\": \"Best Song\"}]
},
{
"Statement": "UPDATE \"Music\" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'"
}
]
```
1. Jalankan perintah berikut di prompt perintah.
```
aws dynamodb execute-transaction --transact-statements file://partiql.json
```
------
#### [ Java ]
```
public class DynamoDBPartiqlTransaction {
public static void main(String[] args) {
// Create the DynamoDB Client with the region you want
AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2");
try {
// Create ExecuteTransactionRequest
ExecuteTransactionRequest executeTransactionRequest = createExecuteTransactionRequest();
ExecuteTransactionResult executeTransactionResult = dynamoDB.executeTransaction(executeTransactionRequest);
System.out.println("ExecuteTransaction successful.");
// Handle executeTransactionResult
} catch (Exception e) {
handleExecuteTransactionErrors(e);
}
}
private static AmazonDynamoDB createDynamoDbClient(String region) {
return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}
private static ExecuteTransactionRequest createExecuteTransactionRequest() {
ExecuteTransactionRequest request = new ExecuteTransactionRequest();
// Create statements
List statements = getPartiQLTransactionStatements();
request.setTransactStatements(statements);
return request;
}
private static List getPartiQLTransactionStatements() {
List statements = new ArrayList();
statements.add(new ParameterizedStatement()
.withStatement("EXISTS(SELECT * FROM "Music" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)"));
statements.add(new ParameterizedStatement()
.withStatement("INSERT INTO "Music" value {'Artist':'?','SongTitle':'?'}")
.withParameters(new AttributeValue("Acme Band"),new AttributeValue("Best Song")));
statements.add(new ParameterizedStatement()
.withStatement("UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'"));
return statements;
}
// Handles errors during ExecuteTransaction execution. Use recommendations in error messages below to add error handling specific to
// your application use-case.
private static void handleExecuteTransactionErrors(Exception exception) {
try {
throw exception;
} catch (TransactionCanceledException tce) {
System.out.println("Transaction Cancelled, implies a client issue, fix before retrying. Error: " + tce.getErrorMessage());
} catch (TransactionInProgressException tipe) {
System.out.println("The transaction with the given request token is already in progress, consider changing " +
"retry strategy for this type of error. Error: " + tipe.getErrorMessage());
} catch (IdempotentParameterMismatchException ipme) {
System.out.println("Request rejected because it was retried with a different payload but with a request token that was already used, " +
"change request token for this payload to be accepted. Error: " + ipme.getErrorMessage());
} catch (Exception e) {
handleCommonErrors(e);
}
}
private static void handleCommonErrors(Exception exception) {
try {
throw exception;
} catch (InternalServerErrorException isee) {
System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage());
} catch (RequestLimitExceededException rlee) {
System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " +
"retrying. Error: " + rlee.getErrorMessage());
} catch (ProvisionedThroughputExceededException ptee) {
System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " +
"Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " +
ptee.getErrorMessage());
} catch (ResourceNotFoundException rnfe) {
System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage());
} catch (AmazonServiceException ase) {
System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " +
"service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " +
"configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage());
} catch (AmazonClientException ace) {
System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " +
"service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+
"Error: " + ace.getMessage());
} catch (Exception e) {
System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage());
}
}
}
```
------
Contoh berikut menunjukkan nilai pengembalian yang berbeda ketika DynamoDB membaca item dengan kondisi berbeda yang ditentukan dalam klausul WHERE.
------
#### [ AWS CLI ]
1. Simpan kode JSON berikut ke file bernama partiql.json.
```
[
// Item exists and projected attribute exists
{
"Statement": "SELECT * FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'"
},
// Item exists but projected attributes do not exist
{
"Statement": "SELECT non_existent_projected_attribute FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'"
},
// Item does not exist
{
"Statement": "SELECT * FROM "Music" WHERE Artist='No One I Know' and SongTitle='Call You Today'"
}
]
```
1. perintah berikut di prompt perintah.
```
aws dynamodb execute-transaction --transact-statements file://partiql.json
```
1. Respons berikut dikembalikan:
```
{
"Responses": [
// Item exists and projected attribute exists
{
"Item": {
"Artist":{
"S": "No One You Know"
},
"SongTitle":{
"S": "Call Me Today"
}
}
},
// Item exists but projected attributes do not exist
{
"Item": {}
},
// Item does not exist
{}
]
}
```
------
# Menjalankan operasi batch dengan PartiQL untuk DynamoDB
Bagian ini menjelaskan cara menggunakan pernyataan batch dengan PartiQL untuk DynamoDB.
**catatan**
Keseluruhan batch harus terdiri dari pernyataan baca atau pernyataan tulis; Anda tidak dapat mencampur keduanya dalam satu batch.
`BatchExecuteStatement` dan `BatchWriteItem` dapat melakukan tidak lebih dari 25 pernyataan per batch.
`BatchExecuteStatement`memanfaatkan `BatchGetItem` yang mengambil daftar kunci utama dalam pernyataan terpisah.
**Topics**
+ [Sintaks](#ql-reference.multiplestatements.batching.syntax)
+ [Parameter](#ql-reference.multiplestatements.batching.parameters)
+ [Contoh](#ql-reference.multiplestatements.batching.examples)
## Sintaks
```
[
{
"Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#9StkWHYTxm7x2AqSXcrfu7' AND sk = 'info'"
},
{
"Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#isC2ChceGbxHgESc4szoTE' AND sk = 'info'"
}
]
```
```
[
{
"Statement":" statement ",
"Parameters":[
{
" parametertype " : " parametervalue "
}, ...]
} , ...
]
```
## Parameter
***statement***
(Diperlukan) Pernyataan yang didukung PartiQL untuk DynamoDB.
+ Keseluruhan batch harus terdiri dari pernyataan baca atau pernyataan tulis; Anda tidak dapat mencampur keduanya dalam satu batch.
+ `BatchExecuteStatement` dan `BatchWriteItem` dapat melakukan tidak lebih dari 25 pernyataan per batch.
***parametertype***
(Opsional) Jenis DynamoDB, jika parameter digunakan saat menentukan pernyataan PartiQL.
***parametervalue***
(Opsional) Nilai parameter jika parameter digunakan saat menentukan pernyataan PartiQL.
## Contoh
------
#### [ AWS CLI ]
1. Simpan json berikut ke file bernama partiql.json
```
[
{
"Statement": "INSERT INTO Music VALUE {'Artist':?,'SongTitle':?}",
"Parameters": [{"S": "Acme Band"}, {"S": "Best Song"}]
},
{
"Statement": "UPDATE Music SET AwardsWon=1, AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'"
}
]
```
1. Jalankan perintah berikut di prompt perintah.
```
aws dynamodb batch-execute-statement --statements file://partiql.json
```
------
#### [ Java ]
```
public class DynamoDBPartiqlBatch {
public static void main(String[] args) {
// Create the DynamoDB Client with the region you want
AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2");
try {
// Create BatchExecuteStatementRequest
BatchExecuteStatementRequest batchExecuteStatementRequest = createBatchExecuteStatementRequest();
BatchExecuteStatementResult batchExecuteStatementResult = dynamoDB.batchExecuteStatement(batchExecuteStatementRequest);
System.out.println("BatchExecuteStatement successful.");
// Handle batchExecuteStatementResult
} catch (Exception e) {
handleBatchExecuteStatementErrors(e);
}
}
private static AmazonDynamoDB createDynamoDbClient(String region) {
return AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
}
private static BatchExecuteStatementRequest createBatchExecuteStatementRequest() {
BatchExecuteStatementRequest request = new BatchExecuteStatementRequest();
// Create statements
List statements = getPartiQLBatchStatements();
request.setStatements(statements);
return request;
}
private static List getPartiQLBatchStatements() {
List statements = new ArrayList();
statements.add(new BatchStatementRequest()
.withStatement("INSERT INTO Music value {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}"));
statements.add(new BatchStatementRequest()
.withStatement("UPDATE Music set AwardDetail.BillBoard=[2020] where Artist='Acme Band' and SongTitle='PartiQL Rocks'"));
return statements;
}
// Handles errors during BatchExecuteStatement execution. Use recommendations in error messages below to add error handling specific to
// your application use-case.
private static void handleBatchExecuteStatementErrors(Exception exception) {
try {
throw exception;
} catch (Exception e) {
// There are no API specific errors to handle for BatchExecuteStatement, common DynamoDB API errors are handled below
handleCommonErrors(e);
}
}
private static void handleCommonErrors(Exception exception) {
try {
throw exception;
} catch (InternalServerErrorException isee) {
System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage());
} catch (RequestLimitExceededException rlee) {
System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " +
"retrying. Error: " + rlee.getErrorMessage());
} catch (ProvisionedThroughputExceededException ptee) {
System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " +
"Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " +
ptee.getErrorMessage());
} catch (ResourceNotFoundException rnfe) {
System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage());
} catch (AmazonServiceException ase) {
System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " +
"service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " +
"configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage());
} catch (AmazonClientException ace) {
System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " +
"service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+
"Error: " + ace.getMessage());
} catch (Exception e) {
System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage());
}
}
}
```
------
# Kebijakan keamanan IAM dengan PartiQL untuk DynamoDB
Izin berikut diperlukan:
+ Untuk membaca item menggunakan PartiQL untuk DynamoDB, Anda harus memiliki izin `dynamodb:PartiQLSelect` pada tabel atau indeks.
+ Untuk menyisipkan item menggunakan PartiQL untuk DynamoDB, Anda harus memiliki izin `dynamodb:PartiQLInsert` pada tabel atau indeks.
+ Untuk memperbarui item menggunakan PartiQL untuk DynamoDB, Anda harus memiliki izin `dynamodb:PartiQLUpdate` pada tabel atau indeks.
+ Untuk menghapus item menggunakan PartiQL untuk DynamoDB, Anda harus memiliki izin `dynamodb:PartiQLDelete` pada tabel atau indeks.
## Contoh: Izinkan semua PartiQL untuk pernyataan DynamoDB () di atas meja Select/Insert/Update/Delete
Kebijakan IAM berikut memberikan izin untuk menjalankan semua pernyataan PartiQL untuk DynamoDB pada tabel.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}
```
------
## Contoh: Mengizinkan pernyataan pilih PartiQL untuk DynamoDB pada tabel
Kebijakan IAM berikut memberikan izin untuk menjalankan pernyataan `select` pada tabel tertentu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}
```
------
## Contoh: Mengizinkan PartiQL untuk pernyataan penyisipan DynamoDB pada indeks
Kebijakan IAM berikut memberikan izin untuk menjalankan pernyataan `insert` pada indeks tertentu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music/index/index1"
]
}
]
}
```
------
## Contoh: Mengizinkan PartiQL untuk pernyataan transaksional DynamoDB hanya pada tabel
Kebijakan IAM berikut memberikan izin untuk hanya menjalankan pernyataan transaksional pada tabel tertentu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
],
"Condition":{
"StringEquals":{
"dynamodb:EnclosingOperation":[
"ExecuteTransaction"
]
}
}
}
]
}
```
------
## Contoh: Mengizinkan PartiQL untuk pembacaan dan penulisan non-transaksional DynamoDB dan memblokir pernyataan transaksional pembacaan dan penulisan transaksional PartiQL pada tabel.
Kebijakan IAM berikut memberikan izin untuk menjalankan PartiQL untuk pembacaan dan penulisan non-transaksional DynamoDB sambil memblokir PartiQL untuk pembacaan dan penulisan transaksional DynamoDB.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Deny",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
],
"Condition":{
"StringEquals":{
"dynamodb:EnclosingOperation":[
"ExecuteTransaction"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLInsert",
"dynamodb:PartiQLUpdate",
"dynamodb:PartiQLDelete",
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/Music"
]
}
]
}
```
------
## Contoh: Mengizinkan pernyataan pilihan dan menolak pernyataan pemindaian tabel lengkap di PartiQL untuk DynamoDB
Kebijakan IAM berikut memberikan izin untuk menjalankan pernyataan `select` pada tabel tertentu sambil memblokir pernyataan `select` yang menghasilkan pemindaian tabel penuh.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Deny",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/WatchList"
],
"Condition":{
"Bool":{
"dynamodb:FullTableScan":[
"true"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"dynamodb:PartiQLSelect"
],
"Resource":[
"arn:aws:dynamodb:us-west-2:123456789012:table/WatchList"
]
}
]
}
```
------
# Bekerja dengan item: Java
Anda dapat menggunakan AWS SDK untuk Java Document API untuk melakukan operasi membuat, membaca, memperbarui, dan menghapus (CRUD) pada item Amazon DynamoDB dalam tabel.
**catatan**
SDK untuk Java juga menyediakan model persistensi objek, memungkinkan Anda memetakan kelas sisi klien ke tabel DynamoDB. Pendekatan ini dapat mengurangi jumlah kode yang harus Anda tulis. Untuk informasi selengkapnya, lihat [Java 1.x: Dinamo DBMapper](DynamoDBMapper.md).
Bagian ini berisi contoh Java untuk melakukan beberapa tindakan item Java Document API dan beberapa contoh kerja yang lengkap.
**Topics**
+ [Menempatkan item](#PutDocumentAPIJava)
+ [Mendapatkan item](#JavaDocumentAPIGetItem)
+ [Penulisan batch: Menempatkan dan menghapus beberapa item](#BatchWriteDocumentAPIJava)
+ [Batch get: Mendapatkan beberapa item](#JavaDocumentAPIBatchGetItem)
+ [Memperbarui Item](#JavaDocumentAPIItemUpdate)
+ [Menghapus item](#DeleteMidLevelJava)
+ [Contoh: Operasi CRUD menggunakan API AWS SDK untuk Java dokumen](JavaDocumentAPICRUDExample.md)
+ [Contoh: Operasi Batch menggunakan API AWS SDK untuk Java dokumen](batch-operation-document-api-java.md)
+ [Contoh: Menangani atribut tipe biner menggunakan API AWS SDK untuk Java dokumen](JavaDocumentAPIBinaryTypeExample.md)
## Menempatkan item
Metode `putItem` menyimpan item dalam tabel. Jika item ada, item tersebut akan menggantikan keseluruhan item. Alih-alih mengganti seluruh item, jika Anda hanya ingin memperbarui atribut tertentu, Anda dapat menggunakan metode `updateItem`. Untuk informasi selengkapnya, lihat [Memperbarui Item](#JavaDocumentAPIItemUpdate).
------
#### [ Java v2 ]
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.PutItemResponse;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To place items into an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client. See the EnhancedPutItem example.
*/
public class PutItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table in which an item is placed (for example, Music3).
key - The key used in the Amazon DynamoDB table (for example, Artist).
keyval - The key value that represents the item to get (for example, Famous Band).
albumTitle - The Album title (for example, AlbumTitle).
AlbumTitleValue - The name of the album (for example, Songs About Life ).
Awards - The awards column (for example, Awards).
AwardVal - The value of the awards (for example, 10).
SongTitle - The song title (for example, SongTitle).
SongTitleVal - The value of the song title (for example, Happy Day).
**Warning** This program will place an item that you specify into a table!
""";
if (args.length != 9) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
String albumTitle = args[3];
String albumTitleValue = args[4];
String awards = args[5];
String awardVal = args[6];
String songTitle = args[7];
String songTitleVal = args[8];
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
putItemInTable(ddb, tableName, key, keyVal, albumTitle, albumTitleValue, awards, awardVal, songTitle,
songTitleVal);
System.out.println("Done!");
ddb.close();
}
public static void putItemInTable(DynamoDbClient ddb,
String tableName,
String key,
String keyVal,
String albumTitle,
String albumTitleValue,
String awards,
String awardVal,
String songTitle,
String songTitleVal) {
HashMap itemValues = new HashMap<>();
itemValues.put(key, AttributeValue.builder().s(keyVal).build());
itemValues.put(songTitle, AttributeValue.builder().s(songTitleVal).build());
itemValues.put(albumTitle, AttributeValue.builder().s(albumTitleValue).build());
itemValues.put(awards, AttributeValue.builder().s(awardVal).build());
PutItemRequest request = PutItemRequest.builder()
.tableName(tableName)
.item(itemValues)
.build();
try {
PutItemResponse response = ddb.putItem(request);
System.out.println(tableName + " was successfully updated. The request id is "
+ response.responseMetadata().requestId());
} catch (ResourceNotFoundException e) {
System.err.format("Error: The Amazon DynamoDB table \"%s\" can't be found.\n", tableName);
System.err.println("Be sure that it exists and that you've typed its name correctly!");
System.exit(1);
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
------
#### [ Java v1 ]
Ikuti langkah-langkah ini:
1. Buat instans dari kelas `DynamoDB`.
1. Buat instans dari kelas `Table` untuk mewakili tabel yang ingin Anda gunakan.
1. Buat instans dari kelas `Item` untuk mewakili item baru. Anda harus menentukan kunci primer item baru dan atributnya.
1. Panggil metode `putItem` dari objek `Table` dengan menggunakan `Item` yang Anda buat pada langkah sebelumnya.
Contoh kode Java berikut menunjukkan tugas sebelumnya. Kode tersebut menulis item baru ke tabel `ProductCatalog`.
**Example**
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
// Build a list of related items
List relatedItems = new ArrayList();
relatedItems.add(341);
relatedItems.add(472);
relatedItems.add(649);
//Build a map of product pictures
Map pictures = new HashMap();
pictures.put("FrontView", "http://example.com/products/123_front.jpg");
pictures.put("RearView", "http://example.com/products/123_rear.jpg");
pictures.put("SideView", "http://example.com/products/123_left_side.jpg");
//Build a map of product reviews
Map> reviews = new HashMap>();
List fiveStarReviews = new ArrayList();
fiveStarReviews.add("Excellent! Can't recommend it highly enough! Buy it!");
fiveStarReviews.add("Do yourself a favor and buy this");
reviews.put("FiveStar", fiveStarReviews);
List oneStarReviews = new ArrayList();
oneStarReviews.add("Terrible product! Do not buy this.");
reviews.put("OneStar", oneStarReviews);
// Build the item
Item item = new Item()
.withPrimaryKey("Id", 123)
.withString("Title", "Bicycle 123")
.withString("Description", "123 description")
.withString("BicycleType", "Hybrid")
.withString("Brand", "Brand-Company C")
.withNumber("Price", 500)
.withStringSet("Color", new HashSet(Arrays.asList("Red", "Black")))
.withString("ProductCategory", "Bicycle")
.withBoolean("InStock", true)
.withNull("QuantityOnHand")
.withList("RelatedItems", relatedItems)
.withMap("Pictures", pictures)
.withMap("Reviews", reviews);
// Write the item to the table
PutItemOutcome outcome = table.putItem(item);
```
Pada contoh sebelumnya, item memiliki atribut berupa skalar (`String`, `Number`, `Boolean`, `Null`), set (`String Set`), dan jenis dokumen (`List`, `Map`).
------
### Menentukan parameter opsional
Selain parameter yang diperlukan, Anda juga dapat menentukan parameter opsional untuk metode `putItem`. Misalnya, contoh kode Java berikut menggunakan parameter opsional untuk menentukan kondisi untuk mengunggah item. Jika kondisi yang Anda tentukan tidak terpenuhi, AWS SDK untuk Java lemparan a`ConditionalCheckFailedException`. Contoh kode menentukan parameter opsional berikut dalam metode `putItem`:
+ `ConditionExpression` yang mendefinisikan kondisi permintaan. Kode tersebut mendefinisikan kondisi bahwa item yang ada dengan kunci primer yang sama diganti hanya jika item tersebut memiliki atribut ISBN yang sama dengan nilai tertentu.
+ Peta untuk `ExpressionAttributeValues` yang digunakan dalam kondisi tersebut. Dalam kasus ini, hanya ada satu substitusi yang diperlukan: placeholder `:val` dalam ekspresi kondisi diganti pada saat runtime dengan nilai ISBN aktual yang akan diperiksa.
Contoh berikut menambahkan item buku baru menggunakan parameter opsional.
**Example**
```
Item item = new Item()
.withPrimaryKey("Id", 104)
.withString("Title", "Book 104 Title")
.withString("ISBN", "444-4444444444")
.withNumber("Price", 20)
.withStringSet("Authors",
new HashSet(Arrays.asList("Author1", "Author2")));
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", "444-4444444444");
PutItemOutcome outcome = table.putItem(
item,
"ISBN = :val", // ConditionExpression parameter
null, // ExpressionAttributeNames parameter - we're not using it for this example
expressionAttributeValues);
```
### PutItem dan dokumen JSON
Anda dapat menyimpan dokumen JSON sebagai atribut dalam tabel DynamoDB. Untuk melakukannya, gunakan metode `withJSON` `Item`. Metode ini mengurai dokumen JSON dan memetakan setiap elemen untuk jenis daya DynamoDB asli.
Misalkan Anda ingin menyimpan dokumen JSON berikut, yang berisi vendor yang dapat memenuhi pesanan untuk produk tertentu.
**Example**
```
{
"V01": {
"Name": "Acme Books",
"Offices": [ "Seattle" ]
},
"V02": {
"Name": "New Publishers, Inc.",
"Offices": ["London", "New York"
]
},
"V03": {
"Name": "Better Buy Books",
"Offices": [ "Tokyo", "Los Angeles", "Sydney"
]
}
}
```
Anda dapat menggunakan metode `withJSON` untuk menyimpan ini dalam tabel `ProductCatalog`, dalam atribut `Map` yang disebut `VendorInfo`. Contoh kode Java berikut mendemonstrasikan cara melakukannya.
```
// Convert the document into a String. Must escape all double-quotes.
String vendorDocument = "{"
+ " \"V01\": {"
+ " \"Name\": \"Acme Books\","
+ " \"Offices\": [ \"Seattle\" ]"
+ " },"
+ " \"V02\": {"
+ " \"Name\": \"New Publishers, Inc.\","
+ " \"Offices\": [ \"London\", \"New York\"" + "]" + "},"
+ " \"V03\": {"
+ " \"Name\": \"Better Buy Books\","
+ "\"Offices\": [ \"Tokyo\", \"Los Angeles\", \"Sydney\""
+ " ]"
+ " }"
+ " }";
Item item = new Item()
.withPrimaryKey("Id", 210)
.withString("Title", "Book 210 Title")
.withString("ISBN", "210-2102102102")
.withNumber("Price", 30)
.withJSON("VendorInfo", vendorDocument);
PutItemOutcome outcome = table.putItem(item);
```
## Mendapatkan item
Untuk mengambil satu item, gunakan metode `getItem` dari objek `Table`. Ikuti langkah-langkah ini:
1. Buat instans dari kelas `DynamoDB`.
1. Buat instans dari kelas `Table` untuk mewakili tabel yang ingin Anda gunakan.
1. Panggil metode `getItem` dari instans `Table`. Anda harus menentukan kunci item primer yang ingin Anda ambil.
Contoh kode Java berikut mendemonstrasikan langkah sebelumnya. Kode mendapatkan item yang memiliki kunci partisi yang ditentukan.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
Item item = table.getItem("Id", 210);
```
### Menentukan parameter opsional
Selain parameter yang diperlukan, Anda juga dapat menentukan parameter opsional untuk metode `getItem`. Misalnya, contoh kode Java berikut menggunakan metode opsional untuk mengambil hanya daftar atribut tertentu dan menentukan bacaan sangat konsisten. (Untuk mempelajari selengkapnya tentang konsistensi baca, lihat [DynamoDB membaca konsistensi](HowItWorks.ReadConsistency.md).)
Anda dapat menggunakan `ProjectionExpression` untuk mengambil hanya atribut atau elemen tertentu, bukan seluruh item. `ProjectionExpression` dapat menentukan tingkat atas atau atribut bersarang menggunakan jalur dokumen. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi proyeksi di DynamoDB](Expressions.ProjectionExpressions.md).
Parameter dari metode `getItem` tidak membiarkan Anda menentukan konsistensi baca. Namun, Anda dapat membuat `GetItemSpec`, yang menyediakan akses penuh ke semua input ke operasi `GetItem` tingkat rendah. Contoh kode berikut membuat `GetItemSpec` dan menggunakan spesifikasi tersebut sebagai input untuk metode `getItem`.
**Example**
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 206)
.withProjectionExpression("Id, Title, RelatedItems[0], Reviews.FiveStar")
.withConsistentRead(true);
Item item = table.getItem(spec);
System.out.println(item.toJSONPretty());
```
Untuk mencetak `Item` dalam format yang dapat dibaca manusia, gunakan metode `toJSONPretty`. Output dari contoh sebelumnya terlihat seperti berikut ini.
```
{
"RelatedItems" : [ 341 ],
"Reviews" : {
"FiveStar" : [ "Excellent! Can't recommend it highly enough! Buy it!", "Do yourself a favor and buy this" ]
},
"Id" : 123,
"Title" : "20-Bicycle 123"
}
```
### GetItem dan dokumen JSON
Di bagian [PutItem dan dokumen JSON](#PutItemJavaDocumentAPI.JSON), Anda menyimpan dokumen JSON dalam atribut `Map` yang disebut `VendorInfo`. Anda dapat menggunakan metode `getItem` untuk mengambil seluruh dokumen dalam format JSON. Selain itu, Anda dapat menggunakan notasi jalur dokumen untuk mengambil hanya beberapa elemen dalam dokumen. Contoh kode Java berikut mendemonstrasikan teknik ini.
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 210);
System.out.println("All vendor info:");
spec.withProjectionExpression("VendorInfo");
System.out.println(table.getItem(spec).toJSON());
System.out.println("A single vendor:");
spec.withProjectionExpression("VendorInfo.V03");
System.out.println(table.getItem(spec).toJSON());
System.out.println("First office location for this vendor:");
spec.withProjectionExpression("VendorInfo.V03.Offices[0]");
System.out.println(table.getItem(spec).toJSON());
```
Output dari contoh sebelumnya terlihat seperti berikut ini.
```
All vendor info:
{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los Angeles","Sydney"]},"V02":{"Name":"New Publishers, Inc.","Offices":["London","New York"]},"V01":{"Name":"Acme Books","Offices":["Seattle"]}}}
A single vendor:
{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los Angeles","Sydney"]}}}
First office location for a single vendor:
{"VendorInfo":{"V03":{"Offices":["Tokyo"]}}}
```
**catatan**
Anda dapat menggunakan metode `toJSON` untuk mengonversi item apa pun (atau atributnya) ke string berformat JSON. Kode berikut mengambil beberapa atribut tingkat atas dan bertingkat serta mencetak hasilnya sebagai JSON.
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 210)
.withProjectionExpression("VendorInfo.V01, Title, Price");
Item item = table.getItem(spec);
System.out.println(item.toJSON());
```
Output-nya akan terlihat seperti berikut.
```
{"VendorInfo":{"V01":{"Name":"Acme Books","Offices":["Seattle"]}},"Price":30,"Title":"Book 210 Title"}
```
## Penulisan batch: Menempatkan dan menghapus beberapa item
*Penulisan batch* merujuk pada penempatan dan penghapusan beberapa item dalam satu batch. Metode `batchWriteItem` memungkinkan Anda untuk memasukkan dan menghapus beberapa item dari satu atau lebih tabel dalam satu panggilan. Berikut ini adalah langkah-langkah untuk menempatkan atau menghapus beberapa item menggunakan AWS SDK untuk Java Document API.
1. Buat instans dari kelas `DynamoDB`.
1. Buat instans dari kelas `TableWriteItems` yang menjelaskan semua operasi put dan hapus untuk tabel. Jika Anda ingin menulis ke beberapa tabel dalam satu operasi penulisan batch, Anda harus membuat satu instans `TableWriteItems` per tabel.
1. Jalankan metode `batchWriteItem` dengan menyediakan objek `TableWriteItems` yang Anda buat pada langkah sebelumnya.
1. Proses responsnya. Anda harus memeriksa apakah ada item permintaan yang belum diproses yang dikembalikan sebagai respons. Hal ini dapat terjadi jika Anda mencapai kuota throughput yang disediakan atau kesalahan sementara lainnya. Selain itu, DynamoDB membatasi ukuran permintaan dan jumlah operasi yang dapat Anda tentukan dalam permintaan. Jika Anda melebihi batas ini, DynamoDB menolak permintaan tersebut. Untuk informasi selengkapnya, lihat [Kuota di Amazon DynamoDB](ServiceQuotas.md).
Contoh kode Java berikut mendemonstrasikan langkah sebelumnya. Contoh tersebut melakukan operasi `batchWriteItem` pada dua tabel: `Forum` dan `Thread`. Objek `TableWriteItems` yang sesuai menentukan tindakan berikut:
+ Tempatkan satu item dalam tabel `Forum`.
+ Tempatkan dan hapus satu item dalam tabel `Thread`.
Kode kemudian menjalankan `batchWriteItem` untuk melakukan operasi.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
TableWriteItems forumTableWriteItems = new TableWriteItems("Forum")
.withItemsToPut(
new Item()
.withPrimaryKey("Name", "Amazon RDS")
.withNumber("Threads", 0));
TableWriteItems threadTableWriteItems = new TableWriteItems("Thread")
.withItemsToPut(
new Item()
.withPrimaryKey("ForumName","Amazon RDS","Subject","Amazon RDS Thread 1")
.withHashAndRangeKeysToDelete("ForumName","Some partition key value", "Amazon S3", "Some sort key value");
BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem(forumTableWriteItems, threadTableWriteItems);
// Code for checking unprocessed items is omitted in this example
```
Untuk contoh pekerjaan, lihat [Contoh: Operasi penulisan Batch menggunakan API AWS SDK untuk Java dokumen](batch-operation-document-api-java.md#JavaDocumentAPIBatchWrite).
## Batch get: Mendapatkan beberapa item
Metode `batchGetItem` memungkinkan Anda mengambil beberapa item dari satu atau lebih tabel. Untuk mengambil satu item, Anda dapat menggunakan metode `getItem`.
Ikuti langkah-langkah ini:
1. Buat instans dari kelas `DynamoDB`.
1. Buat instans dari kelas `TableKeysAndAttributes` yang menjelaskan daftar nilai kunci primer untuk mengambil dari tabel. Jika Anda ingin membaca dari beberapa tabel dalam satu operasi penulisan batch, Anda harus membuat satu instans `TableKeysAndAttributes` per tabel.
1. Jalankan metode `batchGetItem` dengan menyediakan objek `TableKeysAndAttributes` yang Anda buat pada langkah sebelumnya.
Contoh kode Java berikut mendemonstrasikan langkah sebelumnya. Contoh tersebut mengambil dua item dari tabel `Forum` dan tiga item dari tabel `Thread`.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes(forumTableName);
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");
TableKeysAndAttributes threadTableKeysAndAttributes = new TableKeysAndAttributes(threadTableName);
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys("ForumName", "Subject",
"Amazon DynamoDB","DynamoDB Thread 1",
"Amazon DynamoDB","DynamoDB Thread 2",
"Amazon S3","S3 Thread 1");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(
forumTableKeysAndAttributes, threadTableKeysAndAttributes);
for (String tableName : outcome.getTableItems().keySet()) {
System.out.println("Items in table " + tableName);
List- items = outcome.getTableItems().get(tableName);
for (Item item : items) {
System.out.println(item);
}
}
```
### Menentukan parameter opsional
Bersamaan dengan parameter yang diperlukan, Anda juga dapat menentukan parameter opsional saat menggunakan `batchGetItem`. Misalnya, Anda dapat memberikan `ProjectionExpression` dengan setiap `TableKeysAndAttributes` yang Anda tentukan. Hal ini memungkinkan Anda menentukan atribut yang ingin Anda ambil dari tabel.
Contoh kode berikut mengambil dua item dari tabel `Forum`. Parameter `withProjectionExpression` menentukan bahwa hanya atribut `Threads` yang akan diambil.
**Example**
```
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes("Forum")
.withProjectionExpression("Threads");
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes);
```
## Memperbarui Item
Metode `updateItem` dari objek `Table` dapat memperbarui nilai atribut yang ada, menambahkan atribut baru, atau menghapus atribut dari item yang ada.
Metode `updateItem` berperilaku sebagai berikut:
+ Jika item tidak ada (tidak ada item dalam tabel dengan kunci primer yang ditentukan), `updateItem` menambahkan item baru ke tabel.
+ Jika item ada, `updateItem` melakukan pembaruan seperti yang ditentukan oleh parameter `UpdateExpression`.
**catatan**
Hal ini juga memungkinkan untuk "memperbarui" item menggunakan `putItem`. Misalnya, jika Anda memanggil `putItem` untuk menambahkan item ke tabel, tetapi sudah ada item dengan kunci primer yang ditentukan, `putItem` akan menggantikan seluruh item. Jika ada atribut dalam item yang ada yang tidak ditentukan dalam input, `putItem` akan menghapus atribut tersebut dari item.
Secara umum, sebaiknya gunakan `updateItem` setiap kali Anda ingin memodifikasi atribut item. Metode `updateItem` hanya memodifikasi atribut item yang Anda tentukan dalam input, dan atribut lainnya dalam item tidak berubah.
Ikuti langkah-langkah ini:
1. Buat instans dari kelas `Table` untuk mewakili tabel yang ingin Anda gunakan.
1. Panggil metode `updateTable` dari instans `Table`. Anda harus menentukan kunci primer dari item yang ingin Anda ambil, bersama dengan `UpdateExpression` yang menjelaskan atribut untuk memodifikasi dan cara memodifikasinya.
Contoh kode Java berikut menunjukkan tugas sebelumnya. Kode tersebut memperbarui item buku dalam tabel `ProductCatalog`. Contoh tersebut menambahkan penulis baru ke set `Authors`, dan menghapus atribut `ISBN` yang ada. Contoh tersebut juga mengurangi harga sebanyak satu.
Peta `ExpressionAttributeValues` digunakan dalam `UpdateExpression`. Placeholder `:val1` dan `:val2` diganti pada saat runtime dengan nilai aktual untuk `Authors` dan `Price`.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#A", "Authors");
expressionAttributeNames.put("#P", "Price");
expressionAttributeNames.put("#I", "ISBN");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val1",
new HashSet(Arrays.asList("Author YY","Author ZZ")));
expressionAttributeValues.put(":val2", 1); //Price
UpdateItemOutcome outcome = table.updateItem(
"Id", // key attribute name
101, // key attribute value
"add #A :val1 set #P = #P - :val2 remove #I", // UpdateExpression
expressionAttributeNames,
expressionAttributeValues);
```
### Menentukan parameter opsional
Bersamaan dengan parameter yang diperlukan, Anda juga dapat menentukan parameter opsional untuk metode `updateItem`, termasuk kondisi yang harus dipenuhi agar pembaruan bisa terjadi. Jika kondisi yang Anda tentukan tidak terpenuhi, AWS SDK untuk Java lemparan a`ConditionalCheckFailedException`. Misalnya, contoh kode Java berikut memperbarui harga item buku secara kondisional menjadi 25. Ini menentukan pernyataan `ConditionExpression` bahwa harga harus diperbarui hanya jika harga saat ini adalah 20.
**Example**
```
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#P", "Price");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val1", 25); // update Price to 25...
expressionAttributeValues.put(":val2", 20); //...but only if existing Price is 20
UpdateItemOutcome outcome = table.updateItem(
new PrimaryKey("Id",101),
"set #P = :val1", // UpdateExpression
"#P = :val2", // ConditionExpression
expressionAttributeNames,
expressionAttributeValues);
```
### Penghitung atom
Anda dapat menggunakan `updateItem` untuk mengimplementasi penghitung atom, di mana Anda menambahkan atau mengurangi nilai atribut yang ada tanpa mengganggu permintaan tulis lainnya. Untuk kenaikan penghitung atom, gunakan `UpdateExpression` dengan tindakan `set` untuk menambahkan nilai numerik ke atribut jenis `Number` yang ada.
Contoh berikut menunjukkan hal ini, menambahkan satu atribut `Quantity`. Hal ini juga menunjukkan penggunaan parameter `ExpressionAttributeNames` dalam `UpdateExpression`.
```
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#p", "PageCount");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", 1);
UpdateItemOutcome outcome = table.updateItem(
"Id", 121,
"set #p = #p + :val",
expressionAttributeNames,
expressionAttributeValues);
```
## Menghapus item
Metode `deleteItem` menghapus item dari tabel. Anda harus menyediakan kunci item primer yang ingin Anda hapus.
Ikuti langkah-langkah ini:
1. Buat instans dari klien `DynamoDB`.
1. Panggil metode `deleteItem` dengan menyediakan kunci item yang ingin Anda hapus.
Contoh Java berikut menunjukkan tugas ini.
**Example**
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
DeleteItemOutcome outcome = table.deleteItem("Id", 101);
```
### Menentukan parameter opsional
Anda dapat menentukan parameter opsional untuk `deleteItem`. Misalnya, contoh kode Java berikut menentukan `ConditionExpression`, yang menyatakan bahwa item buku dalam `ProductCatalog` hanya dapat dihapus jika buku ini tidak lagi dalam publikasi (atribut `InPublication` adalah salah).
**Example**
```
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", false);
DeleteItemOutcome outcome = table.deleteItem("Id",103,
"InPublication = :val",
null, // ExpressionAttributeNames - not used in this example
expressionAttributeValues);
```
# Contoh: Operasi CRUD menggunakan API AWS SDK untuk Java dokumen
Contoh kode berikut menunjukkan operasi CRUD pada item Amazon DynamoDB. Contohnya membuat item, mengambilnya, melakukan berbagai pembaruan, dan akhirnya menghapus item tersebut.
**catatan**
SDK untuk Java juga menyediakan model persistensi objek, memungkinkan Anda memetakan kelas sisi klien ke tabel DynamoDB. Pendekatan ini dapat mengurangi jumlah kode yang harus Anda tulis. Untuk informasi selengkapnya, lihat [Java 1.x: Dinamo DBMapper](DynamoDBMapper.md).
**catatan**
Contoh kode ini mengasumsikan bahwa Anda telah memuat data ke DynamoDB untuk akun Anda dengan mengikuti petunjuk di bagian [Membuat tabel dan memuat data untuk contoh kode di DynamoDB](SampleData.md).
Untuk step-by-step instruksi untuk menjalankan contoh berikut, lihat[Contoh kode Java](CodeSamples.Java.md).
```
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DeleteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;
public class DocumentAPIItemCRUDExample {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String tableName = "ProductCatalog";
public static void main(String[] args) throws IOException {
createItems();
retrieveItem();
// Perform various updates.
updateMultipleAttributes();
updateAddNewAttribute();
updateExistingAttributeConditionally();
// Delete the item.
deleteItem();
}
private static void createItems() {
Table table = dynamoDB.getTable(tableName);
try {
Item item = new Item().withPrimaryKey("Id", 120).withString("Title", "Book 120 Title")
.withString("ISBN", "120-1111111111")
.withStringSet("Authors", new HashSet(Arrays.asList("Author12", "Author22")))
.withNumber("Price", 20).withString("Dimensions", "8.5x11.0x.75").withNumber("PageCount", 500)
.withBoolean("InPublication", false).withString("ProductCategory", "Book");
table.putItem(item);
item = new Item().withPrimaryKey("Id", 121).withString("Title", "Book 121 Title")
.withString("ISBN", "121-1111111111")
.withStringSet("Authors", new HashSet(Arrays.asList("Author21", "Author 22")))
.withNumber("Price", 20).withString("Dimensions", "8.5x11.0x.75").withNumber("PageCount", 500)
.withBoolean("InPublication", true).withString("ProductCategory", "Book");
table.putItem(item);
} catch (Exception e) {
System.err.println("Create items failed.");
System.err.println(e.getMessage());
}
}
private static void retrieveItem() {
Table table = dynamoDB.getTable(tableName);
try {
Item item = table.getItem("Id", 120, "Id, ISBN, Title, Authors", null);
System.out.println("Printing item after retrieving it....");
System.out.println(item.toJSONPretty());
} catch (Exception e) {
System.err.println("GetItem failed.");
System.err.println(e.getMessage());
}
}
private static void updateAddNewAttribute() {
Table table = dynamoDB.getTable(tableName);
try {
UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 121)
.withUpdateExpression("set #na = :val1").withNameMap(new NameMap().with("#na", "NewAttribute"))
.withValueMap(new ValueMap().withString(":val1", "Some value"))
.withReturnValues(ReturnValue.ALL_NEW);
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
// Check the response.
System.out.println("Printing item after adding new attribute...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Failed to add new attribute in " + tableName);
System.err.println(e.getMessage());
}
}
private static void updateMultipleAttributes() {
Table table = dynamoDB.getTable(tableName);
try {
UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 120)
.withUpdateExpression("add #a :val1 set #na=:val2")
.withNameMap(new NameMap().with("#a", "Authors").with("#na", "NewAttribute"))
.withValueMap(
new ValueMap().withStringSet(":val1", "Author YY", "Author ZZ").withString(":val2",
"someValue"))
.withReturnValues(ReturnValue.ALL_NEW);
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
// Check the response.
System.out.println("Printing item after multiple attribute update...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Failed to update multiple attributes in " + tableName);
System.err.println(e.getMessage());
}
}
private static void updateExistingAttributeConditionally() {
Table table = dynamoDB.getTable(tableName);
try {
// Specify the desired price (25.00) and also the condition (price =
// 20.00)
UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 120)
.withReturnValues(ReturnValue.ALL_NEW).withUpdateExpression("set #p = :val1")
.withConditionExpression("#p = :val2").withNameMap(new NameMap().with("#p", "Price"))
.withValueMap(new ValueMap().withNumber(":val1", 25).withNumber(":val2", 20));
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
// Check the response.
System.out.println("Printing item after conditional update to new attribute...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Error updating item in " + tableName);
System.err.println(e.getMessage());
}
}
private static void deleteItem() {
Table table = dynamoDB.getTable(tableName);
try {
DeleteItemSpec deleteItemSpec = new DeleteItemSpec().withPrimaryKey("Id", 120)
.withConditionExpression("#ip = :val").withNameMap(new NameMap().with("#ip", "InPublication"))
.withValueMap(new ValueMap().withBoolean(":val", false)).withReturnValues(ReturnValue.ALL_OLD);
DeleteItemOutcome outcome = table.deleteItem(deleteItemSpec);
// Check the response.
System.out.println("Printing item that was deleted...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Error deleting item in " + tableName);
System.err.println(e.getMessage());
}
}
}
```
# Contoh: Operasi Batch menggunakan API AWS SDK untuk Java dokumen
Bagian ini memberikan contoh operasi batch write dan batch get di Amazon DynamoDB menggunakan AWS SDK untuk Java Document API.
**catatan**
SDK untuk Java juga menyediakan model persistensi objek, memungkinkan Anda memetakan kelas sisi klien ke tabel DynamoDB. Pendekatan ini dapat mengurangi jumlah kode yang harus Anda tulis. Untuk informasi selengkapnya, lihat [Java 1.x: Dinamo DBMapper](DynamoDBMapper.md).
**Topics**
+ [Contoh: Operasi penulisan Batch menggunakan API AWS SDK untuk Java dokumen](#JavaDocumentAPIBatchWrite)
+ [Contoh: Operasi batch get menggunakan API AWS SDK untuk Java dokumen](#JavaDocumentAPIBatchGet)
## Contoh: Operasi penulisan Batch menggunakan API AWS SDK untuk Java dokumen
Contoh kode Java berikut menggunakan metode `batchWriteItem` untuk melakukan operasi put dan delete berikut:
+ Tempatkan satu item dalam tabel `Forum`.
+ Tempatkan satu item dan hapus satu item dari tabel `Thread`.
Anda dapat menentukan sejumlah permintaan put dan delete terhadap satu atau beberapa tabel saat membuat permintaan batch write Anda. Namun, `batchWriteItem` membatasi ukuran permintaan penulisan batch dan jumlah operasi put dan delete dalam satu operasi penulisan batch. Jika permintaan Anda melebihi batas ini, permintaan Anda ditolak. Jika tabel Anda tidak memiliki cukup throughput yang disediakan untuk melayani permintaan ini, item permintaan yang belum diproses akan dikembalikan sebagai respons.
Contoh berikut memeriksa respons untuk melihat apakah ada item permintaan yang belum diproses. Jika ya, contoh tersebut akan mengulang kembali dan mengirim ulang permintaan `batchWriteItem` dengan item yang belum diproses dalam permintaan tersebut. Jika Anda mengikuti contoh dalam panduan ini, Anda seharusnya sudah membuat `Forum` dan `Thread` tabel. Anda juga dapat membuat tabel ini dan mengunggah data sampel secara terprogram. Untuk informasi selengkapnya, lihat [Membuat tabel contoh dan mengunggah data menggunakan AWS SDK untuk Java](AppendixSampleDataCodeJava.md).
Untuk step-by-step petunjuk pengujian sampel berikut, lihat[Contoh kode Java](CodeSamples.Java.md).
**Example**
```
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.BatchWriteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableWriteItems;
import com.amazonaws.services.dynamodbv2.model.WriteRequest;
public class DocumentAPIBatchWrite {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String forumTableName = "Forum";
static String threadTableName = "Thread";
public static void main(String[] args) throws IOException {
writeMultipleItemsBatchWrite();
}
private static void writeMultipleItemsBatchWrite() {
try {
// Add a new item to Forum
TableWriteItems forumTableWriteItems = new TableWriteItems(forumTableName) // Forum
.withItemsToPut(new Item().withPrimaryKey("Name", "Amazon RDS").withNumber("Threads", 0));
// Add a new item, and delete an existing item, from Thread
// This table has a partition key and range key, so need to specify
// both of them
TableWriteItems threadTableWriteItems = new TableWriteItems(threadTableName)
.withItemsToPut(
new Item().withPrimaryKey("ForumName", "Amazon RDS", "Subject", "Amazon RDS Thread 1")
.withString("Message", "ElastiCache Thread 1 message")
.withStringSet("Tags", new HashSet(Arrays.asList("cache", "in-memory"))))
.withHashAndRangeKeysToDelete("ForumName", "Subject", "Amazon S3", "S3 Thread 100");
System.out.println("Making the request.");
BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem(forumTableWriteItems, threadTableWriteItems);
do {
// Check for unprocessed keys which could happen if you exceed
// provisioned throughput
Map> unprocessedItems = outcome.getUnprocessedItems();
if (outcome.getUnprocessedItems().size() == 0) {
System.out.println("No unprocessed items found");
} else {
System.out.println("Retrieving the unprocessed items");
outcome = dynamoDB.batchWriteItemUnprocessed(unprocessedItems);
}
} while (outcome.getUnprocessedItems().size() > 0);
} catch (Exception e) {
System.err.println("Failed to retrieve items: ");
e.printStackTrace(System.err);
}
}
}
```
## Contoh: Operasi batch get menggunakan API AWS SDK untuk Java dokumen
Contoh kode Java berikut menggunakan metode `batchGetItem` untuk mengambil beberapa item dari tabel `Forum` dan `Thread`. `BatchGetItemRequest` menentukan nama tabel dan daftar kunci untuk setiap item yang akan didapatkan. Contoh tersebut memproses respons dengan mencetak item yang diambil.
**catatan**
Contoh kode ini mengasumsikan bahwa Anda telah memuat data ke DynamoDB untuk akun Anda dengan mengikuti petunjuk di bagian [Membuat tabel dan memuat data untuk contoh kode di DynamoDB](SampleData.md).
Untuk step-by-step instruksi untuk menjalankan contoh berikut, lihat[Contoh kode Java](CodeSamples.Java.md).
**Example**
```
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.BatchGetItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableKeysAndAttributes;
import com.amazonaws.services.dynamodbv2.model.KeysAndAttributes;
public class DocumentAPIBatchGet {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String forumTableName = "Forum";
static String threadTableName = "Thread";
public static void main(String[] args) throws IOException {
retrieveMultipleItemsBatchGet();
}
private static void retrieveMultipleItemsBatchGet() {
try {
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes(forumTableName);
// Add a partition key
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name", "Amazon S3", "Amazon DynamoDB");
TableKeysAndAttributes threadTableKeysAndAttributes = new TableKeysAndAttributes(threadTableName);
// Add a partition key and a sort key
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys("ForumName", "Subject", "Amazon DynamoDB",
"DynamoDB Thread 1", "Amazon DynamoDB", "DynamoDB Thread 2", "Amazon S3", "S3 Thread 1");
System.out.println("Making the request.");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes,
threadTableKeysAndAttributes);
Map unprocessed = null;
do {
for (String tableName : outcome.getTableItems().keySet()) {
System.out.println("Items in table " + tableName);
List
- items = outcome.getTableItems().get(tableName);
for (Item item : items) {
System.out.println(item.toJSONPretty());
}
}
// Check for unprocessed keys which could happen if you exceed
// provisioned
// throughput or reach the limit on response size.
unprocessed = outcome.getUnprocessedKeys();
if (unprocessed.isEmpty()) {
System.out.println("No unprocessed keys found");
} else {
System.out.println("Retrieving the unprocessed keys");
outcome = dynamoDB.batchGetItemUnprocessed(unprocessed);
}
} while (!unprocessed.isEmpty());
} catch (Exception e) {
System.err.println("Failed to retrieve items.");
System.err.println(e.getMessage());
}
}
}
```
# Contoh: Menangani atribut tipe biner menggunakan API AWS SDK untuk Java dokumen
Contoh kode Java berikut menggambarkan penanganan atribut jenis biner. Contoh tersebut menambahkan item ke tabel `Reply`. Item termasuk atribut jenis biner (`ExtendedMessage`) yang menyimpan data terkompresi. Contoh tersebut kemudian mengambil item dan mencetak semua nilai atribut. Sebagai ilustrasi, contoh menggunakan kelas `GZIPOutputStream` untuk mengompresi aliran sampel dan menetapkannya ke atribut `ExtendedMessage`. Ketika atribut binari diambil, atribut didekompresi menggunakan kelas `GZIPInputStream`.
**catatan**
SDK untuk Java juga menyediakan model persistensi objek, memungkinkan Anda memetakan kelas sisi klien ke tabel DynamoDB. Pendekatan ini dapat mengurangi jumlah kode yang harus Anda tulis. Untuk informasi selengkapnya, lihat [Java 1.x: Dinamo DBMapper](DynamoDBMapper.md).
Jika Anda mengikuti bagian [Membuat tabel dan memuat data untuk contoh kode di DynamoDB](SampleData.md), semestinya Anda telah membuat tabel `Reply`. Anda juga dapat membuat tabel ini secara terprogram. Untuk informasi selengkapnya, lihat [Membuat tabel contoh dan mengunggah data menggunakan AWS SDK untuk Java](AppendixSampleDataCodeJava.md).
Untuk step-by-step petunjuk pengujian sampel berikut, lihat[Contoh kode Java](CodeSamples.Java.md).
**Example**
```
package com.amazonaws.codesamples.document;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.GetItemSpec;
public class DocumentAPIItemBinaryExample {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String tableName = "Reply";
static SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
public static void main(String[] args) throws IOException {
try {
// Format the primary key values
String threadId = "Amazon DynamoDB#DynamoDB Thread 2";
dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
String replyDateTime = dateFormatter.format(new Date());
// Add a new reply with a binary attribute type
createItem(threadId, replyDateTime);
// Retrieve the reply with a binary attribute type
retrieveItem(threadId, replyDateTime);
// clean up by deleting the item
deleteItem(threadId, replyDateTime);
} catch (Exception e) {
System.err.println("Error running the binary attribute type example: " + e);
e.printStackTrace(System.err);
}
}
public static void createItem(String threadId, String replyDateTime) throws IOException {
Table table = dynamoDB.getTable(tableName);
// Craft a long message
String messageInput = "Long message to be compressed in a lengthy forum reply";
// Compress the long message
ByteBuffer compressedMessage = compressString(messageInput.toString());
table.putItem(new Item().withPrimaryKey("Id", threadId).withString("ReplyDateTime", replyDateTime)
.withString("Message", "Long message follows").withBinary("ExtendedMessage", compressedMessage)
.withString("PostedBy", "User A"));
}
public static void retrieveItem(String threadId, String replyDateTime) throws IOException {
Table table = dynamoDB.getTable(tableName);
GetItemSpec spec = new GetItemSpec().withPrimaryKey("Id", threadId, "ReplyDateTime", replyDateTime)
.withConsistentRead(true);
Item item = table.getItem(spec);
// Uncompress the reply message and print
String uncompressed = uncompressString(ByteBuffer.wrap(item.getBinary("ExtendedMessage")));
System.out.println("Reply message:\n" + " Id: " + item.getString("Id") + "\n" + " ReplyDateTime: "
+ item.getString("ReplyDateTime") + "\n" + " PostedBy: " + item.getString("PostedBy") + "\n"
+ " Message: "
+ item.getString("Message") + "\n" + " ExtendedMessage (uncompressed): " + uncompressed + "\n");
}
public static void deleteItem(String threadId, String replyDateTime) {
Table table = dynamoDB.getTable(tableName);
table.deleteItem("Id", threadId, "ReplyDateTime", replyDateTime);
}
private static ByteBuffer compressString(String input) throws IOException {
// Compress the UTF-8 encoded String into a byte[]
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPOutputStream os = new GZIPOutputStream(baos);
os.write(input.getBytes("UTF-8"));
os.close();
baos.close();
byte[] compressedBytes = baos.toByteArray();
// The following code writes the compressed bytes to a ByteBuffer.
// A simpler way to do this is by simply calling
// ByteBuffer.wrap(compressedBytes);
// However, the longer form below shows the importance of resetting the
// position of the buffer
// back to the beginning of the buffer if you are writing bytes directly
// to it, since the SDK
// will consider only the bytes after the current position when sending
// data to DynamoDB.
// Using the "wrap" method automatically resets the position to zero.
ByteBuffer buffer = ByteBuffer.allocate(compressedBytes.length);
buffer.put(compressedBytes, 0, compressedBytes.length);
buffer.position(0); // Important: reset the position of the ByteBuffer
// to the beginning
return buffer;
}
private static String uncompressString(ByteBuffer input) throws IOException {
byte[] bytes = input.array();
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPInputStream is = new GZIPInputStream(bais);
int chunkSize = 1024;
byte[] buffer = new byte[chunkSize];
int length = 0;
while ((length = is.read(buffer, 0, chunkSize)) != -1) {
baos.write(buffer, 0, length);
}
String result = new String(baos.toByteArray(), "UTF-8");
is.close();
baos.close();
bais.close();
return result;
}
}
```
# Bekerja dengan item: .NET
Anda dapat menggunakan API AWS SDK untuk .NET tingkat rendah untuk melakukan operasi membuat, membaca, memperbarui, dan menghapus (CRUD) pada item dalam tabel. Berikut ini adalah langkah-langkah umum yang Anda ikuti untuk melakukan operasi CRUD data menggunakan API tingkat rendah .NET:
1. Buat instans dari kelas `AmazonDynamoDBClient` (klien).
1. Berikan parameter khusus operasi yang diperlukan dalam objek permintaan yang sesuai.
Misalnya, gunakan permintaan `PutItemRequest` saat mengunggah item dan gunakan permintaan `GetItemRequest` saat mengambil item yang sudah ada.
Anda dapat menggunakan objek permintaan untuk menyediakan parameter wajib dan opsional.
1. Jalankan metode yang sesuai yang disediakan oleh klien dengan meneruskan objek permintaan yang Anda buat pada langkah sebelumnya.
Klien `AmazonDynamoDBClient` menyediakan metode `PutItem`, `GetItem`, `UpdateItem`, dan `DeleteItem` untuk operasi CRUD.
**Topics**
+ [Menempatkan item](#PutItemLowLevelAPIDotNet)
+ [Mendapatkan item](#GetItemLowLevelDotNET)
+ [Memperbarui Item](#UpdateItemLowLevelDotNet)
+ [Penghitung atom](#AtomicCounterLowLevelDotNet)
+ [Menghapus item](#DeleteMidLevelDotNet)
+ [Penulisan batch: Menempatkan dan menghapus beberapa item](#BatchWriteLowLevelDotNet)
+ [Batch get: Mendapatkan beberapa item](#BatchGetLowLevelDotNet)
+ [Contoh: Operasi CRUD menggunakan API tingkat AWS SDK untuk .NET rendah](LowLevelDotNetItemsExample.md)
+ [Contoh: Operasi Batch menggunakan API AWS SDK untuk .NET tingkat rendah](batch-operation-lowlevel-dotnet.md)
+ [Contoh: Menangani atribut tipe biner menggunakan API AWS SDK untuk .NET tingkat rendah](LowLevelDotNetBinaryTypeExample.md)
## Menempatkan item
Metode `PutItem` mengunggah item ke tabel. Jika item ada, item tersebut akan menggantikan keseluruhan item.
**catatan**
Alih-alih mengganti seluruh item, jika Anda hanya ingin memperbarui atribut tertentu, Anda dapat menggunakan metode `UpdateItem`. Untuk informasi selengkapnya, lihat [Memperbarui Item](#UpdateItemLowLevelDotNet).
Berikut langkah-langkah untuk mengunggah item menggunakan .NET SDK API tingkat rendah:
1. Buat instans dari kelas `AmazonDynamoDBClient`.
1. Berikan parameter yang diperlukan dengan membuat instans kelas `PutItemRequest`.
Untuk menaruh item, Anda harus memberikan nama tabel dan itemnya.
1. Jalankan metode `PutItem` dengan menyediakan objek `PutItemRequest` yang Anda buat pada langkah sebelumnya.
Contoh \$1C berikut menunjukkan langkah-langkah sebelumnya. Contoh tersebut mengunggah item ke tabel `ProductCatalog`.
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary()
{
{ "Id", new AttributeValue { N = "201" }},
{ "Title", new AttributeValue { S = "Book 201 Title" }},
{ "ISBN", new AttributeValue { S = "11-11-11-11" }},
{ "Price", new AttributeValue { S = "20.00" }},
{
"Authors",
new AttributeValue
{ SS = new List{"Author1", "Author2"} }
}
}
};
client.PutItem(request);
```
Pada contoh sebelumnya, Anda mengunggah item buku yang memiliki atribut `Id`, `Title`, `ISBN`, dan `Authors`. Perhatikan bahwa `Id` adalah atribut jenis numerik, dan semua atribut lainnya adalah jenis string. Penulis adalah set `String`.
### Menentukan parameter opsional
Anda juga dapat memberikan parameter opsional menggunakan objek `PutItemRequest` seperti yang ditunjukkan dalam contoh C\$1 berikut. Contoh tersebut menentukan parameter opsional berikut:
+ `ExpressionAttributeNames`, `ExpressionAttributeValues`, dan `ConditionExpression` menentukan bahwa barang tersebut hanya dapat diganti jika barang yang ada memiliki atribut ISBN dengan nilai tertentu.
+ Parameter `ReturnValues` untuk meminta item lama dalam respons.
**Example**
```
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary()
{
{ "Id", new AttributeValue { N = "104" }},
{ "Title", new AttributeValue { S = "Book 104 Title" }},
{ "ISBN", new AttributeValue { S = "444-4444444444" }},
{ "Authors",
new AttributeValue { SS = new List{"Author3"}}}
},
// Optional parameters.
ExpressionAttributeNames = new Dictionary()
{
{"#I", "ISBN"}
},
ExpressionAttributeValues = new Dictionary()
{
{":isbn",new AttributeValue {S = "444-4444444444"}}
},
ConditionExpression = "#I = :isbn"
};
var response = client.PutItem(request);
```
Untuk informasi selengkapnya, lihat [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html).
## Mendapatkan item
Metode `GetItem` mengambil item.
**catatan**
Untuk mengambil beberapa item, Anda dapat menggunakan metode `BatchGetItem`. Untuk informasi selengkapnya, lihat [Batch get: Mendapatkan beberapa item](#BatchGetLowLevelDotNet).
Berikut ini adalah langkah-langkah untuk mengambil item yang ada menggunakan API AWS SDK untuk .NET tingkat rendah.
1. Buat instans dari kelas `AmazonDynamoDBClient`.
1. Berikan parameter yang diperlukan dengan membuat instans kelas `GetItemRequest`.
Untuk mendapatkan item, Anda harus memberikan nama tabel dan kunci primer item tersebut.
1. Jalankan metode `GetItem` dengan menyediakan objek `GetItemRequest` yang Anda buat pada langkah sebelumnya.
Contoh \$1C berikut menunjukkan langkah-langkah sebelumnya. Contoh tersebut mengambil item dari tabel `ProductCatalog`.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } },
};
var response = client.GetItem(request);
// Check the response.
var result = response.GetItemResult;
var attributeMap = result.Item; // Attribute list in the response.
```
### Menentukan parameter opsional
Anda juga dapat memberikan parameter opsional menggunakan objek `GetItemRequest`, seperti yang ditunjukkan dalam contoh C\$1 berikut. Contoh tersebut menentukan parameter opsional berikut:
+ Parameter `ProjectionExpression` untuk menentukan atribut yang akan diambil.
+ Parameter `ConsistentRead` untuk melakukan bacaan sangat konsisten. Untuk mempelajari selengkapnya tentang konsistensi baca, lihat [DynamoDB membaca konsistensi](HowItWorks.ReadConsistency.md).
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } },
// Optional parameters.
ProjectionExpression = "Id, ISBN, Title, Authors",
ConsistentRead = true
};
var response = client.GetItem(request);
// Check the response.
var result = response.GetItemResult;
var attributeMap = result.Item;
```
Untuk informasi selengkapnya, lihat [GetItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html).
## Memperbarui Item
Metode `UpdateItem` memperbarui item yang ada jika ada. Anda dapat menggunakan operasi `UpdateItem` untuk memperbarui nilai atribut yang ada, menambahkan atribut baru, atau menghapus atribut dari koleksi yang ada. Jika item yang memiliki kunci primer yang ditentukan tidak ditemukan, item baru akan ditambahkan.
Operasi `UpdateItem` menggunakan panduan berikut:
+ Jika item tidak ada, `UpdateItem` menambahkan item baru menggunakan kunci primer yang ditentukan dalam input.
+ Jika item ada, `UpdateItem` menerapkan pembaruan sebagai berikut:
+ Menggantikan nilai atribut yang ada dengan nilai dalam pembaruan.
+ Jika atribut yang Anda berikan pada input tidak ada, atribut baru akan ditambahkan ke item tersebut.
+ Jika atribut input adalah null, atribut tersebut akan dihapus, jika ada.
+ Jika Anda menggunakan `ADD` untuk`Action`, Anda dapat menambahkan nilai ke set yang sudah ada (set string atau angka), atau menambahkan secara matematis (menggunakan angka positif) atau mengurangi (menggunakan angka negatif) dari nilai atribut numerik yang ada.
**catatan**
Operasi `PutItem` juga dapat melakukan pembaruan. Untuk informasi selengkapnya, lihat [Menempatkan item](#PutItemLowLevelAPIDotNet). Misalnya, jika Anda memanggil `PutItem` untuk mengunggah item dan kunci primer ada, operasi `PutItem` menggantikan seluruh item. Jika terdapat atribut dalam item yang ada yang tidak ditentukan dalam input, operasi `PutItem` akan menghapus atribut tersebut. Namun, `UpdateItem` hanya memperbarui atribut input yang ditentukan. Atribut lain item tersebut yang ada tidak akan berubah.
Berikut langkah-langkah untuk memperbarui item menggunakan .NET SDK API tingkat rendah:
1. Buat instans dari kelas `AmazonDynamoDBClient`.
1. Berikan parameter yang diperlukan dengan membuat instans kelas `UpdateItemRequest`.
Ini adalah objek permintaan tempat Anda menjelaskan semua pembaruan, seperti menambahkan atribut, memperbarui atribut yang ada, atau menghapus atribut. Untuk menghapus atribut yang ada, tentukan nama atribut dengan nilai null.
1. Jalankan metode `UpdateItem` dengan menyediakan objek `UpdateItemRequest` yang Anda buat pada langkah sebelumnya.
Contoh kode \$1C berikut mendemonstrasikan langkah sebelumnya. Contoh tersebut memperbarui item buku dalam tabel `ProductCatalog`. Contoh tersebut menambahkan penulis baru ke koleksi `Authors`, dan menghapus atribut `ISBN` yang ada. Contoh tersebut juga mengurangi harga sebanyak satu.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new UpdateItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } },
ExpressionAttributeNames = new Dictionary()
{
{"#A", "Authors"},
{"#P", "Price"},
{"#NA", "NewAttribute"},
{"#I", "ISBN"}
},
ExpressionAttributeValues = new Dictionary()
{
{":auth",new AttributeValue { SS = {"Author YY","Author ZZ"}}},
{":p",new AttributeValue {N = "1"}},
{":newattr",new AttributeValue {S = "someValue"}},
},
// This expression does the following:
// 1) Adds two new authors to the list
// 2) Reduces the price
// 3) Adds a new attribute to the item
// 4) Removes the ISBN attribute from the item
UpdateExpression = "ADD #A :auth SET #P = #P - :p, #NA = :newattr REMOVE #I"
};
var response = client.UpdateItem(request);
```
### Menentukan parameter opsional
Anda juga dapat memberikan parameter opsional menggunakan objek `UpdateItemRequest`, seperti yang ditunjukkan dalam contoh C\$1 berikut. Contoh tersebut menentukan parameter opsional berikut:
+ `ExpressionAttributeValues` dan `ConditionExpression` untuk menentukan bahwa harga dapat diperbarui hanya jika harga yang ada adalah 20,00.
+ Parameter `ReturnValues` untuk meminta item yang diperbarui dalam respons.
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new UpdateItemRequest
{
Key = new Dictionary() { { "Id", new AttributeValue { N = "202" } } },
// Update price only if the current price is 20.00.
ExpressionAttributeNames = new Dictionary()
{
{"#P", "Price"}
},
ExpressionAttributeValues = new Dictionary()
{
{":newprice",new AttributeValue {N = "22"}},
{":currprice",new AttributeValue {N = "20"}}
},
UpdateExpression = "SET #P = :newprice",
ConditionExpression = "#P = :currprice",
TableName = tableName,
ReturnValues = "ALL_NEW" // Return all the attributes of the updated item.
};
var response = client.UpdateItem(request);
```
Untuk informasi selengkapnya, lihat [UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).
## Penghitung atom
Anda dapat menggunakan `updateItem` untuk mengimplementasi penghitung atom, di mana Anda menambahkan atau mengurangi nilai atribut yang ada tanpa mengganggu permintaan tulis lainnya. Untuk memperbarui penghitung atom, gunakan `updateItem` dengan atribut jenis `Number` dalam parameter `UpdateExpression`, dan `ADD` sebagai `Action`.
Contoh berikut menunjukkan hal ini, menambahkan satu atribut `Quantity`.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new UpdateItemRequest
{
Key = new Dictionary() { { "Id", new AttributeValue { N = "121" } } },
ExpressionAttributeNames = new Dictionary()
{
{"#Q", "Quantity"}
},
ExpressionAttributeValues = new Dictionary()
{
{":incr",new AttributeValue {N = "1"}}
},
UpdateExpression = "SET #Q = #Q + :incr",
TableName = tableName
};
var response = client.UpdateItem(request);
```
## Menghapus item
Metode `DeleteItem` menghapus item dari tabel.
Berikut ini adalah langkah-langkah untuk menghapus item menggunakan .NET SDK API tingkat rendah.
1. Buat instans dari kelas `AmazonDynamoDBClient`.
1. Berikan parameter yang diperlukan dengan membuat instans kelas `DeleteItemRequest`.
Untuk menghapus item, diperlukan nama tabel dan kunci primer item.
1. Jalankan metode `DeleteItem` dengan menyediakan objek `DeleteItemRequest` yang Anda buat pada langkah sebelumnya.
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string tableName = "ProductCatalog";
var request = new DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "201" } } },
};
var response = client.DeleteItem(request);
```
### Menentukan parameter opsional
Anda juga dapat memberikan parameter opsional menggunakan objek `DeleteItemRequest` seperti yang ditunjukkan dalam contoh kode C\$1 berikut. Contoh tersebut menentukan parameter opsional berikut:
+ `ExpressionAttributeValues`dan `ConditionExpression` untuk menentukan bahwa item buku dapat dihapus hanya jika tidak lagi dalam publikasi (nilai InPublication atribut salah).
+ Parameter `ReturnValues` untuk meminta item yang dihapus dalam respons.
**Example**
```
var request = new DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary() { { "Id", new AttributeValue { N = "201" } } },
// Optional parameters.
ReturnValues = "ALL_OLD",
ExpressionAttributeNames = new Dictionary()
{
{"#IP", "InPublication"}
},
ExpressionAttributeValues = new Dictionary()
{
{":inpub",new AttributeValue {BOOL = false}}
},
ConditionExpression = "#IP = :inpub"
};
var response = client.DeleteItem(request);
```
Untuk informasi selengkapnya, lihat [DeleteItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteItem.html).
## Penulisan batch: Menempatkan dan menghapus beberapa item
*Penulisan batch* merujuk pada penempatan dan penghapusan beberapa item dalam satu batch. Metode `BatchWriteItem` memungkinkan Anda untuk memasukkan dan menghapus beberapa item dari satu atau lebih tabel dalam satu panggilan. Berikut ini adalah langkah-langkah untuk mengambil beberapa item menggunakan .NET SDK API tingkat rendah.
1. Buat instans dari kelas `AmazonDynamoDBClient`.
1. Jelaskan semua operasi tempatkan dan hapus dengan membuat instans dari kelas `BatchWriteItemRequest`.
1. Jalankan metode `BatchWriteItem` dengan menyediakan objek `BatchWriteItemRequest` yang Anda buat pada langkah sebelumnya.
1. Proses responsnya. Anda harus memeriksa apakah ada item permintaan yang belum diproses yang dikembalikan sebagai respons. Hal ini dapat terjadi jika Anda mencapai kuota throughput yang disediakan atau kesalahan sementara lainnya. Selain itu, DynamoDB membatasi ukuran permintaan dan jumlah operasi yang dapat Anda tentukan dalam permintaan. Jika Anda melebihi batas ini, DynamoDB menolak permintaan tersebut. Untuk informasi selengkapnya, lihat [BatchWriteItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html).
Contoh kode \$1C berikut mendemonstrasikan langkah sebelumnya. Contoh ini membuat `BatchWriteItemRequest` untuk melakukan operasi tulis berikut:
+ Tempatkan satu item dalam tabel `Forum`.
+ Tempatkan dan hapus satu item dari tabel `Thread`.
Kode menjalankan `BatchWriteItem` untuk melakukan operasi batch.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string table1Name = "Forum";
string table2Name = "Thread";
var request = new BatchWriteItemRequest
{
RequestItems = new Dictionary>
{
{
table1Name, new List
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary
{
{ "Name", new AttributeValue { S = "Amazon S3 forum" } },
{ "Threads", new AttributeValue { N = "0" }}
}
}
}
}
} ,
{
table2Name, new List
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary
{
{ "ForumName", new AttributeValue { S = "Amazon S3 forum" } },
{ "Subject", new AttributeValue { S = "My sample question" } },
{ "Message", new AttributeValue { S = "Message Text." } },
{ "KeywordTags", new AttributeValue { SS = new List { "Amazon S3", "Bucket" } } }
}
}
},
new WriteRequest
{
DeleteRequest = new DeleteRequest
{
Key = new Dictionary()
{
{ "ForumName", new AttributeValue { S = "Some forum name" } },
{ "Subject", new AttributeValue { S = "Some subject" } }
}
}
}
}
}
}
};
response = client.BatchWriteItem(request);
```
Untuk contoh pekerjaan, lihat [Contoh: Operasi Batch menggunakan API AWS SDK untuk .NET tingkat rendah](batch-operation-lowlevel-dotnet.md).
## Batch get: Mendapatkan beberapa item
Metode `BatchGetItem` memungkinkan Anda mengambil beberapa item dari satu atau lebih tabel.
**catatan**
Untuk mengambil satu item, Anda dapat menggunakan metode `GetItem`.
Berikut ini adalah langkah-langkah untuk mengambil beberapa item menggunakan API AWS SDK untuk .NET tingkat rendah.
1. Buat instans dari kelas `AmazonDynamoDBClient`.
1. Berikan parameter yang diperlukan dengan membuat instans kelas `BatchGetItemRequest`.
Untuk mengambil beberapa item, nama tabel dan daftar nilai kunci primer diperlukan.
1. Jalankan metode `BatchGetItem` dengan menyediakan objek `BatchGetItemRequest` yang Anda buat pada langkah sebelumnya.
1. Proses responsnya. Anda harus memeriksa apakah ada kunci yang belum diproses, yang dapat terjadi jika Anda mencapai kuota throughput yang disediakan atau kesalahan sementara lainnya.
Contoh kode \$1C berikut mendemonstrasikan langkah sebelumnya. Contoh tersebut mengambil item dari dua tabel, `Forum` dan `Thread`. Permintaan menentukan dua item dalam `Forum` dan tiga item dalam tabel `Thread`. Respons tersebut mencakup item dari kedua tabel. Kode tersebut menunjukkan bagaimana Anda dapat memproses respons.
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string table1Name = "Forum";
string table2Name = "Thread";
var request = new BatchGetItemRequest
{
RequestItems = new Dictionary()
{
{ table1Name,
new KeysAndAttributes
{
Keys = new List>()
{
new Dictionary()
{
{ "Name", new AttributeValue { S = "DynamoDB" } }
},
new Dictionary()
{
{ "Name", new AttributeValue { S = "Amazon S3" } }
}
}
}
},
{
table2Name,
new KeysAndAttributes
{
Keys = new List>()
{
new Dictionary()
{
{ "ForumName", new AttributeValue { S = "DynamoDB" } },
{ "Subject", new AttributeValue { S = "DynamoDB Thread 1" } }
},
new Dictionary()
{
{ "ForumName", new AttributeValue { S = "DynamoDB" } },
{ "Subject", new AttributeValue { S = "DynamoDB Thread 2" } }
},
new Dictionary()
{
{ "ForumName", new AttributeValue { S = "Amazon S3" } },
{ "Subject", new AttributeValue { S = "Amazon S3 Thread 1" } }
}
}
}
}
}
};
var response = client.BatchGetItem(request);
// Check the response.
var result = response.BatchGetItemResult;
var responses = result.Responses; // The attribute list in the response.
var table1Results = responses[table1Name];
Console.WriteLine("Items in table {0}" + table1Name);
foreach (var item1 in table1Results.Items)
{
PrintItem(item1);
}
var table2Results = responses[table2Name];
Console.WriteLine("Items in table {1}" + table2Name);
foreach (var item2 in table2Results.Items)
{
PrintItem(item2);
}
// Any unprocessed keys? could happen if you exceed ProvisionedThroughput or some other error.
Dictionary unprocessedKeys = result.UnprocessedKeys;
foreach (KeyValuePair pair in unprocessedKeys)
{
Console.WriteLine(pair.Key, pair.Value);
}
```
### Menentukan parameter opsional
Anda juga dapat memberikan parameter opsional menggunakan objek `BatchGetItemRequest` seperti yang ditunjukkan dalam contoh kode C\$1 berikut. Contoh tersebut mengambil dua item dari tabel `Forum`. Contoh tersebut menentukan parameter opsional berikut:
+ Parameter `ProjectionExpression` untuk menentukan atribut yang akan diambil.
**Example**
```
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string table1Name = "Forum";
var request = new BatchGetItemRequest
{
RequestItems = new Dictionary()
{
{ table1Name,
new KeysAndAttributes
{
Keys = new List>()
{
new Dictionary()
{
{ "Name", new AttributeValue { S = "DynamoDB" } }
},
new Dictionary()
{
{ "Name", new AttributeValue { S = "Amazon S3" } }
}
}
},
// Optional - name of an attribute to retrieve.
ProjectionExpression = "Title"
}
}
};
var response = client.BatchGetItem(request);
```
Untuk informasi selengkapnya, lihat [BatchGetItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchGetItem.html).
# Contoh: Operasi CRUD menggunakan API tingkat AWS SDK untuk .NET rendah
Contoh kode C\$1 berikut menunjukkan operasi CRUD pada item Amazon DynamoDB. Contoh tersebut menambahkan item ke tabel `ProductCatalog`, mengambilnya, melakukan berbagai pembaruan, dan akhirnya menghapus item. Jika Anda belum membuat tabel ini, Anda juga dapat membuatnya secara terprogram. Untuk informasi selengkapnya, lihat [Membuat tabel contoh dan mengunggah data menggunakan AWS SDK untuk .NET](AppendixSampleDataCodeDotNET.md).
Untuk step-by-step instruksi untuk menguji sampel berikut, lihat[Contoh kode .NET](CodeSamples.DotNet.md).
**Example**
```
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
using Amazon.SecurityToken;
namespace com.amazonaws.codesamples
{
class LowLevelItemCRUDExample
{
private static string tableName = "ProductCatalog";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
static void Main(string[] args)
{
try
{
CreateItem();
RetrieveItem();
// Perform various updates.
UpdateMultipleAttributes();
UpdateExistingAttributeConditionally();
// Delete item.
DeleteItem();
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
}
private static void CreateItem()
{
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
}},
{ "Title", new AttributeValue {
S = "Book 201 Title"
}},
{ "ISBN", new AttributeValue {
S = "11-11-11-11"
}},
{ "Authors", new AttributeValue {
SS = new List{"Author1", "Author2" }
}},
{ "Price", new AttributeValue {
N = "20.00"
}},
{ "Dimensions", new AttributeValue {
S = "8.5x11.0x.75"
}},
{ "InPublication", new AttributeValue {
BOOL = false
} }
}
};
client.PutItem(request);
}
private static void RetrieveItem()
{
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
ProjectionExpression = "Id, ISBN, Title, Authors",
ConsistentRead = true
};
var response = client.GetItem(request);
// Check the response.
var attributeList = response.Item; // attribute list in the response.
Console.WriteLine("\nPrinting item after retrieving it ............");
PrintItem(attributeList);
}
private static void UpdateMultipleAttributes()
{
var request = new UpdateItemRequest
{
Key = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
// Perform the following updates:
// 1) Add two new authors to the list
// 1) Set a new attribute
// 2) Remove the ISBN attribute
ExpressionAttributeNames = new Dictionary()
{
{"#A","Authors"},
{"#NA","NewAttribute"},
{"#I","ISBN"}
},
ExpressionAttributeValues = new Dictionary()
{
{":auth",new AttributeValue {
SS = {"Author YY", "Author ZZ"}
}},
{":new",new AttributeValue {
S = "New Value"
}}
},
UpdateExpression = "ADD #A :auth SET #NA = :new REMOVE #I",
TableName = tableName,
ReturnValues = "ALL_NEW" // Give me all attributes of the updated item.
};
var response = client.UpdateItem(request);
// Check the response.
var attributeList = response.Attributes; // attribute list in the response.
// print attributeList.
Console.WriteLine("\nPrinting item after multiple attribute update ............");
PrintItem(attributeList);
}
private static void UpdateExistingAttributeConditionally()
{
var request = new UpdateItemRequest
{
Key = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
ExpressionAttributeNames = new Dictionary()
{
{"#P", "Price"}
},
ExpressionAttributeValues = new Dictionary()
{
{":newprice",new AttributeValue {
N = "22.00"
}},
{":currprice",new AttributeValue {
N = "20.00"
}}
},
// This updates price only if current price is 20.00.
UpdateExpression = "SET #P = :newprice",
ConditionExpression = "#P = :currprice",
TableName = tableName,
ReturnValues = "ALL_NEW" // Give me all attributes of the updated item.
};
var response = client.UpdateItem(request);
// Check the response.
var attributeList = response.Attributes; // attribute list in the response.
Console.WriteLine("\nPrinting item after updating price value conditionally ............");
PrintItem(attributeList);
}
private static void DeleteItem()
{
var request = new DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary()
{
{ "Id", new AttributeValue {
N = "1000"
} }
},
// Return the entire item as it appeared before the update.
ReturnValues = "ALL_OLD",
ExpressionAttributeNames = new Dictionary()
{
{"#IP", "InPublication"}
},
ExpressionAttributeValues = new Dictionary()
{
{":inpub",new AttributeValue {
BOOL = false
}}
},
ConditionExpression = "#IP = :inpub"
};
var response = client.DeleteItem(request);
// Check the response.
var attributeList = response.Attributes; // Attribute list in the response.
// Print item.
Console.WriteLine("\nPrinting item that was just deleted ............");
PrintItem(attributeList);
}
private static void PrintItem(Dictionary attributeList)
{
foreach (KeyValuePair kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]")
);
}
Console.WriteLine("************************************************");
}
}
}
```
# Contoh: Operasi Batch menggunakan API AWS SDK untuk .NET tingkat rendah
**Topics**
+ [Contoh: Operasi penulisan Batch menggunakan API AWS SDK untuk .NET tingkat rendah](#batch-write-low-level-dotnet)
+ [Contoh: Batch get operation menggunakan API AWS SDK untuk .NET tingkat rendah](#LowLevelDotNetBatchGet)
Bagian ini memberikan contoh operasi batch, *batch write* dan *batch get*, yang mendukung Amazon DynamoDB.
## Contoh: Operasi penulisan Batch menggunakan API AWS SDK untuk .NET tingkat rendah
Contoh kode C\$1 berikut menggunakan metode `BatchWriteItem` untuk melakukan operasi put dan delete berikut:
+ Tempatkan satu item dalam tabel `Forum`.
+ Tempatkan satu item dan hapus satu item dari tabel `Thread`.
Anda dapat menentukan sejumlah permintaan put dan delete terhadap satu atau beberapa tabel saat membuat permintaan batch write Anda. Namun, `BatchWriteItem` DynamoDB membatasi ukuran permintaan penulisan batch dan jumlah operasi put dan delete dalam satu operasi penulisan batch. Untuk informasi selengkapnya, lihat [BatchWriteItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html). Jika permintaan Anda melebihi batas ini, permintaan Anda ditolak. Jika tabel Anda tidak memiliki cukup throughput yang disediakan untuk melayani permintaan ini, item permintaan yang belum diproses akan dikembalikan sebagai respons.
Contoh berikut memeriksa respons untuk melihat apakah ada item permintaan yang belum diproses. Jika ya, contoh tersebut akan mengulang kembali dan mengirim ulang permintaan `BatchWriteItem` dengan item yang belum diproses dalam permintaan tersebut. Anda juga dapat membuat tabel sampel ini dan mengunggah data sampel secara terprogram. Untuk informasi selengkapnya, lihat [Membuat tabel contoh dan mengunggah data menggunakan AWS SDK untuk .NET](AppendixSampleDataCodeDotNET.md).
Untuk step-by-step instruksi untuk menguji sampel berikut, lihat[Contoh kode .NET](CodeSamples.DotNet.md).
**Example**
```
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelBatchWrite
{
private static string table1Name = "Forum";
private static string table2Name = "Thread";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
static void Main(string[] args)
{
try
{
TestBatchWrite();
}
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
private static void TestBatchWrite()
{
var request = new BatchWriteItemRequest
{
ReturnConsumedCapacity = "TOTAL",
RequestItems = new Dictionary>
{
{
table1Name, new List
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary
{
{ "Name", new AttributeValue {
S = "S3 forum"
} },
{ "Threads", new AttributeValue {
N = "0"
}}
}
}
}
}
},
{
table2Name, new List
{
new WriteRequest
{
PutRequest = new PutRequest
{
Item = new Dictionary
{
{ "ForumName", new AttributeValue {
S = "S3 forum"
} },
{ "Subject", new AttributeValue {
S = "My sample question"
} },
{ "Message", new AttributeValue {
S = "Message Text."
} },
{ "KeywordTags", new AttributeValue {
SS = new List { "S3", "Bucket" }
} }
}
}
},
new WriteRequest
{
// For the operation to delete an item, if you provide a primary key value
// that does not exist in the table, there is no error, it is just a no-op.
DeleteRequest = new DeleteRequest
{
Key = new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Some partition key value"
} },
{ "Subject", new AttributeValue {
S = "Some sort key value"
} }
}
}
}
}
}
}
};
CallBatchWriteTillCompletion(request);
}
private static void CallBatchWriteTillCompletion(BatchWriteItemRequest request)
{
BatchWriteItemResponse response;
int callCount = 0;
do
{
Console.WriteLine("Making request");
response = client.BatchWriteItem(request);
callCount++;
// Check the response.
var tableConsumedCapacities = response.ConsumedCapacity;
var unprocessed = response.UnprocessedItems;
Console.WriteLine("Per-table consumed capacity");
foreach (var tableConsumedCapacity in tableConsumedCapacities)
{
Console.WriteLine("{0} - {1}", tableConsumedCapacity.TableName, tableConsumedCapacity.CapacityUnits);
}
Console.WriteLine("Unprocessed");
foreach (var unp in unprocessed)
{
Console.WriteLine("{0} - {1}", unp.Key, unp.Value.Count);
}
Console.WriteLine();
// For the next iteration, the request will have unprocessed items.
request.RequestItems = unprocessed;
} while (response.UnprocessedItems.Count > 0);
Console.WriteLine("Total # of batch write API calls made: {0}", callCount);
}
}
}
```
## Contoh: Batch get operation menggunakan API AWS SDK untuk .NET tingkat rendah
Contoh kode C\$1 berikut menggunakan metode `BatchGetItem` untuk mengambil beberapa item dari tabel `Forum` dan `Thread` dalam Amazon DynamoDB. `BatchGetItemRequest` menentukan nama tabel dan daftar kunci primer untuk setiap tabel. Contoh tersebut memproses respons dengan mencetak item yang diambil.
Untuk step-by-step instruksi untuk menguji sampel berikut, lihat[Contoh kode .NET](CodeSamples.DotNet.md).
**Example**
```
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelBatchGet
{
private static string table1Name = "Forum";
private static string table2Name = "Thread";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
static void Main(string[] args)
{
try
{
RetrieveMultipleItemsBatchGet();
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
}
private static void RetrieveMultipleItemsBatchGet()
{
var request = new BatchGetItemRequest
{
RequestItems = new Dictionary()
{
{ table1Name,
new KeysAndAttributes
{
Keys = new List >()
{
new Dictionary()
{
{ "Name", new AttributeValue {
S = "Amazon DynamoDB"
} }
},
new Dictionary()
{
{ "Name", new AttributeValue {
S = "Amazon S3"
} }
}
}
}},
{
table2Name,
new KeysAndAttributes
{
Keys = new List >()
{
new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Amazon DynamoDB"
} },
{ "Subject", new AttributeValue {
S = "DynamoDB Thread 1"
} }
},
new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Amazon DynamoDB"
} },
{ "Subject", new AttributeValue {
S = "DynamoDB Thread 2"
} }
},
new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Amazon S3"
} },
{ "Subject", new AttributeValue {
S = "S3 Thread 1"
} }
}
}
}
}
}
};
BatchGetItemResponse response;
do
{
Console.WriteLine("Making request");
response = client.BatchGetItem(request);
// Check the response.
var responses = response.Responses; // Attribute list in the response.
foreach (var tableResponse in responses)
{
var tableResults = tableResponse.Value;
Console.WriteLine("Items retrieved from table {0}", tableResponse.Key);
foreach (var item1 in tableResults)
{
PrintItem(item1);
}
}
// Any unprocessed keys? could happen if you exceed ProvisionedThroughput or some other error.
Dictionary unprocessedKeys = response.UnprocessedKeys;
foreach (var unprocessedTableKeys in unprocessedKeys)
{
// Print table name.
Console.WriteLine(unprocessedTableKeys.Key);
// Print unprocessed primary keys.
foreach (var key in unprocessedTableKeys.Value.Keys)
{
PrintItem(key);
}
}
request.RequestItems = unprocessedKeys;
} while (response.UnprocessedKeys.Count > 0);
}
private static void PrintItem(Dictionary attributeList)
{
foreach (KeyValuePair kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]")
);
}
Console.WriteLine("************************************************");
}
}
}
```
# Contoh: Menangani atribut tipe biner menggunakan API AWS SDK untuk .NET tingkat rendah
Contoh kode C\$1 berikut menggambarkan penanganan atribut jenis biner. Contoh tersebut menambahkan item ke tabel `Reply`. Item termasuk atribut jenis biner (`ExtendedMessage`) yang menyimpan data terkompresi. Contoh tersebut kemudian mengambil item dan mencetak semua nilai atribut. Sebagai ilustrasi, contoh menggunakan kelas `GZipStream` untuk mengompresi aliran sampel dan menetapkannya ke atribut `ExtendedMessage`, serta mendekompresinya saat mencetak nilai atribut.
Untuk step-by-step instruksi untuk menguji contoh berikut, lihat[Contoh kode .NET](CodeSamples.DotNet.md).
**Example**
```
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
namespace com.amazonaws.codesamples
{
class LowLevelItemBinaryExample
{
private static string tableName = "Reply";
private static AmazonDynamoDBClient client = new AmazonDynamoDBClient();
static void Main(string[] args)
{
// Reply table primary key.
string replyIdPartitionKey = "Amazon DynamoDB#DynamoDB Thread 1";
string replyDateTimeSortKey = Convert.ToString(DateTime.UtcNow);
try
{
CreateItem(replyIdPartitionKey, replyDateTimeSortKey);
RetrieveItem(replyIdPartitionKey, replyDateTimeSortKey);
// Delete item.
DeleteItem(replyIdPartitionKey, replyDateTimeSortKey);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
}
private static void CreateItem(string partitionKey, string sortKey)
{
MemoryStream compressedMessage = ToGzipMemoryStream("Some long extended message to compress.");
var request = new PutItemRequest
{
TableName = tableName,
Item = new Dictionary()
{
{ "Id", new AttributeValue {
S = partitionKey
}},
{ "ReplyDateTime", new AttributeValue {
S = sortKey
}},
{ "Subject", new AttributeValue {
S = "Binary type "
}},
{ "Message", new AttributeValue {
S = "Some message about the binary type"
}},
{ "ExtendedMessage", new AttributeValue {
B = compressedMessage
}}
}
};
client.PutItem(request);
}
private static void RetrieveItem(string partitionKey, string sortKey)
{
var request = new GetItemRequest
{
TableName = tableName,
Key = new Dictionary()
{
{ "Id", new AttributeValue {
S = partitionKey
} },
{ "ReplyDateTime", new AttributeValue {
S = sortKey
} }
},
ConsistentRead = true
};
var response = client.GetItem(request);
// Check the response.
var attributeList = response.Item; // attribute list in the response.
Console.WriteLine("\nPrinting item after retrieving it ............");
PrintItem(attributeList);
}
private static void DeleteItem(string partitionKey, string sortKey)
{
var request = new DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary()
{
{ "Id", new AttributeValue {
S = partitionKey
} },
{ "ReplyDateTime", new AttributeValue {
S = sortKey
} }
}
};
var response = client.DeleteItem(request);
}
private static void PrintItem(Dictionary attributeList)
{
foreach (KeyValuePair kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]") +
(value.B == null ? "" : "B=[" + FromGzipMemoryStream(value.B) + "]")
);
}
Console.WriteLine("************************************************");
}
private static MemoryStream ToGzipMemoryStream(string value)
{
MemoryStream output = new MemoryStream();
using (GZipStream zipStream = new GZipStream(output, CompressionMode.Compress, true))
using (StreamWriter writer = new StreamWriter(zipStream))
{
writer.Write(value);
}
return output;
}
private static string FromGzipMemoryStream(MemoryStream stream)
{
using (GZipStream zipStream = new GZipStream(stream, CompressionMode.Decompress))
using (StreamReader reader = new StreamReader(zipStream))
{
return reader.ReadToEnd();
}
}
}
}
```