Eingabe und Ausgabe von Binärdaten

Snowflake unterstützt drei Binärformate oder Codierungsschemata: hex, base64 und UTF-8.

Unter diesem Thema:

Übersicht der unterstützten Binärformate

hex (Standard)

Das „Hex“-Format bezieht sich auf das hexadezimale oder Base16-System. In diesem Format wird jedes Byte durch zwei Zeichen dargestellt (Ziffern von 0 bis 9 und Buchstaben von A bis F). Bei Verwendung von „Hex“ für die Konvertierung:

Von:

Bis:

Anmerkungen

Binär

Zeichenfolge

hex verwendet Großbuchstaben.

Zeichenfolge

Binär

Bei hex muss Groß-/Kleinschreibung nicht beachtet werden.

Hex ist das Standard-Binärformat.

Base64

Das „Base64“-Format codiert Binärdaten (oder Zeichenfolgendaten) als druckbare ASCII-Zeichen (Buchstaben, Ziffern und Satzzeichen oder mathematische Operatoren). (Das Base64-Codierungsschema ist in RFC 4648 definiert.)

Base64-codierte Daten haben folgende Vorteile:

  • Da Base64-codierte Daten reiner ASCII-Text sind, können sie in Systemen gespeichert werden, die ASCII-Zeichendaten unterstützen, jedoch keine BINARY-Daten. Beispielsweise können binäre Daten, die Musik darstellen (digitale Samples), oder UTF-Daten, die Zeichen aus Mandarin darstellen, als ASCII-Text codiert und in Systemen gespeichert werden, die nur ASCII-Zeichen unterstützen.

  • Da Base64-codierte Daten keine Steuerzeichen (z. B. Übertragungsendezeichen, Tabulatorzeichen) enthalten, können base64-codierte Daten gesendet und empfangen werden, ohne dass die Gefahr besteht, dass Steuerzeichen als Befehle und nicht als Daten interpretiert werden. Base64-codierte Daten sind mit älteren Modems und anderen Telekommunikationsgeräten kompatibel, die Daten jeweils einzeln übertragen und empfangen (ohne Paket-Header oder Protokolle, die angeben, welche Teile eines Pakets Daten sind und welche Header- oder Steuerinformationen sind).

Base64-codierte Daten haben folgende Nachteile:

  • Das Konvertieren von Daten zwischen binären und druckbaren ASCII-Darstellungen verbraucht Rechenressourcen.

  • Base64-codierte Daten benötigen ungefähr 1/3 mehr Speicherplatz als die ursprünglichen Daten.

Technische Details zur Codierung finden interessierte Leser unten:

Details zur base64-Codierung

Jede Gruppe von drei 8-Bit-Bytes (insgesamt 24 Bit) binärer Daten wird in vier Gruppen von jeweils 6 Bit (immer noch 24 Bit) angeordnet. Jede der 64 möglichen Kombinationen von 6 Bits wird durch eines der folgenden 64 druckbaren ASCII-Zeichen dargestellt:

  • Großbuchstaben (A–Z)

  • Kleinbuchstaben (a–z)

  • Dezimalstellen (0–9)

  • +

  • /

Außerdem wird das Zeichen = für das Auffüllen verwendet, wenn die Länge der Eingabe kein genaues Vielfaches von 3 ist.

Da Base64-codierte Daten keine Leerraumzeichen (Leerzeichen, Zeilenumbrüche usw.) enthalten, können Base64-codierte Daten bei Bedarf mit Leerzeichen gemischt werden. Wenn der Sender oder Empfänger beispielsweise eine maximale Zeilenlänge hat, können die Base64-codierten Daten durch Hinzufügen von Zeilenvorschubzeichen in einzelne Zeilen aufgeteilt werden, ohne die Daten zu beschädigen. Bei Verwendung von Base64 zur Durchführung der Konvertierung:

Von:

Bis:

Anmerkungen

Binär

Zeichenfolge

Base64 fügt keine Leerzeichen oder Zeilenumbrüche ein.

Zeichenfolge

Binär

base64 ignoriert alle Leerzeichen und Zeilenumbrüche.

UTF-8

