# Instruções DDL
Use as instruções da linguagem de definição de dados (DDL) compatível apresentadas aqui diretamente no Athena. O mecanismo de consulta do Athena é baseado em parte na [DDL do HiveQL](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL). O Athena não aceita todas as instruções DDL, e há algumas diferenças entre a DDL do HiveQL e do Athena. Para obter mais informações, consulte os tópicos de referência nesta seção e em [DDL incompatível](unsupported-ddl.md).
**Topics**
+ [DDL incompatível](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 incompatível
As instruções DDL a seguir não são aceitas no Athena. Para obter as instruções DDL compatíveis com as tabelas do Iceberg no Athena, consulte [Evoluir o esquema de tabelas do Iceberg](querying-iceberg-evolving-table-schema.md) e [Executar outras operações de DDL em tabelas do 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 (compatível com as tabelas do 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 (compatível com as tabelas do 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
+ CRIAR PERFIL
+ 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 ESTATÍSTICAS
+ SHOW TRANSACTIONS
+ START TRANSACTION
+ UNLOCK DATABASE
+ UNLOCK TABLE
# ALTER DATABASE SET DBPROPERTIES
Cria uma ou mais propriedades para um banco de dados. O uso de `DATABASE` e `SCHEMA` é intercambiável. Eles são iguais.
## Resumo
```
ALTER {DATABASE|SCHEMA} database_name
SET DBPROPERTIES ('property_name'='property_value' [, ...] )
```
## Parâmetros
**SET DBPROPERTIES ('property\$1name'='property\$1value' [, ...]**
Especifica uma propriedade ou propriedades para o banco de dados chamado `property_name` e estabelece o valor para cada uma das propriedades, respectivamente como `property_value`. Se `property_name` já existir, o valor anterior será substituído por `property_value`.
## Exemplos
```
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
Adicione uma ou mais colunas a uma tabela existente. Quando a sintaxe opcional de `PARTITION` é usada, os metadados da partição são atualizados.
## Resumo
```
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 [,...])**
Cria uma partição com as combinações de nome/valor de coluna que você especificar. Coloque `partition_col_value` entre aspas somente se o tipo de dados da coluna for uma string.
**ADD COLUMNS (col\$1name data\$1type [,col\$1name data\$1type,...])**
Adiciona colunas após colunas existentes, mas antes das colunas de partição.
## Exemplos
```
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)
```
## Observações
+ Para ver uma nova coluna de tabela no painel de navegação do editor de consultas do Athena depois de executar `ALTER TABLE ADD COLUMNS`, atualize manualmente a lista de tabelas no editor e expanda a tabela outra vez.
+ `ALTER TABLE ADD COLUMNS` não funciona em colunas com o tipo de dados `date`. Para contornar esse problema, use o tipo de dados `timestamp`.
# ALTER TABLE ADD PARTITION
Cria uma ou mais colunas de partição para a tabela. Cada partição consiste em uma ou mais combinações de nome/valor de coluna distintas. Um diretório de dados à parte é criado para cada combinação especificada, o que pode melhorar a performance da consulta em algumas circunstâncias. As colunas particionadas não existem dentro da própria tabela de dados. Dessa forma, se usar o nome de uma coluna com o mesmo nome de uma coluna na própria tabela, você receberá um erro. Para obter mais informações, consulte [Particionar dados](partitions.md).
No Athena, uma tabela e suas partições devem usar os mesmos formatos de dados, mas os esquemas podem ser diferentes. Para obter mais informações, consulte [Atualizar tabelas com partições](updates-and-partitions.md).
Para obter informações sobre as permissões no nível do recurso necessárias nas políticas do IAM (incluindo `glue:CreatePartition`), consulte [Permissões da API do AWS Glue: referência de ações e recursos](https://docs.aws.amazon.com/glue/latest/dg/api-permissions-reference.html) e [Configurar o acesso a bancos de dados e tabelas no AWS Glue Data Catalog](fine-grained-access-to-glue-resources.md). Para obter informações sobre solução de problemas de permissões ao usar o Athena, consulte a seção [Permissões](troubleshooting-athena.md#troubleshooting-athena-permissions) do tópico [Solucionar problemas no Athena](troubleshooting-athena.md).
## Resumo
```
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']
[,...]
```
## Parâmetros
Ao adicionar uma partição, você especifica um ou mais pares de nome/valor de coluna para a partição e o caminho do Amazon S3 onde residem os arquivos de dados dessa partição.
**[IF NOT EXISTS]**
Suprimirá o erro se uma partição com a mesma definição já existir.
**PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])**
Cria uma partição com as combinações de nome/valor de coluna que você especificar. Coloque `partition_col_value` entre caracteres de string somente se o tipo de dados da coluna for uma string.
**[LOCATION 'location']**
Especifica o diretório no qual armazenar a partição definida pela instrução anterior. A cláusula `LOCATION` é opcional quando os dados usam particionamento no estilo Hive (`pk1=v1/pk2=v2/pk3=v3`). Com o particionamento no estilo Hive, o URI completo do Amazon S3 é estruturado automaticamente com base na localização da tabela, nos nomes das chaves de partição e nos valores de chave de partição. Para obter mais informações, consulte [Particionar dados](partitions.md).
## Considerações
O Amazon Athena não impõe um limite específico ao número de partições que você pode adicionar em uma única instrução DDL `ALTER TABLE ADD PARTITION`. No entanto, se você precisar adicionar um número significativo de partições, considere dividir a operação em lotes menores para evitar possíveis problemas de desempenho. O exemplo a seguir usa comandos sucessivos para adicionar partições individualmente e usa `IF NOT EXISTS` para evitar a adição de duplicatas.
```
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')
```
Ao trabalhar com partições no Athena, lembre-se dos seguintes pontos:
+ Embora o Athena ofereça suporte a consulta a tabelas do AWS Glue com 10 milhões de partições, o Athena não pode ler mais de 1 milhão de partições em uma única varredura.
+ Para otimizar suas consultas e reduzir o número de partições verificadas, considere estratégias como remoção de partições ou uso de índices de partição.
Para considerações adicionais sobre como trabalhar com partições no Athena, consulte [Particionar dados](partitions.md).
## Exemplos
O exemplo a seguir adiciona uma única partição a uma tabela para dados particionados no estilo Hive.
```
ALTER TABLE orders ADD
PARTITION (dt = '2016-05-14', country = 'IN');
```
O exemplo a seguir adiciona múltiplas partições a uma tabela para dados particionados no estilo Hive.
```
ALTER TABLE orders ADD
PARTITION (dt = '2016-05-31', country = 'IN')
PARTITION (dt = '2016-06-01', country = 'IN');
```
Quando a tabela não serve para dados particionados no estilo Hive, a cláusula `LOCATION` é obrigatória e deve ser o URI completo do Amazon S3 para o prefixo que contém os dados da partição.
```
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 erros quando a partição já existe, use a cláusula `IF NOT EXISTS`, como no exemplo a seguir.
```
ALTER TABLE orders ADD IF NOT EXISTS
PARTITION (dt = '2016-05-14', country = 'IN');
```
## Arquivos de zero byte no formato `_$folder$`
Se você executar uma instrução `ALTER TABLE ADD PARTITION` e especificar erroneamente uma partição que já existe e uma localização incorreta do Amazon S3, serão criados arquivos de espaço reservado de zero byte do formato `partition_value_$folder$` no Amazon S3. Você precisa remover esses arquivos manualmente.
Para evitar que isso aconteça, use a sintaxe `ADD IF NOT EXISTS` na instrução `ALTER TABLE ADD PARTITION`, como no exemplo a seguir.
```
ALTER TABLE table_name ADD IF NOT EXISTS PARTITION […]
```
# ALTER TABLE CHANGE COLUMN
Altera o nome, o tipo, a ordem ou o comentário de uma coluna em uma tabela.
## Resumo
```
ALTER TABLE [db_name.]table_name
CHANGE [COLUMN] col_old_name col_new_name column_type
[COMMENT col_comment] [FIRST|AFTER column_name]
```
## Exemplos
O exemplo a seguir altera o nome da coluna de `area` para `zip`, torna o tipo de dados inteiro e coloca a coluna renomeada depois da coluna `id`.
```
ALTER TABLE example_table CHANGE COLUMN area zip int AFTER id
```
O exemplo a seguir adiciona um comentário à coluna `zip` nos metadados para `example_table`. Para ver o comentário, use o comando da 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) ou acesse o esquema da tabela no console do AWS Glue.
```
ALTER TABLE example_table CHANGE COLUMN zip zip int COMMENT 'USA zipcode'
```
# ALTER TABLE DROP PARTITION
Descarta uma ou mais partições especificadas para a tabela nomeada.
## Resumo
```
ALTER TABLE table_name DROP [IF EXISTS] PARTITION (partition_spec) [, PARTITION (partition_spec)]
```
## Parâmetros
**[SE EXISTIR]**
Suprime a mensagem de erro se a partição especificada não existir.
**PARTIÇÃO (partition\$1spec)**
Cada `partition_spec` especifica uma combinação de nome de coluna e valor no formato `partition_col_name = partition_col_value [,...]`.
## Exemplos
```
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');
```
## Observações
A instrução `ALTER TABLE DROP PARTITION` não fornece uma sintaxe única para descartar todas as partições de uma só vez nem suporta critérios de filtragem para especificar um intervalo de partições a serem eliminadas.
Como solução de contorno, use as ações [GetPartitions](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-GetPartitions) e [BatchDeletePartition](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-BatchDeletePartition) da API do AWS Glue no desenvolvimento de scripts. A ação `GetPartitions` suporta expressões de filtro complexas como as de uma expressão `WHERE` em SQL. Depois de usar `GetPartitions` para criar uma lista filtrada das partições a serem excluídas, você pode usar a ação `BatchDeletePartition` para excluir as partições em lotes de 25.
# ALTER TABLE RENAME PARTITION
Renomeia um valor de partição.
**nota**
ALTER TABLE RENAME PARTITION não renomeia as colunas de partição. Para alterar o nome de uma coluna de partição, você pode usar o console do AWS Glue. Para obter mais informações, consulte [Renomear uma coluna de partição no AWS Glue](#alter-table-rename-partition-column-name) adiante neste documento.
## Resumo
Para a tabela chamada `table_name`, renomeia o valor da partição especificado por `partition_spec` para o valor especificado por `new_partition_spec`.
```
ALTER TABLE table_name PARTITION (partition_spec) RENAME TO PARTITION (new_partition_spec)
```
## Parâmetros
**PARTIÇÃO (partition\$1spec)**
Cada `partition_spec` especifica uma combinação de nome de coluna e valor no formato `partition_col_name = partition_col_value [,...]`.
## Exemplos
```
ALTER TABLE orders
PARTITION (dt = '2014-05-14', country = 'IN') RENAME TO PARTITION (dt = '2014-05-15', country = 'IN');
```
## Renomear uma coluna de partição no AWS Glue
Use o procedimento a seguir para renomear colunas de partição no console do AWS Glue.
**Para renomear uma coluna de partição de tabela no console do AWS Glue**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, selecione **Tabelas**.
1. Na página **Tabelas**, use a caixa de pesquisa **Filtrar tabelas** para localizar a tabela que você deseja alterar.
1. Na coluna **Nome**, escolha o link da tabela que você deseja alterar.
1. Na página de detalhes da tabela, na seção **Esquema**, siga um destes procedimentos:
+ Para fazer a alteração do nome no formato JSON, escolha **Editar esquema como JSON**.
+ Para alterar o nome diretamente, escolha **Editar esquema**. Esse procedimento escolhe **Editar esquema**.
1. Marque a caixa de seleção referente à coluna particionada que você deseja renomear e escolha **Editar**.
1. Na caixa de diálogo **Editar entrada do esquema**, em **Nome**, insira o novo nome para a coluna de partição.
1. Selecione **Salvar como nova versão da tabela**. Essa ação atualiza o nome da coluna da partição e preserva o histórico de evolução do esquema sem criar outra cópia física dos dados.
1. Para comparar as versões da tabela, na página de detalhes da tabela, escolha **Ações** e, em seguida, **Comparar versões**.
## Recursos adicionais
Para obter mais informações sobre particionamento, consulte [Particionar dados](partitions.md).
# ALTER TABLE REPLACE COLUMNS
Remove todas as colunas existentes de uma tabela criada com [LazySimpleSerDe](lazy-simple-serde.md) e as substitui pelo conjunto de colunas especificado. Quando a sintaxe opcional de `PARTITION` é usada, os metadados da partição são atualizados. Você também pode usar `ALTER TABLE REPLACE COLUMNS` para descartar as colunas especificando apenas as colunas que deseja manter.
## Resumo
```
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, ...])
```
## Parâmetros
**PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])**
Especifica uma partição com as combinações de nome/valor de coluna que você especificar. Coloque `partition_col_value` entre aspas somente se o tipo de dados da coluna for uma string.
**REPLACE COLUMNS (col\$1name data\$1type [,col\$1name data\$1type,...])**
Substitui as colunas existentes pelos nomes e tipos de dados de coluna especificados.
## Observações
+ Para ver a alteração nas colunas de tabela no painel de navegação do editor de consultas do Athena após executar `ALTER TABLE REPLACE COLUMNS`, pode ser necessário atualizar manualmente a tabela no editor e depois expandir a tabela outra vez.
+ `ALTER TABLE REPLACE COLUMNS` não funciona em colunas com o tipo de dados `date`. Para contornar esse problema, use o tipo de dados `timestamp` na tabela.
+ Observe que, mesmo que se você for substituir apenas uma coluna, a sintaxe deverá ser `ALTER TABLE table-name REPLACE COLUMNS`, com *columns* no plural. Você deve especificar não apenas a coluna que deseja substituir, mas as colunas que deseja manter, do contrário, as colunas que não especificadas serão descartadas. Essa sintaxe e esse comportamento derivam da DDL do Apache Hive. Para referência, consulte [Add/Replace Columns](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-Add/ReplaceColumns) (Adicionar/substituir colunas) na documentação do Apache.
## Exemplo
No exemplo a seguir, a tabela `names_cities`, que foi criada usando o [LazySimpleSerDe](lazy-simple-serde.md), tem três colunas chamadas `col1`, `col2` e `col3`. Todas as colunas são do tipo `string`. Para mostrar as colunas na tabela, o comando a seguir usa a instrução [SHOW COLUMNS](show-columns.md).
```
SHOW COLUMNS IN names_cities
```
Resultado da consulta:
```
col1
col2
col3
```
O comando `ALTER TABLE REPLACE COLUMNS` a seguir substitui os nomes das colunas por `first_name`,`last_name` e `city`. Os dados de origem subjacentes não são afetados.
```
ALTER TABLE names_cities
REPLACE COLUMNS (first_name string, last_name string, city string)
```
Para testar o resultado, `SHOW COLUMNS` é executado novamente.
```
SHOW COLUMNS IN names_cities
```
Resultado da consulta:
```
first_name
last_name
city
```
Outra maneira de mostrar os novos nomes de coluna é exibir a [previsualização da tabela](creating-tables-showing-table-information.md) no editor de consultas do Athena ou executar o sua própria consulta `SELECT`.
# ALTER TABLE SET LOCATION
Altera o local da tabela chamada `table_name` e, como opção, uma partição com `partition_spec`.
## Resumo
```
ALTER TABLE table_name [ PARTITION (partition_spec) ] SET LOCATION 'new location'
```
## Parâmetros
**PARTIÇÃO (partition\$1spec)**
Especifica a partição com parâmetros `partition_spec` cujo local você deseja alterar. O `partition_spec` especifica uma combinação nome/valor na forma `partition_col_name = partition_col_value`.
**SET LOCATION 'new location'**
Especifica o novo local, que deve ser um local do Amazon S3. Para obter informações sobre sintaxe, consulte [Local da tabela no Amazon S3](tables-location-format.md).
## Exemplos
```
ALTER TABLE customers PARTITION (zip='98040', state='WA') SET LOCATION 's3://amzn-s3-demo-bucket/custdata/';
```
# ALTER TABLE SET TBLPROPERTIES
Adiciona propriedades de metadados personalizadas ou predefinidas a uma tabela e define seus valores atribuídos. Para ver as propriedades em uma tabela, use o comando [SHOW TBLPROPERTIES](show-tblproperties.md).
As [tabelas gerenciadas](https://cwiki.apache.org/confluence/display/Hive/Managed+vs.+External+Tables) do Apache Hive não são permitidas, portanto, a definição de `'EXTERNAL'='FALSE'` não tem efeito.
## Resumo
```
ALTER TABLE table_name SET TBLPROPERTIES ('property_name' = 'property_value' [ , ... ])
```
## Parâmetros
**SET TBLPROPERTIES ('property\$1name' = 'property\$1value' [ , ... ])**
Especifica as propriedades de metadados a serem adicionadas como `property_name` e o valor para cada uma como `property value`. Se `property_name` já existir, o valor será definido como o `property_value` recém-especificado.
As propriedades de tabela predefinidas a seguir têm usos especiais.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/alter-table-set-tblproperties.html)
## Exemplos
O exemplo a seguir adiciona uma nota de comentário às propriedades da tabela.
```
ALTER TABLE orders
SET TBLPROPERTIES ('notes'="Please don't drop this table.");
```
O exemplo a seguir modifica a tabela `existing_table` para usar o formato de arquivo Parquet com compactação ZSTD nível 4.
```
ALTER TABLE existing_table
SET TBLPROPERTIES ('parquet.compression' = 'ZSTD', 'compression_level' = 4)
```
# ALTER VIEW DIALECT
Adiciona ou remove um dialeto do mecanismo de uma visualização do AWS Glue Data Catalog. Aplica-se somente às visualizações do AWS Glue Data Catalog. Requer permissões do administrador ou definidor do `Lake Formation`.
Para obter mais informações sobre visualizações do AWS Glue Data Catalog, consulte [Usar visualizações do Catálogo de Dados no Athena](views-glue.md).
## Sintaxe
```
ALTER VIEW name [ FORCE ] [ ADD|UPDATE ] DIALECT AS query
```
```
ALTER VIEW name [ DROP ] DIALECT
```
**FORCE**
A palavra-chave `FORCE` faz com que as informações conflitantes do dialeto do mecanismo em uma visualização sejam substituídas pela nova definição. A palavra-chave `FORCE` é útil quando uma atualização em uma visualização do Catálogo de Dados resulta em definições de visualizações conflitantes entre os dialetos dos mecanismos existentes. Suponha que uma visualização do Catálogo de Dados tenha os dialetos do Athena e do Amazon Redshift e que a atualização resulte em um conflito com o Amazon Redshift na definição de visualização. Nesse caso, é possível usar a palavra-chave `FORCE` para permitir que a atualização seja concluída e marcar o dialeto do Amazon Redshift como obsoleto. Quando mecanismos marcados como obsoletos consultam a visualização, a consulta apresenta falhas. Os mecanismos lançam uma exceção para rejeitar resultados obsoletos. Para corrigir isso, atualize os dialetos obsoletos na visualização.
**ADD**
Adiciona um novo dialeto do mecanismo à visualização do Catálogo de Dados. O mecanismo especificado ainda não deve existir na visualização do Catálogo de Dados.
**UPDATE**
Atualiza um dialeto do mecanismo que já existe na visualização do Catálogo de Dados.
**DROP**
Descarta um dialeto do mecanismo existente de uma visualização do Catálogo de Dados. Após descartar um mecanismo de uma visualização do Catálogo de Dados, a visualização do Catálogo de Dados não poderá ser consultada pelo mecanismo que foi descartado. Outros dialetos do mecanismo na visualização ainda podem consultar a visualização.
**DIALECT AS**
Apresenta uma consulta SQL específica para o mecanismo.
## Exemplos
```
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
Cria um banco de dados. O uso de `DATABASE` e `SCHEMA` é intercambiável. Eles significam a mesma coisa.
**nota**
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
```
CREATE {DATABASE|SCHEMA} [IF NOT EXISTS] database_name
[COMMENT 'database_comment']
[LOCATION 'S3_loc']
[WITH DBPROPERTIES ('property_name' = 'property_value') [, ...]]
```
Para obter restrições sobre nomes de bancos de dados no Athena, consulte [Nomear bancos de dados, tabelas e colunas](tables-databases-columns-names.md).
## Parâmetros
**[IF NOT EXISTS]**
Fará o erro ser suprimido se um banco de dados chamado `database_name` já existir.
**[COMMENT database\$1comment]**
Estabelece o valor de metadados para a propriedade de metadados interna chamada `comment` e o valor fornecido por você para `database_comment`. No AWS Glue, o conteúdo de `COMMENT` é gravado no campo `Description` das propriedades do banco de dados.
**[LOCATION S3\$1loc]**
Especifica o local onde arquivos de banco de dados e metastore existirão como `S3_loc`. O local deve ser um local do Amazon S3.
**[WITH DBPROPERTIES ('property\$1name' = 'property\$1value') [, ...] ]**
Permite especificar propriedades de metadados personalizados para a definição do banco de dados.
## Exemplos
```
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');
```
## Visualizar as propriedades do banco de dados
Para visualizar as propriedades de um banco de dados criado no AWSDataCatalog usando `CREATE DATABASE`, você pode usar o 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) da AWS CLI, como no seguinte exemplo:
```
aws glue get-database --name
```
Na saída do JSON, o resultado é semelhante ao seguinte:
```
{
"Database": {
"Name": "",
"Description": "",
"LocationUri": "s3://amzn-s3-demo-bucket",
"Parameters": {
"": ""
},
"CreateTime": 1603383451.0,
"CreateTableDefaultPermissions": [
{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": [
"ALL"
]
}
]
}
}
```
Para obter mais informações sobre a AWS CLI, consulte o [Manual do usuário da AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/).
# CREATE TABLE
Cria uma tabela com o nome e os parâmetros especificados por você.
**nota**
Esta página contém informações de referência resumidas. Para obter mais informações sobre como criar tabelas no Athena e um exemplo de instrução `CREATE TABLE`, consulte [Criar tabelas no Athena](creating-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
```
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 [, ...] ) ]
```
## Parâmetros
**EXTERNAL**
Especifica que a tabela é baseada em um arquivo de dados subjacente existente no Amazon S3, no `LOCATION` que você especificar. Exceto ao criar tabelas do [Iceberg](querying-iceberg-creating-tables.md), use sempre a palavra-chave `EXTERNAL`. Se você usar `CREATE TABLE` sem a palavra-chave `EXTERNAL` para tabelas que não são do Iceberg, o Athena emitirá um erro. Quando você cria uma tabela externa, os dados referenciados devem estar em conformidade com o formato padrão ou o formato especificado por você com as cláusulas `ROW FORMAT`, `STORED AS` e `WITH SERDEPROPERTIES`.
**[IF NOT EXISTS]**
Este parâmetro verifica se já existe uma tabela com o mesmo nome. Se existir, o parâmetro retornará `TRUE` e o Amazon Athena cancelará a ação `CREATE TABLE`. Como o cancelamento ocorre antes que o Athena chame o catálogo de dados, ele não emite um evento AWS CloudTrail.
**[db\$1name.]table\$1name**
Especifica um nome para a tabela a ser criada. O parâmetro `db_name` opcional especifica o banco de dados no qual a tabela existe. Se omitido, o banco de dados atual será assumido. Se o nome da tabela inclui números, coloque `table_name` entre aspas, por exemplo `"table123"`. Se `table_name` começar com um sublinhado, use acentos graves, por exemplo, ``_mytable``. Os caracteres especiais (que não sejam sublinhado) não são compatíveis.
Os nomes de tabela do Athena não diferenciam maiúsculas de minúsculas. No entanto, se você trabalhar com o Apache Spark, o Spark exigirá nomes de tabela em letras minúsculas. Para restrições sobre nomes de tabelas no Athena, consulte [Nomear bancos de dados, tabelas e colunas](tables-databases-columns-names.md).
**[ ( col\$1name data\$1type [COMMENT col\$1comment] [, ...] ) ]**
Especifica o nome de cada coluna a ser criada, além do tipo de dados da coluna. Os nomes de coluna não permitem caracteres especiais além de sublinhado `(_)`. Se `col_name` começar com um sublinhado, coloque o nome da coluna entre acentos graves, por exemplo ``_mycolumn``. Para restrições sobre nomes de colunas no Athena, consulte [Nomear bancos de dados, tabelas e colunas](tables-databases-columns-names.md).
O valor `data_type` pode ser qualquer um dos seguintes:
+ `boolean` – os valores são `true` e `false`.
+ `tinyint`: um inteiro com sinal de 8 bits no formato de complemento de dois, com um valor mínimo de -2^7 e um valor máximo de 2^7-1.
+ `smallint`: um inteiro com sinal de 16 bits no formato de complemento de dois, com um valor mínimo de -2^15 e um valor máximo de 2^15-1.
+ `int`: nas consultas em Data Definition Language (DDL), como `CREATE TABLE`, use a palavra-chave `int` para representar um número inteiro. Em outras consultas, use a palavra-chave `integer`, em que `integer` é representado por um valor com sinal de 32 bits no formato de complemento de dois, com um valor mínimo de -2^31 e um valor máximo de 2^31-1. No driver JDBC, `integer` é retornado para garantir a compatibilidade com os aplicativos de análise de negócios.
+ `bigint`: um inteiro com sinal de 64 bits no formato de complemento de dois, com um valor mínimo de -2^63 e um valor máximo de 2^63-1.
+ `double`: um número com sinal de ponto flutuante de precisão dupla de 64 bits. O intervalo é de 4.94065645841246544e-324d a 1.79769313486231570e\$1308d, positivo ou negativo. `double` segue o padrão para aritmética de ponto flutuante do IEEE (IEEE 754).
+ `float`: um número com sinal de ponto flutuante de precisão única de 32 bits. O intervalo é de 1.40129846432481707e-45 a 3.40282346638528860e\$138, positivo ou negativo. `float` segue o padrão para aritmética de ponto flutuante do IEEE (IEEE 754). Equivalente a `real` no Presto. No Athena, use `float` nas instruções DDL, como `CREATE TABLE`, e `real` nas funções SQL, como `SELECT CAST`. O crawler do AWS Glue retorna os valores em `float`, e o Athena converte os tipos `real` e `float` internamente (leia as notas de release [5 de junho de 2018](release-notes.md#release-note-2018-06-05)).
+ `decimal [ (precision, scale) ]`, onde `precision` é o número total de dígitos e `scale` (opcional) é o número de dígitos na parte fracionada, o padrão é 0. Por exemplo, use estas definições de tipo: `decimal(11,5)`, `decimal(15)`. O valor máximo para *precisão* é 38 e o valor máximo para *escala* é 38.
Para especificar valores decimais como literais, como ao selecionar filas com um valor decimal específico em uma expressão de consulta DDL, especifique a definição de tipo `decimal` e liste o valor decimal como um literal (em aspas simples) na consulta, como neste exemplo: `decimal_value = decimal '0.12'`.
+ `char` – os dados de caractere de comprimento fixo, com um tamanho especificado entre 1 e 255, como `char(10)`. Para obter mais informações, consulte [CHAR Hive data type](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-char) (Tipo de dado CHAR do Hive).
+ `varchar` – os dados de caractere de comprimento variável, com um tamanho especificado entre 1 e 65535, como `varchar(10)`. Para obter mais informações, consulte [VARCHAR Hive data type](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-varchar) (Tipo de dado VARCHAR do Hive).
+ `string`: um literal de string entre aspas simples ou duplas.
**nota**
Os tipos de dados que não são de string não podem ser convertidos em `string` no Athena. Em vez disso, converta-os em `varchar`.
+ `binary`: (para dados em Parquet)
+ `date` – Uma data no formato ISO, como `YYYY-MM-DD`. Por exemplo, `date '2008-09-15'`. Uma exceção é o OpenCSVSerDe, que usa o número de dias decorridos desde 1° de janeiro de 1970. Para obter mais informações, consulte [Open CSV SerDe para processamento de CSV](csv-serde.md).
+ `timestamp`: instante de data e hora em um formato compatível com [https://docs.oracle.com/javase/8/docs/api/java/sql/Timestamp.html](https://docs.oracle.com/javase/8/docs/api/java/sql/Timestamp.html) até uma resolução máxima de milissegundos, como `yyyy-MM-dd HH:mm:ss[.f...]`. Por exemplo, `timestamp '2008-09-15 03:04:05.324'`. Uma exceção é o OpenCSVSerDe, que usa os dados de `TIMESTAMP` no formato numérico UNIX (por exemplo, `1579059880000`). Para obter mais informações, consulte [Open CSV SerDe para processamento de CSV](csv-serde.md).
+ `array` < data\$1type >
+ `map` < primitive\$1type, data\$1type >
+ `struct` < col\$1name : data\$1type [comment col\$1comment] [, ...] >
**[COMMENT table\$1comment]**
Cria a propriedade da tabela `comment` e a preenche com o `table_comment` especificado por você.
**[PARTITIONED BY (col\$1name data\$1type [ COMMENT col\$1comment ], ... ) ]**
Cria uma tabela particionada com uma ou mais colunas de partição que tenham `col_name`, `data_type` e `col_comment` especificados. A tabela pode ter uma ou mais partições, que consistem em uma combinação distinta de nome e valor de coluna. Um diretório de dados à parte é criado para cada combinação especificada, o que pode melhorar a performance da consulta em algumas circunstâncias. As colunas particionadas não existem na própria tabela de dados. Se você usar um valor para `col_name` que é o mesmo valor usado na coluna da tabela, obterá um erro. Para obter mais informações, consulte [Particionar dados](partitions.md).
Depois de criar uma tabela com partições, execute uma consulta que consista na cláusula [MSCK REPAIR TABLE](msck-repair-table.md) para atualizar metadados de partição, por exemplo, `MSCK REPAIR TABLE cloudfront_logs;`. Para partições que não são compatíveis com o Hive, use o [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) a fim de carregar as partições para que você consiga consultar os dados.
**[CLUSTERED BY (col\$1name, col\$1name, ...) INTO num\$1buckets BUCKETS]**
Divide, com ou sem particionamento, os dados nas colunas `col_name` especificadas em subconjuntos de dados chamados *buckets*. O parâmetro `num_buckets` especifica o número de buckets que serão criados. A criação de buckets pode melhorar a performance de algumas consultas em grandes conjuntos de dados.
**[ROW FORMAT row\$1format]**
Especifica o formato de linha da tabela e os dados de origem subjacente, se aplicável. Para `row_format`, você pode especificar um ou mais delimitadores com a cláusula `DELIMITED` ou, como alternativa, usar a cláusula `SERDE` conforme descrito abaixo. Se `ROW FORMAT` for omitido ou `ROW FORMAT DELIMITED` for especificado, um SerDe nativo será usado.
+ [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]
Disponível somente com o Hive 0.13 e quando o formato de arquivo em STORED AS (ARMAZENADO COMO) for `TEXTFILE`.
**--OU--**
+ SERDE 'serde\$1name' [WITH SERDEPROPERTIES ("property\$1name" = "property\$1value", "property\$1name" = "property\$1value" [, ...] )]
O `serde_name` indica o SerDe a ser usado. A cláusula `WITH SERDEPROPERTIES` permite fornecer uma ou mais propriedades personalizadas permitidas pelo SerDe.
**[STORED AS formato do arquivo]**
Especifica o formato de arquivo para dados da tabela. Se omitido, `TEXTFILE` será o padrão. As opções de `file_format` são:
+ SEQUENCEFILE
+ TEXTFILE
+ RCFILE
+ ORC
+ PARQUET
+ AVRO
+ ION
+ INPUTFORMAT input\$1format\$1classname OUTPUTFORMAT output\$1format\$1classname
**[LOCATION 's3://amzn-s3-demo-bucket/[folder]/']**
Especifica o local dos dados subjacentes no Amazon S3 dos quais a tabela é criada. O caminho do local deve ser um nome de bucket ou um nome de bucket e uma ou mais pastas. Se você estiver usando partições, especifique a raiz dos dados particionados. Para obter mais informações sobre a localização da tabela, consulte [Especificar um local de tabela no Amazon S3](tables-location-format.md). Para obter informações sobre formatos de dados e permissões, consulte [Considerações sobre o Amazon S3](creating-tables.md#s3-considerations).
Use uma barra à direita para a pasta ou o bucket. Não use nomes de arquivo ou caracteres glob.
**Use:**
`s3://amzn-s3-demo-bucket/`
`s3://amzn-s3-demo-bucket/folder/`
`s3://amzn-s3-demo-bucket/folder/anotherfolder/`
**Não use:**
`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 pares de chave/valor de metadados personalizados para a definição da tabela, além das propriedades da tabela predefinidas, como `"comment"`.
**has\$1encrypted\$1data**: o Athena tem uma propriedade integrada, `has_encrypted_data`. Defina essa propriedade como `true` para indicar que o conjunto de dados subjacente especificado por `LOCATION` está criptografado com CSE-KMS. Se omitido e se as configurações do grupo de trabalho não substituírem as configurações do lado do cliente, a pressuposição será `false`. Se omitido ou definido como `false` quando os dados subjacentes estiverem criptografados, a consulta resultará em um erro. Para obter mais informações, consulte [Criptografia em repouso](encryption.md).
**encryption\$1option**: defina essa propriedade como `SSE_S3`, `SSE_KMS` ou `CSE_KMS` para indicar o nível mais alto de criptografia usado no conjunto de dados subjacente especificado por `LOCATION`. Para obter mais informações, consulte [Criptografia em repouso](encryption.md).
**kms\$1key**: defina essa propriedade como o ARN da chave do AWS KMS usada para criptografar e descriptografar arquivos de dados da tabela. O Athena usa essa chave para criptografar arquivos de dados de tabela ao gravar com criptografia `SSE_KMS` ou `CSE_KMS` e para descriptografar arquivos de dados de tabela criptografados com CSE-KMS. Essa propriedade somente é necessária quando `encryption_option` é definido como `SSE_KMS` ou `CSE_KMS`. Para obter mais informações, consulte [Criptografia em repouso](encryption.md).
**classificação**: as tabelas criadas para o Athena no console do CloudTrail adicionam `cloudtrail` como um valor para a propriedade `classification`. Para executar trabalhos ETL, o AWS Glue requer a criação de uma tabela com a propriedade `classification` para indicar o tipo de dados do AWS Glue como `csv`, `parquet`, `orc`, `avro` ou `json`. Por exemplo, `'classification'='csv'`. Os trabalhos ETL falharão se você não especificar essa propriedade. Você poderá especificá-la mais tarde usando o console do AWS Glue, a API ou a CLI. Para obter mais informações, consulte [Criação de tabelas para trabalhos de ETL](schema-classifier.md) e [Criar trabalhos no AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job.html) no *Guia do desenvolvedor do AWS Glue*.
**compression\$1level**: a propriedade `compression_level` especifica o nível de compactação a ser usado. Essa propriedade se aplica apenas à compactação ZSTD. Os valores possíveis são de 1 a 22. O valor padrão é 3. Para obter mais informações, consulte [Usar níveis de compactação ZSTD](compression-support-zstd-levels.md).
Para obter mais informações sobre outras propriedades de tabelas, consulte [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md).
## Exemplos
A instrução de exemplo `CREATE TABLE` a seguir cria uma tabela com base em dados de planetas separados por tabulações armazenados no 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/'
```
Observe os seguintes pontos:
+ A cláusula `ROW FORMAT DELIMITED` indica que os dados são delimitados por um caractere específico.
+ A cláusula `FIELDS TERMINATED BY '\t'` especifica que os campos nos dados do TSV sejam separados pelo caractere de tabulação ('\$1t').
+ A cláusula `STORED AS TEXTFILE` indica que os dados sejam armazenados como arquivos de texto simples no Amazon S3.
Para consultar os dados, você pode usar uma instrução simples `SELECT` como a seguinte:
```
SELECT * FROM planet_data
```
Para usar o exemplo para criar sua própria tabela TSV no Athena, substitua os nomes das tabelas e colunas pelos nomes e tipos de dados de sua própria tabela e colunas e atualize a cláusula `LOCATION` para apontar para o caminho do Amazon S3 em que seus arquivos TSV estão armazenados.
Para obter mais informações sobre como criar tabelas, consulte [Criar tabelas no Athena](creating-tables.md).
# CREATE TABLE AS
Cria uma tabela preenchida com os resultados de uma consulta [SELECT](select.md). Para criar uma tabela vazia, use [CREATE TABLE](create-table.md). `CREATE TABLE AS` combina uma instrução DDL `CREATE TABLE` com uma instrução DML `SELECT` e, portanto, tecnicamente contém DDL e DML. Observe que, embora `CREATE TABLE AS` esteja agrupado aqui com outras instruções DDL, as consultas CTAS no Athena são tratadas como DML para fins de cotas de serviço. Para obter informações sobre as cotas de serviço do Athena, consulte [Service Quotas](service-limits.md).
**nota**
Para instruções CTAS, a configuração esperada do proprietário do bucket 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 ter 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 outras informações sobre `CREATE TABLE AS` que não fazem parte do escopo deste tópico de referência, consulte [Criar uma tabela com base em resultados de consultas (CTAS)](ctas.md).
**Topics**
+ [Resumo](#synopsis)
+ [Propriedades da tabela CTAS](#ctas-table-properties)
+ [Exemplos](#ctas-table-examples)
## Resumo
```
CREATE TABLE table_name
[ WITH ( property_name = expression [, ...] ) ]
AS query
[ WITH [ NO ] DATA ]
```
Em que:
**COM ( property\$1name = expression [, ...] )**
Uma lista de propriedades opcionais da tabela CTAS, algumas das quais são específicas do formato de armazenamento de dados. Consulte [Propriedades da tabela CTAS](#ctas-table-properties).
**consulta**
A consulta [SELECT](select.md) que é usada para criar uma tabela.
Se você planeja criar uma consulta com partições, especifique os nomes das colunas particionadas por último na lista de colunas na `SELECT` instrução.
**[ WITH [ NO ] DATA ]**
Se `WITH NO DATA` for usado, uma tabela vazia com o mesmo esquema da tabela original será criada.
**nota**
Para incluir cabeçalhos de coluna na saída do resultado da consulta, você pode usar uma consulta `SELECT` simples em vez de uma consulta CTAS. Você pode recuperar os resultados no local dos resultados da consulta ou baixá-los diretamente usando o console do Athena. Para ter mais informações, consulte [Trabalhar com resultados de consultas e consultas recentes](querying.md).
## Propriedades da tabela CTAS
Cada tabela CTAS no Athena tem uma lista de propriedades opcionais que você especifica usando `WITH (property_name = expression [, ...] )`. Para obter mais informações sobre como usar esses parâmetros, consulte [Exemplos de consultas CTAS](ctas-examples.md).
** `WITH (property_name = expression [, ...], )` **
`table_type = ['HIVE', 'ICEBERG']`
Opcional. O padrão é `HIVE`. Especifica o tipo de tabela da tabela resultante.
Exemplo:
```
WITH (table_type ='ICEBERG')
```
`external_location = [location]`
Como as tabelas do Iceberg não são externas, essa propriedade não se aplicará a elas. Para definir o local raiz de uma tabela do Iceberg em uma instrução CTAS, use a propriedade `location`, que será descrita posteriormente nesta seção.
Opcional. O local no qual o Athena salvará sua consulta CTAS no Amazon S3.
Exemplo:
```
WITH (external_location ='s3://amzn-s3-demo-bucket/tables/parquet_table/')
```
O Athena não usa o mesmo caminho duas vezes para os resultados das consultas. Se você especificar o local manualmente, verifique se o local especificado no Amazon S3 não contém dados. O Athena nunca tenta excluir os dados. Para usar o mesmo local novamente, exclua os dados manualmente. Caso contrário, a consulta CTAS falhará.
Se você executar uma consulta CTAS que especifica um `external_location` em um grupo de trabalho que [impõe um local para os resultados de consultas](workgroups-settings-override.md), a consulta falhará com uma mensagem de erro. Para ver o local dos resultados de consultas especificado para o grupo de trabalho, [consulte os detalhes do grupo de trabalho](viewing-details-workgroups.md).
Se o grupo de trabalho substituir a configuração de local dos resultados das consultas do lado do cliente, o Athena criará sua tabela no seguinte local:
```
s3://amzn-s3-demo-bucket/tables/query-id/
```
Se você não usar a propriedade `external_location` para especificar um local, e o grupo de trabalho não substituir as configurações do lado do cliente, o Athena usará a [configuração do lado do cliente](query-results-specify-location-console.md) de local dos resultados das consultas para criar sua tabela no seguinte local:
```
s3://amzn-s3-demo-bucket/Unsaved-or-query-name/year/month/date/tables/query-id/
```
`is_external = [boolean]`
Opcional. Indica se a tabela corresponde a uma tabela externa. O padrão é true. Para tabelas do Iceberg, deve ser definido como “false” (falso).
Exemplo:
```
WITH (is_external = false)
```
`location = [location]`
Obrigatório para tabelas do Iceberg. Especifica o local raiz da tabela do Iceberg que será criada a partir dos resultados da consulta.
Exemplo:
```
WITH (location ='s3://amzn-s3-demo-bucket/tables/iceberg_table/')
```
`field_delimiter = [delimiter]`
Opcionais e específicos para formatos de armazenamento físico de dados com base em texto. O delimitador de campo de caractere único para arquivos em CSV, TSV e de texto. Por exemplo, `WITH (field_delimiter = ',')`. Atualmente, os delimitadores de campo de vários caracteres não são permitidos em consultas CTAS. Se você não especificar um delimitador do campo, `\001` será usado por padrão.
`format = [storage_format]`
O formato de armazenamento dos resultados de consultas CTAS, como `ORC`, `PARQUET`, `AVRO`, `JSON`, `ION` ou `TEXTFILE`. Para tabelas do Iceberg, os formatos permitidos são `ORC`, `PARQUET` e `AVRO`. Se for omitido, `PARQUET` é usado por padrão. O nome deste parâmetro, `format`, deve estar listado em minúsculas, ou sua consulta CTAS falhará.
Exemplo:
```
WITH (format = 'PARQUET')
```
`bucketed_by = ARRAY[ column_name[,…], bucket_count = [int] ]`
Essa propriedade não se aplica para tabelas do Iceberg. Para tabelas do Iceberg, use o particionamento com transformação de bucket.
Uma lista matriz de buckets para dados do bucket. Se omitida, o Athena não armazenará os dados dessa consulta em bucket.
`bucket_count = [int]`
Essa propriedade não se aplica para tabelas do Iceberg. Para tabelas do Iceberg, use o particionamento com transformação de bucket.
O número de buckets para armazenar seus dados em um bucket. Se omitido, o Athena não armazenará os dados em bucket. Exemplo:
```
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[,…] ]`
Essa propriedade não se aplica para tabelas do Iceberg. Para usar transformações de partição para tabelas do Iceberg, use a propriedade `partitioning`, que será descrita posteriormente nesta seção.
Opcional. Uma lista matriz de colunas pela qual a tabela CTAS será particionada. Verifique se os nomes das colunas particionadas estão listados por último na lista de colunas da instrução `SELECT`.
`partitioning = ARRAY[partition_transform, ...]`
Opcional. Especifica o particionamento da tabela do Iceberg que será criada. O Iceberg é compatível com uma ampla variedade de transformações e evoluções de partições. As transformações de partição estão resumidas na tabela a seguir.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/athena/latest/ug/create-table-as.html)
Exemplo:
```
WITH (partitioning = ARRAY['month(order_date)',
'bucket(account_number, 10)',
'country']))
```
`optimize_rewrite_min_data_file_size_bytes = [long]`
Opcional. Configuração específica de otimização de dados. Arquivos menores que o valor especificado são incluídos para otimização. O padrão é 0,75 vezes o valor de `write_target_data_file_size_bytes`. Essa propriedade se aplica apenas a tabelas do Iceberg. Para ter mais informações, consulte [Otimizar tabelas do Iceberg](querying-iceberg-data-optimization.md).
Exemplo:
```
WITH (optimize_rewrite_min_data_file_size_bytes = 402653184)
```
`optimize_rewrite_max_data_file_size_bytes = [long]`
Opcional. Configuração específica de otimização de dados. Arquivos maiores que o valor especificado são incluídos para otimização. O padrão é 1,8 vezes o valor de `write_target_data_file_size_bytes`. Essa propriedade se aplica apenas a tabelas do Iceberg. Para ter mais informações, consulte [Otimizar tabelas do Iceberg](querying-iceberg-data-optimization.md).
Exemplo:
```
WITH (optimize_rewrite_max_data_file_size_bytes = 966367641)
```
`optimize_rewrite_data_file_threshold = [int]`
Opcional. Configuração específica de otimização de dados. Se houver menos arquivos de dados que exigem otimização do que o limite fornecido, os arquivos não serão regravados. Isso permite acumular mais arquivos de dados para produzir arquivos mais próximos do tamanho de destino e ignorar a computação desnecessária para gerar economia de custos. O padrão é 5. Essa propriedade se aplica apenas a tabelas do Iceberg. Para ter mais informações, consulte [Otimizar tabelas do Iceberg](querying-iceberg-data-optimization.md).
Exemplo:
```
WITH (optimize_rewrite_data_file_threshold = 5)
```
`optimize_rewrite_delete_file_threshold = [int]`
Opcional. Configuração específica de otimização de dados. Se houver menos arquivos de exclusão associados a um arquivo de dados do que o limite, o arquivo de dados não será regravado. Isso permite acumular mais arquivos de exclusão para cada arquivo de dados a fim de gerar economia de custos. O padrão é 2. Essa propriedade se aplica apenas a tabelas do Iceberg. Para ter mais informações, consulte [Otimizar tabelas do Iceberg](querying-iceberg-data-optimization.md).
Exemplo:
```
WITH (optimize_rewrite_delete_file_threshold = 2)
```
`vacuum_min_snapshots_to_keep = [int]`
Opcional. Configuração específica para vácuo. O número mínimo de snapshots mais recentes a serem retidos. O padrão é um. Essa propriedade se aplica apenas a tabelas do Iceberg. Para ter mais informações, consulte [VACUUM](vacuum-statement.md).
A propriedade `vacuum_min_snapshots_to_keep` requer a versão 3 do mecanismo do Athena.
Exemplo:
```
WITH (vacuum_min_snapshots_to_keep = 1)
```
`vacuum_max_snapshot_age_seconds = [long]`
Opcional. Configuração específica para vácuo. Um período, em segundos, que representa o tempo pelo qual os snapshots serão retidos. O padrão é 432 mil (5 dias). Essa propriedade se aplica apenas a tabelas do Iceberg. Para ter mais informações, consulte [VACUUM](vacuum-statement.md).
A propriedade `vacuum_max_snapshot_age_seconds` requer a versão 3 do mecanismo do Athena.
Exemplo:
```
WITH (vacuum_max_snapshot_age_seconds = 432000)
```
`write_compression = [compression_format]`
O tipo de compactação a ser usado para qualquer formato de armazenamento que permita que a compactação seja especificada. O valor `compression_format` especifica a compactação a ser usada quando os dados são gravados na tabela. Você pode especificar a compactação para os formatos de arquivo `TEXTFILE`, `JSON`, `PARQUET` e `ORC`.
Por exemplo, se a propriedade `format` especificar `PARQUET` como o formato de armazenamento, o valor para `write_compression` especificará o formato de compactação para Parquet. Nesse caso, especificar um valor para `write_compression` é equivalente a especificar um valor para `parquet_compression`.
Por exemplo, se a propriedade `format` especificar `ORC` como o formato de armazenamento, o valor para `write_compression` especificará o formato de compactação para ORC. Nesse caso, especificar um valor para `write_compression` é equivalente a especificar um valor para `orc_compression`.
Não é possível especificar várias propriedades da tabela de formato de compactação na mesma consulta CTAS. Por exemplo, não é possível especificar `write_compression` e `parquet_compression` na mesma consulta. O mesmo se aplica a `write_compression` e `orc_compression`. Para obter mais informações sobre os tipos de compactação suportados para cada formato de arquivo, consulte [Usar compactação no Athena](compression-formats.md).
`orc_compression = [compression_format]`
O tipo de compactação a ser usado para o formato de arquivo `ORC` quando dados `ORC` são gravados na tabela. Por exemplo, `WITH (orc_compression = 'ZLIB')`. As partes dentro do arquivo `ORC` (exceto o `ORC` Postscript) são compactadas usando a compactação que você especificar. Se não especificada, a compactação ZLIB será usada por padrão para `ORC`.
Para consistência, recomendamos que você use a propriedade `write_compression` em vez de `orc_compression`. Use a propriedade `format` para especificar o formato de armazenamento como `ORC` e, em seguida, use a propriedade `write_compression` para especificar o formato de compactação que `ORC` usará.
`parquet_compression = [compression_format]`
O tipo de compactação a ser usado para o formato de arquivo Parquet quando os dados do Parquet são gravados na tabela. Por exemplo, `WITH (parquet_compression = 'SNAPPY')`. Essa compactação é aplicada a blocos de colunas em arquivos Parquet. Se não especificada, a compactação GZIP será usada por padrão para Parquet.
Para consistência, recomendamos que você use a propriedade `write_compression` em vez de `parquet_compression`. Use a propriedade `format` para especificar o formato de armazenamento como `PARQUET` e, em seguida, use a propriedade `write_compression` para especificar o formato de compactação que `PARQUET` usará.
`compression_level = [compression_level]`
O nível de compressão a ser usado. Essa propriedade se aplica apenas à compressão ZSTD. Os valores possíveis são de 1 a 22. O valor padrão é 3. Para ter mais informações, consulte [Usar níveis de compactação ZSTD](compression-support-zstd-levels.md).
## Exemplos
Para obter exemplos de consultas CTAS, consulte os seguintes recursos.
+ [Exemplos de consultas CTAS](ctas-examples.md)
+ [Usar CTAS e INSERT INTO para ETL e análise de dados](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/) (Usar instruções CTAS com o Amazon Athena para reduzir custos e melhorar a performance)
+ [Usar CTAS e INSERT INTO para resolver o limite de 100 partições](ctas-insert-into.md)
# CREATE VIEW e da CREATE PROTECTED MULTI DIALECT VIEW
Uma visualização é uma tabela lógica que pode ser referenciada por futuras consultas. As visualizações não contêm todos os dados e não gravam dados. Em vez disso, a consulta especificada pela exibição é executada sempre que você fizer referência à exibição por outra consulta.
+ `CREATE VIEW` cria uma visualização do Athena a partir de uma consulta `SELECT` especificada. As visualizações do Athena funcionam dentro do Athena. Para obter mais informações sobre visualizações do Athena, consulte [Trabalhar com visualizações](views.md).
+ `CREATE PROTECTED MULTI DIALECT VIEW` cria uma visualização do AWS Glue Data Catalog no AWS Glue Data Catalog. As visualizações do AWS Glue Data Catalog fornecem uma visualização única e comum entre os Serviços da AWS como o Amazon Athena e o Amazon Redshift. Para obter mais informações sobre visualizações do AWS Glue Data Catalog, consulte [Usar visualizações do Catálogo de Dados no Athena](views-glue.md).
## CREATE VIEW
Cria uma visualização para uso no Athena.
### Resumo
```
CREATE [ OR REPLACE ] VIEW view_name AS query
```
A cláusula `OR REPLACE` opcional permite atualizar a exibição existente substituindo-a Para obter mais informações, consulte [Criar visualizações](views-console.md#creating-views).
### Exemplos
Para criar uma exibição `test` a partir da tabela `orders`, use uma consulta semelhante à seguinte:
```
CREATE VIEW test AS
SELECT
orderkey,
orderstatus,
totalprice / 2 AS half
FROM orders;
```
Para criar uma exibição `orders_by_date` a partir da tabela `orders`, use a seguinte consulta:
```
CREATE VIEW orders_by_date AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
GROUP BY orderdate;
```
Para atualizar uma exibição existente, use um exemplo semelhante ao seguinte:
```
CREATE OR REPLACE VIEW test AS
SELECT orderkey, orderstatus, totalprice / 4 AS quarter
FROM orders;
```
Para obter mais informações sobre o uso de visualizações do Athena, consulte [Trabalhar com visualizações](views.md).
## CREATE PROTECTED MULTI DIALECT VIEW
Cria uma visualização do AWS Glue Data Catalog no AWS Glue Data Catalog. Uma visualização do Catálogo de Dados corresponde a um esquema de visualização única que funciona entre o Athena e outros mecanismos de SQL, como o Amazon Redshift e o Amazon EMR.
### Sintaxe
```
CREATE [ OR REPLACE ] PROTECTED MULTI DIALECT VIEW view_name
SECURITY DEFINER
[ SHOW VIEW JSON ]
AS query
```
**OR REPLACE**
(Opcional) Atualiza a visualização existente substituindo-a. Uma visualização do Catálogo de Dados não poderá ser substituída se dialetos SQL de outros mecanismos estiverem presentes na visualização. Se o mecanismo de chamada tiver o único dialeto SQL presente na visualização, a visualização poderá ser substituída.
**PROTECTED**
Palavra-chave obrigatória. Especifica que a visualização está protegida contra vazamentos de dados. As visualizações do Catálogo de Dados podem ser criadas somente como uma visualização `PROTECTED`.
**MULTI DIALECT**
Especifica que a visualização oferece suporte aos dialetos SQL de diferentes mecanismos de consulta e, portanto, que ela pode ser lida por esses mecanismos.
**SECURITY DEFINER**
Especifica que a semântica do programador está em vigor para essa visualização. A semântica do programador significa que as permissões de leitura efetivas nas tabelas subjacentes pertencem à entidade principal ou ao perfil que definiu a visualização, e não à entidade principal que executa a leitura.
**SHOW VIEW JSON**
(Opcional) Retorna o JSON para a especificação da visualização do Catálogo de Dados sem realmente criar uma visualização. Essa opção “dry-run” é útil quando você deseja validar o SQL para a visualização e retornar os metadados da tabela que serão usados pelo AWS Glue.
### Exemplo
O exemplo apresentado a seguir cria a visualização `orders_by_date` do Catálogo de Dados com base em uma consulta na tabela `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 obter mais informações sobre o uso de visualizações do AWS Glue Data Catalog, consulte [Usar visualizações do Catálogo de Dados no Athena](views-glue.md).
# DESCRIBE
Mostra uma ou mais colunas, inclusive de partição, da tabela especificada. Esse comando é útil para examinar os atributos de colunas complexas.
## Resumo
```
DESCRIBE [EXTENDED | FORMATTED] [db_name.]table_name [PARTITION partition_spec] [col_name ( [.field_name] | [.'$elem$'] | [.'$key$'] | [.'$value$'] )]
```
**Importante**
A sintaxe para essa declaração é `DESCRIBE table_name`, não `DESCRIBE TABLE table_name`. O uso da última sintaxe resulta na mensagem de erro FAILED: SemanticException [Error 10001]: Table not found table (FALHA: SemanticException [Erro 10001]: Tabela não encontrada).
## Parâmetros
**[EXTENDED \$1 FORMATTED]**
Determina o formato da saída. A omissão desses parâmetros mostra nomes de colunas e os tipos de dados correspondentes, incluindo colunas de partição, em formato tabular. Especificando `FORMATTED` não só mostra nomes de colunas e tipos de dados em formato tabular, mas também traz informações detalhadas de tabela e armazenamento. `EXTENDED` mostra informações de coluna e tipos de dados em formato tabular, além de metadados detalhados para a tabela no formato serializado Thrift. Esse formato é menos legível e ajuda principalmente na depuração.
**[PARTITION partition\$1spec]**
Se incluído, lista os metadados para a partição especificada por `partition_spec`, onde `partition_spec` está no 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 a coluna e os atributos a serem examinados. Você pode especificar `.field_name` para um elemento de uma struct, `'$elem$'` para um elemento de matriz, `'$key$'` para uma chave de mapa e `'$value$'` para um valor de mapa. Você pode especificar isso de maneira recursiva para explorar mais a coluna complexa.
### Exemplos
```
DESCRIBE orders
```
```
DESCRIBE FORMATTED mydatabase.mytable PARTITION (part_col = 100) columnA;
```
A consulta e a saída a seguir mostram informações de coluna e tipos de dados de uma tabela de `impressions` baseada em dados de amostra do 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
```
Os exemplos de consulta e saída a seguir mostram o resultado da mesma tabela quando a opção `FORMATTED` é usada.
```
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
```
Os exemplos de consulta e saída a seguir mostram o resultado da mesma tabela quando a opção `EXTENDED` é usada. As informações detalhadas da tabela são geradas em uma única linha, mas foram formatadas aqui para facilitar a leitura.
```
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
Mostra a lista de colunas para a visualização do Athena ou do AWS Glue Data Catalog especificada. Útil para examinar os atributos de uma visualização complexa.
Para visualizações do Catálogo de Dados, a saída da instrução é controlada pelo controle de acesso do Lake Formation e mostra somente as colunas às quais o chamador tem acesso.
## Resumo
```
DESCRIBE [db_name.]view_name
```
## Exemplo
```
DESCRIBE orders
```
Consulte também [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [SHOW VIEWS](show-views.md) e [DROP VIEW](drop-view.md).
# DROP DATABASE
Remove o banco de dados nomeado do catálogo. Se o banco de dados incluir tabelas, você deverá descartá-las antes de executar `DROP DATABASE` ou usar a cláusula `CASCADE`. O uso de `DATABASE` e `SCHEMA` é intercambiável. Eles significam a mesma coisa.
## Resumo
```
DROP {DATABASE | SCHEMA} [IF EXISTS] database_name [RESTRICT | CASCADE]
```
## Parâmetros
**[SE EXISTIR]**
Fará o erro ser suprimido se `database_name` não existir.
**[RESTRICT\$1CASCADE]**
Determina como tabelas dentro de `database_name` são consideradas durante a operação `DROP`. Se você especificar `RESTRICT`, o banco de dados não será ignorado se ele contiver tabelas. Esse é o comportamento padrão. Especificar `CASCADE` faz o banco de dados e todas as tabelas serem ignorados.
## Exemplos
```
DROP DATABASE clickstreams;
```
```
DROP SCHEMA IF EXISTS clickstreams CASCADE;
```
**nota**
Quando você tenta eliminar um banco de dados cujo nome tem caracteres especiais (p. ex., `my-database`), você pode receber uma mensagem de erro. Para resolver esse problema, tente delimitar o nome do banco de dados com caracteres de crase (`). Para obter mais informações sobre nomenclatura de bancos de dados no Athena, consulte [Nomear bancos de dados, tabelas e colunas](tables-databases-columns-names.md).
# DROP TABLE
Remove a definição da tabela de metadados da tabela nomeada `table_name`. Quando você descarta uma tabela externa, os dados subjacentes permanecem intactos.
## Resumo
```
DROP TABLE [IF EXISTS] table_name
```
## Parâmetros
**[ IF EXISTS ]**
Fará o erro ser suprimido se `table_name` não existir.
## Exemplos
```
DROP TABLE fulfilled_orders
```
```
DROP TABLE IF EXISTS fulfilled_orders
```
Ao usar o editor de consultas do console do Athena para descartar uma tabela que tenha caracteres especiais diferentes de sublinhados (\$1), use acentos graves, como no exemplo a seguir.
```
DROP TABLE `my-athena-database-01.my-athena-table`
```
Ao usar o conector JDBC para soltar uma tabela que tenha caracteres especiais, os caracteres de acento grave não são necessários.
```
DROP TABLE my-athena-database-01.my-athena-table
```
# DROP VIEW
Descarta (exclui) uma visualização existente do Athena ou do AWS Glue Data Catalog. A cláusula `IF EXISTS` opcional faz com que o erro seja suprimido se a exibição não existir.
Para visualizações do Catálogo de Dados, descarta a visualização somente se a sintaxe da visualização do Athena (dialeto) estiver presente na visualização do Catálogo de Dados. Por exemplo, se um usuário chamar `DROP VIEW` a partir do Athena, a visualização será descartada somente se o dialeto do Athena existir na visualização. Caso contrário, haverá falha na operação. O descarte de visualizações do Catálogo de Dados requer permissões de administrador ou definidor de visualizações do Lake Formation.
Para ter mais informações, consulte [Trabalhar com visualizações](views.md) e [Usar visualizações do Catálogo de Dados no Athena](views-glue.md).
## Resumo
```
DROP VIEW [ IF EXISTS ] view_name
```
## Exemplos
```
DROP VIEW orders_by_date
```
```
DROP VIEW IF EXISTS orders_by_date
```
Consulte também [CREATE VIEW e da 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) e [DESCRIBE VIEW](describe-view.md).
# MSCK REPAIR TABLE
Use o comando `MSCK REPAIR TABLE` para atualizar os metadados no catálogo depois de adicionar partições compatíveis com o Hive.
O comando `MSCK REPAIR TABLE` verifica um sistema de arquivos, como o Amazon S3, para procurar se há partições compatíveis com o Hive que foram adicionadas ao sistema de arquivos após a criação da tabela. `MSCK REPAIR TABLE` compara as partições nos metadados da tabela e as partições no S3. Se houver novas partições no local do S3 que você especificou quando criou a tabela, ele as adicionará aos metadados e à tabela do Athena.
Quando você adiciona partições físicas, os metadados no catálogo ficam inconsistentes com o layout dos dados no sistema de arquivos, e é necessário adicionar informações sobre as novas partições ao catálogo. Para atualizar os metadados, execute `MSCK REPAIR TABLE` para que você possa consultar os dados nas novas partições do Athena.
**nota**
`MSCK REPAIR TABLE` somente adiciona partições aos metadados, não as remove. Para remover partições dos metadados depois que elas foram excluídas manualmente do Amazon S3, execute o comando `ALTER TABLE table-name DROP PARTITION`. Para obter mais informações, consulte [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md).
## Considerações e limitações
Ao usar `MSCK REPAIR TABLE`, lembre-se dos seguintes pontos:
+ É possível que demore algum tempo para adicionar todas as partições. Se expirar, essa operação estará em um estado incompleto, quando somente algumas partições são adicionadas ao catálogo. Você deve executar `MSCK REPAIR TABLE` na mesma tabela até que todas as partições sejam adicionadas. Para obter mais informações, consulte [Particionar dados](partitions.md).
+ Para as partições que não são compatíveis com o Hive, use [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) para carregá-las para poder consultar os dados.
+ Os locais das partições que serão usados com o Athena devem aplicar o protocolo do `s3` (por exemplo, `s3://amzn-s3-demo-bucket/folder/`). No Athena, os locais que usam outros protocolos (por exemplo, `s3a://bucket/folder/`) resultam em falhas nas consultas `MSCK REPAIR TABLE` quando elas são executadas nas tabelas que os contêm.
+ Como `MSCK REPAIR TABLE` verifica uma pasta e as subpastas para encontrar um esquema de partição correspondente, mantenha os dados das tabelas separadas em hierarquias de pastas separadas. Por exemplo, suponha que você tenha dados na tabela 1 em `s3://amzn-s3-demo-bucket1` e dados na tabela 2 em `s3://amzn-s3-demo-bucket1/table-2-data`. Se ambas as tabelas forem particionadas por string, `MSCK REPAIR TABLE` adicionará as partições da tabela 2 à tabela 1. Para evitar isso, use estruturas de pastas separadas, como `s3://amzn-s3-demo-bucket1` e `s3://amzn-s3-demo-bucket2`. Observe que esse comportamento é consistente com o Amazon EMR e o Apache Hive.
+ Devido a um problema conhecido, a `MSCK REPAIR TABLE` falha silenciosamente quando os valores da partição contêm dois pontos (`:`), por exemplo, quando o valor da partição é um carimbo de data/hora. Como solução alternativa, use [ALTER TABLE ADD PARTITION](alter-table-add-partition.md).
+ `MSCK REPAIR TABLE` X não adiciona nomes de colunas de partição que começam com um sublinhado (\$1). Para contornar essa limitação, utilize [ALTER TABLE ADD PARTITION](alter-table-add-partition.md).
## Resumo
```
MSCK REPAIR TABLE table_name
```
## Exemplos
```
MSCK REPAIR TABLE orders;
```
## Solução de problemas
Depois que você executar `MSCK REPAIR TABLE`, se o Athena não adicionar as partições à tabela no AWS Glue Data Catalog, verifique o seguinte:
+ **Acesso do AWS Glue**: certifique-se de que o perfil do AWS Identity and Access Management (IAM) tenha uma política que permita a ação `glue:BatchCreatePartition`. Para obter mais informações, consulte [Permitir glue:BatchCreatePartition na política do IAM](#msck-repair-table-troubleshooting-allow-gluebatchcreatepartition-in-the-policy) adiante neste documento.
+ **Acesso do Amazon S3**: certifique-se de que o perfil tenha uma política com permissões suficientes para acessar o Amazon S3, incluindo a ação [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 ver um exemplo das ações do Amazon S3 que devem ser permitidas, consulte o exemplo de política de bucket em [Configurar o acesso entre contas do Athena aos buckets do Amazon S3](cross-account-permissions.md).
+ **Uso de maiúsculas e minúsculas em chaves de objeto do Amazon S3**: verifique se o caminho do Amazon S3 está em letras minúsculas em vez de minúsculas concatenadas (por exemplo, `userid` em vez de `userId`) ou use `ALTER TABLE ADD PARTITION` para especificar os nomes de chaves de objeto. Para obter mais informações, consulte [Alterar ou redefinir o caminho do Amazon S3](#msck-repair-table-troubleshooting-change-or-redefine-the-amazon-s3-path) adiante neste documento.
+ **Tempo limite de consulta esgotado**: é melhor usar `MSCK REPAIR TABLE` para criar uma tabela pela primeira vez ou quando há incerteza sobre a paridade entre os dados e os metadados da partição. Se você usa `MSCK REPAIR TABLE` para adicionar novas partições com frequência (por exemplo, diariamente) e sempre enfrenta problemas de tempo limite de consulta esgotado, considere usar [ALTER TABLE ADD PARTITION](alter-table-add-partition.md).
+ **Partições ausentes do sistema de arquivos**: se você excluir manualmente uma partição do Amazon S3 e executar `MSCK REPAIR TABLE`, poderá receber a mensagem de erro: Partições ausentes do sistema de arquivos. Isso ocorre porque `MSCK REPAIR TABLE` não remove partições obsoletas dos metadados da tabela. Em vez disso, execute [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md) para remover as partições excluídas dos metadados da tabela. Do mesmo modo, veja que [SHOW PARTITIONS](show-partitions.md) lista apenas as partições nos metadados, e não as partições no sistema de arquivos.
+ **"Erro “NullPointerException name is null” (O nome de NullPointerException é nulo**
Se você usar a operação de API do AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html) ou o modelo [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) do CloudFormation para criar uma tabela para uso no Athena sem especificar a propriedade `TableType` e, depois, executar uma consulta DDL, como `SHOW CREATE TABLE` ou `MSCK REPAIR TABLE`, poderá receber a mensagem de erro FALHA: o nome de NullPointerException é nulo.
Para resolver o erro, especifique um valor para o atributo [TableInput](https://docs.aws.amazon.com/glue/latest/webapi/API_TableInput.html) `TableType` como parte da chamada de API `CreateTable` do AWS Glue ou do [modelo do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html). Os valores possíveis para `TableType` são `EXTERNAL_TABLE` ou `VIRTUAL_VIEW`.
Esse requisito é aplicado somente quando você cria uma tabela usando a operação de API do AWS Glue `CreateTable` ou o modelo do `AWS::Glue::Table`. Se você criar uma tabela do Athena usando uma instrução DDL ou um crawler do AWS Glue, a propriedade `TableType` será definida automaticamente para você.
As seções a seguir apresentam mais detalhes.
### Permitir glue:BatchCreatePartition na política do IAM
Analise as políticas do IAM vinculadas ao perfil que você usa para executar `MSCK REPAIR TABLE`. Quando você [usa o AWS Glue Data Catalog com o Athena](data-sources-glue.md), a política do IAM deve permitir a ação `glue:BatchCreatePartition`. Para ver um exemplo de uma política do IAM que permite a ação `glue:BatchCreatePartition`, consulte [AWSPolítica gerenciada pela : AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy).
### Alterar ou redefinir o caminho do Amazon S3
Se uma ou mais chaves de objeto no caminho do Amazon S3 estiverem em letras minúsculas concatenadas em vez de minúsculas, talvez `MSCK REPAIR TABLE` não adicione as partições ao AWS Glue Data Catalog. Por exemplo, se o caminho do Amazon S3 incluir o nome da chave do objeto `userId`, talvez as seguintes partições não sejam adicionadas ao 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 esse problema, execute um dos seguintes procedimentos:
+ Use letras minúsculas em vez de minúsculas concatenadas ao criar chaves de objeto do 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 o local, como no seguinte exemplo:
```
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/'
```
Embora os nomes de chave de objeto do Amazon S3 possam usar letras maiúsculas, os nomes de bucket do Amazon S3 devem estar sempre em letras minúsculas. Para obter mais informações, consulte [Diretrizes de nomeação de chave de objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines) e [Regras de nomeação de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) no *Guia do usuário do Amazon S3*.
# SHOW COLUMNS
Mostra somente os nomes das colunas para uma tabela especificada única, uma visualização do Athena ou uma visualização do Catálogo de Dados. Para obter informações mais detalhadas sobre visualizações do Athena, consulte o AWS Glue Data Catalog. Para obter informações e exemplos, consulte as seguintes seções do tópico [Consultar o AWS Glue Data Catalog](querying-glue-catalog.md):
+ Para visualizar os metadados de coluna, como tipo de dados, consulte [Listar ou pesquisar colunas de uma tabela ou visualização especificada](querying-glue-catalog-listing-columns.md).
+ Para visualizar todas as colunas de todas as tabelas em um banco de dados específico no `AwsDataCatalog`, consulte [Listar ou pesquisar colunas de uma tabela ou visualização especificada](querying-glue-catalog-listing-columns.md).
+ Para visualizar todas as colunas de todas as tabelas em todos os bancos de dados no `AwsDataCatalog`, consulte [Listar todas as colunas de todas as tabelas](querying-glue-catalog-listing-all-columns-for-all-tables.md).
+ Para visualizar as colunas que tabelas específicas têm em comum em um banco de dados, consulte [Listar colunas que tabelas específicas têm em comum](querying-glue-catalog-listing-columns-in-common.md).
Para visualizações do Catálogo de Dados, a saída da instrução é controlada pelo controle de acesso do Lake Formation e mostra somente as colunas às quais o chamador tem acesso.
## Resumo
```
SHOW COLUMNS {FROM|IN} database_name.table_or_view_name
```
```
SHOW COLUMNS {FROM|IN} table_or_view_name [{FROM|IN} database_name]
```
É possível usar as palavras-chave `FROM` e `IN` de forma intercambiável. Se *table\$1or\$1view\$1name* ou *database\$1name* tiver caracteres especiais como hifens, coloque-os entre acentos graves (por exemplo, ``my-database`.`my-table``). Não coloque *table\$1or\$1view\$1name* ou *database\$1name* entre aspas simples ou duplas. Atualmente, o uso de `LIKE` e das expressões de correspondência de padrões não é permitido.
## Exemplos
Os exemplos equivalentes a seguir mostram as colunas da tabela `orders` no banco de dados `customers`. Os dois primeiros exemplos consideram o banco de dados `customers` como o atual.
```
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
Analisa uma tabela existente chamada `table_name` para gerar a consulta que a criou.
## Resumo
```
SHOW CREATE TABLE [db_name.]table_name
```
## Parâmetros
**TABLE [db\$1name.]table\$1name**
O parâmetro `db_name` é opcional. Se omitido, o contexto assumirá como padrão o banco de dados atual.
O nome da tabela é obrigatório.
## Exemplos
```
SHOW CREATE TABLE orderclickstoday;
```
```
SHOW CREATE TABLE `salesdata.orderclickstoday`;
```
## Solução de problemas
Se você usar a operação de API do AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html) ou o modelo [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) do CloudFormation para criar uma tabela para uso no Athena sem especificar a propriedade `TableType` e, depois, executar uma consulta DDL, como `SHOW CREATE TABLE` ou `MSCK REPAIR TABLE`, poderá receber a mensagem de erro FALHA: o nome de NullPointerException é nulo.
Para resolver o erro, especifique um valor para o atributo [TableInput](https://docs.aws.amazon.com/glue/latest/webapi/API_TableInput.html) `TableType` como parte da chamada de API `CreateTable` do AWS Glue ou do [modelo do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html). Os valores possíveis para `TableType` são `EXTERNAL_TABLE` ou `VIRTUAL_VIEW`.
Esse requisito é aplicado somente quando você cria uma tabela usando a operação de API do AWS Glue `CreateTable` ou o modelo do `AWS::Glue::Table`. Se você criar uma tabela do Athena usando uma instrução DDL ou um crawler do AWS Glue, a propriedade `TableType` será definida automaticamente para você.
# SHOW CREATE VIEW
Mostra a instrução SQL que criou a visualização específica do Athena ou do Catálogo de Dados. O SQL retornado mostra a sintaxe de criação de visualização usada no Athena. A chamada a `SHOW CREATE VIEW` em visualizações do Catálogo de Dados requer permissões de administrador ou definidor de visualizações do Lake Formation.
## Resumo
```
SHOW CREATE VIEW view_name
```
## Exemplos
```
SHOW CREATE VIEW orders_by_date
```
Consulte também [CREATE VIEW e da CREATE PROTECTED MULTI DIALECT VIEW](create-view.md) e [DROP VIEW](drop-view.md).
# SHOW DATABASES
Lista todos os bancos de dados definidos na metastore. Você pode usar `DATABASES` ou `SCHEMAS`. Eles significam a mesma coisa.
O equivalente programático de `SHOW DATABASES` é a ação da API [ListDatabases](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListDatabases.html) do Athena. O método equivalente em AWS SDK para Python (Boto3) é [list\$1databases](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/athena/client/list_databases.html).
## Resumo
```
SHOW {DATABASES | SCHEMAS} [LIKE 'regular_expression']
```
## Parâmetros
**[LIKE '*regular\$1expression*']**
Filtra a lista de bancos de dados aos correspondentes à `regular_expression` especificada por você. Para correspondência de caracteres curinga, você pode usar a combinação `.*`, que associa qualquer caractere zero a multiplicações ilimitadas.
## Exemplos
```
SHOW SCHEMAS;
```
```
SHOW DATABASES LIKE '.*analytics';
```
# SHOW PARTITIONS
Lista todas as partições em uma tabela do Athena em uma ordem não classificada.
## Resumo
```
SHOW PARTITIONS table_name
```
+ Para exibir as partições em uma tabela e listá-las em uma ordem específica, consulte a seção [Listar partições de uma tabela específica](querying-glue-catalog-listing-partitions.md) na página [Consultar o AWS Glue Data Catalog](querying-glue-catalog.md).
+ Para visualizar o conteúdo de uma partição, consulte a seção [Consultar os dados](partitions.md#query-the-data) na página [Particionar dados](partitions.md).
+ `SHOW PARTITIONS` não lista as partições que foram projetadas pelo Athena, mas que não estão registradas no catálogo do AWS Glue. Para obter informações sobre a projeção de partições, consulte [Usar projeção de partições com o Amazon Athena](partition-projection.md).
+ `SHOW PARTITIONS` lista as partições nos metadados, não as partições no sistema de arquivos real. Para atualizar os metadados depois que você excluir manualmente as partições do Amazon S3, execute [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md).
## Exemplos
A consulta de exemplo a seguir mostra as partições da tabela `flight_delays_csv`, que inclui os dados da tabela de voos do Departamento de Transporte dos EUA. Para obter mais informações sobre a tabelas `flight_delays_csv` de exemplo, consulte [Lazy Simple SerDe para arquivos CSV, TSV e com delimitação personalizada](lazy-simple-serde.md). A tabela está particionada por ano.
```
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
...
```
A consulta de exemplo a seguir mostra as partições da tabela `impressions`, que inclui amostra de dados de navegação na Web. Para obter mais informações sobre a tabelas `impressions` de exemplo, consulte [Particionar dados](partitions.md). A tabela está particionada pela coluna `dt` (data e hora).
```
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
...
```
### Listar partições em ordem de classificação
Para ordenar as partições na lista de resultados, use a sintaxe `SELECT` a seguir, em vez de `SHOW PARTITIONS`.
```
SELECT * FROM database_name."table_name$partitions" ORDER BY column_name
```
A consulta a seguir mostra a lista das partições do exemplo de `flight_delays_csv`, mas agora classificada.
```
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 obter mais informações, consulte a seção [Listar partições de uma tabela específica](querying-glue-catalog-listing-partitions.md) na página [Consultar o AWS Glue Data Catalog](querying-glue-catalog.md).
# SHOW TABLES
Lista todas as tabelas base e exibe em um banco de dados.
**nota**
O parâmetro [StatementType](https://docs.aws.amazon.com/athena/latest/APIReference/API_QueryExecution.html#athena-Type-QueryExecution-StatementType) para `SHOW TABLES` na operação da API [GetQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetQueryExecution.html) é categorizado como `UTILITY`, e não `DDL`.
## Resumo
```
SHOW TABLES [IN database_name] ['regular_expression']
```
## Parâmetros
**[IN database\$1name]**
Especifica o `database_name` de quais tabelas serão listadas. Se omitido, o banco de dados do contexto atual é assumido.
`SHOW TABLES` poderá falhar se `database_name` usar um [caractere sem suporte](tables-databases-columns-names.md), como o hífen. Como solução alternativa, tente delimitar o nome do banco de dados com acentos graves.
**['regular\$1expression']**
Filtra a lista de tabelas às correspondentes ao `regular_expression` especificado por você. Para indicar qualquer caractere nas tabelas `AWSDataCatalog`, você pode usar a expressão curinga `*` ou `.*`. Para bancos de dados do Apache Hive, use a expressão curinga `.*`. Para indicar uma opção entre caracteres, use o caractere `|`.
## Exemplos
**Example – mostrar todas as tabelas no banco de dados `sampledb`**
```
SHOW TABLES IN sampledb
```
`Results`
```
alb_logs
cloudfront_logs
elb_logs
flights_2016
flights_parquet
view_2016_flights_dfw
```
**Example – mostrar os nomes de todas as tabelas em `sampledb` que incluem a palavra “flights”**
```
SHOW TABLES IN sampledb '*flights*'
```
`Results`
```
flights_2016
flights_parquet
view_2016_flights_dfw
```
**Example – mostrar os nomes de todas as tabelas em `sampledb` que terminam com a palavra “logs”**
```
SHOW TABLES IN sampledb '*logs'
```
`Results`
```
alb_logs
cloudfront_logs
elb_logs
```
# SHOW TBLPROPERTIES
Lista as propriedades da tabela nomeada.
## Resumo
```
SHOW TBLPROPERTIES table_name [('property_name')]
```
## Parâmetros
**[('property\$1name')]**
Se incluído, somente o valor da propriedade chamada `property_name` será listado.
## Exemplos
```
SHOW TBLPROPERTIES orders;
```
```
SHOW TBLPROPERTIES orders('comment');
```
# SHOW VIEWS
Lista as visualizações do Athena ou do Catálogo de Dados em uma lista de valores do tipo `STRING`. Cada valor na lista é o nome de uma visualização no banco de dados especificado ou no banco de dados atual se você omitir o nome do banco de dados. Use a cláusula `LIKE` opcional com uma expressão regular para restringir a lista de nomes de exibições. Para visualizações do Catálogo de Dados, lista somente as visualizações que usam a sintaxe do Athena SQL. Outras visualizações do Catálogo de Dados são filtradas.
## Resumo
```
SHOW VIEWS [IN database_name] [LIKE 'regular_expression']
```
### Parâmetros
**[IN database\$1name]**
Especifica o `database_name` do qual as exibições serão listadas. Se omitido, o banco de dados do contexto atual é assumido.
**[LIKE 'regular\$1expression']**
Filtra a lista de exibições às correspondentes ao `regular_expression` especificado por você. Somente o caractere curinga `*`, o que indica qualquer caractere, ou `|`, o que indica uma escolha entre caracteres, podem ser usados.
## Exemplos
```
SHOW VIEWS
```
```
SHOW VIEWS IN marketing_analytics LIKE 'orders*'
```
Consulte também [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [DESCRIBE VIEW](describe-view.md) e [DROP VIEW](drop-view.md).