Exemples de requêtes CTAS

Utilisez les exemples suivants pour créer des requêtes CTAS. Pour obtenir des informations sur la syntaxe CTAS, consultez CREATE TABLE AS.

Dans cette section :

Example: Duplicating a table by selecting all columns
Example: Selecting specific columns from one or more tables
Example: Creating an empty copy of an existing table
Example: Specifying data storage and compression formats
Example: Writing query results to a different format
Example: Creating unpartitioned tables
Example: Creating partitioned tables
Example: Creating bucketed and partitioned tables
Example: Creating an Iceberg table with Parquet data
Example: Creating an Iceberg table with Avro data

Exemple : duplication d'une table en sélectionnant toutes les colonnes

L'exemple suivant crée une table en copiant toutes les colonnes d'une table :


CREATE TABLE new_table AS 
SELECT * 
FROM old_table;

Dans la variation suivante du même exemple, votre instruction SELECT inclut également une clause WHERE. Dans ce cas, la requête sélectionne uniquement les lignes du tableau qui respectent la clause WHERE :


CREATE TABLE new_table AS 
SELECT * 
FROM old_table 
WHERE condition;

Exemple : sélection de colonnes spécifiques à partir d'une ou plusieurs tables

L'exemple suivant crée une nouvelle requête qui s'exécute sur un ensemble de colonnes à partir d'une autre table :


CREATE TABLE new_table AS 
SELECT column_1, column_2, ... column_n 
FROM old_table;

Cette variante du même exemple crée une nouvelle table à partir de colonnes spécifiques provenant de plusieurs tables :


CREATE TABLE new_table AS
SELECT column_1, column_2, ... column_n 
FROM old_table_1, old_table_2, ... old_table_n;

Exemple : création d'une copie vide d'une table existante

L'exemple suivant utilise WITH NO DATA pour créer une nouvelle table qui est vide et a le même schéma que la table d'origine :


CREATE TABLE new_table 
AS SELECT * 
FROM old_table
WITH NO DATA;

Exemple : spécification de formats de stockage et de compression des données

Grâce à CTAS, vous pouvez utiliser une table source dans un format de stockage afin de créer une autre table dans un format de stockage différent.

Utilisation de la propriété du format pour spécifier ORC, PARQUET, AVRO, JSON ou TEXTFILE comme format de stockage pour la nouvelle table.

Pour les formats de stockage PARQUET, ORC, TEXTFILE et JSON, utilisez la propriété write_compression pour spécifier le format de compression des données de la nouvelle table. Pour plus d'informations sur les formats de compression pris en charge par chaque format de fichier, consultez Prise en charge de la compression Athena.

L'exemple suivant indique que les données de la table new_table sont stockées au format Parquet et utilisent la compression Snappy. La compression par défaut pour Parquet est GZIP.


CREATE TABLE new_table
WITH (
      format = 'Parquet',
      write_compression = 'SNAPPY')
AS SELECT *
FROM old_table;

L'exemple suivant indique que les données de la table new_table sont stockées au format ORC et utilisent la compression Snappy. La compression par défaut pour ORC est ZLIB.


CREATE TABLE new_table
WITH (format = 'ORC',
      write_compression = 'SNAPPY')
AS SELECT *
FROM old_table ;

L'exemple suivant indique que les données de la table new_table sont stockées au format de fichier texte et utilisent la compression Snappy. La compression par défaut pour les formats de fichier texte et JSON est GZIP.


CREATE TABLE new_table
WITH (format = 'TEXTFILE',
      write_compression = 'SNAPPY')
AS SELECT *
FROM old_table ;

Exemple : écriture des résultats d'une requête dans un format différent

La requête CTAS suivante sélectionne tous les enregistrements depuis old_table, qui peuvent être stockés au format CSV ou dans un autre format, et crée une nouvelle table avec les données sous-jacentes enregistrées dans Simple Storage Service (Amazon S3) au format ORC :


CREATE TABLE my_orc_ctas_table
WITH (
      external_location = 's3://my_athena_results/my_orc_stas_table/',
      format = 'ORC')
AS SELECT * 
FROM old_table;

Exemple : création de tables non partitionnées

Les exemples suivants créent des tables qui ne sont pas partitionnées. Les données de table sont stockées dans des formats différents. Certains de ces exemples spécifient l'emplacement externe.

L'exemple suivant crée une requête CTAS qui stocke les résultats sous la forme d'un fichier texte :


CREATE TABLE ctas_csv_unpartitioned 
WITH (
     format = 'TEXTFILE', 
     external_location = 's3://my_athena_results/ctas_csv_unpartitioned/') 
AS SELECT key1, name1, address1, comment1
FROM table1;

Dans l'exemple suivant, les résultats sont stockés dans Parquet et l'emplacement par défaut des résultats est utilisé :


CREATE TABLE ctas_parquet_unpartitioned 
WITH (format = 'PARQUET') 
AS SELECT key1, name1, comment1
FROM table1;

