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

# Amazon Ion Hive SerDe
<a name="ion-serde"></a>

Puoi utilizzare Amazon Ion Hive SerDe per interrogare i dati archiviati in formato [Amazon Ion](https://amzn.github.io/ion-docs/guides/cookbook.html). Amazon Ion è un formato di dati open source altamente tipizzato e autodescrittivo. Il formato Amazon Ion è utilizzato nel linguaggio di query SQL open source [PartiQL](https://partiql.org/).

Amazon Ion ha formati binari e testuali intercambiabili. Questa funzione combina la facilità d'uso del testo con l'efficienza della codifica binaria.

Per interrogare i dati Amazon Ion di Athena, puoi utilizzare [Amazon Ion Hive SerDe](https://github.com/amzn/ion-hive-serde), che serializza e deserializza i dati Amazon Ion. La deserializzazione ti consente di eseguire query sui dati Amazon Ion o di leggerli per scriverli in un formato diverso come Parquet o ORC. La serializzazione ti consente di generare dati nel formato Amazon Ion utilizzando `CREATE TABLE AS SELECT` (CTAS) o query `INSERT INTO` per copiare dati da tabelle esistenti.

**Nota**  
Poiché Amazon Ion è un superset di JSON, puoi utilizzare Amazon Ion Hive SerDe per interrogare set di dati JSON non Amazon Ion. A differenza di altre [ SerDelibrerie JSON](https://docs.aws.amazon.com/athena/latest/ug/json-serde.html), Amazon Ion SerDe non prevede che ogni riga di dati si trovi su una singola riga. Questa funzione è utile se si desidera eseguire query su set di dati JSON in formato «pretty print» o se si desidera suddividere i campi di una riga con caratteri di nuova riga.

Per ulteriori informazioni ed esempi di esecuzione di query su Amazon Ion con Athena, consulta [Analisi di set di dati Amazon Ion con Amazon Athena](https://aws.amazon.com/blogs/big-data/analyze-amazon-ion-datasets-using-amazon-athena/).

## Nome della libreria di serializzazione
<a name="library-name"></a>

Il nome della libreria di serializzazione per Amazon Ion SerDe è`com.amazon.ionhiveserde.IonHiveSerDe`. Per informazioni sul codice sorgente, consulta [Amazon Ion Hive SerDe](https://github.com/amazon-ion/ion-hive-serde) su GitHub .com.

## Considerazioni e limitazioni
<a name="ion-serde-considerations-and-limitations"></a>
+ **Campi duplicati**: le strutture Amazon Ion vengono ordinate e supportano i campi duplicati, mentre `STRUCT<>` e `MAP<>` di Hive no. Pertanto, quando deserializzi un campo duplicato da una struttura Amazon Ion, viene scelto un singolo valore in modo non deterministico e gli altri vengono ignorati.
+ **Tabelle dei simboli esterne non supportate**: attualmente, Athena non supporta le tabelle dei simboli esterne o le seguenti proprietà di Amazon Ion SerDe Hive:
  + `ion.catalog.class`
  + `ion.catalog.file`
  + `ion.catalog.url`
  + `ion.symbol_table_imports`
+ **Estensioni di file**: Amazon Ion utilizza le estensioni di file per determinare quale codec di compressione utilizzare per deserializzare i file Amazon Ion. Pertanto, i file compressi devono avere l'estensione del file corrispondente all'algoritmo di compressione utilizzato. Ad esempio, se viene utilizzato ZSTD, i file corrispondenti dovrebbero avere l'estensione `.zst`.
+ **Dati omogenei**: Amazon Ion non ha restrizioni sui tipi di dati che possono essere utilizzati per valori in campi specifici. Ad esempio, due documenti Amazon Ion diversi potrebbero avere un campo con lo stesso nome con tipi di dati diversi. Tuttavia, poiché Hive utilizza uno schema, tutti i valori estratti in una singola colonna Hive devono avere lo stesso tipo di dati.
+ **Restrizioni sul tipo di chiave**: quando serializzi dati da un altro formato in Amazon Ion, assicurati che il tipo di chiave mappa sia uno tra `STRING`, `VARCHAR`, oppure `CHAR`. Sebbene Hive ti consenta di utilizzare qualsiasi tipo di dati primitivo come chiave mappa, [Simboli Amazon Ion](https://amzn.github.io/ion-docs/docs/symbols.html) deve essere un tipo di stringa.
+ **Tipo Union**: Athena non supporta attualmente l'Hive [tipo Union](https://cwiki.apache.org/confluence/display/hive/languagemanual+types/#LanguageManualTypes-UnionTypesunionUnionTypes).
+ **Doppio tipo di dati**: Amazon Ion attualmente non supporta questo tipo di dati `double`.

**Topics**
+ [Nome della libreria di serializzazione](#library-name)
+ [Considerazioni e limitazioni](#ion-serde-considerations-and-limitations)
+ [Creare tabelle Amazon Ion](ion-serde-using-create-table.md)
+ [Utilizzare CTAS e INSERT INTO per creare tabelle Amazon Ion](ion-serde-using-ctas-and-insert-into-to-create-ion-tables.md)
+ [Riferimento alla SerDe proprietà Amazon Ion](ion-serde-using-ion-serde-properties.md)
+ [Utilizzare gli estrattori di percorso](ion-serde-using-path-extractors.md)

# Creare tabelle Amazon Ion
<a name="ion-serde-using-create-table"></a>

Per creare una tabella in Athena dai dati archiviati in formato Amazon Ion, è possibile utilizzare una delle seguenti tecniche in un'istruzione CREATE TABLE:
+ Specifica `STORED AS ION`. In questo utilizzo, non è necessario specificare Amazon Ion Hive in SerDe modo esplicito. Questa è l'opzione più semplice.
+ Specifica i percorsi della classe Amazon Ion nei campi `ROW FORMAT SERDE`, `INPUTFORMAT` e `OUTPUTFORMAT`.

È possibile utilizzare anche l'istruzione `CREATE TABLE AS SELECT` (CTAS) per creare tabelle Amazon Ion in Athena. Per informazioni, consulta [Utilizzare CTAS e INSERT INTO per creare tabelle Amazon Ion](ion-serde-using-ctas-and-insert-into-to-create-ion-tables.md).

## Specificare STORED AS ION
<a name="ion-serde-specifying-stored-as-ion"></a>

La seguente istruzione di esempio `CREATE TABLE` utilizza `STORED AS ION` prima della clausola `LOCATION` per creare una tabella basata sui dati di volo in formato Amazon Ion. La clausola `LOCATION` specifica il bucket o la cartella in cui si trovano i file di input in formato Ion. Tutti i file nella posizione specificata vengono scansionati.

```
CREATE EXTERNAL TABLE flights_ion (
    yr INT,
    quarter INT,
    month INT,
    dayofmonth INT,
    dayofweek INT,
    flightdate STRING,
    uniquecarrier STRING,
    airlineid INT,
)
STORED AS ION
LOCATION 's3://amzn-s3-demo-bucket/'
```

## Specificare i percorsi della classe Amazon Ion
<a name="ion-serde-specifying-the-ion-class-paths"></a>

Invece di usare la sintassi `STORED AS ION`, è possibile specificare esplicitamente i valori del percorso della classe Ion per le clausole `ROW FORMAT SERDE`, `INPUTFORMAT` e `OUTPUTFORMAT` come segue.


****  

| Parametro | Percorso della classe Ion | 
| --- | --- | 
| ROW FORMAT SERDE | 'com.amazon.ionhiveserde.IonHiveSerDe' | 
| STORED AS INPUTFORMAT | 'com.amazon.ionhiveserde.formats.IonInputFormat' | 
| OUTPUTFORMAT | 'com.amazon.ionhiveserde.formats.IonOutputFormat' | 

La seguente query DDL utilizza questa tecnica per creare la stessa tabella esterna dell'esempio precedente.

```
CREATE EXTERNAL TABLE flights_ion (
    yr INT,
    quarter INT,
    month INT,
    dayofmonth INT,
    dayofweek INT,
    flightdate STRING,
    uniquecarrier STRING,
    airlineid INT,
)
ROW FORMAT SERDE
 'com.amazon.ionhiveserde.IonHiveSerDe'
STORED AS INPUTFORMAT
 'com.amazon.ionhiveserde.formats.IonInputFormat'
OUTPUTFORMAT
 'com.amazon.ionhiveserde.formats.IonOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/'
```

Per informazioni sulle SerDe proprietà delle `CREATE TABLE` istruzioni in Athena, vedere. [Riferimento alla SerDe proprietà Amazon Ion](ion-serde-using-ion-serde-properties.md)

# Utilizzare CTAS e INSERT INTO per creare tabelle Amazon Ion
<a name="ion-serde-using-ctas-and-insert-into-to-create-ion-tables"></a>

Puoi utilizzare le istruzioni `CREATE TABLE AS SELECT` (CTAS) e `INSERT INTO` per copiare o inserire dati da una tabella ad una nuova in formato Amazon Ion in Athena.

In una query CTAS, specifica `format='ION'` nella clausola `WITH`, come nell'esempio seguente.

```
CREATE TABLE new_table
WITH (format='ION')
AS SELECT * from existing_table
```

Athena serializza di default i risultati di Amazon Ion in [Formato binario Ion](https://amzn.github.io/ion-docs/docs/binary.html), ma è possibile anche utilizzare il formato di testo. Per utilizzare il formato di testo, specifica `ion_encoding = 'TEXT'` nella clausola CTAS `WITH`, come nell'esempio seguente.

```
CREATE TABLE new_table
WITH (format='ION', ion_encoding = 'TEXT')
AS SELECT * from existing_table
```

Per maggiori informazioni sulle proprietà specifiche di Amazon Ion nella clausola CTAS `WITH`, consultare [Proprietà Amazon Ion per la clausola CTAS WITH](#ion-serde-ctas-with-clause-properties).

## Proprietà Amazon Ion per la clausola CTAS WITH
<a name="ion-serde-ctas-with-clause-properties"></a>

In una query CTAS, puoi utilizzare la `WITH` clausola per specificare il formato Amazon Ion e, facoltativamente, specificare l'algoritmo di compressione di and/or scrittura con codifica Amazon Ion da utilizzare.

**format**  
È possibile specificare la parola chiave `ION` come opzione di formato nella clausola `WITH` di una query CTAS. In tal caso, la tabella creata utilizza il formato specificato per `IonInputFormat` per le letture e serializza i dati nel formato specificato per `IonOutputFormat`.  
L'esempio seguente specifica che la query CTAS utilizza il formato Amazon Ion.  

```
WITH (format='ION')
```

**ion\$1encoding**  
Facoltativo  
Impostazione predefinita: `BINARY`  
Valori: `BINARY`, `TEXT`  
Specifica se i dati sono serializzati in formato binario Amazon Ion o in formato di testo Amazon Ion. L'esempio seguente specifica il formato di testo Amazon Ion.  

```
WITH (format='ION', ion_encoding='TEXT')
```

**write\$1compression**  
Facoltativo  
Impostazione predefinita: `GZIP`  
Valori: `GZIP`, `ZSTD`, `BZIP2`, `SNAPPY`, `NONE`  
Specifica l'algoritmo di compressione da utilizzare per comprimere i file di output.  
L'esempio seguente specifica che la query CTAS scrive il suo output in formato Amazon Ion utilizzando l’algoritmo di compressione [Zstandard](https://facebook.github.io/zstd/).  

```
WITH (format='ION', write_compression = 'ZSTD')       
```
Per ulteriori informazioni sulla compressione in Athena, consulta [Usa la compressione in Athena](compression-formats.md). 

Per ulteriori informazioni su altre proprietà CTAS in Athena, consulta [Proprietà tabella CTAS](create-table-as.md#ctas-table-properties).

# Riferimento alla SerDe proprietà Amazon Ion
<a name="ion-serde-using-ion-serde-properties"></a>

Questo argomento contiene informazioni sulle SerDe proprietà delle `CREATE TABLE` istruzioni in Athena. Per ulteriori informazioni ed esempi sull'utilizzo delle SerDe proprietà di Amazon Ion, consulta [SerDe le proprietà](https://github.com/amzn/ion-hive-serde/blob/master/docs/serde-properties.md) nella SerDe documentazione di Amazon Ion Hive su [GitHub](https://github.com/amzn/ion-hive-serde/tree/master/docs).

## Come specificare le SerDe proprietà di Amazon Ion
<a name="ion-serde-specifying-ion-serde-properties"></a>

Per specificare le proprietà di Amazon Ion Hive SerDe nella tua `CREATE TABLE` dichiarazione, utilizza la `WITH SERDEPROPERTIES` clausola. Poiché `WITH SERDEPROPERTIES` si tratta di un sottocampo della `ROW FORMAT SERDE` clausola, è necessario specificare `ROW FORMAT SERDE` prima il percorso della SerDe classe Amazon Ion Hive, come illustrato nella sintassi seguente.

```
...
ROW FORMAT SERDE
 'com.amazon.ionhiveserde.IonHiveSerDe'
WITH SERDEPROPERTIES (
 'property' = 'value',
 'property' = 'value',
...
)
```

Notare che, anche se la clausola `ROW FORMAT SERDE` è obbligatoria, se si desidera utilizzare `WITH SERDEPROPERTIES`, è possibile utilizzare sia `STORED AS ION` che la sintassi più lunga `INPUTFORMAT` e `OUTPUTFORMAT` per specificare il formato Amazon Ion.

## SerDe Proprietà Amazon Ion
<a name="ion-serde-ion-serde-properties"></a>

Di seguito sono elencate le SerDe proprietà di Amazon Ion che possono essere utilizzate nelle `CREATE TABLE` istruzioni in Athena.

**ion.encoding**  
Facoltativo  
Impostazione predefinita: `BINARY`  
Valori: `BINARY`, `TEXT`  
Questa proprietà dichiara se i nuovi valori aggiunti sono serializzati come [Amazon Ion](https://amzn.github.io/ion-docs/docs/binary.html) o in formato testo Amazon Ion.  
Il seguente esempio di SerDe proprietà specifica il formato di testo di Amazon Ion.  

```
'ion.encoding' = 'TEXT'
```

**ion.fail\$1on\$1overflow**  
Facoltativo  
Impostazione predefinita: `true`  
Valori: `true`, `false`  
Al contrario di Hive, Amazon Ion consente di utilizzare tipi numerici arbitrariamente grandi. Per impostazione predefinita, SerDe fallisce se il valore di Amazon Ion non rientra nella colonna Hive, ma puoi utilizzare l'opzione di `fail_on_overflow` configurazione per lasciare che il valore si sovrapponga invece di fallire.  
Questa proprietà può essere impostata a livello di tabella o colonna. Per specificarla a livello di tabella, occorre specificare `ion.fail_on_overflow` come nell'esempio seguente. Questo imposta di default il comportamento per tutte le colonne.  

```
'ion.fail_on_overflow' = 'true'
```
Per controllare una colonna specifica, specifica il nome della colonna tra `ion` e `fail_on_overflow`, delimitato da punti, come nell'esempio seguente.  

```
'ion.<column>.fail_on_overflow' = 'false'
```

**ion.path\$1extractor.case\$1sensitive**  
Facoltativo  
Impostazione predefinita: `false`  
Valori: `true`, `false`  
Determina se trattare i nomi dei campi Amazon Ion come maiuscole e minuscole. Quando`false`, SerDe ignora l'analisi delle maiuscole e minuscole dei nomi dei campi di Amazon Ion.  
Ad esempio, supponiamo di avere uno schema di tabella Hive che definisce un campo `alias` in minuscolo e un documento Amazon Ion con entrambi i campi `alias` e `ALIAS`, come nell'esempio seguente.  

```
-- Hive Table Schema
alias: STRING

-- Amazon Ion Document
{ 'ALIAS': 'value1'} 
{ 'alias': 'value2'}
```
L'esempio seguente mostra le SerDe proprietà e la tabella estratta risultante quando la distinzione tra maiuscole e minuscole è impostata su: `false`  

```
-- Serde properties
'ion.alias.path_extractor' = '(alias)'
'ion.path_extractor.case_sensitive' = 'false'

--Extracted Table
| alias    |
|----------|
| "value1" |
| "value2" |
```
L'esempio seguente mostra le SerDe proprietà e la tabella estratta risultante quando la distinzione tra maiuscole e minuscole è impostata su: `true`  

```
-- Serde properties
'ion.alias.path_extractor' = '(alias)'
'ion.path_extractor.case_sensitive' = 'true'

--Extracted Table
| alias    |
|----------|
| "value2" |
```
Nel secondo caso, il valore `value1` per il campo `ALIAS` viene ignorato quando la sensibilità tra maiuscole e minuscole è impostata su `true` e l'estrattore del percorso è specificato come `alias`.

**ione. *<column>*.path\$1extractor**  
Facoltativo  
Valore predefinito: NA  
Valori: stringa con percorso di ricerca  
Crea un estrattore di percorso con il percorso di ricerca specificato per la colonna data. Gli estrattori di percorso mappano i campi Amazon Ion alle colonne Hive. Se non vengono specificati estrattori di percorso, Athena li crea dinamicamente in fase di esecuzione in base ai nomi delle colonne.  
Il seguente esempio di estrattore di percorso mappa il `example_ion_field` al `example_hive_column`.  

```
'ion.example_hive_column.path_extractor' = '(example_ion_field)'
```
Per ulteriori informazioni sugli estrattori di percorso e i percorsi di ricerca, consulta [Utilizzare gli estrattori di percorso](ion-serde-using-path-extractors.md).

**ion.timestamp.serialization\$1offset**  
Facoltativo  
Impostazione predefinita: `'Z'`  
Valori: `OFFSET`, dove `OFFSET ` è rappresentato come `<signal>hh:mm`. Valori di esempio: `01:00`, `+01:00`, `-09:30`, `Z` (UTC 00:00)  
A differenza dei [timestamp](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-timestamp) di Apache Hive, che non hanno un fuso orario integrato e sono memorizzati come offset rispetto all'UNIX epoch, i timestamp Amazon Ion hanno un offset. Utilizza questa proprietà per specificare l'offset quando esegui la serializzazione su Amazon Ion.  
L'esempio seguente aggiunge un offset di un'ora.  

```
'ion.timestamp.serialization_offset' = '+01:00'       
```

**ion.serialize\$1null**  
Facoltativo  
Impostazione predefinita: `OMIT`  
Valori: `OMIT`, `UNTYPED`, `TYPED`  
Amazon Ion SerDe può essere configurato per serializzare o omettere colonne con valori nulli. È possibile scegliere di scrivere null fortemente tipizzati (`TYPED`) o null non tipizzati (`UNTYPED`). I null fortemente tipizzati vengono determinati in base alla mappatura predefinita di tipo Amazon Ion to Hive.  
L'esempio seguente specifica i valori null fortemente tipizzati.  

```
'ion.serialize_null'='TYPED'
```

**ion.ignore\$1malformed**  
Facoltativo  
Impostazione predefinita: `false`  
Valori: `true`, `false`  
When`true`, ignora le voci non corrette o l'intero file se non SerDe è in grado di leggerlo. Per ulteriori informazioni, consulta [Ignore malformed](https://github.com/amzn/ion-hive-serde/blob/master/docs/serde-properties.md#ignore-malformed) nella documentazione su. GitHub

**icona. *<column>*.serialize\$1as**  
Facoltativo  
Predefinito: tipo predefinito per la colonna.  
Valori: stringa contenente il tipo Amazon Ion  
Determina il tipo di dati Amazon Ion in cui viene serializzato un valore. Poiché i tipi Amazon Ion e Hive non hanno sempre una mappatura diretta, alcuni tipi di Hive hanno più tipi di dati validi per la serializzazione. Per serializzare i dati come tipo di dati non di default, utilizzare questa proprietà. Per ulteriori informazioni sulla mappatura dei tipi, consulta la pagina di [mappatura dei tipi di](https://github.com/amzn/ion-hive-serde/blob/master/docs/type-mapping.md) Amazon Ion su. GitHub  
Le colonne binarie Hive sono serializzate di default come BLOB Amazon Ion, ma possono anche essere serializzate come [ CLOB Amazon Ion](https://amzn.github.io/ion-docs/docs/stringclob.html#ion-clob) (oggetto carattere grande). L'esempio seguente serializza la colonna `example_hive_binary_column` come un CLOB.  

```
'ion.example_hive_binary_column.serialize_as' = 'clob'       
```

# Utilizzare gli estrattori di percorso
<a name="ion-serde-using-path-extractors"></a>

Amazon Ion ha un formato di file in stile documento, ma Apache Hive ha un formato a colonne semplice. Puoi utilizzare SerDe proprietà speciali di Amazon Ion chiamate `path extractors` per mappare tra i due formati. Gli estrattori di percorso appiattiscono il formato gerarchico di Amazon Ion, mappano i valori di Amazon Ion alle colonne di Hive e possono essere usati per rinominare i campi.

Athena può generare gli estrattori per conto tuo, ma è anche possibile definire estrattori personalizzati, se necessario.

**Topics**
+ [Utilizzare gli estrattori di percorsi generati da Athena](ion-serde-generated-path-extractors.md)
+ [Definire estrattori di percorso personalizzati](ion-serde-specifying-your-own-path-extractors.md)
+ [Utilizzare percorsi di ricerca negli estrattori di percorso](ion-serde-using-search-paths-in-path-extractors.md)
+ [Esempi di estrattori di percorso](ion-serde-examples.md)

# Utilizzare gli estrattori di percorsi generati da Athena
<a name="ion-serde-generated-path-extractors"></a>

Per impostazione predefinita, Athena cerca i valori Amazon Ion di primo livello che corrispondono ai nomi delle colonne Hive e crea estrattori di percorso in fase di runtime in base a questi valori. Se il formato dati Amazon Ion corrisponde allo schema della tabella Hive, Athena genera dinamicamente gli estrattori per conto tuo e non è necessario aggiungere ulteriori estrattori di percorso. Questi estrattori di percorso predefiniti non sono archiviati nei metadati della tabella.

Nell'esempio seguente viene illustrato come Athena genera estrattori in base al nome della colonna.

```
-- Example Amazon Ion Document
{
    identification: {
        name: "John Smith",
        driver_license: "XXXX"
    },
    
    alias: "Johnny"    
}

-- Example DDL
CREATE EXTERNAL TABLE example_schema2 (
    identification MAP<STRING, STRING>,
    alias STRING
)
STORED AS ION
LOCATION 's3://amzn-s3-demo-bucket/path_extraction1/'
```

I seguenti estrattori di esempio sono generati da Athena. Il primo estrae il campo `identification` alla colonna `identification` e il secondo estrae il campo `alias` alla colonna `alias`.

```
'ion.identification.path_extractor' = '(identification)'
'ion.alias.path_extractor' = '(alias)'
```

La seguente query di esempio mostra una tabella estratta.

```
|                  identification                    |  alias   |
|----------------------------------------------------|----------|
|{["name", "driver_license"],["John Smith", "XXXX"]} | "Johnny" |
```

# Definire estrattori di percorso personalizzati
<a name="ion-serde-specifying-your-own-path-extractors"></a>

Se i campi Amazon Ion non vengono mappati in modo ordinato alle colonne Hive, puoi specificare estrattori di percorso personalizzati. Nella clausola `WITH SERDEPROPERTIES` dell'istruzione `CREATE TABLE`, utilizza la seguente sintassi.

```
WITH SERDEPROPERTIES (
   "ion.path_extractor.case_sensitive" = "<Boolean>", 
   "ion.<column_name>.path_extractor" = "<path_extractor_expression>"
)
```

**Nota**  
Per impostazione predefinita, gli estrattori di percorso non distinguono tra maiuscole e minuscole. Per ignorare questa impostazione, imposta la [ion.path_extractor.case_sensitive](ion-serde-using-ion-serde-properties.md#ioncase) SerDe proprietà su`true`.

# Utilizzare percorsi di ricerca negli estrattori di percorso
<a name="ion-serde-using-search-paths-in-path-extractors"></a>

La sintassi della SerDe proprietà per l'estrattore di percorsi contiene: *<path\$1extractor\$1expression>*

```
"ion.<column_name>.path_extractor" = "<path_extractor_expression>"         
```

Puoi utilizzare il *<path\$1extractor\$1expression>* per specificare un percorso di ricerca che analizzi il documento Amazon Ion e trovi i dati corrispondenti. Il percorso di ricerca è racchiuso tra parentesi e può contenere uno o più dei seguenti componenti separati da spazi.
+ **Carattere jolly**: corrisponde a tutti i valori.
+ **Index (Indice)**: corrisponde al valore dell'indice numerico specificato. Gli indici sono a base zero.
+ **Testo**: corrisponde a tutti i valori i cui nomi di campo corrispondono al testo specificato.
+ **Annotazioni**: corrisponde ai valori specificati da un componente di percorso avvolto con le annotazioni specificate.

L'esempio seguente mostra un documento Amazon Ion e alcuni esempi di percorsi di ricerca.

```
-- Amazon Ion document
{
    foo: ["foo1", "foo2"] ,
    bar: "myBarValue", 
    bar: A::"annotatedValue"
}

-- Example search paths
(foo 0)       # matches "foo1"
(1)           # matches "myBarValue"
(*)           # matches ["foo1", "foo2"], "myBarValue" and A::"annotatedValue"
()            # matches {foo: ["foo1", "foo2"] , bar: "myBarValue", bar: A::"annotatedValue"}
(bar)         # matches "myBarValue" and A::"annotatedValue"
(A::bar)      # matches A::"annotatedValue"
```

# Esempi di estrattori di percorso
<a name="ion-serde-examples"></a>

I seguenti esempi di estrattori di percorso mostrano come appiattire e rinominare i campi o estrarre dati come testo Amazon Ion.

## Appiattire e rinominare i campi
<a name="ion-serde-flattening-and-renaming-fields"></a>

L'esempio seguente mostra una serie di percorsi di ricerca che appiattiscono e rinominano i campi. Nell'esempio vengono utilizzati i percorsi di ricerca per effettuare le operazioni seguenti:
+ Mappatura della colonna `nickname` per il campo `alias`
+ Mappatura della colonna `name` per il sottocampo `name` situato nella struttura `identification`.

Di seguito è riportato l'esempio di documento Amazon Ion.

```
-- Example Amazon Ion Document
{
    identification: {
        name: "John Smith",
        driver_license: "XXXX"
    },
    
    alias: "Johnny"    
}
```

Di seguito è riportato l'esempio dell'istruzione `CREATE TABLE` che definisce gli estrattori di percorso.

```
-- Example DDL Query
CREATE EXTERNAL TABLE example_schema2 (
    name STRING,
    nickname STRING
)
ROW FORMAT SERDE
 'com.amazon.ionhiveserde.IonHiveSerDe'
WITH SERDEPROPERTIES (
 'ion.nickname.path_extractor' = '(alias)',
 'ion.name.path_extractor' = '(identification name)'
 )
STORED AS ION
LOCATION 's3://amzn-s3-demo-bucket/path_extraction2/'
```

L'esempio seguente mostra i dati estratti.

```
-- Extracted Table
| name         |   nickname   |
|--------------|--------------|
| "John Smith" |  "Johnny"    |
```

Per ulteriori informazioni sui percorsi di ricerca e altri esempi di percorsi di ricerca, consulta la pagina [Ion Java Path Extraction](https://github.com/amzn/ion-java-path-extraction) su GitHub.

## Estrarre dati di volo in formato testo
<a name="ion-serde-extracting-flight-data-to-text-format"></a>

La seguente query di esempio `CREATE TABLE` utilizza `WITH SERDEPROPERTIES` per aggiungere estrattori di percorso per estrarre i dati di volo e specifica la codifica di output come testo Amazon Ion. Nell'esempio viene utilizzata la sintassi `STORED AS ION`.

```
CREATE EXTERNAL TABLE flights_ion (
    yr INT,
    quarter INT,
    month INT,
    dayofmonth INT,
    dayofweek INT,
    flightdate STRING,
    uniquecarrier STRING,
    airlineid INT,
)
ROW FORMAT SERDE
 'com.amazon.ionhiveserde.IonHiveSerDe'
WITH SERDEPROPERTIES (
 'ion.encoding' = 'TEXT',
 'ion.yr.path_extractor'='(year)',
 'ion.quarter.path_extractor'='(results quarter)',
 'ion.month.path_extractor'='(date month)')
STORED AS ION
LOCATION 's3://amzn-s3-demo-bucket/'
```