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à. # Parametri condizionali legacy di DynamoDB In questo documento si fornisce una panoramica dei parametri condizionali legacy in DynamoDB e si consiglia di utilizzare invece i nuovi parametri di espressione. Vengono forniti dettagli su parametri quali AttributesToGet,, AttributeUpdates ConditionalOperator, Expected KeyConditions, QueryFilter, e ScanFilter, e fornisce esempi su come utilizzare i nuovi parametri di espressione come sostituti. **Importante** Consigliamo di utilizzare i nuovi parametri di espressione piuttosto che i parametri precedenti, se possibile. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). Inoltre, DynamoDB non consente l'uso misto di parametri condizionali legacy e parametri di espressione in una singola chiamata. Ad esempio, il richiamo dell'operazione `Query` con `AttributesToGet` e `ConditionExpression` restituirà un errore. Nella tabella seguente vengono illustrate le operazioni API DynamoDB che supportano ancora questi parametri legacy e i parametri di espressione da utilizzare al loro posto. Questa tabella può essere utile se si sta valutando l'aggiornamento delle applicazioni in modo che utilizzino invece i parametri di espressione. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html) Nelle seguenti sezioni vengono fornite ulteriori informazioni sui parametri condizionali legacy. **Topics** + [AttributesToGet (eredità)](LegacyConditionalParameters.AttributesToGet.md) + [AttributeUpdates (eredità)](LegacyConditionalParameters.AttributeUpdates.md) + [ConditionalOperator (eredità)](LegacyConditionalParameters.ConditionalOperator.md) + [Expected (legacy)](LegacyConditionalParameters.Expected.md) + [KeyConditions (eredità)](LegacyConditionalParameters.KeyConditions.md) + [QueryFilter (eredità)](LegacyConditionalParameters.QueryFilter.md) + [ScanFilter (eredità)](LegacyConditionalParameters.ScanFilter.md) + [Scrittura di condizioni con parametri legacy](LegacyConditionalParameters.Conditions.md) # AttributesToGet (eredità) **Nota** Consigliamo di utilizzare i nuovi parametri di espressione piuttosto che i parametri precedenti, se possibile. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). Per informazioni specifiche sul nuovo parametro che sostituisce questo, consulta [Usa invece *ProjectionExpression*](#ProjectionExpression.instead). Il parametro condizionale legacy `AttributesToGet` è un array di uno o più attributi da recuperare da DynamoDB. Se non viene specificato alcun nome di attributo, verranno restituiti tutti gli attributi. Se alcuni degli attributi richiesti non vengono trovati, non appariranno nel risultato. `AttributesToGet` consente di recuperare gli attributi di tipo List o Map, tuttavia, non può recuperare singoli elementi. Tenere presente che `AttributesToGet` non ha alcun effetto sul consumo di velocità effettiva assegnata. DynamoDB determina le unità di capacità consumate in base alla dimensione dell'elemento, non alla quantità di dati restituiti a un'applicazione. ## Usa *ProjectionExpression*invece: Esempio Si supponga di voler recuperare un elemento dalla tabella *Music*, ma che siano restituiti solo alcuni degli attributi. Puoi usare una `GetItem` richiesta con un `AttributesToGet` parametro, come in questo AWS CLI esempio: ``` aws dynamodb get-item \ --table-name Music \ --attributes-to-get '["Artist", "Genre"]' \ --key '{ "Artist": {"S":"No One You Know"}, "SongTitle": {"S":"Call Me Today"} }' ``` Puoi invece utilizzare `ProjectionExpression`: ``` aws dynamodb get-item \ --table-name Music \ --projection-expression "Artist, Genre" \ --key '{ "Artist": {"S":"No One You Know"}, "SongTitle": {"S":"Call Me Today"} }' ``` # AttributeUpdates (eredità) **Nota** Consigliamo di utilizzare i nuovi parametri di espressione piuttosto che i parametri precedenti, se possibile. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). Per informazioni specifiche sul nuovo parametro che sostituisce questo, consulta [usa *UpdateExpression*invece.](#UpdateExpression.instead). In un'operazione `UpdateItem`, parametro condizionale legacy `AttributeUpdates` contiene i nomi degli attributi da modificare, l'operazione da eseguire su ognuno di essi e il nuovo valore per ciascuno. Se si sta aggiornando un attributo che è un attributo chiave di indice per qualsiasi indice in tale tabella, il tipo di attributo deve corrispondere al tipo di chiave di indice definito in `AttributesDefinition` della descrizione della tabella. È possibile utilizzare `UpdateItem` per aggiornare eventuali attributi non chiave. I valori degli attributi non possono essere nulli. Gli attributi di tipo String e Binary devono avere lunghezze maggiori di zero. Gli attributi di tipo Set non devono essere vuoti. Le richieste con valori vuoti verranno rifiutate con una eccezione `ValidationException`. Ogni elemento `AttributeUpdates` è costituito da un nome di attributo da modificare, insieme a quanto segue: + `Value`: il nuovo valore, se applicabile, per questo attributo. + `Action`: un valore che specifica come eseguire l'aggiornamento. Questa operazione è valida solo per un attributo esistente il cui tipo di dati è Number o Set; non utilizzare `ADD` per altri tipi di dati. Se nella tabella viene trovato un elemento con la chiave primaria specificata, i valori seguenti eseguono le operazioni riportate: + `PUT`: aggiunge l'attributo specificato all'elemento. Se l'attributo esiste già, viene sostituito dal nuovo valore. + `DELETE`: rimuove l'attributo e il relativo valore se non viene specificato alcun valore per `DELETE`. Il tipo di dati per il valore specificato deve corrispondere al tipo di dati del valore esistente. Se viene specificato un set di valori, tali valori saranno sottratti dal vecchio set. Ad esempio, se il valore dell'attributo era il set `[a,b,c]` e l'operazione `DELETE` specifica `[a,c]`, il valore dell'attributo finale sarà `[b]`. La specifica di un set vuoto restituisce un errore. + `ADD`: aggiunge il valore specificato all'elemento, se l'attributo non esiste già. Se l'attributo esiste, il comportamento di `ADD` dipende dal tipo di dati dell'attributo: + Se l'attributo è un numero e anche `Value` è un numero, allora `Value` viene aggiunto matematicamente all'attributo esistente. Se `Value` è un numero negativo, viene sottratto dall'attributo esistente. **Nota** Se si utilizza `ADD` per aumentare o diminuire un valore numerico per un elemento che non esiste prima dell'aggiornamento, DynamoDB utilizzerà 0 come valore iniziale. Allo stesso modo, se si utilizza `ADD` per un elemento esistente per aumentare o diminuire un valore di attributo che non esiste prima dell'aggiornamento, DynamoDB utilizzerà `0` come valore iniziale. Si supponga, ad esempio, che l'elemento che desideri aggiornare non abbia un attributo denominato *itemcount*, ma decidi comunque di `ADD` il numero `3` a questo attributo. DynamoDB creerà l'attributo *itemcount*, imposterà il suo valore iniziale su `0` e infine aggiungerà `3` ad esso. Il risultato sarà un nuovo attributo *itemcount*, con un valore `3`. + Se il tipo di dati esistente è un set e se anche `Value` è un set, allora `Value` viene aggiunto al set esistente. Ad esempio, se il valore dell'attributo è il set `[1,2]` e l'operazione `ADD` specifica `[3]`, il valore dell'attributo finale sarà `[1,2,3]`. Se viene specificata un'operazione `ADD` per un attributo Set e il tipo di attributo specificato non corrisponde al tipo di set esistente, si verifica un errore. Entrambi i set devono avere lo stesso tipo di dati primitivi. Ad esempio, se il tipo di dati esistente è un set di stringhe, anche `Value` deve essere un set di stringhe. Se nella tabella non viene trovato alcun elemento con la chiave specificata, i valori seguenti completano le operazioni riportate: + `PUT`: consente a DynamoDB di creare un nuovo elemento con la chiave primaria specificata e quindi aggiunge l'attributo. + `DELETE`: non succede nulla, perché gli attributi non possono essere eliminati da un elemento inesistente. L'operazione ha esito positivo, ma DynamoDB non crea un nuovo elemento. + `ADD`: fa in modo che DynamoDB crei un elemento con la chiave primaria fornita e il numero (o set di numeri) per il valore dell'attributo. Gli unici tipi di dati consentiti sono Number e Number Set. Se si forniscono attributi che fanno parte di una chiave di indice, i tipi di dati per tali attributi devono corrispondere a quelli dello schema nella definizione dell'attributo della tabella. ## Usa *UpdateExpression*invece: Esempio Si supponga di voler modificare un elemento nella tabella *Music*. Puoi usare una `UpdateItem` richiesta con un `AttributeUpdates` parametro, come in questo AWS CLI esempio: ``` 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"} } }' ``` Puoi invece utilizzare `UpdateExpression`: ``` 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 (eredità) **Nota** Consigliamo di utilizzare i nuovi parametri di espressione piuttosto che i parametri precedenti, se possibile. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). Il parametro condizionale legacy `ConditionalOperator` è un operatore logico utilizzato per applicare le condizioni in una mappa `Expected`, `QueryFilter` o `ScanFilter`: + AND: se tutte le condizioni restituiscono true, l'intera mappa restituisce true. + OR: se almeno una delle condizioni restituisce true, l'intera mappa restituisce true. Se si omette `ConditionalOperator`, allora `AND` è il valore predefinito. L'operazione avrà esito positivo solo se l'intera mappa restituisce true. **Nota** Questo parametro non supporta gli attributi di tipo List o Map. # Expected (legacy) **Nota** Consigliamo di utilizzare i nuovi parametri di espressione piuttosto che i parametri precedenti, se possibile. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). Per informazioni specifiche sul nuovo parametro che sostituisce questo, consulta [usa *ConditionExpression*invece.](#Expected.instead). Il parametro condizionale legacy `Expected` è un blocco condizionale per un'operazione. `UpdateItem` `Expected`è una mappa di coppie. attribute/condition Ogni elemento della mappa è costituito da un nome di attributo, un operatore di confronto e uno o più valori. DynamoDB confronta l'attributo con i valori forniti tramite l'operatore di confronto. Per ogni elemento `Expected`, il risultato della valutazione è true o false. Se si specifica più di un elemento nella mappa `Expected`, allora, per impostazione predefinita, tutte le condizioni devono restituire true. In altre parole, le condizioni vengono combinate utilizzando l’operatore `AND`. È possibile utilizzare il parametro `ConditionalOperator` per applicare l'operatore OR alle condizioni. In questo caso, almeno una delle condizioni deve restituire true, se non tutte. Se la mappa `Expected` restituisce true, l'operazione condizionale ha esito positivo, altrimenti ha esito negativo. `Expected` contiene i seguenti dati: + `AttributeValueList`: uno o più valori da valutare rispetto all'attributo fornito. Il numero di valori nell'elenco dipende dal `ComparisonOperator` utilizzato. Per il tipo Number, i confronti dei valori sono numerici. I confronti di valori String per maggiore di, uguale o minore di sono basati su Unicode con codifica binaria UTF-8. Ad esempio, `a` è maggiore di `A` e `a` è maggiore di `B`. Per il tipo Binary, quando confronta i valori binari DynamoDB tratta ogni byte dei dati binari come non firmato. + `ComparisonOperator`: un comparatore per valutare gli attributi in `AttributeValueList`. Quando si esegue il confronto, DynamoDB utilizza letture fortemente consistenti. Sono disponibili i seguenti operatori di confronto: `EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN` Di seguito sono riportate le descrizioni di ogni operatore di confronto. + `EQ`: uguale a. `EQ` è supportato per tutti i tipi di dati, inclusi elenchi e mappe. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number, Binary, String Set, Number Set o Binary Set. Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non è uguale a `{"NS":["6", "2", "1"]}`. + `NE`: diverso da. `NE` è supportato per tutti i tipi di dati, inclusi elenchi e mappe. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number, Binary, String Set, Number Set o Binary Set. Se un elemento contiene un `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non è uguale a `{"NS":["6", "2", "1"]}`. + `LE`: minore o uguale a. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}`. + `LT`: minore di. `AttributeValueList` può contenere solo un `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}`. + `GE`: maggiore o uguale a. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}`. + `GT`: maggiore di. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}`. + `NOT_NULL`: l'attributo esiste. `NOT_NULL` è supportato per tutti i tipi di dati, inclusi elenchi e mappe. **Nota** Questo operatore verifica l'esistenza di un attributo, non il suo tipo di dati. Se il tipo di dati dell'attributo "`a`" è nullo e lo si valuta usando `NOT_NULL`, il risultato è un `true` booleano. Questo risultato è perché l'attributo "`a`" esiste; il suo tipo di dati non è rilevante per l'operatore di confronto `NOT_NULL`. + `NULL`: l'attributo non esiste. `NULL` è supportato per tutti i tipi di dati, inclusi elenchi e mappe. **Nota** Questo operatore verifica la non esistenza di un attributo, non il relativo tipo di dati. Se il tipo di dati dell'attributo "`a`" è nullo e lo si valuta usando `NULL`, il risultato è un `false` booleano. Questo è perché l'attributo "`a`" esiste; il suo tipo di dati non è rilevante per l'operatore di confronto `NULL`. + `CONTAINS`: controlla la presenza di una sottosequenza o di un valore in un set. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se l'attributo di destinazione del confronto è di tipo String, l'operatore verifica la presenza di una corrispondenza di sottostringa. Se l'attributo di destinazione del confronto è di tipo Binary, l'operatore cerca una sottosequenza della destinazione che corrisponde all'input. Se l'attributo di destinazione del confronto è un set "`SS`", "`NS`" o "`BS`"), l'operatore restituisce true se trova una corrispondenza esatta con qualsiasi membro del set. CONTAINES è supportato per gli elenchi: quando si valuta "`a CONTAINS b`", "`a`" può essere un List; tuttavia "`b`" non può essere set, Map o List. + `NOT_CONTAINS`: controlla l'assenza di una sottosequenza o l'assenza di un valore in un set. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se l'attributo di destinazione del confronto è String, l'operatore verifica l'assenza di una corrispondenza di sottostringa. Se l'attributo di destinazione del confronto è Binary, l'operatore verifica l'assenza di una sottosequenza della destinazione che corrisponde all'input. Se l'attributo di destinazione del confronto è un set ("`SS`", "`NS`" o "`BS`"), l'operatore restituisce true se `does not` trova una corrispondenza esatta con qualsiasi membro del set. NOT\$1CONTAINS è supportato per gli elenchi: quando si valuta "`a NOT CONTAINS b`", "`a`" può essere un List; tuttavia "`b`" non può essere set, Map o List. + `BEGINS_WITH`: controlla la presenza di un prefisso. `AttributeValueList` può contenere solo un `AttributeValue` di tipo String o Binary (non un tipo Number o Set). L'attributo di destinazione del confronto deve essere String o Binary (non un tipo Number o Set). + `IN`: verifica la presenza di elementi corrispondenti all'interno di due set. `AttributeValueList` può contenere uno o più elementi `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Questi attributi vengono confrontati con un attributo di tipo Set esistente di un elemento. Se nell'attributo dell'elemento sono presenti elementi del set di input, l'espressione restituisce true. + `BETWEEN`: maggiore di o uguale a primo valore e minore di o uguale a secondo valore. `AttributeValueList` deve contenere due elementi`AttributeValue` dello stesso tipo, String, Number o Binary (non un tipo Set). Un attributo di destinazione corrisponde se il valore di destinazione è maggiore o uguale al primo elemento e minore o uguale al secondo elemento. Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non si confronta con `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}` I seguenti parametri possono essere usati al posto di `AttributeValueList` e `ComparisonOperator`: + `Value`: un valore per DynamoDB da confrontare con un attributo. + `Exists`: un valore booleano che fa sì che DynamoDB valuti il valore prima di provare l'operazione condizionale: + Se `Exists` è `true`, DynamoDB controllerà se tale valore dell'attributo esiste già nella tabella. Se viene trovato, allora la condizione restituisce true, altrimenti restituisce false. + Se `Exists` è `false`, DynamoDB presuppone che il valore dell'attributo `not` esiste nella tabella. Se davvero il valore non esiste, allora l'ipotesi è valida e la condizione restituisce true. Se il valore viene trovato nonostante il presupposto che non esiste, la condizione restituisce false. Si noti che il valore predefinito per `Exists` è `true`. I parametri `Value` e `Exists` sono incompatibili con `AttributeValueList` e `ComparisonOperator`. Si noti che se si utilizzano entrambi i set di parametri contemporaneamente, DynamoDB restituirà una eccezione `ValidationException`. **Nota** Questo parametro non supporta gli attributi di tipo List o Map. ## Usa *ConditionExpression*invece — Esempio Si supponga di voler modificare un elemento nella tabella *Music*, ma solo se una certa condizione è vera. Puoi usare una `UpdateItem` richiesta con un `Expected` parametro, come in questo AWS CLI esempio: ``` 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"} ] } }' ``` Puoi invece utilizzare `ConditionExpression`: ``` 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 (eredità) **Nota** Consigliamo di utilizzare i nuovi parametri di espressione piuttosto che i parametri precedenti, se possibile. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). Per informazioni specifiche sul nuovo parametro che sostituisce questo, consulta [usa *KeyConditionExpression*invece.](#KeyConditionExpression.instead). Il parametro condizionale legacy `KeyConditions` contiene i criteri di selezione per un'operazione `Query`. Per una query su una tabella, è possibile disporre di condizioni solo sugli attributi della chiave primaria della tabella. È necessario specificare il nome e il valore della chiave di partizione come condizione `EQ`. Facoltativamente, è possibile fornire una seconda condizione che fa riferimento alla chiave di ordinamento. **Nota** Se non si specifica una condizione della chiave di ordinamento, verranno recuperati tutti gli elementi che corrispondono alla chiave di partizione. Se è presente `FilterExpression` o `QueryFilter`, verrà applicato dopo che gli elementi sono stati recuperati. Per una query su un indice, è possibile disporre di condizioni solo sugli attributi della chiave di indice. È necessario specificare il nome e il valore della chiave di partizione dell'indice come condizione `EQ`. Facoltativamente, è possibile fornire una seconda condizione che fa riferimento alla chiave di ordinamento dell'indice. Ogni elemento `KeyConditions` è costituito da un nome di attributo da confrontare, insieme a quanto segue: + `AttributeValueList`: uno o più valori da valutare rispetto all'attributo fornito. Il numero di valori nell'elenco dipende dal `ComparisonOperator` utilizzato. Per il tipo Number, i confronti dei valori sono numerici. I confronti di valori String per maggiore di, uguale o minore di sono basati su Unicode con codifica binaria UTF-8. Ad esempio, `a` è maggiore di `A` e `a` è maggiore di `B`. Per il tipo Binary, quando confronta i valori binari DynamoDB tratta ogni byte dei dati binari come non firmato. + `ComparisonOperator`: un comparatore per valutare gli attributi. Ad esempio, uguale a, maggiore di e minore di. Per `KeyConditions`, sono supportati solo i seguenti operatori di confronto: `EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN` Di seguito sono riportate le descrizioni di questi operatori di confronto. + `EQ`: uguale. `AttributeValueList` può contenere solo un `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non è uguale a `{"NS":["6", "2", "1"]}`. + `LE`: minore o uguale a. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}`. + `LT`: minore di. `AttributeValueList` può contenere solo un `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}`. + `GE`: maggiore o uguale a. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}`. + `GT`: maggiore di. `AttributeValueList` può contenere solo un elemento `AttributeValue` di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non è uguale a `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}`. + `BEGINS_WITH`: controlla la presenza di un prefisso. `AttributeValueList` può contenere solo un `AttributeValue` di tipo String o Binary (non un tipo Number o Set). L'attributo di destinazione del confronto deve essere String o Binary (non un tipo Number o Set). + `BETWEEN`: maggiore di o uguale a primo valore e minore di o uguale a secondo valore. `AttributeValueList` deve contenere due elementi`AttributeValue` dello stesso tipo, String, Number o Binary (non un tipo Set). Un attributo di destinazione corrisponde se il valore di destinazione è maggiore o uguale al primo elemento e minore o uguale al secondo elemento. Se un elemento contiene un elemento `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, `{"S":"6"}` non si confronta con `{"N":"6"}`. Inoltre, `{"N":"6"}` non si confronta con `{"NS":["6", "2", "1"]}`. ## Usa *KeyConditionExpression*invece: Esempio Si supponga di voler recuperare diversi elementi con la stessa chiave di partizione dalla tabella *Music*. Puoi usare una `Query` richiesta con un `KeyConditions` parametro, come in questo AWS CLI esempio: ``` 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"} ] } }' ``` Puoi invece utilizzare `KeyConditionExpression`: ``` 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 (eredità) **Nota** Consigliamo di utilizzare i nuovi parametri di espressione piuttosto che i parametri precedenti, se possibile. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). Per informazioni specifiche sul nuovo parametro che sostituisce questo, consulta [usa *FilterExpression*invece.](#FilterExpression.instead). In un'operazione `Query`, parametro condizionale legacy `QueryFilter` è una condizione che valuta i risultati delle query dopo la lettura degli elementi e restituisce solo i valori desiderati. Questo parametro non supporta gli attributi di tipo List o Map. **Nota** `QueryFilter` viene applicato dopo che gli elementi sono già stati letti; il processo di filtraggio non consuma alcuna unità di capacità di lettura aggiuntiva. Se si fornisce più di una condizione nella mappa `QueryFilter`, allora, per impostazione predefinita, tutte le condizioni devono restituire true. In altre parole, le condizioni vengono combinate utilizzando l’operatore `AND`. È possibile utilizzare il parametro [ConditionalOperator (eredità)](LegacyConditionalParameters.ConditionalOperator.md) per applicare l'operatore OR alle condizioni. In questo caso, almeno una delle condizioni deve restituire true, se non tutte. Tenere presente che `QueryFilter` non consente gli attributi chiave. Non è possibile definire una condizione di filtro su una chiave di partizione o una chiave di ordinamento. Ogni elemento `QueryFilter` è costituito da un nome di attributo da confrontare, insieme a quanto segue: + `AttributeValueList`: uno o più valori da valutare rispetto all'attributo fornito. Il numero di valori in List dipende dall'operatore specificato in `ComparisonOperator`. Per il tipo Number, i confronti dei valori sono numerici. I confronti di valori String per maggiore di, uguale o minore di sono basati sulla codifica binaria UTF-8. Ad esempio, `a` è maggiore di `A` e `a` è maggiore di `B`. Per il tipo Binary, quando confronta i valori binari DynamoDB tratta ogni byte dei dati binari come non firmato. Per informazioni su come specificare i tipi di dati in JSON, consulta [API DynamoDB di basso livello](Programming.LowLevelAPI.md). + `ComparisonOperator`: un comparatore per valutare gli attributi. Ad esempio, uguale a, maggiore di e minore di. Sono disponibili i seguenti operatori di confronto: `EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN` ## Usa *FilterExpression*invece: Esempio Si supponga di voler eseguire una query sulla tabella *Music* e di applicare una condizione agli elementi corrispondenti. È possibile utilizzare una richiesta `Query` con un parametro `QueryFilter`, come in questo esempio AWS CLI : ``` 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"} ] } }' ``` Puoi invece utilizzare `FilterExpression`: ``` 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 (eredità) **Nota** Consigliamo di utilizzare i nuovi parametri di espressione piuttosto che i parametri precedenti, se possibile. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). Per informazioni specifiche sul nuovo parametro che sostituisce questo, consulta [usa *FilterExpression*invece.](#FilterExpression2.instead). In una operazione `Scan`, il parametro condizionale legacy `ScanFilter` è una condizione che valuta i risultati della scansione e restituisce solo i valori desiderati. **Nota** Questo parametro non supporta gli attributi di tipo List o Map. Se si specifica più di una condizione nella mappa `ScanFilter`, allora, per impostazione predefinita, tutte le condizioni devono restituire true. In altre parole, le condizioni coesistono ANDed . È possibile utilizzare il parametro [ConditionalOperator (eredità)](LegacyConditionalParameters.ConditionalOperator.md) per applicare l'operatore OR alle condizioni. In questo caso, almeno una delle condizioni deve restituire true, se non tutte. Ogni elemento `ScanFilter` è costituito da un nome di attributo da confrontare, insieme a quanto segue: + `AttributeValueList`: uno o più valori da valutare rispetto all'attributo fornito. Il numero di valori in List dipende dall'operatore specificato in `ComparisonOperator`. Per il tipo Number, i confronti dei valori sono numerici. I confronti di valori String per maggiore di, uguale o minore di sono basati sulla codifica binaria UTF-8. Ad esempio, `a` è maggiore di `A` e `a` è maggiore di `B`. Per il tipo Binary, quando confronta i valori binari DynamoDB tratta ogni byte dei dati binari come non firmato. Per informazioni su come specificare i tipi di dati in JSON, consulta [API DynamoDB di basso livello](Programming.LowLevelAPI.md). + `ComparisonOperator`: un comparatore per valutare gli attributi. Ad esempio, uguale a, maggiore di e minore di. Sono disponibili i seguenti operatori di confronto: `EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN` ## Usa *FilterExpression*invece — Esempio Supponiamo di voler eseguire la scansione della tabella *Music* e di applicare una condizione agli elementi corrispondenti. È possibile utilizzare una richiesta `Scan` con un parametro `ScanFilter`, come in questo esempio AWS CLI : ``` aws dynamodb scan \ --table-name Music \ --scan-filter '{ "Genre":{ "AttributeValueList":[ {"S":"Rock"} ], "ComparisonOperator": "EQ" } }' ``` Puoi invece utilizzare `FilterExpression`: ``` aws dynamodb scan \ --table-name Music \ --filter-expression 'Genre = :g' \ --expression-attribute-values '{ ":g": {"S":"Rock"} }' ``` # Scrittura di condizioni con parametri legacy **Nota** Consigliamo di utilizzare i nuovi parametri di espressione piuttosto che i parametri precedenti, se possibile. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). Nella sezione seguente viene descritto come scrivere le condizioni da utilizzare con i parametri legacy, ad esempio `Expected`, `QueryFilter` e `ScanFilter`. **Nota** Le nuove applicazioni dovrebbero invece utilizzare i parametri di espressione. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md). ## Condizioni semplici Con i valori degli attributi, è possibile scrivere condizioni per i confronti rispetto agli attributi della tabella. Una condizione restituisce sempre true o false ed è costituita da: + `ComparisonOperator`: maggiore di, minore di, uguale a e così via. + `AttributeValueList` (facoltativo): i valori degli attributi da confrontare. A seconda di `ComparisonOperator` utilizzato, `AttributeValueList` potrebbe contenere uno, due o più valori; o potrebbe non essere affatto presente. Nelle sezioni seguenti sono descritti i vari operatori di confronto e sono riportati gli esempi di come utilizzarli nelle condizioni. ### Operatori di confronto senza valori di attributo + `NOT_NULL`: true se esiste un attributo. + `NULL`: true se non esiste un attributo. Utilizza questi operatori per verificare se un attributo esiste o non esiste. Poiché non vi è alcun valore da confrontare, non specificare `AttributeValueList`. **Esempio** La seguente espressione restituisce true se l'attributo *Dimensions* esiste. ``` ... "Dimensions": { ComparisonOperator: "NOT_NULL" } ... ``` ### Operatori di confronto con un valore di attributo + `EQ`: true se un attributo è uguale a un valore. `AttributeValueList` può contenere solo un valore di tipo String, Number, Binary, String Set, Number Set o Binary Set. Se un elemento contiene un valore di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Ad esempio, la stringa `"3"` non è uguale al numero `3`. Inoltre, il numero `3` non è uguale al set di numeri `[3, 2, 1]`. + `NE`: true se un attributo non è uguale a un valore. `AttributeValueList` può contenere solo un valore di tipo String, Number, Binary, String Set, Number Set o Binary Set. Se un elemento contiene un valore di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. + `LE`: true se un attributo è minore o uguale a un valore. `AttributeValueList` può contenere solo un valore di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un `AttributeValue` di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. + `LT`: true se un attributo è minore di un valore. `AttributeValueList` può contenere solo un valore di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un valore di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. + `GE`: true se un attributo è maggiore o uguale a un valore. `AttributeValueList` può contenere solo un valore di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un valore di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. + `GT`: true se un attributo è maggiore di un valore. `AttributeValueList` può contenere solo un valore di tipo String, Number o Binary (non un tipo Set). Se un elemento contiene un valore di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. + `CONTAINS`: true se un valore è presente all'interno di un set o se un valore ne contiene un altro. `AttributeValueList` può contenere solo un valore di tipo String, Number o Binary (non un tipo Set). Se l'attributo di destinazione del confronto è di tipo String, l'operatore controlla la presenza di una corrispondenza di sottostringa. Se l'attributo di destinazione del confronto è di tipo Binary, l'operatore cerca una sottosequenza della destinazione che corrisponde all'input. Se l'attributo di destinazione del confronto è di tipo Set, l'operatore restituisce true se trova una corrispondenza esatta con qualsiasi membro del set. + `NOT_CONTAINS`: true se un valore *non* è presente all'interno di un set o se un valore ne contiene un altro. `AttributeValueList` può contenere solo un valore di tipo String, Number o Binary (non un tipo Set). Se l'attributo di destinazione del confronto è String, l'operatore verifica l'assenza di una corrispondenza di sottostringa. Se l'attributo di destinazione del confronto è Binary, l'operatore verifica l'assenza di una sottosequenza della destinazione che corrisponde all'input. Se l'attributo di destinazione del confronto è di tipo Set, l'operatore restituisce true se *non* trova una corrispondenza esatta con qualsiasi membro del set. + `BEGINS_WITH`: true se i primi caratteri di un attributo corrispondono al valore fornito. Non utilizzare questo operatore per confrontare i numeri. `AttributeValueList` può contenere solo un valore di tipo String o Binary (non un tipo Number o Set). L'attributo di destinazione del confronto deve essere String o Binary (non Number o un set). Utilizza questi operatori per confrontare un attributo con un valore. È necessario specificare un `AttributeValueList` costituito da un valore singolo. Per la maggior parte degli operatori, questo valore deve essere uno scalare; tuttavia, gli operatori `EQ` e `NE` supportano anche i set. **Esempi** Le seguenti espressioni restituiscono true se: + Il prezzo di un prodotto è maggiore di 100. ``` ... "Price": { ComparisonOperator: "GT", AttributeValueList: [ {"N":"100"} ] } ... ``` + Una categoria di prodotti inizia con "Bo". ``` ... "ProductCategory": { ComparisonOperator: "BEGINS_WITH", AttributeValueList: [ {"S":"Bo"} ] } ... ``` + Un prodotto è disponibile in rosso, verde o nero: ``` ... "Color": { ComparisonOperator: "EQ", AttributeValueList: [ [ {"S":"Black"}, {"S":"Red"}, {"S":"Green"} ] ] } ... ``` **Nota** Quando si confrontano i tipi di dati Set, l'ordine degli elementi non ha importanza. DynamoDB restituirà solo gli elementi con lo stesso set di valori, indipendentemente dall'ordine in cui vengono specificati nella richiesta. ### Operatori di confronto con due valori di attributo + `BETWEEN`: true se un valore è compreso tra un limite inferiore e un limite superiore, endpoint inclusi. `AttributeValueList` deve contenere due elementi dello stesso tipo, String, Number o Binary (non un tipo Set). Un attributo di destinazione corrisponde se il valore di destinazione è maggiore o uguale al primo elemento e minore o uguale al secondo elemento. Se un elemento contiene un valore di un tipo diverso da quello specificato nella richiesta, il valore non corrisponde. Utilizza questo operatore per determinare se un valore di attributo è compreso in un intervallo. `AttributeValueList` deve contenere due elementi scalari dello stesso tipo: String, Number o Binary. **Esempio** L'espressione seguente restituisce true se il prezzo di un prodotto è compreso tra 100 e 200. ``` ... "Price": { ComparisonOperator: "BETWEEN", AttributeValueList: [ {"N":"100"}, {"N":"200"} ] } ... ``` ### Operatori di confronto con *N* valori di attributo + `IN`: true se un valore è uguale a uno qualsiasi dei valori in un elenco enumerato. Nell'elenco sono supportati solo i valori scalari, non i set. Per corrispondere, l'attributo di destinazione deve essere dello stesso tipo e valore esatto. `AttributeValueList` può contenere uno o più elementi di tipo String, Number o Binary (non un tipo Set). Questi attributi vengono confrontati con un attributo di tipo non Set esistente di un elemento. Se nell'attributo dell'elemento è presente *qualsiasi* elemento del set di input, l'espressione restituisce true. `AttributeValueList` può contenere uno o più valori di tipo String, Number o Binary (non un tipo Set). Per corrispondere, l'attributo di destinazione del confronto deve essere dello stesso tipo e valore esatto. Una valore stringa non corrisponde mai a un set di stringhe. Utilizza questo operatore per determinare se il valore fornito è incluso in un elenco numerato. È possibile specificare un numero qualsiasi di valori scalari in `AttributeValueList`, ma devono essere tutti dello stesso tipo di dati. **Esempio** L'espressione seguente restituisce true se il valore per *Id* è 201, 203 o 205. ``` ... "Id": { ComparisonOperator: "IN", AttributeValueList: [ {"N":"201"}, {"N":"203"}, {"N":"205"} ] } ... ``` ## Utilizzo di più condizioni DynamoDB consente di combinare più condizioni per formare espressioni complesse. Questa operazione viene eseguita fornendo almeno due espressioni, con un [ConditionalOperator (eredità)](LegacyConditionalParameters.ConditionalOperator.md) facoltativo. Per impostazione predefinita, quando si specifica più di una condizione, *tutte* le condizioni devono restituire true affinché l'intera espressione restituisca true. In altre parole, si verifica un'operazione *AND* implicita. **Esempio** L'espressione seguente restituisce true se un prodotto è un libro che ha almeno 600 pagine. Entrambe le condizioni devono restituire true, poiché sono implicitamente collegate con un operatore *AND*. ``` ... "ProductCategory": { ComparisonOperator: "EQ", AttributeValueList: [ {"S":"Book"} ] }, "PageCount": { ComparisonOperator: "GE", AttributeValueList: [ {"N":600"} ] } ... ``` È possibile utilizzare [ConditionalOperator (eredità)](LegacyConditionalParameters.ConditionalOperator.md) per chiarire che avrà luogo un'operazione *AND*. L'esempio seguente si comporta allo stesso modo del precedente. ``` ... "ConditionalOperator" : "AND", "ProductCategory": { "ComparisonOperator": "EQ", "AttributeValueList": [ {"N":"Book"} ] }, "PageCount": { "ComparisonOperator": "GE", "AttributeValueList": [ {"N":600"} ] } ... ``` È possibile impostare `ConditionalOperator` anche su *OR*, il che significa che *almeno una* delle condizioni deve restituire true. **Esempio** La seguente espressione restituisce true se un prodotto è una mountain bike, se si tratta di un marchio particolare o se il suo prezzo è maggiore di 100. ``` ... ConditionalOperator : "OR", "BicycleType": { "ComparisonOperator": "EQ", "AttributeValueList": [ {"S":"Mountain" ] }, "Brand": { "ComparisonOperator": "EQ", "AttributeValueList": [ {"S":"Brand-Company A" ] }, "Price": { "ComparisonOperator": "GT", "AttributeValueList": [ {"N":"100"} ] } ... ``` **Nota** In un'espressione complessa, le condizioni vengono elaborate in ordine, dalla prima all'ultima condizione. Non è possibile utilizzare sia AND che OR in una singola espressione. ## Altri operatori condizionali Nelle versioni precedenti di DynamoDB, il parametro `Expected` si comportava in modo diverso per le scritture condizionali. Ogni elemento nella mappa `Expected` rappresentava un nome di attributo per il controllo di DynamoDB, insieme a quanto segue: + `Value`: un valore da confrontare con l'attributo. + `Exists`: determina se il valore esiste prima di provare l'operazione. Le opzioni `Value` e `Exists` continuano a essere supportate in DynamoDB; tuttavia, consentono solo di verificare una condizione di uguaglianza o se esiste un attributo. Consigliamo di utilizzare invece `ComparisonOperator` e `AttributeValueList`, perché queste opzioni consentono di costruire una gamma molto più ampia di condizioni. **Example** `DeleteItem` può verificare se un libro non è più in pubblicazione ed eliminarlo solo se questa condizione è true. Ecco un esempio AWS CLI che utilizza una condizione legacy: ``` aws dynamodb delete-item \ --table-name ProductCatalog \ --key '{ "Id": {"N":"600"} }' \ --expected '{ "InPublication": { "Exists": true, "Value": {"BOOL":false} } }' ``` L'esempio seguente fa la stessa cosa, ma non usa una condizione legacy: ``` aws dynamodb delete-item \ --table-name ProductCatalog \ --key '{ "Id": {"N":"600"} }' \ --expected '{ "InPublication": { "ComparisonOperator": "EQ", "AttributeValueList": [ {"BOOL":false} ] } }' ``` **Example** Una operazione `PutItem` può proteggere dalla sovrascrittura di un elemento esistente con gli stessi attributi della chiave primaria. Ecco un esempio che utilizza una condizione legacy: ``` aws dynamodb put-item \ --table-name ProductCatalog \ --item '{ "Id": {"N":"500"}, "Title": {"S":"Book 500 Title"} }' \ --expected '{ "Id": { "Exists": false } }' ``` L'esempio seguente fa la stessa cosa, ma non usa una condizione legacy: ``` aws dynamodb put-item \ --table-name ProductCatalog \ --item '{ "Id": {"N":"500"}, "Title": {"S":"Book 500 Title"} }' \ --expected '{ "Id": { "ComparisonOperator": "NULL" } }' ``` **Nota** Per le condizioni nella mappa `Expected`, non utilizzare le opzioni `Value` e `Exists` legacy insieme a `ComparisonOperator` e `AttributeValueList`. Se si utilizzano, la scrittura condizionale non avrà esito positivo.