Dans la requête suivante, la table est stockée au format JSON, et des colonnes spécifiques sont sélectionnées à partir des résultats de la table d'origine :


CREATE TABLE ctas_json_unpartitioned 
WITH (
     format = 'JSON',  
     external_location = 's3://my_athena_results/ctas_json_unpartitioned/') 
AS SELECT key1, name1, address1, comment1
FROM table1;

Dans l'exemple suivant, le format est ORC :


CREATE TABLE ctas_orc_unpartitioned 
WITH (
     format = 'ORC') 
AS SELECT key1, name1, comment1 
FROM table1;

Dans l'exemple suivant, le format est Avro :


CREATE TABLE ctas_avro_unpartitioned 
WITH (
     format = 'AVRO', 
     external_location = 's3://my_athena_results/ctas_avro_unpartitioned/') 
AS SELECT key1, name1, comment1
FROM table1;

Exemple : création de tables partitionnées

Les exemples suivants illustrent des requêtes CREATE TABLE AS SELECT pour les tables partitionnées dans différents formats de stockage, en utilisant partitioned_by et d'autres propriétés dans la clause WITH. Pour la syntaxe, consultez Propriétés de la table CTAS. Pour plus d'informations sur le choix de colonnes pour le partitionnement, consultez Partitionnement et compartimentation dans Athena.

Note

Répertoriez les colonnes de partition à la fin de la liste de colonnes dans l'instruction SELECT. Vous pouvez partitionner par plusieurs colonnes et avoir jusqu'à 100 combinaisons partition-compartiment uniques. Par exemple, vous pouvez avoir 100 partitions si aucun compartiment n'est spécifié.


CREATE TABLE ctas_csv_partitioned 
WITH (
     format = 'TEXTFILE',  
     external_location = 's3://my_athena_results/ctas_csv_partitioned/', 
     partitioned_by = ARRAY['key1']) 
AS SELECT name1, address1, comment1, key1
FROM tables1;


CREATE TABLE ctas_json_partitioned 
WITH (
     format = 'JSON', 
     external_location = 's3://my_athena_results/ctas_json_partitioned/', 
     partitioned_by = ARRAY['key1']) 
AS select name1, address1, comment1, key1 
FROM table1;

Exemple : création de tables partitionnées et compartimentées

L'exemple suivant illustre une requête CREATE TABLE AS SELECT qui utilise à la fois le partitionnement et la mise en compartiments pour stocker les résultats de requête dans Simple Storage Service (Amazon S3). Les résultats de la table sont partitionnés et mis en compartiments à l'aide de différentes colonnes. Athena prend en charge un maximum de 100 combinaisons uniques de compartiments et de partitions. Par exemple, si vous créez une table avec cinq compartiments, 20 partitions avec cinq compartiments chacune sont prises en charge. Pour la syntaxe, consultez Propriétés de la table CTAS.

Pour plus d'informations sur le choix de colonnes pour la mise en compartiments, consultez Partitionnement et compartimentation dans Athena.


CREATE TABLE ctas_avro_bucketed 
WITH (
      format = 'AVRO', 
      external_location = 's3://my_athena_results/ctas_avro_bucketed/', 
      partitioned_by = ARRAY['nationkey'], 
      bucketed_by = ARRAY['mktsegment'], 
      bucket_count = 3) 
AS SELECT key1, name1, address1, phone1, acctbal, mktsegment, comment1, nationkey 
FROM table1;

Exemple : Création d'une table Iceberg avec des données Parquet

L'exemple suivant crée une table Iceberg avec des fichiers de données Parquet. Les fichiers sont partitionnés par mois à l’aide de la colonne dt dans table1. L'exemple met à jour les propriétés de rétention de la table afin que 10 instantanés soient retenus par défaut sur chaque branche de la table. Les instantanés des 7 derniers jours sont également retenus. Pour plus d'informations sur les propriétés de table Iceberg dans Athena, consultez Propriétés de la table.


CREATE TABLE ctas_iceberg_parquet
WITH (table_type = 'ICEBERG',
      format = 'PARQUET', 
      location = 's3://my_athena_results/ctas_iceberg_parquet/', 
      is_external = false,
      partitioning = ARRAY['month(dt)'],
      vacuum_min_snapshots_to_keep = 10,
      vacuum_max_snapshot_age_seconds = 604800
   ) 
AS SELECT key1, name1, dt FROM table1;

Exemple : Création d'une table Iceberg avec des données Avro

L'exemple suivant crée une table Iceberg avec des fichiers de données Avro partitionnés par key1.


CREATE TABLE ctas_iceberg_avro
WITH ( format = 'AVRO', 
       location = 's3://my_athena_results/ctas_iceberg_avro/', 
       is_external = false,
       table_type = 'ICEBERG',
       partitioning = ARRAY['key1']) 
AS SELECT key1, name1, date FROM table1;

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Partitionnement et compartimentation

Utilisation de CTAS et INSERT INTO pour ETL