Opérateurs et fonctions

Avec Amazon Redshift, vous pouvez effectuer des analyses avancées sur de grands ensembles de données à l'aide de 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 meilleures 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 :

• FLOOR. Pour de plus amples informations, veuillez consulter Fonction FLOOR.

• CEIL et CEILING. Pour de plus amples informations, veuillez consulter Fonction CEILING (ou CEIL).

• ROUND. Pour de plus amples informations, veuillez consulter Fonction ROUND.

• TRUNC. Pour de plus amples informations, veuillez consulter Fonction TRUNC.

• ABS. Pour de plus amples informations, veuillez consulter Fonction ABS.

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 les fonctions utilitaires et de composition de tableaux suivantes :

• RÉSEAU. Pour de plus amples informations, veuillez consulter Fonction array.

• ARRAY_CONCAT. Pour de plus amples informations, veuillez consulter Fonction array_concat.

• ARRAY_FLATTEN. Pour de plus amples informations, veuillez consulter Fonction array_flatten.

• GET_ARRAY_LENGTH. Pour de plus amples informations, veuillez consulter Fonction get_array_length.

• SCINDÉ EN TABLEAU. Pour de plus amples informations, veuillez consulter Fonction split_to_array.

• SOUS-RÉSEAU. Pour de plus amples informations, veuillez consulter Fonction subarray.

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)

Fonctions d'information

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 :

• Fonction IS_ARRAY

• Fonction IS_BIGINT

• Fonction IS_CHAR

• Fonction IS_DECIMAL

• Fonction IS_FLOAT

• Fonction IS_INTEGER

• Fonction IS_OBJECT

• Fonction IS_SCALAR

• Fonction IS_SMALLINT

• Fonction IS_VARCHAR

Pour plus d'informations sur les fonctions d'information de type SUPER, consultezFonctions d’informations sur le type SUPER.