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 ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 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 \$1, -, \$1, /, % 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 \$1, 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 \$1 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 \$1 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 plus d’informations, consultez [Fonction FLOOR](r_FLOOR.md). + CEIL et CEILING. Pour plus d’informations, consultez [Fonction CEILING (ou CEIL)](r_CEILING_FLOOR.md). + ROUND. Pour plus d’informations, consultez [Fonction ROUND](r_ROUND.md). + TRUNC. Pour plus d’informations, consultez [Fonction TRUNC](r_TRUNC.md). + ABS. Pour plus d’informations, consultez [Fonction ABS](r_ABS.md). 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 : + ARRAY. Pour plus d’informations, consultez [Fonction ARRAY](r_array.md). + ARRAY\$1CONCAT. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1CONCAT](r_array_concat.md). + ARRAY\$1CONTAINS. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1CONTAINS](array_contains.md). + ARRAY\$1DISTINCT. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1DISTINCT](array_distinct.md). + ARRAY\$1EXCEPTÉ. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1EXCEPT](array_except.md). + ARRAY\$1FLATTEN. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1FLATTEN](array_flatten.md). + ARRAY\$1INTERSECTION. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1INTERSECTION](array_intersection.md). + POSITION DU TABLEAU. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1POSITION](array_position.md). + POSITIONS DU TABLEAU. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1POSITIONS](array_positions.md). + ARRAY\$1SORT. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1SORT](array_sort.md). + ARRAY\$1UNION. Pour de plus amples informations, veuillez consulter [Fonction ARRAY\$1UNION](array_union.md). + ARRAYS\$1OVERLAP. Pour de plus amples informations, veuillez consulter [Fonction ARRAYS\$1OVERLAP](arrays_overlap.md). + GET\$1ARRAY\$1LENGTH. Pour plus d’informations, consultez [Fonction GET\$1ARRAY\$1LENGTH](get_array_length.md). + SPLIT\$1TO\$1ARRAY. Pour plus d’informations, consultez [Fonction SPLIT\$1TO\$1ARRAY](split_to_array.md). + SUBARRAY. Pour plus d’informations, consultez [Fonction SUBARRAY](r_subarray.md). 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\$1CONCAT : ``` 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\$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) ``` Les fonctions de tableau ARRAY\$1CONCAT et ARRAY\$1FLATTEN 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\$1ARRAY\$1LENGTH 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\$1TO\$1ARRAY. 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](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html), utiliser le classement par défaut défini avec [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html) et définir le classement d’une expression avec la [fonction COLLATE](https://docs.aws.amazon.com/redshift/latest/dg/r_COLLATE.html). 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\$1TYPEOF 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\$1ARRAY](r_is_array.md) + [Fonction IS\$1BIGINT](r_is_bigint.md) + [Fonction IS\$1CHAR](r_is_char.md) + [Fonction IS\$1DECIMAL](r_is_decimal.md) + [Fonction IS\$1FLOAT](r_is_float.md) + [Fonction IS\$1INTEGER](r_is_integer.md) + [Fonction IS\$1OBJECT](r_is_object.md) + [Fonction IS\$1SCALAR](r_is_scalar.md) + [Fonction IS\$1SMALLINT](r_is_smallint.md) + [Fonction IS\$1VARCHAR](r_is_varchar.md) Pour plus d’informations sur les fonctions d’information de type SUPER, consultez [Fonctions d’informations sur le type SUPER](c_Type_Info_Functions.md). ## Fonctions d'objet Voici les fonctions d'objet SQL prises en charge par Amazon Redshift pour créer et exploiter des objets de type SUPER : + [Fonction GET\$1NUMBER\$1ATTRIBUTES](get_number_attributes.md) + [Fonction LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md) + [Fonction OBJECT](r_object_function.md) + [Fonction OBJECT\$1TRANSFORM](r_object_transform_function.md) + [Fonction UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md) Pour plus d'informations sur les fonctions des objets, consultez[Fonctions d’objet](Object_Functions.md). ## 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îne](String_functions_header.md)supporte désormais 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 ```