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. # Commande SELECT **Important** Amazon S3 Select n’est plus disponible pour les nouveaux clients. Les clients existants d’Amazon S3 Select peuvent continuer à utiliser cette fonctionnalité comme d’habitude. [En savoir plus](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) Amazon S3 Select prend en charge uniquement la commande SQL `SELECT`. Les clauses standard ANSI suivantes sont prises en charge pour `SELECT` : + `SELECT` liste + `FROM`Clause + `WHERE`Clause + `LIMIT`Clause **Note** Les requêtes Amazon S3 Select ne prennent actuellement pas en charge les sous-requêtes ni les jointures. ## SELECT liste La liste `SELECT` nomme les colonnes, fonctions et expressions que la requête doit renvoyer. La liste représente le résultat de la requête. ``` SELECT * SELECT projection1 AS column_alias_1, projection2 AS column_alias_2 ``` Le premier format `SELECT` avec `*` (astérisque) renvoie chaque ligne ayant transmis la clause `WHERE`, telle qu’elle. Le second format `SELECT` crée une ligne avec les expressions scalaires de sortie définies par l’utilisateur **`projection1`** et **`projection2`** pour chaque colonne. ## FROMClause Amazon S3 Select prend en charge les formes suivantes de la clause `FROM` : ``` FROM table_name FROM table_name alias FROM table_name AS alias ``` Dans chaque forme de la clause `FROM`, `table_name` est le `S3Object` qui est interrogé. Les utilisateurs provenant de bases de données relationnelles traditionnelles peuvent penser qu’il s’agit d’un schéma de base de données contenant plusieurs vues sur une table. Dans le langage SQL standard, la clause `FROM` crée des lignes qui sont filtrées dans la clause `WHERE` et projetées dans la liste `SELECT`. Pour les objets JSON stockés dans Amazon S3 Select, vous pouvez également utiliser les formes suivantes de la clause `FROM` : ``` FROM S3Object[*].path FROM S3Object[*].path alias FROM S3Object[*].path AS alias ``` En utilisant cette forme de la clause `FROM`, vous pouvez effectuer une sélection dans les tableaux ou les objets contenus dans un objet JSON. Vous pouvez spécifier `path` en utilisant l’un des formats suivants : + Par nom (dans un objet) : `.name` ou `['name']` + Par index (dans un tableau) : `[index]` + Par caractère générique (dans un objet) : `.*` + Par caractère générique (dans un tableau) : `[*]` **Note** Cette forme de la clause `FROM` fonctionne uniquement avec les objets JSON. Les caractères génériques émettent toujours au moins un enregistrement. Si aucun enregistrement ne correspond, Amazon S3 Select émet la valeur `MISSING`. Pendant la sérialisation de la sortie (après que la requête a fini de s’exécuter), Amazon S3 Select remplace les valeurs `MISSING` par des enregistrements vides. Les fonctions d’agrégation (`AVG`, `COUNT`, `MAX`, `MIN` et `SUM`) ignorent les valeurs `MISSING`. Si, lorsque vous utilisez un caractère générique, vous n’indiquez pas d’alias, vous pouvez faire référence à la ligne en utilisant le dernier élément du chemin. Par exemple, vous pouvez sélectionner tous les prix d’une liste de livres en utilisant la requête `SELECT price FROM S3Object[*].books[*].price`. Si le chemin se termine par un caractère générique plutôt qu’un nom, vous pouvez utiliser la valeur `_1` pour faire référence à la ligne. Par exemple, à la place de `SELECT price FROM S3Object[*].books[*].price`, vous pouvez utiliser la requête `SELECT _1.price FROM S3Object[*].books[*]`. Amazon S3 Select traite toujours un document JSON comme un tableau de valeurs de niveau racine. Par conséquent, même si l’objet JSON que vous interrogez ne contient qu’un seul élément racine, la clause `FROM` doit commencer par `S3Object[*]`. Toutefois, pour des raisons de compatibilité, Amazon S3 Select vous autorise à omettre le caractère générique si vous n’incluez pas de chemin. Ainsi, la clause complète `FROM S3Object` équivaut à `FROM S3Object[*] as S3Object`. Si vous incluez un chemin, vous devez également utiliser le caractère générique. Autrement dit, `FROM S3Object` et `FROM S3Object[*].path` sont deux clauses valides, mais pas `FROM S3Object.path`. **Example** **Exemples :** *Exemple 1* Cet exemple affiche les résultats quand le jeu de données et la requête suivants sont utilisés : ``` { "Rules": [ {"id": "1"}, {"expr": "y > x"}, {"id": "2", "expr": "z = DEBUG"} ]} { "created": "June 27", "modified": "July 6" } ``` ``` SELECT id FROM S3Object[*].Rules[*].id ``` ``` {"id":"1"} {} {"id":"2"} {} ``` Amazon S3 Select génère chaque résultat pour les raisons suivantes : + `{"id":"id-1"}` : `S3Object[0].Rules[0].id` a produit une correspondance. + `{}` : `S3Object[0].Rules[1].id` n’a pas produit de correspondance. Amazon S3 Select a donc émis `MISSING`, qui a ensuite été changé en enregistrement vide pendant la sérialisation de la sortie avant d’être renvoyé. + `{"id":"id-2"}` : `S3Object[0].Rules[2].id` a produit une correspondance. + `{}` : `S3Object[1]` n’a pas produit de correspondance sur `Rules`. Amazon S3 Select a donc émis `MISSING`, qui a ensuite été changé en enregistrement vide pendant la sérialisation de la sortie avant d’être renvoyé. Si vous ne voulez pas qu’Amazon S3 Select renvoie des enregistrements vides en l’absence de correspondance, vous pouvez faire un test avec la valeur `MISSING`. La requête suivante renvoie les mêmes résultats que la requête précédente, à la différence près que les valeurs vides sont omises : ``` SELECT id FROM S3Object[*].Rules[*].id WHERE id IS NOT MISSING ``` ``` {"id":"1"} {"id":"2"} ``` *Exemple 2* Cet exemple affiche les résultats quand le jeu de données et les requêtes suivants sont utilisés : ``` { "created": "936864000", "dir_name": "important_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": ".aws" }, { "name": "downloads" } ], "owner": "Amazon S3" } { "created": "936864000", "dir_name": "other_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": "my stuff" }, { "name": "backup" } ], "owner": "User" } ``` ``` SELECT d.dir_name, d.files FROM S3Object[*] d ``` ``` {"dir_name":"important_docs","files":[{"name":"."},{"name":".."},{"name":".aws"},{"name":"downloads"}]} {"dir_name":"other_docs","files":[{"name":"."},{"name":".."},{"name":"my stuff"},{"name":"backup"}]} ``` ``` SELECT _1.dir_name, _1.owner FROM S3Object[*] ``` ``` {"dir_name":"important_docs","owner":"Amazon S3"} {"dir_name":"other_docs","owner":"User"} ``` ## WHEREClause La clause `WHERE` suit la syntaxe suivante : ``` WHERE condition ``` La clause `WHERE` filtre les lignes en fonction de la `condition`. Une condition est une expression générant un résultat booléen. Seules les lignes pour lesquelles la condition a la valeur `TRUE` sont renvoyées dans les résultats. ## LIMITClause La clause `LIMIT` suit la syntaxe suivante : ``` LIMIT number ``` La clause `LIMIT` limite le nombre d’enregistrements que la requête devra renvoyer en fonction du `number`. ## Accès aux attributs Les clauses `SELECT` et `WHERE` peuvent faire référence à des enregistrements à l’aide d’une des méthodes présentées dans les sections suivantes, la méthode utilisée variant selon le format du fichier interrogé (CSV ou JSON). ### CSV + **Numéros de colonne** : vous pouvez faire référence à la *Nième* colonne d’une ligne avec un nom de colonne `_N`, où *`N`* correspond à la position de la colonne. Le compte de la position commence à 1. Par exemple, la première colonne est appelée `_1` et la deuxième colonne est appelée `_2`. Vous pouvez faire référence à une colonne sous la forme `_N` ou `alias._N`. Par exemple, `_2` et `myAlias._2` sont deux manières valides de faire référence à une colonne de la liste `SELECT` et la clause `WHERE`. + **En-têtes de colonne** – Concernant les objets au format CSV ayant une ligne d’en-tête, les en-têtes sont disponibles pour la liste `SELECT` et la clause `WHERE`. Comme dans le SQL traditionnel, dans les expressions de clause `SELECT` et `WHERE`, vous pouvez faire référence aux colonnes via `alias.column_name` ou `column_name`. ### JSON + **Document** – Vous pouvez accéder aux champs du document JSON sous la forme `alias.name`. Vous pouvez aussi accéder au champs imbriqués ; par exemple, `alias.name1.name2.name3`. + **Liste** : vous pouvez accéder aux éléments d’une liste JSON en utilisant des index de base zéro avec l’opérateur `[]`. Par exemple, vous pouvez accéder au second élément d’une liste sous la forme `alias[1]`. Vous pouvez combiner l’accès aux éléments de la liste avec des champs, par exemple, `alias.name1.name2[1].name3`. + **Exemples :** Considérez cet objet JSON comme un exemple de jeu de données : ``` {"name": "Susan Smith", "org": "engineering", "projects": [ {"project_name":"project1", "completed":false}, {"project_name":"project2", "completed":true} ] } ``` *Exemple 1* La requête suivante renvoie ces résultats : ``` Select s.name from S3Object s ``` ``` {"name":"Susan Smith"} ``` *Exemple 2* La requête suivante renvoie ces résultats : ``` Select s.projects[0].project_name from S3Object s ``` ``` {"project_name":"project1"} ``` ## Sensibilité à la casse des noms d’en-tête et d’attribut Avec Amazon S3 Select, vous pouvez utiliser des guillemets doubles pour indiquer que les en-têtes de colonne (pour les objets CSV) et les attributs (pour les objets JSON) sont sensibles à la casse. Sans guillemets doubles, les en-têtes et les attributs d’objet sont sensibles à la casse. Une erreur est envoyée en cas d’ambiguïté. Les exemples suivants sont 1) des objets Amazon S3 au format CSV avec les en-têtes de colonne spécifiés et avec `FileHeaderInfo` défini sur `"Use"` pour la demande de requête ou 2) des objets Amazon S3 au format JSON avec les attributs spécifiés. *Exemple n°1 :* l’objet interrogé possède l’en-tête ou l’attribut `NAME`. + L’expression suivante renvoie avec succès les valeurs de l’objet. Comme il n’y a pas de guillemets, la requête est sensible à la casse. ``` SELECT s.name from S3Object s ``` + L’expression suivante renvoie une erreur 400 `MissingHeaderName`. Comme il y a des guillemets, la requête est sensible à la casse. ``` SELECT s."name" from S3Object s ``` *Exemple n°2 :* l’objet Amazon S3 interrogé possède un en-tête ou un attribut avec `NAME` et un autre en-tête ou attribut avec `name`. + L'expression suivante renvoie une erreur 400 `AmbiguousFieldName`. Comme il n’y a pas de guillemets doubles, la requête est sensible à la casse, mais il y a deux correspondances : l’erreur est renvoyée. ``` SELECT s.name from S3Object s ``` + L'expression suivante renvoie avec succès les valeurs de l'objet. Comme il y a des guillemets, la requête est sensible à la casse sans qu’il y ait d’ambiguïté. ``` SELECT s."NAME" from S3Object s ``` ## Utilisation de mots-clés réservés comme termes définis par l’utilisateur Amazon S3 Select dispose d’un ensemble de mots-clés réservés nécessaires pour exécuter les expressions SQL utilisées pour interroger le contenu d’un objet. Les mots-clés réservés peuvent être des noms de fonctions, des types de données, des opérateurs, etc. Dans certains cas, les termes définis par l’utilisateur comme les en-têtes de colonnes (pour les fichiers CSV) ou les attributs (pour les objets JSON) peuvent entrer en conflit avec un mot-clé réservé. Lorsque cela se produit, vous devez utiliser des guillemets doubles pour indiquer que vous utilisez intentionnellement un terme défini par l’utilisateur qui est en conflit avec un mot-clé réservé. Si vous ne le faites pas, un erreur d’analyse 400 est émise. Pour obtenir la liste complète des mots-clés réservés, consultez [Mots-clés réservés](s3-select-sql-reference-keyword-list.md). L’exemple suivant est 1) un objet Amazon S3 au format CSV avec les en-têtes de colonne spécifiés et avec `FileHeaderInfo` défini sur `"Use"` pour la demande de requête ou 2) un objet Amazon S3 au format JSON avec les attributs spécifiés. *Exemple :* l’objet interrogé possède un en-tête ou un attribut `CAST`, qui est un mot-clé réservé. + L'expression suivante renvoie avec succès les valeurs de l'objet. Comme les guillemets sont utilisés dans la requête, S3 Select utilise l’en-tête ou l’attribut défini par l’utilisateur. ``` SELECT s."CAST" from S3Object s ``` + L’expression suivante renvoie une erreur d’analyse 400. Comme aucun guillemet n’est utilisé dans la requête, `CAST` entre en conflit avec un mot-clé réservé. ``` SELECT s.CAST from S3Object s ``` ## Expressions scalaires Au sein de la clause `WHERE` et de la liste `SELECT`, vous pouvez disposez d’*expressions scalaires* SQL, qui sont des expressions qui renvoient des valeurs scalaires. Elles sont au format suivant : + ***`literal`*** Littéral SQL. + ***`column_reference`*** Référence à une colonne au format `column_name` ou `alias.column_name`. + **`unary_op`** **`expression`** Dans ce cas, ****`unary_op`**** est un opérateur unaire SQL. + **`expression`** **`binary_op`** ***`expression`*** Dans ce cas, ****`binary_op`**** est un opérateur binaire SQL. + **`func_name`** Dans ce cas, **`func_name`** est le nom de la fonction scalaire à invoquer. + ***`expression`*** `[ NOT ] BETWEEN` ****`expression`**** `AND` ****`expression`**** + ***`expression`*** `LIKE` ****`expression`**** [ `ESCAPE` ***`expression`*** ]