Mecanismo Athena versão 3

Para a versão 3 do mecanismo, o Athena também está disponibilizando uma abordagem de integração contínua para o gerenciamento de software de código aberto que melhora a simultaneidade com os projetos Trino e Presto, para que você tenha acesso mais rápido às melhorias da comunidade, integradas e ajustadas no mecanismo do Athena.

Este lançamento do mecanismo do Athena versão 3 oferece suporte a todos os recursos das versões anteriores do mecanismo. Este documento destaca as principais diferenças entre as versões anteriores do mecanismo e o mecanismo do Athena versão 3. Para obter mais informações, consulte o Blog de Big Data da AWS com o artigo Upgrade to Athena engine version 3 to increase query performance and access more analytics features.

• Conceitos básicos

• Melhorias e novos recursos

  • Recursos adicionados

  • Funções adicionadas

  • Melhorias de performance

  • Melhorias na confiabilidade

  • Melhorias na sintaxe da consulta

  • Melhorias no formato e no tipo de dados

• Alterações significativas

  • Mudanças na sintaxe de consulta

  • Alterações no processamento de dados

  • Alterações de timestamp

• Limitações

Conceitos básicos

Para começar, crie um novo grupo de trabalho do Athena que use o mecanismo Athena versão 3 ou configure um grupo de trabalho existente para usar a versão 3.

Para obter mais informações, consulte Alterar versões do mecanismo do Athena.

Melhorias e novos recursos

Os recursos e atualizações listados incluem melhorias do próprio Athena e da funcionalidade incorporada do Trino de código aberto. Para obter uma lista completa de operadores e funções de consulta SQL, consulte a documentação do Trino.

Recursos adicionados

Compatibilidade com o algoritmo de bucketing do Apache Spark

O Athena pode ler buckets gerados pelo algoritmo de hash do Spark. Para especificar que os dados foram originalmente gravados pelo algoritmo de hash do Spark, insira ('bucketing_format'='spark') na cláusula TBLPROPERTIES da sua declaração CREATE TABLE. Se essa propriedade não for especificada, o algoritmo de hash do Hive será usado.

CREATE EXTERNAL TABLE `spark_bucket_table`(
  `id` int, 
  `name` string
  )
CLUSTERED BY (`name`) 
INTO 8 BUCKETS
STORED AS PARQUET
LOCATION 
  's3://amzn-s3-demo-bucket/to/bucketed/table/'
TBLPROPERTIES ('bucketing_format'='spark')

Funções adicionadas

As funções nesta seção são novas no mecanismo Athena versão 3.

Funções agregadas

listagg(x, separator): retorna os valores de entrada concatenados, separados pela string separadora.

SELECT listagg(value, ',') WITHIN GROUP (ORDER BY value) csv_value 
FROM (VALUES 'a', 'c', 'b') t(value);

Funções de array

contains_sequence(x, seq): retorna verdadeiro se a matriz x contiver toda a matriz seq como um subconjunto sequencial (todos os valores na mesma ordem consecutiva).

SELECT contains_sequence(ARRAY [1,2,3,4,5,6], ARRAY[1,2]);

Funções binárias

murmur3(binary): calcula o hash MurmurHash3 de 128 bits do binário.

SELECT murmur3(from_base64('aaaaaa'));

Funções de conversão

format_number(number): retorna uma string formatada usando um símbolo de unidade.

SELECT format_number(123456); -- '123K'

SELECT format_number(1000000); -- '1M'

Perfis de data e hora

timezone_hour(timestamp): retorna a hora da compensação do fuso horário do timestamp.

SELECT EXTRACT(TIMEZONE_HOUR FROM TIMESTAMP '2020-05-10 12:34:56 +08:35');

timezone_minute(timestamp): retorna o minuto da compensação do fuso horário do timestamp.

SELECT EXTRACT(TIMEZONE_MINUTE FROM TIMESTAMP '2020-05-10 12:34:56 +08:35');

Funções geoespaciais

to_encoded_polyline(Geometry): codifica uma cadeia de linha ou multiponto em uma polilinha.

SELECT to_encoded_polyline(ST_GeometryFromText(
   'LINESTRING (-120.2 38.5, -120.95 40.7, -126.453 43.252)'));

from_encoded_polyline(varchar): decodifica uma polilinha em uma string de linha.

SELECT ST_AsText(from_encoded_polyline('_p~iF~ps|U_ulLnnqC_mqNvxq`@'));         

to_geojson_geometry(SphericalGeography): retorna a geografia esférica especificada no formato GeoJSON.

SELECT to_geojson_geometry(to_spherical_geography(ST_GeometryFromText(
   'LINESTRING (0 0, 1 2, 3 4)')));

from_geojson_geometry(varchar): retorna o objeto do tipo geografia esférica da representação GeoJSON, removendo chave/valores que não sejam geométricos. Feature e FeatureCollection não são compatíveis.