Das Format UTF-8 bezieht sich auf die UTF-8-Zeichencodierung für Unicode. Im Gegensatz zu hex und base64, die Binär-zu-Text-Codierungen sind, ist UTF-8 eine Text-zu-Binär-Codierung. Das bedeutet, dass die Konvertierung von Zeichenfolge in Binärwert immer erfolgreich ist, aber die Konvertierung von Binärwert in Zeichenfolge fehlschlagen kann.

Dieses Format ist praktisch für die Eins-zu-Eins-Konvertierung zwischen Binärwerten und Zeichenfolgen, für die Neuinterpretation der zugrunde liegenden Daten als den einen oder anderen Typ und nicht für die eigentliche Codierung und Decodierung.

Sitzungsparameter für Binärwerte

Es gibt zwei Sitzungsparameter, die bestimmen, wie Binärwerte in und aus Snowflake übergeben werden:

  • BINARY_INPUT_FORMAT:

    Wird verwendet für:

    • Konvertierung in Binärwerte in der Ein-Argument-Version von TO_CHAR , TO_VARCHAR.

    • Laden von Daten in Snowflake (wenn keine Dateiformatoption angegeben ist; siehe unten für Details).

    Der Parameter kann auf HEX, BASE64 oder UTF-8 eingestellt werden (UTF8 ist auch erlaubt). Bei den Parameterwerten muss Groß- und Kleinschreibung nicht beachtet werden. Der Standardwert ist HEX.

  • BINARY_OUTPUT_FORMAT:

    Wird verwendet für:

    • Anzeige von binären Resultsets.

    • Durchführung der Konvertierung in Zeichenfolge in der Ein-Argument-Version von TO_BINARY.

    • Entladen von Daten aus Snowflake (wenn keine Dateiformatoption angegeben ist; siehe unten für Details).

    Der Parameter kann auf HEX oder BASE64 eingestellt werden. Bei den Parameterwerten muss Groß- und Kleinschreibung nicht beachtet werden. Der Standardwert ist HEX.

    Bemerkung

    Da die Konvertierung von Binärwert in Zeichenfolge mit dem UTF-8-Format fehlschlagen kann, kann BINARY_OUTPUT_FORMAT nicht auf UTF-8 gesetzt werden. Um in dieser Situation UTF-8 für die Konvertierung zu verwenden, verwenden Sie die Zwei-Argumente-Version von TO_CHAR , TO_VARCHAR.

Die Parameter können auf Konto-, Benutzer- und Sitzungsebene eingestellt werden. Führen Sie den Befehl SHOW PARAMETERS aus, um die aktuellen Parametereinstellungen anzuzeigen, die für alle Operationen in der aktuellen Sitzung gelten.

Dateiformatoption zum Laden/Entladen von Binärwerten

Unabhängig von den binären Ein- und Ausgabeparametern der Sitzung bietet Snowflake die Dateiformatoption BINARY_FORMAT, mit der die binäre Formatierung beim Laden von Daten in oder Entladen von Daten aus Snowflake-Tabellen explizit gesteuert werden kann.

Diese Option kann auf HEX, BASE64 oder UTF-8 eingestellt werden (bei den Werten muss Groß- und Kleinschreibung nicht beachtet werden). Die Option wirkt sich sowohl auf das Laden als auch auf das Entladen von Daten aus und kann, ähnlich wie andere Dateiformatoptionen, auf verschiedene Arten angegeben werden:

  • In einem benannten Dateiformat, das dann in einem benannten Stagingbereich oder direkt in einem COPY-Befehl referenziert werden kann.

  • In einem benannten Stagingbereich, der dann direkt in einem COPY-Befehl referenziert werden kann.

  • Direkt in einem COPY-Befehl.

Laden von Daten

Bei Verwendung für das Laden von Daten gibt BINARY_FORMAT das Format der Binärwerte in Ihren Staging-Datendateien an. Diese Option überschreibt jeden Wert, der für den BINARY_INPUT_FORMAT-Parameter in der Sitzung festgelegt wurde (siehe Sitzungsparameter für Binärwerte oben).

Wenn die Option auf HEX oder BASE64 festgelegt ist und die Zeichenfolgen in der Staging-Datendatei keine gültigen Hex- oder Base64-Werte sind, kann das Laden von Daten fehlschlagen. In diesem Fall gibt Snowflake einen Fehler zurück und führt dann die für die Kopieroption ON_ERROR angegebene Aktion aus.

