Einführung in semistrukturierte Daten

Semistrukturierte Daten sind Daten, die nicht den Standards üblicher strukturierter Daten entsprechen. Sie enthalten Tags und andere Arten von Markierungen, die individuelle, unterschiedliche Einheiten innerhalb der Daten identifizieren.

Zwei der wichtigsten Attribute, die semistrukturierte Daten von strukturierten Daten unterscheiden, sind verschachtelte Datenstrukturen und das Fehlen eines festen Schemas:

  • Strukturierte Daten erfordern ein festes Schema, das definiert wird, bevor die Daten in ein relationales Datenbanksystem geladen und abgefragt werden können. Semistrukturierte Daten erfordern keine vorherige Definition eines Schemas und können sich ständig weiterentwickeln, d. h. es können jederzeit neue Attribute hinzugefügt werden.

    Darüber hinaus können Entitäten innerhalb derselben Klasse unterschiedliche Attribute haben, obwohl sie gruppiert sind, und die Reihenfolge der Attribute ist nicht wichtig.

  • Im Gegensatz zu strukturierten Daten, die Daten als flache Tabelle darstellen, können semistrukturierte Daten n-stufige Hierarchien verschachtelter Informationen enthalten.

Unter diesem Thema:

Laden von semistrukturierten Daten

Die Schritte zum Laden semistrukturierter Daten in Tabellen sind identisch mit denen zum Laden strukturierter Daten in relationale Tabellen.

Snowflake lädt semistrukturierte Daten in eine einzige VARIANT-Spalte. Alternativ können Sie die COPY INTO-Tabellenanweisung mit Datentransformation verwenden, um ausgewählte Spalten einer Staging-Datendatei in separate Tabellenspalten zu extrahieren.

Unterstützte Dateiformate

Was ist JSON?

JSON (JavaScript-Objektnotation) ist ein einfaches, nur aus Text bestehendes Datenaustauschformat, das auf einer Teilmenge der Programmiersprache JavaScript basiert.

JSON-Daten können von jeder Anwendung erstellt werden. Hier einige allgemeine Beispiele:

  • JavaScript-Anwendungen, die zum Generieren von JSON-Daten native Methoden verwenden

  • Nicht-JavaScript-Anwendungen, die zum Generieren von JSON-Daten Bibliotheken (meist mit Erweiterungen) verwenden

  • Ad-hoc-JavaScript-Generatoren

  • Verkettung von JSON-Dokumenten (mit oder ohne Zeilentrennung)

Da es keine formale Spezifikation gibt, gibt es signifikante Unterschiede zwischen verschiedenen Implementierungen. Diese Unterschiede machen den Import von JSON-ähnlichen Datasets unmöglich, wenn der JSON-Parser in seiner Sprachdefinition streng ist. Um den Import von JSON-Datasets so problemlos wie möglich zu gestalten, folgt Snowflake der Regel „Sei liberal in dem, was du akzeptierst“. Die Absicht ist es, den größtmöglichen Bereich von JSON- und JSON-ähnlichen Eingaben zu akzeptieren, die eine eindeutige Interpretation ermöglichen.

Unter diesem Thema wird die Syntax für JSON-Dokumente beschrieben, die von Snowflake akzeptiert werden.

Weitere Informationen zu JSON finden Sie unter json.org.

Grundlegende JSON-Syntax

JSON-Daten sind eine hierarchische Sammlung von Name/Wert-Paaren, die in Objekte und Arrays gruppiert sind:

  • Doppelpunkte : trennen Namen und Werte in Name/Wert-Paaren.

  • Geschweifte Klammern {} kennzeichnen Objekte.

  • Eckige Klammern [] kennzeichnen Arrays.

  • Kommas , trennen Entitäten in Objekten und Arrays.

Name/Wert-Paare

Name/Wert-Paare in JSON bestehen aus einem Feldnamen (in doppelten Anführungszeichen), gefolgt von einem Doppelpunkt und dann einem Wert.

