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à.

# Usa le espressioni
<a name="ddb-mapper-expressions"></a>

****  
**DynamoDB Mapper è una versione di anteprima per sviluppatori. Non è completa di funzionalità ed è soggetta a modifiche.**

Alcune operazioni di DynamoDB [accettano](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.html) espressioni che è possibile utilizzare per specificare vincoli o condizioni. DynamoDB Mapper fornisce un Kotlin DSL idiomatico per creare espressioni. Il DSL offre maggiore struttura e leggibilità al codice e semplifica anche la scrittura di espressioni. 

Questa sezione descrive la sintassi DSL e fornisce diversi esempi. 

## Usa le espressioni nelle operazioni
<a name="ddb-mapper-expressions-basic-usage"></a>

Le espressioni vengono utilizzate in operazioni come`scan`, ad esempio, in cui filtrano gli elementi restituiti in base a criteri definiti dall'utente. Per utilizzare le espressioni con DynamoDB Mapper, aggiungi il componente expression nella richiesta dell'operazione. 

Il seguente frammento mostra un esempio di espressione di filtro utilizzata in un'operazione. `scan` Utilizza un argomento lambda per descrivere i criteri di filtro che limitano gli elementi da restituire a quelli con un valore `year` dell'attributo 2001:

```
val table = // A table instance.

table.scanPaginated {
    filter {
        attr("year") eq 2001
    }
}
```

L'esempio seguente mostra un'`query`operazione che supporta le espressioni in due posizioni: filtraggio tramite chiave di ordinamento e filtraggio non chiave:

```
table.queryPaginated {
    keyCondition = KeyFilter(partitionKey = 1000) { sortKey startsWith "M" }
    filter {
        attr("year") eq 2001
    }
}
```

Il codice precedente filtra i risultati in base a quelli che soddisfano tutti e tre i criteri:
+ Il valore dell'attributo della chiave di partizione è 1000 *-AND-*
+ *Il valore dell'attributo chiave di ordinamento inizia con la lettera *M* -AND-*
+ il valore dell'attributo year è 2001

## componenti DSL
<a name="ddb-mapper-expressions-dsl"></a>

La sintassi DSL espone diversi tipi di componenti, descritti di seguito, che vengono utilizzati per creare espressioni.

### Attributes
<a name="ddb-mapper-expressions-dsl-attrs"></a>

La maggior parte delle condizioni fa riferimento agli attributi, che sono identificati dalla chiave o dal percorso del documento. Con DSK, è possibile creare tutti i riferimenti agli attributi utilizzando la `attr` funzione e, facoltativamente, apportare ulteriori modifiche. 

Il codice seguente mostra una serie di esempi di riferimenti agli attributi, da semplici a complessi, come la dereferenziazione delle liste per indice e la dereferenziazione delle mappe per chiave:

```
attr("foo")           // Refers to the value of top-level attribute `foo`.

attr("foo")[3]        // Refers to the value at index 3 in the list value of
                      // attribute `foo`.

attr("foo")[3]["bar"] // Refers to the value of key `bar` in the map value at
                      // index 3 of the list value of attribute `foo`.
```

### Uguaglianze e disuguaglianze
<a name="ddb-mapper-expressions-dsl-eq-and-ineq"></a>

È possibile confrontare i valori degli attributi in un'espressione mediante uguaglianze e disuguaglianze. È possibile confrontare i valori degli attributi con valori letterali o altri valori di attributo. Le funzioni utilizzate per specificare le condizioni sono:
+ `eq`: è uguale a (equivalente a`==`)
+ `neq`: non è uguale a (equivalente a`!=`)
+ `gt`: è maggiore di (equivalente a`>`)
+ `gte`: è maggiore o uguale a (equivalente a`>=`)
+ `lt`: è minore di (equivalente a`<`)
+ `lte`: è minore o uguale a (equivalente a`<=`)

La funzione di confronto viene combinata con gli argomenti utilizzando la notazione infissa, come illustrato negli esempi seguenti:

```
attr("foo") eq 42           // Uses a literal. Specifies that the attribute value `foo` must be
                            // equal to 42.

attr("bar") gte attr("baz") // Uses another attribute value. Specifies that the attribute 
                            // value `bar` must be greater than or equal to the
                            // attribute value of `baz`.
```

### Intervalli e set
<a name="ddb-mapper-expressions-dsl-ranges-sets"></a>

Oltre ai valori singoli, è possibile confrontare i valori degli attributi con più valori in intervalli o set. Utilizzate la `[isIn](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/is-in.html)` funzione infix per eseguire il confronto, come illustrato negli esempi seguenti:

```
attr("foo") isIn 0..99  // Specifies that the attribute value `foo` must be
                        // in the range of `0` to `99` (inclusive).

attr("foo") isIn setOf( // Specifies that the attribute value `foo` must be
    "apple",            // one of `apple`, `banana`, or `cherry`.
    "banana",
    "cherry",
)
```

La `isIn` funzione fornisce sovraccarichi per le raccolte (come`Set<String>`) e per i limiti che puoi esprimere come Kotlin `[ClosedRange<T>](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.ranges/-closed-range/)` (come). `[IntRange](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.ranges/-int-range/)` Per i limiti che non puoi esprimere come a `ClosedRange<T>` (come gli array di byte o altri riferimenti agli attributi), puoi usare la funzione: `[isBetween](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/is-between.html)`

