Semistrukturierte Datentypen

Die folgenden Snowflake-Datentypen können andere Datentypen enthalten:

  • VARIANT (kann jeden anderen Datentyp enthalten)

  • ARRAY (kann direkt VARIANT und somit indirekt jeden anderen Datentyp, einschließlich sich selbst enthalten)

  • OBJECT (kann direkt VARIANT und somit indirekt jeden anderen Datentyp, einschließlich sich selbst enthalten)

Wir bezeichnen diese Datentypen oft als semistrukturierte Datentypen. Streng genommen ist OBJECT der einzige dieser Datentypen, der für sich genommen alle Merkmale eines echten semistrukturierten Datentyps aufweist. Die Kombination dieser Datentypen ermöglicht jedoch die explizite Darstellung beliebiger hierarchischer Datenstrukturen, die zum Laden und Bearbeiten von Daten in semistrukturierten Formaten (z. B. JSON, Avro, ORC, Parquet oder XML) verwendet werden können.

Jeder dieser Datentypen wird im Folgenden genauer beschrieben.

Unter diesem Thema:

VARIANT

Merkmale des Datentyps VARIANT

Ein VARIANT-Wert kann einen Wert mit einem beliebigen anderen Datentyp einschließlich OBJECT und ARRAY speichern.

Die maximale Länge eines VARIANT-Werts ist 16 MB.

Verwenden von VARIANT-Werten

Um einen Wert in oder aus dem Datentyp VARIANT zu konvertieren, können Sie explizit die Funktion CAST, die Funktion TO_VARIANT oder den Operator :: (z. B. expression::variant) verwenden.

In einigen Situationen können die Werte implizit in VARIANT-Werte umgewandelt werden. Weitere Details dazu finden Sie unter Datentypkonvertierung.

Das nachstehende Codebeispiel zeigt die Verwendung von VARIANT, einschließlich der Konvertierung von VARIANT und nach VARIANT.

Erstellen Sie eine Tabelle, und fügen Sie einen Wert ein:

CREATE TABLE varia (float1 FLOAT, v VARIANT, float2 FLOAT);
INSERT INTO varia (float1, v, float2) VALUES (1.23, NULL, NULL);

Mit dem ersten UPDATE wird ein Wert von einem FLOAT-Wert in einen VARIANT-Wert umgewandelt. Mit dem zweite UPDATE wird ein Wert von einem VARIANT-Wert in einen FLOAT-Wert umgewandelt.

UPDATE varia SET v = TO_VARIANT(float1);  -- converts FROM a float TO a variant.
UPDATE varia SET float2 = v::FLOAT;       -- converts FROM a variant TO a float.

Führen Sie ein SELECT auf allen Werten aus:

SELECT * FROM varia;
+--------+-----------------------+--------+
| FLOAT1 | V                     | FLOAT2 |
|--------+-----------------------+--------|
|   1.23 | 1.230000000000000e+00 |   1.23 |
+--------+-----------------------+--------+

Um einen Wert vom Datentyp VARIANT zu konvertieren, geben Sie den Datentyp an, in den Sie konvertieren möchten. Die folgende Anweisung verwendet beispielsweise den Operator ::, um anzugeben, dass VARIANT in FLOAT umgewandelt werden soll:

SELECT my_variant_column::FLOAT * 3.14 FROM ...;

VARIANT speichert sowohl den Wert als auch den Datentyp des Wertes. Dadurch können Sie auch VARIANT-Werte in Ausdrücken verwenden, in denen der Datentyp des Wertes gültig ist, ohne vorher eine Umwandlung in VARIANT vornehmen zu müssen. Beispiel: Wenn die VARIANT.Spalte my_variant_column einen numerischen Wert enthält, dann können Sie my_variant_column direkt mit einem anderen numerischen Wert multiplizieren:

SELECT my_variant_column * 3.14 FROM ...;

Sie können den nativen Datentyp des Wertes mit der Funktion TYPEOF abrufen.

