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. # SELECT Récupère les lignes de données de zéro ou plusieurs tables. **Note** Cette rubrique fournit des informations récapitulatives à titre de référence. Cette documentation n'a pas pour objectif de couvrir en détail l'utilisation de `SELECT` et du langage SQL. Pour des informations sur l'utilisation de SQL spécifique à Athena, voir [Considérations et limitations relatives aux requêtes SQL dans Amazon Athena](other-notable-limitations.md) et [Exécution de requêtes SQL dans Amazon Athena](querying-athena-tables.md). En guise d'exemple en matière de création d'une base de données, de création d'une table et d'exécution d'une requête `SELECT` sur la table dans Athena, voir [Mise en route](getting-started.md). ## Résumé ``` [ WITH with_query [, ...] ] SELECT [ ALL | DISTINCT ] select_expression [, ...] [ FROM from_item [, ...] ] [ WHERE condition ] [ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ] [ HAVING condition ] [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ] [ ORDER BY expression [ ASC | DESC ] [ NULLS FIRST | NULLS LAST] [, ...] ] [ OFFSET count [ ROW | ROWS ] ] [ LIMIT [ count | ALL ] ] ``` **Note** Les mots réservés dans les instructions SQL SELECT doivent être placés entre guillemets doubles. Pour de plus amples informations, veuillez consulter [Mots-clés réservés à échapper dans les instructions SQL SELECT](reserved-words.md#list-of-reserved-words-sql-select). ## Parameters **[ WITH with\$1query [, ....] ]** Vous pouvez utiliser `WITH` pour aplatir les requêtes imbriquées ou pour simplifier les sous-requêtes. L'utilisation de la clause `WITH` pour créer des requêtes récursives est prise en charge à partir de la version 3 du moteur Athena. La profondeur de récursivité maximale est de 10. La clause `WITH` précède la liste `SELECT` dans une requête et définit une ou plusieurs sous-requêtes pour une utilisation au sein de la requête `SELECT`. Chaque sous-requête définit une table temporaire, similaire à la définition d'une vue, que vous pouvez référencer dans la clause `FROM`. Les tables sont utilisées uniquement lorsque la requête s'exécute. La syntaxe de `with_query` est la suivante : ``` subquery_table_name [ ( column_name [, ...] ) ] AS (subquery) ``` Où : + `subquery_table_name` est un nom unique d'une table temporaire qui définit les résultats de la sous-requête de la clause `WITH`. Chaque `subquery` doit avoir un nom de table qui peut être référencé dans la clause `FROM`. + `column_name [, ...]` est une liste facultative de noms de colonne de sortie. Le nombre de noms de colonne doit être égal ou inférieur au nombre de colonnes défini par `subquery`. + `subquery` désigne n'importe quelle instruction de requête. **[ ALL \$1 DISTINCT ] select\$1expression** `select_expression` détermine les lignes à sélectionner. Un élément `select_expression` peut se présenter sous l’un des formats suivants : ``` expression [ [ AS ] column_alias ] [, ...] ``` ``` row_expression.* [ AS ( column_alias [, ...] ) ] ``` ``` relation.* ``` ``` * ``` + La syntaxe `expression [ [ AS ] column_alias ]` spécifie une colonne de sortie. La syntaxe facultative `[AS] column_alias` spécifie un nom d’en-tête personnalisé à utiliser pour la colonne dans la sortie. + Pour `row_expression.* [ AS ( column_alias [, ...] ) ]`, `row_expression` est une expression arbitraire de type de données `ROW`. Les champs de la ligne définissent les colonnes de sortie à inclure dans le résultat. + Pour `relation.*`, les colonnes de `relation` sont incluses dans le résultat. Cette syntaxe ne permet pas l’utilisation d’alias de colonne. + L’astérisque `*` indique que le jeu de résultats doit inclure toutes les colonnes. + Dans le jeu de résultats, les colonnes s’affichent dans l’ordre dans lequel elles sont spécifiées dans l’expression de sélection. Si une expression de sélection renvoie plusieurs colonnes, elles suivent l’ordre utilisé dans la relation source ou l’expression de type ligne. + Lorsque des alias de colonne sont spécifiés, ils remplacent les noms de champ de colonne ou de ligne préexistants. Si l’expression de sélection ne comporte pas de nom de colonne, la sortie contient des noms de colonne anonymes indexés sur zéro (`_col0`, `_col1`, `_col2, ...`). + `ALL` est la valeur par défaut. L'utilisation d'`ALL` est traité de la même façon que si la valeur avait été omise ; toutes les lignes de toutes les colonnes sont sélectionnées et les doublons sont conservés. + Utilisez `DISTINCT` pour renvoyer uniquement des valeurs distinctes lorsqu'une colonne contient des valeurs en double. **FROM from\$1item [, ...]** Indique les entrées de la requête, où `from_item` peut être une vue, une construction de jointure ou une sous-requête comme décrit ci-dessous. L'élément `from_item` peut être l'un ou l'autre : + `table_name [ [ AS ] alias [ (column_alias [, ...]) ] ]` Où `table_name` est le nom de la table cible à partir de laquelle sélectionner les lignes, où `alias` est le nom pour donner la sortie de l'instruction `SELECT` et où `column_alias` définit les colonnes de l'`alias` spécifié. **-OU-** + `join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]` Où `join_type` est l'un des éléments suivants : + `[ INNER ] JOIN` + `LEFT [ OUTER ] JOIN` + `RIGHT [ OUTER ] JOIN` + `FULL [ OUTER ] JOIN` + `CROSS JOIN` + `ON join_condition | USING (join_column [, ...])` Où l'utilisation de `join_condition` vous permet de spécifier les noms de colonne pour les clés de jointure de plusieurs tables et où l'utilisation de `join_column` nécessite `join_column` pour exister dans les deux tables. **[ Condition WHERE ]** Filtre les résultats en fonction de la `condition` que vous spécifiez, où `condition` a généralement la syntaxe suivante. ``` column_name operator value [[[AND | OR] column_name operator value] ...] ``` Il *operator* peut s'agir de l'un des comparateurs `=``>`,,`<`,`>=`, `<=``<>`,`!=`. Les expressions de sous-requêtes suivantes peuvent également être utilisées dans la clause `WHERE`. + `[NOT] BETWEEN integer_A AND integer_B` – Spécifie une plage entre deux entiers, comme dans l'exemple suivant. Si le type de données de colonne est `varchar`, la colonne doit d'abord être convertie en entier. ``` SELECT DISTINCT processid FROM "webdata"."impressions" WHERE cast(processid as int) BETWEEN 1500 and 1800 ORDER BY processid ``` + `[NOT] LIKE value` – Recherche le motif spécifié. Utilisez le signe de pourcentage (`%`) comme caractère générique, comme dans l'exemple suivant. ``` SELECT * FROM "webdata"."impressions" WHERE referrer LIKE '%.org' ``` + `[NOT] IN (value[, value[, ...])` – Spécifie une liste de valeurs possibles pour une colonne, comme dans l'exemple suivant. ``` SELECT * FROM "webdata"."impressions" WHERE referrer IN ('example.com','example.net','example.org') ``` **[ GROUP BY [ ALL \$1 DISTINCT ] grouping\$1expressions [, ...] ]** Divise la sortie de l'instruction `SELECT` en lignes avec les valeurs correspondantes. `ALL` et `DISTINCT` déterminent si les ensembles de groupement dupliqués produisent chacun des lignes de sortie distinctes. Si ce paramètre n'est pas spécifié, `ALL` est utilisé. `grouping_expressions` vous permettent d'effectuer des opérations de regroupement complexes. Vous pouvez utiliser des opérations de regroupement complexes pour effectuer une analyse qui nécessite une agrégation sur plusieurs ensembles de colonnes dans une seule requête. L'élément `grouping_expressions` peut être une fonction quelconque, telle que `SUM`, `AVG` ou `COUNT`, exécutée sur les colonnes d'entrée. Les expressions `GROUP BY` peuvent grouper les sorties par noms de colonne d'entrée qui n'apparaissent pas dans la sortie de l'instruction `SELECT`. Toutes les expressions de sortie doivent être des fonctions d'agrégat ou des colonnes présentes dans la clause `GROUP BY`. Vous pouvez utiliser une seule requête pour effectuer une analyse qui nécessite l'agrégation de plusieurs jeux de colonnes. Athena prend en charge les agrégations complexes à l'aide de `GROUPING SETS`, `CUBE` et `ROLLUP`. `GROUP BY GROUPING SETS` spécifie plusieurs listes de colonnes à regrouper. `GROUP BY CUBE` génère tous les ensembles de regroupement possibles pour un ensemble de colonnes donné. `GROUP BY ROLLUP` génère tous les sous-totaux possibles pour un ensemble de colonnes donné. Les opérations de regroupement complexes ne prennent pas en charge le regroupement sur des expressions composées de colonnes d'entrée. Seuls les noms de colonnes sont autorisés. Vous pouvez souvent utiliser `UNION ALL` pour obtenir les mêmes résultats que ces opérations `GROUP BY`, mais les requêtes qui utilisent `GROUP BY` ont l'avantage de lire les données une seule fois, tandis qu'`UNION ALL` lit les données sous-jacentes trois fois et peut générer des résultats incohérents lorsque la source de données est soumise à modification. **[ HAVING condition ]** Utilisé avec les fonctions d'agrégat et la clause `GROUP BY`. Détermine quels groupes sont sélectionnés, en éliminant ceux qui ne satisfont pas `condition`. Le filtrage se produit après le calcul des groupes et des agrégats. **[ \$1 UNION \$1 INTERSECT \$1 EXCEPT \$1 [ ALL \$1 DISTINCT ] union\$1query] ]** `UNION`, `INTERSECT` et `EXCEPT` combinent les résultats de plus d'une instruction `SELECT` en une seule requête. `ALL` et `DISTINCT` contrôlent l'unicité des lignes incluses dans le jeu de résultats final. `UNION` combine les lignes résultant de la première requête avec les lignes résultant de la deuxième requête. Pour éliminer les doublons, `UNION` construit une table de hachage, qui consomme de la mémoire. Pour de meilleures performances, envisagez d'utiliser `UNION ALL` si votre requête ne nécessite pas l'élimination des doublons. Plusieurs clauses `UNION` sont traitées de gauche à droite, sauf si vous utilisez des parenthèses pour définir explicitement l'ordre de traitement. `INTERSECT` renvoie uniquement les lignes qui sont présentes dans les résultats de la première et de la seconde requête. `EXCEPT` renvoie les lignes des résultats de la première requête, en excluant les lignes trouvées par la seconde requête. `ALL` entraîne l'inclusion de toutes les lignes, même si elles sont identiques. `DISTINCT` fait en sorte que seules les lignes uniques soient incluses dans le jeu de résultats combinés. **[ ORDER BY expression [ ASC \$1 DESC ] [ NULLS FIRST \$1 NULLS LAST] [, ...] ]** Trie un jeu de résultats par une ou `expression` de sortie. Lorsque la clause contient plusieurs expressions, les résultats sont triés en fonction de la première `expression`. Ensuite, la seconde `expression` est appliquée aux lignes qui possèdent des valeurs correspondantes à partir de la première expression, et ainsi de suite. Chaque `expression` peut spécifier les colonnes à partir de `SELECT` ou un nombre ordinal pour une colonne de sortie par son emplacement, à partir de un. `ORDER BY` est évaluée comme la dernière étape après toute clause `GROUP BY` ou `HAVING`. `ASC` et `DESC` déterminent si les résultats sont triés dans l'ordre croissant ou décroissant. Par défaut, ils sont triés dans l’ordre croissant (`ASC`). L'ordre null par défaut est `NULLS LAST`, que l'ordre soit croissant ou décroissant. **[ OFFSET count [ ROW \$1 ROWS ] ]** Utilisation de la clause `OFFSET` pour ignorer un certain nombre de lignes principales du jeu de résultats. Si la clause `ORDER BY` est présente, la clause `OFFSET` est évaluée sur un jeu de résultats triés, et le jeu reste trié après que les lignes ignorées aient été écartées. Si la requête n'a pas de clause `ORDER BY`, le choix des lignes à écarter est arbitraire. Si le nombre spécifié par `OFFSET` est égal ou dépasse la taille du jeu de résultat, le résultat final est vide. **LIMIT [ count \$1 ALL ]** Limite le nombre de lignes dans le jeu de résultats à `count`. `LIMIT ALL` est identique à l'omission de la clause `LIMIT`. Si la requête n'a pas de clause `ORDER BY`, les résultats sont arbitraires. **TABLESAMPLE [ BERNOULLI \$1 SYSTEM ] (pourcentage)** Opérateur facultatif pour sélectionner les lignes d'une table à partir d'une méthode d'échantillonnage. `BERNOULLI` sélectionne chaque ligne à inclure dans l'exemple de la table avec une probabilité de `percentage`. Tous les blocs physiques de la table sont analysés, et certaines lignes sont ignorées en fonction de la comparaison entre le `percentage` de l'échantillon et une valeur aléatoire calculée lors de l'exécution. Avec `SYSTEM`, la table est divisée en segments logiques de données, et la table est échantillonnée au niveau de cette granularité. Soit toutes les lignes d'un segment sont sélectionnées, soit le segment est ignoré en fonction de la comparaison entre l'échantillon `percentage` et une valeur aléatoire calculée lors de l'exécution. L'échantillonnage `SYSTEM` dépend du connecteur. Cette méthode ne garantit pas de probabilités d'échantillonnage indépendantes. **[ UNNEST (array\$1or\$1map) [WITH ORDINALITY] ]** Développe un tableau ou une carte dans une relation. Les tableaux sont développés en une seule colonne. Les cartes sont développées en deux colonnes (*clé*, *valeur*). Vous pouvez utiliser `UNNEST` avec plusieurs arguments, qui sont développés en plusieurs colonnes avec autant de lignes que l'argument ayant la plus haute cardinalité. Les autres colonnes sont complétées avec les valeurs NULL. La clause `WITH ORDINALITY` ajoute une colonne « ordinality » à la fin. `UNNEST` est généralement utilisé avec une clause `JOIN` et peut référencer les colonnes à partir des relations sur le côté gauche de la jointure `JOIN`. ## Obtention des emplacements de fichiers pour les données source dans Simple Storage Service (Amazon S3) Pour connaître l'emplacement du fichier Simple Storage Service (Amazon S3) pour les données d'une ligne de table, vous pouvez utiliser `"$path"` dans une requête `SELECT`, comme dans l'exemple suivant : ``` SELECT "$path" FROM "my_database"."my_table" WHERE year=2019; ``` Cela renvoie un résultat comme le suivant : ``` s3://amzn-s3-demo-bucket/datasets_mytable/year=2019/data_file1.json ``` Pour obtenir une liste unique et triée des chemins d'accès aux noms de fichiers S3 pour les données d'une table, vous pouvez utiliser `SELECT DISTINCT` et `ORDER BY`, comme dans l'exemple suivant. ``` SELECT DISTINCT "$path" AS data_source_file FROM sampledb.elb_logs ORDER By data_source_file ASC ``` Pour renvoyer uniquement les noms de fichiers sans le chemin d'accès, vous pouvez passer `"$path"` comme paramètre à une fonction `regexp_extract`, comme dans l'exemple suivant. ``` SELECT DISTINCT regexp_extract("$path", '[^/]+$') AS data_source_file FROM sampledb.elb_logs ORDER By data_source_file ASC ``` Pour renvoyer les données d'un fichier spécifique, spécifiez le fichier dans la clause `WHERE`, comme dans l'exemple suivant. ``` SELECT *,"$path" FROM my_database.my_table WHERE "$path" = 's3://amzn-s3-demo-bucket/my_table/my_partition/file-01.csv' ``` Pour plus d'informations et d'exemples, consultez l'article [Comment voir le fichier source Simple Storage Service (Amazon S3) pour une ligne dans une table Athena ?](https://aws.amazon.com/premiumsupport/knowledge-center/find-s3-source-file-athena-table-row/) du Centre de connaissances. **Note** Dans Athena, les colonnes de métadonnées masquées `$bucket`, `$file_modified_time`, `$file_size` et `$partition` ne sont pas prises en charge pour les vues. ## Échappement de guillemets simples Pour échapper un guillemet simple, faites-le précéder d'un autre guillemet simple, comme dans l'exemple suivant. Ne confondez pas ceci avec un guillemet double. ``` Select 'O''Reilly' ``` **Résultats** `O'Reilly` ## Ressources supplémentaires Pour plus d'informations sur l'utilisation des instructions `SELECT` dans Athena, consultez les ressources suivantes. | Pour plus d'informations à ce sujet | Voir ce qui suit | | --- | --- | | Exécution de requêtes dans Athena | [Exécution de requêtes SQL dans Amazon Athena](querying-athena-tables.md) | | Utilisation de SELECT pour créer une table | [Création d’une table à partir des résultats des requêtes (CTAS)](ctas.md) | | Insertion de données à partir d'une requête SELECT dans une autre table | [INSERT INTO](insert-into.md) | | Utilisation de fonctions intégrées dans les instructions SELECT | [Fonctions dans Amazon Athena](functions.md) | | Utilisation de fonctions définies par l'utilisateur dans les instructions SELECT | [Interrogation avec des fonctions définies par l’utilisateur](querying-udf.md) | | Interrogation des métadonnées d'un catalogue de données | [Interrogez le AWS Glue Data Catalog](querying-glue-catalog.md) |