Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di espressioni in DynamoDB
In Amazon DynamoDB è possibile *utilizzare* le espressioni per specificare quali attributi leggere da un elemento, per scrivere dati quando viene soddisfatta una condizione, per specificare come aggiornare un elemento, per definire query e filtrare i risultati di una query.
Questa tabella descrive la grammatica delle espressioni di base e i tipi di espressioni disponibili.
| Tipo di espressione | Description |
| --- | --- |
| Espressioni di proiezione | Un'espressione di proiezione identifica gli attributi che si desidera recuperare da un elemento quando si utilizzano operazioni come Query o GetItem Scan. |
| Espressione condizionale | Un'espressione di condizione determina quali elementi devono essere modificati quando si utilizzano le operazioni PutItem UpdateItem, e. DeleteItem |
| Espressione di aggiornamento | Un'espressione di aggiornamento specifica come UpdateItem verranno modificati gli attributi di un elemento, ad esempio l'impostazione di un valore scalare o la rimozione di elementi da un elenco o da una mappa. |
| Espressione di condizione della chiave | Un’espressione di condizione della chiave determina gli elementi che una query leggerà da una tabella o da un indice. |
| Espressione filtro | Un’espressione di filtro determina quali elementi all’interno dei risultati di Query devono essere restituiti. Tutti gli altri risultati vengono scartati. |
Per ulteriori informazioni sulla sintassi delle espressioni e informazioni più dettagliate su ciascun tipo di espressione, consulta le sezioni riportate di seguito.
**Topics**
+ [Riferimento agli attributi degli elementi quando si utilizzano le espressioni in DynamoDB](Expressions.Attributes.md)
+ [Nomi di attributi di espressione (alias) in DynamoDB](Expressions.ExpressionAttributeNames.md)
+ [Utilizzo dei valori degli attributi di espressione in DynamoDB](Expressions.ExpressionAttributeValues.md)
+ [Utilizzo di espressioni di proiezione in DynamoDB](Expressions.ProjectionExpressions.md)
+ [Utilizzo di espressioni di aggiornamento in DynamoDB](Expressions.UpdateExpressions.md)
+ [Espressioni, operatori e funzioni di condizione e di filtro in DynamoDB](Expressions.OperatorsAndFunctions.md)
+ [Esempio di CLI di espressione condizionale in DynamoDB](Expressions.ConditionExpressions.md)
**Nota**
Per la compatibilità con le versioni precedenti, DynamoDB supporta anche parametri condizionali che non usano espressioni. Per ulteriori informazioni, consulta [Parametri condizionali legacy di DynamoDB](LegacyConditionalParameters.md).
Le nuove applicazioni dovrebbero utilizzare le espressioni al posto dei parametri legacy.
# Riferimento agli attributi degli elementi quando si utilizzano le espressioni in DynamoDB
In questa sezione viene descritto come fare riferimento agli attributi degli elementi in una espressione in Amazon DynamoDB. Puoi utilizzare qualsiasi attributo, anche se è nidificato all'interno di più elenchi e mappe.
**Topics**
+ [Attributi di primo livello](#Expressions.Attributes.TopLevelAttributes)
+ [Attributi nidificati](#Expressions.Attributes.NestedAttributes)
+ [Percorsi dei documenti](#Expressions.Attributes.NestedElements.DocumentPathExamples)
**Un articolo di esempio: ProductCatalog**
Gli esempi presenti in questa pagina utilizzano il seguente elemento di esempio presente nella tabella `ProductCatalog`. (Questa tabella è descritta in [Tabelle e dati di esempio da utilizzare in 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"
}
```
Tenere presente quanto segue:
+ il valore della chiave di partizione (`Id`) è `123`. Non vi è chiave di ordinamento;
+ la maggior parte degli attributi dispone di tipi di dati scalari, come `String`, `Number`, `Boolean` e `Null`;
+ un attributo (`Color`) è di tipo `String Set`;
+ i seguenti attributi sono tipi di dati dei documenti:
+ elenco di `RelatedItems`. Ogni elemento è un `Id` per un prodotto correlato;
+ una mappa di `Pictures`. Ogni elemento rappresenta una breve descrizione di un'immagine insieme all'URL del file dell'immagine corrispondente;
+ una mappa di `ProductReviews`. Ogni elemento rappresenta una classificazione e un elenco delle valutazioni corrispondenti a quella classificazione. Inizialmente, questa mappa viene popolata con valutazioni di cinque stelle e di una stella.
## Attributi di primo livello
Un attributo si definisce di *primo livello* se non è incorporato in un altro attributo. Per gli elementi `ProductCatalog`, gli attributi di primo livello sono:
+ `Id`
+ `Title`
+ `Description`
+ `BicycleType`
+ `Brand`
+ `Price`
+ `Color`
+ `ProductCategory`
+ `InStock`
+ `QuantityOnHand`
+ `RelatedItems`
+ `Pictures`
+ `ProductReviews`
+ `Comment`
+ `Safety.Warning`
Tutti questi attributi di primo livello sono scalari, eccetto `Color` (elenco), `RelatedItems` (elenco), `Pictures` (mappa) e `ProductReviews` (mappa).
## Attributi nidificati
Un attributo si definisce *nidificato* se è incorporato in un altro attributo. Per ottenere l'accesso a un attributo nidificato, usa gli *operatori di deferenziazione*:
+ `[n]`: per gli elementi list
+ `.` (punto): per gli elementi map
### Accesso agli elementi dell'elenco
L'operatore di deferenziazione per un elemento dell'elenco è **[*N*]**, dove *n* è il numero dell'elemento. Gli elementi dell'elenco sono a base zero, ovvero [0] rappresenta il primo elemento nell'elenco, [1] il secondo e così via. Ecco alcuni esempi:
+ `MyList[0]`
+ `AnotherList[12]`
+ `ThisList[5][11]`
L'elemento `ThisList[5]` è esso stesso un elenco nidificato. Pertanto, `ThisList[5][11]` si riferisce al dodicesimo elemento in quell'elenco.
Il numero all'interno delle parentesi quadre deve essere un numero intero non negativo. Pertanto, le espressioni seguenti non sono valide:
+ `MyList[-1]`
+ `MyList[0.4]`
### Accesso agli elementi della mappa
L'operatore di deferenziazione per una mappa è **.** (un punto). Usa un punto come separatore tra gli elementi in una mappa:
+ `MyMap.nestedField`
+ `MyMap.nestedField.deeplyNestedField`
## Percorsi dei documenti
In un espressione si utilizza un *percorso del documento* per comunicare a DynamoDB dove trovare un attributo. Per gli attributi di primo livello, il percorso del documento è semplicemente il nome dell'attributo. Per un attributo nidificato, costruisci il percorso del documento usando gli operatori di deferenziazione.
Di seguito sono riportati alcuni esempi di percorsi di documenti. (Fai riferimento all'elemento mostrato in [Riferimento agli attributi degli elementi quando si utilizzano le espressioni in DynamoDB](#Expressions.Attributes)).
+ Un attributo scalare di primo livello:
`Description`
+ Un attributo dell'elenco di primo livello. (Questo restituisce l'intero elenco, non solo alcuni elementi).
`RelatedItems`
+ Il terzo elemento dall'elenco `RelatedItems`. (Ricorda che gli elementi dell'elenco sono a base zero).
`RelatedItems[2]`
+ L'immagine di vista frontale del prodotto.
`Pictures.FrontView`
+ Tutte le valutazioni da cinque stelle.
`ProductReviews.FiveStar`
+ La prima delle valutazioni da cinque stelle.
`ProductReviews.FiveStar[0]`
**Nota**
La profondità massima per un percorso del documento è 32. Pertanto, il numero di operatori di deferenziazione in un percorso non può eccedere questo limite.
È possibile utilizzare qualsiasi nome di attributo nel percorso di un documento purché soddisfi i seguenti requisiti:
+ Il primo carattere è una lettera (`a-z` o `A-Z`) o un numero (`0-9`)
+ Il secondo carattere (se presente) è una lettera (`a-z` o `A-Z`)
**Nota**
Se un nome di attributo non soddisfa questo requisito, devi definire un nome di attributo dell'espressione come un segnaposto.
Per ulteriori informazioni, consulta [Nomi di attributi di espressione (alias) in DynamoDB](Expressions.ExpressionAttributeNames.md).
# Nomi di attributi di espressione (alias) in DynamoDB
Un *nome di attributo di espressione* è un alias (o segnaposto) utilizzato in un’espressione Amazon DynamoDB in alternativa a un nome di attributo effettivo. Un nome di attributo di espressione deve iniziare con un simbolo di cancelletto (`#`) ed essere seguito da uno o più caratteri alfanumerici. È consentito anche il carattere trattino basso (`_`).
In questa sezione vengono descritte diverse situazioni in cui è necessario utilizzare i nomi di attributi di espressione.
**Nota**
Gli esempi in questa sezione utilizzano il AWS Command Line Interface (AWS CLI).
**Topics**
+ [Parole riservate](#Expressions.ExpressionAttributeNames.ReservedWords)
+ [Nomi di attributi contenenti caratteri speciali](#Expressions.ExpressionAttributeNames.AttributeNamesContainingSpecialCharacters)
+ [Attributi nidificati](#Expressions.ExpressionAttributeNames.NestedAttributes)
+ [Riferimento ripetuto ai nomi di attributo](#Expressions.ExpressionAttributeNames.RepeatingAttributeNames)
## Parole riservate
A volte potrebbe essere necessario scrivere un'espressione contenente un nome di attributo in conflitto con una parola riservata di DynamoDB. Per un elenco completo delle parole riservate, consulta [Parole riservate in DynamoDB](ReservedWords.md).)
Ad esempio, l' AWS CLI esempio seguente non riuscirà perché `COMMENT` è una parola riservata.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "Comment"
```
Come soluzione alternativa, puoi sostituire `Comment` con un nome di attributo di espressione come `#c`. Il simbolo `#` (cancelletto) è obbligatorio e indica che si tratta di un segnaposto per un nome di attributo. L' AWS CLI esempio sarebbe ora simile al seguente.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#c" \
--expression-attribute-names '{"#c":"Comment"}'
```
**Nota**
Se un nome di attributo inizia con un numero, contiene uno spazio o una parola riservata, è *necessario* utilizzare un nome di attributo di espressione per sostituire il nome di tale attributo nell'espressione.
## Nomi di attributi contenenti caratteri speciali
Un punto (".") in un'espressione viene interpretato come carattere separatore in un percorso di un documento. Tuttavia, DynamoDB consente anche di utilizzare un punto e altri caratteri speciali, ad esempio, un trattino ("-") come parte di un nome di attributo. In alcuni casi questo può portare ad ambiguità. A titolo illustrativo, supponi di voler recuperare l'attributo `Safety.Warning` da un elemento `ProductCatalog` (consulta [Riferimento agli attributi degli elementi quando si utilizzano le espressioni in DynamoDB](Expressions.Attributes.md)).
Supponi di voler accedere a `Safety.Warning` utilizzando un'espressione di proiezione.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "Safety.Warning"
```
DynamoDB restituisce un risultato vuoto, anziché la stringa prevista ("`Always wear a helmet`"). Ciò accade poiché DynamoDB interpreta un punto in un'espressione come separatore del percorso di un documento. In questo caso, occorre definire un nome di attributo di espressione (ad esempio `#sw`) come sostituto di `Safety.Warning`. Puoi quindi utilizzare l'espressione di proiezione seguente.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#sw" \
--expression-attribute-names '{"#sw":"Safety.Warning"}'
```
DynamoDB restituirebbe quindi il risultato corretto.
**Nota**
Se il nome di un attributo contiene un punto (".") o un trattino ("-"), è *necessario* utilizzare un nome di attributo di espressione per sostituire il nome di tale attributo nell'espressione.
## Attributi nidificati
Si supponga di voler accedere all’attributo annidato `ProductReviews.OneStar`. In un nome di attributo di espressione, DynamoDB considera il punto (“.”) come carattere all’interno di un nome di attributo. Per fare riferimento all’attributo annidato, definisci un nome di attributo di espressione per ogni elemento nel percorso del documento:
+ `#pr — ProductReviews`
+ `#1star — OneStar`
Puoi quindi utilizzare `#pr.#1star` per l'espressione di proiezione.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "#pr.#1star" \
--expression-attribute-names '{"#pr":"ProductReviews", "#1star":"OneStar"}'
```
DynamoDB restituirebbe quindi il risultato corretto.
## Riferimento ripetuto ai nomi di attributo
I nomi di attributo di espressione sono utili quando si vuole fare riferimento ripetutamente allo stesso nome di attributo. Ad esempio, considera la seguente espressione per recuperare alcune valutazioni da un elemento di `ProductCatalog`.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"123"}}' \
--projection-expression "ProductReviews.FiveStar, ProductReviews.ThreeStar, ProductReviews.OneStar"
```
Per renderlo più conciso, puoi sostituire `ProductReviews` con un nome di attributo di espressione come `#pr`. L'aspetto dell'espressione rivista è ora simile al seguente.
+ `#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"}'
```
Se definisci un nome di attributo di espressione, è necessario usarlo in maniera uniforme nell'intera espressione. Inoltre, non puoi omettere il simbolo `#`.
# Utilizzo dei valori degli attributi di espressione in DynamoDB
I *valori degli attributi di espressione* in Amazon DynamoDB agiscono come variabili. Sostituiscono i valori effettivi che si desidera confrontare, valori che potrebbero non essere noti fino al runtime. Un valore dell'attributo dell'espressione deve iniziare con un carattere di due punti (`:`) ed essere seguito da uno o più caratteri alfanumerici.
Per esempio, supponi di voler restituire tutti gli elementi `ProductCatalog` che sono disponibili in `Black` e che costano `500` o meno. Puoi utilizzare un'operazione `Scan` con un'espressione di filtro, come in questo esempio di 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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file `values.json`:
```
{
":c": { "S": "Black" },
":p": { "N": "500" }
}
```
Se definisci un valore dell'attributo dell'espressione, è necessario usarlo in maniera uniforme nell'intera espressione. Inoltre, non puoi omettere il simbolo `:`.
I valori degli attributi dell'espressione sono usati con espressioni di condizione della chiave, espressioni di condizioni, espressioni di aggiornamento ed espressioni di filtro.
# Utilizzo di espressioni di proiezione in DynamoDB
Per leggere i dati da una tabella, vengono utilizzate operazioni quali `GetItem`, `Query` oppure `Scan`. Amazon DynamoDB restituisce tutti gli attributi dell'elemento per impostazione predefinita. Per ottenerne solo alcuni degli attributi e non tutti, usa un'espressione di proiezione.
Un'*espressione di proiezione* è una stringa che identifica gli attributi che desideri. Per recuperare un singolo attributo, specificane il nome. Per più attributi, i nomi devono essere separati da una virgola.
Di seguito sono riportati alcuni esempi di espressioni di proiezione basate sull'elemento `ProductCatalog` da [Riferimento agli attributi degli elementi quando si utilizzano le espressioni in DynamoDB](Expressions.Attributes.md):
+ Un singolo attributo di primo livello.
`Title `
+ Tre attributi di livello superiore DynamoDB recupera l'intero set `Color`.
`Title, Price, Color`
+ Quattro attributi di livello superiore. DynamoDB restituisce l'intero contenuto di `RelatedItems` e `ProductReviews`.
`Title, Description, RelatedItems, ProductReviews`
**Nota**
L’espressione di proiezione non ha alcun effetto sul consumo di throughput allocato. DynamoDB determina le unità di capacità utilizzate in base alla dimensione dell’elemento anziché alla quantità di dati restituiti a un’applicazione.
**Parole riservate e caratteri speciali**
DynamoDB dispone di parole riservate e caratteri speciali. DynamoDB consente di utilizzare le parole riservate e i caratteri speciali per i nomi, ma si consiglia di evitare questa opzione perché comporta l’utilizzo di alias per i nomi ogni volta che questi vengono utilizzati in un’espressione. Per un elenco completo, consulta [Parole riservate in DynamoDB](ReservedWords.md).
Sarà necessario utilizzare i nomi degli attributi di espressione al posto del nome effettivo se:
+ Il nome di attributo è nell’elenco di parole riservate in DynamoDB.
+ Il nome dell’attributo non soddisfa il requisito che il primo carattere sia `a-z` o `A-Z` e che il secondo carattere (se presente) sia `a-Z`, `A-Z` o`0-9`.
+ Il nome dell’attributo contiene un **\$1** (cancelletto) o **:** (due punti).
L' AWS CLI esempio seguente mostra come utilizzare un'espressione di proiezione con un'`GetItem`operazione. Questa espressione di proiezione recupera un attributo scalare di primo livello (`Description`), il primo elemento in un elenco (`RelatedItems[0]`) e un elenco nidificato in una mappa (`ProductReviews.FiveStar`).
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '"Id": { "N": "123" } \
--projection-expression "Description, RelatedItems[0], ProductReviews.FiveStar"
```
Per questo esempio viene restituito il seguente JSON.
```
{
"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"
}
]
}
}
}
```
# Utilizzo di espressioni di aggiornamento in DynamoDB
L'operazione `UpdateItem` aggiorna una voce esistente o aggiunge una nuova voce alla tabella, se non è già presente. È necessario fornire la chiave dell'elemento che intendi aggiornare. È necessario fornire inoltre un'espressione di aggiornamento che indica gli attributi che intendi modificare e i valori che intendi assegnargli.
Una *espressione di aggiornamento* specifica come `UpdateItem` modificherà gli attributi di un elemento, ad esempio impostando un valore scalare o rimuovendo elementi da un elenco o da una mappa.
Di seguito è riportato un riepilogo della sintassi delle espressioni di aggiornamento.
```
update-expression ::=
[ SET action [, action] ... ]
[ REMOVE action [, action] ...]
[ ADD action [, action] ... ]
[ DELETE action [, action] ...]
```
Un'espressione di aggiornamento comprende una o più clausole. Ogni clausola inizia con una parola chiave `SET`, `REMOVE`, `ADD` o `DELETE`. Puoi includere qualsiasi di queste clausole in un'espressione di aggiornamento, in qualsiasi ordine. Tuttavia, ciascuna parola chiave dell'operazione può comparire una sola volta.
All'interno di ogni clausola esistono una o più operazioni separate da virgole. Ciascuna operazione rappresenta una modifica di dati.
Gli esempi in questa sezione si basano sull'elemento `ProductCatalog` illustrato in [Utilizzo di espressioni di proiezione in DynamoDB](Expressions.ProjectionExpressions.md).
Gli argomenti seguenti illustrano diversi casi d'uso dell'operazione `SET`.
**Topics**
+ [SET: modifica o aggiunta di attributi dell'elemento](#Expressions.UpdateExpressions.SET)
+ [REMOVE: eliminazione degli attributi da un elemento](#Expressions.UpdateExpressions.REMOVE)
+ [ADD: aggiornamento di numeri e set](#Expressions.UpdateExpressions.ADD)
+ [DELETE: rimozione di elementi da un set](#Expressions.UpdateExpressions.DELETE)
+ [Utilizzo di più espressioni di aggiornamento](#Expressions.UpdateExpressions.Multiple)
## SET: modifica o aggiunta di attributi dell'elemento
Utilizza l'operazione `SET` in un'espressione di aggiornamento per aggiungere uno o più attributi a un elemento. Se alcuni di questi attributi esistono già, vengono sovrascritti dai nuovi valori. Se intendi evitare la sovrascrittura di un attributo esistente, puoi utilizzare `SET` con la funzione `if_not_exists`. La funzione `if_not_exists` è specifica dell'operazione `SET` e può essere utilizzata solo in un'espressione di aggiornamento.
Quando utilizzi `SET` per aggiornare un elemento dell'elenco, i contenuti dell'elemento vengono sostituiti con i nuovi dati specificati. Se l'elemento non esiste ancora, `SET` aggiunge il nuovo elemento alla fine dell'elenco.
Se aggiungi più elementi in un'unica operazione `SET`, gli elementi verranno ordinati per numero di elemento.
Puoi inoltre utilizzare `SET` per aggiungere o sottrarre un attributo di tipo `Number`. Per eseguire più operazioni `SET`, separarle con virgole.
Nel riepilogo della sintassi seguente:
+ L'*path*elemento è il percorso del documento verso l'elemento.
+ Un **operand**elemento può essere il percorso del documento verso un elemento o una funzione.
```
set-action ::=
path = value
value ::=
operand
| operand '+' operand
| operand '-' operand
operand ::=
path | function
function ::=
if_not_exists (path, value)
```
Se l’elemento non contiene un attributo nel percorso specificato, `if_not_exists` restituisce `value`. Altrimenti, restituisce `path`.
L'operazione `PutItem` seguente crea un elemento di esempio a cui gli esempi fanno riferimento.
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item file://item.json
```
Gli argomenti per `--item` sono memorizzati nel file `item.json`: (Per semplicità, vengono utilizzati solo pochi attributi dell'item).
```
{
"Id": {"N": "789"},
"ProductCategory": {"S": "Home Improvement"},
"Price": {"N": "52"},
"InStock": {"BOOL": true},
"Brand": {"S": "Acme"}
}
```
**Topics**
+ [Modifica degli attributi](#Expressions.UpdateExpressions.SET.ModifyingAttributes)
+ [Aggiunta di elenchi e mappe](#Expressions.UpdateExpressions.SET.AddingListsAndMaps)
+ [Aggiunta di elementi a un elenco](#Expressions.UpdateExpressions.SET.AddingListElements)
+ [Aggiunta di attributi di mappa nidificati](#Expressions.UpdateExpressions.SET.AddingNestedMapAttributes)
+ [Incremento e decremento di attributi numerici](#Expressions.UpdateExpressions.SET.IncrementAndDecrement)
+ [Aggiunta di elementi a un elenco](#Expressions.UpdateExpressions.SET.UpdatingListElements)
+ [Prevenzione delle sovrascritture di un attributo esistente](#Expressions.UpdateExpressions.SET.PreventingAttributeOverwrites)
### Modifica degli attributi
**Example**
Aggiorna gli attributi `ProductCategory` e `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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file `values.json`:
```
{
":c": { "S": "Hardware" },
":p": { "N": "60" }
}
```
**Nota**
Nell'operazione `UpdateItem`, `--return-values ALL_NEW` fa in modo che DynamoDB restituisca l'elemento come compare dopo l'aggiornamento.
### Aggiunta di elenchi e mappe
**Example**
Aggiungi un nuovo elenco e una nuova mappa.
```
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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file `values.json`:
```
{
":ri": {
"L": [
{ "S": "Hammer" }
]
},
":pr": {
"M": {
"FiveStar": {
"L": [
{ "S": "Best product ever!" }
]
}
}
}
}
```
### Aggiunta di elementi a un elenco
**Example**
Aggiungi un nuovo attributo all'elenco `RelatedItems`. Ricorda che gli elementi dell'elenco sono a base zero, ovvero [0] rappresenta il primo elemento nell'elenco, [1] il secondo e così via.
```
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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file `values.json`:
```
{
":ri": { "S": "Nails" }
}
```
**Nota**
Quando utilizzi `SET` per aggiornare un elemento dell'elenco, i contenuti dell'elemento vengono sostituiti con i nuovi dati specificati. Se l'elemento non esiste ancora, `SET` aggiunge il nuovo elemento alla fine dell'elenco.
Se aggiungi più elementi in un'unica operazione `SET`, gli elementi verranno ordinati per numero di elemento.
### Aggiunta di attributi di mappa nidificati
**Example**
Aggiungi alcuni attributi di mappa nidificati.
```
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
```
Gli argomenti per `--expression-attribute-names` sono memorizzati nel file `names.json`:
```
{
"#pr": "ProductReviews",
"#5star": "FiveStar",
"#3star": "ThreeStar"
}
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file `values.json`:
```
{
":r5": { "S": "Very happy with my purchase" },
":r3": {
"L": [
{ "S": "Just OK - not that great" }
]
}
}
```
**Importante**
Non è possibile aggiornare gli attributi della mappa annidata se la mappa principale non esiste. Se si tenta di aggiornare un attributo annidato (ad esempio,`ProductReviews.FiveStar`) quando la mappa principale (`ProductReviews`) non esiste, DynamoDB restituisce `ValidationException` un con il *messaggio «Il percorso del documento fornito nell'espressione di aggiornamento non è valido per l'aggiornamento*».
Quando crei elementi che avranno gli attributi della mappa nidificata aggiornati in un secondo momento, inizializza mappe vuote per gli attributi principali. Esempio:
```
{
"Id": {"N": "789"},
"ProductReviews": {"M": {}},
"Metadata": {"M": {}}
}
```
Ciò consente di aggiornare gli attributi annidati senza errori. `ProductReviews.FiveStar`
### Incremento e decremento di attributi numerici
Puoi eseguire aggiunte o sottrazioni da un attributo numerico esistente. A questo scopo, utilizza gli operatori `+` (più) e `-` (meno).
**Example**
Riduci il valore `Price` di un elemento.
```
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
```
Per aumentare il valore `Price`, puoi utilizzare l'operatore `+` nell'espressione di aggiornamento.
### Aggiunta di elementi a un elenco
Puoi aggiungere elementi alla fine di un elenco. A tale scopo, utilizza `SET` con la funzione `list_append`. Il nome funzione rileva la distinzione tra maiuscole e minuscole. La funzione `list_append` è specifica dell'operazione `SET` e può essere utilizzata solo in un'espressione di aggiornamento. La sintassi è esposta di seguito.
+ `list_append (list1, list2)`
La funzione prende due liste come input e aggiunge tutti gli elementi da `list2` a ` list1`.
**Example**
In [Aggiunta di elementi a un elenco](#Expressions.UpdateExpressions.SET.AddingListElements), viene creato l'elenco `RelatedItems` e popolato con due elementi: `Hammer` e `Nails`. Vengono quindi aggiunti due altri elementi alla fine di `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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file `values.json`:
```
{
":vals": {
"L": [
{ "S": "Screwdriver" },
{"S": "Hacksaw" }
]
}
}
```
Infine, viene aggiunto un ulteriore elemento all'*inizio* di `RelatedItems`. A questo scopo, scambia l'ordine degli elementi `list_append`. Ricorda che `list_append` accetta due elenchi come input e aggiunge il secondo elenco al primo.
```
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
```
L'attributo `RelatedItems` risultante contiene ora cinque elementi nell'ordine seguente: `Chisel`, `Hammer`, `Nails`, `Screwdriver`, `Hacksaw`.
### Prevenzione delle sovrascritture di un attributo esistente
**Example**
Imposta l'attributo `Price` di un elemento, ma solo se l'elemento non dispone già di un attributo `Price`. Se l'attributo `Price` esiste già, non accade nulla.
```
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: eliminazione degli attributi da un elemento
Utilizza l'operazione `REMOVE` in una espressione di aggiornamento per rimuovere uno o più attributi di un elemento in Amazon DynamoDB. Per eseguire più operazioni `REMOVE`, separarle con virgole.
Di seguito è riportato un riepilogo della sintassi di `REMOVE` in un'espressione di aggiornamento. L'unico operando è il percorso di documento dell'attributo che intendi rimuovere.
```
remove-action ::=
path
```
**Example**
Rimuovi alcuni attributi di un elemento. Se gli attributi non esistono, non accade nulla.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "REMOVE Brand, InStock, QuantityOnHand" \
--return-values ALL_NEW
```
### Rimozione di elementi da un elenco
Puoi utilizzare `REMOVE` per eliminare singoli elementi da un elenco.
**Example**
In [Aggiunta di elementi a un elenco](#Expressions.UpdateExpressions.SET.UpdatingListElements), modifica un attributo di elenco (`RelatedItems`) in modo che contenga cinque elementi:
+ `[0]`—`Chisel`
+ `[1]`—`Hammer`
+ `[2]`—`Nails`
+ `[3]`—`Screwdriver`
+ `[4]`—`Hacksaw`
L'esempio seguente AWS Command Line Interface (AWS CLI) elimina `Hammer` e `Nails` dall'elenco.
```
aws dynamodb update-item \
--table-name ProductCatalog \
--key '{"Id":{"N":"789"}}' \
--update-expression "REMOVE RelatedItems[1], RelatedItems[2]" \
--return-values ALL_NEW
```
Dopo che `Hammer` e `Nails` sono stati rimossi, gli elementi rimanenti vengono spostati. Ora l'elenco contiene quanto segue:
+ `[0]`—`Chisel`
+ `[1]`—`Screwdriver`
+ `[2]`—`Hacksaw`
## ADD: aggiornamento di numeri e set
**Nota**
In generale, consigliamo di utilizzare `SET` piuttosto che `ADD` garantire operazioni idempotenti.
Utilizza l'operazione `ADD` in un'espressione di aggiornamento per aggiungere un nuovo attributo e i suoi valori a un elemento.
Se l'attributo esiste già, il comportamento di `ADD` dipende dal tipo di dati dell'attributo:
+ Se l'attributo è un numero e anche il valore da aggiungere è un numero, il valore viene aggiunto matematicamente all'attributo esistente. Se il valore è un numero negativo, viene sottratto dall'attributo esistente.
+ Se l'attributo è un set e anche il valore da aggiungere è un set, il valore viene aggiunto matematicamente al set esistente.
**Nota**
L'operazione `ADD` supporta solo i tipi di dati Number e Set.
Per eseguire più operazioni `ADD`, separarle con virgole.
Nel riepilogo della sintassi seguente:
+ L'*path*elemento è il percorso del documento verso un attributo. L'attributo deve essere un tipo di dati `Number` o Set.
+ L'*value*elemento è un numero che si desidera aggiungere all'attributo (per `Number` i tipi di dati) o un set da aggiungere all'attributo (per i tipi di set).
```
add-action ::=
path value
```
Gli argomenti seguenti illustrano diversi casi d'uso dell'operazione `ADD`.
**Topics**
+ [Aggiunta di un numero](#Expressions.UpdateExpressions.ADD.Number)
+ [Aggiunta di elementi a un set](#Expressions.UpdateExpressions.ADD.Set)
### Aggiunta di un numero
Supponiamo che l'attributo `QuantityOnHand` non esista. L' AWS CLI esempio seguente è impostato `QuantityOnHand` su 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
```
Ora che `QuantityOnHand` esiste, puoi eseguire nuovamente l'esempio per incrementare `QuantityOnHand` ogni volta di 5.
### Aggiunta di elementi a un set
Supponiamo che l'attributo `Color` non esista. L'esempio AWS CLI seguente imposta `Color` su un set di stringhe con due elementi.
```
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
```
Ora che `Color` esiste, puoi aggiungergli più elementi:
```
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: rimozione di elementi da un set
**Importante**
L'operazione `DELETE` supporta solo i tipi di dati `Set`.
Utilizza l'operazione `DELETE` in un'espressione di aggiornamento per rimuovere uno o più elementi da un set. Per eseguire più operazioni `DELETE`, separarle con virgole.
Nel riepilogo della sintassi seguente:
+ L'*path*elemento è il percorso del documento verso un attributo. L'attributo deve essere un tipo di dati Set.
+ *subset*È uno o più elementi da cui si desidera eliminare*path*. È necessario specificare *subset* come tipo di set.
```
delete-action ::=
path subset
```
**Example**
In [Aggiunta di elementi a un set](#Expressions.UpdateExpressions.ADD.Set), crea lo String Set `Color`. In questo esempio vengono rimossi alcuni elementi di tale set.
```
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
```
## Utilizzo di più espressioni di aggiornamento
È possibile utilizzare più azioni in una singola espressione di aggiornamento. Tutti i riferimenti agli attributi vengono risolti in base allo stato dell'elemento prima dell'applicazione di qualsiasi azione.
**Example**
Dato un elemento`{"id": "1", "a": 1, "b": 2, "c": 3}`, l'espressione seguente rimuove `a` e sposta i valori di `b` e`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
```
Il risultato è`{"id": "1", "b": 1, "c": 2}`. Anche se `a` viene rimosso e `b` riassegnato nella stessa espressione, entrambi i riferimenti tornano ai valori originali.
**Example**
Se vuoi modificare il valore di un attributo e rimuovere completamente un altro attributo, puoi utilizzare le operazioni SET e REMOVE in una singola istruzione. Questa operazione imposta il valore di `Price` su 15 e rimuove l'attributo `InStock` dall'elemento.
```
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**
Se desideri aggiungere una voce a un elenco modificando anche il valore di un attributo, puoi utilizzare due operazioni SET in una singola istruzione. Questa operazione aggiunge "Nails" all'attributo di elenco `RelatedItems` e imposta il valore di `Price` su 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
```
# Espressioni, operatori e funzioni di condizione e di filtro in DynamoDB
Per manipolare i dati in una tabella DynamoDB, è possibile utilizzare le operazioni `PutItem`, `UpdateItem` e `DeleteItem`. Per le operazioni di manipolazione dei dati, puoi specificare un'espressione di condizione per determinare quale elemento deve essere modificato. Se l’espressione condizionale restituisce true, l’operazione ha esito positivo. In caso contrario, l'operazione non va a buon fine.
In questa sezione sono descritte le funzioni e le parole chiave integrate per scrivere espressioni di condizione ed espressioni di filtro in Amazon DynamoDB. Per informazioni più dettagliate sulle funzioni e sulla programmazione con DynamoDB, consulta [Programmazione con DynamoDB e AWS SDKs](Programming.md) e [DynamoDB API Reference](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/).
**Topics**
+ [Sintassi per le espressioni di filtro e condizioni](#Expressions.OperatorsAndFunctions.Syntax)
+ [Realizzazione di confronti](#Expressions.OperatorsAndFunctions.Comparators)
+ [Funzioni](#Expressions.OperatorsAndFunctions.Functions)
+ [Valutazioni logiche](#Expressions.OperatorsAndFunctions.LogicalEvaluations)
+ [Parentesi](#Expressions.OperatorsAndFunctions.Parentheses)
+ [Priorità nelle condizioni](#Expressions.OperatorsAndFunctions.Precedence)
## Sintassi per le espressioni di filtro e condizioni
Nel seguente riepilogo della sintassi, an *operand* può essere il seguente:
+ Un nome di attributo di primo livello, ad esempio `Id`, `Title`, `Description` o `ProductCategory`
+ Un percorso di documento che fa riferimento a un attributo nidificato
```
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)
```
## Realizzazione di confronti
Utilizza questi comparatori per confrontare un operando con un singolo valore:
+ `a = b`— Vero se *a* è uguale a. *b*
+ `a <> b`— Vero se non *a* è uguale a*b*.
+ `a < b`— Vero se *a* è minore di*b*.
+ `a <= b`— Vero se *a* è minore o uguale a*b*.
+ `a > b`— Vero se *a* è maggiore di*b*.
+ `a >= b`— Vero se *a* è maggiore o uguale a*b*.
Utilizza le parole chiave `BETWEEN` e `IN` per confrontare un operando con un intervallo di valori o con un elenco enumerato di valori:
+ `a BETWEEN b AND c`— Vero se *a* è maggiore o uguale a *b* e minore o uguale a*c*.
+ `a IN (b, c, d) `— Vero se *a* è uguale a qualsiasi valore nell'elenco, ad esempio qualsiasi di *b**c*, o. *d* L'elenco può contenere fino a 100 valori separati da virgole.
## Funzioni
Utilizza le seguenti funzioni per determinare se un attributo è presente in un elemento o per valutare il valore di un attributo. I nomi di funzione rispettano la distinzione tra lettere maiuscole e minuscole. Per un attributo nidificato, è necessario fornire l'intero percorso del documento.
****
| Funzione | Description |
| --- | --- |
| `attribute_exists (path)` | True se l'elemento contiene l'attributo specificato da `path`. Esempio: Verifica se un elemento nella tabella `Product` ha un'immagine di vista laterale. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) |
| `attribute_not_exists (path)` | True se l'attributo specificato da `path` non è presente nell'elemento. Esempio: Verifica se un elemento ha un attributo `Manufacturer`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) |
| `attribute_type (path, type)` | True se l'attributo del percorso specificato è di un particolare tipo di dato. Il parametro `type` deve essere uno dei seguenti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) È necessario utilizzare un valore di attributo di espressione per il parametro `type`. Esempio: Verifica se l'attributo `QuantityOnHand` è del tipo List. In questo esempio, `:v_sub` è un segnaposto per la stringa `L`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) È necessario utilizzare un valore di attributo di espressione per il parametro `type`. |
| `begins_with (path, substr)` | True se l'attributo specificato da `path` inizia con una particolare sottostringa. Esempio: Verifica se i primi caratteri dell'URL dell'immagine di vista frontale sono `http://`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Il valore di attributo di espressione `:v_sub` è un segnaposto per `http://`. |
| `contains (path, operand)` | True se l'attributo specificato da `path` è uno dei seguenti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Se l'attributo specificato da `path` è `String`, `operand` deve essere `String`. Se l'attributo specificato da `path` è un `Set`, l'`operand` deve essere il tipo di elemento del set. Il percorso e l'operando devono essere distinti. Vale a dire, `contains (a, a)` restituisce un errore. Esempio: Verifica se l'attributo `Brand` contiene la sottostringa `Company`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Il valore di attributo di espressione `:v_sub` è un segnaposto per `Company`. Esempio: Verifica se il prodotto è disponibile in rosso. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Il valore di attributo di espressione `:v_sub` è un segnaposto per `Red`. |
| `size (path)` | Restituisce un numero che rappresenta le dimensioni di un attributo. I seguenti sono tipi di dati validi per l'utilizzo con `size`. Se l'attributo è di tipo `String`, `size`restituisce la lunghezza della stringa. Esempio: Verifica se la stringa `Brand` è inferiore o uguale a 20 caratteri. Il valore di attributo di espressione `:v_sub` è un segnaposto per `20`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Se l'attributo è di tipo `Binary`, `size` restituisce il numero di byte nel valore attributo. Esempio: supponi che l'elemento `ProductCatalog` abbia un attributo di tipo binario denominato `VideoClip`, che contiene un breve video del prodotto in uso. L'espressione seguente verifica se `VideoClip` supera i 64.000 byte. Il valore di attributo di espressione `:v_sub` è un segnaposto per `64000`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Se il tipo di dati dell'attributo è `Set`, `size` restituisce il numero di elementi nell'insieme. Esempio: Verifica se il prodotto è disponibile in più di un colore. Il valore di attributo di espressione `:v_sub` è un segnaposto per `1`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) Se il tipo dell'attributo è `List` o `Map`, `size` restituisce il numero di elementi figlio. Esempio: Verifica se il numero di revisioni `OneStar` ha superato una certa soglia. Il valore di attributo di espressione `:v_sub` è un segnaposto per `3`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html) |
## Valutazioni logiche
Utilizza le parole chiave `AND`, `OR` e `NOT` per eseguire valutazioni logiche. Nell'elenco seguente, *a* e *b* rappresentano le condizioni da valutare.
+ `a AND b`— Vero se *a* e *b* sono entrambi veri.
+ `a OR b`— Vero se una delle due *a* o *b* (o entrambe) sono vere.
+ `NOT a`— Vero se *a* è falso. Falso se *a* è vero.
Di seguito è riportato un esempio di codice di AND in un'operazione.
`dynamodb-local (*)> select * from exprtest where a > 3 and a < 5;`
## Parentesi
Utilizza le parentesi per modificare la priorità di una valutazione logica. Ad esempio, supponiamo che le condizioni *a* e *b* siano vere e che tale condizione *c* sia falsa. La seguente espressione restituisce true:
+ `a OR b AND c`
Tuttavia, se racchiudi una condizione tra parentesi, verrà valutata per prima. Ad esempio, la seguente espressione restituisce false:
+ `(a OR b) AND c`
**Nota**
Puoi annidare le parentesi in un'espressione: quelle più interne saranno valutate per prime.
Di seguito è riportato un esempio di codice con parentesi in una valutazione logica.
`dynamodb-local (*)> select * from exprtest where attribute_type(b, string) or ( a = 5 and c = “coffee”);`
## Priorità nelle condizioni
DynamoDB valuta le condizioni da sinistra a destra utilizzando le seguenti regole di precedenza:
+ `= <> < <= > >=`
+ `IN`
+ `BETWEEN`
+ `attribute_exists attribute_not_exists begins_with contains`
+ Parentesi
+ `NOT`
+ `AND`
+ `OR`
# Esempio di CLI di espressione condizionale in DynamoDB
Di seguito sono riportati alcuni AWS Command Line Interface (AWS CLI) esempi di utilizzo delle espressioni condizionali. Questo esempi sono basati sulla tabella `ProductCatalog`, che è stata introdotta in [Riferimento agli attributi degli elementi quando si utilizzano le espressioni in DynamoDB](Expressions.Attributes.md). La chiave di partizione di questa tabella è `Id`; non è presente una chiave di ordinamento. L'operazione `PutItem` seguente crea un elemento `ProductCatalog` di esempio a cui gli esempi fanno riferimento.
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item file://item.json
```
Gli argomenti per `--item` sono memorizzati nel file `item.json`: (Per semplicità, vengono utilizzati solo pochi attributi dell'item).
```
{
"Id": {"N": "456" },
"ProductCategory": {"S": "Sporting Goods" },
"Price": {"N": "650" }
}
```
**Topics**
+ [Put condizionale](#Expressions.ConditionExpressions.PreventingOverwrites)
+ [Eliminazioni condizionali](#Expressions.ConditionExpressions.AdvancedComparisons)
+ [Aggiornamenti condizionali](#Expressions.ConditionExpressions.SimpleComparisons)
+ [Esempi di espressioni condizionali](#Expressions.ConditionExpressions.ConditionalExamples)
## Put condizionale
L'operazione `PutItem` sovrascrive un elemento con la stessa chiave primaria (se esiste). Se vuoi evitare che ciò accada, utilizza un'espressione di condizione. Ciò consente alla scrittura di procedere solo se l'elemento in questione non possiede già la stessa chiave primaria.
L'esempio seguente utilizza `attribute_not_exists()` per verificare se la chiave primaria esiste nella tabella prima di tentare l'operazione di scrittura.
**Nota**
Se la chiave primaria è composta sia da una chiave di partizione (PK) che da una chiave di ordinamento (SK), il parametro controllerà se `attribute_not_exists(pk)` E `attribute_not_exists(sk)` vengono considerati true o false come intera istruzione prima di tentare l’operazione di scrittura.
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item file://item.json \
--condition-expression "attribute_not_exists(Id)"
```
Se l'espressione di condizione viene valutata false, D restituisce il seguente messaggio di errore: The conditional request failed (La richiesta condizionale ha avuto esito negativo).
**Nota**
Per ulteriori informazioni su `attribute_not_exists` e altre funzioni, consulta [Espressioni, operatori e funzioni di condizione e di filtro in DynamoDB](Expressions.OperatorsAndFunctions.md).
## Eliminazioni condizionali
Per eseguire un'eliminazione condizionale, utilizza un'operazione `DeleteItem` con un'espressione di condizione. L'espressione di condizione deve restituire true affinché l'operazione abbia esito positivo; in caso contrario, ha esito negativo.
Si consideri l’elemento sopra definito.
Supponiamo che tu voglia eliminare l'elemento, ma solo alle seguenti condizioni:
+ il valore `ProductCategory` è "Sporting Goods" o "Gardening Supplies";
+ il valore `Price` è compreso tra 500 e 600.
Nell'esempio seguente si tenta di eliminare l'elemento:
```
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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file `values.json`:
```
{
":cat1": {"S": "Sporting Goods"},
":cat2": {"S": "Gardening Supplies"},
":lo": {"N": "500"},
":hi": {"N": "600"}
}
```
**Nota**
Nell'espressione di condizione, `:` (due punti) indica un *valore di attributo dell'espressione*, ovvero un segnaposto per un valore effettivo. Per ulteriori informazioni, consulta [Utilizzo dei valori degli attributi di espressione in DynamoDB](Expressions.ExpressionAttributeValues.md).
Per ulteriori informazioni su `IN`, `AND` e altre parole chiave, consulta [Espressioni, operatori e funzioni di condizione e di filtro in DynamoDB](Expressions.OperatorsAndFunctions.md).
In questo esempio, il confronto `ProductCategory` viene valutato come true, ma il confronto `Price` viene valutato come false. Ciò fa sì che l'espressione di condizione venga valutata come false e che l'operazione `DeleteItem` abbia esito negativo.
## Aggiornamenti condizionali
Per eseguire un aggiornamento condizionale, utilizza un'operazione `UpdateItem` con un'espressione di condizione. L'espressione di condizione deve restituire true affinché l'operazione abbia esito positivo; in caso contrario, ha esito negativo.
**Nota**
`UpdateItem` supporta anche *espressioni di aggiornamento*, in cui si specificano le modifiche che intendi apportare a una voce. Per ulteriori informazioni, consulta [Utilizzo di espressioni di aggiornamento in DynamoDB](Expressions.UpdateExpressions.md).
Si supponga di iniziare con l’elemento mostrato sopra.
Nel seguente esempio viene eseguita un'operazione `UpdateItem`. Prova a ridurre il `Price` di un prodotto di 75, ma l'espressione della condizione impedisce l'aggiornamento se `Price` è minore o uguale a 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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file `values.json`:
```
{
":discount": { "N": "75"},
":limit": {"N": "500"}
}
```
Se l'attributo `Price` iniziale è 650, l'operazione `UpdateItem` riduce `Price` a 575. Se esegui nuovamente l'operazione `UpdateItem`, il valore `Price` viene ridotto a 500. Se esegui l'operazione una terza volta, l'espressione di condizione restituisce false e l'aggiornamento ha esito negativo.
**Nota**
Nell'espressione di condizione, `:` (due punti) indica un *valore di attributo dell'espressione*, ovvero un segnaposto per un valore effettivo. Per ulteriori informazioni, consulta [Utilizzo dei valori degli attributi di espressione in DynamoDB](Expressions.ExpressionAttributeValues.md).
Per ulteriori informazioni su "*>*" e altri operatori, consulta [Espressioni, operatori e funzioni di condizione e di filtro in DynamoDB](Expressions.OperatorsAndFunctions.md).
## Esempi di espressioni condizionali
Per ulteriori informazioni sulle funzioni utilizzate negli esempi seguenti, consulta [Espressioni, operatori e funzioni di condizione e di filtro in DynamoDB](Expressions.OperatorsAndFunctions.md). Per ulteriori informazioni su come specificare diversi tipi di attributo in un'espressione, consulta [Riferimento agli attributi degli elementi quando si utilizzano le espressioni in DynamoDB](Expressions.Attributes.md).
### Verifica degli attributi in un elemento
Puoi verificare la presenza o l'assenza di qualsiasi attributo. Se l'espressione condizionale viene valutata a true, l'operazione ha esito positivo, altrimenti ha esito negativo.
Nel seguente esempio si utilizza `attribute_not_exists` per eliminare un prodotto solo se non possiede un attributo `Price`.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_not_exists(Price)"
```
DynamoDB fornisce anche una funzione `attribute_exists`. Nel seguente esempio un prodotto viene eliminato solo se ha ricevuto recensioni negative.
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "456"}}' \
--condition-expression "attribute_exists(ProductReviews.OneStar)"
```
### Verifica del tipo di attributo
Puoi controllare il tipo di dati di un valore di attributo utilizzando la funzione `attribute_type`. Se l'espressione condizionale viene valutata a true, l'operazione ha esito positivo, altrimenti ha esito negativo.
Nell'esempio seguente viene utilizzato `attribute_type` per eliminare un prodotto solo se ha un attributo `Color` di tipo String Set.
```
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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel expression-attribute-values file.json.
```
{
":v_sub":{"S":"SS"}
}
```
### Verifica del valore iniziale della stringa
Puoi verificare se un valore di attributo String inizia con una particolare sottostringa utilizzando la funzione `begins_with`. Se l'espressione condizionale viene valutata a true, l'operazione ha esito positivo, altrimenti ha esito negativo.
Nell'esempio seguente viene utilizzato `begins_with` per eliminare un prodotto solo se l'elemento `FrontView` della mappa `Pictures` inizia con un valore specifico.
```
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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file expression-attribute-values .json.
```
{
":v_sub":{"S":"http://"}
}
```
### Controllo di un elemento in un set
Puoi verificare la presenza di un elemento in un set o cercare una sottostringa all'interno di una stringa utilizzando la funzione `contains`. Se l'espressione condizionale viene valutata a true, l'operazione ha esito positivo, altrimenti ha esito negativo.
Nell'esempio seguente viene utilizzato `contains` per eliminare un prodotto solo se il String Set `Color` ha un elemento con un valore specifico.
```
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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file expression-attribute-values .json.
```
{
":v_sub":{"S":"Red"}
}
```
### Controllo della dimensione di un valore di attributo
Puoi verificare la dimensione di un valore di attributo utilizzando la funzione `size`. Se l'espressione condizionale viene valutata a true, l'operazione ha esito positivo, altrimenti ha esito negativo.
Nell'esempio seguente viene utilizzato `size` per eliminare un prodotto solo se la dimensione dell'attributo `VideoClip` Binary è maggiore di `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
```
Gli argomenti per `--expression-attribute-values` sono memorizzati nel file expression-attribute-values .json.
```
{
":v_sub":{"N":"64000"}
}
```