SELECT from_geojson_geometry(to_geojson_geometry(to_spherical_geography(ST_GeometryFromText(
   'LINESTRING (0 0, 1 2, 3 4)'))));

geometry_nearest_points(Geometry, Geometry): retorna os pontos em cada geometria que estão mais próximos uns dos outros. Se a geometria especificada estiver vazia, retornará NULL. Caso contrário, retornará uma linha de dois objetos Point que têm a distância mínima de quaisquer dois pontos nas geometrias. O primeiro ponto é do primeiro argumento Geometry (Geometria), o segundo do segundo argumento Geometry (Geometria). Se houver vários pares com a mesma distância mínima, um par será escolhido arbitrariamente.

SELECT geometry_nearest_points(ST_GeometryFromText(
   'LINESTRING (50 100, 50 200)'), ST_GeometryFromText(
   'LINESTRING (10 10, 20 20)'));

Funções de definição de resumo

make_set_digest(x): compõe todos os valores de entrada de x em um setdigest.

SELECT make_set_digest(value) FROM (VALUES 1, 2, 3) T(value);

Funções de string

soundex(char): retorna uma string contendo a representação fonética de char.

SELECT name 
FROM nation 
WHERE SOUNDEX(name) = SOUNDEX('CHYNA'); -- CHINA

concat_ws(string0, string1, ..., stringN): retorna a concatenação de string1, string2, ..., stringN usando string0 como separador. Se string0 for null, o valor retornado será nulo. Todos os valores nulos fornecidos nos argumentos após o separador são ignorados.

SELECT concat_ws(',', 'def', 'pqr', 'mno');

Funções de janela

GROUPS: adiciona compatibilidade com frames de janela com base em grupos.

SELECT array_agg(a) OVER(
   ORDER BY a ASC NULLS FIRST GROUPS BETWEEN 1 PRECEDING AND 2 FOLLOWING) 
FROM (VALUES 3, 3, 3, 2, 2, 1, null, null) T(a);

Melhorias de performance

As melhorias na performance do mecanismo Athena versão 3 incluem os seguintes exemplos.

• Recuperação mais rápida de metadados de tabelas do AWS Glue: as consultas que envolvem diversas tabelas terão um tempo de planejamento de consulta reduzido.

• Filtragem dinâmica para RIGHT JOIN: agora, a filtragem dinâmica está habilitada para uniões direitas que têm condições de união de igualdade, como no exemplo a seguir.

  SELECT * 
  FROM lineitem RIGHT JOIN tpch.tiny.supplier 
  ON lineitem.suppkey = supplier.suppkey 
  WHERE supplier.name = 'abc';

• Instruções elaboradas abrangentes: aumento do tamanho padrão do cabeçalho de solicitação/resposta HTTP para 2 MB visando permitir instruções elaboradas abrangentes.

• approx_percentile () - A approx_percentile função agora usa tdigest em vez de qdigest para recuperar valores quantis aproximados das distribuições. Isto resulta em um desempenho superior e em um menor uso de memória. Observe que, como resultado dessa alteração, a função retorna resultados diferentes do que fazia nas versões anteriores do mecanismo. Para ter mais informações, consulte A função approx_percentile retorna resultados diferentes..

Melhorias na confiabilidade

O uso geral da memória do mecanismo e o rastreamento no mecanismo Athena versão 3 passaram por aprimoramento. Consultas grandes estão menos suscetíveis a falhas causadas por falhas em nós.

Melhorias na sintaxe da consulta

INTERSECT ALL: adição de compatibilidade com INTERSECT ALL.

SELECT * FROM (VALUES 1, 2, 3, 4) INTERSECT ALL SELECT * FROM (VALUES 3, 4);

EXCEPT ALL: adição de compatibilidade com EXCEPT ALL.

SELECT * FROM (VALUES 1, 2, 3, 4) EXCEPT ALL SELECT * FROM (VALUES 3, 4);

RANGE PRECEDING: adição de compatibilidade com RANGE PRECEDING em funções de janela.

SELECT sum(x) over (order by x range 1 preceding) 
FROM (values (1), (1), (2), (2)) t(x);

MATCH_RECOGNIZE: adição de compatibilidade com correspondência de padrões de linha, como no exemplo a seguir.

SELECT m.id AS row_id, m.match, m.val, m.label 
FROM (VALUES(1, 90),(2, 80),(3, 70),(4, 70)) t(id, value) 
MATCH_RECOGNIZE ( 
        ORDER BY id 
        MEASURES match_number() AS match, 
        RUNNING LAST(value) AS val, 
        classifier() AS label 
        ALL ROWS PER MATCH 
        AFTER MATCH SKIP PAST LAST ROW 
        PATTERN (() | A) DEFINE A AS true 
) AS m;

Melhorias no formato e no tipo de dados

