# Ejemplos de consultas CTAS
<a name="ctas-examples"></a>

Utilice los siguientes ejemplos para crear consultas CTAS. Para obtener información sobre la sintaxis CTAS, consulte [CREATE TABLE AS](create-table-as.md).

En esta sección: 
+  [Example: Duplicating a table by selecting all columns](#ctas-example-dupe-table) 
+  [Example: Selecting specific columns from one or more tables](#ctas-example-specify-columns) 
+  [Example: Creating an empty copy of an existing table](#ctas-example-empty-table) 
+  [Example: Specifying data storage and compression formats](#ctas-example-compression) 
+  [Example: Writing query results to a different format](#ctas-example-format) 
+  [Example: Creating unpartitioned tables](#ctas-example-unpartitioned) 
+  [Example: Creating partitioned tables](#ctas-example-partitioned) 
+  [Example: Creating bucketed and partitioned tables](#ctas-example-bucketed) 
+  [Example: Creating an Iceberg table with Parquet data](#ctas-example-iceberg-parquet) 
+  [Example: Creating an Iceberg table with Avro data](#ctas-example-iceberg-avro) 
+  [Example: Creating an S3 table using CTAS](#ctas-example-s3-table) 

**Example Ejemplo : duplicación de una tabla mediante la selección de todas las columnas**  
En el siguiente ejemplo se crea una tabla copiando todas las columnas de una tabla:  

```
CREATE TABLE new_table AS 
SELECT * 
FROM old_table;
```
En la siguiente variante del ejemplo anterior, la instrucción `SELECT` incluye también una cláusula `WHERE`. En este caso, la consulta solo selecciona las filas de la tabla que satisfacen la cláusula `WHERE`:   

```
CREATE TABLE new_table AS 
SELECT * 
FROM old_table 
WHERE condition;
```

**Example Ejemplo : selección de columnas específicas de una o más tablas**  
En el siguiente ejemplo se crea una nueva consulta que se ejecuta en un conjunto de columnas de otra tabla:  

```
CREATE TABLE new_table AS 
SELECT column_1, column_2, ... column_n 
FROM old_table;
```
Esta variante del mismo ejemplo crea una nueva tabla a partir de columnas específicas de varias tablas:   

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

**Example Ejemplo : creación de una copia vacía de una tabla existente**  
En el siguiente ejemplo se utiliza `WITH NO DATA` para crear una nueva tabla, que está vacía y tiene el mismo esquema que la tabla original:  

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

**Example Ejemplo : especificación de los formatos de almacenamiento y compresión de datos**  
Con CTAS, puede utilizar una tabla de origen en un formato de almacenamiento para crear otra tabla en un formato de almacenamiento diferente.   
Utilice la propiedad `format` para especificar `ORC`, `PARQUET`, `AVRO`, `JSON`o `TEXTFILE` como formato de almacenamiento para la nueva tabla.   
Para los formatos de almacenamiento `PARQUET`, `ORC`, `TEXTFILE` y `JSON`, utilice la propiedad `write_compression` para especificar el formato de compresión para los datos de la nueva tabla. Para obtener información sobre los formatos de compresión que admite cada formato de archivo, consulte [Uso de la compresión en Athena](compression-formats.md).  
En el siguiente ejemplo se especifica que los datos de la tabla `new_table` se almacenen en formato Parquet y utilicen la compresión Snappy. La compresión predeterminada de Parquet es `GZIP`.  

```
CREATE TABLE new_table
WITH (
      format = 'Parquet',
      write_compression = 'SNAPPY')
AS SELECT *
FROM old_table;
```
En el siguiente ejemplo se especifica que los datos de la tabla `new_table` se almacenen en formato ORC y utilicen la compresión Snappy. La compresión predeterminada de ORC es ZLIB.  

```
CREATE TABLE new_table
WITH (format = 'ORC',
      write_compression = 'SNAPPY')
AS SELECT *
FROM old_table ;
```
En el siguiente ejemplo se especifica que los datos de la tabla `new_table` se almacenen en formato de documento de texto y utilicen la compresión Snappy. La compresión predeterminada de los formatos de documento de texto y JSON es GZIP.  

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

**Example Ejemplo : escritura de los resultados de la consulta en un formato diferente**  
La siguiente consulta CTAS selecciona todos los registros de `old_table`, que podrían estar almacenados en CSV u otro formato, y crea una nueva tabla con los datos subyacentes guardados en Amazon S3 en formato ORC:   

```
CREATE TABLE my_orc_ctas_table
WITH (
      external_location = 's3://amzn-s3-demo-bucket/my_orc_stas_table/',
      format = 'ORC')
AS SELECT * 
FROM old_table;
```

**Example Ejemplo : creación de tablas no particionadas**  
Los siguientes ejemplos crean tablas que no están particionadas. Los datos de las tablas se almacenan en diferentes formatos. Algunos de estos ejemplos especifican la ubicación externa.   
En el siguiente ejemplo se crea una consulta CTAS que almacena los resultados como un archivo de texto:  

```
CREATE TABLE ctas_csv_unpartitioned 
WITH (
     format = 'TEXTFILE', 
     external_location = 's3://amzn-s3-demo-bucket/ctas_csv_unpartitioned/') 
AS SELECT key1, name1, address1, comment1
FROM table1;
```
En el siguiente ejemplo, los resultados se almacenan en Parquet y se utiliza la ubicación predeterminada para los resultados:  

```
CREATE TABLE ctas_parquet_unpartitioned 
WITH (format = 'PARQUET') 
AS SELECT key1, name1, comment1
FROM table1;
```
En la siguiente consulta, la tabla se almacena en JSON y se seleccionan columnas específicas de los resultados de la tabla original:  

```
CREATE TABLE ctas_json_unpartitioned 
WITH (
     format = 'JSON',  
     external_location = 's3://amzn-s3-demo-bucket/ctas_json_unpartitioned/') 
AS SELECT key1, name1, address1, comment1
FROM table1;
```
En el siguiente ejemplo, el formato es ORC:  

```
CREATE TABLE ctas_orc_unpartitioned 
WITH (
     format = 'ORC') 
AS SELECT key1, name1, comment1 
FROM table1;
```
En el siguiente ejemplo, el formato es Avro:  

```
CREATE TABLE ctas_avro_unpartitioned 
WITH (
     format = 'AVRO', 
     external_location = 's3://amzn-s3-demo-bucket/ctas_avro_unpartitioned/') 
AS SELECT key1, name1, comment1
FROM table1;
```

**Example Ejemplo : creación de tablas particionadas**  
Los siguientes ejemplos muestran consultas `CREATE TABLE AS SELECT` para tablas con particiones en diferentes formatos de almacenamiento, que utilizan `partitioned_by` y otras propiedades en la cláusula `WITH`. Para ver la sintaxis, consulte [Propiedades de la tabla CTAS](create-table-as.md#ctas-table-properties). Para obtener más información sobre cómo elegir las columnas para crear particiones, consulte [Uso de particiones y asignación de buckets](ctas-partitioning-and-bucketing.md).  
Indique las columnas particionadas al final de la lista de columnas en la instrucción `SELECT`. Puede particionar por varias columnas y tener hasta 100 combinaciones únicas de partición y bucket. Por ejemplo, puede tener 100 particiones si no se especifican buckets.

```
CREATE TABLE ctas_csv_partitioned 
WITH (
     format = 'TEXTFILE',  
     external_location = 's3://amzn-s3-demo-bucket/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://amzn-s3-demo-bucket/ctas_json_partitioned/', 
     partitioned_by = ARRAY['key1']) 
AS select name1, address1, comment1, key1 
FROM table1;
```

**Example Ejemplo : creación de tablas particionadas y en buckets**  
En el siguiente ejemplo se muestra una consulta `CREATE TABLE AS SELECT` que utiliza particiones y buckets para almacenar los resultados en Amazon S3. Los resultados de las tablas están particionados y distribuidos en buckets por columnas diferentes. Athena admite un máximo de 100 combinaciones únicas de partición y bucket. Por ejemplo, si crea una tabla con cinco buckets, se admiten 20 particiones con cinco buckets cada una. Para ver la sintaxis, consulte [Propiedades de la tabla CTAS](create-table-as.md#ctas-table-properties).  
Para obtener información sobre cómo elegir las columnas para la asignación de buckets, consulte [Uso de particiones y asignación de buckets](ctas-partitioning-and-bucketing.md).  

```
CREATE TABLE ctas_avro_bucketed 
WITH (
      format = 'AVRO', 
      external_location = 's3://amzn-s3-demo-bucket/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;
```

**Example Ejemplo: creación de una tabla de Iceberg con datos de Parquet**  
En el siguiente ejemplo, se crea una tabla de Iceberg con archivos de datos de Parquet. Los archivos se particionan por mes mediante la columna `dt` de `table1`. El ejemplo actualiza las propiedades de retención de la tabla para que se retengan 10 instantáneas de forma predeterminada en cada ramificación de la tabla. También se retienen las instantáneas de los últimos 7 días. Para obtener más información sobre las propiedades de las tablas de Iceberg, consulte [Especificación de propiedades de tablas](querying-iceberg-creating-tables.md#querying-iceberg-table-properties).  

```
CREATE TABLE ctas_iceberg_parquet
WITH (table_type = 'ICEBERG',
      format = 'PARQUET', 
      location = 's3://amzn-s3-demo-bucket/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;
```

**Example Ejemplo: creación de una tabla de Iceberg con datos de Avro**  
En el siguiente ejemplo, se crea una tabla de Iceberg con archivos de datos de Avro particionados por `key1`.  

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

**Example Ejemplo: Creación de una tabla de S3 por medio de CTAS**  
En el siguiente ejemplo se crea una tabla de S3 por medio de CTAS. Tenga en cuenta que se omite la propiedad de ubicación y que el `table_type` se establece de forma predeterminada en `ICEBERG`:  

```
CREATE TABLE "s3tablescatalog/amzn-s3-demo-bucket"."namespace"."s3-table-name"
WITH (
    format = 'PARQUET'
)
AS SELECT *
FROM source_table;
```
Puede especificar todas las demás propiedades de la tabla de Iceberg, como la partición y la agrupación en buckets, con la misma sintaxis que las tablas normales de Iceberg.