Wenn VARCHARs, DATEs, TIMEs und TIMESTAMPs aus einer VARIANT-Spalte abgerufen werden, sind die Werte standardmäßig von doppelten Anführungszeichen umschlossen. Sie können die doppelten Anführungszeichen vermeiden, indem Sie die Werte explizit in die zugrundeliegenden Datentypen umwandeln (z. B. von VARIANT in VARCHAR). Beispiel:

SELECT 'Sample', 'Sample'::VARIANT, 'Sample'::VARIANT::VARCHAR;
+----------+-------------------+----------------------------+
| 'SAMPLE' | 'SAMPLE'::VARIANT | 'SAMPLE'::VARIANT::VARCHAR |
|----------+-------------------+----------------------------|
| Sample   | "Sample"          | Sample                     |
+----------+-------------------+----------------------------+

Ein VARIANT-Wert kann fehlen (SQL NULL enthalten). Das unterscheidet sich von einem VARIANT-null-Wert, bei dem es sich um einen tatsächlichen Wert handelt, der zur Darstellung eines Nullwerts in semistrukturierten Daten dient. VARIANT-null ist echter Wert, der beim Vergleich mit sich selbst Gleichheit ergibt. Weitere Informationen dazu finden Sie unter VARIANT null.

Wenn Daten aus dem JSON-Format geladen und in VARIANT gespeichert wurden, gelten die folgenden Richtlinien:

  • Bei Daten, die größtenteils regulär sind und nur native JSON-Typen nutzen (Zeichenfolgen und Zahlen, keine Zeitstempel), ist die Speicher- und Abfrageleistung bei Operationen mit relationalen Daten und Daten in einer VARIANT-Spalte sehr ähnlich. Werte wie Datum und Zeitstempel, die nicht systemeigen sind, werden beim Laden in eine VARIANT-Spalte als Zeichenfolgen gespeichert, sodass Operationen mit diesen Werten langsamer sein können und auch mehr Speicherplatz beanspruchen als bei einer Speicherung in einer relationalen Spalte mit dem entsprechenden Datentyp.

Weitere Informationen zur Verwendung von VARIANT finden Sie unter Hinweise zu in VARIANT gespeicherten semistrukturierten Daten.

Weitere Informationen zum Abfragen von semistrukturierten Daten, die in einem VARIANT gespeichert sind, finden Sie unter Abfragen von semistrukturierten Daten.

Beispiel für das Einfügen eines VARIANT

Um VARIANT-Daten direkt einzufügen, verwenden Sie IIS (INSERT INTO ... SELECT). Das folgende Beispiel zeigt, wie JSON-formatierte Daten in einen VARIANT eingefügt werden:

INSERT INTO varia (v) 
    SELECT TO_VARIANT(PARSE_JSON('{"key3": "value3", "key4": "value4"}'));

Häufige Verwendungszwecke von VARIANT

VARIANT wird normalerweise in folgenden Fällen verwendet:

  • Sie möchten hierarchische Daten erstellen, indem Sie explizit eine Hierarchie definieren, die zwei oder mehr ARRAYs oder OBJECTs enthält.

  • Sie möchten JSON-, Avro-, ORC- oder Parquet-Daten direkt laden, ohne die hierarchische Struktur der Daten explizit zu beschreiben.

    Snowflake kann Daten aus dem JSON-, Avro-, ORC- oder Parquet-Format automatisch in eine interne Hierarchie von ARRAY-, OBJECT- und VARIANT-Daten konvertieren und diese hierarchischen Daten direkt in einem VARIANT-Wert speichern. Obwohl Sie die Datenhierarchie manuell selbst erstellen können, ist es in der Regel einfacher, dies Snowflake zu überlassen.

    Weitere Informationen zum Laden und Konvertieren semistrukturierter Daten finden Sie unter Laden von semistrukturierten Daten.

OBJECT

