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

# OpenX JSON SerDe
<a name="openx-json-serde"></a>

Come Hive JSON SerDe, puoi usare OpenX JSON per elaborare dati JSON. Questi dati sono rappresentati come stringhe su una sola riga di testo con codifica JSON separati da una nuova riga. Come Hive JSON SerDe, OpenX JSON SerDe non consente chiavi o nomi di chiavi duplicati. `map` `struct` 

## Considerazioni e limitazioni
<a name="openx-json-serde-considerations-limitations"></a>
+ Quando si utilizza OpenX JSON SerDe, il numero di risultati e i relativi valori possono essere non deterministici. I risultati possono contenere più righe del previsto, meno righe del previsto o valori nulli imprevisti quando non sono presenti nei dati sottostanti. Per risolvere il problema, utilizzare [JSON Hive SerDe](hive-json-serde.md) o riscrivere i dati in un altro tipo di formato di file.
+  SerDe Si aspetta che ogni documento JSON si trovi su una singola riga di testo senza caratteri di terminazione di riga che separano i campi del record. Se il testo JSON è in un bel formato di stampa, potresti ricevere un messaggio di errore come HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object o HIVE\$1CURSOR\$1ERROR:: Unexpected end-of-input: expected: expected close marker for OBJECT quando tenti di interrogare la tabella dopo averla JsonParseException creata. 

  Per ulteriori informazioni, consulta [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) nella documentazione di SerDe OpenX su. GitHub 

## Proprietà facoltative
<a name="openx-json-serde-optional-properties"></a>

A differenza di Hive JSON SerDe, OpenX JSON ha SerDe anche le seguenti SerDe proprietà opzionali che possono essere utili per risolvere le incongruenze nei dati.

**usa.null.for.invalid.data**  
Opzionale. Il valore predefinito è `FALSE`. Se impostato su`TRUE`, SerDe utilizza `NULL` i valori delle colonne che non sono riusciti a deserializzare nel tipo di colonna definito dallo schema della tabella.  
L’impostazione `use.null.for.invalid.data` su `TRUE` può causare risultati errati o imprevisti perché i valori `NULL` sostituiscono i dati non validi nelle colonne con mancate corrispondenze dello schema. Si consiglia di correggere i dati nei file o nello schema della tabella anziché abilitare questa proprietà. Quando si abilita questa proprietà, le query non avranno esito negativo su dati non validi, il che potrebbe impedire di scoprire problemi di qualità dei dati.

**ignore.malformed.json**  
Opzionale. Quando è impostata su `TRUE`, consente di saltare la sintassi JSON errata. Il valore predefinito è `FALSE`.

**dots.in.keys**  
Opzionale. Il valore predefinito è `FALSE`. Se impostato su`TRUE`, consente di SerDe sostituire i punti nei nomi delle chiavi con caratteri di sottolineatura. Ad esempio, se il set di dati JSON contiene una chiave denominata `"a.b"`, è possibile usare questa proprietà per definire il nome della colonna come `"a_b"` in Athena. Per impostazione predefinita (senza questa opzione SerDe), Athena non consente l'uso di punti nei nomi delle colonne.

**case.insensitive**  
Opzionale. Il valore predefinito è `TRUE`. Se impostato su`TRUE`, SerDe converte tutte le colonne maiuscole in minuscole.   
Per utilizzare i nomi di chiavi con distinzione tra maiuscole e minuscole nei dati, utilizzare `WITH SERDEPROPERTIES ("case.insensitive"= FALSE;)`. Quindi, per ogni chiave che non è già composta da sole minuscole, fornire un mapping dal nome della colonna al nome della proprietà utilizzando la sintassi seguente:  

```
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ("case.insensitive" = "FALSE", "mapping.userid" = "userId")
```
Se hai due chiavi tipo `URL` e `Url` che sono uguali quando sono in minuscolo, può verificarsi un errore come il seguente:  
HIVE\$1CURSOR\$1ERROR: La riga non è un oggetto JSON valido -: Chiave duplicata «url» JSONException  
Per risolvere questo problema, impostare la proprietà `case.insensitive` su `FALSE` e mappare le chiavi a nomi diversi, come nell'esempio seguente:  

```
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ("case.insensitive" = "FALSE", "mapping.url1" = "URL", "mapping.url2" = "Url")
```

**mappatura**  
Opzionale. Mappa i nomi di colonna a chiavi JSON che non sono identiche ai nomi di colonna. Il parametro `mapping` è utile quando i dati JSON contengono chiavi che sono [parole chiave](reserved-words.md). Ad esempio, se si dispone di una chiave JSON denominata `timestamp`, utilizzare la sintassi seguente per mappare la chiave a una colonna denominata `ts`:  