Beispiel:

{"firstName":"John", "empid":45611}

Unterstützte Datentypen

Ein Wert in einem Name/Wert-Paar kann sein:

  • Eine Zahl (Ganzzahl oder Gleitkommazahl)

  • Eine Zeichenfolge (in doppelten Anführungszeichen)

  • Ein Boolescher Wert (wahr oder falsch)

  • Ein Array (in eckigen Klammern)

  • Ein Objekt (in geschweiften Klammern)

  • Null

Objekte

JSON-Objekte werden in geschweifte Klammern geschrieben. Ein Objekt kann mehrere Name/Wert-Paare enthalten, die durch Kommas getrennt sind. Beispiel:

{"firstName":"John", "lastName":"Doe"}

Arrays

JSON-Arrays werden in eckige Klammern geschrieben. Ein Array kann mehrere Objekte enthalten, die durch Kommas getrennt sind. Beispiel:

{"employees":[
    {"firstName":"John", "lastName":"Doe"},
    {"firstName":"Anna", "lastName":"Smith"},
    {"firstName":"Peter", "lastName":"Jones"}
  ]
}

Beispiele für JSON-Dokumente

FILE NAME: json_sample_data1

Enthält ein Array mit 3 einfachen Mitarbeiterdatensätzen (Objekten):

{"root":[{"employees":[
    {"firstName":"John", "lastName":"Doe"},
    {"firstName":"Anna", "lastName":"Smith"},
    {"firstName":"Peter", "lastName":"Jones"}
]}]}

FILE NAME: json_sample_data2

Enthält ein Array mit 3 Mitarbeiterdatensätzen (Objekte) und den zugehörigen abhängigen Daten (Kinder, Namen und Alter der Kinder, Städte, in denen der Mitarbeiter gelebt hat, und die Jahre, in denen der Mitarbeiter in diesen Städten gelebt hat):

{"root":
   [
    { "kind": "person",
      "fullName": "John Doe",
      "age": 22,
      "gender": "Male",
      "phoneNumber":
        {"areaCode": "206",
         "number": "1234567"},
      "children":
         [
           {
             "name": "Jane",
             "gender": "Female",
             "age": "6"
           },
           {
              "name": "John",
              "gender": "Male",
              "age": "15"
           }
         ],
      "citiesLived":
         [
            {
               "place": "Seattle",
               "yearsLived": ["1995"]
            },
            {
               "place": "Stockholm",
               "yearsLived": ["2005"]
            }
         ]
      },
      {"kind": "person", "fullName": "Mike Jones", "age": 35, "gender": "Male", "phoneNumber": { "areaCode": "622", "number": "1567845"}, "children": [{ "name": "Earl", "gender": "Male", "age": "10"}, {"name": "Sam", "gender": "Male", "age": "6"}, { "name": "Kit", "gender": "Male", "age": "8"}], "citiesLived": [{"place": "Los Angeles", "yearsLived": ["1989", "1993", "1998", "2002"]}, {"place": "Washington DC", "yearsLived": ["1990", "1993", "1998", "2008"]}, {"place": "Portland", "yearsLived": ["1993", "1998", "2003", "2005"]}, {"place": "Austin", "yearsLived": ["1973", "1998", "2001", "2005"]}]},
      {"kind": "person", "fullName": "Anna Karenina", "age": 45, "gender": "Female", "phoneNumber": { "areaCode": "425", "number": "1984783"}, "citiesLived": [{"place": "Stockholm", "yearsLived": ["1992", "1998", "2000", "2010"]}, {"place": "Russia", "yearsLived": ["1998", "2001", "2005"]}, {"place": "Austin", "yearsLived": ["1995", "1999"]}]}
    ]
}

Was ist Avro?