Ein Snowflake-OBJECT ist analog zu einem JSON-„Objekt“. In anderen Programmiersprachen wird der entsprechende Datentyp auch als „Wörterbuch“, „Hash“ oder „Map“ bezeichnet.

Ein OBJECT enthält Schlüssel-Wert-Paare.

Merkmale eines OBJECT

In einem Snowflake-OBJECT ist jeder Schlüssel ein VARCHAR-Wert und jeder Wert ein VARIANT-Wert.

Da VARIANT-Werte jeden anderen Datentyp speichern können, können verschiedene Werte (in verschiedenen Schlüssel-Wert-Paaren) unterschiedliche zugrunde liegende Datentypen haben. So kann beispielsweise ein OBJECT den Namen einer Person als VARCHAR-Wert und das Alter einer Person als INTEGER-Wert enthalten. Im folgenden Beispiel werden sowohl der Name als auch das Alter in VARIANT-Werte umgewandelt.

SELECT OBJECT_CONSTRUCT(
    'name', 'Jones'::VARIANT,
    'age',  42::VARIANT
    );

Snowflake unterstützt derzeit keine explizit typisierten Objekte.

In einem Schlüssel-Wert-Paar darf der Schlüssel keine leere Zeichenfolge sein, und weder der Schlüssel noch der Wert dürfen NULL sein.

Die maximale Länge eines OBJECT ist 16 MB.

Ein OBJECT kann semistrukturierte Daten enthalten.

Ein OBJECT kann verwendet werden, um hierarchische Datenstrukturen zu erstellen.

OBJECT-Konstanten

Eine Konstante (auch als Literal bezeichnet) bezieht sich auf einen festen Datenwert. Snowflake unterstützt die Verwendung von Konstanten zur Angabe von OBJECT-Werten. OBJECT-Konstanten werden durch geschweifte Klammern ({ und }) abgegrenzt.

Der folgende Codeblock zeigt beispielsweise zwei OBJECT-Konstanten, von denen die erste ein leeres OBJECT ist und die zweite die Namen und Hauptstädte von zwei kanadischen Provinzen enthält:

{}

{ 'Alberta': 'Edmonton' , 'Manitoba': 'Winnipeg' }

Die folgenden Anweisungen verwenden eine OBJECT-Konstante und die Funktion OBJECT_CONSTRUCT, um die gleiche Aufgabe auszuführen:

UPDATE my_table SET my_object = { 'Alberta': 'Edmonton' , 'Manitoba': 'Winnipeg' };

UPDATE my_table SET my_object = OBJECT_CONSTRUCT('Alberta', 'Edmonton', 'Manitoba', 'Winnipeg');

Beachten Sie, dass in SQL-Anweisungen Zeichenfolgenliterale innerhalb eines OBJECT mit einfachen Anführungszeichen angeben werden (wie in Snowflake SQL üblich), dass aber Zeichenfolgenliterale innerhalb eines OBJECT mit doppelten Anführungszeichen dargestellt werden:

SELECT { 'Manitoba': 'Winnipeg' } AS 'Capital';

+--------------------------+
| CAPITAL                  |
|--------------------------|
| {                        |
|   "Manitoba": "Winnipeg" |
| }                        |
+--------------------------+

Zugriff auf Elemente eines OBJECT nach Schlüssel

Um den Wert in einem Objekt abzurufen, geben Sie den Schlüssel in eckigen Klammern an, wie unten gezeigt:

select my_variant_column['key1'] from my_table;

Sie können auch den Doppelpunkt-Operator verwenden. Mit dem folgenden Befehl wird gezeigt, dass die Ergebnisse gleich sind, egal ob Doppelpunkt oder eckige Klammern verwendet werden:

SELECT object_column['thirteen'],
       object_column:thirteen
    FROM object_example;
+---------------------------+------------------------+
| OBJECT_COLUMN['THIRTEEN'] | OBJECT_COLUMN:THIRTEEN |
|---------------------------+------------------------|
| 13                        | 13                     |
+---------------------------+------------------------+

