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.

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.

Operatoren und Funktionen

Mit Amazon Redshift können Sie mithilfe von SUPER-Daten mit von Operatoren und Funktionen erweiterte Analytik für große Datensätze durchführen. Operatoren und Funktionen für SUPER-Daten sind SQL-Konstrukte, die eine komplexe Analyse und Bearbeitung von halbstrukturierten Daten ermöglichen, die in Amazon-Redshift-Tabellen gespeichert sind.

In den folgenden Abschnitten werden die Syntax, Beispiele und bewährte Methoden für die Verwendung von Operatoren und Funktionen für SUPER-Daten in Amazon Redshift behandelt, um das volle Potenzial Ihrer halbstrukturierten Daten auszuschöpfen.

Arithmetische Operatoren

SUPER-Werte unterstützen alle grundlegenden arithmetischen Operatoren +, -, *, /, % mit dynamischer Typisierung. Der resultierende Typ der Operation bleibt SUPER. Für alle Operatoren, außer für den binären Operator +, müssen die Eingabeoperanden Zahlen sein. Andernfalls gibt Amazon Redshift null zurück. Die Unterscheidung zwischen Dezimalzahlen und Gleitkommawerten wird beibehalten, wenn Amazon Redshift diese Operatoren ausführt und sich der dynamische Typ nicht ändert. Die Dezimalskalierung ändert sich jedoch, wenn Sie Multiplikationen und Teilungen verwenden. Arithmetische Überläufe verursachen immer noch Abfragefehler, sie werden nicht in null geändert. Der binäre Operator + führt eine Addition aus, wenn die Eingaben Zahlen sind, oder eine Verkettung, wenn die Eingaben Zeichenfolgen sind. Wenn ein Operand eine Zeichenfolge ist und der andere Operand eine Zahl ist, ist das Ergebnis null Die unären Präfix-Operatoren + und - geben null zurück, wenn der SUPER-Wert keine Zahl ist, wie im folgenden Beispiel gezeigt:

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)

Durch die dynamische Typisierung können Dezimalwerte in SUPER unterschiedliche Maßstäbe haben. Amazon Redshift behandelt Dezimalwerte, als ob es sich um unterschiedliche statische Typen handelt und erlaubt alle mathematischen Operationen. Amazon Redshift berechnet die resultierende Skalierung dynamisch basierend auf den Skalierungen der Operanden. Wenn einer der Operanden eine Gleitkommazahl ist, stuft Amazon Redshift den anderen Operanden zu einer Gleitkommazahl herauf und generiert das Ergebnis als Gleitkommazahl.

Arithmetische Funktionen

Amazon Redshift unterstützt die folgenden arithmetischen Funktionen für SUPER-Spalten. Sie geben null zurück, wenn die Eingabe keine Zahl ist:

Im folgenden Beispiel werden arithmetische Funktionen zum Abfragen von Daten verwendet:

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

Die ABS-Funktion behält die Skala der Eingabe-Dezimalzahl während FLOOR, CEIL. ROUND eliminiert die Skala der Eingabe-Dezimalzahl.

Array-Funktionen

Amazon Redshift unterstützt die folgenden Array-Zusammensetzungen und Hilfsfunktionen:

Sie können SUPER-Arrays aus Werten in Amazon-Redshift-Datentypen mithilfe der ARRAY-Funktion erstellen, einschließlich anderer SUPER-Werte. Im folgenden Beispiel wird die variadische Funktion ARRAY verwendet:

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)

Im folgenden Beispiel wird die Array-Verkettung mit der Funktion ARRAY_CONCAT verwendet:

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

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

Das folgende Beispiel verwendet Array-Manipulation mit der SUBARRAY-Funktion, die eine Teilmenge des Eingabe-Arrays zurückgibt.

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

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

Im folgenden Beispiel werden mehrere Ebenen von Arrays mit ARRAY_FLATTEN zu einem einzelnen Array zusammengeführt:

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)

Array-Funktionen ARRAY_CONCAT und ARRAY_FLATTEN verwenden dynamische Typisierungsregeln. Sie geben eine Null anstelle eines Fehlers zurück, wenn die Eingabe kein Array ist. Die Funktion GET_ARRAY_LENGTH gibt die Länge eines an ein bestimmtes Objekt übergebenen SUPER-Arrays oder eines Array-Pfads an.

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

Im folgenden Beispiel wird eine Zeichenfolge mithilfe von SPLIT_TO_ARRAY in ein Array von Zeichenfolgen aufgeteilt. Die Funktion verwendet ein Trennzeichen als optionalen Parameter. Wenn kein Trennzeichen fehlt, ist der Standardwert ein Komma.

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

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

Kollationierungsverhalten

Mit SUPER können Sie die Kollationierung einer Spalte mit CREATE TABLE festlegen, den Standardkollationierungssatz mit CREATE DATABASE verwenden und die Kollationierung eines Ausdrucks mit der COLLATE-Funktion festlegen.

Die Kollationierungseinstellung gilt für alle in SUPER gespeicherten Vergleichsoperatoren und Zeichenkettenwerte, unabhängig davon, ob es sich um Zeichenkettenwerte, Zeichenketten innerhalb von SUPER-Arrays oder Werte eines SUPER-Objekts handelt. Bei SUPER-Objekten gilt das Kollationierungsverhalten nur für die Werte und nicht für die Attribute. Beispielsweise gibt ein Vergleich von Werten, bei denen die Kollationierung {"attribute": "a"} = {"attribute": "A"} ohne Berücksichtigung der Groß- und Kleinschreibung verwendet wird, „true“ zurück, während {"attribute": "a"} = {"ATTRIBUTE": "a"} „false“ zurückgibt.

Informationsfunktionen

SUPER-Datenspalten unterstützen Inspektionsfunktionen, die den dynamischen Typ und andere Typinformationen über den SUPER Wert zurückgeben. Das gängigste Beispiel ist die Skalarfunktion JSON_TYPEOF, die einen VARCHAR mit den Werten „boolean“, „number“, „string“, „object“, „array“ oder „null“ zurückgibt, abhängig vom dynamischen Typ des SUPER-Wertes. Amazon Redshift unterstützt die folgenden booleschen Funktionen für SUPER-Datenspalten:

Weitere Informationen zu SUPER-Informationsfunktionen finden Sie unter Funktionen für SUPER-Typinformationen.

Zeichenfolgenfunktionen

Um Zeichenkettenfunktionen mit Zeichenkettenliteralen im SUPER-Datentyp zu verwenden, müssen Sie das Zeichenkettenliteral in den Zeichenfolgentyp konvertieren, bevor Sie die Funktionen anwenden. Funktionen geben Null zurück, wenn es sich bei der Eingabe nicht um ein Zeichenkettenliteral handelt.

Zeichenfolgenfunktionenunterstützt jetzt bis zu 16.000.000 Byte.

Im folgenden Beispiel wird SUBSTRING verwendet, um die Vorschau einer Zeichenfolge mit einer Größe von 5.000.000 Byte zu extrahieren, die in einem SUPER JSON-Objekt gespeichert ist

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
   

Das folgende Beispiel demonstriert die Funktionen LEFT, RIGHT und CONCAT für Zeichenkettenliterale aus einem SUPER-Array:

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
   

Im folgenden Beispiel wird eine eigenständige Zeichenfolge in SUPER gespeichert:

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