Avro ist ein Open-Source-Datenserialisierungs- und RPC-Framework, das ursprünglich für die Verwendung mit Apache Hadoop entwickelt wurde. Es verwendet Schemas, die in JSON definiert sind, um serialisierte Daten in einem kompakten Binärformat zu erstellen. Die serialisierten Daten können an jedes beliebige Ziel (z. B. Anwendung oder Programm) gesendet und am Ziel einfach deserialisiert werden, da das Schema in den Daten enthalten ist.

Ein Avro-Schema besteht aus einer Zeichenfolge, einem Objekt oder einem Array im JSON-Format, das den Typ des Schemas und die Datenattribute (Feldnamen, Datentypen usw.) für den Schematyp definiert. Die Attribute unterscheiden sich je nach Schematyp. Es werden komplexe Datentypen wie Arrays und Zuordnungen unterstützt.

Snowflake liest Avro-Daten in eine einzige VARIANT-Spalte. Sie können die Daten in einer VARIANT-Spalte genauso wie JSON-Daten abfragen und dabei ähnliche Befehle und Funktionen verwenden.

Weitere Informationen dazu finden Sie unter avro.apache.org.

Beispiel für ein Avro-Schema

{
 "type": "record",
 "name": "person",
 "namespace": "example.avro",
 "fields": [
     {"name": "fullName", "type": "string"},
     {"name": "age",  "type": ["int", "null"]},
     {"name": "gender", "type": ["string", "null"]}
     ]
}

Was ist ORC?

Das Dateiformat ORC (Optimized Row Columnar), das zum Speichern von Hive-Daten verwendet wird, wurde für eine effiziente Komprimierung und eine verbesserte Leistung beim Lesen, Schreiben und Verarbeiten von Daten gegenüber früheren Hive-Dateiformaten entwickelt. Weitere Informationen zu ORC finden Sie unter https://orc.apache.org/.

Snowflake liest ORC-Daten in eine einzige VARIANT-Spalte. Sie können die Daten in einer VARIANT-Spalte genauso wie JSON-Daten abfragen und dabei ähnliche Befehle und Funktionen verwenden.

Alternativ können Sie ausgewählte Spalten einer bereitgestellten ORC-Datei mit einer CREATE TABLE AS SELECT-Anweisung in separate Tabellenspalten extrahieren.

ORC ist ein Binärformat.

Bemerkung

  • Die maximale Länge von binären Spalten und Zeichenfolgenspalten im ORC-Format unterliegt der Snowflake-Begrenzung von 16 MB für VARCHAR-Daten (komprimiert).

  • „Map“-Daten werden in ein Array von Objekten deserialisiert, z. B.:

    "map": [{"key": "chani", "value": {"int1": 5, "string1": "chani"}}, {"key": "mauddib", "value": {"int1": 1, "string1": "mauddib"}}]
    
  • „Union“-Daten werden in ein einzelnes Objekt deserialisiert, z. B.:

    {"time": "1970-05-05 12:34:56.197", "union": {"tag": 0, "value": 3880900}, "decimal": 3863316326626557453.000000000000000000}
    

Beispiel für ORC-Daten, die in eine VARIANT-Spalte geladen werden.

+--------------------------------------+
| SRC                                  |
|--------------------------------------|
| {                                    |
|   "boolean1": false,                 |
|   "byte1": 1,                        |
|   "bytes1": "0001020304",            |
|   "decimal1": 12345678.654745,       |
|   "double1": -1.500000000000000e+01, |
|   "float1": 1.000000000000000e+00,   |
|   "int1": 65536,                     |
|   "list": [                          |
|     {                                |
|       "int1": 3,                     |
|       "string1": "good"              |
|     },                               |
|     {                                |
|       "int1": 4,                     |
|       "string1": "bad"               |
|     }                                |
|   ]                                  |
| }                                    |
+--------------------------------------+

Was ist Parquet?

