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 |
String |
hex verwendet Großbuchstaben. |
String |
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 |
String |
Base64 fügt keine Leerzeichen oder Zeilenumbrüche ein. |
String |
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.
UTF-8 wird zur Text-zu-Binär-Codierung verwendet. UTF-8 kann nicht zur Binär-zu-Text-Codierung verwendet werden, da nicht alle möglichen BINARY-Werte in gültige UTF-8-Zeichenfolgen umgewandelt werden können.
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:
Gibt das Format der VARCHAR-Eingabe für Funktionen an, die von VARCHAR in BINARY konvertiert werden. Dies wird für Folgendes verwendet:
Konvertierung in BINARY-Werte in der Ein-Argument-Version von TO_BINARY.
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:
Gibt das Format der VARCHAR-Ausgabe von Funktionen an, die von BINARY in VARCHAR konvertiert werden. Dies wird für Folgendes verwendet:
Konvertierung in VARCHAR-Werte in der Ein-Argument-Version von TO_CHAR , TO_VARCHAR.
Entladen von Daten aus Snowflake (wenn keine Dateiformatoption angegeben ist; siehe unten für Details).
Anzeige von Binärdaten in einem besser lesbaren Format (z. B. auf der Snowflake-Weboberfläche), wenn keine explizite Konvertierung von BINARY-Daten in VARCHAR-Daten aufgerufen wurde.
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 | +--------+------------------------+