

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.

# Expressions de condition et de filtre, opérateurs et fonctions dans DynamoDB

Manipulez les données d’une table DynamoDB à l’aide des opérations `PutItem`, `UpdateItem` et `DeleteItem`. Pour ces opérations de manipulation de données, vous pouvez préciser une expression de condition afin de déterminer les éléments à modifier. Si l’expression de condition a la valeur true, l’opération aboutit. Sinon, l’opération échoue.

Cette section traite des fonctions et mots clés intégrés pour l’écriture des expressions de filtre et de condition dans Amazon DynamoDB. Pour en savoir plus sur les fonctions et la programmation avec DynamoDB, consultez [Programmation avec DynamoDB et le AWS Kits SDK](Programming.md) et le [guide de référence de l’API DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/).

**Topics**
+ [Syntaxe des expressions de filtre et de condition](#Expressions.OperatorsAndFunctions.Syntax)
+ [Comparaisons](#Expressions.OperatorsAndFunctions.Comparators)
+ [Fonctions](#Expressions.OperatorsAndFunctions.Functions)
+ [Évaluations logiques](#Expressions.OperatorsAndFunctions.LogicalEvaluations)
+ [Parenthèses](#Expressions.OperatorsAndFunctions.Parentheses)
+ [Priorité des conditions](#Expressions.OperatorsAndFunctions.Precedence)

## Syntaxe des expressions de filtre et de condition
<a name="Expressions.OperatorsAndFunctions.Syntax"></a>

Dans le résumé de syntaxe suivant, un {{operand}} peut être le suivant : 
+ Nom d’attribut de niveau supérieur, par exemple `Id`, `Title`, `Description` ou `ProductCategory`
+ Chemin d’accès au document référençant un attribut imbriqué

```
condition-expression ::=
      {{operand}} comparator {{operand}}
    | {{operand}} BETWEEN {{operand}} AND {{operand}}
    | {{operand}} IN ( {{operand}} (',' {{operand}} (, ...) ))
    | function
    | {{condition}} AND {{condition}}
    | {{condition}} OR {{condition}}
    | NOT {{condition}}
    | ( {{condition}} )

comparator ::=
    =
    | <>
    | <
    | <=
    | >
    | >=

function ::=
    attribute_exists ({{path}})
    | attribute_not_exists ({{path}})
    | attribute_type ({{path}}, {{type}})
    | begins_with ({{path}}, {{substr}})
    | contains ({{path}}, {{operand}})
    | size ({{path}})
```

## Comparaisons
<a name="Expressions.OperatorsAndFunctions.Comparators"></a>

Comparez un opérande à une valeur unique à l’aide de ces comparateurs :
+ `{{a}} = {{b}}` — Vrai si {{a}} est égal à {{b}}.
+ `{{a}} <> {{b}}` — Vrai si {{a}} n'est pas égal à {{b}}.
+ `{{a}} < {{b}}` — Vrai si {{a}} est inférieur à {{b}}.
+ `{{a}} <= {{b}}` — Vrai si {{a}} est inférieur ou égal à {{b}}.
+ `{{a}} > {{b}}` — Vrai si {{a}} est supérieur à {{b}}.
+ `{{a}} >= {{b}}` — Vrai si {{a}} est supérieur ou égal à {{b}}.

Comparez un opérande à une plage de valeurs ou une liste énumérée de valeurs à l’aide des mots clés `BETWEEN` et `IN` :
+ `{{a}} BETWEEN {{b}} AND {{c}}` — Vrai si {{a}} est supérieur ou égal à {{b}}, et inférieur ou égal à {{c}}.
+ `{{a}} IN ({{b}}, {{c}}, {{d}}) ` — Vrai si {{a}} est égal à n'importe quelle valeur de la liste, par exemple l'une des {{b}}, {{c}}, ou {{d}}. La liste peut comporter jusqu’à 100 valeurs séparées par des virgules.

Pour filtrer un attribut booléen, comparez-le à une valeur booléenne en utilisant `=` ou `<>` opérateur : vous ne pouvez pas référencer l'attribut seul en tant que condition. Indiquez la valeur booléenne dans les valeurs des attributs d'expression. Par exemple, l'expression de filtre suivante renvoie uniquement les éléments dont `isVisible` l'attribut est `true`:

```
--filter-expression "isVisible = :visible" \
--expression-attribute-values '{":visible": {"BOOL": true}}'
```

## Fonctions
<a name="Expressions.OperatorsAndFunctions.Functions"></a>

Déterminez si un attribut existe dans un élément ou évaluez la valeur d’un attribut à l’aide des fonctions suivantes. Ces noms de fonction respectent la casse. Pour un attribut imbriqué, vous devez fournir le chemin d’accès au document complet.



| Fonction | Description | 
| --- | --- | 
| `attribute_exists ({{path}})` | True si l’élément comporte l’attribut spécifié par `path`.<br />Un attribut dont la valeur stockée est de type nul (`NULL`) est toujours considéré comme existant, donc `attribute_exists` renvoie true pour cela. Ceci est différent d'un attribut absent de l'élément. Certains kits SDK et outils de mappage d'objets omettent les attributs qui ont une valeur nulle dans votre application au lieu de stocker `NULL` type, auquel cas l'attribut n'est pas présent et `attribute_exists` renvoie faux.<br />Exemple : Vérifier si un élément de la table `Product` a une image de vue de côté.+  `attribute_exists (#Pictures.#SideView)`  | 
| `attribute_not_exists ({{path}})` | True si l’attribut spécifié par `path` n’existe pas dans l’élément.<br />Exemple : Vérifier si un élément possède un attribut `Manufacturer`.+  `attribute_not_exists (Manufacturer)`  | 
| `attribute_type ({{path}}, {{type}})` | True si l’attribut à l’emplacement spécifié est d’un type de données particulier. Le paramètre `type` doit avoir l’une des valeurs suivantes :+  `S` – String (chaîne) <br />+  `SS` – String set (ensemble de chaînes) <br />+  `N` – Number (nombre) <br />+  `NS` – Number set (ensemble de nombres) <br />+  `B` – Binary (binaire) <br />+  `BS` – Binary set (ensemble de binaires) <br />+  `BOOL` – Boolean (booléen) <br />+  `NULL` – Null <br />+  `L` – List (liste) <br />+  `M` – Map (mappage) <br />Vous devez utiliser une valeur d’attribut d’expression pour le paramètre `type`.<br />Exemple : Vérifier si l’attribut `QuantityOnHand` est de type List (liste). Dans cet exemple, `:v_sub` est un espace réservé pour la chaîne `L`.+   `attribute_type (ProductReviews.FiveStar, :v_sub)` <br />Vous devez utiliser une valeur d’attribut d’expression pour le paramètre `type`.  | 
| `begins_with ({{path}}, {{substr}})` | True si l’attribut spécifié par `path` commence par une sous-chaîne particulière.<br />Exemple : Vérifier si les tout premiers caractères de l’URL de l’image de vue avant sont `http://`.+  `begins_with (Pictures.FrontView, :v_sub)` <br />La valeur d’attribut d’expression `:v_sub` est un espace réservé pour `http://`. | 
| `contains ({{path}}, {{operand}})` | True si l’attribut spécifié par `path` est l’un des attributs suivants :+  Une `String` qui comporte une sous-chaîne particulière <br />+  Un `Set` qui comporte un élément particulier au sein de l’ensemble <br />+  Une `List` qui comporte un élément particulier <br />Si l’attribut spécifié par `path` est de type `String`, `operand` doit être de type `String`. Si l’attribut spécifié par `path` est de type `Set`, l’`operand` doit être le type d’élément de l’ensemble.<br />Le chemin d’accès et l’opérande doivent être distincts. Autrement dit, `contains (a, a)` renvoie une erreur.<br />Exemple : Vérifier si l’attribut `Brand` comporte la sous-chaîne `Company`.+  `contains (Brand, :v_sub)` <br />La valeur d’attribut d’expression `:v_sub` est un espace réservé pour `Company`.<br />Exemple : Vérifier si le produit est disponible en rouge.+  `contains (Color, :v_sub)` <br />La valeur d’attribut d’expression `:v_sub` est un espace réservé pour `Red`. | 
| `size ({{path}})` | Renvoie un nombre qui représente la taille d’un attribut. Voici les types de données valides à utiliser avec `size`.<br /><br />Si l’attribut est de type `String`, `size` renvoie la longueur de la chaîne.<br />Exemple : Vérifier si la longueur de la chaîne `Brand` est inférieure ou égale à 20 caractères. La valeur d’attribut d’expression `:v_sub` est un espace réservé pour `20`.+  `size (Brand) <= :v_sub` <br /><br />Si l’attribut est de type `Binary`, `size` renvoie le nombre d’octets de la valeur d’attribut.<br />Exemple : supposez que l’élément `ProductCatalog` comporte un binary attribute nommé `VideoClip` qui comporte une courte vidéo du produit utilisé. L’expression suivante vérifie si `VideoClip` dépasse 64 000 octets. La valeur d’attribut d’expression `:v_sub` est un espace réservé pour `64000`. +  `size(VideoClip) > :v_sub` <br /><br />Si l’attribut est un type de données `Set`, `size` renvoie le nombre d’éléments dans l’ensemble. <br />Exemple : Vérifier si le produit est disponible dans plusieurs couleurs. La valeur d’attribut d’expression `:v_sub` est un espace réservé pour `1`.+  `size (Color) < :v_sub` <br /><br />Si l’attribut est de type `List` ou `Map`, `size` renvoie le nombre d’éléments enfants.<br />Exemple : Vérifier si le nombre de révisions `OneStar` a dépassé un certain seuil. La valeur d’attribut d’expression `:v_sub` est un espace réservé pour `3`.+  `size(ProductReviews.OneStar) > :v_sub`  | 

## Évaluations logiques
<a name="Expressions.OperatorsAndFunctions.LogicalEvaluations"></a>

Effectuez les évaluations logiques à l’aide des mots clés `AND`, `OR` et `NOT`. Dans la liste suivante, {{a}} et {{b}} représentent les conditions à évaluer.
+ `{{a}} AND {{b}}` — Vrai si {{a}} et {{b}} sont tous deux vrais.
+ `{{a}} OR {{b}}` — Vrai si l'un ou l'autre {{a}} ou {{b}} (ou les deux) sont vrais.
+ `NOT {{a}}` — Vrai si {{a}} est faux. Faux si {{a}} est vrai.

Voici un exemple de code avec AND dans une opération.

`dynamodb-local (*)> select * from exprtest where a > 3 and a < 5;`

## Parenthèses
<a name="Expressions.OperatorsAndFunctions.Parentheses"></a>

Modifiez la priorité d’une évaluation logique à l’aide de parenthèses. Supposons, par exemple, que les conditions {{a}} et {{b}} sont vrais, et cette condition {{c}} est faux. L’expression suivante a la valeur true :
+ `{{a}} OR {{b}} AND {{c}}`

Toutefois, si vous placez une condition entre parenthèses, elle est évaluée en premier. Par exemple, l’expression suivante a la valeur false :
+  `({{a}} OR {{b}}) AND {{c}}`

**Note**  
Vous pouvez imbriquer des parenthèses dans une expression. Les parenthèses les plus intérieures sont évaluées en premier.

Voici un exemple de code avec des parenthèses dans une évaluation logique.

`dynamodb-local (*)> select * from exprtest where attribute_type(b, string) or ( a = 5 and c = “coffee”);`

## Priorité des conditions
<a name="Expressions.OperatorsAndFunctions.Precedence"></a>

 DynamoDB évalue les conditions de gauche à droite à l’aide des règles de priorité suivantes :
+ `= <> < <= > >=`
+ `IN`
+ `BETWEEN`
+ `attribute_exists attribute_not_exists begins_with contains`
+ Parenthèses
+ `NOT`
+ `AND`
+ `OR`