Weitere Informationen zum Doppelpunkt-Operator finden Sie unter Punktierte Schreibweise, wo die Verwendung der Operatoren : und . für den Zugriff auf verschachtelte Daten beschrieben wird.

Beispiel für das Einfügen eines OBJECT

Um OBJECT-Daten direkt einzufügen, verwenden Sie IIS (INSERT INTO ... SELECT).

Der folgende Code verwendet die Funktion OBJECT_CONSTRUCT, um das einzufügende OBJECT zu konstruieren.

INSERT INTO object_example (object_column)
    SELECT OBJECT_CONSTRUCT('thirteen', 13::VARIANT, 'zero', 0::VARIANT);

Im folgenden Code wird eine OBJECT-Konstante verwendet, um das einzufügende OBJECT anzugeben.

INSERT INTO object_example (object_column)
    SELECT { 'thirteen': 13::VARIANT, 'zero': 0::VARIANT };

Beachten Sie, dass in jedem Schlüssel-Wert-Paar der Wert explizit in einen VARIANT-Wert umgewandelt wurde. Eine explizite Umwandlung war in diesen Fällen nicht erforderlich. Snowflake kann implizit eine Umwandlung in VARIANT ausführen. (Weitere Informationen zur impliziten Umwandlung finden Sie unter Datentypkonvertierung.)

Häufige Verwendungszwecke für ein OBJECT

Ein OBJECT wird normalerweise verwendet, wenn eine oder mehrere der folgenden Bedingungen erfüllt sind:

  • Sie haben mehrere Datenelemente, die durch Zeichenfolgen identifiziert werden. Wenn Sie z. B. Informationen unter Verwendung des Provinznamens suchen möchten, sollten Sie ein OBJECT verwenden.

  • Sie möchten Informationen über die Daten zusammen mit den Daten speichern. Die Namen (Schlüssel) dienen nicht nur als eindeutige Bezeichner, sondern sie haben auch eine Bedeutung.

  • Die Informationen haben keine natürliche Reihenfolge, oder die Reihenfolge lässt sich nur aus den Schlüsseln ableiten.

  • Die Struktur der Daten variiert, oder die Daten können unvollständig sein. Wenn Sie z. B. einen Katalog von Büchern erstellen möchten, der normalerweise den Titel, den Namen des Autors und das Erscheinungsdatum enthält, aber in einigen Fällen ist das Erscheinungsdatum unbekannt, dann sollten Sie ein OBJECT verwenden.

ARRAY

Ein Snowflake-ARRAY ist ähnlich wie ein Array in vielen anderen Programmiersprachen. Ein ARRAY enthält 0 oder mehr Daten. Der Zugriff auf jedes Element erfolgt durch Angabe seiner Position im Array.

Merkmale eines ARRAY

Jeder Wert in einem ARRAY ist vom Typ VARIANT. (Ein VARIANT-Wert kann einen Wert eines beliebigen anderen Datentyps enthalten.)

Werte anderer Datentypen können in VARIANT umgewandelt und dann in einem Array gespeichert werden. Einige Funktionen für ARRAYs, einschließlich ARRAY_CONSTRUCT, können eine implizite Umwandlung in VARIANT-Werte für Sie vornehmen.

Da in ARRAYs VARIANT-Werte gespeichert werden und VARIANT-Werte andere Datentypen enthalten können, müssen die zugrunde liegenden Datentypen der Werte in einem ARRAY nicht identisch sein. In den meisten Fällen haben die Datenelemente denselben oder einen kompatiblen Datentyp, sodass sie alle auf die gleiche Weise verarbeitet werden können.

Snowflake unterstützt keine Arrays mit Elementen eines bestimmten Nicht-VARIANT-Typs.

Eine Snowflake-ARRAY wird ohne Angabe der Anzahl der Elemente deklariert. Ein ARRAY kann auf der Grundlage von Operationen wie ARRAY_APPEND dynamisch wachsen. Snowflake unterstützt derzeit keine Arrays mit fester Größe.

