Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Paramètres conditionnels hérités de DynamoDB
Ce document fournit une vue d’ensemble des paramètres conditionnels hérités de DynamoDB et recommande d’utiliser les nouveaux paramètres d’expression à la place. Il couvre des détails sur des paramètres tels que AttributesToGet AttributeUpdates ConditionalOperator,, KeyConditions QueryFilter, Expected ScanFilter,, et fournit des exemples d'utilisation des nouveaux paramètres d'expression en remplacement.
**Important**
Dans la mesure du possible, nous vous recommandons d’utiliser les nouveaux paramètres d’expression plutôt que ces paramètres hérités. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md).
De plus, DynamoDB ne permet pas de mélanger des paramètres conditionnels hérités et des paramètres d’expression dans un même appel. Par exemple, l’appel de l’opération `Query` avec `AttributesToGet` et `ConditionExpression` entraîne une erreur.
Le tableau suivant présente les opérations d’API DynamoDB qui prennent encore en charge ces paramètres hérités ainsi que les paramètres d’expression à utiliser à leur place. Ce tableau peut être utile si vous envisagez de mettre à jour vos applications afin qu’elles utilisent plutôt des paramètres d’expression.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html)
Les sections suivantes fournissent des informations supplémentaires sur les paramètres conditionnels hérités.
**Topics**
+ [AttributesToGet (héritage)](LegacyConditionalParameters.AttributesToGet.md)
+ [AttributeUpdates (héritage)](LegacyConditionalParameters.AttributeUpdates.md)
+ [ConditionalOperator (héritage)](LegacyConditionalParameters.ConditionalOperator.md)
+ [Expected (hérité)](LegacyConditionalParameters.Expected.md)
+ [KeyConditions (héritage)](LegacyConditionalParameters.KeyConditions.md)
+ [QueryFilter (héritage)](LegacyConditionalParameters.QueryFilter.md)
+ [ScanFilter (héritage)](LegacyConditionalParameters.ScanFilter.md)
+ [Conditions d’écriture avec des paramètres hérités](LegacyConditionalParameters.Conditions.md)
# AttributesToGet (héritage)
**Note**
Dans la mesure du possible, nous vous recommandons d’utiliser les nouveaux paramètres d’expression plutôt que ces paramètres hérités. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md). Pour obtenir des informations précises sur le nouveau paramètre qui remplace celui-ci, [Utiliser *ProjectionExpression* à la place](#ProjectionExpression.instead).
Le paramètre conditionnel hérité `AttributesToGet` est un tableau d’un ou plusieurs attributs à extraire de DynamoDB. Si aucun nom d’attribut n’est fourni, tous les attributs sont renvoyés. Les attributs demandés non trouvés n’apparaissent pas dans le résultat.
`AttributesToGet` vous permet d’extraire des attributs de type liste ou mappage, mais pas des éléments individuels d’une liste ou d’un mappage.
Notez qu’`AttributesToGet` n’a aucun effet sur la consommation du débit approvisionné. DynamoDB détermine les unités de capacité consommées sur la base de la taille d’un élément, pas de la quantité de données qu’il renvoie à une application.
## Utiliser *ProjectionExpression*plutôt — Exemple
Supposons que vous souhaitez extraire un élément de la table *Music*, mais ne voulez renvoyer que certains des attributs. Vous pouvez utiliser une `GetItem` requête avec un `AttributesToGet` paramètre, comme dans cet AWS CLI exemple :
```
aws dynamodb get-item \
--table-name Music \
--attributes-to-get '["Artist", "Genre"]' \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}'
```
Vous pouvez utiliser `ProjectionExpression` à la place :
```
aws dynamodb get-item \
--table-name Music \
--projection-expression "Artist, Genre" \
--key '{
"Artist": {"S":"No One You Know"},
"SongTitle": {"S":"Call Me Today"}
}'
```
# AttributeUpdates (héritage)
**Note**
Dans la mesure du possible, nous vous recommandons d’utiliser les nouveaux paramètres d’expression plutôt que ces paramètres hérités. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md). Pour obtenir des informations précises sur le nouveau paramètre qui remplace celui-ci, [utilisez *UpdateExpression*plutôt.](#UpdateExpression.instead).
Dans une opération `UpdateItem`, le paramètre conditionnel hérité `AttributeUpdates` contient les noms d’attributs à modifier, l’action à effectuer sur chacun d’eux et leur nouvelle valeur. Si vous mettez à jour un attribut de clé d’index pour tous les index figurant dans cette table, le type d’attribut doit correspondre au type de clé d’index défini dans la section `AttributesDefinition` de la description de la table. Vous pouvez utiliser une opération `UpdateItem` pour mettre à jour tous les attributs autres que de clé.
Les valeurs d’attribut ne peuvent pas être nulles. Les attributs de type chaîne et binaire doivent avoir une longueur supérieure à zéro. Les attributs de type ensemble ne peuvent pas être vides. Les demandes comprenant des valeurs vides sont rejetées avec une exception `ValidationException`.
Chaque élément `AttributeUpdates` se compose d’un nom d’attribut à modifier, ainsi que de ce qui suit :
+ `Value` : nouvelle valeur, le cas échéant, pour cet attribut.
+ `Action` : valeur spécifiant comment effectuer la mise à jour. Cette action n’est valide que pour un attribut existant dont le type de données est nombre ou ensemble. N’utilisez pas l’action `ADD` pour d’autres types de données.
Si un élément avec la clé primaire spécifiée est trouvé dans la table, les valeurs suivantes exécutent les actions suivantes :
+ `PUT` - Ajoute l’attribut spécifié à l’élément. Si l’attribut existe déjà, il est remplacé par la nouvelle valeur.
+ `DELETE` - Si aucune valeur n’est spécifiée pour `DELETE`, supprime l’attribut et sa valeur. Le type de données de la valeur spécifiée doit correspondre au type de données de la valeur existante.
Si un ensemble de valeurs est spécifié, ces valeurs sont soustraites de l’ancien ensemble. Par exemple, si la valeur d’attribut était l’ensemble `[a,b,c]` et si l’action `DELETE` spécifie `[a,c]`, la valeur d’attribut finale est `[b]`. La spécification d’un ensemble vide est une erreur.
+ `ADD` - Ajoute la valeur spécifiée à l’élément si l’attribut n’existe pas encore. Si l’attribut existe, le comportement de l’action `ADD` dépend du type de données de l’attribut :
+ Si l’attribut existant est un nombre et si `Value` est également un nombre, `Value` est ajouté mathématiquement à l’attribut existant. Si `Value` est un nombre négatif, celui-ci est soustrait de l’attribut existant.
**Note**
Si vous utilisez l’action `ADD` pour incrémenter ou décrémenter une valeur numérique pour un élément qui n’existe pas avant la mise à jour, DynamoDB utilise 0 comme valeur initiale.
De même, si vous utilisez l’action `ADD` pour un élément existant afin d’incrémenter ou de décrémenter une valeur d’attribut qui n’existe pas avant la mise à jour, DynamoDB utilise `0` comme valeur initiale. Par exemple, supposons que l’élément que vous souhaitez mettre à jour ne possède pas d’attribut nommé *itemcount*, mais que vous décidez malgré tout d’ajouter (`ADD`) le nombre `3` à cet attribut. DynamoDB crée l’attribut *itemcount*, définit sa valeur initiale sur `0`, puis y ajoute `3`. Le résultat sera un nouvel attribut *itemcount*, avec une valeur de `3`.
+ Si le type de données existant est un ensemble, et si `Value` est également un ensemble, `Value` est ajouté à l’ensemble existant. Par exemple, si la valeur d’attribut est l’ensemble `[1,2]` et si l’action `ADD` spécifie `[3]`, la valeur d’attribut finale est `[1,2,3]`. Une erreur se produit si une action `ADD` est spécifiée pour un attribut ensemble et si le type d’attribut spécifié ne correspond pas au type d’ensemble existant.
Les deux ensembles doivent avoir le même type de données primitif. Par exemple, si le type de données existant est un ensemble de chaînes, `Value` doit également être un ensemble de chaînes.
Si aucun élément avec la clé primaire spécifiée n’est trouvé dans la table, les valeurs suivantes exécutent les actions suivantes :
+ `PUT` - Amène DynamoDB à créer un élément avec la clé primaire spécifiée, puis ajoute l’attribut.
+ `DELETE` - Rien ne se passe, car des attributs ne peuvent pas être supprimés d’un élément inexistant. L’opération réussit, mais DynamoDB ne crée pas d’élément.
+ `ADD` – Amène DynamoDB à créer un élément avec la clé primaire et le nombre (ou ensemble de nombres) fournis pour la valeur d’attribut. Les seuls types de données autorisés sont Nombre et Ensemble de nombres.
Si vous fournissez des attributs faisant partie d’une clé d’index, les types de données pour ces attributs doivent correspondre à ceux du schéma dans la définition d’attribut de la table.
## Utiliser *UpdateExpression*plutôt — Exemple
Supposons que vous souhaitez modifier un élément dans la table *Music*. Vous pouvez utiliser une `UpdateItem` requête avec un `AttributeUpdates` paramètre, comme dans cet AWS CLI exemple :
```
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"}
}
}'
```
Vous pouvez utiliser `UpdateExpression` à la place :
```
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 (héritage)
**Note**
Dans la mesure du possible, nous vous recommandons d’utiliser les nouveaux paramètres d’expression plutôt que ces paramètres hérités. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md).
Le paramètre conditionnel hérité `ConditionalOperator` est un opérateur logique destiné s’appliquer aux conditions d’un mappage `Expected`, `QueryFilter` ou `ScanFilter` :
+ AND - Si toutes les conditions ont la valeur true, le mappage entier a la valeur true.
+ OR – Si au moins une des conditions a la valeur true, le mappage entier a la valeur true.
Si vous omettez `ConditionalOperator`, `AND` est l’opérateur par défaut.
L’opération ne réussit que si le mappage entier a la valeur true.
**Note**
Ce paramètre ne prend pas en charge les attributs de type Liste ou Mappage.
# Expected (hérité)
**Note**
Dans la mesure du possible, nous vous recommandons d’utiliser les nouveaux paramètres d’expression plutôt que ces paramètres hérités. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md). Pour obtenir des informations précises sur le nouveau paramètre qui remplace celui-ci, [utilisez *ConditionExpression*plutôt.](#Expected.instead).
Le paramètre conditionnel existant `Expected` est un bloc conditionnel pour une `UpdateItem` opération. `Expected`est une carte de attribute/condition paires. Chaque élément du mappage se compose d’un nom d’attribut, d’un opérateur de comparaison et d’une ou plusieurs valeurs. DynamoDB compare l’attribut avec la ou les valeurs que vous avez fournies, en utilisant l’opérateur de comparaison. Pour chaque élément `Expected`, le résultat de l’évaluation est vrai (true) ou faux (false).
Si vous spécifiez plusieurs éléments dans le mappage `Expected`, par défaut, le résultat de toutes les conditions doit être true. En d’autres termes, les conditions sont combinées à l’aide de l’opérateur `AND`. Vous pouvez également utiliser le paramètre `ConditionalOperator` pour dissocier les conditions à l’aide de l’opérateur logique OR (OU). Dans ce cas, au moins une des conditions doit avoir la valeur vrai, plutôt que toutes.
Si le mappage `Expected` a la valeur true, l’opération conditionnelle réussit. Autrement, elle échoue.
Le mappage `Expected` contient les éléments suivants :
+ `AttributeValueList` - Une ou plusieurs valeurs à évaluer par rapport à l’attribut fourni. Le nombre de valeurs dans la liste dépend de l’opérateur `ComparisonOperator` utilisé.
Pour le type Nombre, les comparaisons de valeurs sont numériques.
Les comparaisons de valeurs de chaîne pour supérieur, égal ou inférieur sont basées sur le codage Unicode binaire UTF-8. Par exemple, `a` est supérieur à `A`, et `a` est supérieur à `B`.
Pour le type Binaire, DynamoDB traite chaque octet des données binaires comme non signé lors de la comparaison de valeurs binaires.
+ `ComparisonOperator` - Comparateur pour l’évaluation d’attributs dans la `AttributeValueList`. Lors de la comparaison, DynamoDB utilise des lectures fortement cohérentes.
Les opérateurs de comparaison pris en charge sont les suivants :
`EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN`
Voici la description de chaque opérateur de comparaison.
+ `EQ` : égal. L’opérateur `EQ` est pris en charge pour tous les types de données, y compris les listes et les mappages.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre, Binaire, Ensemble de chaînes, Ensemble de nombres ou Ensemble de binaires. Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n’est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` n’est pas égal à `{"NS":["6", "2", "1"]}`.
+ `NE` : pas égal. L’opérateur `NE` est pris en charge pour tous les types de données, y compris les listes et les mappages.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre, Binaire, Ensemble de chaînes, Ensemble de nombres ou Ensemble de binaires. Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n’est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` n’est pas égal à `{"NS":["6", "2", "1"]}`.
+ `LE` : inférieur ou égal.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n'est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` n'est pas comparable à `{"NS":["6", "2", "1"]}`.
+ `LT` : inférieur.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n'est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` ne se compare pas à `{"NS":["6", "2", "1"]}`.
+ `GE` : supérieur ou égal.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n'est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` ne se compare pas à `{"NS":["6", "2", "1"]}`.
+ `GT` : supérieur.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n'est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` n’est pas comparable à `{"NS":["6", "2", "1"]}`.
+ `NOT_NULL` : l’attribut existe. L’opérateur `NOT_NULL` est pris en charge pour tous les types de données, y compris les listes et les mappages.
**Note**
Cet opérateur teste l’existence d’un attribut, pas son type de données. Si le type de données de l’attribut « `a` » est nul, et si vous l’évaluez à l’aide de l’opérateur `NOT_NULL`, le résultat est un booléen de valeur `true`. Ce résultat est dû au fait que l’attribut « `a` » existe. Son type de données n’est pas pertinent pour l’opérateur de comparaison `NOT_NULL`.
+ `NULL` : l’attribut n’existe pas. L’opérateur `NULL` est pris en charge pour tous les types de données, y compris les listes et les mappages.
**Note**
Cet opérateur teste la non-existence d’un attribut, pas son type de données. Si le type de données de l’attribut « `a` » est nul, et si vous l’évaluez à l’aide de l’opérateur `NULL`, le résultat est un booléen de valeur `false`. Cela est dû au fait que l’attribut « `a` » existe. Son type de données n’est pas pertinent pour l’opérateur de comparaison `NULL`.
+ `CONTAINS` : vérifie la présence d’une sous-séquence ou d’une valeur dans un ensemble.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si l’attribut cible de la comparaison est de type Chaîne, l’opérateur vérifie la présence d’une sous-chaîne correspondante. Si l’attribut cible de la comparaison est de type Binaire, l’opérateur vérifie la présence d’une sous-séquence de la cible correspondant à l’entrée. Si l’attribut cible de la comparaison est un ensemble (« `SS` », « `NS` » ou « `BS` »), l’opérateur évalue true s’il trouve une correspondance exacte avec un membre de l’ensemble.
L’opérateur CONTAINS est pris en charge pour les listes. Lors de l’évaluation de « `a CONTAINS b` », « `a` » peut être une liste. En revanche, « `b` » ne peut pas être un ensemble, un mappage ou une liste.
+ `NOT_CONTAINS` : vérifie l’absence d’une sous-séquence ou d’une valeur dans un ensemble.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si l’attribut cible de la comparaison est de type Chaîne, l’opérateur vérifie l’absence de sous-chaîne correspondante. Si l’attribut cible de la comparaison est de type Binaire, l’opérateur vérifie l’absence d’une sous-séquence de la cible correspondant à l’entrée. Si l’attribut cible de la comparaison est un ensemble (« `SS` », « `NS` » ou « `BS` »), l’opérateur évalue true s’il ne trouve pas `does not` de correspondance exacte avec un membre de l’ensemble.
L’opérateur NOT\$1CONTAINS est pris en charge pour les listes. Lors de l’évaluation de « `a NOT CONTAINS b` », « `a` » peut être une liste. En revanche, « `b` » ne peut pas être un ensemble, un mappage ou une liste.
+ `BEGINS_WITH` : vérifie la présence d’un préfixe.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne ou Binaire (pas Nombre ou Ensemble). L’attribut cible de la comparaison doit être de type Chaîne ou Binaire (pas Nombre ou Ensemble).
+ `IN` : vérifie la présence d’éléments correspondants dans deux ensembles.
`AttributeValueList` peut contenir un ou plusieurs éléments `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Ces attributs sont comparés à un attribut de type d’ensemble existant d’un élément. Si des éléments de l’ensemble en entrée sont présents dans l’attribut de l’élément, l’expression prend la valeur true.
+ `BETWEEN` : supérieur ou égal à la première valeur, et inférieur ou égal à la deuxième.
`AttributeValueList` doit contenir deux éléments `AttributeValue` du même type, Chaîne, Nombre ou Binaire (pas Ensemble). Un attribut cible correspond si la valeur cible est supérieure ou égale au premier élément, et inférieure ou égale au deuxième. Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` ne se compare pas à `{"N":"6"}`. De même, `{"N":"6"}` ne se compare pas à `{"NS":["6", "2", "1"]}`.
Les paramètres suivants peuvent être utilisés au lieu de `AttributeValueList` et `ComparisonOperator` :
+ `Value` - Valeur que DynamoDB doit comparer avec un attribut.
+ `Exists` - Valeur booléenne qui amène DynamoDB à évaluer la valeur avant de tenter l’opération conditionnelle :
+ Si `Exists` a la valeur `true`, DynamoDB vérifie si cette valeur d’attribut existe déjà dans la table. Si elle y figure, la condition a la valeur true. Sinon, la condition a la valeur false.
+ Si `Exists` a la valeur `false`, DynamoDB suppose que la valeur d’attribut n’existe `not` dans la table. Si la valeur n’existe effectivement pas, l’hypothèse est valide et le résultat de la condition est true. Si la valeur est trouvée malgré l’hypothèse qu’elle n’existe pas, le résultat de la condition est false.
Notez que la valeur par défaut pour `Exists` est `true`.
Les paramètres `Value` et `Exists` sont incompatibles avec `AttributeValueList` et `ComparisonOperator`. Notez que, si vous utilisez les deux ensembles de paramètres à la fois, DynamoDB renvoie une exception `ValidationException`.
**Note**
Ce paramètre ne prend pas en charge les attributs de type Liste ou Mappage.
## Utiliser *ConditionExpression*plutôt — Exemple
Supposons que vous souhaitiez modifier un élément dans la table *Music*, mais seulement si le résultat d’une certaine condition est true. Vous pouvez utiliser une `UpdateItem` requête avec un `Expected` paramètre, comme dans cet AWS CLI exemple :
```
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"} ]
}
}'
```
Vous pouvez utiliser `ConditionExpression` à la place :
```
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 (héritage)
**Note**
Dans la mesure du possible, nous vous recommandons d’utiliser les nouveaux paramètres d’expression plutôt que ces paramètres hérités. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md). Pour obtenir des informations précises sur le nouveau paramètre qui remplace celui-ci, [utilisez *KeyConditionExpression*plutôt.](#KeyConditionExpression.instead).
Le paramètre conditionnel hérité `KeyConditions` contient des critères de sélection pour une opération `Query`. Pour une requête sur une table, vous ne pouvez avoir de conditions que sur les attributs de clé primaire de table. Vous devez fournir le nom et la valeur de la clé de partition comme condition `EQ`. Vous pouvez également fournir une deuxième condition pour la clé de tri.
**Note**
Si vous ne fournissez pas de condition de clé de tri, tous les éléments correspondant à la clé de partition sont extraits. Si les paramètres `FilterExpression` ou un `QueryFilter` sont présents, ils sont appliqués une fois les éléments extraits.
Pour une requête sur un index, vous ne pouvez avoir de conditions que sur les attributs de clé d’index. Vous devez fournir le nom et la valeur de la clé de partition d’index comme condition `EQ`. Vous pouvez également fournir une deuxième condition pour la clé de tri d’index.
Chaque élément `KeyConditions` se compose d’un nom d’attribut à comparer, ainsi que de ce qui suit :
+ `AttributeValueList` - Une ou plusieurs valeurs à évaluer par rapport à l’attribut fourni. Le nombre de valeurs dans la liste dépend de l’opérateur `ComparisonOperator` utilisé.
Pour le type Nombre, les comparaisons de valeurs sont numériques.
Les comparaisons de valeurs de chaîne pour supérieur, égal ou inférieur sont basées sur le codage Unicode binaire UTF-8. Par exemple, `a` est supérieur à `A`, et `a` est supérieur à `B`.
Pour le type Binaire, DynamoDB traite chaque octet des données binaires comme non signé lors de la comparaison de valeurs binaires.
+ `ComparisonOperator` - Comparateur pour l’évaluation d’attributs. Par exemple : égal à, supérieur à, et inférieur à.
Pour `KeyConditions`, seuls les opérateurs de comparaison suivants sont pris en charge :
`EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN`
Voici une description de ces opérateurs de comparaison.
+ `EQ` : égal.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n’est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` n’est pas égal à `{"NS":["6", "2", "1"]}`.
+ `LE` : inférieur ou égal.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n'est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` n'est pas comparable à `{"NS":["6", "2", "1"]}`.
+ `LT` : inférieur.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n'est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` ne se compare pas à `{"NS":["6", "2", "1"]}`.
+ `GE` : supérieur ou égal.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n'est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` ne se compare pas à `{"NS":["6", "2", "1"]}`.
+ `GT` : supérieur.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne, Nombre ou Binaire (pas Ensemble). Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n'est pas égal à `{"N":"6"}`. De même, `{"N":"6"}` n'est pas comparable à `{"NS":["6", "2", "1"]}`.
+ `BEGINS_WITH` : vérifie la présence d’un préfixe.
`AttributeValueList` ne peut contenir qu’un seul élément `AttributeValue` de type Chaîne ou Binaire (pas Nombre ou Ensemble). L’attribut cible de la comparaison doit être de type Chaîne ou Binaire (pas Nombre ou Ensemble).
+ `BETWEEN` : supérieur ou égal à la première valeur, et inférieur ou égal à la deuxième.
`AttributeValueList` doit contenir deux éléments `AttributeValue` du même type, Chaîne, Nombre ou Binaire (pas Ensemble). Un attribut cible correspond si la valeur cible est supérieure ou égale au premier élément, et inférieure ou égale au deuxième. Si une liste contient un élément `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, `{"S":"6"}` n’est pas comparable à `{"N":"6"}`. De même, `{"N":"6"}` n’est pas comparable à `{"NS":["6", "2", "1"]}`.
## Utiliser *KeyConditionExpression*plutôt — Exemple
Supposons que vous souhaitiez extraire plusieurs éléments avec la même clé de partition à partir de la table *Music*. Vous pouvez utiliser une `Query` requête avec un `KeyConditions` paramètre, comme dans cet AWS CLI exemple :
```
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"} ]
}
}'
```
Vous pouvez utiliser `KeyConditionExpression` à la place :
```
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 (héritage)
**Note**
Dans la mesure du possible, nous vous recommandons d’utiliser les nouveaux paramètres d’expression plutôt que ces paramètres hérités. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md). Pour obtenir des informations précises sur le nouveau paramètre qui remplace celui-ci, [utilisez *FilterExpression*plutôt.](#FilterExpression.instead).
Dans une opération `Query`, le paramètre conditionnel hérité `QueryFilter` est une condition qui évalue les résultats de la requête après lecture des éléments et renvoie uniquement les valeurs souhaitées.
Ce paramètre ne prend pas en charge les attributs de type Liste ou Mappage.
**Note**
Un `QueryFilter` est appliqué après lecture des éléments. Le processus de filtrage ne consomme pas d’unités de capacité de lecture supplémentaires.
Si vous spécifiez plusieurs conditions dans le mappage `QueryFilter`, par défaut, le résultat de toutes les conditions doit être true. En d’autres termes, les conditions sont combinées à l’aide de l’opérateur `AND`. Vous pouvez également utiliser le paramètre [ConditionalOperator (héritage)](LegacyConditionalParameters.ConditionalOperator.md) pour dissocier les conditions à l’aide de l’opérateur logique OR (OU). Dans ce cas, au moins une des conditions doit avoir la valeur vrai, plutôt que toutes.
Notez que `QueryFilter` n’autorise pas les attributs de clé. Vous ne pouvez pas définir de condition de filtre sur une clé de partition ou une clé de tri.
Chaque élément `QueryFilter` se compose d’un nom d’attribut à comparer, ainsi que de ce qui suit :
+ `AttributeValueList` - Une ou plusieurs valeurs à évaluer par rapport à l’attribut fourni. Le nombre de valeurs dans la liste dépend de l’opérateur spécifié dans `ComparisonOperator`.
Pour le type Nombre, les comparaisons de valeurs sont numériques.
Les comparaisons de valeurs de chaîne pour supérieur, égal ou inférieur sont basées sur le codage binaire UTF-8. Par exemple, `a` est supérieur à `A`, et `a` est supérieur à `B`.
Pour le type Binaire, DynamoDB traite chaque octet des données binaires comme non signé lors de la comparaison de valeurs binaires.
Pour plus d’informations sur la spécification des types de données en JSON, consultez [API de bas niveau de DynamoDB](Programming.LowLevelAPI.md).
+ `ComparisonOperator` - Comparateur pour l’évaluation d’attributs. Par exemple : égal à, supérieur à, et inférieur à.
Les opérateurs de comparaison pris en charge sont les suivants :
`EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN`
## Utiliser *FilterExpression*plutôt — Exemple
Supposons que vous vouliez interroger la table *Music* et appliquer une condition aux éléments correspondants. Vous pourriez utiliser une requête `Query` avec un paramètre `QueryFilter` comme dans cet exemple d’ 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"} ]
}
}'
```
Vous pouvez utiliser `FilterExpression` à la place :
```
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 (héritage)
**Note**
Dans la mesure du possible, nous vous recommandons d’utiliser les nouveaux paramètres d’expression plutôt que ces paramètres hérités. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md). Pour obtenir des informations précises sur le nouveau paramètre qui remplace celui-ci, [utilisez *FilterExpression*plutôt.](#FilterExpression2.instead).
Dans une opération `Scan`, le paramètre conditionnel hérité `ScanFilter` est une condition qui évalue les résultats de l’analyse et renvoie uniquement les valeurs souhaitées.
**Note**
Ce paramètre ne prend pas en charge les attributs de type Liste ou Mappage.
Si vous spécifiez plusieurs conditions dans le mappage `ScanFilter`, par défaut, le résultat de toutes les conditions doit être true. En d'autres termes, les conditions sont ANDed réunies. Vous pouvez également utiliser le paramètre [ConditionalOperator (héritage)](LegacyConditionalParameters.ConditionalOperator.md) pour dissocier les conditions à l’aide de l’opérateur logique OR (OU). Dans ce cas, au moins une des conditions doit avoir la valeur vrai, plutôt que toutes.
Chaque élément `ScanFilter` se compose d’un nom d’attribut à comparer, ainsi que de ce qui suit :
+ `AttributeValueList` - Une ou plusieurs valeurs à évaluer par rapport à l’attribut fourni. Le nombre de valeurs dans la liste dépend de l’opérateur spécifié dans `ComparisonOperator`.
Pour le type Nombre, les comparaisons de valeurs sont numériques.
Les comparaisons de valeurs de chaîne pour supérieur, égal ou inférieur sont basées sur le codage binaire UTF-8. Par exemple, `a` est supérieur à `A`, et `a` est supérieur à `B`.
Pour le type Binaire, DynamoDB traite chaque octet des données binaires comme non signé lors de la comparaison de valeurs binaires.
Pour plus d’informations sur la spécification des types de données en JSON, consultez [API de bas niveau de DynamoDB](Programming.LowLevelAPI.md).
+ `ComparisonOperator` - Comparateur pour l’évaluation d’attributs. Par exemple : égal à, supérieur à, et inférieur à.
Les opérateurs de comparaison pris en charge sont les suivants :
`EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN`
## Utiliser *FilterExpression*plutôt — Exemple
Supposons que vous vouliez analyser la table *Music* et appliquer une condition aux éléments correspondants. Vous pourriez utiliser une requête `Scan` avec un paramètre `ScanFilter` comme dans cet exemple d’ AWS CLI :
```
aws dynamodb scan \
--table-name Music \
--scan-filter '{
"Genre":{
"AttributeValueList":[ {"S":"Rock"} ],
"ComparisonOperator": "EQ"
}
}'
```
Vous pouvez utiliser `FilterExpression` à la place :
```
aws dynamodb scan \
--table-name Music \
--filter-expression 'Genre = :g' \
--expression-attribute-values '{
":g": {"S":"Rock"}
}'
```
# Conditions d’écriture avec des paramètres hérités
**Note**
Dans la mesure du possible, nous vous recommandons d’utiliser les nouveaux paramètres d’expression plutôt que ces paramètres hérités. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md).
La section suivante décrit comment écrire des conditions pour une utilisation avec des paramètres hérités, tels que `Expected`, `QueryFilter` et `ScanFilter`.
**Note**
Les nouvelles applications doivent utiliser des paramètres d’expression à la place. Pour de plus amples informations, veuillez consulter [Utilisation d’expressions dans DynamoDB](Expressions.md).
## Conditions simples
Avec des valeurs d’attribut, vous pouvez écrire des conditions pour des comparaisons par rapport à des attributs de table. Une condition produit toujours un résultat true (vrai) ou false (faux), et comprend les éléments suivants :
+ `ComparisonOperator` – Supérieur, inférieur, égal, etc.
+ `AttributeValueList` (facultatif) – Valeur(s) d’attribut à comparer. En fonction de l’opérateur `ComparisonOperator` utilisé, la liste `AttributeValueList` peut contenir une ou plusieurs valeurs ou être totalement absente.
Les sections suivantes décrivent les différents opérateurs de comparaison, et fournissent des exemples d’utilisation de ceux-ci dans des conditions.
### Opérateurs de comparaison sans valeur d’attribut
+ `NOT_NULL` – true si un attribut existe.
+ `NULL` – true si aucun attribut n’existe.
Utilisez ces opérateurs pour vérifier si un attribut existe ou non. À défaut de valeur à comparer, ne spécifiez pas `AttributeValueList`.
**Exemple**
L’expression suivante a la valeur true si l’attribut *Dimensions* existe.
```
...
"Dimensions": {
ComparisonOperator: "NOT_NULL"
}
...
```
### Opérateurs de comparaison avec une seule valeur d’attribut
+ `EQ` – true si un attribut est égal à une valeur.
`AttributeValueList` ne peut contenir qu’une seule valeur de type Chaîne, Nombre, Binaire, Ensemble de chaînes, Ensemble de nombres ou Ensemble de binaires. Si un élément contient une valeur d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas. Par exemple, la chaîne `"3"` n’est pas égale au nombre `3`. En outre, le nombre `3` n’est pas égal à l’ensemble de nombres `[3, 2, 1]`.
+ `NE` – true si un attribut n’est pas égal à une valeur.
`AttributeValueList` ne peut contenir qu’une seule valeur de type Chaîne, Nombre, Binaire, Ensemble de chaînes, Ensemble de nombres ou Ensemble de binaires. Si un élément contient une valeur d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas.
+ `LE` – true si un attribut est inférieur ou égal à une valeur.
`AttributeValueList` ne peut contenir qu’une seule valeur de type Chaîne, Nombre ou Binaire (pas Ensemble). Si un élément contient une `AttributeValue` d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas.
+ `LT` – true si un attribut est inférieur à une valeur.
`AttributeValueList` ne peut contenir qu’une seule valeur de type Chaîne, Nombre ou Binaire (pas Ensemble). Si un élément contient une valeur d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas.
+ `GE` – true si un attribut est supérieur ou égal à une valeur.
`AttributeValueList` ne peut contenir qu’une seule valeur de type Chaîne, Nombre ou Binaire (pas Ensemble). Si un élément contient une valeur d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas.
+ `GT` – true si un attribut est supérieur à une valeur.
`AttributeValueList` ne peut contenir qu’une seule valeur de type Chaîne, Nombre ou Binaire (pas Ensemble). Si un élément contient une valeur d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas.
+ `CONTAINS` – true si une valeur est présente dans un ensemble, ou si une valeur en contient une autre.
`AttributeValueList` ne peut contenir qu’une seule valeur de type Chaîne, Nombre ou Binaire (pas Ensemble). Si l’attribut cible de la comparaison est de type Chaîne, l’opérateur vérifie la présence d’une sous-chaîne correspondante. Si l’attribut cible de la comparaison est de type Binaire, l’opérateur vérifie la présence d’une sous-séquence de la cible correspondant à l’entrée. Si l’attribut cible de la comparaison est un ensemble, l’opérateur évalue true s’il trouve une correspondance exacte avec un membre de l’ensemble.
+ `NOT_CONTAINS` – true si une valeur *n’est pas* présente dans un ensemble, ou si une valeur n’en contient pas une autre.
`AttributeValueList` ne peut contenir qu’une seule valeur de type Chaîne, Nombre ou Binaire (pas Ensemble). Si l’attribut cible de la comparaison est de type Chaîne, l’opérateur vérifie l’absence de sous-chaîne correspondante. Si l’attribut cible de la comparaison est de type Binaire, l’opérateur vérifie l’absence d’une sous-séquence de la cible correspondant à l’entrée. Si l’attribut cible de la comparaison est un ensemble, l’opérateur évalue true s’il *ne trouve pas* une correspondance exacte avec un membre de l’ensemble.
+ `BEGINS_WITH` – true si les premiers caractères d’un attribut correspondent à la valeur fournie. N’utilisez pas cet opérateur pour comparer des nombres.
`AttributeValueList` ne peut contenir qu’une seule valeur de type Chaîne ou Binaire (pas Nombre ou Ensemble). L’attribut cible de la comparaison doit être une chaîne ou un binaire (pas un nombre ou un ensemble).
Utilisez ces opérateurs pour comparer un attribut avec une valeur. Vous devez spécifier une `AttributeValueList` contenant une valeur unique. Pour la plupart des opérateurs, cette valeur doit être un scalaire, mais les opérateurs `EQ` et `NE` prennent également en charge des ensembles.
**Exemples**
Les expressions suivantes prennent la valeur true si :
+ Le prix d’un produit est supérieur à 100.
```
...
"Price": {
ComparisonOperator: "GT",
AttributeValueList: [ {"N":"100"} ]
}
...
```
+ Une catégorie de produits commence par « Bo ».
```
...
"ProductCategory": {
ComparisonOperator: "BEGINS_WITH",
AttributeValueList: [ {"S":"Bo"} ]
}
...
```
+ Un produit est disponible en rouge, vert ou noir :
```
...
"Color": {
ComparisonOperator: "EQ",
AttributeValueList: [
[ {"S":"Black"}, {"S":"Red"}, {"S":"Green"} ]
]
}
...
```
**Note**
Lors de la comparaison de types de données d’ensemble, l’ordre des éléments n’a pas d’importance. DynamoDB renvoie uniquement les éléments ayant le même ensemble de valeurs, quel que soit l’ordre dans lequel vous les spécifiez dans votre demande.
### Opérateurs de comparaison avec deux valeurs d’attribut
+ `BETWEEN` – true si une valeur s’inscrit entre une limite inférieure et une limite supérieure, points de terminaison inclus.
`AttributeValueList` doit contenir deux éléments du même type, Chaîne, Nombre ou Binaire (pas Ensemble). Un attribut cible correspond si la valeur cible est supérieure ou égale au premier élément, et inférieure ou égale au deuxième. Si un élément contient une valeur d’un type différent de celui spécifié dans la demande, la valeur ne correspond pas.
Utilisez cet opérateur pour déterminer si une valeur d’attribut s’inscrit dans une plage. `AttributeValueList` doit contenir deux éléments scalaires du même type, Chaîne, Nombre ou Binaire.
**Exemple**
L’expression suivante prend la valeur true si le prix d’un produit est compris entre 100 et 200.
```
...
"Price": {
ComparisonOperator: "BETWEEN",
AttributeValueList: [ {"N":"100"}, {"N":"200"} ]
}
...
```
### Opérateurs de comparaison avec *n* valeurs d’attribut
+ `IN` – true si une valeur est égale à l’une des valeurs d’une liste énumérée. Seules les valeurs scalaires sont prises en charge dans la liste, pas les ensembles. Pour correspondre, l’attribut cible doit être du même type et avoir exactement la même valeur.
`AttributeValueList` peut contenir un ou plusieurs éléments de type Chaîne, Nombre ou Binaire (pas Ensemble). Ces attributs sont comparés à un attribut de type autre qu’Ensemble existant d’un élément. Si *des* éléments de l’ensemble en entrée sont présents dans l’attribut de l’élément, l’expression prend la valeur true.
`AttributeValueList` peut contenir une ou plusieurs valeurs de type Chaîne, Nombre ou Binaire (pas Ensemble). Pour correspondre, l’attribut cible de la comparaison doit être du même type et avoir exactement la même valeur. Une chaîne ne correspond jamais à un ensemble de chaîne.
Utilisez cet opérateur pour déterminer si la valeur fournie figure dans une liste énumérée. Vous pouvez spécifier n’importe quel nombre de valeurs scalaires dans `AttributeValueList`, mais elles doivent toutes être du même type de données.
**Exemple**
L’expression suivante prend la valeur true si la valeur d’*Id* est 201, 203 ou 205.
```
...
"Id": {
ComparisonOperator: "IN",
AttributeValueList: [ {"N":"201"}, {"N":"203"}, {"N":"205"} ]
}
...
```
## Utilisation de plusieurs conditions
DynamoDB permet de combiner plusieurs conditions pour former des expressions complexes. Pour cela, fournissez au moins deux expressions avec un opérateur [ConditionalOperator (héritage)](LegacyConditionalParameters.ConditionalOperator.md) facultatif.
Par défaut, lorsque vous spécifiez plusieurs conditions, *toutes* les conditions doivent avoir la valeur true pour que l’expression entière prenne la valeur true. En d’autres termes, une opération *AND* implicite a lieu.
**Exemple**
L’expression suivante prend la valeur true si un produit est un livre qui contient au moins 600 pages. Les résultats des deux conditions doivent être true, car elles sont implicitement associées avec l’opérateur logique *AND*.
```
...
"ProductCategory": {
ComparisonOperator: "EQ",
AttributeValueList: [ {"S":"Book"} ]
},
"PageCount": {
ComparisonOperator: "GE",
AttributeValueList: [ {"N":600"} ]
}
...
```
Vous pouvez utiliser l’opérateur [ConditionalOperator (héritage)](LegacyConditionalParameters.ConditionalOperator.md) pour préciser qu’une opération *AND* va avoir lieu. L’exemple suivant se comporte de la même manière que le précédent.
```
...
"ConditionalOperator" : "AND",
"ProductCategory": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"N":"Book"} ]
},
"PageCount": {
"ComparisonOperator": "GE",
"AttributeValueList": [ {"N":600"} ]
}
...
```
Vous pouvez également définir l’opérateur `ConditionalOperator` sur *OR*, ce qui signifie que le résultat d’*au moins une* des conditions doit être true.
**Exemple**
L’expression suivante prend la valeur true si un produit est un VTT (mountain bike), s’il est d’une marque particulière ou si son prix est supérieur à 100.
```
...
ConditionalOperator : "OR",
"BicycleType": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"S":"Mountain" ]
},
"Brand": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"S":"Brand-Company A" ]
},
"Price": {
"ComparisonOperator": "GT",
"AttributeValueList": [ {"N":"100"} ]
}
...
```
**Note**
Dans une expression complexe, les conditions sont traitées dans l’ordre, de la première à la dernière.
Vous ne pouvez pas utiliser les opérateurs logiques AND et OR dans une même expression.
## Autres opérateurs conditionnels
Dans les versions précédentes de DynamoDB, le paramètre `Expected` se comportait différemment pour les écritures conditionnelles. Chaque élément du mappage `Expected` représentait un nom d’attribut à vérifier par DynamoDB, ainsi que les éléments suivants :
+ `Value` – Valeur à laquelle comparer l’attribut.
+ `Exists` – Détermine si la valeur existe avant de tenter l’opération.
Les options `Value` et `Exists` sont toujours prises en charge dans DynamoDB. Toutefois, elles vous permettent uniquement de tester une condition d’égalité ou l’existence d’un attribut. Nous vous recommandons d’utiliser `ComparisonOperator` et `AttributeValueList` à la place, car ces options vous permettent de construire un éventail beaucoup plus large de conditions.
**Example**
Une opération `DeleteItem` peut vérifier si un livre n’est plus publié, et ne le supprimer que si le résultat de cette condition est true. Voici un exemple AWS CLI utilisant une condition héritée :
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{
"Id": {"N":"600"}
}' \
--expected '{
"InPublication": {
"Exists": true,
"Value": {"BOOL":false}
}
}'
```
L’exemple suivant fait la même chose, mais n’utilise pas de condition héritée :
```
aws dynamodb delete-item \
--table-name ProductCatalog \
--key '{
"Id": {"N":"600"}
}' \
--expected '{
"InPublication": {
"ComparisonOperator": "EQ",
"AttributeValueList": [ {"BOOL":false} ]
}
}'
```
**Example**
Une opération `PutItem` peut protéger contre le remplacement d’un élément existant par les mêmes attributs de clé primaire. Voici un exemple utilisant une condition héritée :
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item '{
"Id": {"N":"500"},
"Title": {"S":"Book 500 Title"}
}' \
--expected '{
"Id": { "Exists": false }
}'
```
L’exemple suivant fait la même chose, mais n’utilise pas de condition héritée :
```
aws dynamodb put-item \
--table-name ProductCatalog \
--item '{
"Id": {"N":"500"},
"Title": {"S":"Book 500 Title"}
}' \
--expected '{
"Id": { "ComparisonOperator": "NULL" }
}'
```
**Note**
Pour les conditions dans le mappage `Expected`, n’utilisez pas les options `Value` et `Exists` héritées avec `ComparisonOperator` et `AttributeValueList`. Si vous le faites, votre écriture conditionnelle échouera.