Entladen von Daten

Bei Verwendung zum Entladen von Daten gibt die Option BINARY_FORMAT das Format an, das auf Binärwerte angewendet wird, die in die Dateien des angegebenen Stagingbereichs entladen werden. Diese Option überschreibt jeden Wert, der für den BINARY_OUTPUT_FORMAT-Parameter in der Sitzung festgelegt wurde (siehe Sitzungsparameter für Binärwerte oben).

Wenn die Option auf UTF-8 gesetzt ist, kann das Entladen von Daten fehlschlagen, wenn Binärwerte in der Tabelle ungültige UTF-8 enthalten. In diesem Fall gibt Snowflake einen Fehler zurück.

Beispiel für Ein-/Ausgaben

BINARY-Eingabe/Ausgabe kann verwirrend sein, weil „was Sie sehen, nicht unbedingt das ist, was Sie erhalten“.

Betrachten Sie zum Beispiel die folgende Codesequenz:

CREATE TABLE binary_table (v VARCHAR, b BINARY);
INSERT INTO binary_table (v, b)
    SELECT 'AB', TO_BINARY('AB');
SELECT v, b FROM binary_table;
+----+----+
| V  | B  |
|----+----|
| AB | AB |
+----+----+

Die Ausgaben für Spalte v (VARCHAR) und Spalte b scheinen identisch zu sein. Der Wert für Spalte b wurde jedoch in binär konvertiert. Warum sieht der Wert in Spalte b unverändert aus?

Die Antwort ist, dass das Argument für TO_BINARY als eine Folge von Hexadezimalziffern behandelt wird (obwohl es in Anführungszeichen steht und daher wie eine Zeichenfolge aussieht). Die zwei angezeigten Zeichen werden tatsächlich als ein Paar hexadezimaler Ziffern interpretiert, die 1 Byte Binärdaten und nicht 2 Byte Zeichenfolgendaten darstellen. (Dies hätte nicht funktioniert, wenn die Eingabe-„Zeichenfolge“ andere Zeichen als Hexadezimalzahlen enthalten hätte, denn dann wäre eine Fehlermeldung der Form „Zeichenfolge ‚…‘ ist keine zulässige hexadezimal-codierte Zeichenfolge“ ausgegeben worden.)

Bei der Anzeige von BINARY-Daten werden diese standardmäßig als Folge von Hexadezimalziffern angezeigt. Daher wurden die Daten als Hexadezimalziffern (keine Zeichenfolge) eingegeben und als Hexadezimalziffern angezeigt, sodass sie ohne Änderung angezeigt werden.

Wenn das Ziel darin bestand, die aus zwei Zeichen bestehende Zeichenfolge „AB“ zu speichern, war der Code falsch. Der richtige Code würde die Funktion HEX_ENCODE verwenden, um die Zeichenfolge vor dem Speichern der Daten in eine Folge von Hexadezimalziffern zu konvertieren (oder eine andere Codierungsfunktion verwenden, um sie in ein anderes Format, wie z. B. Base64, zu konvertieren). Beispiele dafür finden Sie unten.

Beispiel für ein Hexadezimal-Format („HEX“)

Der einfachste Weg, BINARY-Daten einzugeben, besteht oft darin, sie als eine Zeichenfolge von hexadezimalen Zeichen zu codieren. Ein Beispiel ist unten aufgeführt.

Beginnen Sie, indem Sie eine Tabelle mit einer BINARY-Spalte erstellen:

CREATE TABLE demo_binary (b BINARY);

Wenn Sie versuchen, mit der Funktion TO_BINARY() eine „normale“ Zeichenfolge einzufügen, um sie in einen gültigen BINARY-Wert zu konvertieren, schlägt der Versuch fehl:

INSERT INTO demo_binary (b) SELECT TO_BINARY('HELP', 'HEX');

So lautet die Fehlermeldung:

100115 (22000): The following string is not a legal hex-encoded value: 'HELP'

Diesmal konvertieren Sie die Eingabe explizit in eine Zeichenfolge von hexadezimalen Ziffern, bevor Sie sie einfügen (das wird gelingen):

INSERT INTO demo_binary (b) SELECT TO_BINARY(HEX_ENCODE('HELP'), 'HEX');

