Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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à.
# Funzioni JSON
**Topics**
+ [Funzione JSON\$1PARSE](JSON_PARSE.md)
+ [Funzione CAN\$1JSON\$1PARSE](CAN_JSON_PARSE.md)
+ [Funzione JSON\$1SERIALIZE](JSON_SERIALIZE.md)
+ [Funzione JSON\$1SERIALIZE\$1TO\$1VARBYTE](JSON_SERIALIZE_TO_VARBYTE.md)
+ [Funzioni JSON basate su testo](text-json-functions.md)
**Nota**
Per utilizzare JSON, consigliamo di utilizzare le funzioni seguenti:
[Funzione JSON\$1PARSE](JSON_PARSE.md)
[Funzione CAN\$1JSON\$1PARSE](CAN_JSON_PARSE.md)
[Funzione JSON\$1SERIALIZE](JSON_SERIALIZE.md)
[Funzione JSON\$1SERIALIZE\$1TO\$1VARBYTE](JSON_SERIALIZE_TO_VARBYTE.md)
Con JSON\$1PARSE devi solo convertire il testo JSON in un valore di tipo SUPER una volta al momento dell’importazione. Dopodiché puoi utilizzare i valori SUPER. Amazon Redshift analizza i valori SUPER in modo più efficiente rispetto a VARCHAR, che è l’output per le funzioni JSON basate su testo. Per ulteriori informazioni sull’utilizzo del tipo di dati SUPER, consulta [Dati semistrutturati in Amazon Redshift](super-overview.md).
Quando è necessario memorizzare un insieme relativamente piccolo di coppie chiave-valore, è possibile risparmiare spazio memorizzando i dati nel formato JSON. Poiché le stringhe JSON possono essere memorizzate in una singola colonna, l'utilizzo di JSON potrebbe essere più efficiente rispetto all'archiviazione dei dati in formato tabulare. Ad esempio, supponiamo di disporre di una tabella sparsa, in cui è necessario avere molte colonne per rappresentare a pieno tutti gli attributi possibili, ma la maggior parte dei valori delle colonne è NULL per ogni riga o colonna data. Usando JSON per l'archiviazione, si potrebbe essere in grado di memorizzare i dati per una riga in coppie chiave:valore in una singola stringa JSON ed eliminare le colonne della tabella scarsamente popolate.
Inoltre puoi modificare facilmente le stringhe JSON per memorizzare coppie chiavi:valore aggiuntive senza dover aggiungere colonne a una tabella.
È consigliabile usare un JSON con parsimonia. JSON non è una buona scelta per archiviare set di dati più grandi perché, archiviando dati disparati in una singola colonna, JSON non usa abitualmente l'architettura di archiviazione di colonne di Amazon Redshift. Sebbene Amazon Redshift supporti le funzioni JSON su colonne CHAR e VARCHAR, per l'elaborazione dei dati in formato di serializzazione JSON consigliamo di utilizzare SUPER. SUPER utilizza una rappresentazione senza schema post-analisi in grado di eseguire query in modo efficiente sui dati gerarchici. Per ulteriori informazioni sui tipi di dati SUPER, consultare [Dati semistrutturati in Amazon Redshift](super-overview.md).
JSON utilizza stringhe di testo con codifica UTF-8, pertanto le stringhe JSON possono essere memorizzate come tipi di dati CHAR o VARCHAR.
Le stringhe JSON devono essere formattate in modo corretto con JSON, in base alle seguenti regole:
+ Il JSON di livello radice può essere un oggetto JSON o un array JSON. Un oggetto JSON è un insieme non ordinato di coppie di chiave:valore separate da virgole racchiuse da parentesi graffe.
Ad esempio, `{"one":1, "two":2} `
+ Un array JSON è un insieme ordinato di valori separati da virgola racchiusi tra parentesi.
Un esempio è quanto segue: `["first", {"one":1}, "second", 3, null] `
+ Gli array JSON utilizzano un indice basato su zero; il primo elemento di un array è in posizione 0. In una coppia chiave:valore JSON, la chiave è una stringa racchiusa tra virgolette doppie.
+ Un valore JSON può essere uno dei seguenti:
+ Oggetto JSON
+ array
+ stringa
+ Racchiuso tra virgolette doppie
+ numero
+ Include numeri interi, numeri decimali e numeri a virgola mobile
+ booleano
+ null
+ Gli oggetti vuoti e gli array vuoti sono valori JSON validi.
+ I campi JSON fanno distinzione tra maiuscole e minuscole.
+ Lo spazio bianco tra gli elementi strutturali JSON (ad esempio `{ }, [ ]`) viene ignorato.
Le funzioni JSON di Amazon Redshift e il comando COPY di Amazon Redshift usano gli stessi metodi per lavorare con i dati in formato JSON. Per ulteriori informazioni sull'utilizzo di JSON, consulta [COPY dal formato JSON](copy-usage_notes-copy-from-json.md)
# Funzione JSON\$1PARSE
La funzione JSON\$1PARSE analizza i dati in formato JSON e li converte nella rappresentazione `SUPER`.
Per importare nel tipo di dati `SUPER` utilizzando il comando INSERT o UPDATE, utilizza la funzione JSON\$1PARSE. Quando utilizzi JSON\$1PARSE() per analizzare le stringhe JSON in valori `SUPER`, si applicano alcune restrizioni. Per ulteriori informazioni, consulta [Opzioni di analisi per SUPER](super-configurations.md#parsing-options-super).
## Sintassi
```
JSON_PARSE( {json_string | binary_value} )
```
## Arguments (Argomenti)
*json\$1string*
Un'espressione che restituisce JSON serializzato come tipo `VARBYTE` o `VARCHAR`.
*binary\$1value*
Un valore binario di tipo VARBYTE.
## Tipo restituito
`SUPER`
## Esempi
Per convertire l'array JSON `[10001,10002,"abc"]` nel tipo di dati `SUPER`, utilizza l'esempio seguente.
```
SELECT JSON_PARSE('[10001,10002,"abc"]');
+---------------------+
| json_parse |
+---------------------+
| [10001,10002,"abc"] |
+---------------------+
```
Per assicurare che la funzione abbia convertito l'array JSON nel tipo di dati `SUPER`, utilizza l'esempio seguente. Per ulteriori informazioni, consulta [Funzione JSON\$1TYPEOF](r_json_typeof.md)
```
SELECT JSON_TYPEOF(JSON_PARSE('[10001,10002,"abc"]'));
+-------------+
| json_typeof |
+-------------+
| array |
+-------------+
```
# Funzione CAN\$1JSON\$1PARSE
La funzione CAN\$1JSON\$1PARSE analizza i dati in formato JSON e restituisce `true` se il risultato può essere convertito in un valore `SUPER` utilizzando le funzione JSON\$1PARSE.
## Sintassi
```
CAN_JSON_PARSE( {json_string | binary_value} )
```
## Arguments (Argomenti)
*json\$1string*
Un’espressione che restituisce JSON serializzato nel formato `VARCHAR`.
*binary\$1value*
Un valore binario di tipo VARBYTE.
## Tipo restituito
`BOOLEAN`
## Note per l’utilizzo
+ CAN\$1JSON\$1CAN\$1PARSE restituisce false per le stringhe vuote. Restituisce NULL quando l’argomento di input è null.
## Esempi
L’esempio seguente mostra CAN\$1JSON\$1PARSE in esecuzione su un array JSON formato correttamente utilizzando una condizione CASE. Restituisce true, quindi Amazon Redshift esegue la funzione JSON\$1PARSE per il valore di esempio.
```
SELECT CASE
WHEN CAN_JSON_PARSE('[10001,10002,"abc"]')
THEN JSON_PARSE('[10001,10002,"abc"]')
END;
case
---------------------
'[10001,10002,"abc"]'
```
L’esempio seguente mostra CAN\$1JSON\$1PARSE in esecuzione su un valore che non è in formato JSON utilizzando una condizione CASE. Restituisce false, quindi Amazon Redshift restituisce il segmento nella clausola ELSE della condizione CASE.
```
SELECT CASE
WHEN CAN_JSON_PARSE('This is a string.')
THEN JSON_PARSE('This is a string.')
ELSE 'This is not JSON.'
END;
case
---------------------
"This is not JSON."
```
# Funzione JSON\$1SERIALIZE
La funzione JSON\$1SERIALIZE serializza un'espressione `SUPER` nella rappresentazione testuale JSON per seguire RFC 8259. Per ulteriori informazioni su tale RFC, vedete [The JavaScript Object Notation (JSON) Data Interchange Format](https://tools.ietf.org/html/rfc8259).
Il limite di dimensione `SUPER` è approssimativamente uguale al limite di blocco e il limite `VARCHAR` è più piccolo del limite di dimensione `SUPER`. Pertanto, quando il formato JSON supera il limite VARCHAR del sistema, la funzione JSON\$1SERIALIZE restituisce un errore. Per verificare la dimensione di un'espressione `SUPER`, consulta la funzione [JSON\$1SIZE](r_json_size.md).
## Sintassi
```
JSON_SERIALIZE(super_expression)
```
## Arguments (Argomenti)
*super\$1expression*
Un'espressione o una colonna `SUPER`.
## Tipo restituito
`VARCHAR`
**Nota**
Il valore VARCHAR restituito è sempre una stringa JSON non null. Se *super\$1expression* è NULL, JSON\$1SERIALIZE restituisce la stringa JSON `'null'`.
## Esempi
Per serializzare un valore `SUPER` in una stringa, utilizza l'esempio seguente.
```
SELECT JSON_SERIALIZE(JSON_PARSE('[10001,10002,"abc"]'));
+---------------------+
| json_serialize |
+---------------------+
| [10001,10002,"abc"] |
+---------------------+
```
# Funzione JSON\$1SERIALIZE\$1TO\$1VARBYTE
La funzione JSON\$1SERIALIZE\$1TO\$1VARBYTE converte un valore `SUPER` in una stringa JSON simile a JSON\$1SERIALIZE(), ma archiviata invece in un valore `VARBYTE`.
## Sintassi
```
JSON_SERIALIZE_TO_VARBYTE(super_expression)
```
## Arguments (Argomenti)
*super\$1expression*
Un'espressione o una colonna `SUPER`.
## Tipo restituito
`VARBYTE`
## Esempi
Per serializzare un valore `SUPER` e restituire il risultato in formato `VARBYTE`, utilizza l'esempio seguente.
```
SELECT JSON_SERIALIZE_TO_VARBYTE(JSON_PARSE('[10001,10002,"abc"]'));
+----------------------------------------+
| json_serialize_to_varbyte |
+----------------------------------------+
| 5b31303030312c31303030322c22616263225d |
+----------------------------------------+
```
Per serializzare un valore `SUPER` e convertire il risultato in formato `VARCHAR`, utilizza l'esempio seguente. Per ulteriori informazioni, consulta [Funzione CAST](r_CAST_function.md).
```
SELECT CAST((JSON_SERIALIZE_TO_VARBYTE(JSON_PARSE('[10001,10002,"abc"]'))) AS VARCHAR);
+---------------------------+
| json_serialize_to_varbyte |
+---------------------------+
| [10001,10002,"abc"] |
+---------------------------+
```
# Funzioni JSON basate su testo
Le funzioni di questa sezione analizzano i valori JSON come VARCHAR. Per analizzare JSON, consigliamo invece di utilizzare le seguenti funzioni, che analizzano i valori JSON come SUPER. Amazon Redshift analizza i valori SUPER in modo più efficiente rispetto a VARCHAR.
+ [Funzione JSON\$1PARSE](JSON_PARSE.md)
+ [Funzione CAN\$1JSON\$1PARSE](CAN_JSON_PARSE.md)
+ [Funzione JSON\$1SERIALIZE](JSON_SERIALIZE.md)
+ [Funzione JSON\$1SERIALIZE\$1TO\$1VARBYTE](JSON_SERIALIZE_TO_VARBYTE.md)
**Topics**
+ [Funzione IS\$1VALID\$1JSON](IS_VALID_JSON.md)
+ [Funzione IS\$1VALID\$1JSON\$1ARRAY](IS_VALID_JSON_ARRAY.md)
+ [Funzione JSON\$1ARRAY\$1LENGTH](JSON_ARRAY_LENGTH.md)
+ [Funzione JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT](JSON_EXTRACT_ARRAY_ELEMENT_TEXT.md)
+ [Funzione JSON\$1EXTRACT\$1PATH\$1TEXT](JSON_EXTRACT_PATH_TEXT.md)
# Funzione IS\$1VALID\$1JSON
**Nota**
CAN\$1JSON\$1PARSE e le funzioni associate analizzano i valori JSON come SUPER, che Amazon Redshift analizza in modo più efficiente di VARCHAR.
Invece di utilizzare IS\$1VALID\$1JSON, consigliamo di convalidare le stringhe JSON utilizzando [Funzione CAN\$1JSON\$1PARSE](CAN_JSON_PARSE.md).
La funzione IS\$1VALID\$1JSON convalida una stringa JSON. La funzione restituisce un valore booleano di `true` se la stringa è in formato JSON corretto o `false` se la stringa è in formato errato. Per convalidare un array JSON, utilizzare [Funzione IS\$1VALID\$1JSON\$1ARRAY](IS_VALID_JSON_ARRAY.md)
Per ulteriori informazioni, consultare [Funzioni JSON](json-functions.md).
## Sintassi
```
IS_VALID_JSON('json_string')
```
## Arguments (Argomenti)
*json\$1string*
Una stringa o espressione che valuta una stringa JSON.
## Tipo restituito
`BOOLEAN`
## Esempi
Per creare una tabella e inserire le stringhe JSON per i test, utilizza l'esempio seguente.
```
CREATE TABLE test_json(id int IDENTITY(0,1), json_strings VARCHAR);
-- Insert valid JSON strings --
INSERT INTO test_json(json_strings) VALUES
('{"a":2}'),
('{"a":{"b":{"c":1}}}'),
('{"a": [1,2,"b"]}');
-- Insert invalid JSON strings --
INSERT INTO test_json(json_strings) VALUES
('{{}}'),
('{1:"a"}'),
('[1,2,3]');
```
Per convalidare le stringhe nell'esempio precedente, utilizza l'esempio seguente.
```
SELECT id, json_strings, IS_VALID_JSON(json_strings)
FROM test_json
ORDER BY id;
+----+---------------------+---------------+
| id | json_strings | is_valid_json |
+----+---------------------+---------------+
| 0 | {"a":2} | true |
| 4 | {"a":{"b":{"c":1}}} | true |
| 8 | {"a": [1,2,"b"]} | true |
| 12 | {{}} | false |
| 16 | {1:"a"} | false |
| 20 | [1,2,3] | false |
+----+---------------------+---------------+
```
# Funzione IS\$1VALID\$1JSON\$1ARRAY
**Nota**
JSON\$1PARSE e le funzioni associate analizzano i valori JSON come SUPER, che Amazon Redshift analizza in modo più efficiente di VARCHAR.
Invece di utilizzare IS\$1VALID\$1JSON\$1ARRAY, consigliamo di analizzare le stringhe JSON utilizzando [Funzione JSON\$1PARSE](JSON_PARSE.md) per ottenere un valore SUPER. Quindi utilizza la funzione [Funzione IS\$1ARRAY](r_is_array.md) per verificare che l’array sia formattato correttamente.
La funzione IS\$1VALID\$1JSON‑ARRAY convalida un array JSON. La funzione restituisce un valore booleano `true` se l'array è in formato JSON corretto o `false` se l'array è in formato errato. Per convalidare una stringa JSON, utilizzare [Funzione IS\$1VALID\$1JSON](IS_VALID_JSON.md)
Per ulteriori informazioni, consultare [Funzioni JSON](json-functions.md).
## Sintassi
```
IS_VALID_JSON_ARRAY('json_array')
```
## Arguments (Argomenti)
*json\$1array*
Una stringa o espressione che valuta un array JSON.
## Tipo restituito
`BOOLEAN`
## Esempi
Per creare una tabella e inserire le stringhe JSON per i test, utilizza l'esempio seguente.
```
CREATE TABLE test_json_arrays(id int IDENTITY(0,1), json_arrays VARCHAR);
-- Insert valid JSON array strings --
INSERT INTO test_json_arrays(json_arrays)
VALUES('[]'),
('["a","b"]'),
('["a",["b",1,["c",2,3,null]]]');
-- Insert invalid JSON array strings --
INSERT INTO test_json_arrays(json_arrays)
VALUES('{"a":1}'),
('a'),
('[1,2,]');
```
Per convalidare le stringhe nell'esempio precedente, utilizza l'esempio seguente.
```
SELECT json_arrays, IS_VALID_JSON_ARRAY(json_arrays)
FROM test_json_arrays ORDER BY id;
+------------------------------+---------------------+
| json_arrays | is_valid_json_array |
+------------------------------+---------------------+
| [] | true |
| ["a","b"] | true |
| ["a",["b",1,["c",2,3,null]]] | true |
| {"a":1} | false |
| a | false |
| [1,2,] | false |
+------------------------------+---------------------+
```
# Funzione JSON\$1ARRAY\$1LENGTH
**Nota**
JSON\$1PARSE e le funzioni associate analizzano i valori JSON come SUPER, che Amazon Redshift analizza in modo più efficiente di VARCHAR.
Invece di utilizzare JSON\$1ARRAY\$1LENGTH, consigliamo di analizzare le stringhe JSON utilizzando [Funzione JSON\$1PARSE](JSON_PARSE.md) per ottenere un valore SUPER. Quindi utilizza [Funzione GET\$1ARRAY\$1LENGTH](get_array_length.md) per ottenere la lunghezza dell’array.
La funzione JSON\$1ARRAY\$1LENGTH restituisce il numero di elementi nell'array esterno di una stringa JSON. Se l'argomento *null\$1if\$1invalid* è impostato su `true` e la stringa JSON non è valida, la funzione restituisce `NULL` invece di restituire un errore.
Per ulteriori informazioni, consulta [Funzioni JSON](json-functions.md).
## Sintassi
```
JSON_ARRAY_LENGTH('json_array' [, null_if_invalid ] )
```
## Arguments (Argomenti)
*json\$1array*
Un array JSON correttamente formattato.
*null\$1if\$1invalid*
(Facoltativo) Un valore `BOOLEAN` che specifica se restituire `NULL` se la stringa JSON di input non è valida, invece di restituire un errore. Per restituire `NULL` se JSON non è valido, specifica `true` (`t`). Per restituire un errore se JSON non è valido, specificare `false` (`f`). Il valore predefinito è `false`.
## Tipo restituito
`INTEGER`
## Esempi
Per restituire il numero di elementi nell'array, utilizza l'esempio seguente.
```
SELECT JSON_ARRAY_LENGTH('[11,12,13,{"f1":21,"f2":[25,26]},14]');
+-------------------+
| json_array_length |
+-------------------+
| 5 |
+-------------------+
```
Per restituire un errore poiché JSON non è valido, utilizza l'esempio seguente.
```
SELECT JSON_ARRAY_LENGTH('[11,12,13,{"f1":21,"f2":[25,26]},14');
ERROR: invalid json array object [11,12,13,{"f1":21,"f2":[25,26]},14
```
Per impostare *null\$1if\$1invalid* su *true*, in modo che l'istruzione restituisca `NULL` invece di restituire un errore di formato JSON non valido, utilizza l'esempio seguente.
```
SELECT JSON_ARRAY_LENGTH('[11,12,13,{"f1":21,"f2":[25,26]},14',true);
+-------------------+
| json_array_length |
+-------------------+
| NULL |
+-------------------+
```
# Funzione JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT
**Nota**
JSON\$1PARSE e le funzioni associate analizzano i valori JSON come SUPER, che Amazon Redshift analizza in modo più efficiente di VARCHAR.
Invece di utilizzare JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT, consigliamo di analizzare le stringhe JSON utilizzando [Funzione JSON\$1PARSE](JSON_PARSE.md) per ottenere un valore SUPER. Quindi esegui query sull’elemento desiderato con il relativo indice di array, utilizzando la sintassi `value[element position]`. Per ulteriori informazioni sull’esecuzione di query sugli elementi dell’array nei valori SUPER, consulta [Query sui dati semistrutturati](query-super.md).
JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT restituisce un elemento di array JSON nell'array più esterno di una stringa JSON, utilizzando un indice con base zero. Il primo elemento in un array è in posizione 0. Se l’indice è negativo o fuori intervallo, JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT restituisce `NULL`. Se l'argomento *null\$1if\$1invalid* è impostato su `TRUE` e la stringa JSON non è valida, la funzione restituisce `NULL` invece di restituire un errore.
Per ulteriori informazioni, consulta [Funzioni JSON](json-functions.md).
## Sintassi
```
JSON_EXTRACT_ARRAY_ELEMENT_TEXT('json string', pos [, null_if_invalid ] )
```
## Arguments (Argomenti)
*json\$1string*
Una stringa JSON correttamente formattata.
*pos*
Un `INTEGER` che rappresenta l'indice dell'elemento array da restituire, utilizzando un indice di array con base zero.
*null\$1if\$1invalid*
(Facoltativo) Un valore `BOOLEAN` che specifica se restituire `NULL` se la stringa JSON di input non è valida, invece di restituire un errore. Per restituire `NULL` se JSON non è valido, specifica `true` (`t`). Per restituire un errore se JSON non è valido, specificare `false` (`f`). Il valore predefinito è `false`.
## Tipo restituito
`VARCHAR`
Una stringa `VARCHAR` che rappresenta l'elemento dell'array JSON a cui fa riferimento *pos*.
## Esempi
Per restituire un elemento di array alla posizione 2, che è il terzo elemento di un indice di array a base zero, utilizza l'esempio seguente.
```
SELECT JSON_EXTRACT_ARRAY_ELEMENT_TEXT('[111,112,113]', 2);
+---------------------------------+
| json_extract_array_element_text |
+---------------------------------+
| 113 |
+---------------------------------+
```
Per restituire un errore poiché JSON non è valido, utilizza l'esempio seguente.
```
SELECT JSON_EXTRACT_ARRAY_ELEMENT_TEXT('["a",["b",1,["c",2,3,null,]]]',1);
ERROR: invalid json array object ["a",["b",1,["c",2,3,null,]]]
```
Per impostare *null\$1if\$1invalid* su *true*, in modo che l'istruzione restituisca `NULL` invece di restituire un errore di formato JSON non valido, utilizza l'esempio seguente.
```
SELECT JSON_EXTRACT_ARRAY_ELEMENT_TEXT('["a",["b",1,["c",2,3,null,]]]',1,true);
+---------------------------------+
| json_extract_array_element_text |
+---------------------------------+
| NULL |
+---------------------------------+
```
Considera le seguenti istruzioni di esempio. Se la stringa JSON fornita o l’indice è NULL, JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT restituisce NULL, indipendentemente dal valore di qualsiasi altro parametro.
```
--Statement where json_string is NULL.
SELECT json_extract_array_element_text(NULL, 0)
json_extract_array_element_text
---------------------------------
NULL
--Statement where pos is NULL and json_string is invalid JSON.
SELECT json_extract_array_element_text('invalid_json', NULL);
json_extract_array_element_text
---------------------------------
NULL
--Statement where json_string is NULL and null_if_invalid is FALSE.
SELECT json_extract_array_element_text(NULL, 0, FALSE);
json_extract_array_element_text
---------------------------------
NULL
```
Considera le seguenti istruzioni di esempio. Quando *null\$1if\$1invalid* è TRUE, JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT restituisce NULL quando *json\$1string* è JSON non valido. Se *null\$1if\$1invalid* è FALSE o non è impostato, la funzione restituisce un errore quando *json\$1string* non è valido.
```
--Statement with invalid JSON where null_if_invalid is TRUE.
SELECT json_extract_array_element_text('invalid_json', 0, TRUE);
json_extract_array_element_text
---------------------------------
NULL
--Statement with invalid JSON where null_if_invalid is FALSE.
SELECT json_extract_array_element_text('invalid_json', 0);
ERROR: JSON parsing error
```
Considera l’esempio seguente, dove *json\$1string* è JSON valido e *pos* fa riferimento a un valore JSON `null`. In questo caso JSON\$1EXTRACT\$1ARRAY\$1ELEMENT\$1TEXT restituisce NULL, indipendentemente dal valore di *null\$1if\$1invalid*.
```
--Statement selecting a null value.
SELECT json_extract_array_element_text('[null]', 0);
json_extract_array_element_text
----------------------------------
NULL
```
# Funzione JSON\$1EXTRACT\$1PATH\$1TEXT
**Nota**
JSON\$1PARSE e le funzioni associate analizzano i valori JSON come SUPER, che Amazon Redshift analizza in modo più efficiente di VARCHAR.
Invece di utilizzare JSON\$1EXTRACT\$1PATH\$1TEXT, consigliamo di analizzare le stringhe JSON utilizzando [Funzione JSON\$1PARSE](JSON_PARSE.md) per ottenere un valore SUPER. Quindi esegui query sull’elemento che desideri utilizzando la sintassi `value.attribute`. Per ulteriori informazioni sull’esecuzione di query sugli elementi dell’array nei valori SUPER, consulta [Query sui dati semistrutturati](query-super.md).
La funzione JSON\$1EXTRACT\$1PATH\$1TEXT restituisce il valore per la coppia chiave-valore a cui fa riferimento una serie di elementi di percorso in una stringa JSON. Il percorso JSON può essere nidificato fino a cinque livelli di profondità. Gli elementi del percorso fanno distinzione tra maiuscole e minuscole. Se un elemento del percorso non esiste nella stringa JSON, JSON\$1EXTRACT\$1PATH\$1TEXT restituisce `NULL`.
Se l'argomento *null\$1if\$1invalid* è impostato su `TRUE` e la stringa JSON non è valida, la funzione restituisce `NULL` invece di restituire un errore.
JSON\$1EXTRACT\$1PATH\$1TEXT ha una dimensione massima di 64 KB. Pertanto, se un record JSON è più grande di 64 KB, l’elaborazione con JSON\$1EXTRACT\$1PATH\$1TEXT restituisce un errore.
Per informazioni sulle funzioni JSON aggiuntive, consulta [Funzioni JSON](json-functions.md). Per ulteriori informazioni sull'utilizzo di JSON, consulta [COPY dal formato JSON](copy-usage_notes-copy-from-json.md).
## Sintassi
```
JSON_EXTRACT_PATH_TEXT('json_string', 'path_elem' [,'path_elem'[, …] ] [, null_if_invalid ] )
```
## Arguments (Argomenti)
*json\$1string*
Una stringa JSON correttamente formattata.
*path\$1elem*
Un elemento di percorso in una stringa JSON. Un elemento di percorso è obbligatorio. È possibile specificare elementi aggiuntivi del percorso, fino a cinque livelli di profondità.
*null\$1if\$1invalid*
(Facoltativo) Un valore `BOOLEAN` che specifica se restituire `NULL` se la stringa JSON di input non è valida, invece di restituire un errore. Per restituire `NULL` se JSON non è valido, specifica `TRUE` (`t`). Per restituire un errore se JSON non è valido, specificare `FALSE` (`f`). Il valore predefinito è `FALSE`.
In una stringa JSON, Amazon Redshift riconosce `\n` come carattere newline e `\t` come carattere di tabulazione. Per caricare una barra rovesciata, crea una sequenza di escape con una barra rovesciata (`\\`). Per ulteriori informazioni, consultare [Caratteri escape in JSON](copy-usage_notes-copy-from-json.md#copy-usage-json-escape-characters).
## Tipo restituito
`VARCHAR`
Una stringa `VARCHAR` che rappresenta il valore JSON cui fanno riferimento gli elementi di percorso.
## Esempi
Per restituire il valore per il percorso `'f4', 'f6'`, utilizza l'esempio seguente.
```
SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}}','f4', 'f6');
+------------------------+
| json_extract_path_text |
+------------------------+
| star |
+------------------------+
```
Per restituire un errore poiché JSON non è valido, utilizza l'esempio seguente.
```
SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}','f4', 'f6');
ERROR: invalid json object {"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}
```
Per impostare *null\$1if\$1invalid* su *TRUE* in modo che l’istruzione restituisca `NULL` per JSON non valido invece di restituire un errore, utilizza l’esempio seguente.
```
SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}','f4', 'f6',true);
+------------------------+
| json_extract_path_text |
+------------------------+
| NULL |
+------------------------+
```
Considera l’esempio seguente, che seleziona il valore per il percorso `'farm', 'barn', 'color'`, dove il valore recuperato si trova al terzo livello. Questo esempio è formattato con uno strumento JSON Lint per semplificarne la lettura.
```
SELECT JSON_EXTRACT_PATH_TEXT('{
"farm": {
"barn": {
"color": "red",
"feed stocked": true
}
}
}', 'farm', 'barn', 'color');
+------------------------+
| json_extract_path_text |
+------------------------+
| red |
+------------------------+
```
Per restituire `NULL` perché l'elemento `'color'` risulta mancante, utilizza l'esempio seguente. Questo esempio è formattato con uno strumento JSON Lint.
```
SELECT JSON_EXTRACT_PATH_TEXT('{
"farm": {
"barn": {}
}
}', 'farm', 'barn', 'color');
+------------------------+
| json_extract_path_text |
+------------------------+
| NULL |
+------------------------+
```
Se il formato JSON è valido, il tentativo di estrarre un elemento mancante restituisce `NULL`.
Per restituire il valore per il percorso `'house', 'appliances', 'washing machine', 'brand'`, utilizza l'esempio seguente.
```
SELECT JSON_EXTRACT_PATH_TEXT('{
"house": {
"address": {
"street": "123 Any St.",
"city": "Any Town",
"state": "FL",
"zip": "32830"
},
"bathroom": {
"color": "green",
"shower": true
},
"appliances": {
"washing machine": {
"brand": "Any Brand",
"color": "beige"
},
"dryer": {
"brand": "Any Brand",
"color": "white"
}
}
}
}', 'house', 'appliances', 'washing machine', 'brand');
+------------------------+
| json_extract_path_text |
+------------------------+
| Any Brand |
+------------------------+
```
L’esempio seguente crea una tabella di esempio e la popola con valori SUPER, quindi restituisce il valore per il percorso `'f2'` per entrambe le righe.
```
CREATE TABLE json_example(id INT, json_text SUPER);
INSERT INTO json_example VALUES
(1, JSON_PARSE('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}}')),
(2, JSON_PARSE('{
"farm": {
"barn": {
"color": "red",
"feed stocked": true
}
}
}'));
SELECT * FROM json_example;
id | json_text
------------+--------------------------------------------
1 | {"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}}
2 | {"farm":{"barn":{"color":"red","feed stocked":true}}}
SELECT id, JSON_EXTRACT_PATH_TEXT(JSON_SERIALIZE(json_text), 'f2') FROM json_example;
id | json_text
------------+--------------------------------------------
1 | {"f3":1}
2 |
```
Considera le seguenti istruzioni di esempio. L’argomento *path\$1elem* fornito è NULL, quindi JSON\$1EXTRACT\$1PATH\$1TEXT restituisce NULL, indipendentemente dal valore di qualsiasi altro parametro.
```
--Statement where path_elem is NULL and json_string is valid JSON.
SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}}',NULL);
json_extract_path_text
------------------------
NULL
--Statement where only one path_elem is NULL.
SELECT JSON_EXTRACT_PATH_TEXT('{"f2":{"f3":1},"f4":{"f5":99,"f6":"star"}}','f4',NULL);
json_extract_path_text
------------------------
NULL
--Statement where path_elem is NULL and json_string is invalid JSON.
SELECT json_extract_path_text('invalid_json', NULL);
json_extract_path_text
------------------------
NULL
--Statement where path_elem is NULL and null_if_invalid is FALSE.
SELECT json_extract_path_text(NULL, 0, FALSE);
json_extract_path_text
------------------------
NULL
```
Considera le seguenti istruzioni di esempio. Quando *null\$1if\$1invalid* è TRUE, JSON\$1EXTRACT\$1PATH\$1TEXT restituisce NULL quando *json\$1string* è JSON non valido. Se *null\$1if\$1invalid* è FALSE o non è impostato, la funzione restituisce un errore quando *json\$1string* non è valido.
```
--Statement with invalid JSON where null_if_invalid is TRUE.
SELECT json_extract_path_text('invalid_json', 0, TRUE);
json_extract_path_text
------------------------
NULL
--Statement with invalid JSON where null_if_invalid is FALSE.
SELECT json_extract_path_text('invalid_json', 0, FALSE);
ERROR: JSON parsing error
```
Considera gli esempi seguenti, dove *json\$1string* è JSON valido e *path\$1elem* fa riferimento a un valore JSON `null`. In questo caso JSON\$1EXTRACT\$1PATH\$1TEXT restituisce NULL. Allo stesso modo, quando *path\$1elem* fa riferimento a un valore non esistente, JSON\$1EXTRACT\$1PATH\$1TEXT restituisce NULL, indipendentemente dal valore di *null\$1if\$1invalid*.
```
--Statement selecting a null value.
SELECT json_extract_path_text('[null]', 0);
json_extract_path_text
-------------------------
NULL
--Statement selecting a non-existing value.
SELECT json_extract_path_text('{}', 'a');
json_extract_path_text
-------------------------
NULL
```