Parquet ist eine komprimierte, effiziente spaltenweise Datenrepräsentation, die für Projekte im Hadoop-Ökosystem entwickelt wurde. Das Dateiformat unterstützt komplexe verschachtelte Datenstrukturen und die Verwendung der Zerlegungs- und Rekonstruktionsalgorithmen von Dremel. Weitere Informationen dazu finden Sie unter parquet.apache.org/documentation/latest/.

Snowflake liest Parquet-Daten in eine einzige VARIANT-Spalte. Sie können die Daten in einer VARIANT-Spalte genauso wie JSON-Daten abfragen und dabei ähnliche Befehle und Funktionen verwenden.

Alternativ können Sie ausgewählte Spalten einer bereitgestellten Parquet-Datei mit einer CREATE TABLE AS SELECT-Anweisung in separate Tabellenspalten extrahieren.

Parquet ist ein Binärformat. Es ist nicht möglich, ein Beispiel für eine Parquet-Datei bereitzustellen.

Beispiel für Parquet-Daten, die in eine VARIANT-Spalte geladen werden.

+------------------------------------------+
| SRC                                      |
|------------------------------------------|
| {                                        |
|   "continent": "Europe",                 |
|   "country": {                           |
|     "city": {                            |
|       "bag": [                           |
|         {                                |
|           "array_element": "Paris"       |
|         },                               |
|         {                                |
|           "array_element": "Nice"        |
|         },                               |
|         {                                |
|           "array_element": "Marseilles"  |
|         },                               |
|         {                                |
|           "array_element": "Cannes"      |
|         }                                |
|       ]                                  |
|     },                                   |
|     "name": "France"                     |
|   }                                      |
| }                                        |
+------------------------------------------+

Was ist XML?

XML (Extensible Markup Language) ist eine Markup-Sprache, die eine Reihe von Regeln für die Codierung von Dokumenten definiert. Ursprünglich basierte es auf SGML, einer weiteren Markup-Sprache, die zur Standardisierung von Strukturen und Elementen entwickelt wurde, aus denen ein Dokument besteht.

Seit seiner Einführung ist XML über den anfänglichen Fokus auf Dokumente hinausgewachsen und umfasst ein breites Anwendungsspektrum, einschließlich der Darstellung beliebiger Datenstrukturen und als Basissprache für Kommunikationsprotokolle. Aufgrund ihrer Erweiterbarkeit, Vielseitigkeit und Benutzerfreundlichkeit hat sich XML zu einem der am häufigsten verwendeten Standards für den Datenaustausch im Internet entwickelt.

Ein XML-Dokument besteht im Wesentlichen aus den folgenden Konstrukten:

  • Tags (gekennzeichnet durch spitze Klammern, < und >)

  • Elemente

Elemente bestehen typischerweise aus einem Starttag und einem zugehörigen Endtag, wobei der Text zwischen den Tags den Inhalt des Elements bildet. Ein Element kann auch aus einem „Leeres Element“-Tag ohne Endetag bestehen. Starttag und „Leeres Element“-Tags können Attribute enthalten, die bei der Definition der Merkmale oder Metadaten für das Element helfen.

Beispiel für ein XML-Dokument

<?xml version="1.0"?>
<!DOCTYPE parts system "parts.dtd">
<?xml-stylesheet type="text/css" href="xmlpartsstyle.css"?>
<parts>
   <title>Automobile Parts &amp; Accessories</title>
   <part>
      <item>Spark Plugs</item>
      <partnum>A3-400</partnum>
      <price> 27.00</price>
   </part>
   <part>
      <item>Motor Oil</item>
      <partnum>B5-200</partnum>
      <price> 14.00</price>
   </part>
   <part>
      <item>Motor Oil</item>
      <partnum>B5-300</partnum>
      <price> 16.75</price>
   </part>
   <part>
      <item>Engine Coolant</item>
      <partnum>B6-120</partnum>
      <price> 19.00</price>
   </part>
   <part>
      <item>Engine Coolant</item>
      <partnum>B6-220</partnum>
      <price> 18.25</price>
   </part>
</parts>