Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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
```