# Consultas, funções e operadores em DML Em geral, o mecanismo de consulta DML do Athena é compatível com a sintaxe do Trino e do Presto e acrescenta suas próprias melhorias. O Athena não é compatível com todos os recursos do Trino ou Presto. Para obter mais informações, consulte os tópicos das instruções específicas nesta seção e [Considerações e limitações](other-notable-limitations.md). Para obter informações sobre as funções, consulte [Funções no Amazon Athena](functions.md). Para obter informações sobre as versões do mecanismo do Athena, consulte [Versionamento do mecanismo do Athena](engine-versions.md). Para obter mais informações sobre instruções DDL, consulte [Instruções DDL](ddl-reference.md). Para ver uma lista de instruções DDL não permitidas, consulte [DDL incompatível](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 e EXPLAIN ANALYZE](athena-explain-statement.md) + [PREPARE](sql-prepare.md) + [UNLOAD](unload.md) + [Funções](functions.md) + [Usar fusos horários compatíveis](athena-supported-time-zones.md) # SELECT Recupera linhas de dados de zero ou mais tabelas. **nota** Este tópico fornece informações resumidas para referência. Informações abrangentes sobre o uso de `SELECT` e a linguagem SQL estão além do escopo desta documentação. Para obter informações sobre como usar o SQL específico do Athena, consulte [Considerações e limitações das consultas SQL no Amazon Athena](other-notable-limitations.md) e [Executar consultas SQL no Amazon Athena](querying-athena-tables.md). Para ver um exemplo de como criar um banco de dados, criar uma tabela e executar uma consulta `SELECT` na tabela do Athena, consulte [Conceitos básicos](getting-started.md). ## Resumo ``` [ 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** Palavras reservadas em instruções SQL SELECT devem ficar entre aspas duplas. Para obter mais informações, consulte [Palavras-chave reservadas para escape e em instruções de SQL SELECT](reserved-words.md#list-of-reserved-words-sql-select). ## Parâmetros **[ WITH with\$1query [, ....] ]** Você pode usar `WITH` para nivelar consultas aninhadas ou para simplificar subconsultas. O uso da cláusula `WITH` para criar consultas recursivas é possível a partir da versão 3 do mecanismo Athena. A profundidade de recursão máxima é 10. A cláusula `WITH` precede a lista `SELECT` em uma consulta e define uma ou mais subconsultas a serem usadas dentro da consulta `SELECT`. Cada subconsulta define uma tabela temporária, semelhante a uma definição de exibição, que você pode referenciar na cláusula `FROM`. As tabelas são usadas apenas quando a consulta é executada. `with_query`A sintaxe é: ``` subquery_table_name [ ( column_name [, ...] ) ] AS (subquery) ``` Em que: + `subquery_table_name` é um nome exclusivo para uma tabela temporária que define os resultados da subconsulta de cláusula `WITH`. Cada `subquery` deve ter um nome de tabela que possa ser referenciado na cláusula `FROM`. + `column_name [, ...]` é uma lista opcional de nomes de coluna de saída. O número de nomes de coluna deve ser igual a ou menor que o número de colunas definido por `subquery`. + `subquery` é uma instrução da consulta qualquer. **[ ALL \$1 DISTINCT ] select\$1expression** `select_expression` determina as linhas a serem selecionadas. Uma `select_expression` pode usar um dos seguintes formatos: ``` expression [ [ AS ] column_alias ] [, ...] ``` ``` row_expression.* [ AS ( column_alias [, ...] ) ] ``` ``` relation.* ``` ``` * ``` + A sintaxe `expression [ [ AS ] column_alias ]` especifica uma coluna de saída. A sintaxe opcional `[AS] column_alias` especifica um nome de título personalizado a ser usado para a coluna na saída. + Para `row_expression.* [ AS ( column_alias [, ...] ) ]`, `row_expression` é uma expressão arbitrária do tipo de dados `ROW`. Os campos da linha definem as colunas de saída a serem incluídas no resultado. + Para `relation.*`, as colunas de `relation` são incluídas no resultado. Essa sintaxe não permite o uso de aliases de coluna. + O asterisco `*` especifica que todas as colunas sejam incluídas no conjunto de resultados. + No conjunto de resultados, a ordem das colunas é igual à ordem de sua especificação pela expressão de seleção. Se uma expressão de seleção retornar várias colunas, a ordem das colunas segue a ordem usada na relação de origem ou na expressão do tipo de linha. + Quando os aliases de coluna são especificados, os aliases substituem os nomes de campos de coluna ou linha pré-existentes. Se a expressão de seleção não tiver nomes de coluna, nomes de colunas anônimas com índice zero (`_col0`,`_col1` e `_col2, ...`) serão exibidos na saída. + `ALL` é o padrão. Usar `ALL` será tratado da mesma maneira como se tivesse sido omitido. Todas as linhas de todas as colunas são selecionadas, e as duplicações são mantidas. + Use `DISTINCT` para retornar somente valores distintos quando uma coluna contém valores duplicados. **FROM from\$1item [, ...]** Indica a entrada para a consulta, em que `from_item` pode ser uma exibição, um construto de união ou uma subconsulta conforme descrito abaixo. O `from_item` pode ser: + `table_name [ [ AS ] alias [ (column_alias [, ...]) ] ]` Em que `table_name` é o nome da tabela de destino da qual selecionar linhas, `alias` é o nome para indicar a saída da instrução `SELECT` e `column_alias` define as colunas para o `alias` especificado. **-OU-** + `join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]` Em que `join_type` é um dos: + `[ INNER ] JOIN` + `LEFT [ OUTER ] JOIN` + `RIGHT [ OUTER ] JOIN` + `FULL [ OUTER ] JOIN` + `CROSS JOIN` + `ON join_condition | USING (join_column [, ...])` Em que usar `join_condition` permite especificar nomes de coluna para chaves de união em várias tabelas e usar `join_column` exige que `join_column` exista em ambas as tabelas. **[ WHERE condição ]** Filtra os resultados de acordo com a `condition` que você especificar, em que `condition` costuma ter a sintaxe abaixo. ``` column_name operator value [[[AND | OR] column_name operator value] ...] ``` O *operador* pode ser um dos comparadores `=`, `>`, `<`, `>=`, `<=`, `<>`, `!=`. As expressões de subconsulta a seguir também podem ser usadas na cláusula `WHERE`. + `[NOT] BETWEEN integer_A AND integer_B`: especifica um intervalo entre dois inteiros, como no exemplo a seguir. Se o tipo de dados da coluna for `varchar`, a coluna deverá ser convertida para inteiro primeiro. ``` SELECT DISTINCT processid FROM "webdata"."impressions" WHERE cast(processid as int) BETWEEN 1500 and 1800 ORDER BY processid ``` + `[NOT] LIKE value`: pesquisa o padrão especificado. Use o sinal de porcentagem (`%`) como caractere curinga, conforme mostrado no exemplo a seguir. ``` SELECT * FROM "webdata"."impressions" WHERE referrer LIKE '%.org' ``` + `[NOT] IN (value[, value[, ...])`: especifica uma lista de valores possíveis para uma coluna, como no exemplo a seguir. ``` SELECT * FROM "webdata"."impressions" WHERE referrer IN ('example.com','example.net','example.org') ``` **[ GROUP BY [ ALL \$1 DISTINCT ] grouping\$1expressions [, ...] ]** Divide a saída da instrução `SELECT` em linhas com valores correspondentes. `ALL` e `DISTINCT` determinam se conjuntos de agrupamentos duplicados produzem linhas de saída distintas. Se omitido, `ALL` será pressuposto. `grouping_expressions` permite realizar operações de agrupamento complexas. Você pode usar operações de agrupamento complexas para realizar uma análise que exija agregação de vários conjuntos de colunas em uma única consulta. O elemento `grouping_expressions` pode ser qualquer função, como `SUM`, `AVG` ou `COUNT`, executada nas colunas de entrada. As expressões `GROUP BY` podem agrupar a saída por nomes de coluna de entrada não exibidos na saída da instrução `SELECT`. Todas as expressões de saída devem ser funções agregadas ou colunas presentes na cláusula `GROUP BY`. Você pode usar uma única consulta para realizar uma análise que exija a agregação de vários conjuntos de colunas. O Athena aceita agregações complexas que usam `GROUPING SETS`, `CUBE` e `ROLLUP`. `GROUP BY GROUPING SETS` especifica várias listas de colunas para agrupamento. `GROUP BY CUBE` gera todos os conjuntos de agrupamento possíveis para um determinado conjunto de colunas. `GROUP BY ROLLUP` gera todos os subtotais possíveis para um determinado conjunto de colunas. As operações de agrupamento complexas não permitem agrupamento de expressões compostas de colunas de entrada. Somente nomes de coluna são permitidos. Você normalmente pode usar `UNION ALL` para obter os mesmos resultados dessas operações `GROUP BY`, mas consultas que usam `GROUP BY` têm a vantagem de ler os dados uma vez, e `UNION ALL` lê os dados subjacentes três vezes e podem produzir resultados inconsistentes quando a fonte de dados está sujeita a alterações. **[ HAVING condition ]** Usada com funções de agregação e a cláusula `GROUP BY`. Controla quais grupos são selecionados, eliminando grupos que não atendam a `condition`. A filtragem ocorrerá depois de grupos, e as agregações serão calculadas. **[ \$1 UNION \$1 INTERSECT \$1 EXCEPT \$1 [ ALL \$1 DISTINCT ] union\$1query] ]** `UNION`, `INTERSECT` e `EXCEPT` combinam os resultados de mais de uma instrução `SELECT` em uma única consulta. `ALL` ou `DISTINCT` controla a exclusividade das linhas incluídas no conjunto final de resultados. `UNION` combina as linhas resultantes da primeira consulta com as linhas resultantes da segunda consulta. Para eliminar duplicatas, `UNION` cria uma tabela de hash, que consome memória. Para melhor performance, considere usar `UNION ALL` se a consulta não exigir eliminação de duplicatas. Várias cláusulas `UNION` são processadas da esquerda para a direita, a menos que você use parênteses para definir explicitamente a ordem de processamento. `INTERSECT` retorna apenas as linhas que estão presentes nos resultados da primeira e da segunda consultas. `EXCEPT` retorna as linhas dos resultados da primeira consulta, excluindo as linhas encontradas pela segunda consulta. `ALL` faz com que todas as linhas sejam incluídas, mesmo se elas forem idênticas. `DISTINCT` faz com que apenas as linhas exclusivas sejam incluídas no conjunto de resultados combinados. **[ ORDER BY expression [ ASC \$1 DESC ] [ NULLS FIRST \$1 NULLS LAST] [, ...] ]** Classifica um conjunto de resultados por um ou mais de saída `expression`. Quando a cláusula contém várias expressões, o conjunto de resultados é classificado de acordo com o primeiro `expression`. Em seguida, o segundo `expression` é aplicado a linhas que tenham valores correspondentes da primeira expressão, e assim por diante. Cada `expression` pode especificar colunas de saída de `SELECT` ou um número ordinal para uma coluna de saída por posição, a partir de um. `ORDER BY` é avaliada como a última etapa após qualquer cláusula `GROUP BY` ou `HAVING`. `ASC` e `DESC` determinam se os resultados são classificados em ordem crescente ou decrescente. A ordem de classificação padrão é a ordem decrescente (`ASC`). A ordem nula padrão é `NULLS LAST`, independentemente da ordem de classificação crescente ou decrescente. **[ Contagem de DESLOCAMENTO [ LINHA \$1 LINHAS ] ]** Use a cláusula `OFFSET` para descartar várias linhas iniciais do conjunto de resultados. Se a cláusula `ORDER BY` estiver presente, a cláusula `OFFSET` será avaliada em um conjunto de resultados classificados e o conjunto permanecerá classificado após as linhas ignoradas serem descartadas. Se a consulta não tiver cláusula `ORDER BY`, a definição de quais linhas serão descartadas é arbitrária. Se a contagem especificada por `OFFSET` for igual ou exceder o tamanho do conjunto de resultados, o resultado final será vazio. **LIMIT [ count \$1 ALL ]** Restringe o número de linhas no conjunto de resultados a `count`. `LIMIT ALL` é igual à omissão da cláusula `LIMIT`. Se a consulta não tiver a cláusula `ORDER BY`, os resultados serão arbitrários. **TABLESAMPLE [ BERNOULLI \$1 SYSTEM ] (porcentagem)** Operador operacional para selecionar linhas de uma tabela com base em um método de amostragem. `BERNOULLI` seleciona cada linha para estar no exemplo da tabela com uma probabilidade de `percentage`. Todos os blocos físicos da tabela são examinados, e determinadas linhas são ignoradas com base em uma comparação entre o `percentage` de exemplo e um valor aleatório calculado no runtime Com `SYSTEM`, a tabela é dividida em segmentos lógicos de dados, e a tabela mostra um exemplo dessa granularidade. Todas as linhas de um determinado segmento são selecionadas, ou o segmento é ignorado com base em uma comparação entre o `percentage` de exemplo e um valor aleatório calculado no runtime. A amostragem de `SYSTEM` depende do conector. Esse método não garante probabilidades de amostragem independentes. **[ UNNEST (array\$1or\$1map) [WITH ORDINALITY] ]** Expande uma matriz ou um mapa para uma relação. As matrizes são expandidas para uma única coluna. Os mapas são expandidos para duas colunas (*chave*, *valor*). Você pode usar `UNNEST` com vários argumentos, que são expandidos para várias colunas com o máximo de linhas do maior argumento de cardinalidade. Outras colunas são preenchidas com nulos. A cláusula `WITH ORDINALITY` adiciona uma coluna de ordinalidade ao final. `UNNEST` costuma ser usado com um `JOIN` e pode fazer referência a colunas de relações no lado esquerdo do `JOIN`. ## Obter os locais de arquivos dos dados de origem no Amazon S3 Para ver o local do arquivo do Amazon S3 referente aos dados em uma linha da tabela, você pode usar `"$path"` em uma consulta `SELECT`, como no seguinte exemplo: ``` SELECT "$path" FROM "my_database"."my_table" WHERE year=2019; ``` Essa consulta retorna um resultado semelhante a este: ``` s3://amzn-s3-demo-bucket/datasets_mytable/year=2019/data_file1.json ``` Para retornar uma lista classificada e exclusiva dos caminhos de nome de arquivo do S3 para os dados em uma tabela, você pode usar `SELECT DISTINCT` e `ORDER BY`, como no exemplo a seguir. ``` SELECT DISTINCT "$path" AS data_source_file FROM sampledb.elb_logs ORDER By data_source_file ASC ``` Para retornar somente os nomes de arquivo sem o caminho, você pode especificar `"$path"` como um parâmetro para a função `regexp_extract`, conforme mostrado no exemplo a seguir. ``` SELECT DISTINCT regexp_extract("$path", '[^/]+$') AS data_source_file FROM sampledb.elb_logs ORDER By data_source_file ASC ``` Para retornar os dados de um arquivo específico, especifique o arquivo na cláusula `WHERE`, como no exemplo a seguir. ``` SELECT *,"$path" FROM my_database.my_table WHERE "$path" = 's3://amzn-s3-demo-bucket/my_table/my_partition/file-01.csv' ``` Para obter mais informações e exemplos, consulte o artigo da Central de Conhecimento [Como posso ver o arquivo de origem do Amazon S3 para uma linha em uma tabela do Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/find-s3-source-file-athena-table-row/) **nota** No Athena, as colunas ocultas de metadados do Hive ou do Iceberg `$bucket`, `$file_modified_time`, `$file_size` e `$partition` não são compatíveis para visualizações. ## Caractere de escape para aspas simples Para inserir caracteres de escape em aspas simples, preceda-as com outras aspas simples, conforme o exemplo a seguir. Não confunda isso com aspas duplas. ``` Select 'O''Reilly' ``` **Resultados** `O'Reilly` ## Recursos adicionais Para obter mais informações sobre como usaras instruções `SELECT` no Athena, consulte os recursos abaixo. | Para obter informações sobre este tópico | consulte esta referência | | --- | --- | | Executar consultas no Athena | [Executar consultas SQL no Amazon Athena](querying-athena-tables.md) | | Usar SELECT para criar uma tabela | [Criar uma tabela com base em resultados de consultas (CTAS)](ctas.md) | | Inserir dados de uma consulta SELECT em outra tabela | [INSERT INTO](insert-into.md) | | Usar funções integradas nas instruções SELECT | [Funções no Amazon Athena](functions.md) | | Usar funções definidas pelo usuário nas instruções SELECT | [Consultar com funções definidas pelo usuário](querying-udf.md) | | Consultar metadados do catálogo de dados | [Consultar o AWS Glue Data Catalog](querying-glue-catalog.md) | # INSERT INTO Insere novas linhas em uma tabela de destino com base em uma instrução de consulta `SELECT` executada em uma tabela de origem ou com base em um conjunto de `VALUES` fornecidos como parte da instrução. Quando a tabela de origem é baseada em dados subjacentes em um formato, como CSV ou JSON, e a tabela de destino é baseada em outro formato, como Parquet ou ORC, você pode usar as consultas `INSERT INTO` para transformar os dados selecionados no formato da tabela de destino. ## Considerações e limitações Considere o seguinte ao usar as consultas `INSERT` com o Athena. + Ao executar uma consulta `INSERT` em uma tabela com dados subjacentes criptografados no Amazon S3, os arquivos de saída que a consulta `INSERT` grava não são criptografados por padrão. Recomendamos que você criptografe os resultados da consulta `INSERT` se estiver inserindo em tabelas com dados criptografados. Para obter mais informações sobre como criptografar resultados da consulta usando o console, consulte [Criptografar os resultados de consultas do Athena armazenados no Amazon S3](encrypting-query-results-stored-in-s3.md). Para habilitar a criptografia usando a AWS CLI ou a API do Athena, use as propriedades `EncryptionConfiguration` da ação [StartQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html) para especificar as opções de criptografia do Amazon S3 de acordo com os seus requisitos. + Para instruções `INSERT INTO`, a configuração do proprietário do bucket esperado não se aplica ao local da tabela de destino no Amazon S3. A configuração esperada do proprietário do bucket se aplica somente ao local de saída do Amazon S3 que você especificar para os resultados da consulta do Athena. Para obter mais informações, consulte [Especificar um local para resultados de consultas com uso do console do Athena](query-results-specify-location-console.md). + Para obter instruções `INSERT INTO` em conformidade com ACID, consulte a seção `INSERT INTO` em [Atualizar dados nas tabelas do Iceberg](querying-iceberg-updating-iceberg-table-data.md). ### Formatos compatíveis e SerDes É possível executar uma consulta `INSERT` em tabelas criadas de dados com os seguintes formatos e SerDes. | Formato de dados | 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 | | Arquivo de texto | org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe Há suporte a arquivos TSV e delimitados personalizados. | | CSV | org.apache.hadoop.hive.serde2.OpenCSVSerde Há suporte a operações de escrita somente em tipos string. No Athena, não é possível escrever em tabelas que contêm tipos não string no esquema do Glue. Para obter mais informações, consulte [CSV SerDe](csv-serde.md#csv-serde-opencsvserde-considerations-non-string). | ### Tabelas em bucket sem suporte `INSERT INTO` não é compatível com tabelas em bucket. Para obter mais informações, consulte [Usar particionamento e bucketing](ctas-partitioning-and-bucketing.md). ### Consultas federadas sem suporte `INSERT INTO` não é suportado para consultas federadas. Tentar fazer isso pode gerar a mensagem de erro: This operation is currently not supported for external catalogs (Atualmente, esta operação não é suportada para catálogos externos). Para obter informações sobre consultas federadas, consulte [Usar a consulta federada do Amazon Athena](federated-queries.md). ### Particionamento Considere os pontos desta seção ao usar o particionamento com as consultas `INSERT INTO` ou `CREATE TABLE AS SELECT`. #### Limites A instrução `INSERT INTO` comporta a gravação de no máximo 100 combinações de partições na tabela de destino. Se você executar a cláusula `SELECT` em uma tabela com mais de 100 partições, a consulta falhará a menos que a consulta `SELECT` seja limitada a 100 partições ou menos. Para obter informações sobre como contornar essa limitação, consulte [Usar CTAS e INSERT INTO para resolver o limite de 100 partições](ctas-insert-into.md). #### Ordem das colunas As instruções `INSERT INTO` ou `CREATE TABLE AS SELECT` esperam que a coluna particionada seja a última na lista de colunas projetadas em uma instrução `SELECT`. Se a tabela de origem não for particionada ou for particionada em colunas diferentes em comparação com a tabela de destino, as consultas como `INSERT INTO destination_table SELECT * FROM source_table` vão considerar os valores na última coluna da tabela de origem como os valores de uma coluna de partição na tabela de destino. Tenha isso em mente ao tentar criar uma tabela particionada com base em uma tabela não particionada. #### Recursos Para obter mais informações sobre como usar `INSERT INTO` com particionamento, consulte os recursos abaixo. + Para inserir dados particionados em uma tabela particionada, consulte [Usar CTAS e INSERT INTO para resolver o limite de 100 partições](ctas-insert-into.md). + Para inserir dados não particionados em uma tabela particionada, consulte [Usar CTAS e INSERT INTO para ETL e análise de dados](ctas-insert-into-etl.md). ### Arquivos gravados no Amazon S3 O Athena grava arquivos nos locais dos dados de origem no Amazon S3 como resultado do comando `INSERT`. Cada operação `INSERT` cria um novo arquivo, em vez de anexar a um arquivo existente. Os locais de arquivos dependem da estrutura da tabela e da consulta `SELECT`, se houver. O Athena gera um arquivo manifesto de dados para cada consulta `INSERT`. O manifesto rastreia os arquivos que a consulta gravou. Ele é salvo no local dos resultados das consultas do Athena no Amazon S3. Para obter mais informações, consulte [Identificar arquivos de saída de consultas](querying-finding-output-files.md#querying-identifying-output-files). ### Evitar atualizações altamente transacionais Quando você usa `INSERT INTO` para adicionar linhas a uma tabela no Amazon S3, o Athena não reescreve nem modifica arquivos existentes. Em vez disso, ele grava as linhas como um ou mais novos arquivos. Como tabelas com [muitos arquivos pequenos resultam em desempenho inferior de consultas](performance-tuning-data-optimization-techniques.md#performance-tuning-avoid-having-too-many-files), e operações de gravação e leitura, como `PutObject` e `GetObject`, resultam em custos mais altos no Amazon S3, considere as seguintes opções ao usar `INSERT INTO`: + Execute operações `INSERT INTO` com menor frequência em lotes maiores de linhas. + Para grandes volumes de ingestão de dados, considere usar um serviço como o [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html). + Evite completamente o uso de `INSERT INTO`. Em vez disso, acumule linhas em arquivos maiores e faça o upload deles diretamente para o Amazon S3, onde poderão ser consultados pelo Athena. ### Localizar arquivos órfãos Se uma instrução `INSERT INTO` ou `CTAS` falhar, os dados órfãos poderão ser deixados no local de dados e ser lidos em consultas subsequentes. Para localizar arquivos órfãos para inspeção ou exclusão, é possível usar o arquivo do manifesto de dados que o Athena oferece para rastrear a lista de arquivos a serem gravados. Para obter mais informações, consulte [Identificar arquivos de saída de consultas](querying-finding-output-files.md#querying-identifying-output-files) e [DataManifestLocation](https://docs.aws.amazon.com/athena/latest/APIReference/API_QueryExecutionStatistics.html#athena-Type-QueryExecutionStatistics-DataManifestLocation). ## INSERT INTO...SELECT Especifica a consulta a ser executada em uma tabela, `source_table`, que determina as linhas a serem inseridas em uma segunda tabela, `destination_table`. Se a consulta `SELECT` especificar colunas na `source_table`, as colunas deverão corresponder precisamente àquelas na `destination_table`. Para obter mais informações sobre consultas `SELECT`, consulte [SELECT](select.md). ### Resumo ``` INSERT INTO destination_table SELECT select_query FROM source_table_or_view ``` ### Exemplos Selecione todas as linhas na tabela `vancouver_pageviews` e insira-as na tabela `canada_pageviews`: ``` INSERT INTO canada_pageviews SELECT * FROM vancouver_pageviews; ``` Selecione apenas as linhas na tabela `vancouver_pageviews` em que a coluna `date` tenha um valor entre `2019-07-01` e `2019-07-31`, e insira-as em `canada_july_pageviews`: ``` INSERT INTO canada_july_pageviews SELECT * FROM vancouver_pageviews WHERE date BETWEEN date '2019-07-01' AND '2019-07-31'; ``` Selecione os valores nas colunas `city` e `state` na tabela `cities_world` somente dessas linhas com um valor `usa` na coluna `country` e insira-os nas colunas `city` e `state` na tabela `cities_usa`: ``` INSERT INTO cities_usa (city,state) SELECT city,state FROM cities_world WHERE country='usa' ``` ## INSERT INTO...VALUES Insere linhas em uma tabela existente especificando colunas e valores. As colunas especificadas e os tipos de dados associados devem corresponder precisamente às colunas e aos tipos de dados na tabela de destino. **Importante** Não recomendamos inserir linhas com `VALUES` porque o Athena gera arquivos para cada operação `INSERT`. Isso pode fazer com que muitos arquivos pequenos sejam criados e degradem a performance de consulta da tabela. Para identificar arquivos que uma consulta `INSERT` cria, examine o arquivo manifesto de dados. Para obter mais informações, consulte [Trabalhar com resultados de consultas e consultas recentes](querying.md). ### Resumo ``` INSERT INTO destination_table [(col1,col2,...)] VALUES (col1value,col2value,...)[, (col1value,col2value,...)][, ...] ``` ### Exemplos Nos exemplos a seguir, a tabela de cidades tem três colunas: `id`, `city`, `state`, `state_motto`. A coluna `id` é do tipo `INT`, e todas as outras colunas são do tipo `VARCHAR`. Insira uma única linha na tabela `cities`, com todos os valores da coluna especificados: ``` INSERT INTO cities VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice') ``` Insira duas linhas na tabela `cities`: ``` INSERT INTO cities VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice'), (3,'Boise','ID','Esto perpetua') ``` # VALUES Cria uma tabela em linha de literais. A tabela pode ser anônima ou você pode usar a cláusula `AS` para especificar um nome de tabela, nomes de colunas ou ambos. ## Resumo ``` VALUES row [, ...] ``` ## Parâmetros **linha** O parâmetro `row` pode ser uma única expressão ou `( column_expression [, ...] )`. ## Exemplos Retornar uma tabela com uma coluna e três linhas: ``` VALUES 1, 2, 3 ``` Retornar uma tabela com duas colunas e três linhas: ``` VALUES (1, 'a'), (2, 'b'), (3, 'c') ``` Retornar uma tabela com as colunas `id` e `name`: ``` SELECT * FROM ( VALUES (1, 'a'), (2, 'b'), (3, 'c') ) AS t (id, name) ``` Criar uma tabela denominada `customers` com as colunas `id` e `name`: ``` CREATE TABLE customers AS SELECT * FROM ( VALUES (1, 'a'), (2, 'b'), (3, 'c') ) AS t (id, name) ``` ## Consulte também [INSERT INTO...VALUES](insert-into.md#insert-into-values) # DELETE Exclui linhas em uma tabela do Apache Iceberg. `DELETE` é transacional e é compatível somente com tabelas do Apache Iceberg. ## Resumo Para excluir as linhas de uma tabela do Iceberg, use a sintaxe a seguir. ``` DELETE FROM [db_name.]table_name [WHERE predicate] ``` Para obter mais informações e exemplos, consulte a seção `DELETE` da [Atualizar dados nas tabelas do Iceberg](querying-iceberg-updating-iceberg-table-data.md). # UPDATE Atualiza linhas em uma tabela do Apache Iceberg. `UPDATE` é transacional e é compatível somente com tabelas do Apache Iceberg. A instrução funciona somente em linhas existentes e não pode ser usada para inserir ou acrescentar uma linha. ## Resumo Para atualizar as linhas em uma tabela do Iceberg, use a sintaxe a seguir. ``` UPDATE [db_name.]table_name SET xx=yy[,...] [WHERE predicate] ``` Para obter mais informações e exemplos, consulte a seção `UPDATE` da [Atualizar dados nas tabelas do Iceberg](querying-iceberg-updating-iceberg-table-data.md). # MERGE INTO Atualiza, exclui ou insere linhas de forma condicional em uma tabela do Apache Iceberg. Uma única instrução pode combinar ações de atualização, exclusão e inserção. **nota** `MERGE INTO` é transacional e é compatível somente com tabelas do Apache Iceberg na versão 3 do mecanismo do Athena. ## Resumo Para atualizar, excluir ou inserir linhas de forma condicional em uma tabela do Iceberg, use a sintaxe a seguir. ``` MERGE INTO target_table [ [ AS ] target_alias ] USING { source_table | query } [ [ AS ] source_alias ] ON search_condition when_clause [...] ``` A *when\$1clause* corresponde a uma das seguintes: ``` 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` é compatível com um número arbitrário de cláusulas `WHEN` com diferentes condições `MATCHED`. As cláusulas de condição executam as operações `DELETE`, `UPDATE` ou `INSERT` na primeira cláusula `WHEN` selecionada pelo estado `MATCHED` e pela condição de correspondência. Para cada linha de origem, as cláusulas `WHEN` são processadas por ordem. Somente a primeira cláusula `WHEN` correspondente é executada. As cláusulas subsequentes são ignoradas. Um erro de usuário é gerado quando uma única linha da tabela de destino corresponde a mais de uma linha de origem. Se uma linha de origem não corresponder a nenhuma cláusula `WHEN` e não houver uma cláusula `WHEN NOT MATCHED`, a linha de origem será ignorada. Nas cláusulas `WHEN` que têm operações `UPDATE`, as expressões de valor da coluna podem se referir a qualquer campo de destino ou de origem. No caso de `NOT MATCHED`, as expressões `INSERT` podem se referir a qualquer campo de origem. **Exemplo** O exemplo a seguir mescla linhas da segunda tabela com a primeira tabela, se as linhas não existirem na primeira tabela. As colunas listadas na cláusula `VALUES` devem ser prefixadas pelo alias da tabela de origem. As colunas de destino listadas na cláusula `INSERT` *não* devem ter esse prefixo. ``` 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 obter mais exemplos de `MERGE INTO`, consulte [Atualizar dados nas tabelas do Iceberg](querying-iceberg-updating-iceberg-table-data.md). # OPTIMIZE Otimize as linhas em uma tabela do Apache Iceberg ao gravar novamente arquivos de dados em um layout mais otimizado com base em no tamanho e no número de arquivos excluídos associados. **nota** `OPTIMIZE` é transacional e é compatível somente para tabelas do Apache Iceberg. ## Sintaxe O resumo da sintaxe a seguir mostra como otimizar o layout de dados para uma tabela Iceberg. ``` OPTIMIZE [db_name.]table_name REWRITE DATA USING BIN_PACK [WHERE predicate] ``` **nota** Somente colunas de partição são permitidas no *predicado* da cláusula `WHERE`. Especificar uma coluna sem partição fará com que a consulta falhe. A ação de compactação é cobrada pela quantidade de dados verificados durante o processo de regravação. A ação `REWRITE DATA` usa predicados para selecionar arquivos que contenham linhas iguais. Se alguma linha no arquivo corresponder ao predicado, o arquivo será selecionado para otimização. Assim, para controlar o número de arquivos afetados pela operação de compactação, você pode especificar uma cláusula `WHERE`. ## Configurar propriedades de compactação Para controlar o tamanho dos arquivos a serem selecionados para compactação e o tamanho do arquivo resultante após a compactação, você pode usar parâmetros de propriedade de tabela. Você pode usar o comando [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md) para configurar as [propriedades de tabela](querying-iceberg-creating-tables.md#querying-iceberg-table-properties) a seguir. ## Recursos adicionais [Otimizar tabelas do Iceberg](querying-iceberg-data-optimization.md) # VACUUM A instrução `VACUUM` realiza a manutenção da tabela para as tabelas do Apache Iceberg ao realizar a [expiração de snapshots](https://iceberg.apache.org/docs/latest/spark-procedures/#expire_snapshots) e a [remoção do arquivo órfão](https://iceberg.apache.org/docs/latest/spark-procedures/#remove_orphan_files). **nota** `VACUUM` é transacional e é compatível somente com tabelas do Apache Iceberg na versão 3 do mecanismo do Athena. A instrução `VACUUM` otimiza as tabelas do Iceberg ao reduzir o consumo de armazenamento. Para obter mais informações sobre o uso de `VACUUM`, consulte [Otimizar tabelas do Iceberg](querying-iceberg-data-optimization.md). Como a instrução `VACUUM` faz chamadas de API para o Amazon S3, as cobranças se aplicam às solicitações associadas ao Amazon S3. **Atenção** Se você executar uma operação de expiração de snapshot, não poderá mais fazer viagens no tempo para snapshots expirados. ## Resumo Para remover os arquivos de dados que não são mais necessários para uma tabela do Iceberg, use a sintaxe a seguir. ``` VACUUM [database_name.]target_table ``` + O `VACUUM` espera que os dados do Iceberg estejam em uma pasta do Amazon S3 em vez de em um bucket do Amazon S3. Por exemplo, se seus dados do Iceberg estiverem em `s3://amzn-s3-demo-bucket`/ em vez de `s3://amzn-s3-demo-bucket/myicebergfolder/`, a instrução `VACUUM` falhará com a mensagem de erro GENERIC\$1INTERNAL\$1ERROR: Path missing in file system location: `s3://amzn-s3-demo-bucket`. + Para que o `VACUUM` possa excluir arquivos de dados, sua função de execução de consulta deve ter as permissões `s3:DeleteObject` no bucket em que suas tabelas, metadados, snapshots e arquivos de dados do Iceberg estão localizados. Se a permissão não estiver presente, a consulta de `VACUUM` será bem-sucedida, mas os arquivos não serão excluídos. + Para executar `VACUUM` em uma tabela com um nome que comece com um sublinhado (por exemplo, `_mytable`), coloque o nome da tabela entre acentos maiúsculos, como no exemplo a seguir. Se você prefixar o nome da tabela com um nome de banco de dados, não coloque o nome do banco de dados entre aspas. Observe que aspas duplas não funcionarão no lugar dos acentos. Esse comportamento é específico do `VACUUM`. As instruções `CREATE` e `INSERT INTO` não exigem acentos graves para nomes de tabelas que começam com sublinhados. ``` VACUUM `_mytable` VACUUM my_database.`_mytable` ``` ## Operações realizadas `VACUUM` realiza as seguintes operações: + Remove os snapshots que são mais antigos do que o tempo especificado pela propriedade de tabela `vacuum_max_snapshot_age_seconds`. Por padrão, essa propriedade é definida para 432 mil segundos (cinco dias). + Remove os snapshots que não estão dentro do período de retenção e que excedem o número especificado pela propriedade de tabela `vacuum_min_snapshots_to_keep`. O padrão é um. É possível especificar essas propriedades de tabela em sua instrução `CREATE TABLE`. Após a criação da tabela, é possível usar a instrução [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md) para atualizá-la. + Remove todos os metadados e os arquivos de dados inacessíveis como resultado da remoção do snapshot. Você pode configurar o número de arquivos de metadados antigos a serem retidos definindo a propriedade da tabela `vacuum_max_metadata_files_to_keep`. O valor padrão é 100. + Remove arquivos órfãos que são mais antigos do que o tempo especificado na propriedade de tabela `vacuum_max_snapshot_age_seconds`. Arquivos órfãos corresponde a arquivos no diretório de dados da tabela que não fazem parte do estado da tabela. Para obter mais informações sobre como criar e gerenciar tabelas do Apache Iceberg no Athena, consulte [Criar tabelas do Iceberg](querying-iceberg-creating-tables.md) e [Gerenciar tabelas do Iceberg](querying-iceberg-managing-tables.md). # Usar EXPLAIN e EXPLAIN ANALYZE no Athena A instrução `EXPLAIN` mostra o plano de execução lógico ou distribuído de uma instrução SQL especificada ou valida a instrução SQL. Você pode gerar os resultados no formato de texto ou em um formato de dados para renderização em gráfico. **nota** É possível visualizar representações gráficas de planos lógicos e distribuídos para suas consultas no console do Athena sem usar a sintaxe `EXPLAIN`. Para obter mais informações, consulte [Visualização de planos de execução para consultas SQL](query-plans.md). O `EXPLAIN ANALYZE` mostra o plano de execução distribuído de uma instrução SQL especificada e o custo computacional de cada operação em uma consulta SQL. Você pode gerar os resultados no formato de texto ou JSON. ## Considerações e limitações As instruções `EXPLAIN` e `EXPLAIN ANALYZE` no Athena têm as limitações a seguir. + Como as consultas `EXPLAIN` não verificam os dados, o Athena não cobra por elas. Entretanto, como as consultas `EXPLAIN` fazem chamadas ao AWS Glue para recuperar metadados de tabela, poderá haver cobranças do Glue se as chamadas ultrapassarem o [limite do nível gratuito do 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 consultas `EXPLAIN ANALYZE` são executadas, elas verificam os dados, e o Athena cobra pela quantidade de dados verificados. + As informações de filtragem de linha ou de célula definidas no Lake Formation e as informações de estatísticas de consulta não são mostradas na saída de `EXPLAIN` e de `EXPLAIN ANALYZE`. ## Sintaxe de EXPLAIN ``` EXPLAIN [ ( option [, ...]) ] statement ``` *opção* pode ser uma das seguintes: ``` FORMAT { TEXT | GRAPHVIZ | JSON } TYPE { LOGICAL | DISTRIBUTED | VALIDATE | IO } ``` Se a opção `FORMAT` não for especificada, o padrão de saída será o formato `TEXT`. O tipo`IO` fornece informações sobre as tabelas e os esquemas lidos pela consulta. ## Sintaxe de EXPLAIN ANALYZE Além da saída incluída em `EXPLAIN`, a saída de `EXPLAIN ANALYZE` também inclui estatísticas de runtime para a consulta especificada, como o uso da CPU, o número de linhas da entrada e o número de linhas da saída. ``` EXPLAIN ANALYZE [ ( option [, ...]) ] statement ``` *opção* pode ser uma das seguintes: ``` FORMAT { TEXT | JSON } ``` Se a opção `FORMAT` não for especificada, o padrão de saída será o formato `TEXT`. Porque todas as consultas para `EXPLAIN ANALYZE` são `DISTRIBUTED`, a opção `TYPE` não está disponível para `EXPLAIN ANALYZE`. A *instrução* pode ser uma das seguintes: ``` SELECT CREATE TABLE AS SELECT INSERT UNLOAD ``` ## Exemplos de EXPLAIN Os exemplos a seguir representam a progressão de `EXPLAIN`, do mais simples ao mais complexo. ### Exemplo 1: uso da a instrução EXPLAIN para mostrar um plano de consulta no formato de texto No exemplo a seguir, `EXPLAIN` mostra o plano de execução de uma consulta `SELECT` nos logs do Elastic Load Balancing. O formato é o padrão para saída 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 ``` ### Exemplo 2: uso de EXPLAIN para representar um plano de consulta graficamente É possível utilizar o console do Athena para representar um plano de consulta graficamente para você. Insira uma instrução `SELECT` como a seguinte no editor de consultas do Athena e escolha **EXPLAIN**. ``` 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 ``` A página **Explain** (Explicar) do editor de consultas do Athena é aberta e mostra um plano distribuído e um plano lógico para a consulta. O gráfico a seguir mostra o plano lógico do exemplo. ![\[Gráfico do plano de consulta renderizado pelo editor de consulta do Athena.\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/images/athena-explain-statement-tpch.png) **Importante** Alguns filtros de partição podem não estar visíveis no gráfico de árvore do operador aninhado, mesmo que o Athena os aplique à sua consulta. Para verificar o efeito desses filtros, execute `EXPLAIN` ou `EXPLAIN ANALYZE` na sua consulta e visualize os resultados. Para obter mais informações sobre como usar os recursos de gráfico do plano de consulta no console do Athena, consulte [Visualização de planos de execução para consultas SQL](query-plans.md). ### Exemplo 3: uso da instrução EXPLAIN para verificar redução da partição Quando você usa um predicado de filtragem em uma chave particionada para consultar uma tabela particionada, o mecanismo de consulta aplica o predicado à chave particionada para reduzir a quantidade de dados lidos. O exemplo a seguir usa uma consulta `EXPLAIN` para verificar a remoção da partição de uma consulta `SELECT` em uma tabela particionada. Primeiro, a instrução `CREATE TABLE` cria a tabela `tpch100.orders_partitioned`. A tabela é particionada na coluna `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//' ``` A tabela `tpch100.orders_partitioned` tem várias partições em `o_orderdate`, como mostrado pelo 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 ``` A consulta `EXPLAIN` a seguir verifica a remoção da partição com base na instrução `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 ``` O texto em negrito no resultado mostra que o predicado `o_orderdate = '1995'` foi aplicado a `PARTITION_KEY`. ### Exemplo 4: uso de uma consulta EXPLAIN para verificar ordem e tipo de junção A consulta `EXPLAIN` a seguir verifica o tipo e a ordem de junção da instrução `SELECT`. Use uma consulta como esta para examinar o uso da memória de consulta para que você possa reduzir as chances de receber um erro `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 ``` A consulta de exemplo foi otimizada em uma junção cruzada para uma performance melhor. Os resultados mostram que `tpch100.orders` será distribuído como o tipo de distribuição `BROADCAST`. Isso indica que a tabela `tpch100.orders` será distribuída para todos os nós que executam a operação de junção. O tipo de distribuição `BROADCAST` exige que todos os resultados filtrados da tabela `tpch100.orders` estejam dentro da capacidade de memória de cada nó que executa a operação de junção. No entanto, a tabela `tpch100.customer` é menor que `tpch100.orders`. Como `tpch100.customer` requer menos memória, você pode reescrever a consulta como `BROADCAST tpch100.customer` em vez de `tpch100.orders`. Desse modo, a consulta tem menos chance de receber o erro `EXCEEDED_LOCAL_MEMORY_LIMIT`. Essa estratégia considera os seguintes pontos: + `tpch100.customer.c_custkey` é exclusivo na tabela `tpch100.customer`. + Existe um relacionamento de mapeamento um para muitos entre `tpch100.customer` e `tpch100.orders`. O exemplo a seguir mostra a 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 ``` ### Exemplo 5: uso de uma consulta EXPLAIN para remover predicados sem efeito Você pode usar uma consulta `EXPLAIN` para verificar a eficácia dos predicados de filtragem. Você pode usar os resultados para remover os predicados que não têm efeito, como no exemplo a seguir. ``` 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 ``` O `filterPredicate` nos resultados mostra que o otimizador mesclou os três predicados originais em dois predicados e alterou a ordem de aplicação deles. ``` filterPredicate = (("c_custkey" = 1500) AND ("c_custkey" = CAST(("random"() * 1E3) AS int))) ``` Como os resultados mostram que o predicado `AND c.c_custkey BETWEEN 1000 AND 2000` não tem efeito, você pode removê-lo sem alterar os resultados da consulta. Para obter informações sobre os termos usados nos resultados das consultas `EXPLAIN`, veja [Noções básicas dos resultados da instrução EXPLAIN do Athena](athena-explain-statement-understanding.md). ## Exemplos de EXPLAIN ANALYZE Os exemplos a seguir mostram exemplos de consultas e saídas de `EXPLAIN ANALYZE`. ### Exemplo 1: uso de EXPLAIN ANALYZE para mostrar um plano de consulta e o custo computacional em formato de texto No exemplo a seguir, `EXPLAIN ANALYZE` mostra o plano de execução e os custos computacionais de uma consulta `SELECT` em logs do CloudFront. O formato é o padrão para saída 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 ``` ### Exemplo 2: uso de EXPLAIN ANALYZE para mostrar um plano de consulta em formato JSON O exemplo a seguir mostra o plano de execução e os custos computacionais de uma consulta `SELECT` em logs do CloudFront. O exemplo especifica JSON como formato de saída. ``` 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 adicionais Para obter mais informações, consulte os recursos a seguir. + [Noções básicas dos resultados da instrução EXPLAIN do Athena](athena-explain-statement-understanding.md) + [Visualização de planos de execução para consultas SQL](query-plans.md) + [Visualizar estatísticas e detalhes de execução para consultas concluídas](query-stats.md) + Documentação Trino [https://trino.io/docs/current/sql/explain.html](https://trino.io/docs/current/sql/explain.html) + Documentação Trino [https://trino.io/docs/current/sql/explain-analyze.html](https://trino.io/docs/current/sql/explain-analyze.html) + [Otimize o desempenho de consultas federadas usando EXPLAIN e EXPLAIN ANALYZE no Amazon Athena](https://aws.amazon.com/blogs/big-data/optimize-federated-query-performance-using-explain-and-explain-analyze-in-amazon-athena/) no *Blog de Big Data da 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) # Noções básicas dos resultados da instrução EXPLAIN do Athena Esse tópico apresenta uma rápida orientação sobre os termos operacionais usados nos resultados da instrução `EXPLAIN` do Athena. ## Tipos de saída da instrução EXPLAIN `EXPLAIN`As saídas da instrução podem ser de um destes dois tipos: + **Plano lógico**: mostra o plano lógico que o mecanismo SQL usa para executar uma instrução. A sintaxe para essa opção é `EXPLAIN` ou `EXPLAIN (TYPE LOGICAL)`. + **Plano distribuído**: mostra um plano de execução em um ambiente distribuído. A saída mostra fragmentos, que são os estágios de processamento. Cada fragmento do plano é processado por um ou mais nós. Os dados podem ser trocados entre os nós que processam os fragmentos. A sintaxe para essa opção é `EXPLAIN (TYPE DISTRIBUTED)`. Na saída de um plano de distribuição, os fragmentos (estágios de processamento) são indicados por `Fragment` *número* [*fragment\$1type*], em que *número* é um número inteiro com base zero e *fragment\$1type* especifica como o fragmento é executado pelos nós. Os tipos de fragmento, que mostram insights do layout da troca de dados, estão descritos na tabela a seguir. **Tipos de fragmento do plano distribuído** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/athena-explain-statement-understanding.html) ## Exchange Os termos relacionados à troca descrevem como os dados são trocados entre os nós de processamento. As transferências podem ser locais ou remotas. **LocalExchange [*exchange\$1type*] ** Transfere os dados localmente nos nós de processamento para estágios diferentes de uma consulta. O valor de *exchange\$1type* pode ser um dos tipos de troca lógicos ou distribuídos, conforme descrito mais adiante nesta seção. **RemoteExchange [*exchange\$1type*] ** Transfere os dados entre os nós de processamento para estágios diferentes de uma consulta. O valor de *exchange\$1type* pode ser um dos tipos de troca lógicos ou distribuídos, conforme descrito mais adiante nesta seção. ### Tipos de troca lógicos Os tipos de troca a seguir descrevem as ações executadas durante a fase de troca de um plano lógico. + **`GATHER`** – um único nó de processamento combina a saída de todos os outros nós de processamento. Por exemplo, o último estágio de uma consulta selecionada coleta os resultados de todos os nós e grava esses resultados no Amazon S3. + **`REPARTITION`** – envia os dados da linha para um operador específico com base no esquema de particionamento que deverá ser aplicado ao próximo operador. + **`REPLICATE`** – copia os dados da linha para todos os operadores. ### Tipos de troca distribuídos Os tipos de troca a seguir indicam o layout dos dados quando eles são trocados entre os nós em um plano distribuído. + **`HASH`** – a troca distribui os dados para vários destinos usando uma função hash. + **`SINGLE`** – a troca distribui os dados para um único destino. ## Verificação Os termos a seguir descrevem como os dados são verificados durante uma consulta. **TableScan ** Verifica os dados de origem de uma tabela do Amazon S3 ou de um conector do Apache Hive e aplica a remoção de partição gerada do predicado de filtro. **ScanFilter ** Verifica os dados de origem de uma tabela do Amazon S3 ou de um conector do Hive e aplica a remoção de partição gerada do predicado de filtro e dos outros predicados de filtro não aplicados por meio da remoção de partição. **ScanFilterProject ** Primeiramente, verifica os dados de origem de uma tabela do Amazon S3 ou de um conector do Hive e aplica a remoção de partição gerada do predicado de filtro e dos outros predicados de filtro não aplicados por meio da remoção de partição. Na sequência, modifica o layout da memória dos dados de saída para uma nova projeção a fim de melhorar a performance dos estágios posteriores. ## Ingressar Faz a junção dos dados entre duas tabelas. É possível categorizar as junções por tipo de junção e por tipo de distribuição. ### Tipos de junção Os tipos de junção definem como é feita a operação de junção. **CrossJoin**: gera o produto cartesiano de duas tabelas unidas. **InnerJoin**: seleciona os registros que têm valores correspondentes nas duas tabelas. **LeftJoin**: seleciona todos os registros da tabela esquerda e os registros correspondentes da tabela direita. Se não houver nenhuma correspondência, o resultado no lado direito será NULL. **RightJoin**: seleciona todos os registros da tabela direita e os registros correspondentes da tabela esquerda. Se não houver nenhuma correspondência, o resultado no lado direito será NULL. **FullJoin**: seleciona todos os registros em que há correspondência com os registros da tabela esquerda ou direita. A tabela unida contém todos os registros das duas tabelas e preenche as correspondências ausentes com NULL em um dos lados. **nota** Por motivos de performance, o mecanismo de consulta pode reescrever uma consulta de junção com um tipo de junção diferente para retornar os mesmos resultados. Por exemplo, uma consulta de junção interna com predicado em uma tabela pode ser reescrita como `CrossJoin`. Isso leva o predicado à fase de verificação da tabela para que menos dados sejam verificados. ### Tipos de distribuição de junção Os tipos de distribuição definem como os dados são trocados entre os nós de processamento quando a operação de junção é executada. **Particionada**: as tabelas tanto esquerda quanto direita são particionadas por hash em todos os nós de processamento. A distribuição particionada consome menos memória em cada nó. A distribuição particionada pode ser muito mais lenta do que as junções replicadas. As junções particionadas são ideais para unir duas tabelas grandes. **Replicada**: uma tabela é particionada por hash em todos os nós de processamento, e a outra tabela é replicada para todos os nós de processamento para executar a operação de junção. A distribuição replicada pode ser muito mais rápida do que as junções particionadas, mas consome mais memória em cada nó de processamento. Se a tabela replicada for muito grande, o nó de processamento poderá receber um erro de memória insuficiente. As junções replicadas são ideais quando uma das tabelas unidas é pequena. # PREPARE Cria uma instrução SQL com o nome `statement_name` para execução posterior. A instrução pode incluir parâmetros representados por pontos de interrogação. Para fornecer valores para os parâmetros e executar a instrução preparada, utilize [EXECUTE](sql-execute.md). ## Resumo ``` PREPARE statement_name FROM statement ``` A tabela a seguir descreve os parâmetros. **** | Parâmetro | Descrição | | --- | --- | | statement\$1name | O nome da instrução que será preparada. O nome deve ser exclusivo no grupo de trabalho. | | statement | Uma consulta SELECT, CTAS ou INSERT INTO. | **nota** O número máximo de instruções preparadas em um grupo de trabalho é mil. ## Exemplos O seguinte exemplo prepara uma consulta selecionada sem parâmetros. ``` PREPARE my_select1 FROM SELECT * FROM nation ``` O seguinte exemplo prepara uma consulta selecionada que inclui parâmetros. Os valores para `productid` e `quantity` serão fornecido pela cláusula `USING` de uma instrução `EXECUTE`: ``` PREPARE my_select2 FROM SELECT order FROM orders WHERE productid = ? and quantity < ? ``` O seguinte exemplo prepara uma consulta de inserção. ``` PREPARE my_insert FROM INSERT INTO cities_usa (city, state) SELECT city, state FROM cities_world WHERE country = ? ``` ## Recursos adicionais [Usar instruções preparadas](querying-with-prepared-statements-querying.md) [EXECUTE](sql-execute.md) [DEALLOCATE PREPARE](sql-deallocate-prepare.md) [INSERT INTO](insert-into.md) # EXECUTE Executa uma instrução preparada com o nome `statement_name`. Os valores dos parâmetros para os pontos de interrogação na declaração preparada estão definidos na cláusula `USING` em uma lista separada por vírgulas. Para criar uma instrução preparada, utilize [PREPARE](sql-prepare.md). ## Resumo ``` EXECUTE statement_name [ USING parameter1[, parameter2, ... ] ] ``` ## Exemplos O seguinte exemplo prepara e executa uma consulta sem parâmetros. ``` PREPARE my_select1 FROM SELECT name FROM nation EXECUTE my_select1 ``` O seguinte exemplo prepara e executa uma consulta com um único parâmetro. ``` PREPARE my_select2 FROM SELECT * FROM "my_database"."my_table" WHERE year = ? EXECUTE my_select2 USING 2012 ``` Isso é equivalente a: ``` SELECT * FROM "my_database"."my_table" WHERE year = 2012 ``` O seguinte exemplo prepara e executa uma consulta com dois parâmetros. ``` PREPARE my_select3 FROM SELECT order FROM orders WHERE productid = ? and quantity < ? EXECUTE my_select3 USING 346078, 12 ``` ## Recursos adicionais [Usar instruções preparadas](querying-with-prepared-statements-querying.md) [PREPARE](sql-prepare.md) [INSERT INTO](insert-into.md) # DEALLOCATE PREPARE Remove a instrução preparada com o nome especificado do conjunto de instruções preparadas no grupo de trabalho atual. ## Resumo ``` DEALLOCATE PREPARE statement_name ``` ## Exemplos O exemplo a seguir remove a instrução preparada `my_select1` do grupo de trabalho atual. ``` DEALLOCATE PREPARE my_select1 ``` ## Recursos adicionais [Usar instruções preparadas](querying-with-prepared-statements-querying.md) [PREPARE](sql-prepare.md) # UNLOAD Grava os resultados da consulta de uma instrução `SELECT` no formato de dados especificado. Os formatos permitidos para `UNLOAD` são Apache Parquet, ORC, Apache Avro e JSON. CSV é o único formato de saída compatível com o comando `SELECT` do Athena, mas você pode usar o comando `UNLOAD`, que é compatível com vários formatos de saída, para delimitar sua consulta `SELECT` e reescrever sua saída em um dos formatos compatíveis com `UNLOAD`. Você pode usar a instrução `CREATE TABLE AS` (CTAS) para gerar dados em formatos não CSV, e as instruções CTAS exigem a criação de uma tabela no Athena. A instrução `UNLOAD` é útil quando você quer gerar os resultados de uma consulta `SELECT` em um formato não CSV, mas não quer a tabela associada. Por exemplo, uma aplicação downstream pode exigir que os resultados de uma consulta `SELECT` estejam no formato JSON, e o Parquet ou o ORC pode ter uma performance melhor do que o CSV se você pretende usar os resultados da consulta `SELECT` para realizar outras análises. ## Considerações e limitações Quando você usar a instrução `UNLOAD` no Athena, lembre-se dos seguintes pontos: + **Sem ordenação global de arquivos**: os resultados de `UNLOAD` são gravados em vários arquivos em paralelo. Se a consulta `SELECT` na instrução `UNLOAD` especificar uma ordem de classificação, o conteúdo de cada arquivo estará na ordem classificada, mas os arquivos não serão classificados entre eles. + **Dados órfãos não excluídos**: em caso de falha, o Athena não tenta excluir os dados órfãos. Esse comportamento é o mesmo nas instruções CTAS e `INSERT INTO`. + **Partições máximas**: o número máximo de partições que podem ser usadas com `UNLOAD` é 100. + **Arquivos manifesto e de metadados**: o Athena gera um arquivo de metadados e um arquivo manifesto de dados para cada consulta `UNLOAD`. O manifesto rastreia os arquivos que a consulta gravou. Os dois arquivos são salvos no local dos resultados das consultas do Athena no Amazon S3. Para obter mais informações, consulte [Identificar arquivos de saída de consultas](querying-finding-output-files.md#querying-identifying-output-files). + **Criptografia**: os arquivos de saída de `UNLOAD` são criptografados de acordo com a configuração de criptografia usada no Amazon S3. Para definir a configuração para criptografar o resultado de `UNLOAD`, você pode usar a [API EncryptionConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EncryptionConfiguration.html). + **Instruções preparadas**: `UNLOAD` pode ser usado com instruções preparadas. Para obter informações sobre instruções preparadas no Athena, consulte [Usar consultas parametrizadas](querying-with-prepared-statements.md). + **Cotas de serviço**: o `UNLOAD` usa cotas de consultas em DML. Para obter informações sobre cotas, consulte [Service Quotas](service-limits.md). + **Proprietário do bucket esperado**: a configuração esperada do proprietário do bucket não se aplica ao local de destino do Amazon S3 especificado na consulta `UNLOAD`. A configuração esperada do proprietário do bucket se aplica somente ao local de saída do Amazon S3 que você especificar para os resultados da consulta do Athena. Para obter mais informações, consulte [Especificar um local para resultados de consultas com uso do console do Athena](query-results-specify-location-console.md). ## Sintaxe A instrução `UNLOAD` usa a sintaxe a seguir. ``` UNLOAD (SELECT col_name[, ...] FROM old_table) TO 's3://amzn-s3-demo-bucket/my_folder/' WITH ( property_name = 'expression' [, ...] ) ``` Exceto ao gravar nas partições, o destino `TO` deve especificar um local no Amazon S3 que não tenha dados. Antes de gravar no local especificado, a consulta `UNLOAD` verifica se o local do bucket está vazio. Como `UNLOAD` não grava dados no local especificado se ele já tiver dados, `UNLOAD` não substitui os dados existentes. Para reutilizar um local de bucket como destino para `UNLOAD`, exclua os dados do local do bucket e execute a consulta novamente. Observe que, quando `UNLOAD` grava em partições, esse comportamento é diferente. Se você executar a mesma consulta `UNLOAD` várias vezes com a mesma instrução `SELECT`, o mesmo local `TO` e as mesmas partições, cada consulta `UNLOAD` descarrega os dados no Amazon S3 no local e nas partições especificadas. ### Parâmetros Veja abaixo os valores possíveis para *property\$1name*. ** format = '*file\$1format*' ** Obrigatório. Especifica o formato de arquivo da saída. Os valores possíveis para *file\$1format* são `ORC`, `PARQUET`, `AVRO`, `JSON` ou`TEXTFILE`. ** compression = '*compression\$1format*' ** Opcional. Essa opção é específica aos formatos ORC e Parquet. Para ORC, o padrão é `zlib`, e para Parquet, o padrão é `gzip`. Para obter informações sobre formatos de compactação compatíveis, consulte [Suporte a compactação no Athena](https://docs.aws.amazon.com/athena/latest/ug/compression-formats.html). Essa opção não se aplica ao formato `AVRO`. O Athena usa `gzip` para os formatos `JSON` e `TEXTFILE`. **compression\$1level = *compression\$1level* ** Opcional. O nível de compactação a ser usado para compactação ZSTD. Essa propriedade se aplica apenas à compactação ZSTD. Para obter mais informações, consulte [Usar níveis de compactação ZSTD](compression-support-zstd-levels.md). ** field\$1delimiter = '*delimiter*' ** Opcional. Especifica um delimitador de campo de caractere único para arquivos em CSV, TSV e outros formatos de texto. O exemplo a seguir especifica o delimitador como vírgula. ``` WITH (field_delimiter = ',') ``` Atualmente, não há suporte para delimitadores de campo de vários caracteres. Se você não especificar um delimitador de campo, o caractere octal `\001` (^A) será usado. ** partitioned\$1by = ARRAY[ *col\$1name*[,...] ] ** Opcional. Uma lista matriz de colunas pela qual a saída é particionada. Em sua instrução `SELECT`, verifique se os nomes das colunas particionadas estão listados por último na lista de colunas. ## Exemplos O exemplo a seguir grava a saída de uma consulta `SELECT` no local do Amazon S3 `s3://amzn-s3-demo-bucket/unload_test_1/` usando o formato JSON. ``` UNLOAD (SELECT * FROM old_table) TO 's3://amzn-s3-demo-bucket/unload_test_1/' WITH (format = 'JSON') ``` O exemplo a seguir grava a saída de uma consulta `SELECT` no formato Parquet usando a compactação Snappy. ``` UNLOAD (SELECT * FROM old_table) TO 's3://amzn-s3-demo-bucket/' WITH (format = 'PARQUET',compression = 'SNAPPY') ``` O exemplo a seguir grava quatro colunas no formato de texto, com a saída particionada pela última coluna. ``` UNLOAD (SELECT name1, address1, comment1, key1 FROM table1) TO 's3://amzn-s3-demo-bucket/ partitioned/' WITH (format = 'TEXTFILE', partitioned_by = ARRAY['key1']) ``` O exemplo a seguir descarrega os resultados da consulta no local especificado usando o formato de arquivo Parquet, a compressão ZSTD e o nível 4 de compressão ZSTD. ``` UNLOAD (SELECT * FROM old_table) TO 's3://amzn-s3-demo-bucket/' WITH (format = 'PARQUET', compression = 'ZSTD', compression_level = 4) ``` ## Recursos adicionais + [Simplifique seus pipelines de ETL e ML usando o recurso Amazon Athena UNLOAD](https://aws.amazon.com/blogs/big-data/simplify-your-etl-and-ml-pipelines-using-the-amazon-athena-unload-feature/) no *AWSBlog de Big Data*. # Funções no Amazon Athena Para obter informações sobre as mudanças nas funções entre as versões do mecanismo do Athena, consulte [Versionamento do mecanismo do Athena](engine-versions.md). Para ver uma lista dos fusos horários que podem ser usados com o operador `AT TIME ZONE`, consulte [Usar fusos horários compatíveis](athena-supported-time-zones.md). **Topics** + [Mecanismo Athena versão 3](functions-env3.md) # Funções do mecanismo do Athena versão 3 As funções no mecanismo Athena versão 3 são baseadas no Trino. Para obter informações sobre as funções, operadores e expressões do Trino, consulte [Functions and operators](https://trino.io/docs/current/functions.html) (Funções e operadores) e as seguintes subseções na documentação do Trino. + [Aggregate](https://trino.io/docs/current/functions/aggregate.html) + [Array](https://trino.io/docs/current/functions/array.html) + [Binário](https://trino.io/docs/current/functions/binary.html) + [Bitwise](https://trino.io/docs/current/functions/bitwise.html) + [Color (Cor)](https://trino.io/docs/current/functions/color.html) + [Comparação](https://trino.io/docs/current/functions/comparison.html) + [Condicional](https://trino.io/docs/current/functions/conditional.html) + [Conversão](https://trino.io/docs/current/functions/conversion.html) + [Data e hora](https://trino.io/docs/current/functions/datetime.html) + [Decimal](https://trino.io/docs/current/functions/decimal.html) + [Geoespacial](https://trino.io/docs/current/functions/geospatial.html) + [Log de HyperLogLog](https://trino.io/docs/current/functions/hyperloglog.html) + [Endereço IP](https://trino.io/docs/current/functions/ipaddress.html) + [JSON](https://trino.io/docs/current/functions/json.html) + [Lambda](https://trino.io/docs/current/functions/lambda.html) + [Lógico](https://trino.io/docs/current/functions/logical.html) + [Machine learning](https://trino.io/docs/current/functions/ml.html) + [Mapa](https://trino.io/docs/current/functions/map.html) + [Math (Matemática)](https://trino.io/docs/current/functions/math.html) + [Resumo quantil](https://trino.io/docs/current/functions/qdigest.html) + [Expressão regular](https://trino.io/docs/current/functions/regexp.html) + [Sessão](https://trino.io/docs/current/functions/session.html) + [Definir resumo](https://trino.io/docs/current/functions/setdigest.html) + [String](https://trino.io/docs/current/functions/string.html) + [Tabela](https://trino.io/docs/current/functions/table.html) + [Teradata](https://trino.io/docs/current/functions/teradata.html) + [Resumo em T](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) + [Window](https://trino.io/docs/current/functions/window.html) ## função invoker\$1principal() A função `invoker_principal` é exclusiva da versão 3 do mecanismo do Athena e não é encontrada no Trino. Retorna um `VARCHAR` que contém o ARN da entidade principal (perfil do IAM ou identidade do Identity Center) que executou a consulta chamando a função. Por exemplo, se o invocador da consulta usa as permissões de um perfil do IAM para executar a consulta, a função retornará o ARN do perfil do IAM. A função que executa a consulta deve permitir a ação `LakeFormation:GetDataLakePrincipal`. ### Uso ``` SELECT invoker_principal() ``` A tabela a seguir mostra um exemplo de resultado. **** | \$1 | \$1col0 | | --- | --- | | 1 | arn:aws:iam::111122223333:role/Admin | # Usar fusos horários compatíveis É possível utilizar o operador `AT TIME ZONE` em uma instrução para especificar o fuso horário do carimbo de data/hora que será retornado, como no seguinte exemplo: ``` 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 obter uma lista de fusos horários compatíveis com o Athena, expanda [Lista de fusos horários compatíveis](#athena-supported-time-zones-list) no final deste tópico. ## Funções e exemplos de fuso horário Veja a seguir algumas funções e exemplos adicionais relacionados a fuso horário. + **at\$1timezone(*timestamp*, *zone*)**: retorna o valor de *timestamp* no horário local correspondente para *zone*. **Exemplo** ``` 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*)**: retorna a hora do deslocamento do fuso horário do timestamp como um `bigint`. **Exemplo** ``` SELECT timezone_hour(timestamp '2021-08-22 04:00 UTC' AT TIME ZONE 'Canada/Newfoundland') ``` **Resultado** ``` -2 ``` + **timezone\$1minute(*timestamp*)**: retorna a hora do deslocamento do fuso horário do *timestamp* como um `bigint`. **Exemplo** ``` SELECT timezone_minute(timestamp '2021-08-22 04:00 UTC' AT TIME ZONE 'Canada/Newfoundland') ``` **Resultado** ``` -30 ``` + **with\$1timezone(*timestamp*, *zone*)**: retorna um timestamp com fuso horário dos valores *timestamp* e *zone* especificado. **Exemplo** ``` SELECT with_timezone(timestamp '2021-08-22 04:00', 'Canada/Newfoundland') ``` **Resultado** ``` 2021-08-22 04:00:00.000 Canada/Newfoundland ``` ## Lista de fusos horários compatíveis A lista a seguir contém os fusos horários que podem ser usados com o operador `AT TIME ZONE` no Athena. Para obter funções e exemplos adicionais relacionados a fuso horário, consulte [Funções e exemplos de fuso horário](#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 ```