```
val lowerBytes = byteArrayOf(0x48, 0x65, 0x6c)  // Specifies that the attribute value
val upperBytes = byteArrayOf(0x6c, 0x6f, 0x21)  // `foo` is between the values
attr("foo").isBetween(lowerBytes, upperBytes)   // `0x48656c` and `0x6c6f21`

attr("foo").isBetween(attr("bar"), attr("baz")) // Specifies that the attribute value
                                                // `foo` is between the values of
                                                // attributes `bar` and `baz`.
```

### Logica booleana
<a name="ddb-mapper-expressions-dsl-boolean"></a>

È possibile combinare condizioni singole o modificate utilizzando la logica booleana utilizzando le seguenti funzioni:
+ `and`: ogni condizione deve essere vera (equivalente a) ` &&`
+ `or`: almeno una condizione deve essere vera (equivalente a`||`)
+ `not`: la condizione data deve essere falsa (equivalente a`!`)

Gli esempi seguenti mostrano ogni funzione:

```
and(                           // Both conditions must be met:
    attr("foo") eq "banana",   // * attribute value `foo` must equal `banana`
    attr("bar") isIn 0..99,    // * attribute value `bar` must be between
)                              //   0 and 99 (inclusive)

or(                            // At least one condition must be met:
    attr("foo") eq "cherry",   // * attribute value `foo` must equal `cherry`
    attr("bar") isIn 100..199, // * attribute value `bar` must be between
)                              //   100 and 199 (inclusive)

not(                           // The attribute value `foo` must *not* be
    attr("baz") isIn setOf(    // one of `apple`, `banana`, or `cherry`.
        "apple",               // Stated another way, the attribute value
        "banana",              // must be *anything except* `apple`, `banana`,
        "cherry",              // or `cherry`--including potentially a
    ),                         // non-string value or no value at all.
)
```

È possibile combinare ulteriormente condizioni booleane mediante funzioni booleane per creare una logica annidata, come illustrato nella seguente espressione:

```
or(
    and(
        attr("foo") eq 123,
        attr("bar") eq "abc",
    ),
    and(
        attr("foo") eq 234,
        attr("bar") eq "bcd",
    ),
)
```

L'espressione precedente filtra i risultati in base a quelli che soddisfano una di queste condizioni: 
+  Entrambe queste condizioni sono vere:
  + `foo`il valore dell'attributo è 123 *-AND-*
  + `bar`il valore dell'attributo è «abc» 
+ Entrambe queste condizioni sono vere:
  + `foo`il valore dell'attributo è 234 *-AND-*
  + `bar`il valore dell'attributo è «bcd» 

È equivalente alla seguente espressione booleana di Kotlin:

```
(foo == 123 && bar == "abc") || (foo == 234 && bar == "bcd")
```

### Funzioni e proprietà
<a name="ddb-mapper-expressions-dsl-functions"></a>

Le seguenti funzioni e proprietà forniscono funzionalità di espressione aggiuntive:
+ `[contains](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/contains.html)`: verifica se il valore di un string/list attributo contiene un determinato valore
+ `[exists](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/exists.html)`: controlla se un attributo è definito e contiene qualsiasi valore (incluso`null`)
+ `[notExists](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/not-exists.html)`: controlla se un attributo non è definito
+ `[isOfType](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/is-of-type.html)`: controlla se il valore di un attributo è di un determinato tipo, ad esempio stringa, numero, booleano e così via
+ `[size](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/size.html)`: ottiene la dimensione di un attributo, ad esempio il numero di elementi in una raccolta o la lunghezza di una stringa
+ `[startsWith](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/starts-with.html)`: verifica se il valore di un attributo di stringa inizia con una determinata sottostringa

Gli esempi seguenti mostrano l'uso di funzioni e proprietà aggiuntive che è possibile utilizzare nelle espressioni:

```
attr("foo") contains "apple" // Specifies that the attribute value `foo` must be
                             // a list that contains an `apple` element or a string
                             // which contains the substring `apple`.

attr("bar").exists()         // Specifies that the `bar` must exist and have a
                             // value (including potentially `null`).

attr("baz").size lt 100      // Specifies that the attribute value `baz` must have
                             // a size of less than 100.

attr("qux") isOfType AttributeType.String // Specifies that the attribute `qux`
                                          // must have a string value.
```

### Ordina i filtri chiave
<a name="ddb-mapper-expressions-dsl-sort-key"></a>

Le espressioni di filtro sulle chiavi di ordinamento (ad esempio nel `keyCondition` parametro dell'`query`operazione) non utilizzano valori di attributi denominati. Per utilizzare una chiave di ordinamento in un filtro, è necessario utilizzare la parola chiave `sortKey` in tutti i confronti. La `sortKey` parola chiave sostituisce `attr("<sort key name>")` quanto illustrato negli esempi seguenti:

```
sortKey startsWith "abc" // The sort key attribute value must begin with the
                         // substring `abc`.

sortKey isIn 0..99       // The sort key attribute value must be between 0
                         // and 99 (inclusive).
```

Non è possibile combinare i filtri delle chiavi di ordinamento con la logica booleana e supportano solo un sottoinsieme dei confronti descritti sopra:
+ [Uguaglianze e disuguaglianze: tutti i](#ddb-mapper-expressions-dsl-eq-and-ineq) confronti sono supportati
+ [Intervalli e set: tutti i confronti](#ddb-mapper-expressions-dsl-ranges-sets) sono supportati
+ [Logica booleana](#ddb-mapper-expressions-dsl-boolean): non supportata
+ [Funzioni e proprietà](#ddb-mapper-expressions-dsl-functions): solo `startsWith` è supportata