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. # 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 : **Topics** + [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) # Fonction GET\$1NUMBER\$1ATTRIBUTES Renvoie le nombre de paires clé-valeur existant au niveau racine d'un objet de dictionnaire. ## Syntaxe ``` GET_NUMBER_ATTRIBUTES( super_expression ) ``` ## Arguments *super\$1expression* Une super expression de la forme d'un dictionnaire. ## Type de retour La fonction GET\$1NUMBER\$1ATTRIBUTES renvoie un type INT. ## Remarque Cette fonction ne compte que les attributs directs et n'inclut pas les paires dans les dictionnaires imbriqués. ## Exemple L'exemple suivant montre la fonction GET\$1NUMBER\$1ATTRIBUTES. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": 2, "c": 3}')); get_number_attributes ----------------------- 3 (1 row) ``` La fonction GET\$1NUMBER\$1ATTRIBUTES ne fonctionne qu'au premier niveau du dictionnaire. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": {"c": 3}}')); get_number_attributes ----------------------- 2 (1 row) ``` # Fonction LOWER\$1ATTRIBUTE\$1NAMES Convertit tous les noms d’attributs applicables dans une valeur SUPER en minuscules, en utilisant la même routine de conversion majuscules/minuscules que [Fonction LOWER](r_LOWER.md). LOWER\$1ATTRIBUTE\$1NAMES prend en charge les caractères à plusieurs octets UTF-8, à concurrence de quatre octets au maximum par caractère. Pour convertir les noms d’attributs SUPER en majuscules, utilisez [Fonction UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md). ## Syntaxe ``` LOWER_ATTRIBUTE_NAMES( super_expression ) ``` ## Arguments *super\$1expression* Une expression SUPER. ## Type de retour `SUPER` ## Notes d’utilisation Dans Amazon Redshift, les identifiants de colonne ne font généralement pas la distinction entre majuscules et minuscules et sont convertis en minuscules. Si vous ingérez des données provenant de formats de données sensibles à la casse, tels que JSON, les données peuvent contenir des noms d’attributs composés de majuscules et de minuscules. Prenez l’exemple de code suivant. ``` CREATE TABLE t1 (s) AS SELECT JSON_PARSE('{"AttributeName": "Value"}'); SELECT s.AttributeName FROM t1; attributename ------------- NULL SELECT s."AttributeName" FROM t1; attributename ------------- NULL ``` Amazon Redshift renvoie la valeur NULL pour les deux requêtes. Pour interroger `AttributeName`, utilisez LOWER\$1ATTRIBUTE\$1NAMES pour convertir les noms des attributs des données en minuscules. Prenez l’exemple de code suivant. ``` CREATE TABLE t2 (s) AS SELECT LOWER_ATTRIBUTE_NAMES(s) FROM t1; SELECT s.attributename FROM t2; attributename ------------- "Value" SELECT s.AttributeName FROM t2; attributename ------------- "Value" SELECT s."attributename" FROM t2; attributename ------------- "Value" SELECT s."AttributeName" FROM t2; attributename ------------- "Value" ``` L’option de configuration `enable_case_sensitive_super_attribute` est une option connexe pour travailler avec des noms d’attributs d’objets en majuscules et minuscules. Elle permet à Amazon Redshift de reconnaître les majuscules dans les noms d’attributs SUPER. Cela peut être une solution alternative à l’utilisation de LOWER\$1ATTRIBUTE\$1NAMES. Pour plus d’informations sur `enable_case_sensitive_super_attribute`, consultez [enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md). ## Exemples **Conversion des noms d’attributs SUPER en minuscules** L’exemple suivant utilise LOWER\$1ATTRIBUTE\$1NAMES pour convertir les noms d’attribut de toutes les valeurs SUPER d’une table. ``` -- Create a table and insert several SUPER values. CREATE TABLE t (i INT, s SUPER); INSERT INTO t VALUES (1, NULL), (2, 'A'::SUPER), (3, JSON_PARSE('{"AttributeName": "B"}')), (4, JSON_PARSE( '[{"Subobject": {"C": "C"}, "Subarray": [{"D": "D"}, "E"] }]')); -- Convert all attribute names to lowercase. UPDATE t SET s = LOWER_ATTRIBUTE_NAMES(s); SELECT i, s FROM t ORDER BY i; i | s ---+-------------------------------------------------- 1 | NULL 2 | "A" 3 | {"attributename":"B"} 4 | [{"subobject":{"c":"C"},"subarray":[{"d":"D"}, "E"]}] ``` Observez le fonctionnement de LOWER\$1ATTRIBUTE\$1NAMES. + Les valeurs NULL et les valeurs scalaires SUPER telles que `"A"` restent inchangées. + Dans un objet SUPER, tous les noms d’attributs sont remplacés par des minuscules, mais les valeurs d’attributs tels que `"B"` restent inchangés. + LOWER\$1ATTRIBUTE\$1NAMES s’applique de manière récursive à tout objet SUPER imbriqué dans un tableau SUPER ou dans un autre objet. **Utilisation de LOWER\$1ATTRIBUTE\$1NAMES sur un objet SUPER avec des noms d’attributs dupliqués** Si un objet SUPER contient des attributs dont les noms ne diffèrent que dans leur cas, LOWER\$1ATTRIBUTE\$1NAMES générera une erreur. Prenez l’exemple de code suivant. ``` SELECT LOWER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ``` # Fonction OBJECT Crée un tableau du type de données SUPER. ## Syntaxe ``` OBJECT ( [ key1, value1 ], [ key2, value2 ...] ) ``` ## Arguments *key1, key2* (clé 1, clé 2) Expressions qui évaluent des chaînes de type VARCHAR. *value1, value2* Expressions de n’importe quel type de données Amazon Redshift à l’exception des types datetime, car Amazon Redshift ne convertit pas les types datetime en type de données SUPER. Pour obtenir plus d’informations sur les types datetime, consultez [Types datetime](r_Datetime_types.md). Les expressions `value` dans un objet ne doivent pas nécessairement appartenir au même type de données. ## Type de retour `SUPER` ## Exemple ``` -- Creates an empty object. select object(); object -------- {} (1 row) -- Creates objects with different keys and values. select object('a', 1, 'b', true, 'c', 3.14); object --------------------------- {"a":1,"b":true,"c":3.14} (1 row) select object('a', object('aa', 1), 'b', array(2,3), 'c', json_parse('{}')); object --------------------------------- {"a":{"aa":1},"b":[2,3],"c":{}} (1 row) -- Creates objects using columns from a table. create table bar (k varchar, v super); insert into bar values ('k1', json_parse('[1]')), ('k2', json_parse('{}')); select object(k, v) from bar; object ------------ {"k1":[1]} {"k2":{}} (2 rows) -- Errors out because DATE type values can't be converted to SUPER type. select object('k', '2008-12-31'::date); ERROR: OBJECT could not convert type date to super ``` # Fonction OBJECT\$1TRANSFORM Transforme un objet SUPER. ## Syntaxe ``` OBJECT_TRANSFORM( input [KEEP path1, ...] [SET path1, value1, ..., ... ] ) ``` ## Arguments *input* Expression qui se résout en un objet de type SUPER. *KEEP* Toutes les valeurs de *chemin* spécifiées dans cette clause sont conservées et transférées vers l’objet de sortie. Cette clause est facultative. *path1*, *path2*, ... Litéraux de chaîne constants, au format de composants de chemin entre guillemets doubles délimités par des points. Par exemple, `'"a"."b"."c"'` est une valeur de chemin valide. Ceci s’applique au paramètre path dans les clauses KEEP et SET. *SET* paires *path* et *value* permettant de modifier un chemin existant ou d’ajouter un nouveau chemin, et définir la valeur de celui-ci dans l’objet de sortie. Cette clause est facultative. *value1*, *value2*, ... Expressions qui se résolvent en valeurs de type SUPER. Notez que les types numeric, text et boolean peuvent être résolus en SUPER. ## Type de retour `SUPER` ## Notes d’utilisation OBJECT\$1TRANSFORM renvoie un objet de type SUPER contenant les valeurs de chemin provenant de *input* spécifiées dans KEEP et les paires *path* *value* spécifiées dans SET. Si KEEP et SET sont vides, OBJECT\$1TRANSFORM renvoie *input*. Si *input* n’est pas un objet (*object*) de type SUPER, OBJECT\$1TRANSFORM renvoie *input*, quelles que soient les valeurs KEEP ou SET. ## Exemple L’exemple suivant transforme un objet SUPER en un autre objet SUPER. ``` CREATE TABLE employees ( col_person SUPER ); INSERT INTO employees VALUES ( json_parse(' { "name": { "first": "John", "last": "Doe" }, "age": 25, "ssn": "111-22-3333", "company": "Company Inc.", "country": "U.S." } ') ), ( json_parse(' { "name": { "first": "Jane", "last": "Appleseed" }, "age": 34, "ssn": "444-55-7777", "company": "Organization Org.", "country": "Ukraine" } ') ) ; SELECT OBJECT_TRANSFORM( col_person KEEP '"name"."first"', '"age"', '"company"', '"country"' SET '"name"."first"', UPPER(col_person.name.first::TEXT), '"age"', col_person.age + 5, '"company"', 'Amazon' ) AS col_person_transformed FROM employees; --This result is formatted for ease of reading. col_person_transformed ------------------------------------------------------------- { "name": { "first": "JOHN" }, "age": 30, "company": "Amazon", "country": "U.S." } { "name": { "first": "JANE" }, "age": 39, "company": "Amazon", "country": "Ukraine" } ``` # Fonction UPPER\$1ATTRIBUTE\$1NAMES Convertit tous les noms d’attributs applicables dans une valeur SUPER en majuscules, en utilisant la même routine de conversion majuscules/minuscules que [Fonction UPPER](r_UPPER.md). UPPER\$1ATTRIBUTE\$1NAMES prend en charge les caractères à plusieurs octets UTF-8, à concurrence de quatre octets au maximum par caractère. Pour convertir les noms d’attributs SUPER en minuscules, utilisez [Fonction LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md). ## Syntaxe ``` UPPER_ATTRIBUTE_NAMES( super_expression ) ``` ## Arguments *super\$1expression* Une expression SUPER. ## Type de retour `SUPER` ## Exemples **Conversion des noms d’attributs SUPER en majuscules** L’exemple suivant utilise UPPER\$1ATTRIBUTE\$1NAMES pour convertir les noms d’attribut de toutes les valeurs SUPER d’une table. ``` -- Create a table and insert several SUPER values. CREATE TABLE t (i INT, s SUPER); INSERT INTO t VALUES (1, NULL), (2, 'a'::SUPER), (3, JSON_PARSE('{"AttributeName": "b"}')), (4, JSON_PARSE( '[{"Subobject": {"c": "c"}, "Subarray": [{"d": "d"}, "e"] }]')); -- Convert all attribute names to uppercase. UPDATE t SET s = UPPER_ATTRIBUTE_NAMES(s); SELECT i, s FROM t ORDER BY i; i | s ---+-------------------------------------------------- 1 | NULL 2 | "a" 3 | {"ATTRIBUTENAME":"B"} 4 | [{"SUBOBJECT":{"C":"c"},"SUBARRAY":[{"D":"d"}, "e"]}] ``` Observez le fonctionnement de UPPER\$1ATTRIBUTE\$1NAMES. + Les valeurs NULL et les valeurs scalaires SUPER telles que `"a"` restent inchangées. + Dans un objet SUPER, tous les noms d’attributs sont remplacés par des majuscules, mais les valeurs d’attributs tels que `"b"` restent inchangés. + UPPER\$1ATTRIBUTE\$1NAMES s’applique de manière récursive à tout objet SUPER imbriqué dans un tableau SUPER ou dans un autre objet. **Utilisation de UPPER\$1ATTRIBUTE\$1NAMES sur un objet SUPER avec des noms d’attributs dupliqués** Si un objet SUPER contient des attributs dont les noms ne diffèrent que dans leur cas, UPPER\$1ATTRIBUTE\$1NAMES générera une erreur. Prenez l’exemple de code suivant. ``` SELECT UPPER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ```