Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Versione 3 del motore Athena
<a name="engine-versions-reference-0003"></a>

Per la versione 3 del motore, Athena ha introdotto un approccio di integrazione continua per la gestione del software open source volto a migliorare la simultaneità dei progetti [Trino](https://trino.io/) e [Presto](https://prestodb.io/) e ottenere così un accesso più rapido ai miglioramenti da parte della community, integrati e ottimizzati all'interno del motore Athena.

La versione 3 del motore Athena supporta tutte le funzionalità della versione precedente. Questo documento evidenzia le principali differenze tra versioni precedenti e la versione 3 del motore Athena. Per ulteriori informazioni, consulta l'articolo del *Blog sui Big Data di AWS * [Come fare l'upgrade alla versione 3 del motore Athena per aumentare le prestazioni delle query e accedere a più funzionalità di analisi](https://aws.amazon.com/blogs/big-data/upgrade-to-athena-engine-version-3-to-increase-query-performance-and-access-more-analytics-features/).
+ [Nozioni di base](#engine-versions-reference-0003-getting-started)
+ [Miglioramenti e nuove funzioni](#engine-versions-reference-0003-improvements-and-new-features)
  + [Funzionalità aggiunte](#engine-versions-reference-0003-added-features)
  + [Funzioni aggiunte](#engine-versions-reference-0003-added-functions)
  + [Miglioramenti in termini di prestazioni](#engine-versions-reference-0003-performance-improvements)
  + [Miglioramenti in termini di affidabilità](#engine-versions-reference-0003-reliability-enhancements)
  + [Miglioramenti in termini di sintassi delle query](#engine-versions-reference-0003-query-syntax-enhancements)
  + [Miglioramenti in termini di formato e tipo di dati](#engine-versions-reference-0003-data-format-and-data-type-enhancements)
+ [Modifiche importanti](#engine-versions-reference-0003-breaking-changes)
  + [Modifiche alla sintassi delle query](#engine-versions-reference-0003-syntax-changes)
  + [Modifiche a livello di elaborazione dati](#engine-versions-reference-0003-data-processing-changes)
  + [Modifiche al timestamp](#engine-versions-reference-0003-timestamp-changes)
+ [Limitazioni](#engine-versions-reference-0003-known-limitations)

## Nozioni di base
<a name="engine-versions-reference-0003-getting-started"></a>

Per iniziare, crea un nuovo gruppo di lavoro Athena che utilizza la versione 3 del motore Athena o configura un gruppo di lavoro esistente per l'utilizzo della versione 3. 

Per ulteriori informazioni, consulta [Modifica delle versioni del motore Athena](https://docs.aws.amazon.com/athena/latest/ug/engine-versions-changing.html).

## Miglioramenti e nuove funzioni
<a name="engine-versions-reference-0003-improvements-and-new-features"></a>

Le caratteristiche e gli aggiornamenti elencati includono sia i miglioramenti apportati da Athena sia le funzionalità incorporate dal progetto open source di Trino. Per un elenco esaustivo degli operatori e delle funzioni di query SQL, consulta la [documentazione di Trino](https://trino.io/docs/current/functions.html).

### Funzionalità aggiunte
<a name="engine-versions-reference-0003-added-features"></a>

#### Supporto dell'algoritmo del bucket di Apache Spark
<a name="engine-versions-reference-0003-spark-bucketing-support"></a>

Athena può leggere i bucket generati dall'algoritmo hash di Spark. Per specificare che i dati sono stati scritti originariamente dall'algoritmo hash di Spark, inserisci `('bucketing_format'='spark')` nella clausola `TBLPROPERTIES` dell'istruzione `CREATE TABLE`. Se questa proprietà non viene specificata, si utilizza l'algoritmo hash di Hive.

```
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')
```

### Funzioni aggiunte
<a name="engine-versions-reference-0003-added-functions"></a>

Le funzioni riportate in questa sezione sono nuove nella versione 3 del motore Athena.

#### Funzioni di aggregazione
<a name="engine-versions-reference-0003-aggregate-functions"></a>

**listagg(x, separator)**: Restituisce i valori di input concatenati, separati dalla stringa del separatore.

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

#### Funzioni di array
<a name="engine-versions-reference-0003-array-functions"></a>

**contains\$1sequence(x, seq)**: Restituisce true se la matrice x contiene tutte le sequenze di matrice come sottoinsieme sequenziale (tutti i valori nello stesso ordine consecutivo).

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

#### Funzioni binarie
<a name="engine-versions-reference-0003-binary-functions"></a>

**murmur3 (binario)** — Calcola l'hash MurmurHash 3 a 128 bit del file binario.

```
SELECT murmur3(from_base64('aaaaaa'));
```

#### Funzioni di conversione
<a name="engine-versions-reference-0003-conversion-functions"></a>

**format\$1number(number)**: Restituisce una stringa formattata utilizzando un simbolo di unità.

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

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

#### Funzioni di data e ora
<a name="engine-versions-reference-0003-date-and-time-functions"></a>

**timezone\$1hour(timestamp)**: Restituisce l'ora della differenza del fuso orario dal timestamp.

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

**timezone\$1minute(timestamp)**: Restituisce il minuto della differenza del fuso orario dal timestamp.

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

#### Funzioni geospaziali
<a name="engine-versions-reference-0003-geospatial-functions"></a>

**to\$1encoded\$1polyline(Geometry)**: codifica una linestring o un multipunto in una polilinea.

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

**from\$1encoded\$1polyline(varchar)**: decodifica una polilinea in una linestring.

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

**to\$1geojson\$1geometry (SphericalGeography)** — Restituisce la geografia sferica specificata in formato GeoJSON.

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

**from\$1geojson\$1geometry(varchar)**: Restituisce l'oggetto di tipo geografia sferica dalla rappresentazione GeoJSON, eliminando chiavi/valori non geometrici. `Feature` e `FeatureCollection` non sono supportati.

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

**geometry\$1nearest\$1points(Geometry, Geometry)**: Restituisce i punti di ogni geometria più vicini tra loro. Se una delle due geometrie è vuota, restituisce NULL. In caso contrario, restituisce una riga di due oggetti `Point` con la distanza minima di due punti qualsiasi sulle geometrie. Il primo punto e il secondo punto provengono rispettivamente dal primo e dal secondo argomento di geometria. Se ci sono più coppie con la stessa distanza minima, una coppia viene scelta arbitrariamente.

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

#### Funzioni set digest
<a name="engine-versions-reference-0003-set-digest-functions"></a>

**make\$1set\$1digest(x)**: compone tutti i valori di input di x in un setdigest.

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

#### Funzioni stringa
<a name="engine-versions-reference-0003-string-functions"></a>

**soundex(char)**: Restituisce una stringa di caratteri che contiene la rappresentazione fonetica di char.

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

**concat\$1ws(string0, string1, ..., stringN)**: Restituisce la concatenazione di `string1, string2, ..., stringN` utilizzando `string0` come separatore. Se `string0` è null, allora il valore restituito è null. Negli argomenti, tutti i valori null indicati dopo il separatore vengono ignorati.

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

#### Funzioni finestra
<a name="engine-versions-reference-0003-window-functions"></a>

**GROUPS**: aggiunge il supporto per le cornici delle finestre in base ai gruppi.

```
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);
```

### Miglioramenti in termini di prestazioni
<a name="engine-versions-reference-0003-performance-improvements"></a>

La versione 3 del motore Athena include alcuni miglioramenti in termini di prestazioni, tra cui i seguenti.
+ **Recupero più rapido dei metadati AWS Glue delle tabelle**: le query che coinvolgono più tabelle ridurranno i tempi di pianificazione delle query.
+ **Filtro dinamico per JOIN DESTRO**: il filtro dinamico è ora abilitato per le proprietà JOIN DESTRO con condizioni di join di uguaglianza, come nell'esempio seguente.

  ```
  SELECT * 
  FROM lineitem RIGHT JOIN tpch.tiny.supplier 
  ON lineitem.suppkey = supplier.suppkey 
  WHERE supplier.name = 'abc';
  ```
+ **Istruzioni preparate di grandi dimensioni: la dimensione predefinita dell' request/response intestazione HTTP è stata aumentata a 2 MB per consentire istruzioni preparate** di grandi dimensioni.
+ **approx\$1percentile ()**: la funzione `approx_percentile` ora utilizza `tdigest` invece di `qdigest` per recuperare valori quantili approssimativi dalle distribuzioni. Ciò si traduce in prestazioni più elevate e un minore utilizzo della memoria. Nota che a seguito di questa modifica, la funzione restituisce risultati diversi rispetto alle versioni precedenti del motore Athena. Per ulteriori informazioni, consulta [La funzione approx\$1percentile restituisce risultati diversi](#engine-versions-reference-0003-approx-percentile-function).

### Miglioramenti in termini di affidabilità
<a name="engine-versions-reference-0003-reliability-enhancements"></a>

L'utilizzo generale della memoria del motore e il monitoraggio nella versione 3 del motore Athena sono stati migliorati. Le query di grandi dimensioni sono meno soggette a errori causati dagli arresti anomali dei nodi.

### Miglioramenti in termini di sintassi delle query
<a name="engine-versions-reference-0003-query-syntax-enhancements"></a>

**INTERSECT ALL**: è stato aggiunto il supporto per `INTERSECT ALL`.

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

**EXCEPT ALL**: è stato aggiunto il supporto per `EXCEPT ALL`.

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

**RANGE PRECEDING**: è stato aggiunto il supporto per `RANGE PRECEDING` nelle funzioni finestra.

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

**MATCH\$1RECOGNIZE**: è stato aggiunto il supporto per la corrispondenza dei modelli di riga, come nell'esempio seguente.

```
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;
```

### Miglioramenti in termini di formato e tipo di dati
<a name="engine-versions-reference-0003-data-format-and-data-type-enhancements"></a>

La versione 3 del motore Athena presenta i seguenti miglioramenti in termini di formato e tipo di dati.
+ **LZ4 e ZSTD**: è stato aggiunto il supporto per la lettura LZ4 e la compressione dei dati di Parquet con ZSTD. È stato aggiunto il supporto per la scrittura di dati ORC compressi ZSTD.
+ **Tabelle basate su collegamenti simbolici**: è stato aggiunto il supporto per la creazione di tabelle basate su collegamenti simbolici per file Avro. Di seguito è riportato un esempio.

  ```
  CREATE TABLE test_avro_symlink  
  ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe'  
  ... 
  INPUTFORMAT 'org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat'
  ```
+ **SphericalGeography**— Il SphericalGeography tipo fornisce il supporto nativo per le caratteristiche spaziali rappresentate su coordinate geografiche (a volte chiamate coordinate geodetiche). lat/lon, or lon/lat Le coordinate geografiche sono coordinate sferiche espresse in unità angolari (gradi).

  La funzione `to_spherical_geography` restituisce le coordinate geografiche (sferiche) a partire da coordinate geometriche (piane), come nell'esempio seguente.

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

## Modifiche importanti
<a name="engine-versions-reference-0003-breaking-changes"></a>

Quando si esegue la migrazione dalle versioni precedenti del motore Athena alla versione 3, alcune modifiche possono influire sullo schema della tabella, sulla sintassi o sull’utilizzo del tipo di dati. Questa sezione elenca i messaggi di errore associati e offre alcuni suggerimenti per le soluzioni alternative.

### Modifiche alla sintassi delle query
<a name="engine-versions-reference-0003-syntax-changes"></a>

#### IGNORE NULLS non può essere utilizzato con funzioni di finestra senza valori
<a name="engine-versions-reference-0003-remove-ignore-nulls-for-bool_or"></a>

**Messaggio di errore**: Impossibile specificare la clausola di trattamento null per la funzione `bool_or`.

**Causa**: ora `IGNORE NULLS` può essere utilizzato solo con le [funzioni di valore](https://trino.io/docs/current/functions/window.html#value-functions) `first_value`, `last_value`, `nth_value`, `lead` e `lag`. Questa modifica è stata apportata per conformarsi alle specifiche SQL ANSI.

**Soluzione consigliata**: rimuovi `IGNORE NULLS` dalle funzioni finestra prive di valori nelle stringhe di query.

#### La funzione CONCAT deve avere due o più argomenti
<a name="engine-versions-reference-0003-concat-str-minimum-two-args"></a>

**Messaggio di errore**: INVALID\$1FUNCTION\$1ARGUMENT: There must be two or more concatenation arguments (Argomento della funzione non valido: devono essere presenti due o più argomenti di concatenazione)

**Causa**: in precedenza, la funzione della stringa `CONCAT` accettava un singolo argomento. Nella versione 3 del motore Athena, la funzione `CONCAT` richiede un minimo di due argomenti.

**Soluzione consigliata**: modifica le occorrenze di `CONCAT(str)` in `CONCAT(str, '')`.

Nella versione 3 del motore Athena, le funzioni non possono avere più di 127 argomenti. Per ulteriori informazioni, consulta [Troppi argomenti per la chiamata di funzione](troubleshooting-athena.md#troubleshooting-athena-too-many-arguments).

#### La funzione approx\$1percentile restituisce risultati diversi
<a name="engine-versions-reference-0003-approx-percentile-function"></a>

La funzione `approx_percentile` restituisce risultati diversi nella versione 3 del motore Athena rispetto alle versioni precedenti del motore Athena.

**Messaggio di errore**: nessuno.

**Causa**: la funzione `approx_percentile` è soggetta a modifiche di versione.

**Importante**  
Poiché i risultati della funzione `approx_percentile` sono approssimazioni e le approssimazioni sono soggette a modifiche da una versione all'altra, non è consigliabile fare affidamento sulla funzione `approx_percentile` per applicazioni critiche.

**Soluzione consigliata**: per approssimare il comportamento delle versioni precedenti di `approx_percentile`, puoi utilizzare un set diverso di funzioni nella versione 3 del motore Athena. Ad esempio, supponi di avere la seguente query nelle versioni precedenti del motore:

```
SELECT approx_percentile(somecol, 2E-1)
```

Per ottenere approssimativamente lo stesso risultato nella versione 3 del motore Athena, puoi provare le funzioni `qdigest_agg` e `value_at_quantile`, come nell'esempio seguente. Tieni presente che, anche con questa soluzione alternativa, lo stesso comportamento non è garantito.

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

#### La funzione geospaziale non supporta l'input varbinary
<a name="engine-versions-reference-0003-geo-spatial-function-does-not-support-varbinary-input"></a>

**Messaggio di errore**: FUNCTION\$1NOT\$1FOUND for st\$1XXX (Funzione non trovata per st\$1XXX)

**Causa**: alcune funzioni geospaziali non supportano più il tipo di input `VARBINARY` legacy o le firme delle funzioni correlate al testo.

**Soluzione consigliata**: utilizza le funzioni geospaziali per convertire i tipi di input in tipi supportati. I tipi di input supportati sono indicati nel messaggio di errore.

#### Nelle clausole GROUP BY, le colonne annidate devono essere racchiuse tra virgolette
<a name="engine-versions-reference-0003-group-by-nested-columns-require-double-quotes"></a>

**Messaggio di errore**: "«*column\$1name*.» *nested\$1column*"deve essere un'espressione aggregata o apparire nella clausola GROUP BY

**Causa**: la versione 3 del motore Athena richiede che i nomi delle colonne annidate nelle clausole `GROUP BY` siano tra virgolette doppie. Ad esempio, la seguente query produce l’errore perché, nella clausola `GROUP BY`, `user.name` non è tra virgolette.

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

**Soluzione consigliata**: inserisci le virgolette doppie attorno ai nomi delle colonne annidate nelle clausole `GROUP BY`, come nell'esempio seguente.

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

#### FilterNode Errore imprevisto durante l'utilizzo di OPTIMIZE su una tabella Iceberg
<a name="engine-versions-reference-0003-iceberg-optimize-where-clause-filters"></a>

**Messaggio di errore**: è stato  FilterNoderilevato un problema imprevisto nel piano; probabilmente il connettore non è stato in grado di gestire l'espressione WHERE fornita.

**Causa**: l’`OPTIMIZE`istruzione eseguita sulla tabella Iceberg utilizzava una `WHERE` clausola che includeva una colonna non di partizione nell’espressione di filtro.

**Soluzione consigliata**: l’`OPTIMIZE`istruzione supporta il filtraggio solo per partizioni. Quando esegui `OPTIMIZE` su tabelle partizionate, includi solo le colonne di partizione nella clausola. `WHERE` Se eseguite `OPTIMIZE` su una tabella non partizionata, non specificate alcuna clausola. `WHERE`

#### Ordine degli argomenti della funzione Log()
<a name="engine-versions-reference-0003-log-function"></a>

Nella versione 3 del motore Athena, l’ordine degli argomenti per la `log()` funzione è stato modificato `log(base, value)` in conformità agli standard SQL.

#### La funzione minute() non supporta gli intervalli anno-mese
<a name="engine-versions-reference-0003-minute-function"></a>

**Messaggio di errore**: Unexpected parameters (interval year to month) for function minute. (Parametri non previsti [intervallo anno-mese] per i minuti della funzione.) Expected: minute(timestamp with time zone) , minute(time with time zone) , minute(timestamp) , minute(time) , minute(interval day to second). (Valori previsti: minute[timestamp with time zone], minute[time with time zone], minute[timestamp], minute[time], minute[interval day to second])

**Causa**: nella versione 3 del motore Athena, i controlli relativi al tipo di dati sono stati resi più precisi per `EXTRACT` in base alle specifiche SQL ANSI.

**Soluzione consigliata**: aggiorna le query per assicurarti che i tipi corrispondano alle firme delle funzioni suggerite.

#### Le espressioni ORDER BY devono essere visualizzate nell'elenco SELECT
<a name="engine-versions-reference-0003-order-by-expressions-must-appear-in-select-list"></a>

**Messaggio di errore**: For SELECT DISTINCT, ORDER BY expressions must appear in SELECT list (Per SELECT DISTINCT, le espressioni ORDER BY devono essere visualizzate nell'elenco SELECT)

**Causa**: in una clausola `SELECT` viene utilizzato un alias di tabella errato.

**Soluzione consigliata**: verifica che tutte le colonne dell'espressione `ORDER BY` contengano i riferimenti corretti nella clausola `SELECT DISTINCT`.

#### Errore di query durante il confronto di più colonne restituite da una sottoquery
<a name="engine-versions-reference-0003-subquery-failure-multiple-columns"></a>

**Esempio di messaggio di errore**: l'espressione del valore e il risultato della sottoquery devono essere dello stesso tipo: row(varchar, varchar) vs row(row(varchar, varchar))

**Causa**: A causa di un aggiornamento della sintassi nella versione 3 del motore Athena, questo errore si verifica quando una query tenta di confrontare più valori restituiti da una sottoquery e l'istruzione `SELECT` della sottoquery racchiude l'elenco di colonne tra parentesi, come nell'esempio seguente. 

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

**Soluzione**: nella versione 3 del motore Athena, rimuovi la parentesi attorno all'elenco di colonne nell'istruzione `SELECT` della sottoquery, come nella seguente query di esempio aggiornata.

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

#### SKIP è una parola riservata per le query DML
<a name="engine-versions-reference-0003-skip-is-a-reserved-word-for-dml"></a>

La parola `SKIP` ora è una parola riservata per le query DML come `SELECT`. Per utilizzare la parola `SKIP` come identificatore in una query DML, racchiuderla tra virgolette doppie.

Per ulteriori informazioni sulle parole riservate in Athena, consulta [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md).

#### Le clausole SYSTEM\$1TIME e SYSTEM\$1VERSION sono obsolete per le query temporali
<a name="engine-versions-reference-0003-time-travel-syntax"></a>

**Messaggio di errore**: mismatched input 'SYSTEM\$1TIME'. (Input 'SYSTEM\$1TIME' non corrispondente.) Expecting (Valore atteso): 'TIMESTAMP', 'VERSION'

**Causa**: nelle versioni precedenti, le tabelle Iceberg utilizzavano le clausole `FOR SYSTEM_TIME AS OF` e `FOR SYSTEM_VERSION AS OF` per le query temporali su timestamp e versione. La versione 3 del motore Athena utilizza le clausole `FOR TIMESTAMP AS OF` e `FOR VERSION AS OF`. 

**Soluzione consigliata**: aggiorna la query SQL per utilizzare le clausole `TIMESTAMP AS OF` e `VERSION AS OF` per le operazioni temporali, come negli esempi seguenti.

Query temporale per timestamp:

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

 Query temporale per versione:

```
SELECT * FROM TABLE FOR VERSION AS OF 949530903748831860
```

#### Numero di argomenti eccessivo per un costruttore di array
<a name="engine-versions-reference-0003-array-max-elements"></a>

**Messaggio di errore**: TOO\$1MANY\$1ARGUMENTS: Numero di argomenti eccessivo per il costruttore di array.

**Causa**: il numero massimo di elementi in un costruttore di array è ora impostato a 254.

**Soluzione consigliata**: suddividi gli elementi in più matrici con 254 o meno elementi ciascuna e utilizza la funzione `CONCAT` per concatenare le matrici, come nell'esempio seguente.

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

#### Identificatore delimitato di lunghezza zero non consentito
<a name="engine-versions-reference-0003-zero-length-delimited-identifier"></a>

**Messaggio di errore**: Zero-length delimited identifier not allowed. (Identificatore delimitato di lunghezza zero non consentito.)

**Causa**: una query utilizzava una stringa vuota come alias di colonna.

**Soluzione consigliata**: aggiorna la query in modo che utilizzi un alias non vuoto per la colonna.

### Modifiche a livello di elaborazione dati
<a name="engine-versions-reference-0003-data-processing-changes"></a>

#### Convalida del bucket
<a name="engine-versions-reference-0003-bucket-validation"></a>

**Messaggio di errore**: HIVE\$1INVALID\$1BUCKET\$1FILES: la tabella Hive è danneggiata.

**Causa**: la tabella potrebbe essere danneggiata. Per garantire la correttezza delle query per le tabelle con periodi fissi, la versione 3 del motore Athena consente una verifica aggiuntiva sulle tabelle con periodi fissi per garantire la correttezza delle query ed evitare errori imprevisti durante il runtime.

**Soluzione consigliata**: ricrea la tabella utilizzando la versione 3 del motore Athena.

#### La trasmissione di uno struct in JSON ora restituisce i nomi dei campi
<a name="engine-versions-reference-0003-cast-struct-to-json"></a>

Quando trasmetti uno `struct` a JSON in una query `SELECT` nella versione 3 del motore Athena, la trasmissione ora restituisce sia i nomi dei campi che i valori (ad esempio "`useragent":null`) anziché solo i valori (ad esempio, `null`).

#### Modifica dell'applicazione della sicurezza a livello di colonna delle tabelle Iceberg
<a name="engine-versions-reference-0003-iceberg-column-security"></a>

**Messaggio di errore**: Access Denied: Cannot select from columns (Accesso negato: impossibile selezionare dalle colonne)

**Causa**: la tabella Iceberg è stata creata all'esterno di Athena e utilizza una versione dell'[SDK di Apache Iceberg](https://iceberg.apache.org/releases/) precedente alla 0.13.0. Poiché le versioni precedenti dell'SDK non compilavano le colonne in AWS Glue, Lake Formation non era in grado di determinare le colonne autorizzate per l'accesso.

**Soluzione consigliata**: esegui un aggiornamento utilizzando l'istruzione [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md) di Athena o utilizza l'ultima versione dell'SDK di Iceberg per correggere la tabella e aggiornare le informazioni della colonna in AWS Glue.

#### I valori Null nei tipi di dati List vengono ora propagati a UDFs
<a name="engine-versions-reference-0003-nulls-in-list-datatypes-for-udfs"></a>

**Messaggio di errore**: Null Pointer Exception (Eccezione del puntatore null)

**Causa**: questo problema può verificarsi se utilizzi il connettore UDF con una funzione Lambda definita dall'utente.

Le versioni precedenti del motore hanno filtrato i valori null nei tipi di dati elenco che sono stati trasferiti a una funzione definita dall’utente. Nella versione 3 del motore Athena, i valori null vengono ora mantenuti e trasmessi all'UDF. Ciò può causare un'eccezione del puntatore null se la funzione definita dall'utente tenta di annullare l'elemento null senza eseguire una verifica.

Ad esempio, se i dati `[null, 1, null, 2, 3, 4]` sono presenti in un'origine dati come DynamoDB, alla funzione Lambda definita dall'utente vengono tramessi gli elementi seguenti:

**Versione 3 del motore Athena**: `[null, 1, null, 2, 3, 4]`

**Soluzione consigliata**: assicurati che la funzione Lambda definita dall'utente gestisca gli elementi null per i tipi di dati elenco.

#### Le sottostringhe delle matrici di caratteri non contengono più spazi riempiti
<a name="engine-versions-reference-0003-substring-no-padded-spaces"></a>

**Messaggio di errore**: non viene generato alcun errore, ma la stringa restituita non contiene più spazi riempiti. Ad esempio, `substr(char[20],1,100)` ora restituisce una stringa con lunghezza 20 anziché 100.

**Soluzione consigliata**: non è richiesta alcuna azione.

#### Coercizione del tipo di colonna decimale non supportata
<a name="engine-versions-reference-0003-unsupported-column-type"></a>

**Messaggi di errore**: HIVE\$1CURSOR\$1ERROR: Impossibile leggere il file Parquet: s3://amzn-s3-demo-bucket/*path*/*file\$1name*.parquet o tipo di colonna non supportato (varchar) per la colonna Parquet ([] *column\$1name*

**Causa: la** versione 2 del motore Athena ha avuto successo occasionalmente (ma spesso ha avuto esito negativo) nel tentativo di coercizione dei tipi di dati da `varchar` al numero decimale. Poiché la versione 3 del motore Athena dispone di una convalida del tipo che verifica che questo sia compatibile prima di provare a leggere il valore, questi tentativi di coercizione ora falliscono sempre.

**Soluzione consigliata**: per la versione 3 del motore Athena, modificate lo schema in AWS Glue modo da utilizzare un tipo di dati numerico anziché `varchar` per le colonne decimali nei file Parquet. Scansiona nuovamente i dati e assicurati che il nuovo tipo di dati della colonna sia di tipo decimale oppure ricrea manualmente la tabella in Athena e usa la sintassi `decimal(precision, scale)` per specificare un tipo di dati per la colonna [decimal](data-types.md#data-types-decimal).

#### I valori Float o double NaN non possono più essere convertiti a bigint
<a name="engine-versions-reference-0003-no-nan-to-bigint"></a>

**Messaggio di errore**: INVALID\$1CAST\$1ARGUMENT: impossibile eseguire il cast di NaN su bigint real/double 

**Causa**: nella versione 3 del motore Athena, `NaN` non può più convertire a 0 come `bigint`.

**Soluzione consigliata**: assicurati che i valori `NaN` non siano presenti nelle colonne `float` o `double` quando converti in `bigint`.

#### modifica del tipo di ritorno della funzione uuid ()
<a name="engine-versions-reference-0003-uuid-function-return-type-change"></a>

Il problema seguente riguarda sia le tabelle che le viste.

**Messaggio di errore**: Tipo di Hive non supportato: uuid

**Causa**: nelle versioni precedenti, la funzione `uuid()` restituiva una stringa, ma nella versione 3 del motore Athena restituisce un UUID generato in modo pseudo casuale (tipo 4). Poiché il tipo di dati della colonna UUID non è supportato in Athena, la funzione `uuid()` non può più essere utilizzata direttamente nelle query CTAS per generare colonne UUID nella versione 3 del motore Athena.

Ad esempio, la seguente istruzione `CREATE TABLE` viene completata correttamente nelle versioni precedenti del motore Athena ma restituisce NOT\$1SUPPORTED: tipo di Hive non supportata: uuid nella versione 3 del motore Athena:

```
CREATE TABLE uuid_table AS 
   SELECT uuid() AS myuuid
```

Analogamente, la seguente `CREATE VIEW` istruzione è stata completata correttamente nella versione 2 del motore Athena ma restituisce un tipo di colonna non valido per la colonna myuuid: Tipo di hive non supportato: uuid nella versione 3 del motore Athena:

```
CREATE VIEW uuid_view AS 
   SELECT uuid() AS myuuid
```

Quando su una visualizzazione così creata nelle versioni precedenti viene eseguita una query nella versione 3 del motore Athena, si verifica un errore simile al seguente:

VIEW\$1IS\$1STALE: line 1:15: View 'awsdatacatalog.mydatabase.uuid\$1view' è obsoleta o in stato non valido: la colonna [myuuid] di tipo uuid proiettata dalla visualizzazione della query nella posizione 0 non può essere forzata alla colonna [myuuid] di tipo varchar memorizzata nella definizione della visualizzazione

**Soluzione consigliata**: quando crei la tabella o la visualizzazione, utilizza la funzione `cast()` per convertire l'output di `uuid()` in `varchar`, come negli esempi seguenti:

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

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

#### Problemi di coercizione CHAR e VARCHAR
<a name="engine-versions-reference-0003-char-varchar-coercion-issues"></a>

Usa le soluzioni alternative in questa sezione se riscontri problemi di coercizione con `varchar` e `char` nella versione 3 del motore Athena. Se non riesci a utilizzare queste soluzioni alternative, contatta. Supporto

##### Errore della funzione CONCAT con ingressi misti CHAR e VARCHAR
<a name="engine-versions-reference-0003-concat-function-failure"></a>

**Problema**: la seguente query ha esito positivo sulla versione 2 del motore Athena.

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

Tuttavia, nella versione 3 del motore Athena, la stessa query ha esito negativo con quanto segue:

**Messaggio di errore**: FUNCTION\$1NOT\$1FOUND: riga 1:8: Parametri imprevisti (varchar(20), varchar(2), char(1)) per la funzione concat. Previsto: concat(char(x), char(y)), concat(array(E), E) E, concat(E, array(E)) E, concat(array(E)) E, concat(varchar), concat(varbinary)

**Soluzione consigliata**: quando utilizzi la funzione `concat`, converti su `char` o `varchar`, ma non su una combinazione di entrambi.

##### SQL \$1\$1 errore di concatenazione con gli input CHAR e VARCHAR
<a name="engine-versions-reference-0003-double-pipe-char-varchar-failure"></a>

Nella versione 3 del motore Athena, l'operatore di concatenazione `||` a doppia barra verticale richiede input come input `varchar`. Gli input non possono essere una combinazione di tipi `varchar` e `char`.

**Messaggio di errore**: TYPE\$1NOT\$1FOUND: riga 1:26: Tipo sconosciuto: char(65537) 

**Causa**: una query che utilizza `||` per concatenare `char` e `varchar` può generare l'errore, come nell'esempio seguente.

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

**Soluzione consigliata**: concatena `varchar` con `varchar`, come nell'esempio seguente.

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

##### Errore nelle query CHAR e VARCHAR UNION
<a name="engine-versions-reference-0003-char-varchar-union-query-failure"></a>

**Messaggio di errore**: NOT\$1SUPPORTED: tipo di hive non supportato: char (65536). Tipi di CHAR supportati: CHAR (<=255)

**Causa**: una query che tenta di combinare `char` e `varchar`, come nell'esempio seguente:

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

**Soluzione consigliata**: nella query di esempio, converti `'a'` come `varchar` anziché`char`. 

##### Spazi vuoti indesiderati dopo la coercizione CHAR o VARCHAR
<a name="engine-versions-reference-0003-empty-spaces-added-after-coercion"></a>

Nella versione 3 del motore Athena, quando i dati di `char(X)` e `varchar` vengono forzati a un unico tipo quando formano una matrice o una singola colonna, `char(65535)` è il tipo di destinazione e ogni campo contiene molti spazi finali indesiderati.

**Causa:** la versione 3 del motore Athena costringe `varchar` e `char(X)` a `char(65535)`, quindi riempe a destra i dati con spazi.

**Soluzione consigliata**: converti esplicitamente ogni campo in `varchar`.

### Modifiche al timestamp
<a name="engine-versions-reference-0003-timestamp-changes"></a>

#### L'overflow del timestamp della data genera un errore
<a name="engine-versions-reference-0003-date-timestamp-overflow"></a>

**Messaggio di errore**: Millis overflow: XXX (Overflow di millisecondi: XXX)

**Causa**: poiché le date ISO8601 non erano controllate per l’overflow nelle versioni precedenti, alcune date hanno prodotto un timestamp negativo. La versione 3 del motore Athena verifica la presenza di questo overflow e genera un'eccezione.

**Soluzione consigliata**: assicurati che il timestamp sia compreso nell'intervallo.

#### Fusi orari politici con TIME non supportati
<a name="engine-versions-reference-0003-political-time-zones"></a>

**Messaggio di errore**: INVALID LITERAL (Valore letterale non valido)

**Causa**: query come `SELECT TIME '13:21:32.424 America/Los_Angeles'`.

**Soluzione consigliata**: evita di utilizzare fusi orari politici con `TIME`.

#### La mancata corrispondenza di precisione nelle colonne Timestamp causa un errore di serializzazione
<a name="engine-versions-reference-0003-timestamp-precision-serialization-error"></a>

**Messaggio di errore**: SERIALIZATION\$1ERROR: Impossibile serializzare la colonna '' di tipo 'timestamp (3*COLUMNZ*) 'nella posizione: *X* *Y*

*COLUMNZ*è il nome di output della colonna che causa il problema. I numeri*X*: *Y* indicano la posizione della colonna nell'output.

**Causa**: la versione 3 del motore Athena verifica che la precisione dei timestamp nei dati corrisponda a quella specificata per il tipo di dati della colonna nelle specifiche della tabella. Attualmente, questa precisione è sempre pari a 3. Se i dati hanno una precisione maggiore, le query hanno esito negativo e viene restituito l'errore.

**Soluzione consigliata**: controlla i dati per assicurarti che i timestamp abbiano una precisione al millisecondo.

#### Precisione del timestamp errata nelle query UNLOAD e CTAS per le tabelle Iceberg
<a name="engine-versions-reference-0003-timestamp-precision-unload-ctas-iceberg"></a>

**Messaggio di errore**: precisione del timestamp errata per il timestamp (6); la precisione configurata è MILLISECONDI

**Causa**: la versione 3 del motore Athena verifica che la precisione dei timestamp nei dati corrisponda a quella specificata per il tipo di dati della colonna nelle specifiche della tabella. Attualmente, questa precisione è sempre pari a 3. Se i dati hanno una precisione maggiore di questa (ad esempio, microsecondi anziché millisecondi), le query possono avere esito negativo con l'errore rilevato.

**Soluzione**: per risolvere questo problema, innanzitutto `CAST` la precisione del timestamp a 6, come nel seguente esempio CTAS che crea una tabella Iceberg. Nota che la precisione deve essere specificata come 6 anziché 3 per evitare l'errore Precisione (3) timestamp non supportata per 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
```

Quindi, poiché Athena non supporta il timestamp 6, converti nuovamente il valore in timestamp (ad esempio, in una visualizzazione). Il seguente esempio crea una visualizzazione dalla tabella `my_iceberg_ctas`.

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

#### Ora la lettura del valore di tipo Long come timestamp o viceversa causa nei file ORC un errore indicante un file ORC non valido
<a name="engine-versions-reference-0003-orc-no-implicit-long-to-timestamp-coercion"></a>

**Messaggio di errore**: Error opening Hive split 'FILE (SPLIT POSITION)' Malformed ORC file. (Errore durante l'apertura del file ORC non valido "FILE [SPLIT POSITION]" della suddivisione di Hive.) Cannot read SQL type timestamp from ORC stream .long\$1type of type LONG (Impossibile leggere il timestamp di tipo SQL dal flusso ORC .long\$1type di tipo LONG)

**Causa**: la versione 3 del motore Athena ora rifiuta la coercizione implicita dal tipo di dati `Long` a `Timestamp` o da `Timestamp` a `Long`. In precedenza, i valori `Long` venivano convertiti implicitamente in timestamp come se fossero millisecondi epoch.

**Soluzione consigliata**: utilizza la funzione `from_unixtime` per trasmettere in modo esplicito la colonna o utilizza la funzione `from_unixtime` per creare una colonna aggiuntiva per le query future.

#### Ora e intervallo anno-mese non supportati
<a name="engine-versions-reference-0003-time-and-interval-year-to-month"></a>

**Messaggio di errore**: TYPE MISMATCH (Tipo non corrispondente)

**Causa**: la versione 3 del motore Athena non supporta l'ora e l'intervallo anno-mese (ad esempio, `SELECT TIME '01:00' + INTERVAL '3' MONTH`).

#### Overflow del timestamp per il formato Parquet int96
<a name="engine-versions-reference-0003-timestamp-overflow-for-int96-parquet-format"></a>

**Messaggio di errore**: Nanos non valido timeOfDay

**Causa**: overflow del timestamp per il formato Parquet `int96`.

**Soluzione consigliata**: identifica i file specifici che presentano il problema. Quindi genera nuovamente il file di dati con una up-to-date libreria Parquet ben nota o usa Athena CTAS. Se il problema persiste, contatta l'assistenza di Athena indicando il modo in cui vengono generati i file di dati.

#### Spazio richiesto tra i valori di data e ora per la conversione da una stringa a un timestamp
<a name="engine-versions-reference-0003-timestamp-cast-space"></a>

**Messaggio di errore**: INVALID\$1CAST\$1ARGUMENT: impossibile convertire il valore in timestamp.

**Causa:** la versione 3 del motore Athena non accetta più un trattino come separatore valido tra i valori di data e ora nella stringa di input di `cast`. Ad esempio, la seguente query non funziona nella versione 3 del motore Athena:

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

**Soluzione consigliata**: nella versione 3 del motore Athena, sostituisci il trattino tra la data e l'ora con uno spazio, come nell'esempio seguente.

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

#### modifica del valore di ritorno del timestamp to\$1iso8601 ()
<a name="engine-versions-reference-0003-to-iso8601-function"></a>

**Messaggio di errore**: nessuno

**Causa**: nelle versioni precedenti del motore, la funzione `to_iso8601` restituisce un timestamp con fuso orario anche se il valore passato alla funzione non include il fuso orario. Nella versione 3 del motore Athena, la funzione `to_iso8601` restituisce un timestamp con fuso orario solo quando l'argomento passato include il fuso orario.

Ad esempio, la seguente query passa la data corrente alla funzione `to_iso8601` due volte: prima come timestamp con fuso orario e poi come timestamp.

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

L’output seguente mostra il risultato della query in ogni motore.

Nelle versioni precedenti del motore:


****  

| \$1 | \$1col0 | \$1col1 | 
| --- | --- | --- | 
| 1 |  `2023-02-24T00:00:00.000Z `  |  `2023-02-24T00:00:00.000Z`  | 

Versione 3 del motore Athena:


****  

| \$1 | \$1col0 | \$1col1 | 
| --- | --- | --- | 
| 1 |  `2023-02-24T00:00:00.000Z`  |  `2023-02-24T00:00:00.000`  | 

**Soluzione consigliata**: per replicare il comportamento precedente, puoi passare il valore del timestamp alla funzione `with_timezone` prima di passarlo a`to_iso8601`, come nell'esempio seguente: 

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

Risultato


****  

| \$1 | \$1col0 | 
| --- | --- | 
| 1 |  2023-01-01T00:00:00.000Z  | 

#### at\$1timezone () il primo parametro deve specificare una data
<a name="engine-versions-reference-at-timezone-function"></a>

**Problema**: nella versione 3 del motore Athena, la funzione `at_timezone` non può assumere un valore `time_with_timezone` come primo parametro.

**Causa**: senza informazioni sulla data, non è possibile determinare se il valore passato è l'ora legale o l'ora solare. Ad esempio, `at_timezone('12:00:00 UTC', 'America/Los_Angeles')` è ambiguo poiché non è possibile determinare se il valore passato è Pacific Daylight Time (PDT) o Pacific Standard Time (PST).

## Limitazioni
<a name="engine-versions-reference-0003-known-limitations"></a>

La versione 3 del motore Athena presenta le limitazioni seguenti.
+ **Prestazioni delle query**: molte query vengono eseguite più velocemente sulla versione 3 del motore Athena, ma alcuni piani di query possono differire dalle versioni precedenti del motore. Di conseguenza, alcune query possono differire in termini di latenza o costi.
+ **Connettori Trino e Presto**: i connettori [Trino](https://trino.io/docs/current/connector.html) e [Presto](https://prestodb.io/docs/current/connector.html) non sono supportati. Utilizzare Amazon Athena Federated Query per collegare le origini dati. Per ulteriori informazioni, consulta [Utilizza Amazon Athena Federated Query](federated-queries.md).
+ **Esecuzione a tolleranza di errore**: l'[esecuzione a tolleranza di errore](https://trino.io/docs/current/admin/fault-tolerant-execution.html) di Trino (Trino Tardigrade) non è supportata.
+ **Limite dei parametri della funzione**: le funzioni non possono richiedere più di 127 parametri. Per ulteriori informazioni, consulta [Troppi argomenti per la chiamata di funzione](troubleshooting-athena.md#troubleshooting-athena-too-many-arguments).

I seguenti limiti sono stati introdotti nella versione 2 del motore Athena per garantire che le query non abbiano esito negativo a causa di limitazioni di risorse. Questi limiti non sono configurabili dagli utenti.
+ **Numero degli elementi del risultato**— Il numero di elementi del risultato `n` è limitato a 10.000 o meno per le seguenti funzioni: `min(col, n)`, `max(col, n)`, `min_by(col1, col2, n)` e `max_by(col1, col2, n)`.
+ **GROUPING SETS** – Il numero massimo di sezioni in un gruppo di raggruppamenti è 2048.
+ **Lunghezza massima della riga del file di testo**: la lunghezza massima della riga predefinita per i file di testo è 200 MB.
+ **Dimensione massima del risultato della funzione di sequenza** — La dimensione massima del risultato di una funzione di sequenza è 50.000 voci. Ad esempio, `SELECT sequence(0,45000,1)` ha esito positivo, ma `SELECT sequence(0,55000,1)` ha esito negativo con il messaggio di errore Il risultato della funzione di sequenza non deve avere più di 50.000 voci. Questo limite è valido per tutti i tipi di input per funzioni di sequenza, inclusi i le marche temporali.