```
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ("mapping.ts" = "timestamp")
```
**Mappatura dei nomi dei campi annidati con due punti a nomi compatibili con Hive**  
Se hai il nome di un campo con due punti all'interno di uno `struct`, puoi utilizzare la proprietà `mapping` per mappare il campo a un nome compatibile con Hive. Ad esempio, se le definizioni dei tipi di colonna contengono `my:struct:field:string`, puoi mappare la definizione a `my_struct_field:string` includendo la seguente voce in `WITH SERDEPROPERTIES`:

```
("mapping.my_struct_field" = "my:struct:field")
```
L'esempio seguente mostra l'istruzione `CREATE TABLE` corrispondente.  

```
CREATE EXTERNAL TABLE colon_nested_field (
item struct<my_struct_field:string>)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ("mapping.my_struct_field" = "my:struct:field")
```

## Esempio: dati pubblicitari
<a name="openx-json-serde-ad-data-example"></a>

L'istruzione DDL di esempio seguente utilizza OpenX SerDe JSON per creare una tabella basata sugli stessi dati pubblicitari online di esempio utilizzati nell'esempio per Hive JSON. SerDe Nella `LOCATION` clausola, sostituiscila *myregion* con l'identificatore della regione in cui esegui Athena.

```
CREATE EXTERNAL TABLE impressions (
    requestbegintime string,
    adid string,
    impressionId string,
    referrer string,
    useragent string,
    usercookie string,
    ip string,
    number string,
    processid string,
    browsercokie string,
    requestendtime string,
    timers struct<
       modellookup:string, 
       requesttime:string>,
    threadid string, 
    hostname string,
    sessionid string
)   PARTITIONED BY (dt string)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket.elasticmapreduce/samples/hive-ads/tables/impressions';
```

## Esempio di deserializzazione di un JSON nidificato
<a name="nested-json-serde-example"></a>

Puoi usare JSON per analizzare dati con codifica JSON SerDes più complessi. Ciò richiede l'utilizzo di istruzioni `CREATE TABLE` che utilizzino elementi `struct` e `array` per rappresentare strutture nidificate. 

Nell'esempio seguente viene creata una tabella Athena dai dati JSON con strutture nidificate. Il file ha la struttura seguente:

```
{
"DocId": "AWS",
"User": {
        "Id": 1234,
        "Username": "carlos_salazar", 
        "Name": "Carlos",
"ShippingAddress": {
"Address1": "123 Main St.",
"Address2": null,
"City": "Anytown",
"State": "CA"
   },
"Orders": [
   {
     "ItemId": 6789,
     "OrderDate": "11/11/2022" 
   },
   {
     "ItemId": 4352,
     "OrderDate": "12/12/2022"
   }
  ]
 }
}
```

Ricorda che OpenX SerDe si aspetta che ogni record JSON sia su una singola riga di testo. Se archiviati in Amazon S3, tutti i dati dell’esempio precedente devono trovarsi su un’unica riga, in questo modo:

```
{"DocId":"AWS","User":{"Id":1234,"Username":"carlos_salazar","Name":"Carlos","ShippingAddress" ...
```

L'`CREATE TABLE`istruzione seguente utilizza i tipi di dati [Openx- JsonSerDe](https://github.com/rcongiu/Hive-JSON-Serde) with `struct` and `array` collection per stabilire gruppi di oggetti per i dati di esempio. 

```
CREATE external TABLE complex_json (
   docid string,
   `user` struct<
               id:INT,
               username:string,
               name:string,
               shippingaddress:struct<
                                      address1:string,
                                      address2:string,
                                      city:string,
                                      state:string
                                      >,
               orders:array<
                            struct<
                                 itemid:INT,
                                  orderdate:string
                                  >
                              >
               >
   )
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/myjsondata/';
```

Per eseguire query sulla tabella, utilizzare una `SELECT` istruzione come la seguente.

```
SELECT 
 user.name as Name, 
 user.shippingaddress.address1 as Address, 
 user.shippingaddress.city as City, 
 o.itemid as Item_ID, o.orderdate as Order_date
FROM complex_json, UNNEST(user.orders) as temp_table (o)
```

Per accedere ai campi di dati all’interno delle strutture, la query di esempio utilizza la notazione a punti (ad esempio,`user.name`). Per accedere ai dati all’interno di una matrice di strutture (come nel `orders` campo), puoi usare la funzione. `UNNEST` La `UNNEST` funzione appiattisce l’array in una tabella temporanea (in questo caso chiamata). `o` Ciò consente di utilizzare la notazione a punti come si fa con le strutture per accedere agli elementi dell’array non annidati (ad esempio,). `o.itemid` Il nome `temp_table`, usato nell’esempio a scopo illustrativo, è spesso abbreviato in. `t`

Nella tabella seguente sono riportati i risultati di esempio.


****  

| \$1 | Name | Indirizzo | City | id\$1articolo | Data\$1ordine | 
| --- | --- | --- | --- | --- | --- | 
| 1 | Carlos | 123 Main St. | Qualsiasi città | 6789 | 11/11/2022 | 
| 2 | Carlos | 123 Main St. | Qualsiasi città | 4352 | 12/12/2022 |