Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le billet de blog .

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Opérateurs et fonctions

Avec Amazon Redshift, vous pouvez effectuer des analyses avancées sur de grands jeux de données utilisant des données SUPER à l’aide d’opérateurs et de fonctions. Les opérateurs et les fonctions des données SUPER sont des constructions SQL qui permettent une analyse et une manipulation complexes de données semi-structurées stockées dans des tables Amazon Redshift.

Les sections suivantes présentent la syntaxe, les exemples et les bonnes pratiques d’utilisation des opérateurs et des fonctions pour les données SUPER dans Amazon Redshift afin d’exploiter tout le potentiel de vos données semi-structurées.

Opérateurs arithmétiques

Les valeurs SUPER prennent en charge tous les opérateurs arithmétiques de base +, -, *, /, % en utilisant le typage dynamique. Le type résultant de l’opération reste SUPER. Pour tous les opérateurs, à l’exception de l’opérateur binaire +, les opérandes d’entrée doivent être des nombres. Sinon, Amazon Redshift renvoie null. La distinction entre les valeurs décimales et les valeurs à virgule flottante est conservée lorsque Amazon Redshift exécute ces opérateurs et que le type dynamique ne change pas. Cependant, l’échelle décimale change lorsque vous utilisez des multiplications et des divisions. Les débordements arithmétiques provoquent toujours des erreurs de requête, ils ne sont pas modifiés en null. L’opérateur binaire + effectue une addition si les entrées sont des nombres ou une concaténation si les entrées sont des chaînes de caractères. Si un opérande est une chaîne et que l’autre opérande est un nombre, le résultat est nul. Les opérateurs préfixes unaires + et - renvoient un résultat null si la valeur SUPER n’est pas un nombre, comme le montre l’exemple suivant :

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)

Le typage dynamique permet aux valeurs décimales de SUPER d’avoir des échelles différentes. Amazon Redshift traite les valeurs décimales comme s’il s’agissait de types statiques différents et autorise toutes les opérations mathématiques. Amazon Redshift calcule l’échelle résultante dynamiquement en fonction des échelles des opérandes. Si l’un des opérandes est un nombre à virgule flottante, Amazon Redshift promeut l’autre opérande à un nombre à virgule flottante et génère le résultat sous la forme d’un nombre à virgule flottante.

Fonctions arithmétiques

Amazon Redshift prend en charge les fonctions arithmétiques suivantes pour les colonnes SUPER. Ils retournent null si l’entrée n’est pas un nombre :

L’exemple suivant utilise des fonctions arithmétiques pour interroger des données :

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 fonction ABS conserve l’échelle de la décimale d’entrée contrairement aux fonctions FLOOR, CEIL. ROUND élimine l’échelle de la décimale en entrée.

Fonctions de tableau

Amazon Redshift prend en charge la composition de tableaux et les fonctions utilitaires suivantes :

Vous pouvez construire des tableaux SUPER à partir de valeurs de types de données Amazon Redshift en utilisant la fonction ARRAY, y compris d’autres valeurs SUPER. L’exemple suivant utilise la fonction variadique 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)

L’exemple suivant utilise la concaténation de tableau avec la fonction ARRAY_CONCAT :

SELECT ARRAY_CONCAT(JSON_PARSE('[10001,10002]'),JSON_PARSE('[10003,10004]'));

             array_concat
------------------------------------
 [10001,10002,10003,10004]
(1 row)

L’exemple suivant utilise la manipulation de tableau avec la fonction SUBARRAY qui renvoie un sous-ensemble du tableau d’entrée.

SELECT SUBARRAY(ARRAY('a', 'b', 'c', 'd', 'e', 'f'), 2, 3);

   subarray
---------------
 ["c","d","e"]
(1 row))

L’exemple suivant fusionne plusieurs niveaux de tableaux en un seul tableau en utilisant 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)

Les fonctions de tableau ARRAY_CONCAT et ARRAY_FLATTEN utilisent des règles de typage dynamique. Elles retournent une valeur null au lieu d’une erreur si l’entrée n’est pas un tableau. La fonction GET_ARRAY_LENGTH renvoie la longueur d'un SUPER tableau à partir du chemin d'un objet ou d'un tableau.

SELECT c_name
FROM customer_orders_lineitem
WHERE GET_ARRAY_LENGTH(c_orders) = (
    SELECT MAX(GET_ARRAY_LENGTH(c_orders))
    FROM customer_orders_lineitem
    );

L’exemple suivant divise une chaîne en un tableau de chaînes en utilisant SPLIT_TO_ARRAY. La fonction utilise un délimiteur comme paramètre facultatif. Si aucun délimiteur n’est défini, la valeur par défaut est une virgule.

SELECT SPLIT_TO_ARRAY('12|345|6789', '|');

   split_to_array
---------------------
 ["12","345","6789"]
(1 row)

Comportement du classement

Avec SUPER, vous pouvez définir le classement d’une colonne avec CREATE TABLE, utiliser le classement par défaut défini avec CREATE DATABASE et définir le classement d’une expression avec la fonction COLLATE.

Le paramètre de classement s’applique à tous les opérateurs de comparaison et aux valeurs de chaîne stockés dans SUPER, qu’il s’agisse de valeurs de chaîne, de chaînes contenues dans des tableaux SUPER ou de valeurs d’un objet SUPER. Pour les objets SUPER, le comportement de classement s’applique uniquement aux valeurs et non aux attributs. Par exemple, une comparaison de valeurs avec un classement insensible à la casse de {"attribute": "a"} = {"attribute": "A"} renvoie true, tandis que {"attribute": "a"} = {"ATTRIBUTE": "a"} renvoie false.

Fonctions d’informations

Les colonnes de données SUPER prennent en charge les fonctions d’inspection qui renvoient le type dynamique et d’autres informations de type sur la valeur SUPER. L’exemple le plus courant est la fonction scalaire JSON_TYPEOF qui renvoie un VARCHAR avec les valeurs booléen (boolean), nombre (number), chaîne (string), objet (object), tableau (array) ou null, selon le type dynamique de la valeur SUPER. Amazon Redshift prend en charge les fonctions booléennes suivantes pour les colonnes de données SUPER :

Pour plus d’informations sur les fonctions d’information de type SUPER, consultez Fonctions d’informations sur le type SUPER.

Fonctions de chaîne

Pour utiliser des fonctions de chaîne avec des littéraux de chaîne dans le type de données SUPER, vous devez convertir le littéral de chaîne en type chaîne avant d'appliquer les fonctions. Les fonctions renvoient null si l'entrée n'est pas une chaîne littérale.

Fonctions de chaîneprend désormais en charge jusqu'à 16 000 000 octets.

L'exemple suivant utilise SUBSTRING pour extraire l'aperçu d'une chaîne de 5 000 000 octets stockée dans un objet 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'exemple suivant illustre les fonctions LEFT, RIGHT et CONCAT sur des chaînes littérales d'un tableau 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'exemple suivant enregistre une chaîne autonome dans 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