Ein ARRAY kann NULL-Werte enthalten.

Die theoretische maximale Größe aller Werte in einem ARRAY ist 16 MB. Allerdings haben ARRAYs einen internen Overhead. Die praktische maximale Datengröße ist in der Regel kleiner, abhängig von der Anzahl und den Werten der Elemente.

ARRAY-Konstanten

Eine Konstante (auch als Literal bezeichnet) bezieht sich auf einen festen Datenwert. Snowflake unterstützt die Verwendung von Konstanten zur Angabe von ARRAY-Werten. ARRAY-Konstanten werden durch eckige Klammern ([ und ]) abgegrenzt.

Der folgende Codeblock zeigt zum Beispiel zwei ARRAY-Konstanten, von denen die erste ein leeres ARRAY ist und die zweite die Namen zweier kanadischer Provinzen enthält:

[]

[ 'Alberta', 'Manitoba' ]

Die folgenden Anweisungen verwenden eine ARRAY-Konstante und die Funktion ARRAY_CONSTRUCT, um die gleiche Aufgabe auszuführen:

UPDATE my_table SET my_array = [ 1, 2 ];

UPDATE my_table SET my_array = ARRAY_CONSTRUCT(1, 2);

Beachten Sie, dass in SQL-Anweisungen Zeichenfolgenliterale innerhalb eines ARRAY mit einfachen Anführungszeichen angeben werden (wie in Snowflake SQL üblich), dass aber Zeichenfolgenliterale innerhalb eines ARRAY mit doppelten Anführungszeichen dargestellt werden:

SELECT [ 'Manitoba' ] AS 'Capital';

+----------------+
| CAPITAL        |
|----------------|
| [ "Winnipeg" ] |
+----------------+

Zugriff auf Elemente eines ARRAY per Index oder per Slice

Arrayindizes sind 0-basiert: Das erste Element in einem Array ist das Element 0.

Der Zugriff auf Werte in einem Array erfolgt durch Angabe der Indexnummer eines Arrayelements in eckigen Klammern. Die folgende Abfrage liest zum Beispiel den Wert an der Indexposition 2 aus dem in my_array_column gespeicherten Array.

select my_array_column[2] from my_table;

Arrays können verschachtelt werden. Die folgende Abfrage liest Element 0 aus dem Element 0 eines verschachtelten Arrays:

select my_array_column[0][0] from my_table;

Der Versuch, auf ein Element jenseits des Endes eines Arrays zuzugreifen, liefert NULL.

Ein Slice eines Arrays ist eine Sequenz benachbarter Elemente, d. h. eine zusammenhängende Teilmenge des Arrays.

Sie können auf einen Slices eines Arrays zugreifen, indem Sie die Funktion ARRAY_SLICE aufrufen. Beispiel:

select array_slice(my_array_column, 5, 10) from my_table;

Die Funktion ARRAY_SLICE() gibt Elemente vom angegebenen Anfangselement (Element 5 im obigen Beispiel) bis zum, aber nicht einschließlich des angegebenen Endelements (Element 10 im obigen Beispiel) zurück.

Ein leeres Array oder ein leeres Slice wird meist durch ein Paar eckiger Klammern mit nichts dazwischen ([]) angegeben.

Dünnbesetzte vs. dichte ARRAYs

Ein Array kann dicht oder dünnbesetzt sein.

In einem dichten Array beginnen die Indexwerte der Elemente bei 0 und sind sequenziell (0, 1, 2, usw.). In einem dünnbesetzten Array müssen die Indexwerte nicht sequenziell sein (z. B. 0, 2, 5). Die Werte müssen nicht bei 0 beginnen.

Hat ein Index kein entsprechendes Element, so gilt der Wert, der diesem Index entspricht, als undefiniert. Wenn zum Beispiel ein dünnbesetztes Array drei Elemente hat und diese Elemente an den Indizes 0, 2 und 5 liegen, dann sind die Elemente an den Indizes 1, 3 und 4 undefined.

   0            2                  5