O mecanismo Athena versão 3 recebeu os seguintes aprimoramentos de formato e tipo de dados.

• LZ4 e ZSTD: adição de compatibilidade com leitura de dados compactados de LZ4 e ZSTD em Parquet. Adição de compatibilidade com gravação de dados ORC compactados em ZSTD.

• Tabelas baseadas em links simbólicos: adição de compatibilidade com a criação de tabelas baseadas em links simbólicos em arquivos Avro. Veja a seguir um exemplo.

  CREATE TABLE test_avro_symlink  
  ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe'  
  ... 
  INPUTFORMAT 'org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat'

• SphericalGeography: o tipo SphericalGeography fornece suporte nativo para características espaciais representadas em coordenadas geográficas (às vezes chamadas de coordenadas geodésicas, lat/lon ou lon/lat). As coordenadas geográficas são coordenadas esféricas expressas em unidades angulares (graus).

  A função to_spherical_geography retorna coordenadas geográficas (esféricas) de coordenadas geométricas (planares), como no exemplo a seguir.

  SELECT to_spherical_geography(ST_GeometryFromText(
     'LINESTRING (-40.2 28.9, -40.2 31.9, -37.2 31.9)'));

Alterações significativas

Quando você migrar das versões anteriores do mecanismo para o mecanismo do Athena versão 3, algumas alterações poderão afetar o esquema da tabela, a sintaxe ou o uso do tipo de dados. Esta seção lista as mensagens de erro associadas e fornece sugestões de soluções alternativas.

Mudanças na sintaxe de consulta

IGNORE NULLS não pode ser usado com funções de janela sem valor

Mensagem de erro: não é possível especificar a cláusula de tratamento nula para a função bool_or.

Causa: o IGNORE NULLS agora pode ser usado somente com as funções de valor first_value, last_value, nth_value, lead elag. Essa alteração foi feita para estar em conformidade com a especificação ANSI SQL.

Solução sugerida: Remover o IGNORE NULLS de funções de janela sem valor em cadeias de caracteres de consulta.

A função CONCAT deve ter dois ou mais argumentos

Mensagem de erro: INVALID_FUNCTION_ARGUMENT: There must be two or more concatenation arguments (INVALID_FUNCTION_ARGUMENT: deve haver dois ou mais argumentos de concatenação).

Causa: anteriormente, a função de string CONCAT aceitava somente um argumento. Na versão 3 do mecanismo do Athena, a função CONCAT requer, no mínimo, dois argumentos.

Solução sugerida: altere as ocorrências de CONCAT(str) para CONCAT(str, '').

No mecanismo Athena versão 3, as funções não podem ter mais de 127 argumentos. Para ter mais informações, consulte Excesso de argumentos para chamada de função.

A função approx_percentile retorna resultados diferentes.

A função approx_percentile retorna resultados diferentes no mecanismo do Athena versão 3 em comparação com as versões anteriores do mecanismo.

Mensagem de erro: nenhum

Causa: A função approx_percentile está sujeita a alterações de versão.

Importante

Como as saídas da função approx_percentile são aproximações e as aproximações estão sujeitas a alterações de uma versão para outra, você não deve confiar na função para aplicações críticas approx_percentile.

Solução sugerida: para aproximar o comportamento das versões anteriores do mecanismo de approx_percentile, é possível usar um conjunto diferente de funções no mecanismo do Athena versão 3. Por exemplo, suponha que você tenha a seguinte consulta nas versões anteriores do mecanismo:

SELECT approx_percentile(somecol, 2E-1)

Para obter aproximadamente a mesma saída na versão 3 do motor Athena, você pode experimentar qdigest_agg as funções value_at_quantile e, como no exemplo a seguir. Observe que, mesmo com esta solução alternativa, o mesmo comportamento não é garantido.

SELECT value_at_quantile(qdigest_agg(somecol, 1), 2E-1)

A função geoespacial não é compatível com entrada varibinária

Mensagem de erro: FUNCTION_NOT_FOUND for st_XXX (FUNCTION_NOT_FOUND para st_XXX).

Causa: algumas funções geoespaciais não são mais compatíveis com o tipo de entrada VARBINARY legado ou as assinaturas de funções relacionadas ao texto.

Solução sugerida: use funções geoespaciais para converter os tipos de entrada em tipos compatíveis. Os tipos de entrada compatíveis são indicados na mensagem de erro.

Em cláusulas GROUP BY, as colunas aninhadas devem ter aspas duplas

Mensagem de erro: “column_name” “nested_column” deve ser uma expressão agregada ou aparecer na cláusula GROUP BY

Causa: o mecanismo Athena versão 3 exige que os nomes das colunas aninhadas nas cláusulas GROUP BY tenham aspas duplas. Por exemplo, a consulta a seguir produz o erro porque, na cláusula GROUP BY, user.name não está entre aspas duplas.

SELECT "user"."name" FROM dataset 
GROUP BY user.name

