# Referencia de SQL para Athena Amazon Athena admite un subconjunto de instrucciones, funciones, operadores y tipos de datos del lenguaje de definición de datos (DDL, Data Definition Language) y el lenguaje de manipulación de datos (DML, Data Manipulation Language). Salvo algunas excepciones, DDL de Athena se basa en [DDL de HiveQL](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL) y DML de Athena se basa en [Trino](https://trino.io/docs/current/language.html). Para obtener información acerca de las versiones del motor Athena, consulte [Control de versiones del motor Athena](engine-versions.md). **Topics** + [Tipos de datos en Athena](data-types.md) + [Consultas, funciones y operadores de DML](dml-queries-functions-operators.md) + [Instrucciones DDL](ddl-reference.md) + [Consideraciones y limitaciones](other-notable-limitations.md) # Tipos de datos en Amazon Athena Cuando ejecute `CREATE TABLE`, deberá especificar los nombres de las columnas y el tipo de datos que puede contener cada columna. Las tablas que cree se almacenan en el AWS Glue Data Catalog. Para facilitar la interoperabilidad con otros motores de consultas, Athena usa nombres de tipos de datos de [Apache Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types) para instrucciones DDL como `CREATE TABLE`. Para consultas de DML como `SELECT`, `CTAS` y `INSERT INTO`, Athena usa nombres de tipos de datos de [Trino](https://trino.io/docs/current/language/types.html). En la siguiente tabla, se muestran los tipos de datos admitidos en Athena. Cuando los tipos DDL y DML difieren en el nombre, la disponibilidad o la sintaxis, se muestran en columnas independientes. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/data-types.html) **Topics** + [Ejemplos de tipos de datos](data-types-examples.md) + [Consideraciones sobre los tipos de datos](data-types-considerations.md) + [Trabajo con datos de marca de tiempo](data-types-timestamps.md) # Ejemplos de tipos de datos En la siguiente tabla se muestran ejemplos de literales de los tipos de datos DML. **** | Tipo de datos | Ejemplos | | --- | --- | | BOOLEANO | `true` `false ` | | TINYINT | `TINYINT '123'` | | SMALLINT | `SMALLINT '123'` | | INT, INTEGER | `123456790` | | BIGINT | `BIGINT '1234567890'` `2147483648` | | REAL | `'123456.78'` | | DOBLE | `1.234` | | DECIMAL (precisión, escala) | `DECIMAL '123.456'` | | CHAR, CHAR (longitud) | `CHAR 'hello world'`, `CHAR 'hello ''world''!'` | | VARCHAR, VARCHAR (longitud) | `VARCHAR 'hello world'`, `VARCHAR 'hello ''world''!'` | | VARBINARY | `X'00 01 02'` | | HORA, HORA (precisión) | `TIME '10:11:12'`, `TIME '10:11:12.345'` | | HORA CON ZONA HORARIA | `TIME '10:11:12.345 -06:00'` | | DATE | `DATE '2024-03-25'` | | MARCA DE TIEMPO, MARCA DE TIEMPO SIN ZONA HORARIA, MARCA DE TIEMPO (*precisión*), MARCA DE TIEMPO (*precisión*) SIN ZONA HORARIA | `TIMESTAMP '2024-03-25 11:12:13'`, `TIMESTAMP '2024-03-25 11:12:13.456'` | | MARCA DE TIEMPO CON ZONA HORARIA, MARCA DE TIEMPO (precisión) CON ZONA HORARIA | `TIMESTAMP '2024-03-25 11:12:13.456 Europe/Berlin'` | | INTERVALO AÑO A MES | `INTERVAL '3' MONTH` | | INTERVALO DÍA A SEGUNDO | `INTERVAL '2' DAY` | | ARRAY[element\$1type] | `ARRAY['one', 'two', 'three']` | | MAPA(key\$1type, value\$1type) | `MAP(ARRAY['one', 'two', 'three'], ARRAY[1, 2, 3])` Tenga en cuenta que los mapas se crean a partir de una matriz de claves y una matriz de valores. En el siguiente ejemplo, se crea una tabla que asigna cadenas a enteros. 
CREATE TABLE map_table(col1 map) LOCATION '...';
INSERT INTO map_table values(MAP(ARRAY['foo', 'bar'], ARRAY[1, 2]));
| | FILA(field\$1name\$11 field\$1type\$11, field\$1name\$12 field\$1type\$12, …) | `ROW('one', 'two', 'three')` Tenga en cuenta que las filas creadas de esta manera no tienen nombres de columna. Puede usar `CAST` para nombrar las columnas, como en el siguiente ejemplo: 
CAST(ROW(1, 2, 3) AS ROW(one INT, two INT, three INT))
| | JSON | `JSON '{"one":1, "two": 2, "three": 3}'` | | UUID | `UUID '12345678-90ab-cdef-1234-567890abcdef'` | | IPADDRESS | `IPADDRESS '10.0.0.1'` `IPADDRESS '2001:db8::1'` | # Consideraciones sobre los tipos de datos ## Límites de tamaño En el caso de los tipos de datos que no especifican un límite de tamaño, tenga en cuenta que existe un límite práctico de 32 MB para todos los datos de una sola fila. Para obtener más información, consulte [Row or column size limitation](other-notable-limitations.md#sql-limitations-rowsize) en [Consideraciones y limitaciones de las consultas SQL en Amazon Athena](other-notable-limitations.md). ## CHAR y VARCHAR Un valor `CHAR(n)` siempre tiene un recuento de `n` caracteres. Por ejemplo, si cambia “abc” a `CHAR(7)`, se añaden 4 espacios finales. Las comparaciones de valores `CHAR` incluyen espacios iniciales y finales. Si se especifica una longitud para `CHAR` o `VARCHAR`, las cadenas se truncan con la longitud especificada al leerlas. Si la cadena de datos subyacente es más larga, esta permanece sin cambios. Para evitar una comilla simple en un `CHAR` o `VARCHAR`, utilice una comilla simple adicional. Para convertir un tipo de datos que no sea una cadena en una consulta DML, cámbielo al tipo de datos `VARCHAR`. Para utilizar la función `substr` para devolver una subcadena de longitud especificada desde un tipo de datos `CHAR`, primero debe convertir el valor de `CHAR` a `VARCHAR`. En el siguiente ejemplo, `col1` utiliza el tipo de datos `CHAR`. ``` substr(CAST(col1 AS VARCHAR), 1, 4) ``` ## DECIMAL Para especificar valores decimales como literales en consultas `SELECT` como, por ejemplo, al seleccionar filas con un valor decimal específico, puede especificar el tipo `DECIMAL` y enumerar el valor decimal como literal entre comillas simples en su consulta, como en este ejemplo: ``` SELECT * FROM my_table WHERE decimal_value = DECIMAL '0.12' ``` ``` SELECT DECIMAL '44.6' + DECIMAL '77.2' ``` # Trabajo con datos de marca de tiempo En esta sección se describen algunas consideraciones para trabajar con datos de marcas de tiempo en Athena. **nota** El tratamiento de las marcas de tiempo ha cambiado ligeramente entre las versiones anteriores del motor y la versión 3 del motor de Athena. Para obtener información sobre los errores relacionados con la marca de tiempo que se pueden producir en la versión 3 del motor de Athena y las soluciones sugeridas, consulte [Cambios en la marca de tiempo](engine-versions-reference-0003.md#engine-versions-reference-0003-timestamp-changes) en la referencia de [Versión 3 del motor Athena](engine-versions-reference-0003.md). ## Formato para escribir datos de marcas de tiempo en objetos de Amazon S3 El formato en el que se deben escribir los datos de marcas de tiempo en los objetos de Amazon S3 depende tanto del tipo de datos de la columna como de la [biblioteca SerDe](https://docs.aws.amazon.com/athena/latest/ug/supported-serdes.html) que utilice. + Si cuenta con una columna de tabla de tipo `DATE`, Athena espera que la columna o propiedad correspondiente de los datos sea una cadena en el formato ISO `YYYY-MM-DD` o un tipo de fecha integrado, como los de Parquet u ORC. + Si cuenta con una columna de tabla de tipo `TIME`, Athena espera que la columna o propiedad correspondiente de los datos sea una cadena en el formato ISO `HH:MM:SS` o un tipo de hora integrado, como los de Parquet u ORC. + Si cuenta con una columna de tabla de tipo `TIMESTAMP`, Athena espera que la columna o propiedad correspondiente de los datos sea una cadena en el formato `YYYY-MM-DD HH:MM:SS.SSS` (tenga en cuenta el espacio entre la fecha y la hora) o un tipo de hora integrado, como los de Parquet, ORC o Ion. Tenga en cuenta que Athena no garantiza el comportamiento de las marcas de tiempo que son inválidas (por ejemplo, `0000-00-00 08:00:00.000`). **nota** Las marcas de tiempo de OpenCSVSerDe son una excepción y se deben codificar como periodos UNIX con una resolución de milisegundos. ## Cómo garantizar que los datos particionados en el tiempo coincidan con el campo de marca de tiempo de un registro El productor de los datos debe asegurarse de que los valores de la partición se alineen con los datos de la partición. Por ejemplo, si sus datos tienen una propiedad `timestamp` y utiliza Firehose para cargar los datos en Amazon S3, debe utilizar la [partición dinámica](https://docs.aws.amazon.com/firehose/latest/dev/dynamic-partitioning.html), ya que la partición predeterminada de Firehose se basa en un tiempo cronológico. ## Uso de una cadena como tipo de datos para las claves de partición Por motivos de rendimiento, es preferible utilizar `STRING` como el tipo de datos para las claves de partición. Si bien Athena reconoce los valores de partición en el formato `YYYY-MM-DD` como fechas al utilizar el tipo `DATE`, esto puede provocar un rendimiento deficiente. Por este motivo, en su lugar le recomendamos que utilice el tipo de datos `STRING` para las claves de partición. ## Cómo escribir consultas para campos de marca de tiempo que también se encuentren particionados por tiempo La forma en que se escriben las consultas para los campos de marca de tiempo que se encuentran particionados por tiempo dependen del tipo de tabla que se desee consultar. ### Tablas de Hive Con las tablas de Hive más utilizadas en Athena, el motor de consultas no conoce las relaciones entre las columnas y las claves de partición. Por este motivo, siempre debe agregar predicados en las consultas tanto para la columna como para la clave de partición. Por ejemplo, supongamos que tiene una columna `event_time` y una clave de partición `event_date` y desea consultar eventos entre las 23:00 y las 03:00. En este caso, debe incluir predicados en la consulta tanto para la columna como para la clave de partición, como en el siguiente ejemplo. ``` WHERE event_time BETWEEN start_time AND end_time AND event_date BETWEEN start_time_date AND end_time_date ``` ### Tablas de Iceberg Con las tablas de Iceberg, puede utilizar valores de partición calculados, lo que simplifica las consultas. Por ejemplo, supongamos que la tabla de Iceberg se creó con una cláusula `PARTITIONED BY` como la siguiente: ``` PARTITIONED BY (event_date month(event_time)) ``` En este caso, el motor de consultas reduce de forma automática las particiones en función de los valores de los predicados `event_time`. Por este motivo, la consulta solo necesita especificar un predicado para `event_time`, como en el siguiente ejemplo. ``` WHERE event_time BETWEEN start_time AND end_time ``` Para obtener más información, consulte [Creación de tablas de Iceberg](querying-iceberg-creating-tables.md). Al utilizar la partición oculta de Iceberg para una columna de tipo marca de tiempo, Iceberg puede crear una partición en una columna de tabla construida, derivada de una columna de marca de tiempo y transformada en una fecha para una partición más eficiente. Por ejemplo, podría crear `event_date` a partir de la columna de marca de tiempo `event_time` y particionar automáticamente por `event_date`. En este caso, el **tipo** de partición es una **fecha**. Para conseguir un rendimiento óptimo de las consultas al utilizar la partición, filtre por rangos de días completos para habilitar la propagación de predicados. Por ejemplo, la siguiente consulta no aplicaría la propagación de predicados porque el rango no se puede convertir en una única partición de fecha, a pesar de que está dentro de un mismo día. ``` WHERE event_time >= TIMESTAMP '2024-04-18 00:00:00' AND event_time < TIMESTAMP '2024-04-18 12:00:00' ``` En su lugar, utilice un rango de día completo para permitir la propagación del predicado y mejorar el rendimiento de la consulta, como en el siguiente ejemplo. ``` WHERE event_time >= TIMESTAMP '2024-04-18 00:00:00' AND event_time < TIMESTAMP '2024-04-19 00:00:00' ``` También puede utilizar la sintaxis `BETWEEN start_time AND end_time` o emplear rangos de varios días siempre que las porciones de marcas de tiempo sean `00:00:00`. Para obtener más información, consulte la [publicación en el blog de Trino](https://trino.io/blog/2023/04/11/date-predicates.html). # Consultas, funciones y operadores de DML El motor de consultas DML de Athena generalmente admite la sintaxis de Trino y Presto y agrega sus propias mejoras. Athena no es compatible con todas las características de Presto. Para obtener más información, consulte los temas sobre instrucciones específicas de esta sección, así como [Consideraciones y limitaciones](other-notable-limitations.md). Para obtener información sobre las funciones, consulte [Funciones en Amazon Athena](functions.md). Para obtener más información acerca de las versiones de motor Athena, consulte [Control de versiones del motor Athena](engine-versions.md). Para obtener información sobre las instrucciones DDL, consulte [Instrucciones DDL](ddl-reference.md). Para ver una lista de las instrucciones DDL no admitidas, consulte [DDL no admitido](unsupported-ddl.md). **Topics** + [SELECT](select.md) + [INSERT INTO](insert-into.md) + [VALUES](values-statement.md) + [DELETE](delete-statement.md) + [UPDATE](update-statement.md) + [MERGE INTO](merge-into-statement.md) + [OPTIMIZE](optimize-statement.md) + [VACUUM](vacuum-statement.md) + [EXPLAIN y EXPLAIN ANALYZE](athena-explain-statement.md) + [PREPARE](sql-prepare.md) + [UNLOAD](unload.md) + [Funciones](functions.md) + [Uso de zonas horarias admitidas](athena-supported-time-zones.md) # SELECT Recupera filas de datos de cero o más tablas. **nota** En este tema se proporciona un resumen de información de referencia. La información completa sobre el uso de `SELECT` y el lenguaje SQL está fuera del alcance de esta documentación. Para obtener información sobre el uso de SQL específico de Athena, consulte [Consideraciones y limitaciones de las consultas SQL en Amazon Athena](other-notable-limitations.md) y [Ejecución de consultas SQL en Amazon Athena](querying-athena-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 ``` [ WITH with_query [, ...] ] SELECT [ ALL | DISTINCT ] select_expression [, ...] [ FROM from_item [, ...] ] [ WHERE condition ] [ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ] [ HAVING condition ] [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ] [ ORDER BY expression [ ASC | DESC ] [ NULLS FIRST | NULLS LAST] [, ...] ] [ OFFSET count [ ROW | ROWS ] ] [ LIMIT [ count | ALL ] ] ``` **nota** Las palabras reservadas en las instrucciones SELECT de SQL deben ponerse entre comillas dobles. Para obtener más información, consulte [Palabras reservadas para incluir en las instrucciones SQL SELECT](reserved-words.md#list-of-reserved-words-sql-select). ## Parameters **[ WITH with\$1query [, ....] ]** Puede utilizar `WITH` para aplanar consultas anidadas o para simplificar subconsultas. Se admite el uso de la cláusula `WITH` para crear consultas recursivas con la versión 3 del motor de Athena. La profundidad máxima de recursión es 10. La cláusula `WITH` precede a la lista `SELECT` de una consulta y define una o varias subconsultas para utilizarlas en la consulta `SELECT`. Cada subconsulta define una tabla temporal, similar a la definición de una vista, a la que puede hacer referencia en la cláusula `FROM`. Las tablas se utilizan solo cuando se ejecuta la consulta. `with_query`La sintaxis de es: ``` subquery_table_name [ ( column_name [, ...] ) ] AS (subquery) ``` Donde: + `subquery_table_name` es un nombre único para una tabla temporal que define los resultados de la subconsulta de cláusula `WITH`. Cada `subquery` debe tener un nombre de tabla al que se pueda hacer referencia en la cláusula `FROM`. + `column_name [, ...]` es una lista opcional de los nombres de columna de salida. La cantidad de nombres de columnas debe ser igual o menor que la cantidad de columnas definidas por la `subquery`. + `subquery` es cualquier declaración de consulta. **[ ALL \$1 DISTINCT ] select\$1expression** `select_expression` determina las filas que deben seleccionarse. Con la opción `select_expression` se puede usar uno de los siguientes formatos: ``` expression [ [ AS ] column_alias ] [, ...] ``` ``` row_expression.* [ AS ( column_alias [, ...] ) ] ``` ``` relation.* ``` ``` * ``` + La sintaxis `expression [ [ AS ] column_alias ]` especifica una columna de salida. La sintaxis opcional `[AS] column_alias` especifica un nombre de encabezado personalizado que se utilizará en la columna de la salida. + Para `row_expression.* [ AS ( column_alias [, ...] ) ]`, `row_expression` es una expresión arbitraria de tipo `ROW`. Los campos de la fila definen las columnas de salida que se incluirán en el resultado. + Para `relation.*`, las columnas de `relation` se incluyen en el resultado. Esta sintaxis no permite el uso de alias de columna. + El asterisco `*` especifica que todas las columnas deben incluirse en el conjunto de resultados. + En el conjunto de resultados, el orden de las columnas es el mismo que el orden de su especificación según la expresión seleccionada. Si una expresión seleccionada devuelve varias columnas, el orden de las columnas sigue el orden utilizado en la relación de origen o la expresión de tipo fila. + Cuando se especifican alias de columna, estos sustituyen a los nombres de columna o campos de fila preexistentes. Si la expresión seleccionada no tiene nombres de columna, en la salida se muestran los nombres de columna anónimos indexados a cero (`_col0`, `_col1` y `_col2, ...`). + `ALL` es el valor predeterminado. El uso de `ALL` se trata de la misma manera que si se hubiera omitido; todas las filas de todas las columnas se seleccionan y se conservan los duplicados. + Utilice `DISTINCT` para devolver solo valores únicos cuando una columna contiene valores duplicados. **FROM from\$1item [, ...]** Indica la entrada de datos de la consulta, donde `from_item` puede ser una vista, una construcción JOIN o una subconsulta, tal y como se describe a continuación. `from_item` puede ser: + `table_name [ [ AS ] alias [ (column_alias [, ...]) ] ]` Donde `table_name` es el nombre de la tabla de destino en la que se seleccionan las filas, `alias` es el nombre que se debe dar a la salida de la instrucción `SELECT` y `column_alias` define las columnas para el `alias` especificado. **-O BIEN-** + `join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]` Donde `join_type` es uno de los valores siguientes: + `[ INNER ] JOIN` + `LEFT [ OUTER ] JOIN` + `RIGHT [ OUTER ] JOIN` + `FULL [ OUTER ] JOIN` + `CROSS JOIN` + `ON join_condition | USING (join_column [, ...])` Donde con `join_condition` puede especificar nombres de columnas para claves de combinación en varias tablas y el uso de `join_column` requiere que `join_column` exista en ambas tablas. **[ WHERE condition ]** Filtra los resultados de acuerdo con la `condition` que especifique, donde `condition` por lo general tiene la siguiente sintaxis. ``` column_name operator value [[[AND | OR] column_name operator value] ...] ``` El *operador* puede ser uno de los comparadores `=`, `>`, `<`, `>=`, `<=`, `<>`, `!=`. Las siguientes expresiones de subconsulta también se pueden utilizar en la cláusula `WHERE`. + `[NOT] BETWEEN integer_A AND integer_B`: especifica un rango entre dos enteros, como en el ejemplo siguiente. Si el tipo de datos de la columna es `varchar`, primero se debe convertir la columna a números enteros. ``` SELECT DISTINCT processid FROM "webdata"."impressions" WHERE cast(processid as int) BETWEEN 1500 and 1800 ORDER BY processid ``` + `[NOT] LIKE value`: busca el patrón especificado. Utilice el signo de porcentaje (`%`) como carácter comodín, como en el ejemplo siguiente. ``` SELECT * FROM "webdata"."impressions" WHERE referrer LIKE '%.org' ``` + `[NOT] IN (value[, value[, ...])`: especifica una lista de valores posibles para una columna, como en el ejemplo siguiente. ``` SELECT * FROM "webdata"."impressions" WHERE referrer IN ('example.com','example.net','example.org') ``` **[ GROUP BY [ ALL \$1 DISTINCT ] grouping\$1expressions [, ...] ]** Divide la salida de la instrucción `SELECT` en filas con valores coincidentes. `ALL` y `DISTINCT` determinan si los conjuntos de agrupación duplicados producen cada uno filas de salida diferenciadas. Si se omite, el sistema presupone que se utiliza `ALL`. `grouping_expressions` le permite realizar operaciones de agrupación complejas. Puede utilizar operaciones de agrupación complejas para realizar análisis que requieran la agregación de varios conjuntos de columnas en una sola consulta. El elemento `grouping_expressions` puede ser cualquier función, como `SUM`, `AVG` o `COUNT`, realizado en columnas de entrada. Las expresiones `GROUP BY` pueden agrupar la salida por nombres de columna de entrada que no se muestran en la salida de la instrucción `SELECT`. Todas las expresiones de salida deben ser funciones o columnas agregadas que existan en la cláusula `GROUP BY`. Puede utilizar una sola consulta para realizar análisis que requieran la agregación de varios conjuntos de columnas. Athena admite agregaciones complejas usando `GROUPING SETS`, `CUBE` y `ROLLUP`. `GROUP BY GROUPING SETS` especifica varias listas de columnas en las que se agruparán. `GROUP BY CUBE` genera todos los conjuntos de agrupación posibles para un conjunto determinado de columnas. `GROUP BY ROLLUP` genera todos los subtotales posibles para un conjunto determinado de columnas. Las operaciones de agrupación complejas no admiten agrupación en expresiones compuestas por columnas de entrada. Solo se admiten nombres de columnas. A menudo puede utilizar `UNION ALL` para obtener los mismos resultados que estas operaciones `GROUP BY`, pero las consultas que utilizan `GROUP BY` tienen la ventaja de leer los datos una vez, mientras que `UNION ALL` lee los datos subyacentes tres veces y puede producir resultados incoherentes cuando el origen de los datos está sujeto a cambios. **[ HAVING condition ]** Se usa con funciones agregadas y la cláusula `GROUP BY`. Controla qué grupos se seleccionan, con lo que se eliminan los grupos que no cumplen el valor de `condition`. Este filtro se aplica después de calcular los grupos y los agregados. **[ \$1 UNION \$1 INTERSECT \$1 EXCEPT \$1 [ ALL \$1 DISTINCT ] union\$1query] ]** `UNION`, `INTERSECT` y `EXCEPT` combinan los resultados de más de una instrucción `SELECT` en una sola consulta. `ALL` o `DISTINCT` determinan el carácter único de las filas que se incluyen en el conjunto de resultados final. `UNION` combina las filas resultantes de la primera consulta con las filas resultantes de la segunda consulta. Para eliminar duplicados, `UNION` construye una tabla hash, que consume memoria. Para un mejor rendimiento, considere utilizar `UNION ALL` si la consulta no requiere la eliminación de duplicados. Si hay varias cláusulas `UNION`, dichas cláusulas se procesan de izquierda a derecha a menos que utilice paréntesis para definir explícitamente el orden de procesamiento. `INTERSECT` devuelve solo las filas que están presentes en los resultados de la primera y la segunda consulta. `EXCEPT` devuelve las filas de los resultados de la primera consulta, y excluye las filas encontradas por la segunda consulta. `ALL` hace que se incluyan todas las filas, incluso si dichas filas son idénticas. `DISTINCT` hace que solo se incluyan filas únicas en el conjunto de resultados combinados. **[ ORDER BY expression [ ASC \$1 DESC ] [ NULLS FIRST \$1 NULLS LAST] [, ...] ]** Ordena un conjunto de resultados por una o varias salidas `expression`. Cuando la cláusula contiene varias expresiones, el conjunto de resultados se ordena de acuerdo con la primera `expression`. A continuación, se aplica la segunda `expression` a las filas que tienen valores coincidentes de la primera expresión y así sucesivamente. Cada `expression` puede especificar columnas de salida de `SELECT` o un número ordinal para una columna de salida por posición, a partir de uno. `ORDER BY` se evalúa como el último paso después de cualquier cláusula `GROUP BY` o `HAVING`. `ASC` y `DESC` determinan si los resultados se ordenan de forma ascendente o descendente. El orden es ascendente de manera predeterminada (`ASC`). El orden de los valores nulos predeterminado es `NULLS LAST`, sea cual sea el orden de clasificación, ascendente o descendente. **[ OFFSET count [ ROW \$1 ROWS ] ]** Utilice la cláusula `OFFSET` para descartar varias filas iniciales del conjunto de resultados. Si la cláusula `ORDER BY` está presente, la cláusula `OFFSET` se evalúa sobre un conjunto de resultados ordenado. El conjunto permanece ordenado después de descartar las filas omitidas. Si la consulta no tiene la cláusula `ORDER BY`, es arbitrario qué filas se descartan. Si el recuento especificado por `OFFSET` es igual o superior al tamaño del conjunto de resultados, el resultado final estará vacío. **LIMIT [ count \$1 ALL ]** Restringe el número de filas del conjunto de resultados a `count`. `LIMIT ALL` equivale a omitir la cláusula `LIMIT`. Si la consulta no contiene ninguna cláusula `ORDER BY`, los resultados son arbitrarios. **TABLESAMPLE [ BERNOULLI \$1 SYSTEM ] (porcentaje)** Operador opcional para seleccionar filas de una tabla basado en un método de muestreo. `BERNOULLI` selecciona cada fila que se muestra en la tabla con una probabilidad de `percentage`. Todos los bloques físicos de la tabla se analizan y determinadas filas se omiten basándose en una comparación entre el valor de `percentage` de muestra y un valor aleatorio calculado en el tiempo de ejecución. Con `SYSTEM`, la tabla se divide en segmentos lógicos de datos y la tabla se muestrea con esta granularidad. O bien se seleccionan todas las filas de un segmento en particular, o el segmento se omite basándose en la comparación del valor de `percentage` de la muestra con un valor aleatorio calculado en tiempo de ejecución. El muestreo de `SYSTEM` depende del conector. Este método no garantiza que las probabilidades de muestreo sean independientes. **[ UNNEST (array\$1or\$1map) [WITH ORDINALITY] ]** Amplía una matriz o un mapa a una relación. Las matrices se amplían a una sola columna. Los mapas se amplían a dos columnas (*clave*, *valor*). Puede utilizar `UNNEST` con varios argumentos, que se amplían en varias columnas con tantas filas como el mayor argumento de cardinalidad. Las demás columnas se rellenan con valores nulos. La cláusula `WITH ORDINALITY` añade una columna de ordinalidad al final. `UNNEST` suele utilizarse con `JOIN` y puede hacer referencia a columnas de relaciones del lado izquierdo de `JOIN`. ## Obtención de las ubicaciones de archivos para los datos de origen en Simple Storage Service (Amazon S3) Para ver la ubicación del archivo de Amazon S3 para los datos de una fila de tabla, puede utilizar `"$path"` en una consulta `SELECT`, como en el ejemplo siguiente: ``` SELECT "$path" FROM "my_database"."my_table" WHERE year=2019; ``` Esta consulta devuelve un resultado similar al siguiente: ``` s3://amzn-s3-demo-bucket/datasets_mytable/year=2019/data_file1.json ``` Para devolver una lista ordenada y única de las rutas de nombre de archivo S3 para los datos de una tabla, puede utilizar `SELECT DISTINCT` y `ORDER BY`, como en el ejemplo a continuación. ``` SELECT DISTINCT "$path" AS data_source_file FROM sampledb.elb_logs ORDER By data_source_file ASC ``` Para devolver solo los nombres de archivo sin la ruta, puede pasar `"$path"` como parámetro a una función `regexp_extract`, como en el siguiente ejemplo. ``` SELECT DISTINCT regexp_extract("$path", '[^/]+$') AS data_source_file FROM sampledb.elb_logs ORDER By data_source_file ASC ``` Para devolver los datos de un archivo específico, especifique el archivo en la cláusula `WHERE`, como en el siguiente ejemplo. ``` SELECT *,"$path" FROM my_database.my_table WHERE "$path" = 's3://amzn-s3-demo-bucket/my_table/my_partition/file-01.csv' ``` Para obtener más información y ejemplos, consulte el artículo del Centro de conocimientos [¿Cómo puedo ver el archivo de origen de Amazon S3 de una fila en una tabla de Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/find-s3-source-file-athena-table-row/). **nota** En Athena, las columnas de metadatos ocultas de Hive o Iceberg `$bucket`, `$file_modified_time`, `$file_size` y `$partition` no son compatibles con las vistas. ## Incluir las comillas simples en caracteres de escape Para incluir una comilla simple en caracteres de escape, inserte delante otra comilla simple, como en el ejemplo siguiente. Esto no debe confundirse con las comillas dobles. ``` Select 'O''Reilly' ``` **Resultados** `O'Reilly` ## Recursos adicionales Para obtener más información acerca del uso de instrucciones `SELECT` en Athena, consulte los siguientes recursos. | Para obtener información sobre este tema | Consulte | | --- | --- | | Ejecución de consultas en Athena | [Ejecución de consultas SQL en Amazon Athena](querying-athena-tables.md) | | Uso de SELECT para crear una tabla | [Creación de una tabla a partir de los resultados de una consulta (CTAS)](ctas.md) | | Insertar datos desde una consulta SELECT en otra tabla | [INSERT INTO](insert-into.md) | | Uso de funciones integradas en instrucciones SELECT | [Funciones en Amazon Athena](functions.md) | | Uso de funciones definidas por el usuario en instrucciones SELECT | [Consulta con funciones definidas por el usuario](querying-udf.md) | | Consulta de metadatos del catálogo de datos | [Consulta de AWS Glue Data Catalog](querying-glue-catalog.md) | # INSERT INTO Inserta filas nuevas en una tabla de destino en función de una instrucción de consulta `SELECT` que se ejecuta en una tabla de origen o en función de un conjunto de `VALUES` proporcionados como parte de la instrucción. Cuando la tabla de origen se basa en datos subyacentes con un formato concreto, como CSV o JSON, y la tabla de destino emplea otro formato, como Parquet u ORC, puede utilizar consultas `INSERT INTO` para transformar los datos seleccionados en el formato de la tabla de destino. ## Consideraciones y limitaciones Cuando utilice las consultas `INSERT` con Athena, tenga en cuenta lo siguiente. + De forma predeterminada, cuando se ejecuta una consulta `INSERT` en una tabla con datos subyacentes cifrados en Amazon S3, los archivos de salida que escribe la consulta `INSERT` no se cifran. Le recomendamos que cifre los resultados de las consultas `INSERT` si se van a insertar en tablas con datos cifrados. Para obtener más información acerca cómo cifrar los resultados de las consultas utilizando la consola, consulte [Cifrado de los resultados de las consultas de Athena en Amazon S3](encrypting-query-results-stored-in-s3.md). Para habilitar el cifrado mediante la AWS CLI o la API de Athena, utilice las propiedades `EncryptionConfiguration` de la acción [StartQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html) para especificar las opciones de cifrado de Amazon S3 en función de sus necesidades. + Para las instrucciones `INSERT INTO`, 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). + En relación con las instrucciones `INSERT INTO` que cumplen con los requisitos de ACID, consulte la sección `INSERT INTO` de [Actualización de los datos de las tablas de Iceberg](querying-iceberg-updating-iceberg-table-data.md). ### Formatos y SerDes compatibles Puede ejecutar una consulta `INSERT` en las tablas creadas a partir de datos con los siguientes formatos y SerDes. | Formato de los datos | SerDe | | --- | --- | | Avro | org.apache.hadoop.hive.serde2.avro.AvroSerDe | | Ion | com.amazon.ionhiveserde.IonHiveSerDe | | JSON | org.apache.hive.hcatalog.data.JsonSerDe | | ORC | org.apache.hadoop.hive.ql.io.orc.OrcSerde | | Parquet | org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe | | Archivo de texto | org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe Se admiten archivos TSV y con delimitadores personalizados. | | CSV | org.apache.hadoop.hive.serde2.OpenCSVSerde Las escrituras solo son compatibles con tipos de datos de cadena. Desde Athena, no se puede escribir en tablas cuyo esquema de Glue contenga tipos de datos que no sean de cadena. Para obtener más información, consulte [CSV SerDe](csv-serde.md#csv-serde-opencsvserde-considerations-non-string). | ### No se admiten tablas en buckets. `INSERT INTO` no es compatible con las tablas en buckets. Para obtener más información, consulte [Uso de particiones y asignación de buckets](ctas-partitioning-and-bucketing.md). ### Consultas federadas no compatibles `INSERT INTO` no es compatible con las consultas federadas. Si intenta hacerlo, puede aparecer el mensaje de error This operation is currently not supported for external catalogs (Esta operación no es compatible actualmente con catálogos externos). Para obtener información sobre las consultas federadas, consulte [Uso de consulta federada de Amazon Athena](federated-queries.md). ### Particiones Tenga en cuenta los puntos de esta sección al utilizar particiones con consultas `INSERT INTO` o `CREATE TABLE AS SELECT`. #### Límites La instrucción `INSERT INTO` admite escribir un máximo de 100 particiones en la tabla de destino. Si ejecuta la cláusula `SELECT` en una tabla con más de 100 particiones, se produce un error en la consulta a menos que la consulta `SELECT` esté limitada a 100 particiones o menos. Para obtener más información sobre cómo evitar esta limitación, consulte [Uso de CTAS e INSERT INTO para evitar el límite de 100 particiones](ctas-insert-into.md). #### Ordenamiento de columnas Las instrucciones `INSERT INTO` o `CREATE TABLE AS SELECT` esperan que la columna particionada sea la última de la lista de columnas proyectadas en una instrucción `SELECT`. Si la tabla de origen no está particionada o está particionada en columnas diferentes en comparación con la tabla de destino, las consultas como `INSERT INTO destination_table SELECT * FROM source_table` consideran que los valores de la última columna de la tabla de origen son valores para una columna de partición en la tabla de destino. Tenga esto en cuenta al intentar crear una tabla particionada desde una tabla no particionada. #### Recursos Para obtener más información acerca del uso de `INSERT INTO` con la partición, consulte los siguientes recursos. + Para insertar datos particionados en una tabla particionada, consulte [Uso de CTAS e INSERT INTO para evitar el límite de 100 particiones](ctas-insert-into.md). + Para insertar datos no particionados en una tabla particionada, consulte [Uso de CTAS e INSERT INTO en ETL y análisis de datos](ctas-insert-into-etl.md). ### Archivos escritos en Simple Storage Service (Amazon S3) Tras ejecutar el comando `INSERT`, Athena escribe archivos en las ubicaciones de datos de origen de Amazon S3. Cada operación `INSERT` crea un nuevo archivo, en lugar de anexar el resultado a un archivo existente. Las ubicaciones de los archivos dependen de la estructura de la tabla y la consulta `SELECT`, si procede. Athena genera un archivo de manifiesto de datos para cada consulta `INSERT`. El manifiesto realiza un seguimiento de los archivos que escribió la consulta. Se guarda en la ubicación del resultado de la consulta de Athena en Amazon S3. Para obtener más información, consulte [Identificación de archivos de salida de consultas](querying-finding-output-files.md#querying-identifying-output-files). ### Evite las actualizaciones altamente transaccionales Cuando utiliza `INSERT INTO` para añadir filas a una tabla en Amazon S3, Athena no reescribe ni modifica los archivos existentes. En su lugar, escribe las filas como uno o más archivos nuevos. Dado que las tablas con [ muchos archivos pequeños reducen el rendimiento de las consultas](performance-tuning-data-optimization-techniques.md#performance-tuning-avoid-having-too-many-files) y que las operaciones de escritura lectura, como `PutObject` y `GetObject`, generan costes más altos de Amazon S3, tenga en cuenta las siguientes opciones cuando utiliza `INSERT INTO`: + Ejecute las operaciones `INSERT INTO` con menos frecuencia en lotes más grandes de filas. + Para grandes volúmenes de ingesta de datos, considere la posibilidad de utilizar un servicio como [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html). + Evite por completo el uso de `INSERT INTO`. En su lugar, acumule filas en archivos más grandes y cárguelos directamente en Amazon S3, donde Athena podrá consultarlos. ### Localización de archivos huérfanos Si una instrucción `CTAS` o `INSERT INTO` falla, los datos huérfanos se pueden dejar en la ubicación de los datos y se pueden leer en consultas posteriores. Para localizar archivos huérfanos para su inspección o eliminación, puede utilizar el archivo de manifiesto de datos que Athena proporciona para realizar un seguimiento de la lista de archivos que se van a escribir. Para obtener más información, consulte [Identificación de archivos de salida de consultas](querying-finding-output-files.md#querying-identifying-output-files) y [DataManifestLocation](https://docs.aws.amazon.com/athena/latest/APIReference/API_QueryExecutionStatistics.html#athena-Type-QueryExecutionStatistics-DataManifestLocation). ## INSERT INTO...SELECT Especifica la consulta que se va a ejecutar en una tabla, `source_table`, lo que determina las filas que se van a insertar en una segunda tabla, `destination_table`. Si la consulta `SELECT` especifica columnas de `source_table`, las columnas deben coincidir exactamente con las de `destination_table`. Para obtener más información acerca de las consultas `SELECT`, consulte [SELECT](select.md). ### Sinopsis ``` INSERT INTO destination_table SELECT select_query FROM source_table_or_view ``` ### Ejemplos Seleccione todas las filas de la tabla `vancouver_pageviews` e insértelas en la tabla `canada_pageviews`: ``` INSERT INTO canada_pageviews SELECT * FROM vancouver_pageviews; ``` Seleccione solo las filas de la tabla `vancouver_pageviews` en las que la columna `date` tiene un valor comprendido entre `2019-07-01` y `2019-07-31`. Después, insértelas en `canada_july_pageviews`: ``` INSERT INTO canada_july_pageviews SELECT * FROM vancouver_pageviews WHERE date BETWEEN date '2019-07-01' AND '2019-07-31'; ``` En la tabla `city`, seleccione los valores de las columnas `state` y `cities_world` de aquellas filas que tengan el valor `usa` en la columna `country` e insértelos en las columnas `city` y `state` de la tabla `cities_usa`: ``` INSERT INTO cities_usa (city,state) SELECT city,state FROM cities_world WHERE country='usa' ``` ## INSERT INTO...VALUES Inserta filas en una tabla existente especificando columnas y valores. Las columnas especificadas y los tipos de datos asociados deben coincidir exactamente con las columnas y los tipos de datos de la tabla de destino. **importante** No es recomendable utilizar `VALUES` para insertar las filas, ya que Athena genera archivos con cada operación `INSERT`. Esto puede provocar que se creen muchos archivos pequeños y reducir el rendimiento de las consultas de la tabla. Para identificar los archivos que crea una consulta `INSERT`, examine el archivo del manifiesto de datos. Para obtener más información, consulte [Trabajo con resultados de la consulta y consultas recientes](querying.md). ### Sinopsis ``` INSERT INTO destination_table [(col1,col2,...)] VALUES (col1value,col2value,...)[, (col1value,col2value,...)][, ...] ``` ### Ejemplos En los siguientes ejemplos, la tabla de ciudades tiene varias columnas: , , y: `id`, `city`, `state`, `state_motto`. La columna `id` es de tipo `INT`, mientras que todas las demás columnas son de tipo `VARCHAR`. Inserte una sola fila en la tabla `cities` con todos los valores de columna especificados: ``` INSERT INTO cities VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice') ``` Inserte dos filas en la tabla `cities`: ``` INSERT INTO cities VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice'), (3,'Boise','ID','Esto perpetua') ``` # VALUES Crea una tabla en línea literal. La tabla puede ser anónima o puede usar la cláusula `AS` para especificar un nombre de tabla, nombres de columnas o ambos. ## Sinopsis ``` VALUES row [, ...] ``` ## Parámetros **fila** El parámetro `row` puede ser una expresión única o `( column_expression [, ...] )`. ## Ejemplos Devolver una tabla con una columna y tres filas: ``` VALUES 1, 2, 3 ``` Devolver una tabla con dos columnas y tres filas: ``` VALUES (1, 'a'), (2, 'b'), (3, 'c') ``` Devolver una tabla con las columnas `id` y `name`: ``` SELECT * FROM ( VALUES (1, 'a'), (2, 'b'), (3, 'c') ) AS t (id, name) ``` Crear una tabla llamada `customers` con las columnas `id` y `name`: ``` CREATE TABLE customers AS SELECT * FROM ( VALUES (1, 'a'), (2, 'b'), (3, 'c') ) AS t (id, name) ``` ## Véase también [INSERT INTO...VALUES](insert-into.md#insert-into-values) # DELETE Elimina filas de una tabla de Apache Iceberg. `DELETE` es transaccional y solo se admite en tablas de Apache Iceberg. ## Sinopsis Para eliminar las filas de una tabla de Iceberg, use la siguiente sintaxis. ``` DELETE FROM [db_name.]table_name [WHERE predicate] ``` Para obtener más información y ejemplos, consulte la sección de `DELETE` de [Actualización de los datos de las tablas de Iceberg](querying-iceberg-updating-iceberg-table-data.md). # UPDATE Actualice las filas de una tabla de Apache Iceberg. `UPDATE` es transaccional y solo se admite en tablas de Apache Iceberg. La instrucción solo funciona en las filas existentes y no se puede utilizar para insertar o anexar una fila. ## Sinopsis Para actualizar las filas de una tabla de Iceberg, use la siguiente sintaxis. ``` UPDATE [db_name.]table_name SET xx=yy[,...] [WHERE predicate] ``` Para obtener más información y ejemplos, consulte la sección de `UPDATE` de [Actualización de los datos de las tablas de Iceberg](querying-iceberg-updating-iceberg-table-data.md). # MERGE INTO Actualiza, elimina o inserta filas de forma condicional en una tabla de Apache Iceberg. Una sola instrucción puede combinar acciones de actualización, eliminación e inserción. **nota** `MERGE INTO` es transaccional y solo es compatible con las tablas de Apache Iceberg en la versión 3 del motor Athena. ## Sinopsis Para actualizar, eliminar o insertar filas de forma condicional de una tabla de Iceberg, use la siguiente sintaxis. ``` MERGE INTO target_table [ [ AS ] target_alias ] USING { source_table | query } [ [ AS ] source_alias ] ON search_condition when_clause [...] ``` La cláusula *when\$1clause* es una de las siguientes: ``` WHEN MATCHED [ AND condition ] THEN DELETE ``` ``` WHEN MATCHED [ AND condition ] THEN UPDATE SET ( column = expression [, ...] ) ``` ``` WHEN NOT MATCHED [ AND condition ] THEN INSERT (column_name[, column_name ...]) VALUES (expression, ...) ``` `MERGE` admite un número arbitrario de cláusulas `WHEN` con diferentes condiciones `MATCHED`. Las cláusulas de condición ejecutan la operación `DELETE`, `UPDATE` o `INSERT` de la primera cláusula `WHEN` seleccionada por el estado `MATCHED` y la condición de coincidencia. Para cada fila de origen, las cláusulas `WHEN` se procesan en orden. Solo se ejecuta la primera cláusula `WHEN` coincidente. Las demás cláusulas se ignoran. Se produce un error de usuario cuando una sola fila de la tabla de destino coincide con más de una fila de origen. Si una fila de origen no coincide con ninguna cláusula `WHEN` y no hay ninguna cláusula `WHEN NOT MATCHED`, se ignora la fila de origen. En las cláusulas `WHEN` que tienen operaciones `UPDATE`, las expresiones de valores de la columna pueden hacer referencia a cualquier campo del destino o del origen. En el caso de `NOT MATCHED`, las expresiones `INSERT` pueden referirse a cualquier campo del origen. **Ejemplo** En el siguiente ejemplo, se combinan filas de la segunda tabla en la primera tabla si las filas no existen en la primera tabla. Tenga en cuenta que las columnas que aparecen en la cláusula `VALUES` deben ir precedidas del alias de la tabla de origen. Las columnas de destino enumeradas en la cláusula `INSERT` *no* deben tener ese prefijo. ``` MERGE INTO iceberg_table_sample as ice1 USING iceberg2_table_sample as ice2 ON ice1.col1 = ice2.col1 WHEN NOT MATCHED THEN INSERT (col1) VALUES (ice2.col1) ``` Para obtener más ejemplos de `MERGE INTO`, consulte [Actualización de los datos de las tablas de Iceberg](querying-iceberg-updating-iceberg-table-data.md). # OPTIMIZE Optimiza las filas de una tabla de Apache Iceberg al reescribir los archivos de datos en un diseño más optimizado en función de su tamaño y del número de archivos de eliminación asociados. **nota** `OPTIMIZE` es transaccional y solo se admite en tablas de Apache Iceberg. ## Sintaxis En el siguiente resumen de sintaxis, se muestra cómo optimizar el diseño de datos de una tabla de Iceberg. ``` OPTIMIZE [db_name.]table_name REWRITE DATA USING BIN_PACK [WHERE predicate] ``` **nota** Solo se permiten columnas de partición en el *predicado* de la cláusula `WHERE`. Si se especifica una columna que no es de partición, se producirá un error en la consulta. La acción de compactación se cobra por la cantidad de datos analizados durante el proceso de reescritura. La acción `REWRITE DATA` usa predicados para seleccionar los archivos que contienen filas que coinciden. Si alguna fila del archivo coincide con el predicado, el archivo se selecciona para la optimización. Así, para controlar el número de archivos afectados por la operación de compactación, puede especificar una cláusula `WHERE`. ## Configuración de las propiedades de compactación Para controlar el tamaño de los archivos que se seleccionarán para la compactación y el tamaño de archivo resultante después de la compactación, puede usar parámetros de propiedades de tabla. Puede utilizar el comando [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md) para configurar las siguientes [propiedades de la tabla](querying-iceberg-creating-tables.md#querying-iceberg-table-properties) relacionadas. ## Recursos adicionales [Optimización de las tablas de Iceberg](querying-iceberg-data-optimization.md) # VACUUM La instrucción `VACUUM` realiza el mantenimiento de las tablas de Apache Iceberg al ocuparse del [vencimiento de las instantáneas](https://iceberg.apache.org/docs/latest/spark-procedures/#remove_orphan_files) y la [eliminación de los archivos huérfanos](https://iceberg.apache.org/docs/latest/spark-procedures/#expire_snapshots). **nota** `VACUUM` es transaccional y solo es compatible con las tablas de Apache Iceberg en la versión 3 del motor Athena. La instrucción `VACUUM` optimiza las tablas de Iceberg al reducir el consumo de almacenamiento. Para obtener más información acerca del uso de `VACUUM`, consulte [Optimización de las tablas de Iceberg](querying-iceberg-data-optimization.md). Tenga en cuenta que, debido a que la instrucción `VACUUM` realiza llamadas de API a Amazon S3, se aplican cargos por las solicitudes asociadas a Amazon S3. **aviso** Si ejecuta una operación de vencimiento de instantáneas, ya no podrá viajar en el tiempo a instantáneas vencidas. ## Sinopsis Para eliminar los archivos de datos que ya no se necesitan para una tabla de Iceberg, use la siguiente sintaxis. ``` VACUUM [database_name.]target_table ``` + Tenga en cuenta que `VACUUM` espera que los datos de Iceberg estén en una carpeta de Amazon S3 en lugar de estar en un bucket de Amazon S3. Por ejemplo, si los datos de Iceberg se encuentran en `s3://amzn-s3-demo-bucket`/ en lugar de `s3://amzn-s3-demo-bucket/myicebergfolder/`, la instrucción `VACUUM` falla con el mensaje de error GENERIC\$1INTERNAL\$1ERROR: Falta la ruta en la ubicación del sistema de archivos: `s3://amzn-s3-demo-bucket`. + Para que `VACUUM` pueda eliminar archivos de datos, su función de ejecución de consultas debe tener `s3:DeleteObject` permisos en el bucket en el que se encuentran las tablas, los metadatos, las instantáneas y los archivos de datos de Iceberg. Si el permiso no está presente, la consulta `VACUUM` se realizará correctamente, pero los archivos no se eliminarán. + Para ejecutar `VACUUM` en una tabla cuyo nombre comience con un guión bajo (por ejemplo, `_mytable`), encierre el nombre de la tabla entre comillas inversas, como en el siguiente ejemplo. Si antepone al nombre de la tabla un nombre de base de datos, no encierre el nombre de la base de datos entre comillas inversas. Tenga en cuenta que las comillas dobles no funcionarán en lugar de las comillas inversas. Este comportamiento es específico de `VACUUM`. Las instrucciones `CREATE` y `INSERT INTO` no requieren comillas inversas para los nombres de tabla que comienzan con guiones bajos. ``` VACUUM `_mytable` VACUUM my_database.`_mytable` ``` ## Operaciones realizadas `VACUUM` lleva a cabo las siguientes operaciones: + Elimina las instantáneas que tengan una antigüedad superior a la cantidad de tiempo especificada en la propiedad de la tabla `vacuum_max_snapshot_age_seconds`. De forma predeterminada, esta propiedad se establece en 432 000 segundos (5 días). + Elimina las instantáneas que no estén dentro del periodo de conservación y que superen el número especificado en la propiedad de la tabla `vacuum_min_snapshots_to_keep`. El valor predeterminado de es 1. Puede especificar estas propiedades de la tabla en su instrucción `CREATE TABLE`. Después de crear la tabla, se puede usar la instrucción [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md) para actualizarla. + Elimina los metadatos y los archivos de datos a los que no se pueda acceder como resultado de la eliminación de la instantánea. Puede configurar la cantidad de archivos de metadatos antiguos que se van a retener al configurar la propiedad de la tabla `vacuum_max_metadata_files_to_keep`. El valor predeterminado es 100. + Elimina los archivos huérfanos que tienen una antigüedad superior al tiempo especificado en la propiedad de la tabla `vacuum_max_snapshot_age_seconds`. Los archivos huérfanos son archivos del directorio de datos de la tabla que no forman parte del estado de la tabla. Para obtener más información acerca de la creación y administración de tablas de Apache Iceberg en Athena, consulte [Creación de tablas de Iceberg](querying-iceberg-creating-tables.md) y [Administración de tablas de Iceberg](querying-iceberg-managing-tables.md). # Uso de EXPLAIN y EXPLAIN ANALYZE en Athena La instrucción `EXPLAIN` muestra el plan de ejecución lógico o distribuido de una instrucción SQL especificada, o valida la instrucción SQL. Puede generar los resultados en formato de texto o en formato de datos para representarlos en un gráfico. **nota** Puede ver representaciones gráficas de planes lógicos y distribuidos para sus consultas en la consola de Athena sin usar la sintaxis `EXPLAIN`. Para obtener más información, consulte [Visualización de planes de ejecución para consultas SQL](query-plans.md). La instrucción `EXPLAIN ANALYZE` muestra el plan de ejecución distribuido de una instrucción SQL especificada y el costo computacional de cada operación en una consulta SQL. Puede generar los resultados en formato de texto o JSON. ## Consideraciones y limitaciones Las instrucciones `EXPLAIN` y `EXPLAIN ANALYZE` de Athena tienen las siguientes limitaciones. + Dado que las consultas `EXPLAIN` no escanean ningún dato, Athena no cobra por ellas. Sin embargo, como las consultas `EXPLAIN` realizan llamadas a AWS Glue para recuperar metadatos de la tabla, puede incurrir en cargos de Glue si las llamadas superan el [límite de nivel gratuito de Glue](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc&awsf.Free%20Tier%20Categories=categories%23analytics&all-free-tier.q=glue&all-free-tier.q_operator=AND). + Como se ejecutan las consultas `EXPLAIN ANALYZE`, analizan datos, de modo que Athena cobra en función de los datos escaneados. + La información de filtrado de filas o celdas definida en Lake Formation y la información de estadísticas de consultas no se muestran en la salida de `EXPLAIN` y `EXPLAIN ANALYZE`. ## Sintaxis de EXPLAIN ``` EXPLAIN [ ( option [, ...]) ] statement ``` La *opción* puede ser una de las siguientes: ``` FORMAT { TEXT | GRAPHVIZ | JSON } TYPE { LOGICAL | DISTRIBUTED | VALIDATE | IO } ``` Si no se especifica la opción `FORMAT`, la salida predeterminada es en formato `TEXT`. El tipo `IO` proporciona información sobre las tablas y esquemas que la consulta lee. ## Sintaxis de EXPLAIN ANALYZE Además de la salida incluida en `EXPLAIN`, la salida `EXPLAIN ANALYZE` también incluye estadísticas de tiempo de ejecución de la consulta especificada, como el uso de CPU, el número de filas de entrada y el número de filas de salida. ``` EXPLAIN ANALYZE [ ( option [, ...]) ] statement ``` La *opción* puede ser una de las siguientes: ``` FORMAT { TEXT | JSON } ``` Si no se especifica la opción `FORMAT`, la salida predeterminada es en formato `TEXT`. Como todas las consultas para `EXPLAIN ANALYZE` son `DISTRIBUTED`, la opción `TYPE` no está disponible para `EXPLAIN ANALYZE`. La *instrucción* puede ser una de las siguientes: ``` SELECT CREATE TABLE AS SELECT INSERT UNLOAD ``` ## Ejemplos de EXPLAIN Los siguientes ejemplos de `EXPLAIN` avanzan de los más sencillos a los más complejos. ### Ejemplo 1: uso de la instrucción EXPLAIN para mostrar un plan de consulta en formato de texto En el siguiente ejemplo, `EXPLAIN` muestra el plan de ejecución de una consulta `SELECT` en registros de Elastic Load Balancing. El formato se establece de forma predeterminada en la salida de texto. ``` EXPLAIN SELECT request_timestamp, elb_name, request_ip FROM sampledb.elb_logs; ``` #### Resultados ``` - Output[request_timestamp, elb_name, request_ip] => [[request_timestamp, elb_name, request_ip]] - RemoteExchange[GATHER] => [[request_timestamp, elb_name, request_ip]] - TableScan[awsdatacatalog:HiveTableHandle{schemaName=sampledb, tableName=elb_logs, analyzePartitionValues=Optional.empty}] => [[request_timestamp, elb_name, request_ip]] LAYOUT: sampledb.elb_logs request_ip := request_ip:string:2:REGULAR request_timestamp := request_timestamp:string:0:REGULAR elb_name := elb_name:string:1:REGULAR ``` ### Ejemplo 2: uso de EXPLAIN para la representación gráfica de un plan de consulta Puede utilizar la consola de Athena para representar de manera gráfica un plan de consultas. Ingrese una instrucción `SELECT` como la siguiente en el editor de consultas de Athena y, a continuación, elija **EXPLICAR**. ``` SELECT c.c_custkey, o.o_orderkey, o.o_orderstatus FROM tpch100.customer c JOIN tpch100.orders o ON c.c_custkey = o.o_custkey ``` Se abrirá la página **Explain** (Explicar) del editor de consultas de Athena y se mostrára un plan distribuido y un plan lógico para la consulta. En el siguiente gráfico se muestra el plan lógico para el ejemplo. ![\[Gráfico del plan de consulta representado por el editor de consulta de Athena.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/athena-explain-statement-tpch.png) **importante** Actualmente, es posible que algunos filtros de partición no estén visibles en el gráfico de árbol de operadores anidado, aunque Athena los aplique a la consulta. Para comprobar el efecto de dichos filtros, ejecute `EXPLAIN` o `EXPLAIN ANALYZE` en la consulta y observe los resultados. Para obtener más información sobre cómo usar las características de representación gráfica de planes de consulta en la consola de Athena, consulte [Visualización de planes de ejecución para consultas SQL](query-plans.md). ### Ejemplo 3: uso de la instrucción EXPLAIN para comprobar la eliminación de particiones Cuando se utiliza un predicado de filtrado en una clave particionada para consultar una tabla particionada, el motor de consultas aplica el predicado a la clave particionada para reducir la cantidad de datos leídos. En el siguiente ejemplo se utiliza una consulta `EXPLAIN` para verificar la poda de partición para una consulta `SELECT` en una tabla particionada. Primero, una instrucción `CREATE TABLE` crea la tabla `tpch100.orders_partitioned`. La tabla está particionada en la columna `o_orderdate`. ``` CREATE TABLE `tpch100.orders_partitioned`( `o_orderkey` int, `o_custkey` int, `o_orderstatus` string, `o_totalprice` double, `o_orderpriority` string, `o_clerk` string, `o_shippriority` int, `o_comment` string) PARTITIONED BY ( `o_orderdate` string) ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe' STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat' LOCATION 's3://amzn-s3-demo-bucket//' ``` La tabla `tpch100.orders_partitioned` tiene varias particiones en `o_orderdate`, como se muestra en el comando `SHOW PARTITIONS`. ``` SHOW PARTITIONS tpch100.orders_partitioned; o_orderdate=1994 o_orderdate=2015 o_orderdate=1998 o_orderdate=1995 o_orderdate=1993 o_orderdate=1997 o_orderdate=1992 o_orderdate=1996 ``` La siguiente consulta `EXPLAIN` comprueba la poda de partición en la instrucción `SELECT` especificada. ``` EXPLAIN SELECT o_orderkey, o_custkey, o_orderdate FROM tpch100.orders_partitioned WHERE o_orderdate = '1995' ``` #### Resultados ``` Query Plan - Output[o_orderkey, o_custkey, o_orderdate] => [[o_orderkey, o_custkey, o_orderdate]] - RemoteExchange[GATHER] => [[o_orderkey, o_custkey, o_orderdate]] - TableScan[awsdatacatalog:HiveTableHandle{schemaName=tpch100, tableName=orders_partitioned, analyzePartitionValues=Optional.empty}] => [[o_orderkey, o_custkey, o_orderdate]] LAYOUT: tpch100.orders_partitioned o_orderdate := o_orderdate:string:-1:PARTITION_KEY :: [[1995]] o_custkey := o_custkey:int:1:REGULAR o_orderkey := o_orderkey:int:0:REGULAR ``` El texto en negrita del resultado muestra que se aplicó el predicado `o_orderdate = '1995'` en `PARTITION_KEY`. ### Ejemplo 4: uso de una consulta EXPLAIN para comprobar el orden de unión y el tipo de unión La siguiente consulta `EXPLAIN` verifica el orden y el tipo de unión de la instrucción `SELECT`. Utilice una consulta como esta para examinar el uso de la memoria de consulta de modo que pueda reducir las posibilidades de obtener un error `EXCEEDED_LOCAL_MEMORY_LIMIT`. ``` EXPLAIN (TYPE DISTRIBUTED) SELECT c.c_custkey, o.o_orderkey, o.o_orderstatus FROM tpch100.customer c JOIN tpch100.orders o ON c.c_custkey = o.o_custkey WHERE c.c_custkey = 123 ``` #### Resultados ``` Query Plan Fragment 0 [SINGLE] Output layout: [c_custkey, o_orderkey, o_orderstatus] Output partitioning: SINGLE [] Stage Execution Strategy: UNGROUPED_EXECUTION - Output[c_custkey, o_orderkey, o_orderstatus] => [[c_custkey, o_orderkey, o_orderstatus]] - RemoteSource[1] => [[c_custkey, o_orderstatus, o_orderkey]] Fragment 1 [SOURCE] Output layout: [c_custkey, o_orderstatus, o_orderkey] Output partitioning: SINGLE [] Stage Execution Strategy: UNGROUPED_EXECUTION - CrossJoin => [[c_custkey, o_orderstatus, o_orderkey]] Distribution: REPLICATED - ScanFilter[table = awsdatacatalog:HiveTableHandle{schemaName=tpch100, tableName=customer, analyzePartitionValues=Optional.empty}, grouped = false, filterPredicate = ("c_custkey" = 123)] => [[c_custkey]] LAYOUT: tpch100.customer c_custkey := c_custkey:int:0:REGULAR - LocalExchange[SINGLE] () => [[o_orderstatus, o_orderkey]] - RemoteSource[2] => [[o_orderstatus, o_orderkey]] Fragment 2 [SOURCE] Output layout: [o_orderstatus, o_orderkey] Output partitioning: BROADCAST [] Stage Execution Strategy: UNGROUPED_EXECUTION - ScanFilterProject[table = awsdatacatalog:HiveTableHandle{schemaName=tpch100, tableName=orders, analyzePartitionValues=Optional.empty}, grouped = false, filterPredicate = ("o_custkey" = 123)] => [[o_orderstatus, o_orderkey]] LAYOUT: tpch100.orders o_orderstatus := o_orderstatus:string:2:REGULAR o_custkey := o_custkey:int:1:REGULAR o_orderkey := o_orderkey:int:0:REGULAR ``` La consulta de ejemplo se optimizó en una combinación cruzada para obtener un mejor rendimiento. Los resultados muestran que `tpch100.orders` se distribuirá como el tipo de distribución `BROADCAST`. Esto implica que la tabla `tpch100.orders` se distribuirá a todos los nodos que realizan la operación de unión. El tipo de distribución `BROADCAST` requerirá que todos los resultados filtrados de la tabla `tpch100.orders` se ajusten en la memoria de cada nodo que realiza la operación de unión. Sin embargo, la tabla `tpch100.customer` es más pequeña que `tpch100.orders`. Dado que `tpch100.customer` requiere menos memoria, puede reescribir la consulta en `BROADCAST tpch100.customer` en lugar de `tpch100.orders`. Esto reduce la posibilidad de que la consulta reciba el error `EXCEEDED_LOCAL_MEMORY_LIMIT`. Esta estrategia supone los siguientes puntos: + La `tpch100.customer.c_custkey` es única en la tabla `tpch100.customer`. + Existe una relación de asignación de uno a muchos entre `tpch100.customer` y `tpch100.orders`. En el siguiente ejemplo, se muestra la consulta reescrita. ``` SELECT c.c_custkey, o.o_orderkey, o.o_orderstatus FROM tpch100.orders o JOIN tpch100.customer c -- the filtered results of tpch100.customer are distributed to all nodes. ON c.c_custkey = o.o_custkey WHERE c.c_custkey = 123 ``` ### Ejemplo 5: uso de una consulta EXPLAIN para eliminar predicados que no tengan efecto Puede utilizar una consulta `EXPLAIN` para verificar la eficacia de los predicados de filtrado. Puede utilizar los resultados para eliminar predicados que no tengan ningún efecto, como en el ejemplo a continuación. ``` EXPLAIN SELECT c.c_name FROM tpch100.customer c WHERE c.c_custkey = CAST(RANDOM() * 1000 AS INT) AND c.c_custkey BETWEEN 1000 AND 2000 AND c.c_custkey = 1500 ``` #### Resultados ``` Query Plan - Output[c_name] => [[c_name]] - RemoteExchange[GATHER] => [[c_name]] - ScanFilterProject[table = awsdatacatalog:HiveTableHandle{schemaName=tpch100, tableName=customer, analyzePartitionValues=Optional.empty}, filterPredicate = (("c_custkey" = 1500) AND ("c_custkey" = CAST(("random"() * 1E3) AS int)))] => [[c_name]] LAYOUT: tpch100.customer c_custkey := c_custkey:int:0:REGULAR c_name := c_name:string:1:REGULAR ``` El `filterPredicate` en los resultados muestra que el optimizador fusionó los tres predicados originales en dos predicados y cambió su orden de aplicación. ``` filterPredicate = (("c_custkey" = 1500) AND ("c_custkey" = CAST(("random"() * 1E3) AS int))) ``` Como los resultados muestran que el predicado `AND c.c_custkey BETWEEN 1000 AND 2000` no tiene ningún efecto, puede eliminar este predicado sin cambiar los resultados de la consulta. Para obtener información sobre los términos utilizados en los resultados de las consultas `EXPLAIN`, consulte [Descripción de los resultados de la instrucción EXPLAIN de Athena](athena-explain-statement-understanding.md). ## Ejemplos de EXPLAIN ANALYZE En los siguientes ejemplos, se muestran consultas y salidas `EXPLAIN ANALYZE`. ### Ejemplo 1: uso de EXPLAIN ANALYZE para mostrar un plan de consulta y los costos computacionales en formato de texto En el siguiente ejemplo, `EXPLAIN ANALYZE` muestra el plan de ejecución y los costos computacionales de una consulta `SELECT` en los registros de CloudFront. El formato se establece de forma predeterminada en la salida de texto. ``` EXPLAIN ANALYZE SELECT FROM cloudfront_logs LIMIT 10 ``` #### Resultados ``` Fragment 1 CPU: 24.60ms, Input: 10 rows (1.48kB); per task: std.dev.: 0.00, Output: 10 rows (1.48kB) Output layout: [date, time, location, bytes, requestip, method, host, uri, status, referrer,\ os, browser, browserversion] Limit[10] => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion]] CPU: 1.00ms (0.03%), Output: 10 rows (1.48kB) Input avg.: 10.00 rows, Input std.dev.: 0.00% LocalExchange[SINGLE] () => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion]] CPU: 0.00ns (0.00%), Output: 10 rows (1.48kB) Input avg.: 0.63 rows, Input std.dev.: 387.30% RemoteSource[2] => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion]] CPU: 1.00ms (0.03%), Output: 10 rows (1.48kB) Input avg.: 0.63 rows, Input std.dev.: 387.30% Fragment 2 CPU: 3.83s, Input: 998 rows (147.21kB); per task: std.dev.: 0.00, Output: 20 rows (2.95kB) Output layout: [date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion] LimitPartial[10] => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion]] CPU: 5.00ms (0.13%), Output: 20 rows (2.95kB) Input avg.: 166.33 rows, Input std.dev.: 141.42% TableScan[awsdatacatalog:HiveTableHandle{schemaName=default, tableName=cloudfront_logs,\ analyzePartitionValues=Optional.empty}, grouped = false] => [[date, time, location, bytes, requestip, method, host, uri, st CPU: 3.82s (99.82%), Output: 998 rows (147.21kB) Input avg.: 166.33 rows, Input std.dev.: 141.42% LAYOUT: default.cloudfront_logs date := date:date:0:REGULAR referrer := referrer:string:9:REGULAR os := os:string:10:REGULAR method := method:string:5:REGULAR bytes := bytes:int:3:REGULAR browser := browser:string:11:REGULAR host := host:string:6:REGULAR requestip := requestip:string:4:REGULAR location := location:string:2:REGULAR time := time:string:1:REGULAR uri := uri:string:7:REGULAR browserversion := browserversion:string:12:REGULAR status := status:int:8:REGULAR ``` ### Ejemplo  2: uso de EXPLAIN ANALYZE para mostrar un plan de consulta en formato JSON En el siguiente ejemplo, se muestra el plan de ejecución y los costos computacionales de una consulta `SELECT` en los registros de CloudFront. En el ejemplo se especifica JSON como formato de salida. ``` EXPLAIN ANALYZE (FORMAT JSON) SELECT * FROM cloudfront_logs LIMIT 10 ``` #### Resultados ``` { "fragments": [{ "id": "1", "stageStats": { "totalCpuTime": "3.31ms", "inputRows": "10 rows", "inputDataSize": "1514B", "stdDevInputRows": "0.00", "outputRows": "10 rows", "outputDataSize": "1514B" }, "outputLayout": "date, time, location, bytes, requestip, method, host,\ uri, status, referrer, os, browser, browserversion", "logicalPlan": { "1": [{ "name": "Limit", "identifier": "[10]", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host",\ "uri", "status", "referrer", "os", "browser", "browserversion"], "details": "", "distributedNodeStats": { "nodeCpuTime": "0.00ns", "nodeOutputRows": 10, "nodeOutputDataSize": "1514B", "operatorInputRowsStats": [{ "nodeInputRows": 10.0, "nodeInputRowsStdDev": 0.0 }] }, "children": [{ "name": "LocalExchange", "identifier": "[SINGLE] ()", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host",\ "uri", "status", "referrer", "os", "browser", "browserversion"], "details": "", "distributedNodeStats": { "nodeCpuTime": "0.00ns", "nodeOutputRows": 10, "nodeOutputDataSize": "1514B", "operatorInputRowsStats": [{ "nodeInputRows": 0.625, "nodeInputRowsStdDev": 387.2983346207417 }] }, "children": [{ "name": "RemoteSource", "identifier": "[2]", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host",\ "uri", "status", "referrer", "os", "browser", "browserversion"], "details": "", "distributedNodeStats": { "nodeCpuTime": "0.00ns", "nodeOutputRows": 10, "nodeOutputDataSize": "1514B", "operatorInputRowsStats": [{ "nodeInputRows": 0.625, "nodeInputRowsStdDev": 387.2983346207417 }] }, "children": [] }] }] }] } }, { "id": "2", "stageStats": { "totalCpuTime": "1.62s", "inputRows": "500 rows", "inputDataSize": "75564B", "stdDevInputRows": "0.00", "outputRows": "10 rows", "outputDataSize": "1514B" }, "outputLayout": "date, time, location, bytes, requestip, method, host, uri, status,\ referrer, os, browser, browserversion", "logicalPlan": { "1": [{ "name": "LimitPartial", "identifier": "[10]", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host", "uri",\ "status", "referrer", "os", "browser", "browserversion"], "details": "", "distributedNodeStats": { "nodeCpuTime": "0.00ns", "nodeOutputRows": 10, "nodeOutputDataSize": "1514B", "operatorInputRowsStats": [{ "nodeInputRows": 83.33333333333333, "nodeInputRowsStdDev": 223.60679774997897 }] }, "children": [{ "name": "TableScan", "identifier": "[awsdatacatalog:HiveTableHandle{schemaName=default,\ tableName=cloudfront_logs, analyzePartitionValues=Optional.empty},\ grouped = false]", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host", "uri",\ "status", "referrer", "os", "browser", "browserversion"], "details": "LAYOUT: default.cloudfront_logs\ndate := date:date:0:REGULAR\nreferrer :=\ referrer: string:9:REGULAR\nos := os:string:10:REGULAR\nmethod := method:string:5:\ REGULAR\nbytes := bytes:int:3:REGULAR\nbrowser := browser:string:11:REGULAR\nhost :=\ host:string:6:REGULAR\nrequestip := requestip:string:4:REGULAR\nlocation :=\ location:string:2:REGULAR\ntime := time:string:1: REGULAR\nuri := uri:string:7:\ REGULAR\nbrowserversion := browserversion:string:12:REGULAR\nstatus :=\ status:int:8:REGULAR\n", "distributedNodeStats": { "nodeCpuTime": "1.62s", "nodeOutputRows": 500, "nodeOutputDataSize": "75564B", "operatorInputRowsStats": [{ "nodeInputRows": 83.33333333333333, "nodeInputRowsStdDev": 223.60679774997897 }] }, "children": [] }] }] } }] } ``` ## Recursos adicionales Para obtener información adicional, consulte los siguientes recursos. + [Descripción de los resultados de la instrucción EXPLAIN de Athena](athena-explain-statement-understanding.md) + [Visualización de planes de ejecución para consultas SQL](query-plans.md) + [Visualización de estadísticas y detalles de ejecución de consultas completadas](query-stats.md) + Documentación de Trino sobre [https://trino.io/docs/current/sql/explain.html](https://trino.io/docs/current/sql/explain.html) + Documentación de Trino sobre [https://trino.io/docs/current/sql/explain-analyze.html](https://trino.io/docs/current/sql/explain-analyze.html) + [Optimice el rendimiento de las consultas federadas con EXPLAIN y EXPLAIN ANALYZE en Amazon Athena](https://aws.amazon.com/blogs/big-data/optimize-federated-query-performance-using-explain-and-explain-analyze-in-amazon-athena/) en el *Blog de macrodatos de AWS*. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/7JUyTqglmNU/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/7JUyTqglmNU) # Descripción de los resultados de la instrucción EXPLAIN de Athena Este tema proporciona una breve guía de los términos operativos utilizados en los resultados de instrucciones `EXPLAIN` en Athena. ## Tipos de salida de instrucciones EXPLAIN `EXPLAIN`Las salidas de instrucciones pueden ser de dos tipos: + **Plan lógico**: muestra el plan lógico que utiliza el motor SQL para ejecutar una instrucción. La sintaxis para esta opción es `EXPLAIN` o `EXPLAIN (TYPE LOGICAL)`. + **Plan distribuido**: muestra un plan de ejecución en un entorno distribuido. La salida muestra fragmentos, que son etapas de procesamiento. Cada fragmento de plan es procesado por uno o más nodos. Los datos se pueden intercambiar entre los nodos que procesan los fragmentos. La sintaxis para esta opción es `EXPLAIN (TYPE DISTRIBUTED)`. En la salida de un plan distribuido, los fragmentos (etapas de procesamiento) están indicados por un `Fragment` *número* [*fragment\$1type*], donde el *número* es un entero basado en cero y *fragment\$1type* especifica cómo los nodos ejecutan el fragmento. En la siguiente tabla se describen los tipos de fragmentos, que proporcionan información del diseño del intercambio de datos. **Tipos de fragmentos del plan distribuido** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/athena-explain-statement-understanding.html) ## Exchange Los términos relacionados con el intercambio describen cómo se intercambian datos entre nodos de trabajo. Las transferencias pueden ser locales o remotas. **LocalExchange [*exchange\$1type*] ** Transfiere datos de manera local dentro de los nodos de trabajo para diferentes etapas de una consulta. El valor de *exchange\$1type* puede ser uno de los tipos de intercambio lógicos o distribuidos, como se describe más adelante en esta sección. **RemoteExchange [*exchange\$1type*] ** Transfiere datos entre los nodos de trabajo para diferentes etapas de una consulta. El valor de *exchange\$1type* puede ser uno de los tipos de intercambio lógicos o distribuidos, como se describe más adelante en esta sección. ### Tipos de intercambio lógico Los siguientes tipos de intercambio describen las acciones efectuadas durante la fase de intercambio de un plan lógico. + **`GATHER`** – un nodo de trabajo único recopila la salida de todos los demás nodos de trabajo. Por ejemplo, la última etapa de una consulta de selección reúne los resultados de todos los nodos y los escribe en Amazon S3. + **`REPARTITION`** – envía los datos de fila a un empleado específico según el esquema de partición necesario para aplicar al siguiente operador. + **`REPLICATE`** – copia los datos de fila en todos los empleados. ### Tipos de intercambio distribuido Los siguientes tipos de intercambio indican el diseño de los datos cuando se intercambian entre nodos en un plan distribuido. + **`HASH`** – el intercambio distribuye datos a varios destinos utilizando una función hash. + **`SINGLE`** – el intercambio distribuye los datos a un único destino. ## Análisis Los siguientes términos describen cómo se analizan los datos durante una consulta. **TableScan ** Analiza los datos de origen de una tabla desde Amazon S3 o un conector Apache Hive y aplica la poda de partición generada a partir del predicado del filtro. **ScanFilter ** Analiza los datos de origen de una tabla desde Amazon S3 o un conector Hive y aplica la poda de partición generada a partir del predicado del filtro y de predicados de filtro adicionales no aplicados a través de la poda de partición. **ScanFilterProject ** Primero, analiza los datos de origen de una tabla desde Amazon S3 o un conector Hive y aplica la poda de partición generada a partir del predicado del filtro y de predicados de filtro adicionales no aplicados a través de la poda de partición. A continuación, modifica el diseño de la memoria de los datos de salida en una nueva proyección para mejorar el rendimiento de etapas posteriores. ## Join Une datos entre dos tablas. Las uniones se pueden clasificar por tipo de unión y por tipo de distribución. ### Tipos de combinación Los tipos de unión definen la manera en que se produce la operación de unión. **CrossJoin**: produce el producto cartesiano de las dos tablas unidas. **InnerJoin**: selecciona registros que tienen valores coincidentes en ambas tablas. **LeftJoin**: selecciona todos los registros de la tabla izquierda y los registros coincidentes de la tabla derecha. Si no se produce ninguna coincidencia, el resultado en el lado derecho es NULL. **Right Join**: selecciona todos los registros de la tabla derecha y los registros coincidentes de la tabla izquierda. Si no se produce ninguna coincidencia, el resultado en el lado izquierdo es NULL. **FullJoin**: selecciona todos los registros en los que hay una coincidencia en los registros de la tabla izquierda o derecha. La tabla combinada contiene todos los registros de las tablas y rellena NULL para las coincidencias que faltan en ambos lados. **nota** Por razones de rendimiento, el motor de consultas puede reescribir una consulta de unión en un tipo de unión diferente para producir los mismos resultados. Por ejemplo, una consulta de unión interna con predicado en una tabla se puede volver a escribir en una `CrossJoin`. Esto empuja el predicado a la fase de escaneo de la tabla para que se escaneen menos datos. ### Tipos de distribución de unión Los tipos de distribución definen la manera en que se intercambian los datos entre nodos de trabajo cuando se realiza la operación de unión. **Particionada**: tanto la tabla izquierda como la derecha están particionadas en hash en todos los nodos de trabajo. La distribución particionada consume menos memoria en cada nodo. La distribución particionada puede ser mucho más lenta que las uniones replicadas. Las uniones particionadas son adecuadas cuando se unen dos tablas grandes. **Replicada**: una tabla está particionada en hash en todos los nodos de trabajo y la otra tabla se replica en todos los nodos de trabajo para realizar la operación de unión. La distribución replicada puede ser mucho más rápida que las uniones particionadas, pero consume más memoria en cada nodo de trabajo. Si la tabla replicada es demasiado grande, el nodo de trabajo puede experimentar un error de memoria insuficiente. Las uniones replicadas son adecuadas cuando una de las tablas combinadas es pequeña. # PREPARE Crea una instrucción SQL con el nombre `statement_name` que se ejecutará en un momento posterior. La instrucción puede incluir parámetros representados por signos de interrogación. Para proporcionar valores para los parámetros y ejecutar la instrucción preparada, utilice [EXECUTE](sql-execute.md). ## Sinopsis ``` PREPARE statement_name FROM statement ``` En la tabla siguiente se describen estos parámetros. **** | Parámetro | Descripción | | --- | --- | | statement\$1name | Nombre de la instrucción a preparar. El nombre debe ser único dentro del grupo de trabajo. | | statement | Una consulta SELECT, CTAS o INSERT INTO. | **nota** El número máximo de instrucciones preparadas en un grupo de trabajo es 1000. ## Ejemplos El siguiente ejemplo prepara una consulta SELECT sin parámetros. ``` PREPARE my_select1 FROM SELECT * FROM nation ``` El siguiente ejemplo prepara una consulta SELECT que incluye parámetros. Los valores `productid` y `quantity` serán suministrados por la cláusula `USING` de una instrucción `EXECUTE`: ``` PREPARE my_select2 FROM SELECT order FROM orders WHERE productid = ? and quantity < ? ``` En el siguiente ejemplo, se prepara una consulta de inserción. ``` PREPARE my_insert FROM INSERT INTO cities_usa (city, state) SELECT city, state FROM cities_world WHERE country = ? ``` ## Recursos adicionales de [Uso de instrucciones preparadas](querying-with-prepared-statements-querying.md) [EXECUTE](sql-execute.md) [DEALLOCATE PREPARE](sql-deallocate-prepare.md) [INSERT INTO](insert-into.md) # EXECUTE Ejecuta una instrucción preparada con el nombre `statement_name`. Los valores de los parámetros para los signos de interrogación de la instrucción preparada se definen en la cláusula `USING` en una lista separada por comas. Para crear una instrucción preparada, utilice [PREPARE](sql-prepare.md). ## Sinopsis ``` EXECUTE statement_name [ USING parameter1[, parameter2, ... ] ] ``` ## Ejemplos El siguiente ejemplo prepara y ejecuta una consulta sin parámetros. ``` PREPARE my_select1 FROM SELECT name FROM nation EXECUTE my_select1 ``` El siguiente ejemplo prepara y ejecuta una consulta con un único parámetro. ``` PREPARE my_select2 FROM SELECT * FROM "my_database"."my_table" WHERE year = ? EXECUTE my_select2 USING 2012 ``` Equivale a: ``` SELECT * FROM "my_database"."my_table" WHERE year = 2012 ``` El siguiente ejemplo prepara y ejecuta una consulta con dos parámetros. ``` PREPARE my_select3 FROM SELECT order FROM orders WHERE productid = ? and quantity < ? EXECUTE my_select3 USING 346078, 12 ``` ## Recursos adicionales de [Uso de instrucciones preparadas](querying-with-prepared-statements-querying.md) [PREPARE](sql-prepare.md) [INSERT INTO](insert-into.md) # DEALLOCATE PREPARE Elimina la instrucción preparada con el nombre especificado de las instrucciones preparadas del grupo de trabajo actual. ## Sinopsis ``` DEALLOCATE PREPARE statement_name ``` ## Ejemplos En el siguiente ejemplo, se elimina la instrucción preparada `my_select1` del grupo de trabajo actual. ``` DEALLOCATE PREPARE my_select1 ``` ## Recursos adicionales de [Uso de instrucciones preparadas](querying-with-prepared-statements-querying.md) [PREPARE](sql-prepare.md) # UNLOAD Escribe los resultados de la consulta desde una instrucción `SELECT` al formato de datos especificado. Los formatos admitidos para `UNLOAD` incluyen Apache Parquet, ORC, Apache Avro y JSON. CSV es el único formato de salida compatible con el comando `SELECT` de Athena; no obstante, pero puede usar el comando `UNLOAD`, que admite una variedad de formatos de salida, para incluir la consulta `SELECT` y reescribir su salida en uno de los formatos compatibles con `UNLOAD`. Si bien puede utilizar la instrucción `CREATE TABLE AS` (CTAS) para generar datos en formatos distintos a CSV, esas instrucciones también requieren la creación de una tabla en Athena. La instrucción `UNLOAD` es útil cuando se desea generar los resultados de una consulta `SELECT` en un formato que no sea CSV, pero no se requiere la tabla asociada. Por ejemplo, una aplicación descendente puede requerir que los resultados de una consulta `SELECT` estén en formato JSON, y Parquet u ORC podrían proporcionar una ventaja de rendimiento sobre CSV si tiene la intención de utilizar los resultados de la consulta `SELECT` para un análisis adicional. ## Consideraciones y limitaciones Cuando utiliza la instrucción `UNLOAD` en Athena, tenga en cuenta los siguientes puntos: + **Sin orden global de archivos**: los resultados de `UNLOAD` se escriben en varios archivos en paralelo. Si la consulta `SELECT` en la instrucción `UNLOAD` especifica un orden de clasificación, el contenido de cada archivo está en orden de clasificación, pero los archivos no están ordenados entre sí. + **Datos huérfanos no eliminados**: en caso de error, Athena no intenta eliminar datos huérfanos. Este comportamiento es el mismo que en instrucciones CTAS y `INSERT INTO`. + **Particiones máximas**: el número máximo de particiones que se pueden utilizar con `UNLOAD` es 100. + **Archivos de manifiesto y metadatos**: Athena genera un archivo de metadatos y un archivo de manifiesto de datos para cada consulta `UNLOAD`. El manifiesto realiza un seguimiento de los archivos que escribió la consulta. Ambos archivos se guardan en la ubicación de resultados de consulta de Athena en Amazon S3. Para obtener más información, consulte [Identificación de archivos de salida de consultas](querying-finding-output-files.md#querying-identifying-output-files). + **Cifrado**: Los archivos de salida `UNLOAD` se cifran de acuerdo con la configuración de cifrado utilizada para Amazon S3. Para configurar la configuración de cifrado para cifrar el resultado `UNLOAD`, puede utilizar la [API EncryptionConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EncryptionConfiguration.html). + **Instrucciones preparadas**: `UNLOAD` se puede utilizar con instrucciones preparadas. Para obtener información acerca de las instrucciones preparadas en Athena, consulte [Uso de consultas parametrizadas](querying-with-prepared-statements.md). + **Service quotas**: `UNLOAD` utiliza cuotas de consultas DML. Para obtener información sobre las cuotas, consulte [Service Quotas](service-limits.md). + **Propietario esperado del bucket**: la configuración del propietario esperado del bucket no se aplica a la ubicación de Amazon S3 de destino especificada en la consulta `UNLOAD`. 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). ## Sintaxis La instrucción `UNLOAD` utiliza la siguiente sintaxis. ``` UNLOAD (SELECT col_name[, ...] FROM old_table) TO 's3://amzn-s3-demo-bucket/my_folder/' WITH ( property_name = 'expression' [, ...] ) ``` Excepto cuando se escribe en particiones, el destino de `TO` debe especificar una ubicación en Amazon S3 que no tenga datos. Antes de que la consulta `UNLOAD` escriba en la ubicación especificada, verifica que la ubicación del bucket está vacía. Como `UNLOAD` no escribe datos en la ubicación especificada si la ubicación ya tiene datos en ella, `UNLOAD` no sobrescribe los datos existentes. Para reutilizar una ubicación de bucket como destino para `UNLOAD`, elimine los datos de la ubicación del bucket y, a continuación, vuelva a ejecutar la consulta. Tenga en cuenta que cuando `UNLOAD` escribe en particiones, este comportamiento es diferente. Si ejecuta la misma consulta `UNLOAD` varias veces con la misma instrucción `SELECT`, la misma ubicación `TO` y las mismas particiones, cada consulta `UNLOAD` descargará los datos en Amazon S3 en la ubicación y las particiones especificadas. ### Parameters Los valores posibles para *property\$1name* son los siguientes. ** format = '*file\$1format*' ** Obligatorio. Especifica el formato de archivo de la salida. Los valores posibles para *file\$1format* son `ORC`, `PARQUET`, `AVRO`, `JSON` o `TEXTFILE`. ** compression = '*compression\$1format*' ** Opcional. Esta opción es específica de los formatos ORC y Parquet. Para ORC, el valor predeterminado es `zlib`, y para Parquet, el valor predeterminado es `gzip`. Para obtener información sobre los formatos de compresión compatibles, consulte [Compatibilidad con la compresión de Athena](https://docs.aws.amazon.com/athena/latest/ug/compression-formats.html). Esta opción no se aplica al formato `AVRO`. Athena utiliza `gzip` para los formatos `JSON` y `TEXTFILE`. **compression\$1level = *compression\$1level* ** Opcional. El nivel de compresión que se debe utilizar para la compresión ZSTD. Esta propiedad solo se aplica a la compresión ZSTD. Para obtener más información, consulte [Uso de niveles de compresión de ZSTD](compression-support-zstd-levels.md). ** field\$1delimiter = '*delimiter*' ** Opcional. Especifica un delimitador de campo de un solo carácter para archivos con formato CSV, TSV y otros formatos de texto. En el ejemplo siguiente se especifica un delimitador de coma. ``` WITH (field_delimiter = ',') ``` Actualmente, no se admiten delimitadores de campos de caracteres múltiples. Si no especifica un delimitador de campo, se utiliza el carácter octal `\001` (^A). ** partitioned\$1by = ARRAY[ *col\$1name*[,...] ] ** Opcional. Una matriz de columnas por las que se particiona la salida. Asegúrese de que en su instrucción `SELECT`, los nombres de las columnas particionadas aparezcan en último lugar en la lista de columnas. ## Ejemplos En el siguiente ejemplo se escribe el resultado de una consulta `SELECT` en la ubicación `s3://amzn-s3-demo-bucket/unload_test_1/` de Amazon S3 utilizando el formato JSON. ``` UNLOAD (SELECT * FROM old_table) TO 's3://amzn-s3-demo-bucket/unload_test_1/' WITH (format = 'JSON') ``` En el siguiente ejemplo se escribe el resultado de una consulta `SELECT` en formato Parquet mediante compresión Snappy. ``` UNLOAD (SELECT * FROM old_table) TO 's3://amzn-s3-demo-bucket/' WITH (format = 'PARQUET',compression = 'SNAPPY') ``` En el siguiente ejemplo se escriben cuatro columnas en formato de texto, con la salida particionada por la última columna. ``` UNLOAD (SELECT name1, address1, comment1, key1 FROM table1) TO 's3://amzn-s3-demo-bucket/ partitioned/' WITH (format = 'TEXTFILE', partitioned_by = ARRAY['key1']) ``` En el siguiente ejemplo se descargan los resultados de la consulta en la ubicación especificada mediante el formato de archivo Parquet, compresión ZSTD y el nivel 4 de compresión ZSTD. ``` UNLOAD (SELECT * FROM old_table) TO 's3://amzn-s3-demo-bucket/' WITH (format = 'PARQUET', compression = 'ZSTD', compression_level = 4) ``` ## Recursos adicionales + [Simplificar las canalizaciones de ETL y ML con la característica UNLOAD de Amazon Athena](https://aws.amazon.com/blogs/big-data/simplify-your-etl-and-ml-pipelines-using-the-amazon-athena-unload-feature/) en el *Blog de macrodatos de AWS*. # Funciones en Amazon Athena Para obtener información acerca de los cambios en las funciones entre las versiones del motor de Athena, consulte [Control de versiones del motor Athena](engine-versions.md). Para obtener una lista de las zonas horarias que se pueden utilizar con el operador `AT TIME ZONE`, consulte [Uso de zonas horarias admitidas](athena-supported-time-zones.md). **Topics** + [Versión 3 del motor Athena](functions-env3.md) # Funciones de la versión 3 del motor Athena Las funciones de la versión 3 del motor Athena se basan en Trino. Para obtener información sobre las funciones, los operadores y las expresiones de Trino, consulte [Funciones y operadores](https://trino.io/docs/current/functions.html) y las siguientes subsecciones de la documentación de Trino. + [Aggregate](https://trino.io/docs/current/functions/aggregate.html) + [Array](https://trino.io/docs/current/functions/array.html) (Matriz) + [Binario](https://trino.io/docs/current/functions/binary.html) + [Bitwise](https://trino.io/docs/current/functions/bitwise.html) (Bit a bit) + [Color](https://trino.io/docs/current/functions/color.html) + [Comparación](https://trino.io/docs/current/functions/comparison.html) + [Condicional](https://trino.io/docs/current/functions/conditional.html) + [Conversion](https://trino.io/docs/current/functions/conversion.html) (Conversión) + [Fecha y hora](https://trino.io/docs/current/functions/datetime.html) + [Decimal](https://trino.io/docs/current/functions/decimal.html) (Decimal) + [Geospatial](https://trino.io/docs/current/functions/geospatial.html) (Geoespacial) + [HyperLogLog](https://trino.io/docs/current/functions/hyperloglog.html) + [IP Address](https://trino.io/docs/current/functions/ipaddress.html) (Dirección IP) + [JSON](https://trino.io/docs/current/functions/json.html) + [Lambda](https://trino.io/docs/current/functions/lambda.html) + [Logical](https://trino.io/docs/current/functions/logical.html) (Lógica) + [Machine learning](https://trino.io/docs/current/functions/ml.html) + [Map](https://trino.io/docs/current/functions/map.html) + [Math (Matemática)](https://trino.io/docs/current/functions/math.html) + [Quantile digest](https://trino.io/docs/current/functions/qdigest.html) (Resumen de cuantiles) + [Expresión regular](https://trino.io/docs/current/functions/regexp.html) + [Session](https://trino.io/docs/current/functions/session.html) (Sesión) + [Set Digest](https://trino.io/docs/current/functions/setdigest.html) (Establecer resumen) + [Cadena](https://trino.io/docs/current/functions/string.html) + [Tabla](https://trino.io/docs/current/functions/table.html) + [Teradata](https://trino.io/docs/current/functions/teradata.html) + [T-Digest](https://trino.io/docs/current/functions/tdigest.html) + [URL](https://trino.io/docs/current/functions/url.html) + [UUID](https://trino.io/docs/current/functions/uuid.html) (Identificador único universal) + [Window](https://trino.io/docs/current/functions/window.html) ## función invoker\$1principal() La función `invoker_principal` es exclusiva de la versión 3 del motor de Athena y no se encuentra en Trino. Devuelve `VARCHAR` que contiene el ARN de la entidad principal (rol de IAM o identidad del Centro de Identidades) que ejecutó la consulta que llama a la función. Por ejemplo, si el invocador de la consulta utiliza los permisos de un rol IAM para ejecutar la consulta, la función devuelve el ARN del rol de IAM. El rol que ejecuta la consulta debe permitir la acción `LakeFormation:GetDataLakePrincipal`. ### Uso ``` SELECT invoker_principal() ``` En la tabla que figura a continuación aparece un ejemplo de resultado. **** | \$1 | \$1col0 | | --- | --- | | 1 | arn:aws:iam::111122223333:role/Admin | # Uso de zonas horarias admitidas Puede utilizar el operador `AT TIME ZONE` en una instrucción `SELECT timestamp` para especificar la zona horaria de la marca de tiempo que se devuelve, como en el ejemplo siguiente: ``` SELECT timestamp '2012-10-31 01:00 UTC' AT TIME ZONE 'America/Los_Angeles' AS la_time; ``` **Resultados** ``` la_time 2012-10-30 18:00:00.000 America/Los_Angeles ``` Para ver una lista de las zonas horarias compatibles en Athena, amplíe la [Lista de zonas horarias admitidas](#athena-supported-time-zones-list) al final de este tema. ## Funciones y ejemplos de zona horaria A continuación, se muestran más funciones y ejemplos relacionados con zona horaria. + **at\$1timezone (*timestamp*, *zone*)**: devuelve el valor de *timestamp* (marca temporal) en la hora local correspondiente para *zone* (zona). **Ejemplo** ``` SELECT at_timezone(timestamp '2021-08-22 00:00 UTC', 'Canada/Newfoundland') ``` **Resultado** ``` 2021-08-21 21:30:00.000 Canada/Newfoundland ``` + **timezone\$1hour (*timestamp*)**: devuelve la hora de diferencia de la zona horaria con respecto al valor timestamp como `bigint`. **Ejemplo** ``` SELECT timezone_hour(timestamp '2021-08-22 04:00 UTC' AT TIME ZONE 'Canada/Newfoundland') ``` **Resultado** ``` -2 ``` + **timezone\$1minute (*timestamp*)**: devuelve los minutos de diferencia de la zona horaria con respecto a *timestamp* como `bigint`. **Ejemplo** ``` SELECT timezone_minute(timestamp '2021-08-22 04:00 UTC' AT TIME ZONE 'Canada/Newfoundland') ``` **Resultado** ``` -30 ``` + **with\$1timezone (*timestamp*, *zone*)**: devuelve una marca temporal con zona horaria de los valores *timestamp* y *zone* especificados. **Ejemplo** ``` SELECT with_timezone(timestamp '2021-08-22 04:00', 'Canada/Newfoundland') ``` **Resultado** ``` 2021-08-22 04:00:00.000 Canada/Newfoundland ``` ## Lista de zonas horarias admitidas La siguiente lista contiene las zonas horarias que se pueden utilizar con el operador `AT TIME ZONE` en Athena. Para obtener más funciones y ejemplos relacionados con zona horaria, consulte [Funciones y ejemplos de zona horaria](#athena-supported-time-zones-functions-examples). ``` Africa/Abidjan Africa/Accra Africa/Addis_Ababa Africa/Algiers Africa/Asmara Africa/Asmera Africa/Bamako Africa/Bangui Africa/Banjul Africa/Bissau Africa/Blantyre Africa/Brazzaville Africa/Bujumbura Africa/Cairo Africa/Casablanca Africa/Ceuta Africa/Conakry Africa/Dakar Africa/Dar_es_Salaam Africa/Djibouti Africa/Douala Africa/El_Aaiun Africa/Freetown Africa/Gaborone Africa/Harare Africa/Johannesburg Africa/Juba Africa/Kampala Africa/Khartoum Africa/Kigali Africa/Kinshasa Africa/Lagos Africa/Libreville Africa/Lome Africa/Luanda Africa/Lubumbashi Africa/Lusaka Africa/Malabo Africa/Maputo Africa/Maseru Africa/Mbabane Africa/Mogadishu Africa/Monrovia Africa/Nairobi Africa/Ndjamena Africa/Niamey Africa/Nouakchott Africa/Ouagadougou Africa/Porto-Novo Africa/Sao_Tome Africa/Timbuktu Africa/Tripoli Africa/Tunis Africa/Windhoek America/Adak America/Anchorage America/Anguilla America/Antigua America/Araguaina America/Argentina/Buenos_Aires America/Argentina/Catamarca America/Argentina/ComodRivadavia America/Argentina/Cordoba America/Argentina/Jujuy America/Argentina/La_Rioja America/Argentina/Mendoza America/Argentina/Rio_Gallegos America/Argentina/Salta America/Argentina/San_Juan America/Argentina/San_Luis America/Argentina/Tucuman America/Argentina/Ushuaia America/Aruba America/Asuncion America/Atikokan America/Atka America/Bahia America/Bahia_Banderas America/Barbados America/Belem America/Belize America/Blanc-Sablon America/Boa_Vista America/Bogota America/Boise America/Buenos_Aires America/Cambridge_Bay America/Campo_Grande America/Cancun America/Caracas America/Catamarca America/Cayenne America/Cayman America/Chicago America/Chihuahua America/Coral_Harbour America/Cordoba America/Costa_Rica America/Creston America/Cuiaba America/Curacao America/Danmarkshavn America/Dawson America/Dawson_Creek America/Denver America/Detroit America/Dominica America/Edmonton America/Eirunepe America/El_Salvador America/Ensenada America/Fort_Nelson America/Fort_Wayne America/Fortaleza America/Glace_Bay America/Godthab America/Goose_Bay America/Grand_Turk America/Grenada America/Guadeloupe America/Guatemala America/Guayaquil America/Guyana America/Halifax America/Havana America/Hermosillo America/Indiana/Indianapolis America/Indiana/Knox America/Indiana/Marengo America/Indiana/Petersburg America/Indiana/Tell_City America/Indiana/Vevay America/Indiana/Vincennes America/Indiana/Winamac America/Indianapolis America/Inuvik America/Iqaluit America/Jamaica America/Jujuy America/Juneau America/Kentucky/Louisville America/Kentucky/Monticello America/Knox_IN America/Kralendijk America/La_Paz America/Lima America/Los_Angeles America/Louisville America/Lower_Princes America/Maceio America/Managua America/Manaus America/Marigot America/Martinique America/Matamoros America/Mazatlan America/Mendoza America/Menominee America/Merida America/Metlakatla America/Mexico_City America/Miquelon America/Moncton America/Monterrey America/Montevideo America/Montreal America/Montserrat America/Nassau America/New_York America/Nipigon America/Nome America/Noronha America/North_Dakota/Beulah America/North_Dakota/Center America/North_Dakota/New_Salem America/Ojinaga America/Panama America/Pangnirtung America/Paramaribo America/Phoenix America/Port-au-Prince America/Port_of_Spain America/Porto_Acre America/Porto_Velho America/Puerto_Rico America/Punta_Arenas America/Rainy_River America/Rankin_Inlet America/Recife America/Regina America/Resolute America/Rio_Branco America/Rosario America/Santa_Isabel America/Santarem America/Santiago America/Santo_Domingo America/Sao_Paulo America/Scoresbysund America/Shiprock America/Sitka America/St_Barthelemy America/St_Johns America/St_Kitts America/St_Lucia America/St_Thomas America/St_Vincent America/Swift_Current America/Tegucigalpa America/Thule America/Thunder_Bay America/Tijuana America/Toronto America/Tortola America/Vancouver America/Virgin America/Whitehorse America/Winnipeg America/Yakutat America/Yellowknife Antarctica/Casey Antarctica/Davis Antarctica/DumontDUrville Antarctica/Macquarie Antarctica/Mawson Antarctica/McMurdo Antarctica/Palmer Antarctica/Rothera Antarctica/South_Pole Antarctica/Syowa Antarctica/Troll Antarctica/Vostok Arctic/Longyearbyen Asia/Aden Asia/Almaty Asia/Amman Asia/Anadyr Asia/Aqtau Asia/Aqtobe Asia/Ashgabat Asia/Ashkhabad Asia/Atyrau Asia/Baghdad Asia/Bahrain Asia/Baku Asia/Bangkok Asia/Barnaul Asia/Beirut Asia/Bishkek Asia/Brunei Asia/Calcutta Asia/Chita Asia/Choibalsan Asia/Chongqing Asia/Chungking Asia/Colombo Asia/Dacca Asia/Damascus Asia/Dhaka Asia/Dili Asia/Dubai Asia/Dushanbe Asia/Gaza Asia/Harbin Asia/Hebron Asia/Ho_Chi_Minh Asia/Hong_Kong Asia/Hovd Asia/Irkutsk Asia/Istanbul Asia/Jakarta Asia/Jayapura Asia/Jerusalem Asia/Kabul Asia/Kamchatka Asia/Karachi Asia/Kashgar Asia/Kathmandu Asia/Katmandu Asia/Khandyga Asia/Kolkata Asia/Krasnoyarsk Asia/Kuala_Lumpur Asia/Kuching Asia/Kuwait Asia/Macao Asia/Macau Asia/Magadan Asia/Makassar Asia/Manila Asia/Muscat Asia/Nicosia Asia/Novokuznetsk Asia/Novosibirsk Asia/Omsk Asia/Oral Asia/Phnom_Penh Asia/Pontianak Asia/Pyongyang Asia/Qatar Asia/Qyzylorda Asia/Rangoon Asia/Riyadh Asia/Saigon Asia/Sakhalin Asia/Samarkand Asia/Seoul Asia/Shanghai Asia/Singapore Asia/Srednekolymsk Asia/Taipei Asia/Tashkent Asia/Tbilisi Asia/Tehran Asia/Tel_Aviv Asia/Thimbu Asia/Thimphu Asia/Tokyo Asia/Tomsk Asia/Ujung_Pandang Asia/Ulaanbaatar Asia/Ulan_Bator Asia/Urumqi Asia/Ust-Nera Asia/Vientiane Asia/Vladivostok Asia/Yakutsk Asia/Yangon Asia/Yekaterinburg Asia/Yerevan Atlantic/Azores Atlantic/Bermuda Atlantic/Canary Atlantic/Cape_Verde Atlantic/Faeroe Atlantic/Faroe Atlantic/Jan_Mayen Atlantic/Madeira Atlantic/Reykjavik Atlantic/South_Georgia Atlantic/St_Helena Atlantic/Stanley Australia/ACT Australia/Adelaide Australia/Brisbane Australia/Broken_Hill Australia/Canberra Australia/Currie Australia/Darwin Australia/Eucla Australia/Hobart Australia/LHI Australia/Lindeman Australia/Lord_Howe Australia/Melbourne Australia/NSW Australia/North Australia/Perth Australia/Queensland Australia/South Australia/Sydney Australia/Tasmania Australia/Victoria Australia/West Australia/Yancowinna Brazil/Acre Brazil/DeNoronha Brazil/East Brazil/West CET CST6CDT Canada/Atlantic Canada/Central Canada/Eastern Canada/Mountain Canada/Newfoundland Canada/Pacific Canada/Saskatchewan Canada/Yukon Chile/Continental Chile/EasterIsland Cuba EET EST5EDT Egypt Eire Europe/Amsterdam Europe/Andorra Europe/Astrakhan Europe/Athens Europe/Belfast Europe/Belgrade Europe/Berlin Europe/Bratislava Europe/Brussels Europe/Bucharest Europe/Budapest Europe/Busingen Europe/Chisinau Europe/Copenhagen Europe/Dublin Europe/Gibraltar Europe/Guernsey Europe/Helsinki Europe/Isle_of_Man Europe/Istanbul Europe/Jersey Europe/Kaliningrad Europe/Kiev Europe/Kirov Europe/Lisbon Europe/Ljubljana Europe/London Europe/Luxembourg Europe/Madrid Europe/Malta Europe/Mariehamn Europe/Minsk Europe/Monaco Europe/Moscow Europe/Nicosia Europe/Oslo Europe/Paris Europe/Podgorica Europe/Prague Europe/Riga Europe/Rome Europe/Samara Europe/San_Marino Europe/Sarajevo Europe/Simferopol Europe/Skopje Europe/Sofia Europe/Stockholm Europe/Tallinn Europe/Tirane Europe/Tiraspol Europe/Ulyanovsk Europe/Uzhgorod Europe/Vaduz Europe/Vatican Europe/Vienna Europe/Vilnius Europe/Volgograd Europe/Warsaw Europe/Zagreb Europe/Zaporozhye Europe/Zurich GB GB-Eire Hongkong Iceland Indian/Antananarivo Indian/Chagos Indian/Christmas Indian/Cocos Indian/Comoro Indian/Kerguelen Indian/Mahe Indian/Maldives Indian/Mauritius Indian/Mayotte Indian/Reunion Iran Israel Jamaica Japan Kwajalein Libya MET MST7MDT Mexico/BajaNorte Mexico/BajaSur Mexico/General NZ NZ-CHAT Navajo PRC PST8PDT Pacific/Apia Pacific/Auckland Pacific/Bougainville Pacific/Chatham Pacific/Chuuk Pacific/Easter Pacific/Efate Pacific/Enderbury Pacific/Fakaofo Pacific/Fiji Pacific/Funafuti Pacific/Galapagos Pacific/Gambier Pacific/Guadalcanal Pacific/Guam Pacific/Honolulu Pacific/Johnston Pacific/Kiritimati Pacific/Kosrae Pacific/Kwajalein Pacific/Majuro Pacific/Marquesas Pacific/Midway Pacific/Nauru Pacific/Niue Pacific/Norfolk Pacific/Noumea Pacific/Pago_Pago Pacific/Palau Pacific/Pitcairn Pacific/Pohnpei Pacific/Ponape Pacific/Port_Moresby Pacific/Rarotonga Pacific/Saipan Pacific/Samoa Pacific/Tahiti Pacific/Tarawa Pacific/Tongatapu Pacific/Truk Pacific/Wake Pacific/Wallis Pacific/Yap Poland Portugal ROK Singapore Turkey US/Alaska US/Aleutian US/Arizona US/Central US/East-Indiana US/Eastern US/Hawaii US/Indiana-Starke US/Michigan US/Mountain US/Pacific US/Pacific-New US/Samoa W-SU WET ``` # 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). # Consideraciones y limitaciones de las consultas SQL en Amazon Athena Al ejecutar consultas en Athena, tenga en cuenta las siguientes consideraciones y limitaciones: + **Procedimientos almacenados**: no se admiten los procedimientos almacenados. + **Número máximo de particiones**: el número máximo de particiones que se pueden crear con las instrucciones `CREATE TABLE AS SELECT` (CTAS) es 100. Para obtener más información, consulte [CREATE TABLE AS](create-table-as.md). Para obtener una solución alternativa, consulte [Uso de CTAS e INSERT INTO para evitar el límite de 100 particiones](ctas-insert-into.md). + **Instrucciones no compatibles**: entre las instrucciones no compatibles se incluyen las siguientes. Para ver una lista de las instrucciones DDL no compatibles en Athena, consulte [DDL no admitido](unsupported-ddl.md). + `CREATE TABLE LIKE` no se admite. + `DESCRIBE INPUT` y `DESCRIBE OUTPUT` no son compatibles. + La instrucción `MERGE` solo se admite para formatos de tablas transaccionales. Para obtener más información, consulte [MERGE INTO](merge-into-statement.md). + `UPDATE`No se admiten las instrucciones . + `DELETE FROM` no se admite. + **Conectores de Trino y Presto**: no se admiten los conectores de [Trino](https://trino.io/docs/current/connector.html) ni de [Presto](https://prestodb.io/docs/current/connector.html). Utilice la consulta federada de Amazon Athena para conectar orígenes de datos. Para obtener más información, consulte [Uso de consulta federada de Amazon Athena](federated-queries.md). + **Tiempos de espera en tablas con muchas particiones**: Athena puede agotar el tiempo de espera al consultar una tabla que tiene muchos miles de particiones. Esto puede ocurrir cuando la tabla tiene muchas particiones que no son de tipo `string`. Cuando utiliza el tipo `string`, Athena elimina las particiones en el nivel de metaalmacén. Sin embargo, cuando utiliza otros tipos de datos, Athena elimina las particiones en el lado del servidor. Cuantas más particiones tenga, más tardará este proceso y más probable será que se agote el tiempo de espera de las consultas. Para resolver este problema, establezca el tipo de partición en `string` de modo que Athena elimine las particiones en el nivel de metaalmacén. Esto reduce la sobrecarga y evita que se agote el tiempo de espera de las consultas. + Compatibilidad con **Amazon Glacier**: para obtener información sobre cómo consultar objetos restaurados de Amazon Glacier, consulte [Consulta de objetos de Amazon Glacier restaurados](querying-glacier.md). + **Archivos tratados como ocultos**: Athena trata los archivos de origen que comienzan con un guion bajo (`_`) o un punto (`.`) como ocultos. Para evitar esta limitación, cambie el nombre de los archivos. + **Limitación del tamaño de las filas o columnas**: el tamaño de una fila o de sus columnas no puede superar los 32 MB. Este límite se puede superar cuando, por ejemplo, una fila contiene una sola columna de 35 MB. Se trata de un límite estricto del servicio y no se puede modificar. + **Longitud máxima de línea en un archivo de texto**: el tamaño de una sola línea en un archivo de texto tiene un límite máximo de 200 MB. Si se supera este límite, se puede generar el mensaje de error TextLineLimitExceededException: Demasiados bytes antes de la nueva línea. Para evitar esta limitación, asegúrate de que no haya ni una sola línea en un archivo de texto que supere los 200 MB. + **Máximo de la cláusula LIMIT**: el número máximo de filas que se puede especificar para la cláusula `LIMIT` es 9.223.372.036.854.775.807 Cuando se utiliza `ORDER BY`, el número máximo de filas admitidas para la cláusula LIMIT es 2147483647. Si se excede este límite, se produce un mensaje de error NOT\$1SUPPORTED: ORDER BY LIMIT > 2 147 483 647 no es compatible. + **esquema\$1information**: hacer una consulta a `information_schema` es más eficaz si tiene una cantidad de pequeña a moderada demetadatos de AWS Glue. Si tiene una gran cantidad de metadatos, pueden producirse errores. Para obtener información sobre la consulta de la base de datos de`information_schema` para metadatos de AWS Glue, consulte el [Consulta de AWS Glue Data Catalog](querying-glue-catalog.md). + **Inicializaciones de matriz**: debido a una limitación en Java, no es posible inicializar una matriz en Athena que tenga más de 254 argumentos. + **Columnas de metadatos ocultas**: las columnas de metadatos ocultas de Hive o Iceberg `$bucket`, `$file_modified_time`, `$file_size` y `$partition` no son compatibles con las vistas. Para obtener información sobre el uso de la columna de metadatos `$path` en Athena, consulte [Obtención de las ubicaciones de archivos para los datos de origen en Simple Storage Service (Amazon S3)](select.md#select-path). Para obtener información sobre la longitud máxima de la cadena de consulta, las cuotas para los tiempos de espera de las consultas y las cuotas para el número activo de consultas DML, consulte [Service Quotas](service-limits.md).