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