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.

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 +, -, *,/,% 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 le seguenti funzioni di composizione di array e di utilità:

È 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)

Comportamento di confronto

Con SUPER puoi impostare il confronto di una colonna con CREATE TABLE, utilizzare le regole di confronto predefinite con CREATE DATABASE e impostare il confronto di un’espressione con la funzione COLLATE.

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_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 di informazioni di tipo SUPER, consulta Funzioni di informazioni sul tipo SUPER.

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