Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

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

****  
**DynamoDB Mapper es una versión preliminar para desarrolladores. No incluye todas las funciones y está sujeta a cambios.**

Algunas operaciones de DynamoDB [aceptan](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.html) expresiones que se pueden usar para especificar restricciones o condiciones. DynamoDB Mapper proporciona un DSL idiomático de Kotlin para crear expresiones. El DSL aporta una mayor estructura y legibilidad al código y también facilita la escritura de expresiones. 

En esta sección se describe la sintaxis de DSL y se proporcionan varios ejemplos. 

## Utilice expresiones en las operaciones
<a name="ddb-mapper-expressions-basic-usage"></a>

Usas expresiones en operaciones como`scan`, por ejemplo, en las que filtran los elementos devueltos en función de los criterios que tú definas. Para usar expresiones con DynamoDB Mapper, añada el componente de expresión en la solicitud de operación. 

En el siguiente fragmento se muestra un ejemplo de una expresión de filtro que se utiliza en una operación. `scan` Utiliza un argumento lambda para describir los criterios de filtro que limitan los elementos que se van a devolver a aquellos con un valor de `year` atributo de 2001:

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

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

En el siguiente ejemplo, se muestra una `query` operación que admite expresiones en dos lugares: el filtrado por clave de clasificación y el filtrado sin clave:

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

El código anterior filtra los resultados para que cumplan los tres criterios:
+ El valor del atributo clave de partición es 1000 *-AND-*
+ El valor del atributo de la clave de clasificación comienza con la letra *M -AND* *-*
+ El valor del atributo del año es 2001

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

La sintaxis de DSL expone varios tipos de componentes (que se describen a continuación) que se utilizan para crear expresiones.

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

La mayoría de las condiciones hacen referencia a los atributos, que se identifican por su clave o ruta de documento. Con el DSK, puede crear todas las referencias de atributos mediante la `attr` función y, si lo desea, realizar modificaciones adicionales. 

El código siguiente muestra un rango de ejemplos de referencias a atributos, desde simples hasta complejas, como la desreferenciación de listas por índice y la desreferenciación de mapas por clave:

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

### Igualdades y desigualdades
<a name="ddb-mapper-expressions-dsl-eq-and-ineq"></a>

Puede comparar los valores de los atributos de una expresión mediante igualdades y desigualdades. Puede comparar los valores de los atributos con valores literales u otros valores de atributos. Las funciones que se utilizan para especificar las condiciones son:
+ `eq`: es igual a (equivalente a`==`)
+ `neq`: no es igual a (equivalente a`!=`)
+ `gt`: es mayor que (equivalente a`>`)
+ `gte`: es mayor o igual a (equivalente a`>=`)
+ `lt`: es menor que (equivalente a`<`)
+ `lte`: es menor o igual a (equivalente a`<=`)

La función de comparación con los argumentos se combina mediante la notación infija, como se muestra en los siguientes ejemplos:

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

### Rangos y conjuntos
<a name="ddb-mapper-expressions-dsl-ranges-sets"></a>

Además de los valores individuales, puede comparar los valores de los atributos con varios valores de los rangos o conjuntos. La `[isIn](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/is-in.html)` función infijo se utiliza para realizar la comparación, tal y como se muestra en los siguientes ejemplos:

```
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` función proporciona sobrecargas para las colecciones (por ejemplo`Set<String>`) y para los límites que se pueden expresar como Kotlin `[ClosedRange<T>](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.ranges/-closed-range/)` (por ejemplo). `[IntRange](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.ranges/-int-range/)` Para los límites que no puedes expresar como a `ClosedRange<T>` (como matrices de bytes u otras referencias de atributos), puedes usar la función: `[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`.
```

### Lógica booleana
<a name="ddb-mapper-expressions-dsl-boolean"></a>

Puede combinar condiciones individuales o modificarlas mediante la lógica booleana mediante las siguientes funciones:
+ `and`: todas las condiciones deben ser verdaderas (equivalentes a) ` &&`
+ `or`: al menos una condición debe ser verdadera (equivalente a`||`)
+ `not`: la condición dada debe ser falsa (equivalente a`!`)

Los siguientes ejemplos muestran cada función:

```
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.
)
```

También puede combinar condiciones booleanas con funciones booleanas para crear una lógica anidada, como se muestra en la siguiente expresión:

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

La expresión anterior filtra los resultados por aquellos que cumplen alguna de estas condiciones: 
+  Se cumplen las dos condiciones siguientes:
  + `foo`el valor del atributo es 123 *-AND-*
  + `bar`el valor del atributo es «abc» 
+ Ambas condiciones son verdaderas:
  + `foo`el valor del atributo es 234 *-AND-*
  + `bar`el valor del atributo es «bcd» 

Esto equivale a la siguiente expresión booleana de Kotlin:

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

### Funciones y propiedades
<a name="ddb-mapper-expressions-dsl-functions"></a>

Las siguientes funciones y propiedades proporcionan capacidades de expresión adicionales:
+ `[contains](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/contains.html)`: comprueba si el valor de un string/list atributo contiene un valor determinado
+ `[exists](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/exists.html)`: comprueba si un atributo está definido y contiene algún valor (incluido`null`)
+ `[notExists](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/not-exists.html)`: comprueba si un atributo no está definido
+ `[isOfType](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/is-of-type.html)`: comprueba si el valor de un atributo es de un tipo determinado, como cadena, número, booleano, etc.
+ `[size](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/size.html)`: obtiene el tamaño de un atributo, como el número de elementos de una colección o la longitud de una cadena
+ `[startsWith](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.expressions/-filter/starts-with.html)`: comprueba si el valor de un atributo de cadena comienza con una subcadena determinada

Los siguientes ejemplos muestran el uso de funciones y propiedades adicionales que se pueden utilizar en las expresiones:

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

### Ordene los filtros clave
<a name="ddb-mapper-expressions-dsl-sort-key"></a>

Las expresiones de filtro de las claves de clasificación (como las del `keyCondition` parámetro de la `query` operación) no utilizan valores de atributos con nombre asignado. Para utilizar una clave de ordenación en un filtro, debe utilizar la palabra clave `sortKey` en todas las comparaciones. La `sortKey` palabra clave se reemplaza `attr("<sort key name>")` como se muestra en los ejemplos siguientes:

```
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).
```

Los filtros de claves de clasificación no se pueden combinar con la lógica booleana y solo admiten un subconjunto de las comparaciones descritas anteriormente:
+ [Igualidades y desigualdades](#ddb-mapper-expressions-dsl-eq-and-ineq): se admiten todas las comparaciones
+ [Rangos y conjuntos: se](#ddb-mapper-expressions-dsl-ranges-sets) admiten todas las comparaciones
+ [Lógica booleana](#ddb-mapper-expressions-dsl-boolean): no se admite
+ [Funciones y propiedades](#ddb-mapper-expressions-dsl-functions): solo se admite `startsWith`