# Instrucciones DDL
Utilice las instrucciones de lenguaje de definición de datos (DDL) compatibles que se presentan aquí directamente en Athena. El motor de consultas de Athena se basa en parte en el [DDL de HiveQL](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL). Athena no admite todas las instrucciones DDL y existen algunas diferencias entre el DDL de HiveQL y el DDL de Athena. Para obtener más información, consulte los temas de referencia de esta sección y [DDL no admitido](unsupported-ddl.md).
**Topics**
+ [DDL no admitido](unsupported-ddl.md)
+ [ALTER DATABASE SET DBPROPERTIES](alter-database-set-dbproperties.md)
+ [ALTER TABLE ADD COLUMNS](alter-table-add-columns.md)
+ [ALTER TABLE ADD PARTITION](alter-table-add-partition.md)
+ [ALTER TABLE CHANGE COLUMN](alter-table-change-column.md)
+ [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md)
+ [ALTER TABLE RENAME PARTITION](alter-table-rename-partition.md)
+ [ALTER TABLE REPLACE COLUMNS](alter-table-replace-columns.md)
+ [ALTER TABLE SET LOCATION](alter-table-set-location.md)
+ [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md)
+ [ALTER VIEW DIALECT](alter-view-dialect.md)
+ [CREATE DATABASE](create-database.md)
+ [CREATE TABLE](create-table.md)
+ [CREATE TABLE AS](create-table-as.md)
+ [CREATE VIEW](create-view.md)
+ [DESCRIBE](describe-table.md)
+ [DESCRIBE VIEW](describe-view.md)
+ [DROP DATABASE](drop-database.md)
+ [DROP TABLE](drop-table.md)
+ [DROP VIEW](drop-view.md)
+ [MSCK REPAIR TABLE](msck-repair-table.md)
+ [SHOW COLUMNS](show-columns.md)
+ [SHOW CREATE TABLE](show-create-table.md)
+ [SHOW CREATE VIEW](show-create-view.md)
+ [SHOW DATABASES](show-databases.md)
+ [SHOW PARTITIONS](show-partitions.md)
+ [SHOW TABLES](show-tables.md)
+ [SHOW TBLPROPERTIES](show-tblproperties.md)
+ [SHOW VIEWS](show-views.md)
# DDL no admitido
Athena SQL no admite las siguientes instrucciones DDL. Para ver las instrucciones de DDL compatibles con las tablas de Iceberg en Athena, consulte [Evolución del esquema de tabla de Iceberg](querying-iceberg-evolving-table-schema.md) y [Otras operaciones de DDL en tablas de Iceberg](querying-iceberg-additional-operations.md).
+ ALTER INDEX
+ ALTER TABLE *table\$1name* ARCHIVE PARTITION
+ ALTER TABLE *table\$1name* CLUSTERED BY
+ ALTER TABLE *table\$1name* DROP COLUMN (compatible con tablas de Iceberg)
+ ALTER TABLE *table\$1name* EXCHANGE PARTITION
+ ALTER TABLE *table\$1name* NOT CLUSTERED
+ ALTER TABLE *table\$1name* NOT SKEWED
+ ALTER TABLE *table\$1name* NOT SORTED
+ ALTER TABLE *table\$1name* NOT STORED AS DIRECTORIES
+ ALTER TABLE *table\$1name* partitionSpec CHANGE COLUMNS
+ ALTER TABLE *table\$1name* partitionSpec COMPACT
+ ALTER TABLE *table\$1name* partitionSpec CONCATENATE
+ ALTER TABLE *table\$1name* partitionSpec SET FILEFORMAT
+ ALTER TABLE *table\$1name* RENAME TO (compatible con las tablas de Iceberg)
+ ALTER TABLE *table\$1name* SET SERDEPROPERTIES
+ ALTER TABLE *table\$1name* SET SKEWED LOCATION
+ ALTER TABLE *table\$1name* SKEWED BY
+ ALTER TABLE *table\$1name* TOUCH
+ ALTER TABLE *table\$1name* UNARCHIVE PARTITION
+ COMMIT
+ CREATE INDEX
+ CREAR ROL
+ CREATE TABLE *table\$1name* LIKE *existing\$1table\$1name*
+ CREATE TEMPORARY MACRO
+ DELETE FROM
+ DESCRIBE DATABASE
+ DFS
+ DROP INDEX
+ DROP ROLE
+ DROP TEMPORARY MACRO
+ EXPORT TABLE
+ GRANT ROLE
+ IMPORT TABLE
+ LOCK DATABASE
+ LOCK TABLE
+ REVOKE ROLE
+ ROLLBACK
+ SHOW COMPACTIONS
+ SHOW CURRENT ROLES
+ SHOW GRANT
+ SHOW INDEXES
+ SHOW LOCKS
+ SHOW PRINCIPALS
+ SHOW ROLE GRANT
+ SHOW ROLES
+ MOSTRAR ESTADÍSTICAS
+ SHOW TRANSACTIONS
+ START TRANSACTION
+ UNLOCK DATABASE
+ UNLOCK TABLE
# ALTER DATABASE SET DBPROPERTIES
Crea una o varias propiedades de una base de datos. `DATABASE` y `SCHEMA` son intercambiables; significan lo mismo.
## Sinopsis
```
ALTER {DATABASE|SCHEMA} database_name
SET DBPROPERTIES ('property_name'='property_value' [, ...] )
```
## Parameters
**SET DBPROPERTIES ('property\$1name'='property\$1value' [, ...]**
Especifica una o varias propiedades de la base de datos con el nombre `property_name` y establece como valor de cada propiedad `property_value`. Si `property_name` ya existe, se sobrescribe el valor antiguo con `property_value`.
## Ejemplos
```
ALTER DATABASE jd_datasets
SET DBPROPERTIES ('creator'='John Doe', 'department'='applied mathematics');
```
```
ALTER SCHEMA jd_datasets
SET DBPROPERTIES ('creator'='Jane Doe');
```
# ALTER TABLE ADD COLUMNS
Agrega una o más columnas a una tabla existente. Cuando se utiliza la sintaxis `PARTITION` opcional, actualiza los metadatos de la partición.
## Sinopsis
```
ALTER TABLE table_name
[PARTITION
(partition_col1_name = partition_col1_value
[,partition_col2_name = partition_col2_value][,...])]
ADD COLUMNS (col_name data_type)
```
## Parámetros
**PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])**
Crea una partición con las combinaciones de nombre y valor de columna que especifica. Escriba `partition_col_value` entre comillas solo si el tipo de datos de la columna es una cadena.
**ADD COLUMNS (col\$1name data\$1type [,col\$1name data\$1type,...])**
Agrega columnas después de las columnas existentes pero antes de las columnas de partición.
## Ejemplos
```
ALTER TABLE events ADD COLUMNS (eventowner string)
```
```
ALTER TABLE events PARTITION (awsregion='us-west-2') ADD COLUMNS (event string)
```
```
ALTER TABLE events PARTITION (awsregion='us-west-2') ADD COLUMNS (eventdescription string)
```
## Notas
+ Para ver una nueva columna de tabla en el panel de navegación del Editor de consultas de Athena después de ejecutar `ALTER TABLE ADD COLUMNS`, actualice manualmente la lista de tablas en el editor y vuelva a expandirla.
+ `ALTER TABLE ADD COLUMNS` no funciona para columnas con el tipo de datos `date`. Para solucionar este problema, utilice el tipo de datos `timestamp` en su lugar.
# ALTER TABLE ADD PARTITION
Crea una o varias columnas de partición para la tabla. Cada partición se compone de una o varias combinaciones diferenciadas de nombre y valor de columna. Se crea un directorio de datos independiente por cada combinación especificada, lo que puede mejorar el rendimiento de la consulta en algunas circunstancias. Las columnas con particiones no existen en la tabla de datos en sí, de modo que si utiliza un nombre de columna que tiene el mismo nombre que una columna de la tabla, obtendrá un error. Para obtener más información, consulte [Partición de datos](partitions.md).
En Athena, una tabla y sus particiones deben utilizar los mismos formatos de datos, pero sus esquemas pueden ser diferentes. Para obtener más información, consulte [Actualización de tablas con particiones](updates-and-partitions.md).
Para obtener información sobre los permisos de nivel de recursos requeridos en las políticas de IAM (incluido `glue:CreatePartition`), consulte [Permisos de la API de AWS Glue: Referencia de recursos y acciones](https://docs.aws.amazon.com/glue/latest/dg/api-permissions-reference.html) y [Configuración del acceso a las bases de datos y tablas en el AWS Glue Data Catalog](fine-grained-access-to-glue-resources.md). Para obtener información sobre la solución de problemas de permisos al utilizar Athena, consulte la sección [Permisos](troubleshooting-athena.md#troubleshooting-athena-permissions) del tema [Solución de problemas en Athena](troubleshooting-athena.md).
## Sinopsis
```
ALTER TABLE table_name ADD [IF NOT EXISTS]
PARTITION
(partition_col1_name = partition_col1_value
[,partition_col2_name = partition_col2_value]
[,...])
[LOCATION 'location1']
[PARTITION
(partition_colA_name = partition_colA_value
[,partition_colB_name = partition_colB_value
[,...])]
[LOCATION 'location2']
[,...]
```
## Parameters
Cuando agrega una partición, especifica uno o más pares de nombre y valor de columna para la partición y la ruta de acceso de Amazon S3 donde residen los archivos de datos de esa partición.
**[IF NOT EXISTS]**
Hace que se suprima el error si ya existe una partición con la misma definición.
**PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])**
Crea una partición con las combinaciones de nombre y valor de columna que especifica. Ponga `partition_col_value` entre caracteres de cadena solo si el tipo de datos de la columna es una cadena.
**[LOCATION 'location']**
Especifica el directorio en el que se va a almacenar la partición definida mediante la instrucción anterior. La cláusula `LOCATION` es opcional cuando los datos están particionados al estilo Hive (`pk1=v1/pk2=v2/pk3=v3`). Con la partición al estilo Hive, el URI completo de Amazon S3 se crea automáticamente a partir de la ubicación de la tabla, los nombres de las claves de partición y los valores de las claves de partición. Para obtener más información, consulte [Partición de datos](partitions.md).
## Consideraciones
Amazon Athena no le impone un límite específico al número de particiones que se pueden añadir en una sola instrucción DDL `ALTER TABLE ADD PARTITION`. Sin embargo, si necesita añadir un número significativo de particiones, considere la posibilidad de dividir la operación en lotes más pequeños para evitar posibles problemas de rendimiento. En el siguiente ejemplo, se utilizan comandos sucesivos para añadir particiones de forma individual y se utiliza `IF NOT EXISTS` para evitar añadir duplicados.
```
ALTER TABLE table_name ADD IF NOT EXISTS PARTITION (ds='2023-01-01')
ALTER TABLE table_name ADD IF NOT EXISTS PARTITION (ds='2023-01-02')
ALTER TABLE table_name ADD IF NOT EXISTS PARTITION (ds='2023-01-03')
```
Cuando trabaje con particiones en Athena, también tenga en cuenta los siguientes puntos:
+ Aunque Athena admite consultas de tablas de AWS Glue que tienen 10 millones de particiones, no puede leer más de 1 millón de particiones en un solo escaneo.
+ Para optimizar sus consultas y reducir el número de particiones escaneadas, considere estrategias como la eliminación de particiones o el uso de índices de particiones.
Para obtener información adicional sobre el trabajo con particiones en Athena, consulte [Partición de datos](partitions.md).
## Ejemplos
En el siguiente ejemplo, se agrega una sola partición a una tabla para datos particionados al estilo Hive.
```
ALTER TABLE orders ADD
PARTITION (dt = '2016-05-14', country = 'IN');
```
En el siguiente ejemplo, se agregan varias particiones a una tabla para datos particionados al estilo Hive.
```
ALTER TABLE orders ADD
PARTITION (dt = '2016-05-31', country = 'IN')
PARTITION (dt = '2016-06-01', country = 'IN');
```
Si la tabla no es para datos particionados al estilo Hive, la cláusula `LOCATION` es obligatoria y debe ser el URI completo de Amazon S3 del prefijo que contiene los datos de la partición.
```
ALTER TABLE orders ADD
PARTITION (dt = '2016-05-31', country = 'IN') LOCATION 's3://amzn-s3-demo-bucket/path/to/INDIA_31_May_2016/'
PARTITION (dt = '2016-06-01', country = 'IN') LOCATION 's3://amzn-s3-demo-bucket/path/to/INDIA_01_June_2016/';
```
Para ignorar los errores cuando la partición ya existe, utilice la cláusula `IF NOT EXISTS`, como en el siguiente ejemplo.
```
ALTER TABLE orders ADD IF NOT EXISTS
PARTITION (dt = '2016-05-14', country = 'IN');
```
## Archivos `_$folder$` sin bytes
Si ejecuta una declaración `ALTER TABLE ADD PARTITION` y especifica erróneamente una partición que ya existe y una ubicación de Amazon S3 incorrecta, se crean archivos de marcador de posición de cero bytes del formato `partition_value_$folder$` en Amazon S3. Debe eliminar esos archivos en forma manual.
Para evitar que esto ocurra, utilice la sintaxis `ADD IF NOT EXISTS` de la instrucción `ALTER TABLE ADD PARTITION`, como se muestra en el siguiente ejemplo.
```
ALTER TABLE table_name ADD IF NOT EXISTS PARTITION […]
```
# ALTER TABLE CHANGE COLUMN
Cambiar el nombre, el tipo, el orden o el comentario de una columna en una tabla de Iceberg.
## Sinopsis
```
ALTER TABLE [db_name.]table_name
CHANGE [COLUMN] col_old_name col_new_name column_type
[COMMENT col_comment] [FIRST|AFTER column_name]
```
## Ejemplos
El siguiente ejemplo cambia el nombre de la columna `area` a `zip`, convierte el tipo de datos en entero y coloca la columna cuyo nombre ha cambiado según la columna `id`.
```
ALTER TABLE example_table CHANGE COLUMN area zip int AFTER id
```
El siguiente ejemplo agrega un comentario a la columna `zip` en los metadatos para `example_table`. Para ver el comentario, utilice el comando AWS CLI [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/get-table-metadata.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/get-table-metadata.html) o visite el esquema de la tabla en la consola AWS Glue.
```
ALTER TABLE example_table CHANGE COLUMN zip zip int COMMENT 'USA zipcode'
```
# ALTER TABLE DROP PARTITION
Elimina una o varias particiones especificadas de la tabla indicada.
## Sinopsis
```
ALTER TABLE table_name DROP [IF EXISTS] PARTITION (partition_spec) [, PARTITION (partition_spec)]
```
## Parameters
**[IF EXISTS]**
Suprime el mensaje de error si la partición especificada no existe.
**PARTITION (partition\$1spec)**
Cada valor de `partition_spec` especifica una combinación de columna nombre/valor con la forma `partition_col_name = partition_col_value [,...]`.
## Ejemplos
```
ALTER TABLE orders
DROP PARTITION (dt = '2014-05-14', country = 'IN');
```
```
ALTER TABLE orders
DROP PARTITION (dt = '2014-05-14', country = 'IN'), PARTITION (dt = '2014-05-15', country = 'IN');
```
## Notas
La instrucción `ALTER TABLE DROP PARTITION` no proporciona una sintaxis única para eliminar todas las particiones a la vez ni admite criterios de filtro para especificar un rango de particiones que se eliminarán.
Como alternativa, puede utilizar las acciones de la API de AWS Glue [GetPartitions](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-GetPartitions) y [BatchDeletePartition](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-BatchDeletePartition) durante el scripting. La acción `GetPartitions` admite expresiones de filtro complejas como las de una expresión `WHERE` de SQL. Después de usar `GetPartitions` para crear una lista filtrada de particiones para eliminar, puede utilizar la acción `BatchDeletePartition` para eliminar las particiones en lotes de 25.
# ALTER TABLE RENAME PARTITION
Cambia el nombre de un valor de partición.
**nota**
ALTER TABLE RENAME PARTITION no cambia el nombre de las columnas de partición. Para cambiar el nombre de una columna de partición, puede utilizar la consola de AWS Glue. Para obtener más información, consulte [Cambiar el nombre de una columna de partición en AWS Glue](#alter-table-rename-partition-column-name) más adelante en este documento.
## Sinopsis
En el caso de la tabla llamada `table_name`, cambia el nombre del valor de la partición especificado por `partition_spec` al valor especificado por `new_partition_spec`.
```
ALTER TABLE table_name PARTITION (partition_spec) RENAME TO PARTITION (new_partition_spec)
```
## Parameters
**PARTITION (partition\$1spec)**
Cada valor de `partition_spec` especifica una combinación de columna nombre/valor con la forma `partition_col_name = partition_col_value [,...]`.
## Ejemplos
```
ALTER TABLE orders
PARTITION (dt = '2014-05-14', country = 'IN') RENAME TO PARTITION (dt = '2014-05-15', country = 'IN');
```
## Cambiar el nombre de una columna de partición en AWS Glue
Utilice el siguiente procedimiento para cambiar el nombre de las columnas de partición en la consola de AWS Glue.
**Para cambiar el nombre de una columna de partición de tabla en la consola de AWS Glue**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. En el panel de navegación, elija **Tablas**.
1. En la página **Tablas**, utilice el cuadro de búsqueda **Filtrar tablas** para encontrar la tabla que desea modificar.
1. En la columna **Nombre**, elija el enlace de la tabla que desea modificar.
1. En la página de detalles de la tabla, en la sección **Esquema**, realice una de las siguientes acciones:
+ Para realizar el cambio de nombre en formato JSON, seleccione **Editar esquema como JSON**.
+ Para cambiar el nombre directamente, elija **Editar esquema**. Este procedimiento elige **Editar esquema**.
1. Seleccione la casilla de verificación de la columna particionada cuyo nombre desee cambiar y, a continuación, elija **Editar**.
1. En el cuadro de diálogo **Editar entrada de esquema**, en **Nombre**, ingrese el nuevo nombre de la columna de partición.
1. Elija **Guardar como nueva versión de la tabla**. Esta acción actualiza el nombre de columna de la partición y conserva el historial de evolución del esquema sin crear una copia física separada de los datos.
1. Para comparar versiones de tablas, en la página de detalles de la tabla, elija **Acciones** y, a continuación, seleccione **Comparar versiones**.
## Recursos adicionales
Para obtener más información sobre la creación de particiones, consulte [Partición de datos](partitions.md).
# ALTER TABLE REPLACE COLUMNS
Elimina todas las columnas existentes de una tabla creada con [LazySimpleSerDe](lazy-simple-serde.md) y las reemplaza con el conjunto de columnas especificado. Cuando se utiliza la sintaxis `PARTITION` opcional, actualiza los metadatos de la partición. También puede utilizar `ALTER TABLE REPLACE COLUMNS` para eliminar columnas al especificar solo las columnas que desea conservar.
## Sinopsis
```
ALTER TABLE table_name
[PARTITION
(partition_col1_name = partition_col1_value
[,partition_col2_name = partition_col2_value][,...])]
REPLACE COLUMNS (col_name data_type [, col_name data_type, ...])
```
## Parameters
**PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])**
Especifica una partición con las combinaciones de nombre y valor de columna que especifica. Escriba `partition_col_value` entre comillas solo si el tipo de datos de la columna es una cadena.
**REPLACE COLUMNS (col\$1name data\$1type [,col\$1name data\$1type,...])**
Reemplaza las columnas existentes por los nombres de columna y los tipos de datos especificados.
## Notas
+ Para ver el cambio de las columnas de la tabla en el panel de navegación del Editor de consultas de Athena después de ejecutar `ALTER TABLE REPLACE COLUMNS`, es posible que tenga que actualizar manualmente la lista de tablas en el editor y volver a expandirla.
+ `ALTER TABLE REPLACE COLUMNS` no funciona para columnas con el tipo de datos `date`. Para solucionar este problema, utilice el tipo de datos `timestamp` en la tabla en su lugar.
+ Tenga en cuenta que, incluso si está reemplazando una sola columna, la sintaxis debe ser `ALTER TABLE table-name REPLACE COLUMNS`, con *columns* (columnas) en plural. Debe especificar no solo la columna que desea reemplazar, sino también las columnas que desea conservar; de lo contrario, se eliminarán las columnas que no especifique. Esta sintaxis y este comportamiento se derivan del DDL de Apache Hive. Como referencia, consulte [Agregar o reemplazar columnas](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-Add/ReplaceColumns) en la documentación de Apache.
## Ejemplo
En el siguiente ejemplo, la tabla `names_cities`, que se creó con [LazySimpleSerDe](lazy-simple-serde.md), tiene tres columnas denominadas `col1`, `col2` y `col3`. Todas las columnas son de tipo `string`. Para mostrar las columnas de la tabla, el siguiente comando utiliza la instrucción [SHOW COLUMNS](show-columns.md).
```
SHOW COLUMNS IN names_cities
```
Resultado de la consulta:
```
col1
col2
col3
```
El siguiente comando `ALTER TABLE REPLACE COLUMNS` reemplaza los nombres de las columnas por `first_name`, `last_name` y `city`. Los datos de origen subyacentes no se ven afectados.
```
ALTER TABLE names_cities
REPLACE COLUMNS (first_name string, last_name string, city string)
```
Para probar el resultado, `SHOW COLUMNS` se ejecuta de nuevo.
```
SHOW COLUMNS IN names_cities
```
Resultado de la consulta:
```
first_name
last_name
city
```
Otra forma de mostrar los nuevos nombres de las columnas es [obtener una vista previa de la tabla](creating-tables-showing-table-information.md) en el Editor de consultas de Athena o ejecutar su propia consulta `SELECT`.
# ALTER TABLE SET LOCATION
Cambia la ubicación de la tabla denominada `table_name` y, de forma opcional, una partición con `partition_spec`.
## Sinopsis
```
ALTER TABLE table_name [ PARTITION (partition_spec) ] SET LOCATION 'new location'
```
## Parámetros
**PARTITION (partition\$1spec)**
Especifica la partición con parámetros `partition_spec` cuya ubicación desea cambiar. La `partition_spec` especifica una combinación de nombre de columna y valor con la forma `partition_col_name = partition_col_value`.
**SET LOCATION 'nueva ubicación'**
Especifica la nueva ubicación, que debe ser una ubicación de Amazon S3. Para obtener información sobre la sintaxis, consulte [Ubicación de las tablas en Amazon S3](tables-location-format.md).
## Ejemplos
```
ALTER TABLE customers PARTITION (zip='98040', state='WA') SET LOCATION 's3://amzn-s3-demo-bucket/custdata/';
```
# ALTER TABLE SET TBLPROPERTIES
Agrega propiedades de metadatos personalizadas o predefinidas a una tabla y establece sus valores asignados. Para ver las propiedades de una tabla, utilice el comando [SHOW TBLPROPERTIES](show-tblproperties.md).
No se admiten las [tablas administradas](https://cwiki.apache.org/confluence/display/Hive/Managed+vs.+External+Tables) por Apache Hive, por lo que el valor `'EXTERNAL'='FALSE'` no tiene ningún efecto.
## Sinopsis
```
ALTER TABLE table_name SET TBLPROPERTIES ('property_name' = 'property_value' [ , ... ])
```
## Parámetros
**SET TBLPROPERTIES ('property\$1name' = 'property\$1value' [ , ... ])**
Especifica las propiedades de metadatos que se añaden como `property_name` y el valor de cada una como `property value`. Si `property_name` ya existe, su valor está establecido en el `property_value` recién especificado.
Las siguientes propiedades de tabla predefinidas tienen usos especiales.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/alter-table-set-tblproperties.html)
## Ejemplos
En el siguiente ejemplo se agrega una nota de comentario a las propiedades de tabla.
```
ALTER TABLE orders
SET TBLPROPERTIES ('notes'="Please don't drop this table.");
```
En el siguiente ejemplo se modifica la tabla `existing_table` para que utilice el formato de archivo Parquet con compresión ZSTD y nivel 4 de compresión ZSTD.
```
ALTER TABLE existing_table
SET TBLPROPERTIES ('parquet.compression' = 'ZSTD', 'compression_level' = 4)
```
# ALTER VIEW DIALECT
Agrega o elimina un dialecto del motor de una vista del AWS Glue Data Catalog. Se aplica únicamente a las vistas del AWS Glue Data Catalog. Requiere permisos de administrador o de definidor de `Lake Formation`.
Para obtener más información acerca de las vistas del AWS Glue Data Catalog, consulte [Uso de vistas del Catálogo de datos en Athena](views-glue.md).
## Sintaxis
```
ALTER VIEW name [ FORCE ] [ ADD|UPDATE ] DIALECT AS query
```
```
ALTER VIEW name [ DROP ] DIALECT
```
**FORCE**
La palabra clave `FORCE` hace que la información entre los dialectos del motor en conflicto de una vista se sobrescriba con la nueva definición. La palabra clave `FORCE` resulta útil cuando una actualización de una vista del catálogo de datos da como resultado definiciones de vista contradictorias entre los dialectos del motor existentes. Supongamos que una vista del catálogo de datos tiene los dialectos Athena y Amazon Redshift y que la actualización provoca un conflicto con Amazon Redshift en la definición de la vista. En este caso, puede usar la palabra clave `FORCE` para permitir que se complete la actualización y marcar el dialecto de Amazon Redshift como obsoleto. Cuando los motores marcados como obsoletos consultan la vista, la consulta falla. Los motores hacen una excepción para impedir que se obtengan resultados obsoletos. Para corregir esto, actualice los dialectos obsoletos de la vista.
**ADD**
Añade un nuevo dialecto del motor a la vista del catálogo de datos. El motor especificado no debe existir en la vista del catálogo de datos.
**UPDATE**
Actualiza un dialecto del motor que ya existe en la vista del catálogo de datos.
**DROP**
Elimina un dialecto del motor existente de la vista del catálogo de datos. Tras eliminar un motor de una vista del catálogo de datos, el motor que se descartó no podrá consultar la vista del catálogo de datos. Otros dialectos del motor de la vista aún pueden consultar la vista.
**DIALECT AS**
Introduce una consulta SQL específica del motor.
## Ejemplos
```
ALTER VIEW orders_by_date FORCE ADD DIALECT
AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
GROUP BY orderdate
```
```
ALTER VIEW orders_by_date FORCE UPDATE DIALECT
AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
GROUP BY orderdate
```
```
ALTER VIEW orders_by_date DROP DIALECT
```
# CREATE DATABASE
Crea una base de datos. El uso de `DATABASE` y `SCHEMA` es intercambiable. Significan lo mismo.
**nota**
Para ver un ejemplo de cómo crear una base de datos, crear una tabla y ejecutar una consulta `SELECT` en una tabla en Athena, consulte [Introducción](getting-started.md).
## Sinopsis
```
CREATE {DATABASE|SCHEMA} [IF NOT EXISTS] database_name
[COMMENT 'database_comment']
[LOCATION 'S3_loc']
[WITH DBPROPERTIES ('property_name' = 'property_value') [, ...]]
```
Para obtener las restricciones para los nombres de las bases de datos en Athena, consulte [Nombrar tablas, bases de datos y columnas](tables-databases-columns-names.md).
## Parámetros
**[IF NOT EXISTS]**
Hace que se suprima el error si ya existe una base de datos denominada `database_name`.
**[COMMENT database\$1comment]**
Establece el valor de metadato de la propiedad de metadatos integrada denominada `comment` y el valor que proporciona para `database_comment`. En AWS Glue, los contenidos `COMMENT` se escriben en el campo `Description` de las propiedades de la base de datos.
**[LOCATION S3\$1loc]**
Especifica como `S3_loc` la ubicación donde existirán los archivos de la base de datos y el metaalmacén. La ubicación tiene que ser una ubicación de Amazon S3.
**[WITH DBPROPERTIES ('property\$1name' = 'property\$1value') [, ...] ]**
Le permite especificar las propiedades de metadatos personalizados para la definición de la base de datos.
## Ejemplos
```
CREATE DATABASE clickstreams;
```
```
CREATE DATABASE IF NOT EXISTS clickstreams
COMMENT 'Site Foo clickstream data aggregates'
LOCATION 's3://amzn-s3-demo-bucket/clickstreams/'
WITH DBPROPERTIES ('creator'='Jane D.', 'Dept.'='Marketing analytics');
```
## Visualización de las propiedades de la base de datos
Para ver las propiedades de la base de datos que se crea en AWSDataCatalog mediante `CREATE DATABASE`, puede utilizar el comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-database.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-database.html) de la AWS CLI, como en el siguiente ejemplo:
```
aws glue get-database --name
```
En la salida JSON, el resultado tiene el siguiente aspecto:
```
{
"Database": {
"Name": "",
"Description": "",
"LocationUri": "s3://amzn-s3-demo-bucket",
"Parameters": {
"": ""
},
"CreateTime": 1603383451.0,
"CreateTableDefaultPermissions": [
{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": [
"ALL"
]
}
]
}
}
```
Para obtener más información acerca de la AWS CLI, consulte la [Guía del usuario de AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/).
# CREATE TABLE
Crea una tabla con el nombre y los parámetros que especifica.
**nota**
Esta página contiene información de referencia resumida. Para obtener más información sobre la creación de tablas en Athena y una declaración de `CREATE TABLE` de ejemplo, consulte [Creación de tablas en Athena](creating-tables.md). Para ver un ejemplo de cómo crear una base de datos, crear una tabla y ejecutar una consulta `SELECT` en una tabla en Athena, consulte [Introducción](getting-started.md).
## Sinopsis
```
CREATE EXTERNAL TABLE [IF NOT EXISTS]
[db_name.]table_name [(col_name data_type [COMMENT col_comment] [, ...] )]
[COMMENT table_comment]
[PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)]
[CLUSTERED BY (col_name, col_name, ...) INTO num_buckets BUCKETS]
[ROW FORMAT row_format]
[STORED AS file_format]
[WITH SERDEPROPERTIES (...)]
[LOCATION 's3://amzn-s3-demo-bucket/[folder]/']
[TBLPROPERTIES ( ['has_encrypted_data'='true | false',] ['encryption_option'='SSE_S3 | SSE_KMS | CSE_KMS',] ['kms_key'='aws_kms_key_arn',] ['classification'='aws_glue_classification',] property_name=property_value [, ...] ) ]
```
## Parameters
**EXTERNAL**
Especifica que la tabla se basa en un archivo de datos subyacente que existe en Amazon S3, en la ubicación `LOCATION` que especifique. Utilice siempre la palabra clave `EXTERNAL` excepto al crear tablas de [Iceberg](querying-iceberg-creating-tables.md). Si utiliza `CREATE TABLE` sin la palabra clave `EXTERNAL` para tablas que no son Iceberg, Athena emite un error. Cuando cree una tabla externa, los datos a los que hace referencia deben respetar el formato predeterminado o el formato que especifique con las cláusulas `ROW FORMAT`, `STORED AS` y `WITH SERDEPROPERTIES`.
**[IF NOT EXISTS]**
Este parámetro comprueba si ya existe una tabla con el mismo nombre. Si es así, el parámetro devuelve `TRUE` y Amazon Athena cancela la acción `CREATE TABLE`. Como la cancelación se produce antes de que Athena llame al catálogo de datos, no emite ningún evento AWS CloudTrail.
**[db\$1name.]table\$1name**
Especifica un nombre para la tabla que se creará. El parámetro opcional `db_name` especifica la base de datos donde existe la tabla. Si se omite, se presupondrá que se utiliza la base de datos actual. Si el nombre de la tabla incluye números, ponga `table_name` entre comillas; por ejemplo `"table123"`. Si `table_name` comienza con un guion bajo, utilice acentos graves; por ejemplo: ``_mytable``. Los caracteres especiales, salvo el guion bajo, no se admiten.
En los nombres de tabla de Athena no se distingue entre mayúsculas y minúsculas. Sin embargo, si utiliza Apache Spark, este requiere que los nombres de las tablas estén en minúsculas. Para ver las restricciones para los nombres de las tablas en Athena, consulte [Nombrar tablas, bases de datos y columnas](tables-databases-columns-names.md).
**[ ( col\$1name data\$1type [COMMENT col\$1comment] [, ...] ) ]**
Especifica el nombre de cada columna que se va a crear, junto con el tipo de datos de la columna. Los nombres de columnas no permiten caracteres especiales que no sean guiones bajos `(_)`. Si `col_name` comienza con un guion bajo, ponga el nombre de la columna entre acentos graves; por ejemplo ``_mycolumn``. Para ver las restricciones para los nombres de las columnas en Athena, consulte [Nombrar tablas, bases de datos y columnas](tables-databases-columns-names.md).
El valor `data_type` puede ser cualquiera de los siguientes:
+ `boolean` – los valores son `true` y `false`.
+ `tinyint`: un número entero firmado de 8 bits en formato de complemento de dos, con un valor mínimo de -2^7 y un valor máximo de 2^7-1.
+ `smallint`: un número entero firmado de 16 bits en formato de complemento de dos, con un valor mínimo de -2^15 y un valor máximo de 2^15-1.
+ `int`: en las consultas de lenguaje de definición de datos (DDL), como `CREATE TABLE`, utilice la palabra clave `int` para representar un entero. En otras consultas, utilice la palabra clave `integer`, donde `integer` se representa como un valor firmado de 32 bits en formato de complemento a dos, con un valor mínimo de -2^31 y un valor máximo de 2^31-1. En el controlador JDBC se devuelve `integer` a fin de garantizar la compatibilidad con las aplicaciones de análisis empresarial.
+ `bigint`: un número entero firmado de 64 bits en formato de complemento de dos, con un valor mínimo de -2^63 y un valor máximo de 2^63-1.
+ `double`: un número firmado de punto flotante de doble precisión de 64 bits. El rango es de 4.94065645841246544e-324d a 1.79769313486231570e\$1308d, positivo o negativo. `double` sigue el estándar IEEE para la aritmética de punto flotante (IEEE 754).
+ `float`: un número firmado de punto flotante de precisión simple de 32 bits. El rango es de 1.40129846432481707e-45 a 3.40282346638528860e\$138, positivo o negativo. `float` sigue el estándar IEEE para la aritmética de punto flotante (IEEE 754). Equivalente a `real` en Presto. En Athena, utilice `float` en instrucciones DDL como `CREATE TABLE` y `real` en funciones SQL como `SELECT CAST`. El rastreador de AWS Glue devuelve valores en `float`, y Athena traduce los tipos `real` y `float` internamente (consulte las notas de la versión [5 de junio de 2018](release-notes.md#release-note-2018-06-05)).
+ `decimal [ (precision, scale) ]`, donde `precision` es el número total de dígitos y `scale` (opcional) es el número de dígitos con parte fraccional, el valor predeterminado es 0. Por ejemplo, utilice estas definiciones de tipo: `decimal(11,5)`, `decimal(15)`. El valor máximo para *precisión* es 38 y el valor máximo para *escala* también es 38.
Para especificar valores decimales como literales como, por ejemplo, al seleccionar filas con un valor decimal específico en una expresión DDL de consulta, especifique la definición de tipo `decimal` y enumere el valor decimal como literal (entre comillas simples) en su consulta, como en este ejemplo: `decimal_value = decimal '0.12'`.
+ `char` – datos de caracteres de longitud fija, con una longitud especificada comprendida entre 1 y 255 como, por ejemplo `char(10)`. Para obtener más información, consulte [Tipo de datos Hive CHAR](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-char).
+ `varchar` – datos de caracteres de longitud variable, con una longitud especificada comprendida entre 1 y 65 535 como, por ejemplo `varchar(10)`. Para obtener más información, consulte [Tipo de datos Hive VARCHAR](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-varchar).
+ `string`: un literal de cadena entre comillas simples o dobles.
**nota**
Los tipos de datos que no son de cadena no se pueden convertir en `string` en Athena; en su lugar, se pueden convertir en `varchar`.
+ `binary`: (para los datos en formato Parquet)
+ `date` – Una fecha en formato ISO, como `YYYY-MM-DD`. Por ejemplo, `date '2008-09-15'`. Una excepción es OpenCSVSerDe, que utiliza el número de días transcurridos desde el 1 de enero de 1970. Para obtener más información, consulte [Open CSV SerDe para el procesamiento de CSV](csv-serde.md).
+ `timestamp`: instante de fecha y hora en un formato compatible con [https://docs.oracle.com/javase/8/docs/api/java/sql/Timestamp.html](https://docs.oracle.com/javase/8/docs/api/java/sql/Timestamp.html) hasta una resolución máxima de milisegundos, como `yyyy-MM-dd HH:mm:ss[.f...]`. Por ejemplo, `timestamp '2008-09-15 03:04:05.324'`. Una excepción es OpenCSVSerDe, que utiliza datos de `TIMESTAMP` en formato numérico UNIX (por ejemplo, `1579059880000`). Para obtener más información, consulte [Open CSV SerDe para el procesamiento de CSV](csv-serde.md).
+ `array` < tipo\$1datos >
+ `map` < tipo\$1primitiva, tipo\$1datos >
+ `struct` < nombre\$1col : tipo\$1datos [comment comentario\$1col] [, ...] >
**[COMMENT table\$1comment]**
Crea la propiedad de tabla `comment` y la rellena con el `table_comment` que especifique.
**[PARTITIONED BY (col\$1name data\$1type [ COMMENT col\$1comment ], ... ) ]**
Crea una tabla con particiones, con una o varias columnas de partición que tienen especificados los elementos `col_name`, `data_type` y `col_comment`. Una tabla puede tener una o varias particiones, que consisten en una combinación de nombre de columna y valor diferenciada. Se crea un directorio de datos independiente por cada combinación especificada, lo que puede mejorar el rendimiento de la consulta en algunas circunstancias. Las columnas particionadas no existen dentro de los propios datos de la tabla. Recibirá un error si utiliza un valor para `col_name` igual al de una columna de la tabla. Para obtener más información, consulte la sección sobre [partición de datos](partitions.md).
Después de crear una tabla con particiones, ejecute una consulta posterior que consista en la cláusula [MSCK REPAIR TABLE](msck-repair-table.md) para actualizar los metadatos de partición; por ejemplo, `MSCK REPAIR TABLE cloudfront_logs;`. Para las particiones que no son compatibles con Hive, utilice [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) para cargar las particiones de modo que pueda consultar los datos.
**[CLUSTERED BY (col\$1name, col\$1name, ...) INTO num\$1buckets BUCKETS]**
Divide los datos, con o sin particiones, de las columnas `col_name` especificadas en subconjuntos de datos llamados *buckets*. El parámetro `num_buckets` especifica el número de buckets que se va a crear. La asignación de buckets puede mejorar el rendimiento de algunas consultas en conjuntos de datos grandes.
**[ROW FORMAT row\$1format]**
Especifica el formato de fila de la tabla y su origen de datos subyacente, si procede. En `row_format` puede especificar uno o varios delimitadores con la cláusula `DELIMITED` o bien puede utilizar la cláusula `SERDE` tal y como se describe más abajo. Si `ROW FORMAT` se omite o bien se especifica `ROW FORMAT DELIMITED`, se utilizará un SerDe nativo.
+ [DELIMITED FIELDS TERMINATED BY char [ESCAPED BY char]]
+ [DELIMITED COLLECTION ITEMS TERMINATED BY char]
+ [MAP KEYS TERMINATED BY char]
+ [LINES TERMINATED BY char]
+ [NULL DEFINED AS char]
Disponible solo con Hive 0.13 y cuando el formato de archivo STORED AS es `TEXTFILE`.
**--O BIEN--**
+ SERDE 'serde\$1name' [WITH SERDEPROPERTIES ("property\$1name" = "property\$1value", "property\$1name" = "property\$1value" [, ...] )]
`serde_name` indica el SerDe que debe utilizarse. La cláusula `WITH SERDEPROPERTIES` le permite proporcionar una o varias propiedades personalizadas que el SerDe permite.
**[STORED AS file\$1format]**
Especifica el formato de archivo de los datos de la tabla. Si se omite, `TEXTFILE` es la opción predeterminada. Las opciones para `file_format` son:
+ SEQUENCEFILE
+ TEXTFILE
+ RCFILE
+ ORC
+ PARQUET
+ AVRO
+ ION
+ INPUTFORMAT input\$1format\$1classname OUTPUTFORMAT output\$1format\$1classname
**[LOCATION 's3://amzn-s3-demo-bucket/[folder]/']**
Especifica la ubicación de los datos subyacentes en Amazon S3 a partir de los cuales se crea la tabla. La ruta de la ubicación debe ser un nombre de bucket solo o un nombre de bucket y una o varias carpetas. Si utiliza particiones, especifique la raíz de los datos particionados. Para obtener más información sobre la ubicación de la tabla, consulte [Especificación de la ubicación de una tabla en Amazon S3](tables-location-format.md). Para obtener información sobre el formato de datos y los permisos, consulte [Consideraciones sobre Amazon S3](creating-tables.md#s3-considerations).
Utilice una barra diagonal final para su carpeta o bucket. No utilice nombres de archivo ni caracteres glob.
**Uso de:**
`s3://amzn-s3-demo-bucket/`
`s3://amzn-s3-demo-bucket/folder/`
`s3://amzn-s3-demo-bucket/folder/anotherfolder/`
**No utilice:**
`s3://amzn-s3-demo-bucket`
`s3://amzn-s3-demo-bucket/*`
`s3://amzn-s3-demo-bucket/mydatafile.dat`
**[TBLPROPERTIES ( ['has\$1encrypted\$1data'='true \$1 false',] ['encryption\$1option'='SSE\$1S3 \$1 SSE\$1KMS \$1 CSE\$1KMS',] ['kms\$1key'='aws\$1kms\$1key\$1arn',] ['classification'='classification\$1value',] property\$1name=property\$1value [, ...] ) ]**
Especifica los pares de clave-valor de metadatos personalizados para la definición de la tabla, además de las propiedades de tablas predefinidas como `"comment"`.
**has\$1encrypted\$1data**: Athena tiene una propiedad integrada, `has_encrypted_data`. Establezca esta propiedad en `true` para indicar que el conjunto de datos subyacente que `LOCATION` especifica está cifrado con CSE-KMS. Si se omite y si la configuración del grupo de trabajo no invalida la configuración del lado del cliente, se supone el valor `false`. Si se omite o se establece en `false` cuando los datos subyacentes están cifrados, los resultados de la consulta generarán un error. Para obtener más información, consulte [Cifrado en reposo](encryption.md).
**encryption\$1option**: establezca esta propiedad en `SSE_S3`, `SSE_KMS` o `CSE_KMS` para indicar el nivel más alto de cifrado utilizado en el conjunto de datos subyacente especificado por `LOCATION`. Para obtener más información, consulte [Cifrado en reposo](encryption.md).
**kms\$1key**: establezca esta propiedad en el ARN de la clave de AWS KMS utilizada para cifrar y descifrar los archivos de datos de tablas. Athena utiliza esta clave para cifrar los archivos de datos de tablas al escribir con el cifrado con `SSE_KMS` o `CSE_KMS`, y para descifrar los archivos de datos de tablas cifrados con CSE-KMS. Esta propiedad no es necesaria cuando `encryption_option` se establece en `SSE_KMS` o `CSE_KMS`. Para obtener más información, consulte [Cifrado en reposo](encryption.md).
**clasificación**: las tablas creadas para Athena en la consola de CloudTrail añaden `cloudtrail` como valor a la propiedad `classification`. Para ejecutar trabajos de ETL, AWS Glue necesita que usted cree una tabla con la propiedad `classification` para indicar que el tipo de datos para AWS Glue es `csv`, `parquet`, `orc`, `avro` o `json`. Por ejemplo, `'classification'='csv'`. Los trabajos de ETL generarán un error si no especifica esta propiedad. Puede especificarla posteriormente utilizando la consola, la API o la CLI de AWS Glue. Para obtener más información, consulte [Creación de tablas para los trabajos de ETL](schema-classifier.md) y [Creación de trabajos en AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job.html) en la *Guía para desarrolladores de AWS Glue*.
**compression\$1level**: la propiedad `compression_level` especifica el nivel de compresión que se debe utilizar. Esta propiedad solo se aplica a la compresión ZSTD. Los valores posibles están comprendidos entre 1 y 22. El valor predeterminado es 3. Para obtener más información, consulte [Uso de niveles de compresión de ZSTD](compression-support-zstd-levels.md).
Para obtener más información sobre otras propiedades de tabla, consulte [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md).
## Ejemplos
La siguiente instrucción `CREATE TABLE` de ejemplo crea una tabla basada en datos planetarios separados por tabulaciones almacenados en Amazon S3.
```
CREATE EXTERNAL TABLE planet_data (
planet_name string,
order_from_sun int,
au_to_sun float,
mass float,
gravity_earth float,
orbit_years float,
day_length float
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
STORED AS TEXTFILE
LOCATION 's3://amzn-s3-demo-bucket/tsv/'
```
Tenga en cuenta los siguientes puntos:
+ La cláusula `ROW FORMAT DELIMITED` indica que los datos están delimitados por un carácter específico.
+ La cláusula `FIELDS TERMINATED BY '\t'` especifica que los campos de los datos TSV están separados por el carácter de tabulación (“\$1t”).
+ La cláusula `STORED AS TEXTFILE` indica que los datos se almacenan como archivos de texto sin formato en Amazon S3.
Para consultar los datos, puede utilizar una instrucción `SELECT` sencilla como la siguiente:
```
SELECT * FROM planet_data
```
Para utilizar el ejemplo de creación de una tabla TSV propia en Athena, sustituya los nombres de tabla y columna por los nombres y tipos de datos de la tabla y las columnas propias, y actualice la cláusula `LOCATION` de modo que se dirija a la ruta de Amazon S3 en la que se almacenan los archivos TSV.
Para obtener más información sobre cómo crear tablas, consulte [Creación de tablas en Athena](creating-tables.md).
# CREATE TABLE AS
Crea una nueva tabla rellena con los resultados de una consulta [SELECT](select.md). Para crear una tabla vacía, utilice [CREATE TABLE](create-table.md). `CREATE TABLE AS` combina una instrucción DDL `CREATE TABLE` con una instrucción DML `SELECT` y, por lo tanto, técnicamente contiene tanto DDL como DML. Tenga en cuenta que, aunque `CREATE TABLE AS` se agrupa aquí con otras instrucciones DDL, las consultas CTAS en Athena se tratan como DML a efectos de Service Quotas. Para obtener información acerca de Service Quotas de Athena, consulte [Service Quotas](service-limits.md).
**nota**
Para las instrucciones CTAS, la configuración del propietario del bucket esperado no se aplica a la ubicación de la tabla de destino en Amazon S3. La configuración del propietario esperado del bucket se aplica solo a la ubicación de salida de Amazon S3 especificada para los resultados de las consultas de Athena. Para obtener más información, consulte [Especificación de una ubicación de resultados de consulta mediante la consola de Athena](query-results-specify-location-console.md).
Para obtener información adicional sobre `CREATE TABLE AS` más allá del alcance de este tema de referencia, consulte [Creación de una tabla a partir de los resultados de una consulta (CTAS)](ctas.md).
**Topics**
+ [Sinopsis](#synopsis)
+ [Propiedades de la tabla CTAS](#ctas-table-properties)
+ [Ejemplos](#ctas-table-examples)
## Sinopsis
```
CREATE TABLE table_name
[ WITH ( property_name = expression [, ...] ) ]
AS query
[ WITH [ NO ] DATA ]
```
Donde:
**WITH ( property\$1name = expression [, ...] )**
Una lista de propiedades de tabla CTAS opcionales, algunas de las cuales son específicas del formato de almacenamiento de datos. Consulte [Propiedades de la tabla CTAS](#ctas-table-properties).
**consulta**
Una consulta [SELECT](select.md) que se utiliza para crear una tabla nueva.
Si tiene previsto crear una consulta con particiones, especifique los nombres de columnas particionadas en último lugar en la lista de columnas en la instrucción `SELECT`.
**[ WITH [ NO ] DATA ]**
Si se utiliza `WITH NO DATA`, se crea una nueva tabla vacía con el mismo esquema que la tabla original.
**nota**
Para incluir encabezados de columna en el resultado de la consulta, puede utilizar una consulta `SELECT` simple en lugar de una consulta CTAS. Puede recuperar los resultados de la ubicación de los resultados de la consulta o descargar los resultados directamente por medio de la consola de Athena. Para obtener más información, consulte [Trabajo con resultados de la consulta y consultas recientes](querying.md).
## Propiedades de la tabla CTAS
Cada tabla CTAS de Athena tiene una lista de propiedades de tabla CTAS opcionales que se especifican mediante `WITH (property_name = expression [, ...] )`. Para obtener información sobre cómo usar estos parámetros, consulte [Ejemplos de consultas CTAS](ctas-examples.md).
** `WITH (property_name = expression [, ...], )` **
`table_type = ['HIVE', 'ICEBERG']`
Opcional. El valor predeterminado es `HIVE`. Especifica el tipo de tabla de la tabla resultante.
Ejemplo:
```
WITH (table_type ='ICEBERG')
```
`external_location = [location]`
Como las tablas de Iceberg no son externas, esta propiedad no se aplica a ellas. Para definir la ubicación raíz de una tabla de Iceberg en una instrucción CTAS, use la propiedad `location` que se describe más adelante en esta sección.
Opcional. La ubicación en la que Athena guarda la consulta CTAS en Amazon S3.
Ejemplo:
```
WITH (external_location ='s3://amzn-s3-demo-bucket/tables/parquet_table/')
```
Athena no usa la misma ruta para los resultados de la consulta dos veces. Si especifica la ubicación de forma manual, asegúrese de que la ubicación de Amazon S3 que especifica no tenga datos. Athena nunca intenta eliminar los datos. Si desea utilizar la misma ubicación de nuevo, borre manualmente los datos; de lo contrario, su consulta CTAS producirá un error.
Si ejecuta una consulta CTAS que especifica un `external_location` en un grupo de trabajo que [aplica una ubicación de resultados de consulta](workgroups-settings-override.md), la consulta devuelve un mensaje de error. Para ver la ubicación de los resultados de la consulta especificada para el grupo de trabajo, [consulte los detalles del grupo de trabajo](viewing-details-workgroups.md).
Si el grupo de trabajo anula la configuración del lado cliente para la ubicación de los resultados de la consulta, Athena crea la tabla en la siguiente ubicación:
```
s3://amzn-s3-demo-bucket/tables/query-id/
```
Si no utiliza la propiedad `external_location` para especificar una ubicación y el grupo de trabajo no anula la configuración del lado del cliente, Athena utiliza la [configuración del lado del cliente](query-results-specify-location-console.md) para la ubicación de resultados de consulta para crear la tabla en la siguiente ubicación:
```
s3://amzn-s3-demo-bucket/Unsaved-or-query-name/year/month/date/tables/query-id/
```
`is_external = [boolean]`
Opcional. Indica si la tabla es externa. El valor predeterminado es true. Para las tablas de Iceberg, se debe establecer en false.
Ejemplo:
```
WITH (is_external = false)
```
`location = [location]`
Obligatoria para las tablas de Iceberg. Especifica la ubicación raíz de la tabla de Iceberg que se va a crear a partir de los resultados de la consulta.
Ejemplo:
```
WITH (location ='s3://amzn-s3-demo-bucket/tables/iceberg_table/')
```
`field_delimiter = [delimiter]`
Opcional y específico de los formatos de almacenamiento de datos basados en texto. El delimitador de campo de un solo carácter para los archivos en CSV, TSV y archivos de texto. Por ejemplo, `WITH (field_delimiter = ',')`. Actualmente, no se admiten delimitadores de campos de caracteres múltiples para las consultas CTAS. Si no especifica un delimitador de campo, se utiliza `\001` de forma predeterminada.
`format = [storage_format]`
El formato de almacenamiento de los resultados de las consultas CTAS, como `ORC`, `PARQUET`, `AVRO`, `JSON`, `ION` o `TEXTFILE`. Los formatos permitidos para las tablas de Iceberg son `ORC`, `PARQUET` y `AVRO`. Si se omite, se utiliza `PARQUET` de forma predeterminada. El nombre de este parámetro `format`, debe incluirse en minúsculas o la consulta CTAS producirá un error.
Ejemplo:
```
WITH (format = 'PARQUET')
```
`bucketed_by = ARRAY[ column_name[,…], bucket_count = [int] ]`
Esta propiedad no se aplica a las tablas de Iceberg. Para las tablas de Iceberg, use el particionamiento con transformación de buckets.
Una matriz de buckets de datos. Si se omite, Athena no crea un bucket con sus datos en esta consulta.
`bucket_count = [int]`
Esta propiedad no se aplica a las tablas de Iceberg. Para las tablas de Iceberg, use el particionamiento con transformación de buckets.
El número de buckets de sus datos. Si se omite, Athena no crea un bucket con sus datos. Ejemplo:
```
CREATE TABLE bucketed_table WITH (
bucketed_by = ARRAY[column_name],
bucket_count = 30, format = 'PARQUET',
external_location ='s3://amzn-s3-demo-bucket/tables/parquet_table/'
) AS
SELECT
*
FROM
table_name
```
`partitioned_by = ARRAY[ col_name[,…] ]`
Esta propiedad no se aplica a las tablas de Iceberg. Para usar las transformaciones de partición en las tablas de Iceberg, use la propiedad `partitioning` que se describe más adelante en esta sección.
Opcional. Una matriz de columnas por las que se particiona la tabla CTAS. Compruebe que los nombres de las columnas particionadas aparecen en último lugar en la lista de columnas en la instrucción `SELECT`.
`partitioning = ARRAY[partition_transform, ...]`
Opcional. Especifica el particionamiento de la tabla de Iceberg que se va a crear. Iceberg admite una amplia variedad de transformaciones y evoluciones de partición. Las transformaciones de partición se resumen en la siguiente tabla.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/create-table-as.html)
Ejemplo:
```
WITH (partitioning = ARRAY['month(order_date)',
'bucket(account_number, 10)',
'country']))
```
`optimize_rewrite_min_data_file_size_bytes = [long]`
Opcional. Configuración específica de optimización de datos. Los archivos más pequeños que el valor especificado se incluyen para la optimización. El valor predeterminado es 0,75 veces el valor de `write_target_data_file_size_bytes`. Esta propiedad se aplica solo a las tablas de Iceberg. Para obtener más información, consulte [Optimización de las tablas de Iceberg](querying-iceberg-data-optimization.md).
Ejemplo:
```
WITH (optimize_rewrite_min_data_file_size_bytes = 402653184)
```
`optimize_rewrite_max_data_file_size_bytes = [long]`
Opcional. Configuración específica de optimización de datos. Los archivos más grandes que el valor especificado se incluyen para la optimización. El valor predeterminado es 1,8 veces el valor de `write_target_data_file_size_bytes`. Esta propiedad se aplica solo a las tablas de Iceberg. Para obtener más información, consulte [Optimización de las tablas de Iceberg](querying-iceberg-data-optimization.md).
Ejemplo:
```
WITH (optimize_rewrite_max_data_file_size_bytes = 966367641)
```
`optimize_rewrite_data_file_threshold = [int]`
Opcional. Configuración específica de optimización de datos. Si los archivos de datos que requieren optimización son menores que el límite determinado, los archivos no se reescriben. Esto permite acumular más archivos de datos para producir archivos más cercanos al tamaño objetivo y omitir cálculos innecesarios para ahorrar costos. El valor predeterminado es 5. Esta propiedad se aplica solo a las tablas de Iceberg. Para obtener más información, consulte [Optimización de las tablas de Iceberg](querying-iceberg-data-optimization.md).
Ejemplo:
```
WITH (optimize_rewrite_data_file_threshold = 5)
```
`optimize_rewrite_delete_file_threshold = [int]`
Opcional. Configuración específica de optimización de datos. Si los archivos de eliminación asociados a un archivo de datos son menores que el límite, el archivo de datos no se reescribe. Esto permite acumular más archivos de eliminación para cada archivo de datos para ahorrar costos. El valor predeterminado es 2. Esta propiedad se aplica solo a las tablas de Iceberg. Para obtener más información, consulte [Optimización de las tablas de Iceberg](querying-iceberg-data-optimization.md).
Ejemplo:
```
WITH (optimize_rewrite_delete_file_threshold = 2)
```
`vacuum_min_snapshots_to_keep = [int]`
Opcional. Configuración específica de Vacuum. El número mínimo de instantáneas más recientes que se deben retener. El valor predeterminado de es 1. Esta propiedad se aplica solo a las tablas de Iceberg. Para obtener más información, consulte [VACUUM](vacuum-statement.md).
La propiedad `vacuum_min_snapshots_to_keep` requiere la versión 3 del motor Athena.
Ejemplo:
```
WITH (vacuum_min_snapshots_to_keep = 1)
```
`vacuum_max_snapshot_age_seconds = [long]`
Opcional. Configuración específica de Vacuum. Un periodo en segundos que representa la antigüedad de las instantáneas que se van a retener. El valor predeterminado es 432 000 (5 días). Esta propiedad se aplica solo a las tablas de Iceberg. Para obtener más información, consulte [VACUUM](vacuum-statement.md).
La propiedad `vacuum_max_snapshot_age_seconds` requiere la versión 3 del motor Athena.
Ejemplo:
```
WITH (vacuum_max_snapshot_age_seconds = 432000)
```
`write_compression = [compression_format]`
Tipo de compresión que se va a utilizar para cualquier formato de almacenamiento que permita especificar la compresión. El valor `compression_format` especifica la compresión que se utilizará cuando los datos se escriben en la tabla. Puede especificar la compresión para los formatos de archivo `TEXTFILE`, `JSON`, `PARQUET` y `ORC`.
Por ejemplo, si la propiedad `format` especifica `PARQUET` como formato de almacenamiento, el valor de `write_compression` especifica el formato de compresión para Parquet. En este caso, especificar un valor para `write_compression` equivale a especificar un valor para `parquet_compression`.
De igual modo, si la propiedad `format` especifica `ORC` como formato de almacenamiento, el valor de `write_compression` especifica el formato de compresión para ORC. En este caso, especificar un valor para `write_compression` equivale a especificar un valor para `orc_compression`.
No se pueden especificar varias propiedades de tabla de formato de compresión en la misma consulta CTAS. Por ejemplo, no puede especificar `write_compression` y `parquet_compression` en la misma consulta. Lo mismo se aplica para `write_compression` y `orc_compression`. Para obtener información sobre los tipos de compresión admitidos para cada formato de archivo, consulte [Uso de la compresión en Athena](compression-formats.md).
`orc_compression = [compression_format]`
Tipo de compresión que se utiliza para el formato de archivo `ORC` cuando se escriben los datos de `ORC` en la tabla. Por ejemplo, `WITH (orc_compression = 'ZLIB')`. Los fragmentos del archivo `ORC` (excepto el `ORC` Postscript) se comprimen con la compresión que especifique. Si se omite, se utiliza la compresión ZLIB de forma predeterminada para `ORC`.
Por motivos de coherencia, le recomendamos que utilice la propiedad `write_compression` en lugar de `orc_compression`. Utilice la propiedad `format` para especificar el formato de almacenamiento como `ORC` y, a continuación, utilice la propiedad `write_compression` para especificar el formato de compresión que utilizará `ORC`.
`parquet_compression = [compression_format]`
Tipo de compresión que se utiliza para el formato de archivo Parquet cuando se escriben los datos de Parquet en la tabla. Por ejemplo, `WITH (parquet_compression = 'SNAPPY')`. Esta compresión se aplica a los fragmentos de columna de los archivos Parquet. Si se omite, se utiliza la compresión GZIP de forma predeterminada para Parquet.
Por motivos de coherencia, le recomendamos que utilice la propiedad `write_compression` en lugar de `parquet_compression`. Utilice la propiedad `format` para especificar el formato de almacenamiento como `PARQUET` y, a continuación, utilice la propiedad `write_compression` para especificar el formato de compresión que utilizará `PARQUET`.
`compression_level = [compression_level]`
Nivel de compresión que se debe utilizar. Esta propiedad solo se aplica a la compresión ZSTD. Los valores posibles están comprendidos entre 1 y 22. El valor predeterminado es 3. Para obtener más información, consulte [Uso de niveles de compresión de ZSTD](compression-support-zstd-levels.md).
## Ejemplos
Para obtener ejemplos de consultas CTAS, consulte los siguientes recursos.
+ [Ejemplos de consultas CTAS](ctas-examples.md)
+ [Uso de CTAS e INSERT INTO en ETL y análisis de datos](ctas-insert-into-etl.md)
+ [Use CTAS statements with Amazon Athena to reduce cost and improve performance](https://aws.amazon.com/blogs/big-data/using-ctas-statements-with-amazon-athena-to-reduce-cost-and-improve-performance/) (Utilice instrucciones CTAS con Amazon Athena para reducir los costos y mejorar el rendimiento)
+ [Uso de CTAS e INSERT INTO para evitar el límite de 100 particiones](ctas-insert-into.md)
# CREATE VIEW y CREATE PROTECTED MULTI DIALECT VIEW
Una vista es una tabla lógica a la que se puede hacer referencia en futuras consultas. Las vistas no contienen datos ni escriben datos. En su lugar, la consulta especificada por la vista se ejecuta cada vez que se hace referencia a la vista en otra consulta.
+ `CREATE VIEW` crea una vista de Athena a partir de una consulta `SELECT` especificada. Las vistas de Athena funcionan en Athena. Para más información acerca de las vistas de Athena, consulte [Trabajo con vistas](views.md).
+ `CREATE PROTECTED MULTI DIALECT VIEW` crea una vista de AWS Glue Data Catalog en el AWS Glue Data Catalog. Las vistas del AWS Glue Data Catalog proporcionan una única vista común entre los Servicios de AWS como Amazon Athena y Amazon Redshift. Para obtener más información acerca de las vistas del AWS Glue Data Catalog, consulte [Uso de vistas del Catálogo de datos en Athena](views-glue.md).
## CREATE VIEW
Crea una vista para usarla en Athena.
### Sinopsis
```
CREATE [ OR REPLACE ] VIEW view_name AS query
```
La cláusula opcional `OR REPLACE` le permite actualizar la vista existente sustituyéndola. Para obtener más información, consulte [Creación de vistas](views-console.md#creating-views).
### Ejemplos
Para crear una vista `test` a partir de la tabla `orders`, utilice una consulta similar a la siguiente:
```
CREATE VIEW test AS
SELECT
orderkey,
orderstatus,
totalprice / 2 AS half
FROM orders;
```
Para crear una vista `orders_by_date` a partir de la tabla `orders`, utilice la siguiente consulta:
```
CREATE VIEW orders_by_date AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
GROUP BY orderdate;
```
Para actualizar una vista existente, utilice un ejemplo similar al siguiente:
```
CREATE OR REPLACE VIEW test AS
SELECT orderkey, orderstatus, totalprice / 4 AS quarter
FROM orders;
```
Para obtener más información acerca del uso de vistas de Athena, consulte [Trabajo con vistas](views.md).
## CREATE PROTECTED MULTI DIALECT VIEW
Crea una vista del AWS Glue Data Catalog en el AWS Glue Data Catalog. Una vista del Catálogo de datos es un esquema de vista única que funciona en Athena y otros motores SQL, como Amazon Redshift y Amazon EMR.
### Sintaxis
```
CREATE [ OR REPLACE ] PROTECTED MULTI DIALECT VIEW view_name
SECURITY DEFINER
[ SHOW VIEW JSON ]
AS query
```
**OR REPLACE**
(Opcional) Sustituye la vista existente para actualizarla. No se puede reemplazar una vista del catálogo de datos si en la vista hay dialectos SQL de otros motores. Si el motor de llamada tiene el único dialecto SQL presente en la vista, la vista se puede reemplazar.
**PROTECTED**
Palabra clave necesaria. Especifica que la vista está protegida contra las filtraciones de datos. Las vistas de catálogo de datos solo se pueden crear como una vista `PROTECTED`.
**MULTI DIALECT**
Especifica que la vista admite los dialectos SQL de diferentes motores de consulta y, por lo tanto, esos motores pueden leerla.
**SECURITY DEFINER**
Especifica que la semántica del definidor está vigente en esta vista. La semántica de los definidores significa que los permisos de lectura en vigencia de las tablas subyacentes pertenecen a la entidad principal o al rol que definió la vista y no a la entidad principal que realiza la lectura real.
**SHOW VIEW JSON**
(Opcional) Devuelve el archivo JSON de la especificación de la vista del Catálogo de datos sin crear una vista. Esta opción de “ejecución de práctica” es útil cuando se desea validar el SQL de la vista y devolver los metadatos de la tabla que utilizará AWS Glue.
### Ejemplo
En el siguiente ejemplo se crea la vista del catálogo de datos de `orders_by_date` en función de una consulta de la tabla `orders`.
```
CREATE PROTECTED MULTI DIALECT VIEW orders_by_date
SECURITY DEFINER
AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
WHERE order_city = 'SEATTLE'
GROUP BY orderdate
```
Para más información acerca de cómo usar las vistas del AWS Glue Data Catalog, consulte [Uso de vistas del Catálogo de datos en Athena](views-glue.md).
# DESCRIBE
Muestra una o más columnas, incluidas las columnas de partición, de la tabla especificada. Este comando resulta útil para examinar los atributos de columnas complejas.
## Sinopsis
```
DESCRIBE [EXTENDED | FORMATTED] [db_name.]table_name [PARTITION partition_spec] [col_name ( [.field_name] | [.'$elem$'] | [.'$key$'] | [.'$value$'] )]
```
**importante**
La sintaxis de esta instrucción es `DESCRIBE table_name`, no `DESCRIBE TABLE table_name`. El uso de la última sintaxis da como resultado el mensaje de error FAILED: SemanticException [Error 10001]: Table not found table (ERROR: Excepción semántica [Error 10001]: tabla no encontrada).
## Parámetros
**[EXTENDED \$1 FORMATTED]**
Determina el formato de la salida. Si se omiten estos parámetros, se muestran los nombres de las columnas y sus tipos de datos correspondientes, incluidas las columnas de partición, en formato tabular. Si se especifica `FORMATTED`, se muestran no solo los nombres de las columnas y los tipos de datos en formato tabular, sino también información detallada de las tablas y el almacenamiento. `EXTENDED` muestra información de columnas y tipos de datos en formato tabular y metadatos detallados de la tabla en formato serializado de Thrift. Este formato es menos legible y es útil principalmente para depurar.
**[PARTITION partition\$1spec]**
Si se incluye, enumera los metadatos de la partición que especifica `partition_spec`, donde `partition_spec` tiene el formato `(partition_column = partition_col_value, partition_column = partition_col_value, ...)`.
**[col\$1name ( [.field\$1name] \$1 [.'\$1elem\$1'] \$1 [.'\$1key\$1'] \$1 [.'\$1value\$1'] )\$1 ]**
Especifica la columna y los atributos que deben examinarse. Puede especificar `.field_name` para un elemento de una estructura, `'$elem$'` para un elemento matriz, `'$key$'` para una clave de asignación y `'$value$'` para un valor de mapa. Puede especificarlo recursivamente para explora en profundidad la columna compleja.
### Ejemplos
```
DESCRIBE orders
```
```
DESCRIBE FORMATTED mydatabase.mytable PARTITION (part_col = 100) columnA;
```
En la consulta y el resultado siguientes, se muestra información de columnas y tipos de datos de una tabla `impressions` basada en los datos de muestra de Amazon EMR.
```
DESCRIBE impressions
```
```
requestbegintime string from deserializer
adid string from deserializer
impressionid string from deserializer
referrer string from deserializer
useragent string from deserializer
usercookie string from deserializer
ip string from deserializer
number string from deserializer
processid string from deserializer
browsercokie string from deserializer
requestendtime string from deserializer
timers struct from deserializer
threadid string from deserializer
hostname string from deserializer
sessionid string from deserializer
dt string
# Partition Information
# col_name data_type comment
dt string
```
En la consulta y el resultado de ejemplo siguientes, se muestra el resultado de la misma tabla cuando se utiliza la opción `FORMATTED`.
```
DESCRIBE FORMATTED impressions
```
```
requestbegintime string from deserializer
adid string from deserializer
impressionid string from deserializer
referrer string from deserializer
useragent string from deserializer
usercookie string from deserializer
ip string from deserializer
number string from deserializer
processid string from deserializer
browsercokie string from deserializer
requestendtime string from deserializer
timers struct from deserializer
threadid string from deserializer
hostname string from deserializer
sessionid string from deserializer
dt string
# Partition Information
# col_name data_type comment
dt string
# Detailed Table Information
Database: sampledb
Owner: hadoop
CreateTime: Thu Apr 23 02:55:21 UTC 2020
LastAccessTime: UNKNOWN
Protect Mode: None
Retention: 0
Location: s3://us-east-1.elasticmapreduce/samples/hive-ads/tables/impressions
Table Type: EXTERNAL_TABLE
Table Parameters:
EXTERNAL TRUE
transient_lastDdlTime 1587610521
# Storage Information
SerDe Library: org.openx.data.jsonserde.JsonSerDe
InputFormat: org.apache.hadoop.mapred.TextInputFormat
OutputFormat: org.apache.hadoop.hive.ql.io.IgnoreKeyTextOutputFormat
Compressed: No
Num Buckets: -1
Bucket Columns: []
Sort Columns: []
Storage Desc Params:
paths requestbegintime, adid, impressionid, referrer, useragent, usercookie, ip
serialization.format 1
```
En la consulta y el resultado de ejemplo siguientes, se muestra el resultado de la misma tabla cuando se utiliza la opción `EXTENDED`. La información detallada de la tabla se muestra en una sola línea, pero se formatea aquí para que sea legible.
```
DESCRIBE EXTENDED impressions
```
```
requestbegintime string from deserializer
adid string from deserializer
impressionid string from deserializer
referrer string from deserializer
useragent string from deserializer
usercookie string from deserializer
ip string from deserializer
number string from deserializer
processid string from deserializer
browsercokie string from deserializer
requestendtime string from deserializer
timers struct from deserializer
threadid string from deserializer
hostname string from deserializer
sessionid string from deserializer
dt string
# Partition Information
# col_name data_type comment
dt string
Detailed Table Information Table(tableName:impressions, dbName:sampledb, owner:hadoop, createTime:1587610521,
lastAccessTime:0, retention:0, sd:StorageDescriptor(cols:[FieldSchema(name:requestbegintime, type:string, comment:null),
FieldSchema(name:adid, type:string, comment:null), FieldSchema(name:impressionid, type:string, comment:null),
FieldSchema(name:referrer, type:string, comment:null), FieldSchema(name:useragent, type:string, comment:null),
FieldSchema(name:usercookie, type:string, comment:null), FieldSchema(name:ip, type:string, comment:null),
FieldSchema(name:number, type:string, comment:null), FieldSchema(name:processid, type:string, comment:null),
FieldSchema(name:browsercokie, type:string, comment:null), FieldSchema(name:requestendtime, type:string, comment:null),
FieldSchema(name:timers, type:struct, comment:null), FieldSchema(name:threadid,
type:string, comment:null), FieldSchema(name:hostname, type:string, comment:null), FieldSchema(name:sessionid,
type:string, comment:null)], location:s3://us-east-1.elasticmapreduce/samples/hive-ads/tables/impressions,
inputFormat:org.apache.hadoop.mapred.TextInputFormat,
outputFormat:org.apache.hadoop.hive.ql.io.IgnoreKeyTextOutputFormat, compressed:false, numBuckets:-1,
serdeInfo:SerDeInfo(name:null, serializationLib:org.openx.data.jsonserde.JsonSerDe, parameters:{serialization.format=1,
paths=requestbegintime, adid, impressionid, referrer, useragent, usercookie, ip}), bucketCols:[], sortCols:[], parameters:{},
skewedInfo:SkewedInfo(skewedColNames:[], skewedColValues:[], skewedColValueLocationMaps:{}),
storedAsSubDirectories:false), partitionKeys:[FieldSchema(name:dt, type:string, comment:null)],
parameters:{EXTERNAL=TRUE, transient_lastDdlTime=1587610521}, viewOriginalText:null, viewExpandedText:null,
tableType:EXTERNAL_TABLE)
```
# DESCRIBE VIEW
Muestra la lista de las columnas de la vista especificada del AWS Glue Data Catalog o Athena. Resulta útil para examinar los atributos de una vista compleja.
En el caso de las vistas del Catálogo de datos, el resultado de la instrucción se controla mediante el control de acceso de Lake Formation y muestra solo las columnas a las que tiene acceso el solicitante.
## Sinopsis
```
DESCRIBE [db_name.]view_name
```
## Ejemplo
```
DESCRIBE orders
```
Consulte también [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [SHOW VIEWS](show-views.md) y [DROP VIEW](drop-view.md).
# DROP DATABASE
Borra del catálogo la base de datos nombrada. Si la base de datos contiene tablas, debe anular las tablas antes de ejecutar `DROP DATABASE` o bien utilizar la cláusula `CASCADE`. El uso de `DATABASE` y `SCHEMA` es intercambiable. Significan lo mismo.
## Sinopsis
```
DROP {DATABASE | SCHEMA} [IF EXISTS] database_name [RESTRICT | CASCADE]
```
## Parámetros
**[IF EXISTS]**
Hace que se suprima el error si `database_name` no existe.
**[RESTRICT\$1CASCADE]**
Determina cómo se consideran las tablas de dentro de `database_name` durante la operación `DROP`. Si especifica `RESTRICT`, la base de datos no se anula si contiene tablas. Este es el comportamiento predeterminado. Si especifica `CASCADE`, se anularán la base de datos y todas sus tablas.
## Ejemplos
```
DROP DATABASE clickstreams;
```
```
DROP SCHEMA IF EXISTS clickstreams CASCADE;
```
**nota**
Cuando intenta eliminar una base de datos cuyo nombre contenga caracteres especiales (por ejemplo, `my-database`), puede recibir un mensaje de error. Para resolver este problema, pruebe a incluir el nombre de la base de datos entre tildes invertidas (`). Para más información sobre la asignación de nombres de bases de datos en Athena, consulte [Nombrar tablas, bases de datos y columnas](tables-databases-columns-names.md).
# DROP TABLE
Elimina la definición de mesa de metadatos de la tabla llamada `table_name`. Cuando se anula una tabla externa, los datos subyacentes permanecen intactos.
## Sinopsis
```
DROP TABLE [IF EXISTS] table_name
```
## Parámetros
**[ IF EXISTS ]**
Hace que se suprima el error si `table_name` no existe.
## Ejemplos
```
DROP TABLE fulfilled_orders
```
```
DROP TABLE IF EXISTS fulfilled_orders
```
Cuando utilice el Editor de consultas de la consola de Athena para eliminar una tabla que tenga caracteres especiales distintos del guion bajo (\$1), utilice acentos graves, como en el ejemplo siguiente.
```
DROP TABLE `my-athena-database-01.my-athena-table`
```
Cuando se utiliza el conector JDBC para eliminar una tabla que tiene caracteres especiales, no se requieren acentos graves.
```
DROP TABLE my-athena-database-01.my-athena-table
```
# DROP VIEW
Quita (elimina) una vista existente de Athena o AWS Glue Data Catalog. La cláusula `IF EXISTS` opcional provoca la eliminación del error si la vista no existe.
En el caso de las vistas del Catálogo de datos, quita la vista solo si la sintaxis (dialecto) de la vista de Athena está presente en la vista del Catálogo de datos. Por ejemplo, si un usuario llama a `DROP VIEW` desde Athena, la vista solo se elimina si el dialecto de Athena existe en la vista. De lo contrario, la operación no se llevará a cabo correctamente. Para eliminar las vistas del Catálogo de datos se requieren permisos de administrador o definidor de vistas de Lake Formation.
Para obtener más información, consulte [Trabajo con vistas](views.md) y [Uso de vistas del Catálogo de datos en Athena](views-glue.md).
## Sinopsis
```
DROP VIEW [ IF EXISTS ] view_name
```
## Ejemplos
```
DROP VIEW orders_by_date
```
```
DROP VIEW IF EXISTS orders_by_date
```
Consulte también [CREATE VIEW y CREATE PROTECTED MULTI DIALECT VIEW](create-view.md), [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [SHOW VIEWS](show-views.md) y [DESCRIBE VIEW](describe-view.md).
# MSCK REPAIR TABLE
Utilice el comando `MSCK REPAIR TABLE` para actualizar los metadatos del catálogo después de agregar particiones compatibles con Hive.
El comando `MSCK REPAIR TABLE` analiza un sistema de archivos como Amazon S3 en busca de particiones compatibles con Hive que se agregaron al sistema de archivos después de crear la tabla. `MSCK REPAIR TABLE` compara las particiones en los metadatos de la tabla y las particiones en S3. Si hay nuevas particiones en la ubicación de S3 que especificó al crear la tabla, agrega esas particiones a los metadatos y a la tabla Athena.
Al agregar particiones físicas, los metadatos del catálogo se vuelven incoherentes con el diseño de los datos en el sistema de archivos, y la información sobre las nuevas particiones debe agregarse al catálogo. Para actualizar los metadatos, ejecute `MSCK REPAIR TABLE` para consultar los datos en las nuevas particiones de Athena.
**nota**
`MSCK REPAIR TABLE` solo agrega particiones a los metadatos; no las elimina. Para eliminar particiones de los metadatos después de haber eliminado las particiones manualmente en Amazon S3, ejecute el comando `ALTER TABLE table-name DROP PARTITION`. Para obtener más información, consulte [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md).
## Consideraciones y limitaciones
Al utilizar `MSCK REPAIR TABLE`, tenga en cuenta los siguientes puntos:
+ Es posible que tarde un tiempo en añadir todas las particiones. Si esta operación agota el tiempo de espera, se encontrará en un estado incompleto en el que solo se habrán añadido unas cuantas particiones al catálogo. Debe ejecutar `MSCK REPAIR TABLE` en la misma tabla hasta que se hayan agregado todas las particiones. Para obtener más información, consulte [Partición de datos](partitions.md).
+ En el caso de las particiones que no son compatibles con Hive, utilice [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) para cargar las particiones de modo que pueda consultar los datos.
+ Las ubicaciones de partición que se van a utilizar con Athena deben utilizar el protocolo `s3` (por ejemplo, `s3://amzn-s3-demo-bucket/folder/`). En Athena, las ubicaciones que utilizan otros protocolos (por ejemplo, `s3a://bucket/folder/`) producirán errores de consulta cuando se ejecuten consultas `MSCK REPAIR TABLE` en las tablas que contienen.
+ Dado que `MSCK REPAIR TABLE` analiza una carpeta y sus subcarpetas para encontrar un esquema de partición coincidente, asegúrese de mantener los datos de tablas separadas en jerarquías de carpetas separadas. Por ejemplo, supongamos que tiene los datos de la tabla 1 en `s3://amzn-s3-demo-bucket1` y los datos de la tabla 2 en `s3://amzn-s3-demo-bucket1/table-2-data`. Si ambas tablas están particionadas por cadena, `MSCK REPAIR TABLE` agregará las particiones de la tabla 2 a la tabla 1. Para evitarlo, utilice estructuras de carpetas independientes, como `s3://amzn-s3-demo-bucket1` y `s3://amzn-s3-demo-bucket2` en su lugar. Tenga en cuenta que este comportamiento es coherente con Amazon EMR y Apache Hive.
+ Debido a un problema conocido, `MSCK REPAIR TABLE` falla silenciosamente cuando los valores de partición contienen el carácter de dos puntos (`:`) (por ejemplo, cuando el valor de la partición es una marca de tiempo). Como alternativa, utilice [ALTER TABLE ADD PARTITION](alter-table-add-partition.md).
+ `MSCK REPAIR TABLE` no agrega nombres de columnas de particiones que comiencen por un carácter de guion bajo (\$1). Para evitar este límite, utilice [ALTER TABLE ADD PARTITION](alter-table-add-partition.md).
## Sinopsis
```
MSCK REPAIR TABLE table_name
```
## Ejemplos
```
MSCK REPAIR TABLE orders;
```
## Solución de problemas
Después de ejecutar `MSCK REPAIR TABLE`, si Athena no agrega las particiones a la tabla en AWS Glue Data Catalog, verifique lo siguiente:
+ **Acceso a AWS Glue**: asegúrese de que el rol de AWS Identity and Access Management (IAM) tenga una política que permita la acción `glue:BatchCreatePartition`. Para obtener más información, consulte [Permitir glue:BatchCreatePartition en la política de IAM](#msck-repair-table-troubleshooting-allow-gluebatchcreatepartition-in-the-policy) más adelante en este documento.
+ **Acceso a Amazon S3**: asegúrese de que el rol tenga una política con permisos suficientes para acceder a Amazon S3, incluida la acción [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html). Para obtener un ejemplo de las acciones de Amazon S3 que debe permitir, consulte el ejemplo de política de bucket en [Configuración del acceso entre cuentas en Athena a los buckets de Amazon S3](cross-account-permissions.md).
+ **Mayúsculas en las claves de objeto en Amazon S3**: asegúrese de que la ruta de Amazon S3 esté escrita en minúsculas en lugar de una combinación de mayúsculas y minúsculas (por ejemplo, `userid` en lugar de `userId`) o use `ALTER TABLE ADD PARTITION` para especificar los nombres de las claves de objeto. Para obtener más información, consulte [Cambiar o redefinir la ruta de Amazon S3](#msck-repair-table-troubleshooting-change-or-redefine-the-amazon-s3-path) más adelante en este documento.
+ **Tiempos de espera de consulta**: `MSCK REPAIR TABLE` se utiliza mejor al crear una tabla por primera vez o cuando hay incertidumbre acerca de la paridad entre los datos y los metadatos de partición. Si utiliza `MSCK REPAIR TABLE` para agregar particiones nuevas con frecuencia (por ejemplo, a diario) y experimentan tiempos de espera de consulta, considere usar [ALTER TABLE ADD PARTITION](alter-table-add-partition.md).
+ **Faltan particiones en el sistema de archivos**: si elimina una partición de forma manual en Amazon S3 y, a continuación, ejecuta `MSCK REPAIR TABLE`, puede recibir el mensaje de error Faltan particiones en el sistema de archivos. Esto sucede porque `MSCK REPAIR TABLE` no elimina particiones obsoletas de los metadatos de la tabla. Para quitar las particiones eliminadas de los metadatos de la tabla, ejecute [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md) en su lugar. Tenga en cuenta que [SHOW PARTITIONS](show-partitions.md) (Mostrar particiones) muestra de manera similar solo las particiones en los metadatos, no las particiones en el sistema de archivos.
+ **"Error “NullPointerException name is null” (El nombre NullPointerException es nulo**
Si utiliza la operación de la API [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html) de AWS Glue o la plantilla [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html) de CloudFormation para crear una tabla para su uso en Athena sin especificar la propiedad `TableType`, y luego ejecuta una consulta DDL como `SHOW CREATE TABLE` o `MSCK REPAIR TABLE`, puede recibir el mensaje de error FAILED: NullPointerException Name is null (ERROR: el nombre NullPointerException es nulo).
Para resolver el error, especifique un valor para el atributo `TableType` [TableInput](https://docs.aws.amazon.com/glue/latest/webapi/API_TableInput.html) como parte de la llamada a la API `CreateTable` de AWS Glue o la [plantilla CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html). Entre los valores posibles para `TableType`, se incluyen `EXTERNAL_TABLE` o `VIRTUAL_VIEW`.
Este requisito se aplica únicamente cuando se crea una tabla mediante la operación de la API `CreateTable` de AWS Glue o la plantilla `AWS::Glue::Table`. Si crea una tabla para Athena mediante una instrucción DDL o un rastreador de AWS Glue, la propiedad `TableType` se define automáticamente.
Las secciones siguientes proporcionan algunos detalles adicionales.
### Permitir glue:BatchCreatePartition en la política de IAM
Revise las políticas de IAM asociadas al rol que utiliza para ejecutar `MSCK REPAIR TABLE`. Cuando [utiliza AWS Glue Data Catalog con Athena](data-sources-glue.md), la política de IAM debe permitir la acción `glue:BatchCreatePartition`. Para obtener un ejemplo de una política de IAM que permita la acción `glue:BatchCreatePartition`, consulte [AWSPolítica administrada de : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy).
### Cambiar o redefinir la ruta de Amazon S3
Si una o más claves de objeto de la ruta de Amazon S3 están en mayúsculas y minúsculas y no solo en minúsculas, `MSCK REPAIR TABLE` podría no agregar las particiones a AWS Glue Data Catalog. Por ejemplo, si la ruta de Amazon S3 incluye el nombre de la clave del objeto `userId`, es posible que las siguientes particiones no se agreguen al AWS Glue Data Catalog:
```
s3://amzn-s3-demo-bucket/path/userId=1/
s3://amzn-s3-demo-bucket/path/userId=2/
s3://amzn-s3-demo-bucket/path/userId=3/
```
Para resolver este problema, siga uno de estos pasos:
+ Utilice minúsculas en lugar de una combinación de mayúsculas y minúsculas cuando cree las claves de objeto de Amazon S3:
```
s3://amzn-s3-demo-bucket/path/userid=1/
s3://amzn-s3-demo-bucket/path/userid=2/
s3://amzn-s3-demo-bucket/path/userid=3/
```
+ Use [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) para redefinir la ubicación, como en el siguiente ejemplo:
```
ALTER TABLE table_name ADD [IF NOT EXISTS]
PARTITION (userId=1)
LOCATION 's3://amzn-s3-demo-bucket/path/userId=1/'
PARTITION (userId=2)
LOCATION 's3://amzn-s3-demo-bucket/path/userId=2/'
PARTITION (userId=3)
LOCATION 's3://amzn-s3-demo-bucket/path/userId=3/'
```
Tenga en cuenta que, aunque los nombres de las claves de objeto de Amazon S3 pueden estar en mayúsculas, los nombres de los buckets de Amazon S3 deben estar siempre en minúsculas. Para obtener más información, consulte las [pautas de nomenclatura de claves de objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines) y las [reglas de nomenclatura de buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) en la *Guía del usuario de Amazon S3*.
# SHOW COLUMNS
Solo muestra los nombres de las columnas de una única tabla, vista de Athena o vista del Catálogo de datos especificada. Para obtener información más detallada de las vistas de Athena, consulte el AWS Glue Data Catalog en su lugar. Para obtener información y ejemplos, consulte las siguientes secciones del tema [Consulta de AWS Glue Data Catalog](querying-glue-catalog.md):
+ Para ver metadatos de columna, como el tipo de datos, consulte [Enumeración o búsqueda de las columnas de una tabla o vista especificadas](querying-glue-catalog-listing-columns.md).
+ Para ver todas las columnas de todas las tablas en una base de datos específica en `AwsDataCatalog`, consulte [Enumeración o búsqueda de las columnas de una tabla o vista especificadas](querying-glue-catalog-listing-columns.md).
+ Para ver todas las columnas de todas las tablas en todas las bases de datos en `AwsDataCatalog`, consulte [Enumeración de todas las columnas de todas las tablas](querying-glue-catalog-listing-all-columns-for-all-tables.md).
+ Para ver las columnas que tienen en común tablas específicas de una base de datos, consulte [Enumeración de las columnas que tienen en común tablas específicas](querying-glue-catalog-listing-columns-in-common.md).
En el caso de las vistas del Catálogo de datos, el resultado de la instrucción se controla mediante el control de acceso de Lake Formation y muestra solo las columnas a las que tiene acceso el solicitante.
## Sinopsis
```
SHOW COLUMNS {FROM|IN} database_name.table_or_view_name
```
```
SHOW COLUMNS {FROM|IN} table_or_view_name [{FROM|IN} database_name]
```
Las palabras clave `FROM` y `IN` se pueden utilizar indistintamente. Si *table\$1or\$1view\$1name* o *database\$1name* tiene caracteres especiales como guiones, indique el nombre con acentos invertidos (por ejemplo, ``my-database`.`my-table``). No indique *table\$1or\$1view\$1name* o *database\$1name* con comillas simples o dobles. Actualmente, el uso de `LIKE` y las expresiones de asociación de patrones no son compatibles.
## Ejemplos
Los siguientes ejemplos equivalentes muestran las columnas de la tabla `orders` en la base de datos `customers`. En los dos primeros ejemplos se presupone que `customers` es la base de datos actual.
```
SHOW COLUMNS FROM orders
```
```
SHOW COLUMNS IN orders
```
```
SHOW COLUMNS FROM customers.orders
```
```
SHOW COLUMNS IN customers.orders
```
```
SHOW COLUMNS FROM orders FROM customers
```
```
SHOW COLUMNS IN orders IN customers
```
# SHOW CREATE TABLE
Analiza una tabla existente con el nombre `table_name` para generar la consulta que la creó.
## Sinopsis
```
SHOW CREATE TABLE [db_name.]table_name
```
## Parámetros
**TABLE [db\$1name.]table\$1name**
El parámetro `db_name` es opcional. Si se omite, se usa como contexto predeterminado la base de datos actual.
El nombre de la tabla es obligatorio.
## Ejemplos
```
SHOW CREATE TABLE orderclickstoday;
```
```
SHOW CREATE TABLE `salesdata.orderclickstoday`;
```
## Resolución de problemas
Si utiliza la operación de la API [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html) de AWS Glue o la plantilla [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html) de CloudFormation para crear una tabla para su uso en Athena sin especificar la propiedad `TableType`, y luego ejecuta una consulta DDL como `SHOW CREATE TABLE` o `MSCK REPAIR TABLE`, puede recibir el mensaje de error FAILED: NullPointerException Name is null (ERROR: el nombre NullPointerException es nulo).
Para resolver el error, especifique un valor para el atributo `TableType` [TableInput](https://docs.aws.amazon.com/glue/latest/webapi/API_TableInput.html) como parte de la llamada a la API `CreateTable` de AWS Glue o la [plantilla CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html). Entre los valores posibles para `TableType`, se incluyen `EXTERNAL_TABLE` o `VIRTUAL_VIEW`.
Este requisito se aplica únicamente cuando se crea una tabla mediante la operación de la API `CreateTable` de AWS Glue o la plantilla `AWS::Glue::Table`. Si crea una tabla para Athena mediante una instrucción DDL o un rastreador de AWS Glue, la propiedad `TableType` se define automáticamente.
# SHOW CREATE VIEW
Muestra la instrucción SQL que creó la vista especificada de Athena o del Catálogo de datos. El SQL devuelto muestra la sintaxis de creación de vistas utilizada en Athena. Para llamar a `SHOW CREATE VIEW` en las vistas del Catálogo de datos se requieren permisos de administrador o definidor de vistas de Lake Formation.
## Sinopsis
```
SHOW CREATE VIEW view_name
```
## Ejemplos
```
SHOW CREATE VIEW orders_by_date
```
Consulte también [CREATE VIEW y CREATE PROTECTED MULTI DIALECT VIEW](create-view.md) y [DROP VIEW](drop-view.md).
# SHOW DATABASES
Enumera todas las bases de datos definidas en el metaalmacén. Puede utilizar `DATABASES` o `SCHEMAS`. Significan lo mismo.
El equivalente programático de `SHOW DATABASES` es la acción de la API de Athena [ListDatabases](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListDatabases.html). El método equivalente en AWS SDK para Python (Boto3) es [list\$1databases](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/athena/client/list_databases.html).
## Sinopsis
```
SHOW {DATABASES | SCHEMAS} [LIKE 'regular_expression']
```
## Parámetros
**[LIKE '*regular\$1expression*']**
Filtra la lista de bases de datos para obtener las bases de datos que coinciden con la `regular_expression` que especifica. Para la coincidencia de caracteres comodín, puede usar la combinación `.*`, que coincide con cualquier carácter cero en veces ilimitadas.
## Ejemplos
```
SHOW SCHEMAS;
```
```
SHOW DATABASES LIKE '.*analytics';
```
# SHOW PARTITIONS
Muestra todas las particiones de una tabla de Athena en orden sin clasificar.
## Sinopsis
```
SHOW PARTITIONS table_name
```
+ Para mostrar las particiones en una tabla y enumerarlas en un orden específico, consulte la sección [Enumeración de las particiones de una tabla específica](querying-glue-catalog-listing-partitions.md) de la página [Consulta de AWS Glue Data Catalog](querying-glue-catalog.md).
+ Para ver el contenido de una partición, consulte la sección [Consulta de los datos](partitions.md#query-the-data) de la página [Partición de datos](partitions.md).
+ `SHOW PARTITIONS` no enumera las particiones que están proyectadas por Athena pero no están registradas en el catálogo de AWS Glue. Para obtener información sobre la proyección de particiones, consulte [Uso de proyección de particiones con Amazon Athena](partition-projection.md).
+ `SHOW PARTITIONS` enumera las particiones en metadatos, no las particiones en el sistema de archivos real. Para actualizar los metadatos después de eliminar particiones manualmente en Amazon S3, ejecute [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md).
## Ejemplos
En la siguiente consulta de ejemplo se muestran las particiones de la tabla `flight_delays_csv`, que muestra los datos de la tabla de vuelos del Departamento de Transporte de los Estados Unidos. Para obtener más información acerca de la tabla `flight_delays_csv`, consulte [Lazy Simple SerDe para CSV, TSV y archivos con delimitación personalizada](lazy-simple-serde.md). La tabla está particionada por año.
```
SHOW PARTITIONS flight_delays_csv
```
**Resultados**
```
year=2007
year=2015
year=1999
year=1993
year=1991
year=2003
year=1996
year=2014
year=2004
year=2011
...
```
En la siguiente consulta de ejemplo se muestran las particiones de la tabla `impressions`, que contiene datos de muestra de navegación web. Para obtener más información acerca de la tabla `impressions`, consulte [Partición de datos](partitions.md). La tabla está particionada por la columna `dt` (datetime).
```
SHOW PARTITIONS impressions
```
**Resultados**
```
dt=2009-04-12-16-00
dt=2009-04-13-18-15
dt=2009-04-14-00-20
dt=2009-04-12-13-00
dt=2009-04-13-02-15
dt=2009-04-14-12-05
dt=2009-04-14-06-15
dt=2009-04-12-21-15
dt=2009-04-13-22-15
...
```
### Listado de particiones en orden clasificado
Para ordenar las particiones en la lista de resultados, utilice la siguiente sintaxis `SELECT` en lugar de `SHOW PARTITIONS`.
```
SELECT * FROM database_name."table_name$partitions" ORDER BY column_name
```
La consulta a continuación muestra la lista de particiones para el ejemplo `flight_delays_csv`, pero en orden clasificado.
```
SELECT * FROM "flight_delays_csv$partitions" ORDER BY year
```
**Resultados**
```
year
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
...
```
Para obtener más información, consulte la sección [Enumeración de las particiones de una tabla específica](querying-glue-catalog-listing-partitions.md) de la página [Consulta de AWS Glue Data Catalog](querying-glue-catalog.md).
# SHOW TABLES
Enumera todas las tablas de base y vistas de una base de datos.
**nota**
El parámetro [StatementType](https://docs.aws.amazon.com/athena/latest/APIReference/API_QueryExecution.html#athena-Type-QueryExecution-StatementType) correspondiente a `SHOW TABLES` en la operación de la API [GetQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetQueryExecution.html) se clasifica como `UTILITY`, no `DDL`.
## Sinopsis
```
SHOW TABLES [IN database_name] ['regular_expression']
```
## Parameters
**[IN database\$1name]**
Especifica la `database_name` cuyas tablas se enumerarán. Si se omite, se presupondrá que es la base de datos del contexto actual.
`SHOW TABLES` puede fallar si `database_name` usa un [carácter no admitido](tables-databases-columns-names.md), como un guion. Como solución alternativa, intente incluir el nombre de la base de datos entre comillas hacia atrás.
**['regular\$1expression']**
Filtra la lista de tablas para obtener las tablas que coinciden con la `regular_expression` que especifica. Para indicar cualquier carácter en las tablas `AWSDataCatalog`, puede utilizar la expresión comodín `*` o `.*`. Para las bases de datos de Apache Hive, utilice la expresión comodín `.*`. Para indicar una opción entre caracteres, utilice el carácter `|`.
## Ejemplos
**Example – Mostrar todas las tablas de la base de datos `sampledb`**
```
SHOW TABLES IN sampledb
```
`Results`
```
alb_logs
cloudfront_logs
elb_logs
flights_2016
flights_parquet
view_2016_flights_dfw
```
**Example – Mostrar los nombres de todas las tablas de `sampledb` que incluyen la palabra “flights” (vuelos)**
```
SHOW TABLES IN sampledb '*flights*'
```
`Results`
```
flights_2016
flights_parquet
view_2016_flights_dfw
```
**Example – Mostrar los nombres de todas las tablas de `sampledb` que terminan con la palabra “logs” (registros)**
```
SHOW TABLES IN sampledb '*logs'
```
`Results`
```
alb_logs
cloudfront_logs
elb_logs
```
# SHOW TBLPROPERTIES
Muestra las propiedades de la tabla indicada.
## Sinopsis
```
SHOW TBLPROPERTIES table_name [('property_name')]
```
## Parámetros
**[('property\$1name')]**
Si se especifica, solo se muestra el valor de la propiedad `property_name`.
## Ejemplos
```
SHOW TBLPROPERTIES orders;
```
```
SHOW TBLPROPERTIES orders('comment');
```
# SHOW VIEWS
Muestra las vistas de Athena o del Catálogo de datos en una lista de valores de tipo `STRING`. Cada valor de la lista es el nombre de una vista de la base de datos especificada o de la base de datos actual si se omite el nombre de la base de datos. Utilice la cláusula opcional `LIKE` con una expresión regular para limitar la lista de nombres de vista. En el caso de las vistas del Catálogo de datos, enumera solo las vistas que utilizan la sintaxis SQL de Athena. Se excluyen las demás vistas del Catálogo de datos.
## Sinopsis
```
SHOW VIEWS [IN database_name] [LIKE 'regular_expression']
```
### Parámetros
**[IN database\$1name]**
Especifica el `database_name` a partir de la cual se enumerarán las vistas. Si se omite, se presupondrá que es la base de datos del contexto actual.
**[LIKE 'regular\$1expression']**
Filtra la lista de vistas para obtener las vistas que coinciden con la `regular_expression` que especifique. Solo se puede utilizar el carácter comodín `*`, que equivale a cualquier carácter, o el comodín `|`, que indica una elección entre caracteres.
## Ejemplos
```
SHOW VIEWS
```
```
SHOW VIEWS IN marketing_analytics LIKE 'orders*'
```
Consulte también [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [DESCRIBE VIEW](describe-view.md) y [DROP VIEW](drop-view.md).