+-----+.....+-------+.....+.....+------+
| Ann |     | Carol |     |     | Fred |
+-----+.....+-------+.....+.....+------+

         ^             ^     ^
         |             |     |
        undefined--------------

Ein undefiniertes Element wird wie ein Element behandelt. Betrachten wir zum Beispiel das frühere Beispiel eines dünnbesetzten Arrays, das Elemente bei den Indizes 0, 2 und 5 enthält (und keine Elemente nach Index 5). Wenn Sie den Slice mit den Elementen an den Indizes 3 und 4 lesen, sieht die Ausgabe wie folgt aus:

[ undefined, undefined ]

Der Versuch, auf einen Slice hinter dem Ende eines Arrays zuzugreifen, führt zu einem leeren Array, nicht zu einem Array mit undefined Werten. Mit der folgenden SELECT-Anweisung wird versucht, über das letzte Element des dünnbesetzten Arrays hinaus zu lesen:

select array_slice(array_column, 6, 8) from table_1;

Die Ausgabe ist ein leeres Array:

+---------------------------------+
| array_slice(array_column, 6, 8) |
+---------------------------------+
| [ ]                             |
+---------------------------------+

Beachten Sie, dass sich undefined von NULL unterscheidet. Ein NULL-Wert in einem Array ist ein definiertes Element.

In einem dichten Array verbraucht jedes Element Speicherplatz, auch wenn der Wert des Elements NULL ist.

In einem dünnbesetzten Array verbrauchen die undefined-Elemente nicht direkt Speicherplatz.

In einem dichten Array liegt der theoretische Bereich der Indexwerte zwischen 0 und 16.777.215. (Die maximale theoretische Anzahl von Elementen ist 16.777.216, da die Obergrenze der Größe 16 MB (16.777.216 Bytes) und der kleinstmögliche Wert ein Byte ist).

In einem dünnbesetzten Array liegt der theoretische Bereich der Indexwerte zwischen 0 und 231 - 1. Aufgrund der 16-MB-Beschränkung kann ein dünnbesetztes Array jedoch keine 231 Werte enthalten. Die maximale theoretische Anzahl von Werten ist immer noch auf 16.777.216 begrenzt.

(Denken Sie daran, dass aufgrund des internen Overheads die praktische Größenbegrenzung sowohl bei dichten als auch bei dünnbesetzten Arrays zumindest geringfügig unter dem theoretischen Maximum von 16 MB liegt).

Sie können ein dünnbesetztes Array erstellen, indem Sie die Funktion ARRAY_INSERT verwenden, um Werte an bestimmten Indexpunkten in ein Array einzufügen (wobei andere Arrayelemente undefined bleiben). Beachten Sie, dass ARRAY_INSERT() die Elemente nach rechts schiebt, wodurch sich die Indexwerte ändern, die für den Zugriff auf die Elemente erforderlich sind. Daher sollten Sie ein dünnbesetztes Array fast immer von links nach rechts füllen (d. h. von 0 aufwärts, wobei der Indexwert für jeden neu eingefügten Wert erhöht wird).

Beispiel für das Einfügen eines ARRAY

Um ARRAY-Daten direkt einzufügen, verwenden Sie IIS (INSERT INTO ... SELECT).

Der folgende Code verwendet die Funktion ARRAY_CONSTRUCT, um das einzufügende ARRAY zu konstruieren.

INSERT INTO array_example (array_column)
    SELECT ARRAY_CONSTRUCT(12, 'twelve', NULL);

Im folgenden Code wird eine ARRAY-Konstante verwendet, um das einzufügende ARRAY anzugeben.

INSERT INTO array_example (array_column)
    SELECT [ 12, 'twelve', NULL ];

Häufige Verwendungszwecke für ein ARRAY

