# Solucionar problemas no Athena
<a name="troubleshooting-athena"></a>

A equipe do Athena reuniu as seguintes informações de solução de problemas dos clientes. Elas não abrangem tudo, mas incluem orientações sobre alguns problemas comuns de performance, tempo limite e falta de memória.

**Topics**
+ [CREATE TABLE AS SELECT (CTAS)](#troubleshooting-athena-create-table-as-select-ctas)
+ [Problemas no arquivo de dados](#troubleshooting-athena-data-file-issues)
+ [Tabelas do Linux Foundation Delta Lake](#troubleshooting-athena-delta-lake-tables)
+ [Consultas federadas](#troubleshooting-athena-federated-queries)
+ [Erros relacionados ao JSON](#troubleshooting-athena-json-related-errors)
+ [MSCK REPAIR TABLE](#troubleshooting-athena-msck-repair-table)
+ [Problemas de saída](#troubleshooting-athena-output-issues)
+ [Problemas do Parquet](#troubleshooting-athena-parquet-issues)
+ [Problemas de particionamento](#troubleshooting-athena-partitioning-issues)
+ [Permissões](#troubleshooting-athena-permissions)
+ [Problemas de sintaxe da consulta](#troubleshooting-athena-query-syntax-issues)
+ [Problemas de tempo limite de consulta](#troubleshooting-athena-query-timeout-issues)
+ [Problemas de controle de utilização](#troubleshooting-athena-throttling-issues)
+ [Visualizações](#troubleshooting-athena-views)
+ [Grupos de trabalho](#troubleshooting-athena-workgroups)
+ [Recursos adicionais](#troubleshooting-athena-additional-resources)
+ [Catálogo de erros do Athena](error-reference.md)

## CREATE TABLE AS SELECT (CTAS)
<a name="troubleshooting-athena-create-table-as-select-ctas"></a>

### Dados duplicados ocorrem com instruções CTAS simultâneas
<a name="troubleshooting-athena-duplicated-data-occurs-with-concurrent-ctas-statements"></a>

O Athena não mantém a validação simultânea de CTAS. Verifique se não há instruções CTAS duplicadas para o mesmo local ao mesmo tempo. Mesmo se uma instrução CTAS ou INSERT INTO falhar, os dados órfãos podem permanecer no local de dados especificado na instrução.

### HIVE\$1TOO\$1MANY\$1OPEN\$1PARTITIONS
<a name="troubleshooting-athena-ctas-hive-too-many-open-partitions"></a>

Ao usar uma instrução CTAS para criar uma tabela com mais de 100 partições, você pode receber o erro HIVE\$1TOO\$1MANY\$1OPEN\$1PARTITIONS: Exceeded limit of 100 open writers for partitions/buckets (Limite excedido de 100 gravadores abertos para partições/buckets). Para contornar essa limitação, é possível usar uma instrução CTAS e uma série de instruções `INSERT INTO` que criam ou inserem até 100 partições cada. Para obter mais informações, consulte [Usar CTAS e INSERT INTO para resolver o limite de 100 partições](ctas-insert-into.md).

## Problemas no arquivo de dados
<a name="troubleshooting-athena-data-file-issues"></a>

### O Athena não pode ler arquivos ocultos
<a name="troubleshooting-athena-athena-cannot-read-hidden-files"></a>

O Athena trata os arquivos de origem que começam com sublinhado (\$1) ou ponto (.) como ocultos. Para contornar essa limitação, renomeie os arquivos.

### O Athena lê arquivos que eu excluí do crawler do AWS Glue
<a name="troubleshooting-athena-athena-reads-files-that-i-excluded-from-the-glue-crawler"></a>

O Athena não reconhece os [padrões de exclusão](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude) que você especifica para um crawler do AWS Glue. Por exemplo, se você tem um bucket do Amazon S3 com os arquivos `.csv` e `.json` e exclui os arquivos `.json` do crawler, o Athena consulta os dois grupos de arquivos. Para evitar isso, coloque os arquivos que você deseja excluir em um local diferente.

### HIVE\$1BAD\$1DATA: erro ao analisar o valor do campo
<a name="troubleshooting-athena-hive_bad_data-error-parsing-field-value"></a>

Esse erro pode ocorrer nos seguintes cenários:
+ O tipo de dados definido na tabela não corresponde aos dados de origem ou um único campo contém tipos de dados diferentes. Para ver as resoluções sugeridas, consulte [My Amazon Athena query fails with the error “HIVE\$1BAD\$1DATA: Error parsing field value for field x: For input string: ‘12312845691’”](https://aws.amazon.com/premiumsupport/knowledge-center/athena-hive-bad-data-parsing-field-value/) (Minha consulta do Amazon Athena falha com o erro “HIVE\$1BAD\$1DATA: erro ao analisar o valor do campo x: para a string de entrada: ‘12312845691’”) na Central de Conhecimento da AWS.
+ Há valores nulos em um campo de número inteiro. Uma solução alternativa é criar a coluna com os valores nulos como `string` e usar `CAST` para converter o campo em uma consulta especificando um valor padrão de `0` para nulos. Para obter mais informações, consulte [When I query CSV data in Athena, I get the error “HIVE\$1BAD\$1DATA: Error parsing field value “ for field x: For input string: ”””](https://aws.amazon.com/premiumsupport/knowledge-center/athena-hive-bad-data-error-csv/) (Quando consulto dados CSV no Athena, aparece o erro “HIVE\$1BAD\$1DATA: erro ao analisar o valor do campo x: para a string de entrada: ‘’') na Central de Conhecimento da AWS.

### HIVE\$1CANNOT\$1OPEN\$1SPLIT: erro ao abrir divisão do Hive s3://amzn-s3-demo-bucket
<a name="troubleshooting-athena-hive_cannot_open_split-error-opening-hive-split-s3bucket-name"></a>

Esse erro pode ocorrer quando você consulta um prefixo de bucket do Amazon S3 que tenha um grande número de objetos. Para obter mais informações, consulte [Como resolver o erro "HIVE\$1CANNOT\$1OPEN\$1SPLIT: Error opening Hive split s3://amzn-s3-demo-bucket/: Slow down" no Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/hive-cannot-open-split-503-athena/) na Central de Conhecimento da AWS.

### HIVE\$1CURSOR\$1ERROR: com.amazonaws.services.s3.model.AmazonS3Exception: a chave especificada não existe
<a name="troubleshooting-athena-hive_cursor_error-com.amazonaws.services.s3.model.amazons3exception-the-specified-key-does-not-exist"></a>

Geralmente, esse erro ocorre quando um arquivo é removido durante a execução de uma consulta. Execute novamente a consulta ou examine o fluxo de trabalho para ver se outro trabalho ou processo está modificando os arquivos durante a execução da consulta.

### HIVE\$1CURSOR\$1ERROR: fim inesperado do stream de entrada
<a name="troubleshooting-athena-hive_cursor_error-unexpected-end-of-input-stream"></a>

Essa mensagem indica que o arquivo está corrompido ou vazio. Verifique a integridade do arquivo e execute a consulta novamente.

### HIVE\$1FILESYSTEM\$1ERROR: Incorrect fileSize *1234567* for file (HIVE\$1FILESYSTEM\$1ERROR: tamanho de arquivo 1234567 incorreto para o arquivo)
<a name="troubleshooting-athena-hive_filesystem_error-incorrect-file-size"></a>

Essa mensagem pode ocorrer quando um arquivo foi alterado entre o planejamento da consulta e a execução da consulta. Geralmente ocorre quando um arquivo no Amazon S3 é substituído no local (por exemplo, um `PUT` é executado em uma chave em que um objeto já existe). O Athena não suporta a exclusão ou a substituição do conteúdo de um arquivo quando uma consulta está em execução. Para evitar esse erro, agende trabalhos que substituam ou excluam arquivos para quando consultas não são executadas ou simplesmente grave os dados em novos arquivos ou partições.

### HIVE\$1UNKNOWN\$1ERROR: não é possível criar o formato de entrada
<a name="troubleshooting-athena-hive_unknown_error-unable-to-create-input-format"></a>

Esse erro pode ser resultado de problemas como estes:
+ O crawler do AWS Glue não conseguiu classificar o formato de dados
+ Certas propriedades de definição de tabela do AWS Glue estão vazias
+ O Athena não é compatível com o formato de dados dos arquivos no Amazon S3

Para obter mais informações, consulte [Como resolvo o erro “não é possível criar o formato de entrada” no Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-unable-to-create-input-format/) (em inglês) ou assista ao [vídeo](https://www.youtube.com/watch?v=CGzXW3hRa8g) na Central de Conhecimento da AWS.

### O local do S3 especificado para salvar os resultados das consultas é inválido.
<a name="troubleshooting-athena-the-s3-location-provided-to-save-your-query-results-is-invalid."></a>

Verifique se você especificou um local válido do S3 para os resultados das consultas. Para obter mais informações, consulte [Especificar um local para resultados de consultas](query-results-specify-location.md)[Trabalhar com resultados de consultas e consultas recentes](querying.md) no tópico.

## Tabelas do Linux Foundation Delta Lake
<a name="troubleshooting-athena-delta-lake-tables"></a>

### O esquema das tabelas do Delta Lake não está sincronizado
<a name="troubleshooting-athena-delta-lake-table-schema-out-of-sync"></a>

Quando você consulta uma tabela do Delta Lake que tem um esquema no AWS Glue, pode receber a seguinte mensagem de erro:

```
INVALID_GLUE_SCHEMA: Delta Lake table schema in Glue does not match the most recent schema of the 
Delta Lake transaction log. Please ensure that you have the correct schema defined in Glue.
```

O esquema pode ficar desatualizado se for modificado no AWS Glue depois de ser adicionado ao Athena. Para atualizar o esquema, faça uma das etapas a seguir:
+ No AWS Glue, execute o [crawler do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html).
+ No Athena, [descarte a tabela ](drop-table.md) e torne a [criá-la](create-table.md).
+ Adicione manualmente as colunas que estiverem faltando, usando a instrução [ALTER TABLE ADD COLUMNS](alter-table-add-columns.md) no Athena ou [editando o esquema da tabela no AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html#console-tables-details). 

## Consultas federadas
<a name="troubleshooting-athena-federated-queries"></a>

### Tempo limite ao chamar ListTableMetadata
<a name="troubleshooting-athena-federated-queries-list-table-metadata-timeout"></a>

Uma chamada para a API [ListTableMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListTableMetadata.html) pode atingir o tempo limite se houver muitas tabelas na fonte de dados, se a fonte de dados estiver lenta ou se a rede estiver lenta. Para solucionar esse problema, experimente as seguintes etapas:
+ **Verifique o número de tabelas**: se você tiver mais de 1.000 tabelas, tente reduzir esse número. Para uma resposta mais rápida de `ListTableMetadata`, recomendamos ter menos de 1000 tabelas por catálogo.
+ **Verifique a configuração do Lambda** — Monitorar o comportamento da função do Lambda é fundamental. Ao usar catálogos federados, examine os logs de execução da função do Lambda. Com base nos resultados, ajuste os valores de memória e tempo limite. Para identificar possíveis problemas de tempo limite, revise sua configuração do Lambda. Para obter mais informações, consulte [Configurar o tempo de limite da função (console)](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html#configuration-timeout-console) no *Guia do desenvolvedor do AWS Lambda*.
+ **Verifique os logs da fonte de dados federada** — Examine os logs e as mensagens de erro da fonte de dados federada para ver se há algum problema ou erro. Os logs podem fornecer informações valiosas sobre a causa do tempo limite.
+ **Use `StartQueryExecution` para buscar os metadados**: se você tiver mais de 1.000 tabelas, recuperar os metadados usando o conector federado pode levar mais tempo que o esperado. Como a natureza assíncrona de [StartQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html) garante que o Athena execute a consulta da maneira ideal, considere usar `StartQueryExecution` como alternativa a `ListTableMetadata`. Os exemplos da AWS CLI a seguir mostram como `StartQueryExecution` pode ser usado em vez de `ListTableMetadata` para obter todos os metadados das tabelas do catálogo de dados.

  Primeiro, execute uma consulta que obtenha todas as tabelas, como no exemplo a seguir.

  ```
  aws athena start-query-execution --region us-east-1 \
  --query-string "SELECT table_name FROM information_schema.tables LIMIT 50" \
  --work-group "your-work-group-name"
  ```

  Em seguida, recupere os metadados de uma tabela individual, como no exemplo a seguir.

  ```
  aws athena start-query-execution --region us-east-1 \
  --query-string "SELECT * FROM information_schema.columns \
  WHERE table_name = 'your-table-name' AND \
  table_catalog = 'your-catalog-name'" \
  --work-group "your-work-group-name"
  ```

  O tempo necessário para obter os resultados depende do número de tabelas do catálogo.

Para obter mais informações sobre como solucionar problemas de consultas federadas, acesse [Common\$1Problems](https://github.com/awslabs/aws-athena-query-federation/wiki/Common_Problems) na seção awslabs/aws-athena-query-federation do GitHub ou consulte a documentação de cada [conector de fonte de dados do Athena](connectors-available.md).

## Erros relacionados ao JSON
<a name="troubleshooting-athena-json-related-errors"></a>

### Erros de dados NULL ou incorretos ao tentar ler dados JSON
<a name="troubleshooting-athena-null-or-incorrect-data-errors-when-trying-to-read-json-data"></a>

Os erros de dados NULL ou incorretos quando você tenta ler dados JSON podem ter diversas causas. Para identificar as linhas que estão causando erros quando você usa o OpenX SerDe, defina `ignore.malformed.json` como `true`. Registros malformados serão retornados como NULL. Para obter mais informações, consulte [Recebo erros ao tentar ler dados JSON no Amazon Athena](https://aws.amazon.com/premiumsupport/knowledge-center/error-json-athena/) (em inglês) ou assista ao [vídeo](https://youtu.be/ME7Pv1qPFLM) na Central de Conhecimento da AWS.

### HIVE\$1BAD\$1DATA: erro ao analisar o valor do campo 0: java.lang.String não pode ser convertido em org.openx.data.jsonserde.json.JSONObject
<a name="troubleshooting-athena-hive-bad-data-openx-json-serde"></a>

O [OpenX JSON SerDe](openx-json-serde.md) gera esse erro quando não consegue analisar uma coluna em uma consulta do Athena. Isso poderá acontecer se você definir uma coluna como `map` ou `struct`, mas os dados subjacentes são, na verdade, `string`, `int` ou outro tipo primitivo.

### HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON object - JSONException: Duplicate key (HIVE\$1CURSOR\$1ERROR: a linha não é um objeto JSON válido - JSONException: chave duplicada)
<a name="troubleshooting-athena-hive_cursor_error-row-is-not-a-valid-json-object---jsonexception-duplicate-key"></a>

Esse erro ocorre ao usar o Athena para consultar recursos de AWS Config que têm várias etiquetas com o mesmo nome com letras maiúsculas e minúsculas diferentes. A solução é executar `CREATE TABLE` usando `WITH SERDEPROPERTIES 'case.insensitive'='false'` e mapear os nomes. Para obter mais informações sobre `case.insensitive` e mapeamento, consulte [Bibliotecas SerDe JSON](json-serde.md). Para obter mais informações, consulte [Como resolvo o erro “HIVE\$1CURSOR\$1ERROR: a linha não é um objeto JSON válido - JSONException: chave duplicada” ao ler arquivos do AWS Config no Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/json-duplicate-key-error-athena-config/) no Centro de Conhecimento da AWS.

### Mensagens HIVE\$1CURSOR\$1ERROR com JSON formatado para impressão
<a name="troubleshooting-athena-json-serde-hive-cursor-error"></a>

As bibliotecas [Hive JSON SerDe](hive-json-serde.md) e [OpenX JSON SerDe](openx-json-serde.md) esperam que cada documento JSON esteja em uma única linha de texto, sem caracteres de terminação de linha separando os campos no registro. Se o texto JSON estiver formatado para impressão, você poderá receber uma mensagem de erro como HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object (HIVE\$1CURSOR\$1ERROR: a linha não é um objeto JSON válido) ou HIVE\$1CURSOR\$1ERROR: JsonParseException: Unexpected end-of-input: expected close marker for OBJECT (HIVE\$1CURSOR\$1ERROR: JSONParseException: Fim de entrada inesperado: marcador de fechamento esperado para OBJECT) quando tentar consultar a tabela após criá-la. Para obter mais informações, consulte [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) (Arquivos de dados do JSON) na documentação do OpenX SerDe no GitHub.

### Vários registros JSON retornam SELECT COUNT de 1
<a name="troubleshooting-athena-multiple-json-records-return-a-select-count-of-1"></a>

Se você usa [OpenX JSON SerDe](openx-json-serde.md), verifique se os registros estão separados por um caractere de nova linha. Para obter mais informações, consulte [A consulta SELECT COUNT no Amazon Athena retorna somente um registro, embora o arquivo JSON de entrada tenha vários registros](https://aws.amazon.com/premiumsupport/knowledge-center/select-count-query-athena-json-records/) (em inglês) na Central de Conhecimento da AWS.

### Não é possível consultar uma tabela criada por um crawler do AWS Glue que usa um classificador JSON personalizado
<a name="troubleshooting-athena-cannot-query-a-table-created-by-a-glue-crawler-that-uses-a-custom-json-classifier"></a>

O mecanismo do Athena não é compatível com [classificadores JSON personalizados](https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html#custom-classifier-json). Para resolver esse problema, crie uma nova tabela sem o classificador personalizado. Para transformar o JSON, você pode usar CTAS ou criar uma visualização. Por exemplo, se você trabalha com arrays, pode usar a opção UNNEST para nivelar o JSON. Outra opção é usar um trabalho ETL AWS Glue que aceita o classificador personalizado, converter os dados em parquet no Amazon S3 e consultá-los no Athena.

## MSCK REPAIR TABLE
<a name="troubleshooting-athena-msck-repair-table"></a>

Para obter informações sobre problemas relacionados a MSCK REPAIR TABLE, consulte as seções [Considerações e limitações](msck-repair-table.md#msck-repair-table-considerations) e [Solução de problemas](msck-repair-table.md#msck-repair-table-troubleshooting) da página [MSCK REPAIR TABLE](msck-repair-table.md).

## Problemas de saída
<a name="troubleshooting-athena-output-issues"></a>

### Não é possível verificar/criar bucket de saída
<a name="troubleshooting-athena-unable-to-verifycreate-output-bucket"></a>

Esse erro poderá ocorrer se o local de resultados das consultas especificado não existir ou se as permissões apropriadas não estiverem presentes. Para obter mais informações, consulte [How do I resolve the “unable to verify/create output bucket” error in Amazon Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-output-bucket-error/) (Como resolvo o erro “Não é possível verificar/criar bucket de saída” no Amazon Athena?) na Central de Conhecimento da AWS.

### O resultado de TIMESTAMP é vazio
<a name="troubleshooting-athena-timestamp-result-is-empty"></a>

O Athena requer o formato de TIMESTAMP do Java. Para obter mais informações, consulte [Quando consulto uma tabela no Amazon Athena, o resultado de TIMESTAMP é vazio](https://aws.amazon.com/premiumsupport/knowledge-center/query-table-athena-timestamp-empty/) (em inglês) na Central de Conhecimento da AWS.

### Armazenar saída de consulta do Athena em um formato diferente de CSV
<a name="troubleshooting-athena-store-athena-query-output-in-a-format-other-than-csv"></a>

Por padrão, o Athena só gera arquivos de saída no formato CSV. Para gerar os resultados de uma consulta `SELECT` em outro formato, você pode usar a instrução `UNLOAD`. Para obter mais informações, consulte [UNLOAD](unload.md). Você também pode usar uma consulta do CTAS que usa a [propriedade de tabela](create-table-as.md#ctas-table-properties) `format` para configurar o formato de saída. Ao contrário de `UNLOAD`, a técnica CTAS requer a criação de uma tabela. Para obter mais informações, consulte [Como posso armazenar uma saída de consulta do Athena em um formato diferente de CSV, como um formato compactado?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-query-output-different-format/) (em inglês) na Central de Conhecimento da AWS.

### O local do S3 especificado para salvar os resultados das consultas é inválido
<a name="troubleshooting-athena-the-s3-location-provided-to-save-your-query-results-is-invalid"></a>

Você poderá receber essa mensagem de erro se o local do bucket de saída não estiver na mesma região onde você executa sua consulta. Para evitar isso, especifique um local de resultados de consulta na região onde você executa a consulta. Para obter as etapas, consulte [Especificar um local para resultados de consultas](query-results-specify-location.md).

## Problemas do Parquet
<a name="troubleshooting-athena-parquet-issues"></a>

### org.apache.parquet.io.GroupColumnIO não pode ser convertido em org.apache.parquet.io.PrimitiveColumnIO
<a name="troubleshooting-athena-org.apache.parquet.io.groupcolumnio-cannot-be-cast-to-org.apache.parquet.io.primitivecolumnio"></a>

Esse erro é causado por uma incompatibilidade de esquema do parquet. Uma coluna com um tipo não primitivo (por exemplo, `array`) foi declarado como um tipo primitivo (por exemplo, `string`) no AWS Glue. Para solucionar esse problema, verifique o esquema de dados nos arquivos e compare-o com o esquema declarado no AWS Glue.

### Problemas estatísticos do Parquet
<a name="troubleshooting-athena-parquet-statistics-issues"></a>

Quando você lê dados Parquet, pode receber mensagens de erro como as seguintes:

```
HIVE_CANNOT_OPEN_SPLIT: Index x out of bounds for length y
HIVE_CURSOR_ERROR: Failed to read x bytes
HIVE_CURSOR_ERROR: FailureException at Malformed input: offset=x
HIVE_CURSOR_ERROR: FailureException at java.io.IOException: 
can not read class org.apache.parquet.format.PageHeader: Socket is closed by peer.
```

Para contornar esse problema, use a instrução [CREATE TABLE](create-table.md) ou [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md) para definir a `parquet.ignore.statistics` propriedade Parquet SerDe como `true`, como nos exemplos a seguir. 

Exemplo de CREATE TABLE

```
...
ROW FORMAT SERDE  
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe' 
WITH SERDEPROPERTIES ('parquet.ignore.statistics'='true')  
STORED AS PARQUET 
...
```

Exemplo de ALTER TABLE

```
ALTER TABLE ... SET TBLPROPERTIES ('parquet.ignore.statistics'='true')
```

Para obter mais informações sobre o Parquet Hive SerDe, consulte [Parquet SerDe](parquet-serde.md). 

## Problemas de particionamento
<a name="troubleshooting-athena-partitioning-issues"></a>

### MSCK REPAIR TABLE não remove partições obsoletas
<a name="troubleshooting-athena-msck-repair-table-does-not-remove-stale-partitions"></a>

Se você excluir uma partição manualmente no 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 as partições obsoletas dos metadados da tabela. Use [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md) para remover as partições obsoletas manualmente. Para obter mais informações, consulte a seção “Solução de problemas” do tópico [MSCK REPAIR TABLE](msck-repair-table.md).

### Falha em MSCK REPAIR TABLE
<a name="troubleshooting-athena-msck-repair-table-failure"></a>

Quando uma grande quantidade de partições (por exemplo, mais de 100.000) são associadas a uma tabela específica, pode haver falha em `MSCK REPAIR TABLE` devido às limitações de memória. Para contornar esse limite, use [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) no lugar dele.

### MSCK REPAIR TABLE detecta partições, mas não as adiciona ao AWS Glue
<a name="troubleshooting-athena-msck-repair-table-detects-partitions-but-doesnt-add-them-to-glue"></a>

Esse problema poderá ocorrer se um caminho do Amazon S3 estiver em maiúsculas e minúsculas, em vez de apenas minúsculas, ou se uma política do IAM não permitir a ação `glue:BatchCreatePartition`. Para obter mais informações, consulte [MSCK REPAIR TABLE detecta partições no Athena, mas não as adiciona ao AWS Glue Data Catalog](https://aws.amazon.com/premiumsupport/knowledge-center/athena-aws-glue-msck-repair-table/) (em inglês) na Central de Conhecimento da AWS.

### Os intervalos de projeção de partições com o formato de data dd-MM-yyyy-HH-mm-ss ou yyyy-MM-dd não funcionam
<a name="troubleshooting-athena-partition-projection-ranges-with-the-date-format-of-dd-mm-yyyy-hh-mm-ss-or-yyyy-mm-dd-do-not-work"></a>

Para funcionar corretamente, o formato de data deve ser definido como `yyyy-MM-dd HH:00:00`. Para obter mais informações, consulte a publicação do Stack Overflow [Athena Partition Projection Not Working As Expected](https://stackoverflow.com/questions/63943920/athena-partition-projection-not-working-as-expected) (A projeção de partições do Athena não está funcionado como esperado).

### PARTITITION BY não é compatível com o tipo BIGINT
<a name="troubleshooting-athena-partition-by-doesnt-support-the-bigint-type"></a>

Converta o tipo de dados em `string` e tente novamente.

### Não há partições significativas disponíveis
<a name="troubleshooting-athena-no-meaningful-partitions-available"></a>

Geralmente, essa mensagem de erro significa que as configurações de partição foram corrompidas. Para resolver esse problema, descarte a tabela e crie outra com novas partições.

### A projeção de partições não funciona em conjunto com as partições do intervalo
<a name="troubleshooting-athena-partition-projection-does-not-work-in-conjunction-with-range-partitions"></a>

Verifique se a unidade do intervalo de tempo [projection.*<columnName>*.interval.unit](partition-projection-supported-types.md#partition-projection-date-type) corresponde ao delimitador das partições. Por exemplo, se as partições forem delimitadas por dias, uma unidade de intervalo de horas não funcionará.

### Erro de projeção de partição quando o intervalo é especificado por hífen
<a name="troubleshooting-athena-partition-projection-range-issue-with-hyphen"></a>

Especificar a propriedade da tabela `range` com um hífen em vez de uma vírgula produz um erro como INVALID\$1TABLE\$1PROPERTY: For input string: "*number*-*number*". Certifique-se de que os valores do intervalo estejam separados por uma vírgula, não por um hífen. Para obter mais informações, consulte [Tipo integer](partition-projection-supported-types.md#partition-projection-integer-type).

### HIVE\$1UNKNOWN\$1ERROR: não é possível criar o formato de entrada
<a name="troubleshooting-athena-hive_unknown_error-unable-to-create-input-format-1"></a>

Uma ou mais das partições do Glue são declaradas em um formato diferente porque cada uma tem um formato próprio de entrada específico que é independente. Verifique como suas partições estão definidas no AWS Glue.

### HIVE\$1PARTITION\$1SCHEMA\$1MISMATCH
<a name="troubleshooting-athena-hive_partition_schema_mismatch"></a>

Se o esquema de uma partição for diferente do esquema da tabela, uma consulta poderá falhar com a mensagem de erro HIVE\$1PARTITION\$1SCHEMA\$1MISMATCH.

Para cada tabela no AWS Glue Data Catalog que tenha colunas de partição, o esquema é armazenado no nível de tabela e para cada partição individual dentro da tabela. O esquema de partições é preenchido por um crawler do AWS Glue com base no exemplo de dados lido dentro da partição.

Quando o Athena executa uma consulta, ela valida o esquema da tabela e o esquema de todas as partições necessárias para a consulta. A validação compara os tipos de dados da coluna em ordem e verifica se eles correspondem às colunas que se sobrepõem. Isso evita operações inesperadas, como adicionar ou remover colunas no meio de uma tabela. Se o Athena detectar que o esquema de uma partição é diferente do esquema da tabela, o Athena talvez não possa processar a consulta e emita uma falha com `HIVE_PARTITION_SCHEMA_MISMATCH`.

Existem algumas maneiras de corrigir esse problema. Primeiro, se os dados tiverem sido adicionados acidentalmente, você poderá remover os arquivos de dados que causam a diferença no esquema, ignorar a partição e rastrear novamente os dados. Segundo, você pode descartar a partição individual e executar `MSCK REPAIR` no Athena para recriá-la usando o esquema da tabela. Essa segunda opção só funcionará se você tiver certeza de que o esquema aplicado continuará lendo os dados corretamente.

### A tabela SemanticException não foi particionada, mas a especificação da partição existe
<a name="troubleshooting-athena-semanticexception-table-is-not-partitioned-but-partition-spec-exists"></a>

Esse erro pode ocorrer quando não há partições definidas na instrução `CREATE TABLE`. Para obter mais informações, consulte [Como solucionar o erro "FALHA: a tabela SemanticException não foi particionada, mas a especificação da partição existe" no Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-failed-semanticexception-table/) (em inglês) na Central de Conhecimento da AWS.

### Arquivos de zero byte no formato `_$folder$`
<a name="troubleshooting-athena-alter-table-add-partition-zero-byte-folder-files"></a>

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` em sua instrução `ALTER TABLE ADD PARTITION`, assim:

```
ALTER TABLE table_name ADD IF NOT EXISTS PARTITIION […]
```

### Zero registro retornado dos dados particionados
<a name="troubleshooting-athena-zero-records-returned-from-partitioned-data"></a>

Esse problema pode ocorrer por vários motivos. Para saber as causas possíveis e as resoluções, consulte [Criei uma tabela no Amazon Athena com partições definidas, mas quando consulto a tabela, zero registro é retornado](https://aws.amazon.com/premiumsupport/knowledge-center/athena-empty-results/) (em inglês) na Central de Conhecimento da AWS.

Consulte também [HIVE\$1TOO\$1MANY\$1OPEN\$1PARTITIONS](#troubleshooting-athena-ctas-hive-too-many-open-partitions).

## Permissões
<a name="troubleshooting-athena-permissions"></a>

### Erro de acesso negado ao consultar o Amazon S3
<a name="troubleshooting-athena-access-denied-error-when-querying-amazon-s3"></a>

Isso pode ocorrer quando você não tem permissão para ler os dados no bucket, permissão para gravar no bucket de resultados ou o caminho do Amazon S3 contém um endpoint de região como `us-east-1.amazonaws.com`. Para obter mais informações, consulte [When I run an Athena query, I get an “access denied” error](https://aws.amazon.com/premiumsupport/knowledge-center/access-denied-athena/) (Quando executo uma consulta do Athena, recebo um erro “Acesso negado”) na Central de Conhecimento da AWS.

### Acesso negado com o erro de código de status 403 ao executar consultas DDL em dados criptografados no Amazon S3
<a name="troubleshooting-athena-access-denied-error-when-querying-amazon-s3-encrypted"></a>

Você poderá receber a mensagem de erro Acesso negado (serviço: Amazon S3; código de status: 403; código de erro: AccessDenied; ID da solicitação: *<request\$1id>*) se as seguintes condições forem verdadeiras:

1. Execute uma consulta DDL, como `ALTER TABLE ADD PARTITION` ou `MSCK REPAIR TABLE`.

1. Você tem um bucket com a [criptografia padrão](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-bucket-encryption.html) configurada para usar `SSE-S3`.

1. O bucket também tem uma política como a seguinte que força as solicitações `PutObject` a especificar os cabeçalhos `PUT` `"s3:x-amz-server-side-encryption": "true"` e `"s3:x-amz-server-side-encryption": "AES256"`.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Deny",
               "Principal": "*",
               "Action": "s3:PutObject",
               "Resource": "arn:aws:s3:::<resource-name>/*",
               "Condition": {
                   "Null": {
                       "s3:x-amz-server-side-encryption": "true"
                   }
               }
           },
           {
               "Effect": "Deny",
               "Principal": "*",
               "Action": "s3:PutObject",
               "Resource": "arn:aws:s3:::<resource-name>/*",
               "Condition": {
                   "StringNotEquals": {
                       "s3:x-amz-server-side-encryption": "AES256"
                   }
               }
           }
       ]
   }
   ```

------

Nesse caso, a solução recomendada é remover a política de bucket, como a que foi mostrada acima, quando a criptografia padrão do bucket já está presente.

### Acesso negado com código de status 403 ao consultar um bucket do Amazon S3 em outra conta
<a name="troubleshooting-athena-access-denied-with-status-code-403-when-querying-an-amazon-s3-bucket-in-another-account"></a>

Esse erro pode ocorrer quando você tenta consultar logs escritos por outro AWS service (Serviço da AWS) e a segunda conta é o proprietária do bucket, mas não tem os objetos no bucket. Para obter mais informações, consulte [I get the Amazon S3 exception “access denied with status code: 403” in Amazon Athena when I query a bucket in another account](https://aws.amazon.com/premiumsupport/knowledge-center/athena-access-denied-status-code-403/) (Vejo a exceção do Amazon S3 “Acesso negado com código de status: 403” no Amazon Athena quando consulto um bucket em outra conta) na Central de Conhecimento da AWS.

### Usar credenciais de função do IAM para se conectar ao driver JDBC do Athena
<a name="troubleshooting-athena-use-IAM-role-credentials-to-connect-to-the-athena-jdbc-driver"></a>

Você pode recuperar as credenciais temporárias de uma função para autenticar o [conector JDBC ao Athena](connect-with-jdbc.md). As credenciais temporárias têm uma vida útil máxima de 12 horas. Para obter mais informações, consulte [Como posso usar minhas credenciais de função do IAM ou alternar para outra função do IAM ao me conectar ao Athena usando o driver JDBC?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-iam-jdbc-driver/) (em inglês) na Central de Conhecimento da AWS.

### O descritor de armazenamento de tabela obrigatório não está preenchido
<a name="troubleshooting-athena-access-denied-table-storage"></a>

Isso pode ocorrer quando você tenta consultar ou visualizar uma tabela para a qual não tem permissões. Para isso, a solução recomendada é conceder permissões `DESCRIBE` e `SELECT` sobre os recursos via AWS Lake Formation. Se seu recurso for compartilhado entre contas, onde o recurso original existe na conta A e você deseja consultar um recurso vinculado na conta B, é necessário garantir que seu perfil tenha permissão `DESCRIBE` sobre o recurso original na conta A e permissão `SELECT` sobre o recurso vinculado na conta B.

## Problemas de sintaxe da consulta
<a name="troubleshooting-athena-query-syntax-issues"></a>

### FAILED: NullPointerException name is null (FALHA: o nome de NullPointerException é nulo)
<a name="troubleshooting-athena-nullpointerexception-name-is-null"></a>

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ê. 

### Função não registrada
<a name="troubleshooting-athena-function-not-registered"></a>

Esse erro ocorre quando você tenta usar uma função que o Athena não permite. Para ver a lista de funções permitidas pelo Athena, consulte [Funções no Amazon Athena](functions.md) ou execute a instrução `SHOW FUNCTIONS` no editor de consultas. Você também pode escrever sua própria [User Defined Function (UDF – Função definida pelo usuário)](querying-udf.md). Para obter mais informações, consulte [Como resolver o erro de sintaxe “função não registrada” no Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-syntax-function-not-registered/) (em inglês) na Central de Conhecimento da AWS.

### Exceções GENERIC\$1INTERNAL\$1ERROR
<a name="troubleshooting-athena-generic-internal-error"></a>

`GENERIC_INTERNAL_ERROR`As exceções podem ter várias causas, incluindo as seguintes:
+ **GENERIC\$1INTERNAL\$1ERROR: Null** (GENERIC\$1INTERNAL\$1ERROR: nulo): você pode ver essa exceção em qualquer uma das seguintes condições:
  + Existe discrepância de esquema entre o tipo de dados de uma coluna na definição de tabela e o tipo de dados real do conjunto de dados.
  + Você está executando uma consulta (CTAS) `CREATE TABLE AS SELECT` com uma sintaxe inexata.
+ **GENERIC\$1INTERNAL\$1ERROR: parent builder is null** (GENERIC\$1INTERNAL\$1ERROR: o criador pai é nulo): você pode ver essa exceção quando consulta uma tabela de colunas com tipo de dado `array` e está usando a biblioteca OpenCSVSerde. O formato OpenCSVSerde não suporta o tipo de dados `array`.
+ **GENERIC\$1INTERNAL\$1ERROR: Value exceeds MAX\$1INT** (GENERIC\$1INTERNAL\$1ERROR: o valor excede MAX\$1INT): você pode ver essa exceção quando a coluna de dados de origem é definida com o tipo de dados `INT` e tem um valor numérico maior que 2.147.483.647.
+ **GENERIC\$1INTERNAL\$1ERROR: Value exceeds MAX\$1BYTE** (GENERIC\$1INTERNAL\$1ERROR: o valor excede MAX\$1BYTE): você pode ver essa exceção quando a coluna de dados de origem tem um valor numérico que excede o tamanho permitido para o tipo de dados`BYTE`. O tipo de dado `BYTE` é equivalente a `TINYINT`. `TINYINT` é um número inteiro com sinal de 8 bits no formato de complemento de dois com um valor mínimo de -128 e um valor máximo de 127.
+ **GENERIC\$1INTERNAL\$1ERROR: Number of partition values does not match number of filters** (GENERIC\$1INTERNAL\$1ERROR: o número de partições não corresponde ao número de filtros): você pode ver essa exceção se tiver partições inconsistentes nos dados do Amazon Simple Storage Service (Amazon S3). Você pode ter partições inconsistentes em qualquer uma das seguintes condições:
  + As partições no Amazon S3 foram alteradas (exemplo: novas partições foram adicionadas).
  + O número de colunas de partição na tabela não corresponde às dos metadados da partição.

Para obter informações mais detalhadas sobre cada um desses erros, consulte [How do I resolve the error “GENERIC\$1INTERNAL\$1ERROR" when I query a table in Amazon Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-generic-internal-error/) na Central de Conhecimento da AWS.

### O número de grupos correspondentes não corresponde ao número de colunas
<a name="troubleshooting-athena-number-of-matching-groups-doesnt-match-the-number-of-columns"></a>

Esse erro ocorre ao usar [Regex SerDe](regex-serde.md) em uma instrução CREATE TABLE e o número de grupos correspondentes de regex não corresponde ao número de colunas que você especificou para a tabela. Para obter mais informações, consulte [How do I resolve the RegexSerDe error “number of matching groups doesn't match the number of columns” in Amazon Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/regexserde-error-athena-matching-groups/) (Como resolvo o erro RegexSerDe “O número de grupos correspondentes não corresponde ao número de colunas” no Amazon Athena?) na Central de Conhecimento da AWS.

### queryString não atende à restrição: o tamanho do membro deve ser menor ou igual a 262144
<a name="troubleshooting-athena-querystring-failed-to-satisfy-constraint-member-must-have-length-less-than-or-equal-to-262144"></a>

O tamanho máximo da string de consulta no Athena (262.144 bytes) não é uma cota ajustável. O AWS Support não pode aumentar a cota para você, mas você pode tentar resolver o problema dividindo as consultas longas em tamanhos menores. Para obter mais informações, consulte [Como posso aumentar o tamanho máximo da string de consulta no Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-query-string-length/) (em inglês) na Central de Conhecimento da AWS.

### SYNTAX\$1ERROR: a coluna não pode ser resolvida
<a name="troubleshooting-athena-syntax_error-column-cannot-be-resolved"></a>

Esse erro pode ocorrer quando você consulta uma tabela criada por um crawler do AWS Glue de um arquivo CSV codificado em UTF-8 que tem uma Byte Order Mark (BOM – Marca de ordem de byte). O AWS Glue não reconhece as BOMs e as altera para pontos de interrogação, que o Amazon Athena não reconhece. A solução é remover o ponto de interrogação no Athena ou no AWS Glue.

### Excesso de argumentos para chamada de função
<a name="troubleshooting-athena-too-many-arguments"></a>

No mecanismo Athena versão 3, as funções não podem receber mais de 127 argumentos. Essa limitação é proposital. Se você usar uma função com mais de 127 parâmetros, ocorrerá uma mensagem de erro como esta:

TOO\$1MANY\$1ARGUMENTS: linha *nnn*:*nn*: excesso de argumentos para a chamada da função *function\$1name*().

Para resolver esse problema, utilize menos parâmetros por chamada de função.

## Problemas de tempo limite de consulta
<a name="troubleshooting-athena-query-timeout-issues"></a>

Se você tiver erros de tempo limite nas suas consultas do Athena, verifique os logs do CloudTrail. O tempo limite das consultas pode ser atingido devido ao controle de utilização das APIs do AWS Glue ou do Lake Formation. Quando esses erros ocorrem, as mensagens de erro correspondentes podem indicar um problema de tempo limite de consulta em vez de um problema de controle de utilização. Para solucionar o problema, você pode verificar os logs do CloudTrail antes de entrar em contato com o Suporte. Para obter mais informações, consulte [Consultar logs do AWS CloudTrail](cloudtrail-logs.md) e [Registrar em log as chamadas de API do Amazon Athena com o AWS CloudTrail](monitor-with-cloudtrail.md).

Vaja informações sobre problemas de tempo limite de consulta com as consultas federadas quando você chama a API `ListTableMetadata` em [Tempo limite ao chamar ListTableMetadata](#troubleshooting-athena-federated-queries-list-table-metadata-timeout).

## Problemas de controle de utilização
<a name="troubleshooting-athena-throttling-issues"></a>

Se suas consultas excederem os limites dos serviços dependentes, como o Amazon S3, AWS KMS, AWS Glue ou AWS Lambda, as mensagens a seguir podem ser esperadas. Para resolver esses problemas, reduza o número de chamadas simultâneas originadas da mesma conta.


****  

| Serviço | A mensagem de erro | 
| --- | --- | 
| AWS Glue | AWSGlueException: Rate exceeded. (AWSGlueException: Taxa excedida. | 
| AWS KMS | Você excedeu a taxa na qual pode chamar o KMS. Reduza a frequência de suas chamadas. | 
| AWS Lambda |  Rate exceeded (Taxa excedida TooManyRequestsException  | 
| Amazon S3 | AmazonS3Exception: Please reduce your request rate. (AmazonS3Exception: Reduza sua taxa de solicitação. | 

Para obter informações sobre formas de evitar o controle de utilização do Amazon S3 ao usar o Athena, consulte [Prevenir o controle de utilização do Amazon S3](performance-tuning-s3-throttling.md).

## Visualizações
<a name="troubleshooting-athena-views"></a>

### Visualizações criadas no shell do Apache Hive não funcionam no Athena
<a name="troubleshooting-athena-views-created-in-hive-shell-do-not-work-in-athena"></a>

Devido a suas implementações fundamentalmente diferentes, as visualizações criadas no shell do Apache Hive não são compatíveis com o Athena. Para resolver esse problema, recrie as visualizações no Athena.

### A visualização é obsoleta e deve ser recriada
<a name="troubleshooting-athena-view-is-stale-it-must-be-re-created"></a>

Você pode receber esse erro se a tabela subjacente a uma visualização foi alterada ou descartada. A resolução é recriar a visualização. Para obter mais informações, consulte [How can I resolve the “view is stale; it must be re-created” error in Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/athena-view-is-stale-error/) (Como posso resolver o erro “A visualização é obsoleta e deve ser recriada” no Athena?) na Central de Conhecimento da AWS.

## Grupos de trabalho
<a name="troubleshooting-athena-workgroups"></a>

Para obter informações sobre como solucionar problemas de grupos de trabalho, consulte [Solucionar erros de grupo de trabalho](workgroups-troubleshooting.md).

## Recursos adicionais
<a name="troubleshooting-athena-additional-resources"></a>

As páginas a seguir apresentam mais informações para solucionar problemas com o Amazon Athena.
+ [Catálogo de erros do Athena](error-reference.md)
+ [Service Quotas](service-limits.md)
+ [Considerações e limitações das consultas SQL no Amazon Athena](other-notable-limitations.md)
+ [DDL incompatível](unsupported-ddl.md)
+ [Nomear bancos de dados, tabelas e colunas](tables-databases-columns-names.md)
+ [Tipos de dados no Amazon Athena](data-types.md)
+ [Escolha de um SerDe para seus dados](supported-serdes.md)
+ [Usar compactação no Athena](compression-formats.md)
+ [Escapar palavras-chave reservadas em consultas](reserved-words.md)
+ [Solucionar erros de grupo de trabalho](workgroups-troubleshooting.md)

Os seguintes recursos da AWS também podem ajudar:
+  [Tópicos do Athena na Central de Conhecimento da AWS](https://aws.amazon.com/premiumsupport/knowledge-center/#Amazon_Athena) 
+  [Perguntas do Amazon Athena em AWS re:Post](https://repost.aws/tags/TA78iVOM7gR62_QqDe2-CmiA/amazon-athena)
+  [Publicações do Athena no blog sobre big data da AWS](https://aws.amazon.com/blogs/big-data/tag/amazon-athena/) 

Geralmente, a solução de problemas requer consulta e descoberta iterativas por um especialista ou de uma comunidade de ajudantes. Se continuar a enfrentar problemas após tentar as sugestões nesta página, entre em contato com o AWS Support (no Console de gerenciamento da AWS, clique em **Suporte**, **Central de Suporte**), ou faça uma pergunta no [AWS re:Post](https://repost.aws/tags/TA78iVOM7gR62_QqDe2-CmiA/amazon-athena) usando a tag **Amazon Athena**.

# Catálogo de erros do Athena
<a name="error-reference"></a>

O Athena fornece informações de erro padronizadas para ajudar você a compreender consultas com falha e tomar medidas após uma falha de consulta. O recurso `AthenaError` inclui um campo `ErrorCategory` e um campo `ErrorType`. `ErrorCategory` especifica se a causa da consulta com falha é um erro do sistema, erro do usuário ou outro erro. `ErrorType` fornece informações mais detalhadas sobre a origem da falha. Ao combinar esses dois campos, você entende melhor as circunstâncias relacionadas e as causas do erro específico que ocorreu.

## Categoria do erro
<a name="error-reference-error-category"></a>

A seguinte tabela lista os valores da categoria de erro do Athena e seus significados.


****  

| Categoria do erro | Origem | 
| --- | --- | 
| 1 | SYSTEM | 
| 2 | USER | 
| 3 | OUTRO | 

## Referência de tipos de erros
<a name="error-reference-error-type-reference"></a>

A seguinte tabela lista os valores do tipo de erro do Athena e seus significados.


****  

| Tipo de erro | Descrição | 
| --- | --- | 
| 0 | A consulta esgotou recursos esgotados nesse fator de escala | 
| 1 | A consulta esgotou recursos esgotados nesse fator de escala | 
| 2 | A consulta esgotou recursos esgotados nesse fator de escala | 
| 3 | A consulta esgotou recursos esgotados nesse fator de escala | 
| 4 | A consulta esgotou recursos esgotados nesse fator de escala | 
| 5 | A consulta esgotou recursos esgotados nesse fator de escala | 
| 6 | A consulta esgotou recursos esgotados nesse fator de escala | 
| 7 | A consulta esgotou recursos esgotados nesse fator de escala | 
| 8 | A consulta esgotou recursos esgotados nesse fator de escala | 
| 100 | Erro de serviço interno | 
| 200 | O mecanismo de consulta apresentou um erro interno | 
| 201 | O mecanismo de consulta apresentou um erro interno | 
| 202 | O mecanismo de consulta apresentou um erro interno | 
| 203 | Erro do driver | 
| 204 | Erro no metastore | 
| 205 | O mecanismo de consulta apresentou um erro interno | 
| 206 | Tempo limite da consulta | 
| 207 | O mecanismo de consulta apresentou um erro interno | 
| 208 | O mecanismo de consulta apresentou um erro interno | 
| 209 | Falha no cancelamento da consulta | 
| 210 | Tempo limite da consulta | 
| 211 | O mecanismo de consulta apresentou um erro interno | 
| 212 | O mecanismo de consulta apresentou um erro interno | 
| 213 | O mecanismo de consulta apresentou um erro interno | 
| 214 | O mecanismo de consulta apresentou um erro interno | 
| 215 | O mecanismo de consulta apresentou um erro interno | 
| 216 | O mecanismo de consulta apresentou um erro interno | 
| 217 | O mecanismo de consulta apresentou um erro interno | 
| 218 | O mecanismo de consulta apresentou um erro interno | 
| 219 | O mecanismo de consulta apresentou um erro interno | 
| 220 | O mecanismo de consulta apresentou um erro interno | 
| 221 | O mecanismo de consulta apresentou um erro interno | 
| 222 | O mecanismo de consulta apresentou um erro interno | 
| 223 | O mecanismo de consulta apresentou um erro interno | 
| 224 | O mecanismo de consulta apresentou um erro interno | 
| 225 | O mecanismo de consulta apresentou um erro interno | 
| 226 | O mecanismo de consulta apresentou um erro interno | 
| 227 | O mecanismo de consulta apresentou um erro interno | 
| 228 | O mecanismo de consulta apresentou um erro interno | 
| 229 | O mecanismo de consulta apresentou um erro interno | 
| 230 | O mecanismo de consulta apresentou um erro interno | 
| 231 | O mecanismo de consulta apresentou um erro interno | 
| 232 | O mecanismo de consulta apresentou um erro interno | 
| 233 | Erro no Iceberg | 
| 234 | Erro no Lake Formation | 
| 235 | O mecanismo de consulta apresentou um erro interno | 
| 236 | O mecanismo de consulta apresentou um erro interno | 
| 237 | Erro de serialização | 
| 238 | Falha ao carregar metadados no Amazon S3 | 
| 239 | Erro geral de persistência | 
| 240 | Falha no envio da consulta | 
| 300 | Erro de serviço interno | 
| 301 | Erro de serviço interno | 
| 302 | Erro de serviço interno | 
| 303 | Erro de serviço interno | 
| 400 | Erro de serviço interno | 
| 401 | Falha na gravação de resultados da consulta no Amazon S3 | 
| 402 | Falha na gravação de resultados da consulta no Amazon S3 | 
| 1000 | Erro do usuário | 
| 1001 | Erro de dados | 
| 1.002 | Erro de dados | 
| 1003 | Falha na tarefa DDL | 
| 1004 | Erro de esquema | 
| 1005 | Erro de serialização | 
| 1006 | Erro de sintaxe | 
| 1007 | Erro de dados | 
| 1008 | Consulta rejeitada | 
| 1009 | Falha na consulta | 
| 1010 | Erro de serviço interno | 
| 1011 | Cancelamento da consulta pelo usuário | 
| 1012 | O mecanismo de consulta apresentou um erro interno | 
| 1013 | O mecanismo de consulta apresentou um erro interno | 
| 1014 | Cancelamento da consulta pelo usuário | 
| 1100 | Argumento inválido fornecido | 
| 1101 | Propriedade inválida fornecida | 
| 1102 | O mecanismo de consulta apresentou um erro interno | 
| 1103 | Propriedade de tabela inválida fornecida | 
| 1104 | O mecanismo de consulta apresentou um erro interno | 
| 1105 | O mecanismo de consulta apresentou um erro interno | 
| 1106 | Argumento de função inválido fornecido | 
| 1107 | Exibição inválida | 
| 1108 | Falha no registro da função | 
| 1109 | Caminho fornecido do Amazon S3 não encontrado | 
| 1110 | Tabela ou exibição fornecida inexistente | 
| 1200 | Consulta sem suporte | 
| 1201 | Decodificador fornecido sem suporte | 
| 1202 | Tipo de consulta sem suporte | 
| 1300 | Erro geral de não encontrado | 
| 1301 | Entidade geral não encontrada | 
| 1302 | Arquivo não encontrado | 
| 1303 | Função ou implementação de função fornecida não encontrada | 
| 1304 | O mecanismo de consulta apresentou um erro interno | 
| 1305 | O mecanismo de consulta apresentou um erro interno | 
| 1306 | Bucket do Amazon S3 não encontrado | 
| 1307 | Mecanismo selecionado não encontrado | 
| 1308 | O mecanismo de consulta apresentou um erro interno | 
| 1400 | Erros de controle de utilização | 
| 1401 | Falha na consulta devido a controle de utilização de AWS Glue | 
| 1402 | Falha na consulta devido a muitas versões de tabela na AWS Glue | 
| 1403 | A consulta falhou como resultado do controle de utilização do Amazon S3 | 
| 1404 | A consulta falhou como resultado do controle de utilização do Amazon Athena | 
| 1405 | A consulta falhou como resultado do controle de utilização do Amazon Athena | 
| 1406 | A consulta falhou como resultado do controle de utilização do Amazon Athena | 
| 1500 | Erro de permissão | 
| 1501 | Erro de permissão do Amazon S3 | 
| 1602 |  Excedeu o limite da capacidade reservada. Capacidade insuficiente para executar esta consulta.  | 
| 1700 | A consulta falhou devido a uma exceção interna do Lake Formation | 
| 1701 | A consulta falhou devido a uma exceção interna do AWS Glue | 
| 9999 | Erro de serviço interno |