# Expected (heredado)
<a name="LegacyConditionalParameters.Expected"></a>

**nota**  
Le recomendamos que utilice los nuevos parámetros de expresión en lugar de estos parámetros heredados siempre que sea posible. Para obtener más información, consulte [Uso de expresiones en DynamoDB](Expressions.md). Para obtener información específica sobre el nuevo parámetro que reemplaza a este, [Use *ConditionExpression* en su lugar.](#Expected.instead). 

El parámetro condicional heredado `Expected` es un bloque condicional para una operación `UpdateItem`. `Expected` es un mapa de pares atributo-condición. Cada entrada del mapa consta de un nombre de atributo, un operador de comparación y uno o varios valores. DynamoDB utiliza el operador de comparación para comparar el atributo con el o los valores suministrados. Para cada entrada de `Expected`, el resultado de la evaluación es true o false.

Si especifica más de una entrada en el mapa `Expected`, de forma predeterminada todas las condiciones deben evaluarse en true (verdadero). Es decir, las condiciones se combinan con el operador `AND`. (Si lo desea, puede usar el parámetro `ConditionalOperator` para definir las condiciones en OR (o). En tal caso, deberá evaluarse en true (verdadero) al menos una de las condiciones, en lugar de todas ellas).

Si el mapa `Expected` se evalúa en true, entonces la operación condicional se realiza correctamente; de lo contrario, se produce un error.

 `Expected` contiene lo siguiente:
+  `AttributeValueList`: uno o más valores que se evaluarán respecto al atributo suministrado. El número de valores de la lista depende del valor de `ComparisonOperator` que se utilice.

  Para el tipo Number, las comparaciones de los valores son numéricas.

  Las comparaciones de valores String (cadena) de tipo mayor que, igual que o menor que se basan en Unicode con la codificación UTF-8 binaria. Por ejemplo, `a` es mayor que `A` y `a` es mayor que `B`.

  Al comparar valores de tipo Binary, DynamoDB trata cada byte de los datos binarios como sin signo.
+  `ComparisonOperator` - comparador que permite evaluar los atributos contenidos en `AttributeValueList`. Al realizar la comparación, DynamoDB utiliza lecturas de consistencia alta.

  Están disponibles los siguientes operadores de comparación:

   `EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN` 

  A continuación se indican las descripciones de cada operador de comparación.
  +  `EQ`: igual. `EQ` se admite para todos los tipos de datos, incluyendo las listas y los mapas.

     `AttributeValueList` puede contener una sola entrada `AttributeValue` de tipo String (cadena), Number (número), Binary (binario), String Set (conjunto de cadenas), Number Set (conjunto de números) o Binary Set (conjunto de binarios). Si un elemento contiene una entrada `AttributeValue` de un tipo distinto del proporcionado en la solicitud, el valor no coincide. Por ejemplo, `{"S":"6"}` no es igual que `{"N":"6"}`. `{"N":"6"}` tampoco es igual que `{"NS":["6", "2", "1"]}`.
  +  `NE`: distinto. `NE` se admite para todos los tipos de datos, incluyendo las listas y los mapas.

     `AttributeValueList` puede contener un solo `AttributeValue` de tipo String (cadena), Number (número), Binary (binario), String Set (conjunto de cadenas), Number Set (conjunto de números) o Binary Set (conjunto de binarios). Si un elemento contiene un `AttributeValue` de un tipo distinto del proporcionado en la solicitud, el valor no coincide. Por ejemplo, `{"S":"6"}` no es igual que `{"N":"6"}`. `{"N":"6"}` tampoco es igual que `{"NS":["6", "2", "1"]}`.
  +  `LE`: menor o igual que. 

     `AttributeValueList` puede contener una sola entrada `AttributeValue` de tipo String (cadena), Number (número) o Binary (binario) (no de tipo Set [conjunto]). Si un elemento contiene una entrada `AttributeValue` de un tipo distinto del proporcionado en la solicitud, el valor no coincide. Por ejemplo, `{"S":"6"}` no es igual que `{"N":"6"}`. `{"N":"6"}` tampoco se compara con `{"NS":["6", "2", "1"]}`.
  +  `LT` : Menor que. 

     `AttributeValueList` puede contener un solo `AttributeValue` de tipo String (cadena), Number (número) o Binary (binario) (no de tipo Set [conjunto]). Si un elemento contiene una entrada `AttributeValue` de un tipo distinto del proporcionado en la solicitud, el valor no coincide. Por ejemplo, `{"S":"6"}` no es igual que `{"N":"6"}`. `{"N":"6"}` tampoco se compara con `{"NS":["6", "2", "1"]}`.
  +  `GE`: mayor o igual que. 

     `AttributeValueList` puede contener una sola entrada `AttributeValue` de tipo String (cadena), Number (número) o Binary (binario) (no de tipo Set [conjunto]). Si un elemento contiene una entrada `AttributeValue` de un tipo distinto del proporcionado en la solicitud, el valor no coincide. Por ejemplo, `{"S":"6"}` no es igual que `{"N":"6"}`. `{"N":"6"}` tampoco se compara con `{"NS":["6", "2", "1"]}`.
  +  `GT` : Mayor que. 

     `AttributeValueList` puede contener una sola entrada `AttributeValue` de tipo String (cadena), Number (número) o Binary (binario) (no de tipo Set [conjunto]). Si un elemento contiene una entrada `AttributeValue` de un tipo distinto del proporcionado en la solicitud, el valor no coincide. Por ejemplo, `{"S":"6"}` no es igual que `{"N":"6"}`. `{"N":"6"}` tampoco se compara con `{"NS":["6", "2", "1"]}`.
  +  `NOT_NULL`: el atributo existe. `NOT_NULL` se admite para todos los tipos de datos, incluyendo las listas y los mapas.
**nota**  
Este operador comprueba si existe un atributo, no su tipo de datos. Si el tipo de datos del atributo “`a`” es null y se evalúa mediante `NOT_NULL`, el resultado es un valor `true` booleano. Este resultado se debe a que el atributo "`a`" existe; su tipo de datos no es pertinente para el operador de comparación `NOT_NULL`.
  +  `NULL`: el atributo no existe. `NULL` se admite para todos los tipos de datos, incluyendo las listas y los mapas.
**nota**  
Este operador comprueba la inexistencia de un atributo, no su tipo de datos. Si el tipo de datos del atributo “`a`” es null y se evalúa mediante `NULL`, el resultado es un valor `false` booleano. Esto se debe a que el atributo "`a`" existe; su tipo de datos no es pertinente para el operador de comparación `NULL`.
  +  `CONTAINS`: comprueba si hay una subsecuencia, o un valor en un conjunto.

     `AttributeValueList` puede contener una sola entrada `AttributeValue` de tipo String (cadena), Number (número) o Binary (binario) (no de tipo Set [conjunto]). Si el atributo de destino de la comparación es de tipo String (cadena), entonces el operador comprueba si hay una subcadena coincidente. Si el atributo de destino de la comparación es de tipo Binary (binario), entonces el operador busca una subsecuencia del destino que coincida con la entrada. Si el atributo de destino de la comparación es un conjunto ("`SS`", "`NS`" o "`BS`"), entonces el operador se evalúa en true si encuentra una coincidencia exacta con cualquier miembro del conjunto.

    CONTAINS es compatible con listas: al evaluar "`a CONTAINS b`", "`a`" puede ser una lista; sin embargo, "`b`" no puede ser un conjunto, un mapa ni una lista.
  +  `NOT_CONTAINS`: comprueba la ausencia de una subsecuencia, o la ausencia de un valor en un conjunto.

     `AttributeValueList` puede contener una sola entrada `AttributeValue` de tipo String (cadena), Number (número) o Binary (binario) (no de tipo Set [conjunto]). Si el atributo de destino de la comparación es de tipo String (cadena), entonces el operador comprueba la ausencia de una subcadena coincidente. Si el atributo de destino de la comparación es de tipo Binary (binario), entonces el operador busca la ausencia de una subsecuencia del destino que coincida con la entrada. Si el atributo de destino de la comparación es un conjunto ("`SS`", "`NS`" o "`BS`"), entonces el operador se evalúa en true si no (`does not`) encuentra una coincidencia exacta con cualquier miembro del conjunto.

    NOT\$1CONTAINS es compatible con listas: al evaluar "`a NOT CONTAINS b`", "`a`" puede ser una lista; sin embargo, "`b`" no puede ser un conjunto, un mapa ni una lista.
  +  `BEGINS_WITH`: comprueba si hay un prefijo. 

     `AttributeValueList` puede contener un solo `AttributeValue` de tipo String (cadena) o Binary (binario) (no de tipo Number [número] ni Set [conjunto]). El atributo de destino de la comparación debe ser un valor de tipo String o Binary (no de tipo Number ni Set).
  +  `IN`: comprueba si hay entradas que coincidan en dos conjuntos.

     `AttributeValueList` puede contener una o varias entradas `AttributeValue` de tipo String (cadena), Number (número) o Binary (binario) (no de tipo Set [conjunto]). Estos atributos se comparan con un atributo existente de tipo Set (conjunto) de un elemento. Si cualquier entrada del conjunto de entrada está presente en el atributo del elemento, la expresión se evalúa en true.
  +  `BETWEEN`: mayor o igual que el primer valor y menor o igual que el segundo valor. 

     `AttributeValueList` debe contener dos entradas `AttributeValue` del mismo tipo, que puede ser String (cadena), Number (número) o Binary (binario) (pero no de tipo Set [conjunto]). Un atributo de destino coincide si el valor de destino es mayor o igual que la primer entrada y menor o igual que la segunda entrada. Si un elemento contiene una entrada `AttributeValue` de un tipo distinto del proporcionado en la solicitud, el valor no coincide. Por ejemplo, `{"S":"6"}` no se compara con `{"N":"6"}`. `{"N":"6"}` tampoco se compara con `{"NS":["6", "2", "1"]}`. 

Los parámetros siguientes se pueden utilizar en lugar de `AttributeValueList` y `ComparisonOperator`:
+  `Value`: valor que DynamoDB compara con un atributo.
+  `Exists`: valor de tipo Boolean que hace que DynamoDB evalúe el valor antes de intentar la operación condicional.
  + Si `Exists` es `true`, DynamoDB verificará si el valor del atributo ya existe en la tabla. Si lo encuentra, la condición se evalúa en true; de lo contrario, la condición se evalúa en false.
  + Si `Exists` es `false`, DynamoDB presupone que el valor del atributo `not` (no) existe en la tabla. Si el valor no existe, entonces el supuesto es válido y la condición se evalúa en true (verdadero). Si el valor se encuentra, a pesar del supuesto de que no existía, la condición se evalúa en false.

  Tenga en cuenta que el valor predeterminado de `Exists` es `true`.

Los parámetros `Value` y `Exists` son incompatibles con `AttributeValueList` y `ComparisonOperator`. Tenga en cuenta que si utiliza los dos conjuntos de parámetros a la vez, DynamoDB devolverá una excepción `ValidationException`.

**nota**  
Este parámetro no es compatible con atributos de tipo List o Map.

## Use *ConditionExpression* en su lugar; ejemplo
<a name="Expected.instead"></a>

Supongamos que desea modificar un elemento de la tabla *Music*, pero solo si se cumple una condición determinada. Podría usar una solicitud `UpdateItem` con un parámetro `Expected` como en este ejemplo de la AWS CLI:

```
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"} ]
        }
    }'
```

Puede utilizar `ConditionExpression` en su lugar:

```
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"}
    }'
```