Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Objektfunktionen Im Folgenden sind die SQL-Objektfunktionen aufgeführt, die Amazon Redshift unterstützt, um Objekte vom Typ SUPER zu erstellen und zu bearbeiten: **Topics** + [Funktion GET\$1NUMBER\$1ATTRIBUTES](get_number_attributes.md) + [Funktion LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md) + [OBJECT-Funktion](r_object_function.md) + [OBJECT\$1TRANSFORM-Funktion](r_object_transform_function.md) + [Funktion UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md) # Funktion GET\$1NUMBER\$1ATTRIBUTES Gibt die Anzahl der Schlüssel-Wert-Paare zurück, die auf der Stammebene eines Wörterbuchobjekts existieren. ## Syntax ``` GET_NUMBER_ATTRIBUTES( super_expression ) ``` ## Argumente *super\$1expression* Ein SUPER-Ausdruck in Wörterbuchform. ## Rückgabetyp Die Funktion GET\$1NUMBER\$1ATTRIBUTES gibt einen INT-Typ zurück. ## Hinweis Diese Funktion zählt nur direkte Attribute und schließt keine Paare in verschachtelten Wörterbüchern ein. ## Beispiel Das folgende Beispiel zeigt die Funktion GET\$1NUMBER\$1ATTRIBUTES. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": 2, "c": 3}')); get_number_attributes ----------------------- 3 (1 row) ``` Die Funktion GET\$1NUMBER\$1ATTRIBUTES funktioniert nur auf der ersten Ebene des Wörterbuchs. ``` SELECT GET_NUMBER_ATTRIBUTES(JSON_PARSE('{"a": 1, "b": {"c": 3}}')); get_number_attributes ----------------------- 2 (1 row) ``` # Funktion LOWER\$1ATTRIBUTE\$1NAMES Konvertiert alle zutreffenden Attributnamen in einem SUPER-Wert in Kleinbuchstaben und verwendet dabei dieselbe Konvertierungsroutine wie [Die Funktion LOWER](r_LOWER.md). LOWER\$1ATTRIBUTE\$1NAMES unterstützt UTF-8-Multibyte-Zeichen bis zu einer maximalen Länge von vier Bytes pro Zeichen. Verwenden Sie [Funktion UPPER\$1ATTRIBUTE\$1NAMES](r_upper_attribute_names.md), um SUPER-Attributnamen in Großbuchstaben zu konvertieren. ## Syntax ``` LOWER_ATTRIBUTE_NAMES( super_expression ) ``` ## Argumente *super\$1expression* Ein SUPER-Ausdruck. ## Rückgabetyp `SUPER` ## Nutzungshinweise In Amazon Redshift wird bei Spaltenbezeichnern traditionell nicht zwischen Groß- und Kleinschreibung unterschieden und sie werden in Kleinbuchstaben umgewandelt. Wenn Sie Daten aus Datenformaten wie JSON aufnehmen, bei denen die Groß- und Kleinschreibung beachtet wird, können die Daten Attributnamen mit gemischter Groß- und Kleinschreibung enthalten. Betrachten Sie das folgende Beispiel. ``` 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 gibt für beide Abfragen NULL zurück. Verwenden Sie für Abfragen von `AttributeName` LOWER\$1ATTRIBUTE\$1NAMES, um die Attributnamen der Daten in Kleinbuchstaben umzuwandeln. Betrachten Sie das folgende Beispiel. ``` 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" ``` Eine verwandte Option für die Arbeit mit Objektattributnamen mit gemischter Groß- und Kleinschreibung ist die `enable_case_sensitive_super_attribute`-Konfigurationsoption, mit der Amazon Redshift Groß- und Kleinschreibung in SUPER-Attributnamen erkennt. Dies kann eine alternative Lösung zur Verwendung von LOWER\$1ATTRIBUTE\$1NAMES sein. Weitere Informationen zu `enable_case_sensitive_super_attribute` finden Sie unter [enable\$1case\$1sensitive\$1super\$1attribute](r_enable_case_sensitive_super_attribute.md). ## Beispiele **Konvertieren von SUPER-Attributnamen in Kleinbuchstaben** Im folgenden Beispiel wird LOWER\$1ATTRIBUTE\$1NAMES verwendet, um die Attributnamen aller SUPER-Werte in einer Tabelle zu konvertieren. ``` -- 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"]}] ``` Beobachten Sie, wie LOWER\$1ATTRIBUTE\$1NAMES funktioniert. + NULL-Werte und skalare SUPER-Werte wie `"A"` sind unverändert. + In einem SUPER-Objekt werden alle Attributnamen zu Kleinbuchstaben geändert, Attributwerte wie z. B. `"B"` bleiben jedoch unverändert. + LOWER\$1ATTRIBUTE\$1NAMES gilt rekursiv für jedes SUPER-Objekt, das in einem SUPER-Array oder in einem anderen Objekt verschachtelt ist. **Verwendung von LOWER\$1ATTRIBUTE\$1NAMES für ein SUPER-Objekt mit doppelten Attributnamen** Wenn ein SUPER-Objekt Attribute enthält, deren Namen sich nur in ihrer Groß- und Kleinschreibung unterscheiden, gibt LOWER\$1ATTRIBUTE\$1NAMES einen Fehler aus. Betrachten Sie das folgende Beispiel. ``` SELECT LOWER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ``` # OBJECT-Funktion Erstellt ein Array des SUPER-Datentyps. ## Syntax ``` OBJECT ( [ key1, value1 ], [ key2, value2 ...] ) ``` ## Argumente *key1, key2* Ausdrücke, die zu VARCHAR-Typzeichenfolgen ausgewertet werden. *value1, value2* Ausdrücke eines Amazon-Redshift-Datentyps außer Datums- und Uhrzeittypen, da Amazon Redshift die Datums- und Uhrzeittypen nicht in den SUPER-Datentyp umwandelt. Weitere Informationen zu Datums- und Uhrzeittypen finden Sie unter [Datum-/Uhrzeittypen](r_Datetime_types.md). `value`-Ausdrücke in einem Objekt müssen nicht denselben Datentyp haben. ## Rückgabetyp `SUPER` ## Beispiel ``` -- 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 ``` # OBJECT\$1TRANSFORM-Funktion Transformiert ein SUPER-Objekt. ## Syntax ``` OBJECT_TRANSFORM( input [KEEP path1, ...] [SET path1, value1, ..., ... ] ) ``` ## Argumente *input* Ein Ausdruck, der in ein Objekt vom Typ SUPER aufgelöst wird. *KEEP* Alle in dieser Klausel angegebenen *Pfad*-Werte werden beibehalten und auf das Ausgabeobjekt übertragen. Diese Klausel ist optional. *path1*, *path2*, ... Konstante Zeichenfolgenliterale im Format von Pfadkomponenten in doppelten Anführungszeichen, die durch Punkte getrennt sind. Beispielsweise ist `'"a"."b"."c"'` ein gültiger Pfad-Wert. Dies gilt für den Pfadparameter sowohl in der KEEP- als auch in der SET-Klausel. *SET* *Pfad*- und *Wert*-Paare, um einen bestehenden Pfad zu ändern oder einen neuen Pfad hinzuzufügen und den Wert dieses Pfads im Ausgabeobjekt festzulegen. Diese Klausel ist optional. *value1*, *value2*, ... Ausdrücke, die in Werte vom Typ SUPER aufgelöst werden. Beachten Sie, dass numerische, Text- und boolesche Typen in SUPER aufgelöst werden können. ## Rückgabetyp `SUPER` ## Nutzungshinweise OBJECT\$1TRANSFORM gibt ein Objekt vom Typ SUPER zurück, das die Pfadwerte aus der *Eingabe* enthält, die in KEEP angegeben wurden, und die *Pfad*-*Wert*-Paare, die in SET angegeben wurden. Wenn sowohl KEEP als auch SET leer sind, gibt OBJECT\$1TRANSFORM *Eingabe* zurück. Wenn es sich bei *Eingabe* nicht um ein *Objekt* vom Typ SUPER handelt, gibt OBJECT\$1TRANSFORM unabhängig von KEEP- oder SET-Werten *Eingabe* zurück. ## Beispiel Im folgenden Beispiel wird ein SUPER-Objekt in ein anderes SUPER-Objekt umgewandelt. ``` 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" } ``` # Funktion UPPER\$1ATTRIBUTE\$1NAMES Konvertiert alle zutreffenden Attributnamen in einem SUPER-Wert in Großbuchstaben und verwendet dabei dieselbe Umwandlungsroutine wie [Die Funktion UPPER](r_UPPER.md). UPPER\$1ATTRIBUTE\$1NAMES unterstützt UTF-8-Multibyte-Zeichen bis zu einer maximalen Länge von vier Bytes pro Zeichen. Um SUPER-Attributnamen in Kleinbuchstaben umzuwandeln, verwenden Sie [Funktion LOWER\$1ATTRIBUTE\$1NAMES](r_lower_attribute_names.md). ## Syntax ``` UPPER_ATTRIBUTE_NAMES( super_expression ) ``` ## Argumente *super\$1expression* Ein SUPER-Ausdruck. ## Rückgabetyp `SUPER` ## Beispiele **Konvertieren von SUPER-Attributnamen in Großbuchstaben** Im folgenden Beispiel werden UPPER\$1ATTRIBUTE\$1NAMES verwendet, um die Attributnamen aller SUPER-Werte in einer Tabelle zu konvertieren. ``` -- 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"]}] ``` Beobachten Sie, wie UPPER\$1ATTRIBUTE\$1NAMES funktioniert. + NULL-Werte und skalare SUPER-Werte wie `"a"` sind unverändert. + In einem SUPER-Objekt werden alle Attributnamen zu Großbuchstaben geändert, Attributwerte wie z. B. `"b"` bleiben jedoch unverändert. + UPPER\$1ATTRIBUTE\$1NAMES gilt rekursiv für jedes SUPER-Objekt, das in einem SUPER-Array oder in einem anderen Objekt verschachtelt ist. **Verwendung von UPPER\$1ATTRIBUTE\$1NAMES für ein SUPER-Objekt mit doppelten Attributnamen** Wenn ein SUPER-Objekt Attribute enthält, deren Namen sich nur in ihrer Groß- und Kleinschreibung unterscheiden, gibt UPPER\$1ATTRIBUTE\$1NAMES einen Fehler aus. Betrachten Sie das folgende Beispiel. ``` SELECT UPPER_ATTRIBUTE_NAMES(JSON_PARSE('{"A": "A", "a": "a"}')); error: Invalid input code: 8001 context: SUPER value has duplicate attributes after case conversion. ```