Solução sugerida: coloque aspas duplas ao redor dos nomes das colunas aninhadas nas cláusulas GROUP BY, como no exemplo a seguir.

SELECT "user"."name" FROM dataset 
GROUP BY "user"."name"

Erro de FilterNode inesperado ao usar OPTIMIZE em uma tabela Iceberg

Mensagem de erro: FilterNode inesperado encontrado no plano; provavelmente o conector não conseguiu lidar com a expressão WHERE fornecida.

Causa: a instrução OPTIMIZE que foi executada na tabela Iceberg usou uma cláusula WHERE que incluía uma coluna sem partição em sua expressão de filtro.

Solução sugerida: a instrução OPTIMIZE suporta a filtragem somente por partições. Ao executar OPTIMIZE em tabelas particionadas, inclua somente colunas de partição na cláusula WHERE. Se você executar OPTIMIZE em uma tabela não particionada, não especifique uma cláusula WHERE.

Ordem dos argumentos na função Log()

Na versão 3 do mecanismo do Athena, a ordem dos argumentos da função log() foi alterada para log(base, value) em conformidade com os padrões SQL.

A função Minute() não é compatível com intervalos de ano a mês

Mensagem de erro: Unexpected parameters (interval year to month) for function minute. (Parâmetros inesperados [intervalo de ano a mês] para a função “minute” [minutos]). Expected: minute(timestamp with time zone) , minute(time with time zone) , minute(timestamp) , minute(time) , minute(interval day to second).

Causa: no mecanismo Athena versão 3, as verificações estão mais precisas para EXTRACT de acordo com a especificação ANSI SQL.

Solução sugerida: atualize as consultas para garantir que os tipos correspondam às assinaturas de função sugeridas.

Expressões ORDER BY devem aparecer na lista SELECT

Mensagem de erro: For SELECT DISTINCT, ORDER BY expressions must appear in SELECT list (Para SELECT DISTINCT, expressões ORDER BY devem aparecer na lista SELECT).

Causa: o alias de tabela incorreto é usado em uma cláusula SELECT.

Solução sugerida: verifique se todas as colunas na expressão ORDER BY têm referências adequadas na cláusula SELECT DISTINCT.

Falha na consulta ao comparar várias colunas retornadas de uma subconsulta

Exemplo de mensagem de erro: a expressão do valor e o resultado da subconsulta devem ser do mesmo tipo: row(varchar, varchar) vs. row(row(varchar, varchar))

Causa: devido a uma atualização de sintaxe no mecanismo Athena versão 3, esse erro ocorre quando uma consulta tenta comparar vários valores retornados de uma subconsulta, e a instrução SELECT da subconsulta coloca a lista de colunas entre parênteses, como no exemplo a seguir.

SELECT *
FROM table1
WHERE (t1_col1, t1_col2)
IN (SELECT (t2_col1, t2_col2) FROM table2)

Solução: no mecanismo Athena versão 3, remova os parênteses ao redor da lista de colunas na instrução SELECT da subconsulta, como no exemplo de consulta atualizado a seguir.

SELECT *
FROM table1
WHERE (t1_col1, t1_col2)
IN (SELECT t2_col1, t2_col2 FROM table2)

SKIP é uma palavra reservada para consultas DML

Agora a palavra SKIP é reservada para consultas DML, como SELECT. Para usar SKIP como identificador em uma consulta DML, coloque-a entre aspas duplas.

Para obter mais informações sobre as palavras reservadas no Athena, consulte Escapar palavras-chave reservadas em consultas.

Cláusulas SYSTEM_TIME e SYSTEM_VERSION estão obsoletas para passagem de tempo

Mensagem de erro: mismatched input ‘SYSTEM_TIME’ (entrada “SYSTEM_TIME” incompatível). Expecting: ‘TIMESTAMP’, ‘VERSION’ (Esperado: “TIMESTAMP”, “VERSION”).

Causa: nas versões anteriores do mecanismo, as tabelas do Iceberg usavam as cláusulas FOR SYSTEM_TIME AS OF e FOR SYSTEM_VERSION AS OF como timestamp e viagem no tempo da versão. A versão 3 do mecanismo do Athena usa as cláusulas FOR TIMESTAMP AS OF e FOR VERSION AS OF.

Solução sugerida: atualize a consulta SQL para usar as cláusulas TIMESTAMP AS OF e VERSION AS OF para operações de passagem de tempo, como nos exemplos a seguir.

Passagem de tempo por data e hora:

SELECT * FROM TABLE FOR TIMESTAMP AS OF (current_timestamp - interval '1' day)

Passagem de tempo por versão:

SELECT * FROM TABLE FOR VERSION AS OF 949530903748831860

Excesso de argumentos para um construtor de matrizes

Mensagem de erro: TOO_MANY_ARGUMENTS: excesso de argumentos para o construtor de matrizes.

Causa: o número máximo de elementos em um construtor de matrizes agora está definido como 254.

Solução sugerida: divida os elementos em várias matrizes com até 254 elementos cada e use a função CONCAT para concatenar as matrizes, como no exemplo a seguir.

CONCAT(
ARRAY[x1,x2,x3...x254],
ARRAY[y1,y2,y3...y254],
...
)

Identificador delimitado com comprimento zero não permitido

Mensagem de erro: Zero-length delimited identifier not allowed (Identificadores delimitados por comprimento zero não são permitidos).

Causa: uma consulta usou uma string vazia como alias de coluna.

Solução sugerida: atualize a consulta para usar um alias que não esteja vazio para a coluna.

Alterações no processamento de dados

Validação de bucket

Mensagem de erro: HIVE_INVALID_BUCKET_FILES: a tabela do Hive está corrompida..

Causa: a tabela pode ter sido corrompida. O mecanismo Athena versão 3 permite validação adicional de tabelas em buckets para assegurar que as consultas estejam corretas e evitar falhas inesperadas no runtime.

Solução sugerida: recrie a tabela usando o mecanismo Athena versão 3.

Agora a conversão de um struct para JSON retorna nomes de campos

Agora, ao converter um struct para JSON em uma consulta SELECT no mecanismo do Athena versão 3, a conversão retorna os nomes dos campos e os valores (por exemplo, "useragent":null em vez de apenas os valores (por exemplo, null).

Alteração da imposição de segurança em nível de coluna da tabela do Iceberg

Mensagem de erro: Access Denied: Cannot select from columns (Acesso negado: não é possível realizar a seleção entre as colunas).

Causa: a tabela do Iceberg foi criada exteriormente ao Athena e usa uma versão do SDK do Apache Iceberg anterior à versão 0.13.0. Como as versões anteriores do SDK não preenchem as colunas no AWS Glue, o Lake Formation não é capaz de determinar as colunas autorizadas para o acesso.

Solução sugerida: realize uma atualização usando a instrução ALTER TABLE SET TBLPROPERTIES do Athena ou use o SDK mais recente do Iceberg para corrigir a tabela e atualizar as informações da coluna no AWS Glue.

Agora, os nulos nos tipos de dados List (Lista) são propagados para UDFs

Mensagem de erro: Null Pointer Exception.

Causa: esse problema pode afetar você se você usar o conector UDF e tiver implementado uma função Lambda definida pelo usuário.

As versões anteriores do mecanismo filtravam os nulos nos tipos de dados List que eram passados para uma função definida pelo usuário. No mecanismo Athena versão 3, agora os nulos são preservados e transmitidos para a UDF. Isso pode causar uma exceção de ponteiro nulo se a UDF tentar desfazer a referência ao elemento nulo sem verificação.

Por exemplo, se você tiver os dados [null, 1, null, 2, 3, 4] em uma fonte de dados de origem como o DynamoDB, o seguinte será transmitido para a função Lambda definida pelo usuário:

Mecanismo Athena versão 3: [null, 1, null, 2, 3, 4]

Solução sugerida: certifique-se de que sua função do Lambda definida pelo usuário trate os elementos nulos nos tipos de dados de lista.

Subsequências de matrizes de caracteres não contêm mais espaços preenchidos

Mensagem de erro: nenhuma mensagem de erro é gerada, mas a string retornada não contém mais os espaços preenchidos. Por exemplo, agora substr(char[20],1,100) retorna uma string com comprimento 20 em vez de 100.

Solução sugerida: nenhuma ação é necessária.

Coerção de tipo de coluna decimal não compatível

Mensagens de erro: HIVE_CURSOR_ERROR: Failed to read Parquet file: s3://amzn-s3-demo-bucket/caminho/nome_Arquivo.parquet ou Unsupported column type (varchar) for Parquet column ([nome_coluna]

Causa: o mecanismo Athena versão 2 teve sucesso algumas vezes (mas falhou frequentemente) ao tentar conversões de tipo de dados de varchar para decimal. Como a versão 3 do mecanismo Athena tem validação de tipo, que verifica se o tipo é compatível antes de tentar ler o valor, essas tentativas de coerção agora sempre falham.

Solução sugerida: para o mecanismo do Athena versão 3, modifique o esquema no AWS Glue para usar um tipo de dado numérico em vez de varchar para colunas decimais em arquivos do Parquet. Ou recrawle os dados e garanta que o novo tipo de dados da coluna seja do tipo decimal, ou recrie manualmente a tabela no Athena e use a sintaxe decimal(precision, scale) para especificar um tipo de dados decimal para a coluna.

Valores NaN de ponto flutuante ou precisão dupla não podem mais ser convertidos para bigint

Mensagem de erro: INVALID_CAST_ARGUMENT: Cannot cast real/double NaN to bigint

Causa: na versão 3 do mecanismo do Athena, NaN não pode mais ser convertido para 0 como bigint.

Solução sugerida: certifique-se de que os valores NaN não estejam presentes nas colunas float e double ao converter para bigint.

alteração do tipo de retorno da função uuid()

O problema a seguir afeta tanto as tabelas como as visualizações.

Mensagem de erro: Unsupported Hive type: uuid

Causa: nas versões anteriores do mecanismo, a função uuid() retornava uma string, mas no mecanismo do Athena versão 3, ela retorna um pseudo UUID gerado aleatoriamente (tipo 4). Como o tipo de dados da coluna UUID não é compatível com o Athena, a função uuid() não pode mais ser usada diretamente em consultas CTAS para gerar colunas UUID no mecanismo Athena versão 3.

Por exemplo, a seguinte instrução CREATE TABLE é concluída com êxito nas versões anteriores do mecanismo, mas retorna NOT_SUPPORTED: Tipo de hive sem suporte: uuid no mecanismo do Athena versão 3:

CREATE TABLE uuid_table AS 
   SELECT uuid() AS myuuid

Da mesma forma, a seguinte instrução CREATE VIEW é concluída com êxito no mecanismo do Athena versão 2, mas retorna Tipo de coluna inválido para myuuid de coluna: Tipo de hive sem suporte: uuid no mecanismo do Athena versão 3:

CREATE VIEW uuid_view AS 
   SELECT uuid() AS myuuid

Quando uma visualização criada dessa forma em uma versão anterior do mecanismo é consultada no mecanismo do Athena versão 3, um erro como este ocorre:

VIEW_IS_STALE: linha 1:15: a exibição 'awsdatacatalog.mydatabase.uuid_view' está esmaecida ou em estado inválido: a coluna [myuuid] do tipo uuid projetada da exibição da consulta na posição 0 não pode ser forçada na coluna [myuuid] do tipo varchar armazenada na definição da exibição

Solução sugerida: ao criar ou visualizar a tabela, use a função cast() para converter a saída de uuid() para varchar, como no seguinte exemplo:

CREATE TABLE uuid_table AS
   SELECT CAST(uuid() AS VARCHAR) AS myuuid

CREATE VIEW uuid_view AS
   SELECT CAST(uuid() AS VARCHAR) AS myuuid

Problemas de coerção de CHAR e VARCHAR

Use as soluções alternativas desta seção caso encontre problemas de coerção de varchar e char no mecanismo do Athena versão 3. Se não conseguir usar essas soluções alternativas, entre em contato com o Suporte.

Falha na função CONCAT com entradas CHAR e VARCHAR mistas

Problema: a consulta a seguir tem êxito no mecanismo do Athena versão 2.

SELECT concat(CAST('abc' AS VARCHAR(20)), '12', CAST('a' AS CHAR(1)))

Porém, no mecanismo do Athena versão 3, a mesma consulta falha com o seguinte:

Mensagem de erro: FUNCTION_NOT_FOUND: line 1:8: Unexpected parameters (varchar(20), varchar(2), char(1)) for function concat. Esperado: concat(char(x), char(y)), concat(array(E), E) E, concat(E, array(E)) E, concat(array(E)) E, concat(varchar), concat(varbinary)

Solução sugerida: ao usar a função concat, converta para char ou varchar, mas não para uma mistura de ambas.

Falha de concatenação de || do SQL com entradas CHAR e VARCHAR

No mecanismo do Athena versão 3, o operador de concatenação de barras verticais duplas || requer varchar como entradas. As entradas não podem ser uma combinação de tipos varchar e char.

Mensagem de erro: TYPE_NOT_FOUND: line 1:26: Unknown type: char(65537)

Causa: uma consulta que usa || para concatenar um char e um varchar pode produzir o erro, como no exemplo a seguir.

SELECT CAST('a' AS CHAR) || CAST('b' AS VARCHAR)

Solução sugerida: concatene varchar com varchar, como no exemplo a seguir.

SELECT CAST('a' AS VARCHAR) || CAST('b' AS VARCHAR) 

Falha na consulta CHAR e VARCHAR UNION

Mensagem de erro: NOT_SUPPORTED: Unsupported Hive type: char(65536). Tipos de CHAR compatíveis: CHAR (<=255) 

Causa: uma consulta que tenta combinar char e varchar, como no seguinte exemplo:

CREATE TABLE t1 (c1) AS SELECT CAST('a' as CHAR) as c1 UNION ALL SELECT CAST('b' AS VARCHAR) AS c1 

Solução sugerida: na consulta de exemplo, converta 'a' para varchar em vez de char.

Espaços vazios indesejados após a coerção de CHAR ou VARCHAR

Na versão 3 do mecanismo Athena, quando os dados char(X) e varchar são forçados para um único tipo formando uma matriz ou coluna única, char(65535) é o tipo de destino, e cada campo contém muitos espaços indesejados à direita.

Causa: o mecanismo Athena versão 3 força varchar e char(X) para char(65535) e preenche os dados com espaços à direita.

Solução sugerida: converta cada campo explicitamente para varchar.

Alterações de timestamp

O estouro do timestamp gera um erro

Mensagem de erro: Millis overflow: XXX (Estouro de milissegundos: XXX)

Causa: como as datas ISO 8601 não foram verificadas quanto ao estouro nas versões anteriores do mecanismo, algumas datas produziram um timestamp negativo. O mecanismo Athena versão 3 verifica esse estouro e gera uma exceção.

Solução sugerida: certifique-se de que o timestamp esteja dentro do intervalo.

Não há compatibilidade com fusos horários políticos com TIME

Mensagem de erro: INVALID LITERAL

Causa: consultas como SELECT TIME '13:21:32.424 America/Los_Angeles'.

Solução sugerida: evite usar fusos horários políticos com TIME.

Divergência de precisão nas colunas Timestamp causa erro de serialização

Mensagem de erro: SERIALIZATION_ERROR: Could not serialize column ‘COLUMNZ’ of type ‘timestamp(3)’ at position X:Y (SERIALIZATION_ERROR: não foi possível serializar a coluna “COLUMNZ” do tipo “timestamp(3)” na posição X:Y).

COLUMNZ é o nome de saída da coluna que causa o problema. Os números X:Y indicam a posição da coluna na saída.

Causa: o mecanismo Athena versão 3 verifica se a precisão dos registros de data e hora nos dados é igual à precisão especificada para o tipo de dados da coluna na especificação da tabela. No momento, essa precisão é sempre 3. Se os dados tiverem uma precisão maior do que isso, as consultas falharão com o erro observado.

Solução sugerida: verifique seus dados para garantir que os timestamps tenham a precisão de milissegundos.

Precisão incorreta do timestamp nas consultas UNLOAD e CTAS para tabelas Iceberg

Mensagem de erro: precisão incorreta do timestamp para timestamp(6); a precisão configurada é MILLISECONDS

Causa: o mecanismo Athena versão 3 verifica se a precisão dos registros de data e hora nos dados é igual à precisão especificada para o tipo de dados da coluna na especificação da tabela. No momento, essa precisão é sempre 3. Se os dados tiverem uma precisão maior do que isso (por exemplo, microssegundos em vez de milissegundos), as consultas poderão falhar com o erro observado.

Solução: para resolver esse problema, primeiro CAST a precisão do timestamp para 6, como no exemplo de CTAS a seguir, que cria uma tabela Iceberg. Observe que a precisão deve ser especificada como 6 em vez de 3 para evitar o erro Timestamp precision (3) not supported for Iceberg.

CREATE TABLE my_iceberg_ctas
WITH (table_type = 'ICEBERG', location = 's3://amzn-s3-demo-bucket/table_ctas/',
format = 'PARQUET')
AS SELECT id, CAST(dt AS timestamp(6)) AS "dt"
FROM my_iceberg

Então, como o Athena não é compatível com o timestamp 6, converta o valor novamente para timestamp (por exemplo, em uma exibição). O exemplo a seguir cria uma visualização da tabela my_iceberg_ctas.

CREATE OR REPLACE VIEW my_iceberg_ctas_view AS
SELECT cast(dt AS timestamp) AS dt
FROM my_iceberg_ctas

Ler o tipo Long como Timestamp ou vice-versa em arquivos ORC agora causa um erro de arquivo ORC malformado.

Mensagem de erro: Error opening Hive split ‘FILE (SPLIT POSITION)’ Malformed ORC file. (Erro ao abrir o arquivo ORC malformado da divisão Hive ‘FILE (SPLIT POSITION)’). Cannot read SQL type timestamp from ORC stream .long_type of type LONG

Causa: agora, o mecanismo Athena versão 3 rejeita a coerção implícita do tipo de dados Long para Timestamp ou de Timestamp para Long. Anteriormente, os valores Long eram convertidos implicitamente em timestamp como se fossem milissegundos de época.

Solução sugerida: use a função from_unixtime para converter explicitamente a coluna ou use a função from_unixtime para criar uma coluna adicional para consultas futuras.

Não há compatibilidade com tempo e intervalo de ano a mês

Mensagem de erro: TYPE MISMATCH

Causa: o mecanismo Athena versão 3 não é compatível com tempo e intervalo de ano a mês (p. ex., SELECT TIME '01:00' + INTERVAL '3' MONTH).

Estouro de timestamp para o formato Parquet int96

Mensagem de erro: Invalid timeOfDayNanos (timeOfDayNanos inválido).

Causa: um estouro de timestamp para o formato Parquet int96.

Solução sugerida: identifique os arquivos específicos que apresentam o problema. Em seguida, gere o arquivo de dados novamente com uma biblioteca Parquet atualizada e conhecida ou use o Athena CTAS. Se o problema persistir, entre em contato com o suporte do Athena e nos informe como os arquivos de dados são gerados.

Espaço necessário entre os valores de data e hora ao converter de string para timestamp

Mensagem de erro: INVALID_CAST_ARGUMENT: o valor não pode ser convertido para timestamp.

Causa: o mecanismo Athena versão 3 não aceita mais um hífen como separador válido entre valores de data e hora na string de entrada para cast. Por exemplo, a seguinte consulta não funciona no mecanismo do Athena versão 3:

SELECT CAST('2021-06-06-23:38:46' AS timestamp) AS this_time

Solução sugerida: no mecanismo Athena versão 3, substitua o hífen entre a data e a hora por um espaço, como no exemplo a seguir.

SELECT CAST('2021-06-06 23:38:46' AS timestamp) AS this_time

alteração do valor de retorno do timestamp to_iso8601()

Mensagem de erro: nenhuma

Causa: nas versões anteriores do mecanismo, a função to_iso8601 retorna um timestamp com fuso horário, mesmo que o valor passado para a função não inclua o fuso horário. No mecanismo Athena versão 3, a função to_iso8601 retorna um timestamp com fuso horário somente quando o argumento passado inclui o fuso horário.

Por exemplo, a consulta a seguir passa a data atual para a função to_iso8601 duas vezes: primeiro como timestamp com fuso horário e depois como um timestamp.

SELECT TO_ISO8601(CAST(CURRENT_DATE AS TIMESTAMP WITH TIME ZONE)), TO_ISO8601(CAST(CURRENT_DATE AS TIMESTAMP))

A saída a seguir mostra o resultado da consulta no mecanismo do Athena versão 3.

Em versões anteriores do mecanismo:

#	_col0	_col1
1	2023-02-24T00:00:00.000Z	2023-02-24T00:00:00.000Z

Mecanismo Athena versão 3:

#	_col0	_col1
1	2023-02-24T00:00:00.000Z	2023-02-24T00:00:00.000

Solução sugerida: para replicar o comportamento anterior, você pode passar o valor do timestamp para a função with_timezone antes de passá-lo para to_iso8601, como no exemplo a seguir:

SELECT to_iso8601(with_timezone(TIMESTAMP '2023-01-01 00:00:00.000', 'UTC'))

Resultado

#	_col0
1	2023-01-01T00:00:00.000Z

o primeiro parâmetro at_timezone() deve especificar uma data

Problema: no mecanismo Athena versão 3, a função at_timezone não pode ter um valor time_with_timezone como o primeiro parâmetro.

Causa: sem informações de data, não é possível determinar se o valor passado está no horário de verão ou no horário padrão. Por exemplo, at_timezone('12:00:00 UTC', 'America/Los_Angeles') é ambíguo, pois não há como determinar se o valor passado está no Horário de Verão do Pacífico (PDT) ou no Horário Padrão do Pacífico (PST).

Limitações

O mecanismo Athena versão 3 tem as seguintes limitações.

• Performance de consulta: muitas consultas são executadas mais rapidamente no mecanismo Athena versão 3, mas alguns planos de consulta podem ser diferentes em relação às versões anteriores do mecanismo. Como resultado, algumas consultas podem diferir em latência ou custo.

• Conectores Trino e Presto: não há compatibilidade com conectores Trino nem Presto. Use a consulta federada do Amazon Athena para conectar origens de dados. Para ter mais informações, consulte Usar a consulta federada do Amazon Athena.

• Execução tolerante a falhas: não há compatibilidade com a execução tolerante a falhas do Trino (Trino Tardigrade).

• Limite de parâmetros de função: as funções não podem ter mais de 127 parâmetros. Para ter mais informações, consulte Excesso de argumentos para chamada de função.

Os limites a seguir foram introduzidos no mecanismo do Athena versão 2 para garantir que as consultas não falhem devido a limitações de recursos. Esses limites não são configuráveis pelos usuários.

• Número de elementos do resultado: o número de elementos do resultado n é restrito a no máximo 10.000 para as seguintes funções: min(col, n), max(col, n), min_by(col1, col2, n) e max_by(col1, col2, n).

• GROUPING SETS: o número máximo de fatias em um conjunto de agrupamento é 2.048.

• Comprimento máximo de linha de arquivo de texto: o comprimento máximo de linha padrão para arquivos de texto é de 200 MB.

• Tamanho máximo do resultado da função de sequência: o tamanho máximo do resultado de uma função de sequência é 50.000 entradas. Por exemplo, SELECT sequence(0,45000,1) é bem-sucedido, mas SELECT sequence(0,55000,1) falha com a mensagem de erro: The result of the sequence function must not have more than 50000 entries (O resultado da função de sequência não deve ter mais de 50.000 entradas). Esse limite se aplica a todos os tipos de entrada das funções de sequência, incluindo timestamps.