Ein ARRAY wird normalerweise verwendet, wenn eine oder mehrere der folgenden Bedingungen erfüllt sind:

  • Sie haben viele Datenelemente, die alle gleich oder ähnlich strukturiert sind.

  • Alle Daten müssen auf ähnliche Weise verarbeitet werden. Sie könnten zum Beispiel die Daten mit einer Schleife durchlaufen und jedes Element auf dieselbe Weise verarbeiten.

  • Die Daten haben eine natürliche Reihenfolge, zum Beispiel chronologisch.

Beispiele

Dieses erste Beispiel zeigt die Ausgabe eines DESC TABLE-Befehls in einer Tabelle mit VARIANT-, ARRAY- und OBJECT-Daten.

CREATE OR REPLACE TABLE test_semi_structured(var VARIANT,
                                    arr ARRAY,
                                    obj OBJECT
                                    );

DESC TABLE test_semi_structured;

+------+---------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name | type    | kind   | null? | default | primary key | unique key | check | expression | comment |
|------+---------+--------+-------+---------+-------------+------------+-------+------------+---------|
| VAR  | VARIANT | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| ARR  | ARRAY   | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| OBJ  | OBJECT  | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+------+---------+--------+-------+---------+-------------+------------+-------+------------+---------+

In diesem Beispiel wird gezeigt, wie Sie einfache Werte in die Tabelle laden und wie diese Werte aussehen, wenn Sie die Tabelle abfragen.

Erstellen Sie eine Tabelle, und Laden Sie die Daten:

CREATE TABLE demonstration1 (
    ID INTEGER,
    array1 ARRAY,
    variant1 VARIANT,
    object1 OBJECT
    );

INSERT INTO demonstration1 (id, array1, variant1, object1) 
  SELECT 
    1, 
    ARRAY_CONSTRUCT(1, 2, 3), 
    PARSE_JSON(' { "key1": "value1", "key2": "value2" } '),
    PARSE_JSON(' { "outer_key1": { "inner_key1A": "1a", "inner_key1B": "1b" }, '
              ||
               '   "outer_key2": { "inner_key2": 2 } } ')
    ;

INSERT INTO demonstration1 (id, array1, variant1, object1) 
  SELECT 
    2,
    ARRAY_CONSTRUCT(1, 2, 3, NULL), 
    PARSE_JSON(' { "key1": "value1", "key2": NULL } '),
    PARSE_JSON(' { "outer_key1": { "inner_key1A": "1a", "inner_key1B": NULL }, '
              ||
               '   "outer_key2": { "inner_key2": 2 } '
              ||
               ' } ')
  ;

Zeigen Sie nun die Daten in der Tabelle an.

SELECT * 
    FROM demonstration1
    ORDER BY id;
+----+-------------+---------------------+--------------------------+
| ID | ARRAY1      | VARIANT1            | OBJECT1                  |
|----+-------------+---------------------+--------------------------|
|  1 | [           | {                   | {                        |
|    |   1,        |   "key1": "value1", |   "outer_key1": {        |
|    |   2,        |   "key2": "value2"  |     "inner_key1A": "1a", |
|    |   3         | }                   |     "inner_key1B": "1b"  |
|    | ]           |                     |   },                     |
|    |             |                     |   "outer_key2": {        |
|    |             |                     |     "inner_key2": 2      |
|    |             |                     |   }                      |
|    |             |                     | }                        |
|  2 | [           | {                   | {                        |
|    |   1,        |   "key1": "value1", |   "outer_key1": {        |
|    |   2,        |   "key2": null      |     "inner_key1A": "1a", |
|    |   3,        | }                   |     "inner_key1B": null  |
|    |   undefined |                     |   },                     |
|    | ]           |                     |   "outer_key2": {        |
|    |             |                     |     "inner_key2": 2      |
|    |             |                     |   }                      |
|    |             |                     | }                        |
+----+-------------+---------------------+--------------------------+

Weitere Beispiele für die Nutzung semistrukturierter Daten finden Sie unter Abfragen von semistrukturierten Daten.

Zurück zum Anfang