SELECT - Amazon Athena
RésuméParamètresObtention des emplacements de fichiers pour les données source dans Simple Storage Service (Amazon S3) Échappement de guillemets simplesRessources supplémentaires

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 et Exécuter des requêtes SQL dans Amazon Athena. 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.

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 auxquels il est possible d'échapper dans les instructions SQL SELECT.

Paramètres

[ WITH with_query [, ....] ]

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.

[TOUS | DISTINCT] select_expression

select_expression détermine les lignes à sélectionner. A select_expression peut utiliser l'un des formats suivants :

expression [ [ AS ] column_alias ] [, ...]
row_expression.* [ AS ( column_alias [, ...] ) ]
relation.*
*

  • La expression [ [ AS ] column_alias ] syntaxe spécifie une colonne de sortie. La [AS] column_alias syntaxe facultative spécifie un nom de titre personnalisé à utiliser pour la colonne dans la sortie.

  • Pourrow_expression.* [ AS ( column_alias [, ...] ) ], row_expression est une expression arbitraire du type de donnéesROW. Les champs de la ligne définissent les colonnes de sortie à inclure dans le résultat.

  • En effetrelation.*, les colonnes de relation sont incluses dans le résultat. Cette syntaxe n'autorise pas l'utilisation d'alias de colonne.

  • L'astérisque * indique que toutes les colonnes doivent être incluses dans le jeu de résultats.

  • Dans le jeu de résultats, l'ordre des colonnes est identique à l'ordre de leur spécification par l'expression de sélection. Si une expression de sélection renvoie plusieurs colonnes, l'ordre des colonnes suit 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 champs de colonne ou de ligne préexistants. Si l'expression select ne comporte pas de nom de colonne, les noms de colonnes anonymes indexés à zéro (_col0,_col1,_col2, ...) sont affichés dans la sortie.

  • 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_item [, ...]

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 | DISTINCT ] grouping_expressions [, ...] ]

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.

[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] union_query] ]

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 | DESC ] [ NULLS FIRST | 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. L'ordre de tri par défaut est croissant (ASC). L'ordre null par défaut est NULLS LAST, que l'ordre soit croissant ou décroissant.

[ OFFSET count [ ROW | 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 | 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 | 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_or_map) [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 ? 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écuter des requêtes SQL dans Amazon Athena
Utilisation de SELECT pour créer une table Création d'une table à partir des résultats d'une requête (CTAS)
Insertion de données à partir d'une requête SELECT dans une autre table INSERT INTO
Utilisation de fonctions intégrées dans les instructions SELECT Fonctions dans Amazon Athena
Utilisation de fonctions définies par l'utilisateur dans les instructions SELECT Requête avec fonctions définies par l'utilisateur
Interrogation des métadonnées d'un catalogue de données Interrogez le AWS Glue Data Catalog