Operatori e funzioni - Amazon Redshift
Operatori aritmeticiFunzioni aritmeticheFunzioni di arrayFunzioni di informazione

Amazon Redshift non supporterà più la creazione di nuovi Python a UDFs partire dal 1° novembre 2025. Se vuoi usare Python UDFs, crea la UDFs data precedente a quella data. Python esistente UDFs continuerà a funzionare normalmente. Per ulteriori informazioni, consulta il post del blog.

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 utilizzando 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 seguenti sezioni tratteranno la sintassi, gli esempi e le migliori pratiche per l'utilizzo di operatori e funzioni per i dati SUPER in Amazon Redshift per sbloccare tutto il potenziale dei tuoi dati semistrutturati.

Operatori aritmetici

I valori SUPER supportano tutti gli operatori aritmetici di base +, -, *,/,% con la digitazione dinamica. Il tipo risultante dell'operazione rimane SUPER. Per tutti gli operatori, ad eccezione dell'operatore binario +, 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 + 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 + 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:

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 la composizione degli array e le funzioni di utilità seguenti:

È 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_CONCAT:

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_FLATTEN:

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_CONCAT e ARRAY_FLATTEN utilizzano regole di digitazione dinamica. Restituiscono un null invece di un errore se l'input non è un array. La funzione GET_ARRAY_LENGTH 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_TO_ARRAY. 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)

Funzioni di informazione

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_TYPEOF 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:

Per ulteriori informazioni sulle funzioni informative di tipo SUPER, vedereFunzioni di informazioni sul tipo SUPER.