Rufen Sie nun die Daten ab:

SELECT TO_VARCHAR(b), HEX_DECODE_STRING(TO_VARCHAR(b)) FROM demo_binary;
+---------------+----------------------------------+
| TO_VARCHAR(B) | HEX_DECODE_STRING(TO_VARCHAR(B)) |
|---------------+----------------------------------|
| 48454C50      | HELP                             |
+---------------+----------------------------------+

Wie Sie sehen, wird die Ausgabe standardmäßig im Hexadezimalformat dargestellt. Um die ursprüngliche Zeichenfolge wiederherzustellen, verwenden Sie die Funktion HEX_DECODE_STRING (das Komplement der Funktion HEX_ENCODE_STRING, die zuvor zum Codieren der Zeichenfolge verwendete wurde).

Die folgenden Hinweise zeigen genauer, was intern geschieht:

SELECT 'HELP', HEX_ENCODE('HELP'), b, HEX_DECODE_STRING(HEX_ENCODE('HELP')),
   TO_VARCHAR(b), HEX_DECODE_STRING(TO_VARCHAR(b)) FROM demo_binary;

Ausgabe:

SELECT 'HELP', HEX_ENCODE('HELP'), b, HEX_DECODE_STRING(HEX_ENCODE('HELP')),
   TO_VARCHAR(b), HEX_DECODE_STRING(TO_VARCHAR(b)) FROM demo_binary;
+--------+--------------------+----------+---------------------------------------+---------------+----------------------------------+
| 'HELP' | HEX_ENCODE('HELP') | B        | HEX_DECODE_STRING(HEX_ENCODE('HELP')) | TO_VARCHAR(B) | HEX_DECODE_STRING(TO_VARCHAR(B)) |
|--------+--------------------+----------+---------------------------------------+---------------+----------------------------------|
| HELP   | 48454C50           | 48454C50 | HELP                                  | 48454C50      | HELP                             |
+--------+--------------------+----------+---------------------------------------+---------------+----------------------------------+

BASE64-Formatbeispiel

Bevor Sie diesen Abschnitt lesen, sollten Sie möglicherweise erst den Abschnitt zum Hexadezimalformat oben lesen. Die grundlegenden Konzepte sind ähnlich und werden im Abschnitt „Hexadezimalformat“ näher erläutert.

Beginnen Sie, indem Sie eine Tabelle mit einer BINARY-Spalte erstellen:

CREATE TABLE demo_binary (b BINARY);

Einfügen einer Zeile:

INSERT INTO demo_binary (b) SELECT TO_BINARY(BASE64_ENCODE('HELP'), 'BASE64');

Abrufen dieser Zeile:

SELECT 'HELP', BASE64_ENCODE('HELP'),
   BASE64_DECODE_STRING(BASE64_ENCODE('HELP')),
   TO_VARCHAR(b, 'BASE64'), 
   BASE64_DECODE_STRING(TO_VARCHAR(b, 'BASE64'))
   FROM demo_binary;
+--------+-----------------------+---------------------------------------------+-------------------------+-----------------------------------------------+
| 'HELP' | BASE64_ENCODE('HELP') | BASE64_DECODE_STRING(BASE64_ENCODE('HELP')) | TO_VARCHAR(B, 'BASE64') | BASE64_DECODE_STRING(TO_VARCHAR(B, 'BASE64')) |
|--------+-----------------------+---------------------------------------------+-------------------------+-----------------------------------------------|
| HELP   | SEVMUA==              | HELP                                        | SEVMUA==                | HELP                                          |
+--------+-----------------------+---------------------------------------------+-------------------------+-----------------------------------------------+

Beispiel für UTF-8-Format

Beginnen Sie, indem Sie eine Tabelle mit einer BINARY-Spalte erstellen:

CREATE TABLE demo_binary (b BINARY);

Einfügen einer Zeile:

INSERT INTO demo_binary (b) SELECT TO_BINARY('HELP', 'UTF-8');

Abrufen dieser Zeile:

SELECT 'HELP', TO_VARCHAR(b, 'UTF-8')
   FROM demo_binary;
+--------+------------------------+
| 'HELP' | TO_VARCHAR(B, 'UTF-8') |
|--------+------------------------|
| HELP   | HELP                   |
+--------+------------------------+