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 di oggetti Di seguito sono elencate le funzioni degli oggetti SQL supportate da Amazon Redshift per creare e utilizzare oggetti di tipo SUPER: **Topics** + [Funzione GET\$1NUMBER\$1ATTRIBUTES](get_number_attributes.md) + [Funzione LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md) + [Funzione OBJECT](r_object_function.md) + [Funzione OBJECT\$1TRANSFORM](r_object_transform_function.md) + [Funzione UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md) # Funzione GET\$1NUMBER\$1ATTRIBUTES Restituisce il conteggio di quante coppie chiave-valore esistono al livello principale di un oggetto dizionario. ## Sintassi ``` GET_NUMBER_ATTRIBUTES( super_expression ) ``` ## Arguments (Argomenti) *super\$1expression* Un'espressione SUPER in forma di dizionario. ## Tipo restituito La funzione GET\$1NUMBER\$1ATTRIBUTES restituisce un tipo INT. ## Nota Questa funzione conta solo gli attributi diretti e non include le coppie nei dizionari annidati. ## Esempio L'esempio seguente mostra la funzione GET\$1NUMBER\$1ATTRIBUTES. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": 2, "c": 3}')); get_number_attributes ----------------------- 3 (1 row) ``` La funzione GET\$1NUMBER\$1ATTRIBUTES funziona solo al primo livello del dizionario. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": {"c": 3}}')); get_number_attributes ----------------------- 2 (1 row) ``` # Funzione LOWER\$1ATTRIBUTE\$1NAMES Converte tutti i nomi degli attributi applicabili in un valore SUPER in minuscolo, utilizzando la stessa routine di conversione in maiuscolo e minuscolo di [Funzione LOWER](r_LOWER.md). LOWER\$1ATTRIBUTE\$1NAMES supporta i caratteri multibyte UTF-8, fino a un massimo di quattro byte per carattere. Per convertire i nomi degli attributi SUPER in maiuscolo, utilizza [Funzione UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md). ## Sintassi ``` LOWER_ATTRIBUTE_NAMES( super_expression ) ``` ## Arguments (Argomenti) *super\$1expression* Un’espressione SUPER. ## Tipo restituito `SUPER` ## Note per l’utilizzo In Amazon Redshift, gli identificatori di colonna tradizionalmente non fanno distinzione tra maiuscole e minuscole e vengono convertiti in lettere minuscole. Se importi dati in formati che fanno distinzione tra maiuscole e minuscole come JSON, questi potrebbero contenere nomi di attributi in maiuscolo e minuscolo. Analizza l’esempio seguente. ``` CREATE TABLE t1 (s) AS SELECT JSON_PARSE('{"AttributeName": "Value"}'); SELECT s.AttributeName FROM t1; attributename ------------- NULL SELECT s."AttributeName" FROM t1; attributename ------------- NULL ``` Amazon Redshift restituisce NULL per entrambe le query. Per eseguire query su `AttributeName`, utilizza LOWER\$1ATTRIBUTE\$1NAMES per convertire i nomi degli attributi dei dati in minuscolo. Analizza l’esempio seguente. ``` CREATE TABLE t2 (s) AS SELECT LOWER_ATTRIBUTE_NAMES(s) FROM t1; SELECT s.attributename FROM t2; attributename ------------- "Value" SELECT s.AttributeName FROM t2; attributename ------------- "Value" SELECT s."attributename" FROM t2; attributename ------------- "Value" SELECT s."AttributeName" FROM t2; attributename ------------- "Value" ``` Un’opzione correlata per l’utilizzo di nomi di attributi di oggetti con maiuscole e minuscole è l’opzione di configurazione `enable_case_sensitive_super_attribute`, che consente ad Amazon Redshift di riconoscere il maiuscolo e il minuscolo nei nomi degli attributi SUPER. Questa può essere una soluzione alternativa all’utilizzo di LOWER\$1ATTRIBUTE\$1NAMES. Per ulteriori informazioni su `enable_case_sensitive_super_attribute`, consulta [enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md). ## Esempi **Conversione dei nomi degli attributi SUPER in minuscolo** L’esempio seguente utilizza LOWER\$1ATTRIBUTE\$1NAMES per convertire i nomi degli attributi di tutti i valori SUPER in una tabella. ``` -- Create a table and insert several SUPER values. CREATE TABLE t (i INT, s SUPER); INSERT INTO t VALUES (1, NULL), (2, 'A'::SUPER), (3, JSON_PARSE('{"AttributeName": "B"}')), (4, JSON_PARSE( '[{"Subobject": {"C": "C"}, "Subarray": [{"D": "D"}, "E"] }]')); -- Convert all attribute names to lowercase. UPDATE t SET s = LOWER_ATTRIBUTE_NAMES(s); SELECT i, s FROM t ORDER BY i; i | s ---+-------------------------------------------------- 1 | NULL 2 | "A" 3 | {"attributename":"B"} 4 | [{"subobject":{"c":"C"},"subarray":[{"d":"D"}, "E"]}] ``` Osserva come funziona LOWER\$1ATTRIBUTE\$1NAMES. + I valori NULL e i valori SUPER scalari, come `"A"`, sono invariati. + In un oggetto SUPER, tutti i nomi degli attributi vengono convertiti in minuscolo, ma i valori degli attributi, ad esempio `"B"`, rimangono invariati. + LOWER\$1ATTRIBUTE\$1NAMES si applica in modo ricorsivo a qualsiasi oggetto SUPER annidato all’interno di un array SUPER o all’interno di un altro oggetto. **Utilizzo di LOWER\$1ATTRIBUTE\$1NAMES per un oggetto SUPER con nomi di attributi duplicati** Se un oggetto SUPER contiene attributi i cui nomi differiscono solo nel maiuscolo o nel minuscolo, LOWER\$1ATTRIBUTE\$1NAMES restituisce un errore. Analizza l’esempio seguente. ``` SELECT LOWER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ``` # Funzione OBJECT Crea un oggetto del tipo di dati SUPER. ## Sintassi ``` OBJECT ( [ key1, value1 ], [ key2, value2 ...] ) ``` ## Arguments (Argomenti) *key1, key2* Espressioni che valutano stringhe di tipo VARCHAR. *value1, value2* Espressioni di qualsiasi tipo di dati Amazon Redshift eccetto i tipi datetime, poiché Amazon Redshift non esegue il casting dei tipi datetime nel tipo di dati SUPER. Per ulteriori informazioni sui tipi datetime, consulta [Tipi datetime](r_Datetime_types.md). Non è necessario che le espressioni `value` in un oggetto siano dello stesso tipo di dati. ## Tipo restituito `SUPER` ## Esempio ``` -- Creates an empty object. select object(); object -------- {} (1 row) -- Creates objects with different keys and values. select object('a', 1, 'b', true, 'c', 3.14); object --------------------------- {"a":1,"b":true,"c":3.14} (1 row) select object('a', object('aa', 1), 'b', array(2,3), 'c', json_parse('{}')); object --------------------------------- {"a":{"aa":1},"b":[2,3],"c":{}} (1 row) -- Creates objects using columns from a table. create table bar (k varchar, v super); insert into bar values ('k1', json_parse('[1]')), ('k2', json_parse('{}')); select object(k, v) from bar; object ------------ {"k1":[1]} {"k2":{}} (2 rows) -- Errors out because DATE type values can't be converted to SUPER type. select object('k', '2008-12-31'::date); ERROR: OBJECT could not convert type date to super ``` # Funzione OBJECT\$1TRANSFORM Trasforma un oggetto SUPER. ## Sintassi ``` OBJECT_TRANSFORM( input [KEEP path1, ...] [SET path1, value1, ..., ... ] ) ``` ## Arguments (Argomenti) *input* Un'espressione che restituisce un oggetto di tipo SUPER. *KEEP* Tutti i valori *path* specificati in questa clausola vengono mantenuti e passati all'oggetto di output. Questa clausola è facoltativa. *path1*, *path2*, ... Valori letterali di stringa costanti, nel formato di componenti del percorso tra virgolette doppie delimitate da punti. Ad esempio, `'"a"."b"."c"'` è un valore di percorso valido. Questo vale per il parametro path in entrambe le clausole KEEP e SET. *SET* Coppie di *path* e *value* per modificare un percorso esistente o aggiungerne uno nuovo e impostare il valore del percorso nell'oggetto di output. Questa clausola è facoltativa. *value1*, *value2*, ... Espressioni che restituiscono valori di tipo SUPER. Tieni presente che i tipi numerico, testo e booleano restituiscono valori SUPER. ## Tipo restituito `SUPER` ## Note per l’utilizzo OBJECT\$1TRANSFORM restituisce un oggetto di tipo SUPER contenente i valori del percorso dell'*input* specificati in KEEP e le coppie di *path* e *value* specificate in SET. Se sia KEEP che SET sono vuoti, OBJECT\$1TRANSFORM restituisce l'*input*. Se l'*input* non è un *oggetto* di tipo SUPER, OBJECT\$1TRANSFORM restituisce l'*input*, indipendentemente dai valori KEEP o SET. ## Esempio L'esempio seguente trasforma un oggetto SUPER in un altro oggetto SUPER. ``` CREATE TABLE employees ( col_person SUPER ); INSERT INTO employees VALUES ( json_parse(' { "name": { "first": "John", "last": "Doe" }, "age": 25, "ssn": "111-22-3333", "company": "Company Inc.", "country": "U.S." } ') ), ( json_parse(' { "name": { "first": "Jane", "last": "Appleseed" }, "age": 34, "ssn": "444-55-7777", "company": "Organization Org.", "country": "Ukraine" } ') ) ; SELECT OBJECT_TRANSFORM( col_person KEEP '"name"."first"', '"age"', '"company"', '"country"' SET '"name"."first"', UPPER(col_person.name.first::TEXT), '"age"', col_person.age + 5, '"company"', 'Amazon' ) AS col_person_transformed FROM employees; --This result is formatted for ease of reading. col_person_transformed ------------------------------------------------------------- { "name": { "first": "JOHN" }, "age": 30, "company": "Amazon", "country": "U.S." } { "name": { "first": "JANE" }, "age": 39, "company": "Amazon", "country": "Ukraine" } ``` # Funzione UPPER\$1ATTRIBUTE\$1NAMES Converte tutti i nomi degli attributi applicabili in un valore SUPER in maiuscolo, utilizzando la stessa routine di conversione in maiuscolo e minuscolo di [Funzione UPPER](r_UPPER.md). UPPER\$1ATTRIBUTE\$1NAMES supporta i caratteri multibyte UTF-8, fino a un massimo di quattro byte per carattere. Per convertire i nomi degli attributi SUPER in minuscolo, utilizza [Funzione LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md). ## Sintassi ``` UPPER_ATTRIBUTE_NAMES( super_expression ) ``` ## Arguments (Argomenti) *super\$1expression* Un’espressione SUPER. ## Tipo restituito `SUPER` ## Esempi **Conversione dei nomi degli attributi SUPER in maiuscolo** L’esempio seguente utilizza UPPER\$1ATTRIBUTE\$1NAMES per convertire i nomi degli attributi di tutti i valori SUPER in una tabella. ``` -- Create a table and insert several SUPER values. CREATE TABLE t (i INT, s SUPER); INSERT INTO t VALUES (1, NULL), (2, 'a'::SUPER), (3, JSON_PARSE('{"AttributeName": "b"}')), (4, JSON_PARSE( '[{"Subobject": {"c": "c"}, "Subarray": [{"d": "d"}, "e"] }]')); -- Convert all attribute names to uppercase. UPDATE t SET s = UPPER_ATTRIBUTE_NAMES(s); SELECT i, s FROM t ORDER BY i; i | s ---+-------------------------------------------------- 1 | NULL 2 | "a" 3 | {"ATTRIBUTENAME":"B"} 4 | [{"SUBOBJECT":{"C":"c"},"SUBARRAY":[{"D":"d"}, "e"]}] ``` Osserva come funziona UPPER\$1ATTRIBUTE\$1NAMES. + I valori NULL e i valori SUPER scalari, come `"a"`, sono invariati. + In un oggetto SUPER, tutti i nomi degli attributi vengono convertiti in maiuscolo, ma i valori degli attributi, ad esempio `"b"`, rimangono invariati. + UPPER\$1ATTRIBUTE\$1NAMES si applica in modo ricorsivo a qualsiasi oggetto SUPER annidato all’interno di un array SUPER o all’interno di un altro oggetto. **Utilizzo di UPPER\$1ATTRIBUTE\$1NAMES per un oggetto SUPER con nomi di attributi duplicati** Se un oggetto SUPER contiene attributi i cui nomi differiscono solo nel maiuscolo o nel minuscolo, UPPER\$1ATTRIBUTE\$1NAMES restituisce un errore. Analizza l’esempio seguente. ``` SELECT UPPER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ```