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à.
# 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"}
}
```