Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Parameter bersyarat DynamoDB lama
Dokumen ini memberikan gambaran umum parameter bersyarat lama di DynamoDB dan merekomendasikan penggunaan parameter ekspresi baru sebagai gantinya. Ini mencakup detail tentang parameter seperti AttributesToGet, AttributeUpdates, ConditionalOperator, Diharapkan KeyConditions, QueryFilter,, dan ScanFilter, dan, dan memberikan contoh bagaimana menggunakan parameter ekspresi baru sebagai pengganti.
**penting**
Kami menyarankan agar Anda menggunakan parameter ekspresi yang baru, bukan parameter warisan ini, jika memungkinkan. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md).
Selain itu, DynamoDB tidak mengizinkan pencampuran parameter bersyarat warisan dan parameter ekspresi dalam satu panggilan. Sebagai contoh, memanggil operasi `Query` dengan `AttributesToGet` dan `ConditionExpression` akan memunculkan kesalahan.
Tabel berikut menunjukkan operasi API DynamoDB yang masih mendukung parameter warisan ini, dan parameter ekspresi mana yang akan digunakan sebagai gantinya. Tabel ini dapat membantu jika Anda akan memperbarui aplikasi Anda agar aplikasi tersebut menggunakan parameter ekspresi sebagai gantinya.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html)
Bagian berikut menyediakan informasi lebih lanjut tentang parameter bersyarat warisan.
**Topics**
+ [AttributesToGet (warisan)](LegacyConditionalParameters.AttributesToGet.md)
+ [AttributeUpdates (warisan)](LegacyConditionalParameters.AttributeUpdates.md)
+ [ConditionalOperator (warisan)](LegacyConditionalParameters.ConditionalOperator.md)
+ [Expected (warisan)](LegacyConditionalParameters.Expected.md)
+ [KeyConditions (warisan)](LegacyConditionalParameters.KeyConditions.md)
+ [QueryFilter (warisan)](LegacyConditionalParameters.QueryFilter.md)
+ [ScanFilter (warisan)](LegacyConditionalParameters.ScanFilter.md)
+ [Syarat penulisan dengan parameter warisan](LegacyConditionalParameters.Conditions.md)
# AttributesToGet (warisan)
**catatan**
Kami menyarankan agar Anda menggunakan parameter ekspresi yang baru, bukan parameter warisan ini, jika memungkinkan. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md). Untuk informasi spesifik tentang parameter baru sebagai pengganti untuk yang satu ini, [Gunakan *ProjectionExpression*sebagai gantinya](#ProjectionExpression.instead).
Parameter bersyarat warisan `AttributesToGet` adalah susunan satu atau beberapa atribut untuk diambil dari DynamoDB. Jika tidak ada nama atribut yang disediakan, semua atribut akan dikembalikan. Jika salah satu atribut yang diminta tidak ditemukan, atribut tersebut tidak akan muncul dalam hasil.
`AttributesToGet` memungkinkan Anda untuk mengambil atribut dari jenis Daftar atau Peta; tetapi, parameter tersebut tidak dapat mengambil elemen individu dalam Daftar atau Peta.
Perhatikan bahwa `AttributesToGet` tidak berpengaruh pada konsumsi throughput yang disediakan. DynamoDB menentukan unit kapasitas yang digunakan berdasarkan ukuran item, bukan jumlah data yang dikembalikan ke aplikasi.
## Gunakan *ProjectionExpression*sebagai gantinya - Contoh
Misalkan Anda ingin mengambil item dari tabel *Musik*, tapi Anda hanya ingin mengembalikan beberapa atributnya. Anda dapat menggunakan `GetItem` permintaan dengan `AttributesToGet` parameter, seperti dalam AWS CLI contoh ini:
```
aws dynamodb get-item \
--table-name Music \
--attributes-to-get '["Artist", "Genre"]' \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}'
```
Anda dapat menggunakan `ProjectionExpression` sebagai gantinya:
```
aws dynamodb get-item \
--table-name Music \
--projection-expression "Artist, Genre" \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}'
```
# AttributeUpdates (warisan)
**catatan**
Kami menyarankan agar Anda menggunakan parameter ekspresi yang baru, bukan parameter warisan ini, jika memungkinkan. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md). Untuk informasi spesifik tentang parameter baru sebagai pengganti untuk yang satu ini, [gunakan *UpdateExpression*sebagai gantinya.](#UpdateExpression.instead).
Dalam operasi `UpdateItem`, parameter bersyarat warisan `AttributeUpdates` berisi nama-nama atribut yang akan dimodifikasi, tindakan yang akan dilakukan pada setiap atribut, dan nilai baru untuk setiap atribut. Jika Anda memperbarui atribut yang merupakan atribut kunci indeks untuk setiap indeks pada tabel tersebut, jenis atribut harus sesuai dengan jenis kunci indeks yang didefinisikan dalam `AttributesDefinition` pada deskripsi tabel. Anda dapat menggunakan `UpdateItem` untuk memperbarui setiap atribut non-kunci.
Nilai atribut tidak boleh nol. Atribut jenis Biner dan String harus memiliki panjang lebih dari nol. Atribut jenis set tidak boleh kosong. Permintaan dengan nilai kosong akan ditolak dengan pengecualian `ValidationException`.
Setiap elemen `AttributeUpdates` terdiri dari nama atribut untuk dimodifikasi, beserta hal berikut:
+ `Value` - Nilai baru, jika berlaku, untuk atribut ini.
+ `Action` - Sebuah nilai yang menentukan cara melakukan pembaruan. Tindakan ini hanya berlaku untuk atribut yang ada yang jenis datanya adalah Angka atau sebuah set; jangan gunakan `ADD` untuk jenis data lainnya.
Jika item dengan kunci primer tertentu ditemukan dalam tabel, nilai berikut melakukan tindakan berikut:
+ `PUT` - Menambahkan atribut tertentu pada item. Jika sudah ada, atribut akan digantikan oleh nilai baru.
+ `DELETE` - Menghapus atribut dan nilainya, jika tidak ada nilai yang ditentukan untuk `DELETE`. Jenis data dari nilai yang ditentukan harus sesuai dengan jenis data dari nilai yang ada.
Jika suatu set nilai ditentukan, nilai-nilai tersebut dikurangi dari set lama. Sebagai contoh, jika nilai atribut adalah set `[a,b,c]` dan tindakan `DELETE` menentukan `[a,c]`, nilai atribut akhir adalah `[b]`. Menentukan satu set kosong adalah kesalahan.
+ `ADD` - Menambahkan nilai yang ditentukan untuk item, jika atribut belum ada. Jika atribut tidak ada, perilaku `ADD` bergantung pada jenis data dari atribut:
+ Jika atribut yang ada berupa angka, dan jika `Value` juga berupa angka, `Value` secara matematis ditambahkan ke atribut yang ada. Jika `Value` adalah angka negatif, nilai tersebut dikurangi dari atribut yang ada.
**catatan**
Jika Anda menggunakan `ADD` untuk menambah atau mengurangi nilai angka untuk item yang tidak ada sebelum pembaruan, DynamoDB menggunakan 0 sebagai nilai awal.
Begitu pun halnya, jika Anda menggunakan `ADD` untuk item yang ada untuk menambah atau mengurangi nilai atribut yang tidak ada sebelum pembaruan, DynamoDB menggunakan `0` sebagai nilai awal. Misalnya, anggap item yang ingin Anda perbarui tidak memiliki atribut bernama *itemcount*, tetapi Anda memutuskan untuk tetap `ADD` angka `3` ke atribut ini. DynamoDB akan membuat atribut *itemcount*, mengatur nilai awalnya ke `0`, dan akhirnya menambahkan `3` ke nilai tersebut. Hasilnya akan menjadi atribut *itemcount* baru, dengan nilai `3`.
+ Jika jenis data yang ada merupakan sebuah set, dan jika `Value` juga merupakan sebuah set, `Value` ditambahkan ke set yang ada. Misalnya, jika nilai atribut adalah set `[1,2]`, dan tindakan `ADD` menentukan `[3]`, nilai atribut akhir adalah `[1,2,3]`. Terjadi kesalahan jika tindakan `ADD` ditentukan untuk atribut set dan jenis atribut yang ditentukan tidak cocok dengan jenis set yang ada.
Kedua set harus memiliki jenis data primitif yang sama. Sebagai contoh, jika jenis data yang ada adalah set string, `Value` juga harus berupa set string.
Jika item dengan kunci yang ditentukan ditemukan dalam tabel, nilai berikut melakukan tindakan berikut:
+ `PUT` - Menyebabkan DynamoDB membuat item baru dengan kunci primer yang ditentukan, lalu menambahkan atribut.
+ `DELETE` - Tidak terjadi apa-apa, karena atribut tidak dapat dihapus dari item yang tidak ada. Operasi berhasil, tapi DynamoDB tidak membuat item baru.
+ `ADD` - Menyebabkan DynamoDB membuat item dengan kunci primer yang disediakan dan angka (atau set angka) untuk nilai atribut. Satu-satunya jenis data yang diperbolehkan adalah Angka dan Set Angka.
Jika Anda memberikan atribut apa pun yang merupakan bagian dari kunci indeks, set data untuk atribut tersebut harus sesuai dengan skema dalam definisi atribut tabel.
## Gunakan *UpdateExpression*sebagai gantinya - Contoh
Misalkan Anda ingin memodifikasi item dalam tabel *Musik*. Anda dapat menggunakan `UpdateItem` permintaan dengan `AttributeUpdates` parameter, seperti dalam AWS CLI contoh ini:
```
aws dynamodb update-item \
--table-name Music \
--key '{
"SongTitle": {"S":"Call Me Today"},
"Artist": {"S":"No One You Know"}
}' \
--attribute-updates '{
"Genre": {
"Action": "PUT",
"Value": {"S":"Rock"}
}
}'
```
Anda dapat menggunakan `UpdateExpression` sebagai gantinya:
```
aws dynamodb update-item \
--table-name Music \
--key '{
"SongTitle": {"S":"Call Me Today"},
"Artist": {"S":"No One You Know"}
}' \
--update-expression 'SET Genre = :g' \
--expression-attribute-values '{
":g": {"S":"Rock"}
}'
```
# ConditionalOperator (warisan)
**catatan**
Kami menyarankan agar Anda menggunakan parameter ekspresi yang baru, bukan parameter warisan ini, jika memungkinkan. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md).
Parameter bersyarat warisan `ConditionalOperator` adalah operator logis yang digunakan untuk menerapkan syarat dalam peta `Expected`, `QueryFilter`, atau `ScanFilter`:
+ AND - Jika semua syarat bernilai true, seluruh peta bernilai true.
+ OR - Jika setidaknya salah satu syarat bernilai true, seluruh peta bernilai true.
Jika Anda menghilangkan `ConditionalOperator`, `AND` menjadi pengaturan default.
Operasi akan berhasil hanya jika seluruh peta bernilai true.
**catatan**
Parameter ini tidak mendukung atribut jenis Daftar atau Peta.
# Expected (warisan)
**catatan**
Kami menyarankan agar Anda menggunakan parameter ekspresi yang baru, bukan parameter warisan ini, jika memungkinkan. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md). Untuk informasi spesifik tentang parameter baru sebagai pengganti untuk yang satu ini, [gunakan *ConditionExpression*sebagai gantinya.](#Expected.instead).
Parameter bersyarat lama `Expected` adalah blok bersyarat untuk operasi. `UpdateItem` `Expected`adalah peta attribute/condition pasangan. Setiap elemen peta terdiri dari nama atribut, operator perbandingan, dan satu atau beberapa nilai. DynamoDB membandingkan atribut dengan nilai(-nilai) yang Anda berikan, menggunakan operator perbandingan. Untuk setiap elemen `Expected`, hasil evaluasi adalah true atau false.
Jika Anda menentukan lebih dari satu elemen dalam peta `Expected`, secara default semua syarat harus bernilai true. Dengan kata lain, kondisi digabungkan menggunakan `AND` operator. (Anda dapat menggunakan parameter `ConditionalOperator` untuk syarat OR sebagai gantinya. Jika Anda melakukan ini, setidaknya salah satu syarat harus bernilai true, bukan semuanya.)
Jika peta `Expected` bernilai true, operasi bersyarat berhasil; jika tidak, gagal.
`Expected` berisi hal berikut ini:
+ `AttributeValueList` - Satu atau beberapa nilai untuk mengevaluasi atribut yang disediakan. Jumlah nilai dalam daftar tergantung pada `ComparisonOperator` yang sedang digunakan.
Untuk jenis Angka, perbandingan nilainya bersifat numerik.
Perbandingan nilai string untuk lebih besar dari, sama dengan, atau kurang dari didasarkan pada Unicode dengan UTF-8 encoding biner. Sebagai contoh, `a` lebih besar dari `A`, dan `a` lebih besar dari `B`.
Untuk jenis Biner, DynamoDB memperlakukan setiap byte data biner sebagai tidak bertanda ketika membandingkan nilai-nilai biner.
+ `ComparisonOperator` - Sebuah pembanding untuk mengevaluasi atribut dalam `AttributeValueList`. Saat melakukan perbandingan, DynamoDB menggunakan bacaan sangat konsisten.
Operator perbandingan berikut ini tersedia:
`EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN`
Berikut adalah deskripsi setiap operator perbandingan.
+ `EQ`: Sama dengan. `EQ` didukung untuk semua jenis data, termasuk daftar dan peta.
`AttributeValueList` hanya dapat berisi satu elemen `AttributeValue` berjenis String, Angka, Biner, Set String, Set Angka, atau Set Biner. Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sama dengan `{"NS":["6", "2", "1"]}`.
+ `NE`: Tidak sama dengan. `NE` didukung untuk semua set data, termasuk daftar dan peta.
`AttributeValueList` hanya dapat berisi satu `AttributeValue` berjenis String, Angka, Biner, Set String, Set Angka, atau Set Biner. Jika item berisi `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sama dengan `{"NS":["6", "2", "1"]}`.
+ `LE`: Kurang dari atau sama dengan.
`AttributeValueList` hanya dapat berisi satu elemen `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`.
+ `LT`: Kurang dari.
`AttributeValueList` hanya dapat berisi satu `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`.
+ `GE`: Lebih besar dari atau sama dengan.
`AttributeValueList` hanya dapat berisi satu elemen `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`.
+ `GT`: Lebih besar dari.
`AttributeValueList` hanya dapat berisi satu elemen `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`.
+ `NOT_NULL`: Atribut ada. `NOT_NULL` didukung untuk semua jenis data, termasuk daftar dan peta.
**catatan**
Operator ini menguji keberadaan atribut, bukan jenis datanya. Jika jenis data atribut "`a`" adalah nol, dan Anda mengevaluasinya menggunakan `NOT_NULL`, hasilnya adalah Boolean `true`. Hasil ini karena atribut "`a`" ada; jenis data tidak relevan dengan operator perbandingan `NOT_NULL`.
+ `NULL`: Atribut tidak ada. `NULL` didukung untuk semua jenis data, termasuk daftar dan peta.
**catatan**
Operator ini menguji tidak adanya atribut, bukan jenis datanya. Jika jenis data atribut "`a`" adalah nol, dan Anda mengevaluasinya menggunakan `NULL`, hasilnya adalah Boolean `false`. Hasil ini karena atribut "`a`" ada; jenis datanya tidak relevan dengan operator perbandingan `NULL`.
+ `CONTAINS`: Memeriksa urutan berikutnya, atau nilai dalam suatu set.
`AttributeValueList` hanya dapat berisi satu elemen `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika atribut target perbandingan berjenis String, operator memeriksa kecocokan substring. Jika atribut target perbandingan berjenis Biner, operator mencari urutan berikutnya dari target yang cocok dengan input. Jika atribut target perbandingan adalah suatu set ("`SS`", "`NS`", atau "`BS`"), operator bernilai true jika menemukan kecocokan sama persis dengan anggota set tersebut.
CONTAINS didukung untuk daftar: Saat mengevaluasi "`a CONTAINS b`", "`a`" dapat berupa sebuah daftar; tetapi, "`b`" tidak dapat berupa set, peta, atau daftar.
+ `NOT_CONTAINS`: Memeriksa tidak adanya urutan berikutnya, atau tidak adanya nilai dalam suatu set.
`AttributeValueList` hanya dapat berisi satu elemen `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika atribut target perbandingan adalah String, operator memeriksa tidak adanya kecocokan substring. Jika atribut target perbandingan adalah Biner, operator mencari tidak adanya urutan berikutnya dari target yang cocok dengan input. Jika atribut target perbandingan adalah suatu set ("`SS`", "`NS`", atau "`BS`"), operator bernilai true jika `does not` menemukan kecocokan sama persis dengan anggota set tersebut.
NOT\$1CONTAINS didukung untuk daftar: Saat mengevaluasi "`a NOT CONTAINS b`", "`a`" dapat berupa sebuah daftar; tetapi, "`b`" tidak dapat berupa set, peta, atau daftar.
+ `BEGINS_WITH`: Memeriksa prefiks.
`AttributeValueList` hanya dapat berisi satu `AttributeValue` berjenis String atau Biner (bukan jenis Angka atau set). Atribut target perbandingan harus berjenis String atau Biner (bukan jenis Angka atau set).
+ `IN`: Memeriksa elemen yang cocok dalam dua set.
`AttributeValueList` dapat berisi satu atau beberapa elemen `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Atribut ini dibandingkan dengan atribut jenis set yang ada dari suatu item. Jika elemen apa pun dari set input ada dalam atribut item, ekspresi bernilai true.
+ `BETWEEN`: Lebih besar dari atau sama dengan nilai pertama, dan kurang dari atau sama dengan nilai kedua.
`AttributeValueList` harus berisi dua elemen `AttributeValue` berjenis yang sama, baik String, Angka, atau Biner (bukan jenis set). Suatu atribut target cocok jika nilai target lebih besar dari, atau sama dengan, elemen pertama dan kurang dari, atau sama dengan, elemen kedua. Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Misalnya, `{"S":"6"}` tidak sebanding dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`
Parameter berikut dapat digunakan sebagai pengganti `AttributeValueList` dan `ComparisonOperator`:
+ `Value` - Nilai untuk DynamoDB guna membandingkan dengan atribut.
+ `Exists` - Nilai Boolean yang menyebabkan DynamoDB mengevaluasi nilai sebelum mencoba operasi bersyarat:
+ Jika `Exists` adalah `true`, DynamoDB akan memeriksa untuk melihat apakah nilai atribut sudah ada dalam tabel. Jika ditemukan, syarat bernilai true; jika tidak, syarat akan bernilai false.
+ Jika `Exists` adalah `false`, DynamoDB mengasumsikan bahwa nilai atribut `not` ada dalam tabel. Jika pada dasarnya nilai tidak ada, asumsi tersebut valid dan syarat bernilai true. Jika nilai ditemukan, terlepas dari asumsi bahwa nilai itu tidak ada, syaratnya bernilai false.
Perhatikan bahwa nilai default untuk `Exists` adalah `true`.
Parameter `Value` dan `Exists` tidak kompatibel dengan `AttributeValueList` dan `ComparisonOperator`. Perhatikan bahwa jika Anda menggunakan kedua set parameter sekaligus, DynamoDB akan mengembalikan pengecualian `ValidationException`.
**catatan**
Parameter ini tidak mendukung atribut jenis Daftar atau Peta.
## Gunakan *ConditionExpression*sebagai gantinya - Contoh
Misalkan Anda ingin memodifikasi item dalam tabel *Musik*, tetapi hanya jika syarat tertentu bernilai true. Anda dapat menggunakan `UpdateItem` permintaan dengan `Expected` parameter, seperti dalam AWS CLI contoh ini:
```
aws dynamodb update-item \
--table-name Music \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}' \
--attribute-updates '{
"Price": {
"Action": "PUT",
"Value": {"N":"1.98"}
}
}' \
--expected '{
"Price": {
"ComparisonOperator": "LE",
"AttributeValueList": [ {"N":"2.00"} ]
}
}'
```
Anda dapat menggunakan `ConditionExpression` sebagai gantinya:
```
aws dynamodb update-item \
--table-name Music \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}' \
--update-expression 'SET Price = :p1' \
--condition-expression 'Price <= :p2' \
--expression-attribute-values '{
":p1": {"N":"1.98"},
":p2": {"N":"2.00"}
}'
```
# KeyConditions (warisan)
**catatan**
Kami menyarankan agar Anda menggunakan parameter ekspresi yang baru, bukan parameter warisan ini, jika memungkinkan. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md). Untuk informasi spesifik tentang parameter baru sebagai pengganti untuk yang satu ini, [gunakan *KeyConditionExpression*sebagai gantinya.](#KeyConditionExpression.instead).
Parameter bersyarat warisan `KeyConditions` berisi kriteria pemilihan untuk operasi `Query`. Untuk kueri pada tabel, Anda dapat memiliki syarat pada tabel atribut kunci primer saja. Anda harus memberikan nama kunci partisi dan nilai sebagai syarat `EQ`. Anda dapat memberikan syarat kedua secara opsional, dengan merujuk pada kunci urutan.
**catatan**
Jika Anda tidak memberikan syarat kunci urutan, semua item yang cocok dengan kunci partisi akan diambil. Jika ada, `FilterExpression` atau `QueryFilter` akan diterapkan setelah item diambil.
Untuk kueri pada indeks, Anda dapat memiliki syarat hanya pada atribut kunci indeks. Anda harus memberikan nama kunci partisi indeks dan nilai sebagai syarat `EQ`. Anda dapat memberikan syarat kedua secara opsional, dengan merujuk pada kunci urutan indeks.
Setiap elemen `KeyConditions` terdiri dari nama atribut untuk dimodifikasi, beserta hal berikut:
+ `AttributeValueList` - Satu atau beberapa nilai untuk mengevaluasi atribut yang disediakan. Jumlah nilai dalam daftar tergantung pada `ComparisonOperator` yang sedang digunakan.
Untuk jenis Angka, perbandingan nilainya bersifat numerik.
Perbandingan nilai string untuk lebih besar dari, sama dengan, atau kurang dari didasarkan pada Unicode dengan UTF-8 encoding biner. Sebagai contoh, `a` lebih besar dari `A`, dan `a` lebih besar dari `B`.
Untuk Biner, DynamoDB memperlakukan setiap byte data biner sebagai tidak bertanda ketika membandingkan nilai-nilai biner.
+ `ComparisonOperator` - Sebuah pembanding untuk mengevaluasi atribut. Misalnya: sama dengan, lebih besar dari, dan kurang dari.
Untuk `KeyConditions`, hanya operator perbandingan berikut yang didukung:
`EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN`
Berikut adalah deskripsi setiap operator perbandingan.
+ `EQ`: Sama dengan.
`AttributeValueList` hanya dapat berisi satu `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang ditentukan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sama dengan `{"NS":["6", "2", "1"]}`.
+ `LE`: Kurang dari atau sama dengan.
`AttributeValueList` hanya dapat berisi satu elemen `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`.
+ `LT`: Kurang dari.
`AttributeValueList` hanya dapat berisi satu `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`.
+ `GE`: Lebih besar dari atau sama dengan.
`AttributeValueList` hanya dapat berisi satu elemen `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`.
+ `GT`: Lebih besar dari.
`AttributeValueList` hanya dapat berisi satu elemen `AttributeValue` berjenis String, Angka, atau Biner (bukan jenis set). Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Sebagai contoh, `{"S":"6"}` tidak sama dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`.
+ `BEGINS_WITH`: Memeriksa prefiks.
`AttributeValueList` hanya dapat berisi satu `AttributeValue` berjenis String atau Biner (bukan jenis Angka atau set). Atribut target perbandingan harus berjenis String atau Biner (bukan jenis Angka atau set).
+ `BETWEEN`: Lebih besar dari atau sama dengan nilai pertama, dan kurang dari atau sama dengan nilai kedua.
`AttributeValueList` harus berisi dua elemen `AttributeValue` berjenis yang sama, baik String, Angka, atau Biner (bukan jenis set). Suatu atribut target cocok jika nilai target lebih besar dari, atau sama dengan, elemen pertama dan kurang dari, atau sama dengan, elemen kedua. Jika item berisi elemen `AttributeValue` dengan jenis berbeda dari yang disediakan dalam permintaan, nilainya tidak cocok. Misalnya, `{"S":"6"}` tidak sebanding dengan `{"N":"6"}`. Selain itu, `{"N":"6"}` tidak sebanding dengan `{"NS":["6", "2", "1"]}`.
## Gunakan *KeyConditionExpression*sebagai gantinya - Contoh
Misalkan Anda ingin mengambil beberapa item dengan kunci partisi yang sama dari tabel *Musik*. Anda dapat menggunakan `Query` permintaan dengan `KeyConditions` parameter, seperti dalam AWS CLI contoh ini:
```
aws dynamodb query \
--table-name Music \
--key-conditions '{
"Artist":{
"ComparisonOperator":"EQ",
"AttributeValueList": [ {"S": "No One You Know"} ]
},
"SongTitle":{
"ComparisonOperator":"BETWEEN",
"AttributeValueList": [ {"S": "A"}, {"S": "M"} ]
}
}'
```
Anda dapat menggunakan `KeyConditionExpression` sebagai gantinya:
```
aws dynamodb query \
--table-name Music \
--key-condition-expression 'Artist = :a AND SongTitle BETWEEN :t1 AND :t2' \
--expression-attribute-values '{
":a": {"S": "No One You Know"},
":t1": {"S": "A"},
":t2": {"S": "M"}
}'
```
# QueryFilter (warisan)
**catatan**
Kami menyarankan agar Anda menggunakan parameter ekspresi yang baru, bukan parameter warisan ini, jika memungkinkan. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md). Untuk informasi spesifik tentang parameter baru sebagai pengganti untuk yang satu ini, [gunakan *FilterExpression*sebagai gantinya.](#FilterExpression.instead).
Dalam operasi `Query`, parameter bersyarat warisan `QueryFilter` adalah syarat yang mengevaluasi hasil kueri setelah item dibaca dan hanya mengembalikan nilai-nilai yang diinginkan.
Parameter ini tidak mendukung atribut jenis Daftar atau Peta.
**catatan**
`QueryFilter` diterapkan setelah item dibaca; proses penyaringan tidak menggunakan unit kapasitas baca tambahan.
Jika Anda memberikan lebih dari satu syarat dalam peta `QueryFilter`, secara default semua syarat harus bernilai true. Dengan kata lain, kondisi digabungkan menggunakan `AND` operator. (Anda dapat menggunakan parameter [ConditionalOperator (warisan)](LegacyConditionalParameters.ConditionalOperator.md) untuk syarat OR sebagai gantinya. Jika Anda melakukan ini, setidaknya salah satu syarat harus bernilai true, bukan semuanya.)
Perhatikan bahwa `QueryFilter` tidak mengizinkan atribut kunci. Anda tidak dapat menentukan syarat filter pada kunci partisi atau kunci urutan.
Setiap elemen `QueryFilter` terdiri dari nama atribut untuk dimodifikasi, beserta hal berikut:
+ `AttributeValueList` - Satu atau beberapa nilai untuk mengevaluasi atribut yang disediakan. Jumlah nilai dalam daftar tergantung pada operator yang ditentukan dalam `ComparisonOperator`.
Untuk jenis Angka, perbandingan nilainya bersifat numerik.
Perbandingan nilai string untuk lebih besar dari, sama dengan, atau kurang dari didasarkan pada pengodean biner UTF-8. Sebagai contoh, `a` lebih besar dari `A`, dan `a` lebih besar dari `B`.
Untuk jenis Biner, DynamoDB memperlakukan setiap byte data biner sebagai tidak bertanda ketika membandingkan nilai-nilai biner.
Untuk informasi tentang menentukan jenis data di JSON, lihat [API tingkat rendah DynamoDB](Programming.LowLevelAPI.md).
+ `ComparisonOperator` - Sebuah pembanding untuk mengevaluasi atribut. Misalnya: sama dengan, lebih besar dari, dan kurang dari.
Operator perbandingan berikut ini tersedia:
`EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN`
## Gunakan *FilterExpression*sebagai gantinya - Contoh
Misalkan Anda ingin mengajukan kueri tabel *Musik* dan menerapkan syarat untuk item yang cocok. Anda dapat menggunakan permintaan `Query` dengan parameter `QueryFilter`, seperti dalam contoh AWS CLI ini:
```
aws dynamodb query \
--table-name Music \
--key-conditions '{
"Artist": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"S": "No One You Know"} ]
}
}' \
--query-filter '{
"Price": {
"ComparisonOperator": "GT",
"AttributeValueList": [ {"N": "1.00"} ]
}
}'
```
Anda dapat menggunakan `FilterExpression` sebagai gantinya:
```
aws dynamodb query \
--table-name Music \
--key-condition-expression 'Artist = :a' \
--filter-expression 'Price > :p' \
--expression-attribute-values '{
":p": {"N":"1.00"},
":a": {"S":"No One You Know"}
}'
```
# ScanFilter (warisan)
**catatan**
Kami menyarankan agar Anda menggunakan parameter ekspresi yang baru, bukan parameter warisan ini, jika memungkinkan. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md). Untuk informasi spesifik tentang parameter baru sebagai pengganti untuk yang satu ini, [gunakan *FilterExpression*sebagai gantinya.](#FilterExpression2.instead).
Dalam operasi `Scan`, parameter bersyarat warisan `ScanFilter` adalah syarat yang mengevaluasi hasil pemindaian dan hanya mengembalikan nilai-nilai yang diinginkan.
**catatan**
Parameter ini tidak mendukung atribut jenis Daftar atau Peta.
Jika Anda menentukan lebih dari satu syarat di peta `ScanFilter`, secara default semua syarat harus bernilai true. Dengan kata lain, kondisinya ANDed bersama. (Anda dapat menggunakan parameter [ConditionalOperator (warisan)](LegacyConditionalParameters.ConditionalOperator.md) untuk syarat OR sebagai gantinya. Jika Anda melakukan ini, setidaknya salah satu syarat harus bernilai true, bukan semuanya.)
Setiap elemen `ScanFilter` terdiri dari nama atribut untuk dimodifikasi, beserta hal berikut:
+ `AttributeValueList` - Satu atau beberapa nilai untuk mengevaluasi atribut yang disediakan. Jumlah nilai dalam daftar tergantung pada operator yang ditentukan dalam `ComparisonOperator`.
Untuk jenis Angka, perbandingan nilainya bersifat numerik.
Perbandingan nilai string untuk lebih besar dari, sama dengan, atau kurang dari didasarkan pada pengodean biner UTF-8. Sebagai contoh, `a` lebih besar dari `A`, dan `a` lebih besar dari `B`.
Untuk Biner, DynamoDB memperlakukan setiap byte data biner sebagai tidak bertanda ketika membandingkan nilai-nilai biner.
Untuk informasi tentang menentukan jenis data di JSON, lihat [API tingkat rendah DynamoDB](Programming.LowLevelAPI.md).
+ `ComparisonOperator` - Sebuah pembanding untuk mengevaluasi atribut. Misalnya: sama dengan, lebih besar dari, dan kurang dari.
Operator perbandingan berikut ini tersedia:
`EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN`
## Gunakan *FilterExpression*sebagai gantinya - Contoh
Misalkan Anda ingin memindai tabel *Musik* dan menerapkan syarat untuk item yang cocok. Anda dapat menggunakan permintaan `Scan` dengan parameter `ScanFilter`, seperti dalam contoh AWS CLI ini:
```
aws dynamodb scan \
--table-name Music \
--scan-filter '{
"Genre":{
"AttributeValueList":[ {"S":"Rock"} ],
"ComparisonOperator": "EQ"
}
}'
```
Anda dapat menggunakan `FilterExpression` sebagai gantinya:
```
aws dynamodb scan \
--table-name Music \
--filter-expression 'Genre = :g' \
--expression-attribute-values '{
":g": {"S":"Rock"}
}'
```
# Syarat penulisan dengan parameter warisan
**catatan**
Kami menyarankan agar Anda menggunakan parameter ekspresi yang baru, bukan parameter warisan ini, jika memungkinkan. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md).
Bagian berikut menjelaskan cara menulis syarat untuk digunakan dengan parameter warisan, seperti `Expected`, `QueryFilter`, dan `ScanFilter`.
**catatan**
Aplikasi baru harus menggunakan parameter ekspresi sebagai gantinya. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi di DynamoDB](Expressions.md).
## Syarat sederhana
Dengan nilai atribut, Anda dapat menulis syarat untuk perbandingan terhadap atribut tabel. Syarat selalu bernilai true atau false, dan terdiri dari:
+ `ComparisonOperator` – lebih besar dari, kurang dari, sama dengan, dan sebagainya.
+ `AttributeValueList` (opsional) – nilai atribut untuk dibandingkan. Tergantung pada `ComparisonOperator` yang sedang digunakan, `AttributeValueList` mungkin berisi satu, dua, atau lebih nilai; atau mungkin tidak ada sama sekali.
Bagian berikut menjelaskan berbagai operator perbandingan, beserta contoh cara menggunakannya dalam syarat.
### Operator perbandingan tanpa nilai atribut
+ `NOT_NULL` - true jika atribut ada.
+ `NULL` - true jika atribut tidak ada.
Gunakan operator ini untuk memeriksa apakah atribut ada, atau tidak ada. Karena tidak ada nilai untuk dibandingkan, jangan tentukan `AttributeValueList`.
**Contoh**
Ekspresi berikut bernilai true jika ada atribut *Dimensi*.
```
...
"Dimensions": {
ComparisonOperator: "NOT_NULL"
}
...
```
### Operator perbandingan dengan satu nilai atribut
+ `EQ` - true jika atribut sama dengan sebuah nilai.
`AttributeValueList` hanya dapat berisi satu nilai berjenis String, Angka, Biner, Set String, Set Angka, atau Set Biner. Jika item berisi nilai dengan jenis berbeda dari jenis yang ditentukan dalam permintaan, nilainya tidak cocok. Misalnya, string `"3"` tidak sama dengan angka `3`. Selain itu, angka `3` tidak sama dengan set angka `[3, 2, 1]`.
+ `NE` - true jika atribut tidak sama dengan sebuah nilai.
`AttributeValueList` hanya dapat berisi satu nilai berjenis String, Angka, Biner, Set String, Set Angka, atau Set Biner. Jika item berisi nilai dengan jenis berbeda dari jenis yang ditentukan dalam permintaan, nilainya tidak cocok.
+ `LE` - true jika atribut kurang dari atau sama dengan sebuah nilai.
`AttributeValueList` hanya dapat berisi satu nilai berjenis String, Angka, atau Biner (bukan set). Jika item berisi `AttributeValue` dengan jenis berbeda dari yang ditentukan dalam permintaan, nilainya tidak cocok.
+ `LT` - true jika atribut kurang dari sebuah nilai.
`AttributeValueList` hanya dapat berisi satu nilai berjenis String, Angka, atau Biner (bukan set). Jika item berisi nilai dengan jenis berbeda dari jenis yang ditentukan dalam permintaan, nilainya tidak cocok.
+ `GE` - true jika atribut lebih besar dari atau sama dengan suatu nilai.
`AttributeValueList` hanya dapat berisi satu nilai berjenis String, Angka, atau Biner (bukan set). Jika item berisi nilai dengan jenis berbeda dari jenis yang ditentukan dalam permintaan, nilainya tidak cocok.
+ `GT` - true jika atribut lebih besar dari sebuah nilai.
`AttributeValueList` hanya dapat berisi satu nilai berjenis String, Angka, atau Biner (bukan set). Jika item berisi nilai dengan jenis berbeda dari jenis yang ditentukan dalam permintaan, nilainya tidak cocok.
+ `CONTAINS` - true jika nilai ada dalam suatu set, atau jika satu nilai berisi nilai lain.
`AttributeValueList` hanya dapat berisi satu nilai berjenis String, Angka, atau Biner (bukan set). Jika atribut target perbandingan berupa String, operator memeriksa kecocokan substring. Jika atribut target perbandingan berupa Biner, operator mencari urutan berikutnya dari target yang cocok dengan input. Jika atribut target perbandingan adalah suatu set, operator bernilai true jika menemukan kecocokan sama persis dengan anggota set tersebut.
+ `NOT_CONTAINS` - true jika nilai *tidak* ada dalam suatu set, atau jika satu nilai tidak berisi nilai lainnya.
`AttributeValueList` hanya dapat berisi satu nilai berjenis String, Angka, atau Biner (bukan set). Jika atribut target perbandingan adalah String, operator memeriksa tidak adanya kecocokan substring. Jika atribut target perbandingan adalah Biner, operator mencari tidak adanya urutan berikutnya dari target yang cocok dengan input. Jika atribut target perbandingan adalah sebuah set, operator akan bernilai true jika *tidak* menemukan kecocokan yang sama persis dengan anggota set.
+ `BEGINS_WITH` - true jika beberapa karakter pertama atribut cocok dengan nilai yang disediakan. Jangan gunakan operator ini untuk membandingkan angka.
`AttributeValueList` hanya dapat berisi satu nilai berjenis String atau Biner (bukan Angka atau set). Atribut target perbandingan harus berupa String atau Biner (bukan Angka atau set).
Gunakan operator ini untuk membandingkan atribut dengan sebuah nilai. Anda harus menentukan `AttributeValueList` yang berisi nilai tunggal. Untuk sebagian besar operator, nilai ini harus berupa skalar; tetapi, operator `EQ` dan `NE` juga mendukung set.
**Contoh**
Ekspresi berikut bernilai true jika:
+ Harga produk lebih besar dari 100.
```
...
"Price": {
ComparisonOperator: "GT",
AttributeValueList: [ {"N":"100"} ]
}
...
```
+ Kategori produk dimulai dengan "Bo".
```
...
"ProductCategory": {
ComparisonOperator: "BEGINS_WITH",
AttributeValueList: [ {"S":"Bo"} ]
}
...
```
+ Produk tersedia dalam warna merah, hijau, atau hitam:
```
...
"Color": {
ComparisonOperator: "EQ",
AttributeValueList: [
[ {"S":"Black"}, {"S":"Red"}, {"S":"Green"} ]
]
}
...
```
**catatan**
Saat membandingkan jenis data set, urutan elemen tidak menjadi masalah. DynamoDB hanya akan mengembalikan item dengan set nilai yang sama, terlepas dari urutan yang Anda tentukan dalam permintaan Anda.
### Operator perbandingan dengan dua nilai atribut
+ `BETWEEN` - true jika nilai adalah antara batas bawah dan batas atas, termasuk titik akhir.
`AttributeValueList` harus berisi dua elemen dari jenis yang sama, baik String, Angka, atau Biner (bukan set). Suatu atribut target cocok jika nilai target lebih besar dari, atau sama dengan, elemen pertama dan kurang dari, atau sama dengan, elemen kedua. Jika item berisi nilai dengan jenis berbeda dari jenis yang ditentukan dalam permintaan, nilainya tidak cocok.
Gunakan operator ini untuk menentukan apakah nilai atribut termasuk dalam kisaran. `AttributeValueList` harus berisi dua elemen skalar berjenis yang sama - String, Angka, atau Biner.
**Contoh**
Ekspresi berikut bernilai true jika harga produk adalah antara 100 dan 200.
```
...
"Price": {
ComparisonOperator: "BETWEEN",
AttributeValueList: [ {"N":"100"}, {"N":"200"} ]
}
...
```
### Operator perbandingan dengan nilai atribut *n*
+ `IN` - true jika nilai sama dengan salah satu nilai dalam daftar yang dienumerasi. Hanya nilai skalar yang didukung dalam daftar, bukan set. Atribut target harus memiliki jenis yang sama dan nilai persis agar cocok.
`AttributeValueList` dapat berisi satu atau beberapa elemen jenis String, Angka, atau Biner (bukan set). Atribut ini dibandingkan dengan atribut jenis non-set yang ada dari suatu item. Jika elemen *apa pun* dari set input ada dalam atribut item, ekspresi bernilai true.
`AttributeValueList` dapat berisi satu atau beberapa nilai berjenis String, Angka, atau Biner (bukan set). Atribut target perbandingan harus memiliki jenis yang sama dan nilai persis agar cocok. Sebuah String tidak pernah cocok dengan set String.
Gunakan operator ini untuk menentukan apakah nilai yang disediakan berada dalam daftar yang dienumerasi. Anda dapat menentukan nilai skalar apa pun di `AttributeValueList`, tetapi semua angka tersebut harus dari jenis data yang sama.
**Contoh**
Ekspresi berikut bernilai true jika nilai untuk *Id* adalah 201, 203, atau 205.
```
...
"Id": {
ComparisonOperator: "IN",
AttributeValueList: [ {"N":"201"}, {"N":"203"}, {"N":"205"} ]
}
...
```
## Menggunakan beberapa syarat
DynamoDB memungkinkan Anda menggabungkan beberapa syarat untuk membentuk ekspresi kompleks. Anda melakukan ini dengan menyediakan setidaknya dua ekspresi, dengan [ConditionalOperator (warisan)](LegacyConditionalParameters.ConditionalOperator.md) opsional.
Secara default, ketika Anda menentukan lebih dari satu syarat, *semua* syarat harus bernilai true agar seluruh ekspresi bernilai true. Dengan kata lain, operasi *AND* sedang berlangsung secara implisit.
**Contoh**
Ekspresi berikut bernilai true jika produk adalah buku yang memiliki setidaknya 600 halaman. Kedua syarat harus bernilai true, karena keduanya menjalankan *AND* secara implisit dan bersama-sama.
```
...
"ProductCategory": {
ComparisonOperator: "EQ",
AttributeValueList: [ {"S":"Book"} ]
},
"PageCount": {
ComparisonOperator: "GE",
AttributeValueList: [ {"N":600"} ]
}
...
```
Anda dapat menggunakan [ConditionalOperator (warisan)](LegacyConditionalParameters.ConditionalOperator.md) untuk memperjelas bahwa operasi *AND* akan berlangsung. Contoh berikut berperilaku dengan cara yang sama seperti sebelumnya.
```
...
"ConditionalOperator" : "AND",
"ProductCategory": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"N":"Book"} ]
},
"PageCount": {
"ComparisonOperator": "GE",
"AttributeValueList": [ {"N":600"} ]
}
...
```
Anda juga dapat mengatur `ConditionalOperator` menjadi *OR*, yang berarti bahwa *setidaknya salah satu* syarat harus bernilai true.
**Contoh**
Ekspresi berikut bernilai true jika produk adalah sepeda gunung, jika produk tersebut adalah nama merek tertentu, atau jika harganya lebih besar dari 100.
```
...
ConditionalOperator : "OR",
"BicycleType": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"S":"Mountain" ]
},
"Brand": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"S":"Brand-Company A" ]
},
"Price": {
"ComparisonOperator": "GT",
"AttributeValueList": [ {"N":"100"} ]
}
...
```
**catatan**
Dalam ekspresi yang kompleks, syarat diproses secara berurutan, mulai syarat pertama hingga terakhir.
Anda tidak dapat menggunakan AND dan OR dalam satu ekspresi.
## Operator bersyarat lainnya
Dalam rilis DynamoDB sebelumnya, parameter `Expected` berperilaku berbeda untuk penulisan bersyarat. Setiap item dalam peta `Expected` mewakili nama atribut untuk diperiksa DynamoDB, beserta hal berikut:
+ `Value` – nilai untuk dibandingkan terhadap atribut.
+ `Exists` – menentukan apakah nilai ada sebelum mencoba operasi.
Opsi `Value` dan `Exists` tetap didukung dalam DynamoDB; tetapi, keduanya hanya membiarkan Anda menguji syarat kesetaraan, atau apakah atribut ada. Kami menyarankan agar Anda menggunakan `ComparisonOperator` dan `AttributeValueList` sebagai gantinya, karena opsi ini memungkinkan Anda membangun berbagai syarat yang lebih luas.
**Example**
`DeleteItem` dapat memeriksa untuk melihat apakah buku tidak lagi dalam publikasi, dan hanya menghapusnya jika syarat ini bernilai true. Berikut adalah contoh AWS CLI menggunakan syarat warisan:
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{
"Id": {"N":"600"}
}' \
--expected '{
"InPublication": {
"Exists": true,
"Value": {"BOOL":false}
}
}'
```
Contoh berikut melakukan hal yang sama, tetapi tidak menggunakan syarat warisan:
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{
"Id": {"N":"600"}
}' \
--expected '{
"InPublication": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"BOOL":false} ]
}
}'
```
**Example**
Operasi `PutItem` dapat melindungi terhadap penimpaan item yang ada dengan atribut kunci primer yang sama. Berikut adalah contoh penggunaan syarat warisan:
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item '{
"Id": {"N":"500"},
"Title": {"S":"Book 500 Title"}
}' \
--expected '{
"Id": { "Exists": false }
}'
```
Contoh berikut melakukan hal yang sama, tetapi tidak menggunakan syarat warisan:
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item '{
"Id": {"N":"500"},
"Title": {"S":"Book 500 Title"}
}' \
--expected '{
"Id": { "ComparisonOperator": "NULL" }
}'
```
**catatan**
Untuk syarat di peta `Expected`, jangan gunakan opsi warisan `Value` dan `Exists` bersama dengan `ComparisonOperator` dan `AttributeValueList`. Jika Anda melakukan hal ini, penulisan bersyarat Anda akan gagal.