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à. # Operatori e funzioni Con Amazon Redshift puoi eseguire analisi avanzate su set di dati di grandi dimensioni con dati SUPER utilizzando operatori e funzioni. Gli operatori e le funzioni per i dati SUPER sono costrutti SQL che consentono l’analisi e la manipolazione complesse di dati semistrutturati archiviati nelle tabelle di Amazon Redshift. Le sezioni seguenti trattano la sintassi, gli esempi e le best practice per l’utilizzo di operatori e funzioni per i dati SUPER in Amazon Redshift per realizzare appieno il potenziale dei dati semistrutturati. ## Operatori aritmetici I valori SUPER supportano tutti gli operatori aritmetici di base \$1, -, \$1,/,% con la digitazione dinamica. Il tipo risultante dell'operazione rimane SUPER. Per tutti gli operatori, ad eccezione dell'operatore binario \$1, gli operandi di input devono essere numeri. In caso contrario, Amazon Redshift restituisce null. La distinzione tra valori decimali e a virgola mobile viene mantenuta quando Amazon Redshift esegue questi operatori e il tipo dinamico non cambia. Tuttavia, la scala decimale cambia quando si utilizzano moltiplicazioni e divisioni. Gli overflow aritmetici causano ancora errori di query, non vengono modificati in null. L'operatore binario \$1 esegue l'aggiunta se gli input sono numeri o la concatenazione se gli input sono una stringa. Se un operando è una stringa e l'altro operando è un numero, il risultato è null. Gli operatori con prefisso unario \$1 e - restituisce null se il valore SUPER non è un numero, come illustrato nell'esempio seguente: ``` SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0]. o_orderkey / 10 AS math FROM customer_orders_lineitem; math ---------------------------- 1757958232200.1500 (1 row) ``` La digitazione dinamica consente ai valori decimali in SUPER di avere scale diverse. Amazon Redshift considera i valori decimali come se fossero tipi statici diversi e consente tutte le operazioni matematiche. Amazon Redshift calcola dinamicamente la scala risultante in base alle scale degli operandi. Se uno degli operandi è un numero a virgola mobile, Amazon Redshift promuove l'altro operando a un numero a virgola mobile e genera il risultato come numero a virgola mobile. ## Funzioni aritmetiche Amazon Redshift supporta le seguenti funzioni aritmetiche per le colonne SUPER. Restituiscono null se l'input non è un numero: + FLOOR. Per ulteriori informazioni, consulta [Funzione FLOOR](r_FLOOR.md). + CEIL e CEILING. Per ulteriori informazioni, consulta [Funzione CEILING (oppure CEIL)](r_CEILING_FLOOR.md). + ROUND. Per ulteriori informazioni, consulta [Funzione ROUND](r_ROUND.md). + TRUNC. Per ulteriori informazioni, consulta [Funzione TRUNC](r_TRUNC.md). + ABS. Per ulteriori informazioni, consulta [Funzione ABS](r_ABS.md). Nell'esempio seguente vengono utilizzate funzioni aritmetiche per eseguire query sui dati: ``` SELECT x, FLOOR(x), CEIL(x), ROUND(x) FROM ( SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0].o_orderkey / 10 AS x FROM customer_orders_lineitem ); x | floor | ceil | round --------------------+---------------+---------------+--------------- 1389636795898.0500 | 1389636795898 | 1389636795899 | 1389636795898 ``` La funzione ABS mantiene la scala del decimale di input mentre FLOOR, CEIL. ROUND elimina la scala del decimale di input. ## Funzioni di array Amazon Redshift supporta le seguenti funzioni di composizione di array e di utilità: + ARRAY. Per ulteriori informazioni, consulta [Funzione ARRAY](r_array.md). + ARRAY\$1CONCAT. Per ulteriori informazioni, consulta [Funzione ARRAY\$1CONCAT](r_array_concat.md). + ARRAY\$1CONTIENE. Per ulteriori informazioni, consulta [Funzione ARRAY\$1CONTAINS](array_contains.md). + ARRAY\$1DISTINCT. Per ulteriori informazioni, consulta [Funzione ARRAY\$1DISTINCT](array_distinct.md). + ARRAY\$1EXCEPT. Per ulteriori informazioni, consulta [Funzione ARRAY\$1EXCEPT](array_except.md). + ARRAY\$1FLATTEN. Per ulteriori informazioni, consulta [funzione ARRAY\$1FLATTEN](array_flatten.md). + INTERSEZIONE TRA MATRICI. Per ulteriori informazioni, consulta [Funzione ARRAY\$1INTERSECTION](array_intersection.md). + POSIZIONE\$1MATRICE. Per ulteriori informazioni, consulta [funzione ARRAY\$1POSITION](array_position.md). + POSIZIONI\$1MATRICE. Per ulteriori informazioni, consulta [Funzione ARRAY\$1POSITIONS](array_positions.md). + ARRAY\$1SORT. Per ulteriori informazioni, consulta [Funzione ARRAY\$1SORT](array_sort.md). + UNIONE A MATRICE. Per ulteriori informazioni, consulta [Funzione ARRAY\$1UNION](array_union.md). + ARRAYS\$1OVERLAP. Per ulteriori informazioni, consulta [Funzione ARRAYS\$1OVERLAP](arrays_overlap.md). + GET\$1ARRAY\$1LENGTH. Per ulteriori informazioni, consulta [Funzione GET\$1ARRAY\$1LENGTH](get_array_length.md). + SPLIT\$1TO\$1ARRAY. Per ulteriori informazioni, consulta [funzione SPLIT\$1TO\$1ARRAY](split_to_array.md). + SUBARRAY. Per ulteriori informazioni, consulta [funzione SUBARRAY](r_subarray.md). È possibile costruire array SUPER da valori nei tipi di dati Amazon Redshift utilizzando la funzione ARRAY, inclusi altri valori SUPER. Nell'esempio seguente viene utilizzata la funzione variadica ARRAY: ``` SELECT ARRAY(1, c.c_custkey, NULL, c.c_name, 'abc') FROM customer_orders_lineitem c; array ------------------------------------------------------- [1,8401,null,""Customer#000008401"",""abc""] [1,9452,null,""Customer#000009452"",""abc""] [1,9451,null,""Customer#000009451"",""abc""] [1,8251,null,""Customer#000008251"",""abc""] [1,5851,null,""Customer#000005851"",""abc""] (5 rows) ``` Nell'esempio seguente viene utilizzata la concatenazione di array con la funzione ARRAY\$1CONCAT: ``` SELECT ARRAY_CONCAT(JSON_PARSE('[10001,10002]'),JSON_PARSE('[10003,10004]')); array_concat ------------------------------------ [10001,10002,10003,10004] (1 row) ``` Nell'esempio seguente viene utilizzata la manipolazione di array con la funzione SUBARRAY che restituisce un sottoinsieme dell'array di input. ``` SELECT SUBARRAY(ARRAY('a', 'b', 'c', 'd', 'e', 'f'), 2, 3); subarray --------------- ["c","d","e"] (1 row)) ``` Nell'esempio seguente vengono uniti più livelli di array in un singolo array tramite ARRAY\$1FLATTEN: ``` SELECT x, ARRAY_FLATTEN(x) FROM (SELECT ARRAY(1, ARRAY(2, ARRAY(3, ARRAY()))) AS x); x | array_flatten ----------------+--------------- [1,[2,[3,[]]]] | [1,2,3] (1 row) ``` Le funzioni di array ARRAY\$1CONCAT e ARRAY\$1FLATTEN utilizzano regole di digitazione dinamica. Restituiscono un null invece di un errore se l'input non è un array. La funzione GET\$1ARRAY\$1LENGTH restituisce la lunghezza di un array SUPER dato un percorso oggetto o array. ``` SELECT c_name FROM customer_orders_lineitem WHERE GET_ARRAY_LENGTH(c_orders) = ( SELECT MAX(GET_ARRAY_LENGTH(c_orders)) FROM customer_orders_lineitem ); ``` Nell'esempio seguente una stringa viene suddivisa in un array di stringhe tramite SPLIT\$1TO\$1ARRAY. La funzione utilizza un delimitatore come parametro opzionale. Se non è assente alcun delimitatore, il valore di default è una virgola. ``` SELECT SPLIT_TO_ARRAY('12|345|6789', '|'); split_to_array --------------------- ["12","345","6789"] (1 row) ``` ## Comportamento di confronto Con SUPER puoi impostare il confronto di una colonna con [CREATE TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html), utilizzare le regole di confronto predefinite con [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html) e impostare il confronto di un’espressione con la [funzione COLLATE](https://docs.aws.amazon.com/redshift/latest/dg/r_COLLATE.html). L’impostazione di confronto si applica a tutti gli operatori di confronto e ai valori di stringa archiviati in SUPER, siano essi valori di stringa, stringhe all’interno di array SUPER o valori di un oggetto SUPER. Per gli oggetti SUPER, il comportamento di confronto si applica solo ai valori e non agli attributi. Ad esempio, un confronto dei valori senza distinzione tra maiuscole e minuscole di `{"attribute": "a"} = {"attribute": "A"}` restituisce true, mentre `{"attribute": "a"} = {"ATTRIBUTE": "a"}` restituisce false. ## Funzioni di informazioni Le colonne di dati SUPER supportano funzioni di ispezione che restituiscono il tipo dinamico e altre informazioni di tipo sul valore SUPER. L'esempio più comune è la funzione scalare JSON\$1TYPEOF che restituisce un VARCHAR con valori booleani, number, string, object, array o null, a seconda del tipo dinamico del valore SUPER. Amazon Redshift supporta le seguenti funzioni booleane per le colonne di dati SUPER: + [Funzione IS\$1ARRAY](r_is_array.md) + [Funzione IS\$1BIGINT](r_is_bigint.md) + [Funzione IS\$1CHAR](r_is_char.md) + [Funzione IS\$1DECIMAL](r_is_decimal.md) + [Funzione IS\$1FLOAT](r_is_float.md) + [Funzione IS\$1INTEGER](r_is_integer.md) + [Funzione IS\$1OBJECT](r_is_object.md) + [Funzione IS\$1SCALAR](r_is_scalar.md) + [Funzione IS\$1SMALLINT](r_is_smallint.md) + [Funzione IS\$1VARCHAR](r_is_varchar.md) Per ulteriori informazioni sulle funzioni di informazioni di tipo SUPER, consulta [Funzioni di informazioni sul tipo SUPER](c_Type_Info_Functions.md). ## Funzioni di oggetti Di seguito sono elencate le funzioni degli oggetti SQL supportate da Amazon Redshift per creare e utilizzare oggetti di tipo SUPER: + [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) Per ulteriori informazioni sulle funzioni degli oggetti, consulta[Funzioni di oggetti](Object_Functions.md). ## Funzioni stringa Per utilizzare le funzioni di stringa con stringhe letterali nel tipo di dati SUPER, è necessario convertire la stringa letterale in tipo stringa prima di applicare le funzioni. Le funzioni restituiscono null se l'input non è una stringa letterale. [Funzioni stringa](String_functions_header.md)ora supporta fino a 16.000.000 di byte. L'esempio seguente utilizza SUBSTRING per estrarre l'anteprima di una stringa con dimensione 5.000.000 di byte memorizzata in un oggetto SUPER JSON ``` CREATE TABLE customer_data ( customer_id INT, profile SUPER ); INSERT INTO customer_data VALUES ( 1, JSON_PARSE('{"name": "John Doe", "description": "' || REPEAT('A', 5000000) || '"}') ); SELECT customer_id, profile.name::VARCHAR AS name, SUBSTRING(profile.description::VARCHAR, 1, 50) AS description_preview FROM customer_data; customer_id | name | description_preview -------------+----------+---------------------------------------------------- 1 | John Doe | AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ``` L'esempio seguente illustra le funzioni LEFT, RIGHT e CONCAT su stringhe letterali da un array SUPER: ``` CREATE TABLE documents ( doc_id INT, chapters SUPER ); INSERT INTO documents VALUES ( 1, JSON_PARSE('["' || REPEAT('hello', 400000) || '", "' || REPEAT('world', 600000) || '"]') ); SELECT doc_id, LEFT(chapters[0]::VARCHAR, 20) AS chapter1_start, RIGHT(chapters[1]::VARCHAR, 20) AS chapter2_end, LEN(CONCAT(chapters[0]::VARCHAR, chapters[1]::VARCHAR)) AS concat_size FROM documents; doc_id | chapter1_start | chapter2_end | concat_size --------+----------------------+----------------------+------------- 1 | hellohellohellohello | worldworldworldworld | 5000000 ``` L'esempio seguente memorizza una stringa autonoma in SUPER: ``` CREATE TABLE text_storage ( text_id INT, content SUPER ); INSERT INTO text_storage VALUES (1, REPEAT('A', 8000000)), (2, REPEAT('B', 16000000)); SELECT text_id, LEN(content::VARCHAR) AS content_length FROM text_storage; text_id | content_length ---------+---------------- 1 | 8000000 2 | 16000000 ```