Zeichenfolgen- und Binärdatentypen

Unter diesem Thema werden die von Snowflake unterstützten Datentypen für Zeichenfolge/Text (einschließlich binärer Zeichenfolgen) sowie die unterstützten Formate für Zeichenfolgenkonstanten/-literale beschrieben.

Unter diesem Thema:

Datentypen für Textzeichenfolgen

Snowflake unterstützt die folgenden Datentypen für Textzeichenfolgen (d. h. Zeichenfolgen).

VARCHAR

VARCHAR enthält Unicode/UTF-8-Zeichen.

Bemerkung

In einigen Systemen außerhalb von Snowflake werden Werte der Datentypen CHAR und VARCHAR als ASCII-Zeichen gespeichert, während Werte der Datentypen NCHAR und NVARCHAR als Unicode-Zeichen gespeichert werden.

In Snowflake werden Werte vom Datentyp VARCHAR und aller anderen Zeichenfolgen-Datentypen als Unicode/UTF-8-Zeichen gespeichert. In Bezug auf die Unicode-Verarbeitung gibt es keinen Unterschied zwischen den Datentypen CHAR und NCHAR. Synonyme wie NCHAR dienen in erster Linie der Syntaxkompatibilität bei der Portierung von DDL-Befehlen zu Snowflake.

Wenn Sie eine Spalte des Typs VARCHAR deklarieren, können Sie einen optionalen Parameter (N) angeben, der die maximale Anzahl der zu speichernden Zeichen darstellt. Beispiel:

create table t1 (v varchar(16777216));

Wenn keine Länge angegeben wird, ist der Standard die maximal zulässige Länge (16.777.216).

Obwohl die maximale Länge eines VARCHAR-Werts in Zeichen angegeben ist, ist auch ein VARCHAR-Wert auf eine maximale Anzahl von Bytes (16.777.216 = 16 MB) begrenzt. Die maximale Anzahl von Unicode-Zeichen, die in einer VARCHAR-Spalte gespeichert werden können, ist unten dargestellt:

Einzelbyte

16.777.216

Multibyte

Zwischen 8.388.608 (2 Bytes pro Zeichen) und 4.194.304 (4 Bytes pro Zeichen)

Wenn Sie beispielsweise eine Spalte als VARCHAR (16.777.216) deklarieren, kann die Spalte maximal 8.388.608 2-Byte-Unicode-Zeichen enthalten, obwohl Sie eine maximale Länge von 16.777.216 angegeben haben.

Bei der Wahl der maximalen Länge für eine VARCHAR-Spalte ist Folgendes zu beachten:

  • Speicher: Eine Spalte verbraucht nur Speicherplatz für die Menge der tatsächlich gespeicherten Daten. Beispielsweise verbraucht eine 1-stellige Zeichenfolge in einer VARCHAR-Spalte (16.777.216) nur ein einziges Zeichen.

  • Performance: Es gibt keinen Leistungsunterschied zwischen der Verwendung der vollständigen VARCHAR-Deklaration VARCHAR(16.777.216) und einer geringeren Länge.

    Beachten Sie, dass in jeder relationalen Datenbank SELECT-Anweisungen, in denen eine WHERE-Klausel auf VARCHAR-Spalten oder Zeichenfolgenspalten verweist, nicht so schnell sind wie SELECT-Anweisungen, die mit einer Datums- oder numerischen Spaltenbedingung gefiltert werden.

  • Tools zur Verwendung der Daten: Einige BI/ETL-Tools definieren die maximale Größe der VARCHAR-Daten im Speicher oder im Arbeitsspeicher. Wenn Sie die maximale Größe einer Spalte kennen, können Sie die Größe beim Hinzufügen der Spalte begrenzen.

  • Sortierung: Wenn Sie eine Sortierung für eine VARCHAR-Spalte angeben, variiert die Anzahl der zulässigen Zeichen je nach der von jedem Zeichen benötigten Anzahl von Bytes und der Sortierungsspezifikation der Spalte.

    Beim Vergleichen von Werten in einer sortierten Spalte folgt Snowflake dem Unicode Collation Algorithm (UCA). Dieser Algorithmus beeinflusst die maximal zulässige Anzahl von Zeichen. Derzeit sind etwa 1,5 Millionen bis 8 Millionen Zeichen in einer VARCHAR-Spalte zulässig, für die eine maximale Größe und eine Sortierungsspezifikation definiert ist.

    Beispiel: Die folgende Tabelle zeigt, wie die maximale Anzahl von Zeichen für eine VARCHAR(16777216)-Spalte in Abhängigkeit von der Anzahl der Bytes pro Zeichen und der verwendeten Sortierungsspezifikation variieren kann:

    Anzahl der Bytes pro Zeichen

    Sortierungsspezifikation

    Maximal zulässige Anzahl von Zeichen (ungefähr)

    1 Byte

    en-ci oder en-ci-pi-ai

    Rund 7 Millionen Zeichen

    1 Byte

    en

    Rund 4 Millionen Zeichen

    2 Bytes

    en-ci-pi-ai

    Rund 8 Millionen Zeichen

    2 Bytes

    en-ci oder en-ci-pi

    Rund 2,7 Millionen Zeichen

    2 Bytes

    en

    Rund 1,5 Millionen Zeichen

CHAR , CHARACTER , NCHAR

Synonym für VARCHAR, allerdings ist CHAR(1) der Standard, wenn keine Länge angegeben wird.

Bemerkung

Snowflake weicht derzeit von der üblichen CHAR-Semantik dadurch ab, dass Zeichenfolgen, die kürzer als die maximale Länge sind, am Ende nicht mit Leerzeichen aufgefüllt werden.

STRING , TEXT , NVARCHAR , NVARCHAR2 , CHAR VARYING , NCHAR VARYING

Synonym für VARCHAR.

Zeichenfolgenbeispiele in Tabellenspalten

CREATE OR REPLACE TABLE test_text(v VARCHAR,
                                  v50 VARCHAR(50),
                                  c CHAR,
                                  c10 CHAR(10),
                                  s STRING,
                                  s20 STRING(20),
                                  t TEXT,
                                  t30 TEXT(30)
                                  );

DESC TABLE test_text;

+------+-------------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name | type              | kind   | null? | default | primary key | unique key | check | expression | comment |
|------+-------------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| V    | VARCHAR(16777216) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| V50  | VARCHAR(50)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| C    | VARCHAR(1)        | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| C10  | VARCHAR(10)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| S    | VARCHAR(16777216) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| S20  | VARCHAR(20)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| T    | VARCHAR(16777216) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| T30  | VARCHAR(30)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+------+-------------------+--------+-------+---------+-------------+------------+-------+------------+---------+

Datentypen für binäre Zeichenfolgen

Snowflake unterstützt die folgenden Datentypen für binäre Zeichenfolgen.

BINARY

Die maximale Länge beträgt 8 MB (8.388.608 Bytes). Im Gegensatz zu VARCHAR kennt der Datentyp BINARY keine Unicode-Zeichen, sodass die Länge stets in Bytes gemessen wird.

(BINARY-Werte sind auf 8 MB begrenzt, damit sie in 16 MB passen, wenn sie in hexadezimale Zeichenfolgen umgewandelt werden, z. B. über TO_CHAR(<Binary-Ausdruck>, 'HEX')).

Wenn keine Länge angegeben wird, ist der Standard die maximale Länge.

VARBINARY

VARBINARY ist gleichbedeutend mit BINARY.

Interne Repräsentation

Der Datentyp BINARY enthält eine Folge von 8-Bit-Bytes.

Bei der Anzeige BINARY-Datenwerten stellt Snowflake oft jedes Byte als 2 Hexadezimalzeichen dar. So kann beispielsweise das Wort „HELP“ als 48454C50 angezeigt werden, wobei „48“ das hexadezimale Äquivalent des ASCII (Unicode)-Buchstaben „H“ ist, „45“ die hexadezimale Darstellung des Buchstabens „E“ usw.

Weitere Informationen zum Eingeben und Anzeigen von BINARY-Daten finden Sie unter Eingabe und Ausgabe von Binärdaten.

Beispiele für Binärwerte in Tabellenspalten

CREATE OR REPLACE TABLE test_binary(b BINARY,
                                    b100 BINARY(100),
                                    vb VARBINARY
                                    );

DESC TABLE test_binary;

+------+-----------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name | type            | kind   | null? | default | primary key | unique key | check | expression | comment |
|------+-----------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| B    | BINARY(8388608) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| B100 | BINARY(100)     | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| VB   | BINARY(8388608) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+------+-----------------+--------+-------+---------+-------------+------------+-------+------------+---------+

Zeichenfolgenkonstanten

Konstanten (auch als Literale bekannt) beziehen sich auf feste Datenwerte. Zeichenfolgenkonstanten in Snowflake müssen immer in Trennzeichen eingeschlossen werden. Snowflake unterstützt die Verwendung einer der folgenden Möglichkeiten zur Abgrenzung von Zeichenfolgenkonstanten:

Zeichenfolgenkonstanten in einfachen Anführungszeichen

Eine Zeichenfolgenkonstante kann in einfache Anführungszeichen eingeschlossen werden (z. B. 'This is a string'). Um in einer Zeichenfolgenkonstante ein einzelnes Anführungszeichen einzufügen, geben Sie nebeneinander zwei einfache Anführungszeichen ein (z. B. '').

Beispiel:

SELECT 'Today''s sales projections', '-''''-';

+------------------------------+----------+
| 'TODAY''S SALES PROJECTIONS' | '-''''-' |
|------------------------------+----------|
| Today's sales projections    | -''-     |
+------------------------------+----------+

Bemerkung

Zwei einfache Anführungszeichen sind nicht das Gleiche wie ein doppeltes Anführungszeichen ("), das (ggf.) zur Trennung von Objektbezeichnern verwendet wird. Weitere Informationen dazu finden Sie unter Anforderungen an Bezeichner.

Escapesequenzen bei Zeichenfolgenkonstanten in einfachen Anführungszeichen

Um ein einfaches Anführungszeichen oder andere Sonderzeichen (z. B. Zeilenumbrüche) in eine in einfachen Anführungszeichen stehende Zeichenfolgenkonstante einzuschließen, müssen Sie diese Zeichen mit Backslash-Escapesequenzen versehen. Eine Backslash-Escapesequenz ist eine Folge von Zeichen, die mit einem Backslash (\) beginnt.

Bemerkung

Wenn die Zeichenfolge viele einfache Anführungszeichen, Backslashes oder andere Sonderzeichen enthält, können Sie auch eine Zeichenfolgenkonstante in Dollarzeichen verwenden, um für das Zeichen kein Escapezeichen verwenden zu müssen.

Sie können auch Escapesequenzen verwenden, um ASCII-Zeichen einzufügen, indem Sie deren Codepunkte (die numerischen Werte, die diesen Zeichen entsprechen) in oktaler oder hexadezimaler Form angeben. In ASCII zum Beispiel ist der Codepunkt für das Leerzeichen 32, was hexadezimal 20 entspricht. Um ein Leerzeichen anzugeben, können Sie die hexadezimale Escapesequenz \x20 verwenden.

Sie können zum Einfügen von Unicode-Zeichen auch Escapesequenzen verwenden, zum Beispiel \u26c4.

In der folgenden Tabelle sind die unterstützten Escapesequenzen in den vier Kategorien einfach, oktal, hexadezimal und Unicode aufgeführt:

Escape-Sequenz

Dargestelltes Zeichen

Einfache Escapesequenzen

\'

Ein einfaches Anführungszeichen (')

\"

Ein doppeltes Anführungszeichen (")

\\

Ein Backslash-Zeichen (\)

\b

Ein Rücktastenzeichen

\f

Ein Formfeed-Zeichen

\n

Ein Neue-Zeile-Zeichen (Linefeed)

\r

Ein Zeilenumbruchzeichen

\t

Ein Tabulatorzeichen

\0

Ein ASCII-NUL-Zeichen

Oktale Escapesequenzen

\ooo

ASCII-Zeichen in oktaler Notation (d. h. jedes o steht für eine Oktalziffer)

Hexadezimale Escapesequenzen

\xhh

ASCII-Zeichen in hexadezimaler Schreibweise (d. h. jedes h steht für eine hexadezimale Ziffer)

Unicode-Escapesequenzen

\uhhhh

Unicode-Zeichen in hexadezimaler Schreibweise (d. h. jedes h steht für eine hexadezimale Ziffer). Die Anzahl der Hexadezimalziffern muss genau 4 sein.

Wenn eine Zeichenfolgenkonstante ein Backslash-Zeichen enthalten muss (z. B. C:\ in einem Windows-Pfad oder \d in einem regulären Ausdruck), müssen Sie den Backslash mit einem zweiten Backslash als Escapezeichen versehen, wie in der obigen Tabelle gezeigt. Um zum Beispiel \d in einem regulären Ausdruck in eine Zeichenfolgenkonstante einzuschließen, müssen Sie \\d verwenden.

Wird ein Backslash in anderen als den oben aufgeführten Sequenzen verwendet, wird er ignoriert. So wird beispielsweise die Zeichensequenz '\z' als 'z' interpretiert.

Das folgende Beispiel zeigt, wie Backslash-Escapesequenzen zu verwenden sind. Die Beispiele zeigen auch, wie Sie Folgendes spezifizieren:

  • ein Tabulatorzeichen

  • ein Neue-Zeile-Zeichen

  • einen Backslash

  • die oktalen und hexadezimalen Escapesequenzen für ein Ausrufezeichen (Codepunkt 33, das ist \041 in oktal und \x21 in hexadezimal)

  • die Unicode-Escapesequenz für ein kleines Bild eines Schneemanns

  • etwas, das keine gültige Escapesequenz ist

    SELECT $1, $2 FROM
    VALUES
    ('Tab','Hello\tWorld'),
    ('Newline','Hello\nWorld'),
    ('Backslash','C:\\user'),
    ('Octal','-\041-'),
    ('Hexadecimal','-\x21-'),
    ('Unicode','-\u26c4-'),
    ('Not an escape sequence', '\z')
    ;
    
    +------------------------+---------------+
    | $1                     | $2            |
    |------------------------+---------------|
    | Tab                    | Hello   World |
    | Newline                | Hello         |
    |                        | World         |
    | Backslash              | C:\user       |
    | Octal                  | -!-           |
    | Hexadecimal            | -!-           |
    | Unicode                | -⛄-          |
    | Not an escape sequence | z             |
    +------------------------+---------------+
    

Zeichenfolgenkonstanten in Dollarzeichen

In einigen Fällen müssen Sie eine Zeichenfolgenkonstante angeben, die Folgendes enthält:

In diesen Fällen können Sie das Abschneiden dieser Zeichen vermeiden, indem Sie ein Paar Dollarzeichen ($$) anstelle eines einzelnen Anführungszeichens (') verwenden, um Anfang und Ende der Zeichenfolge abzugrenzen.

In einer mit Dollarzeichen versehenen Zeichenfolgenkonstante können Sie Anführungszeichen, umgekehrte Schrägstriche, Zeilenumbrüche und alle anderen Sonderzeichen (mit Ausnahme von doppelten Dollar-Zeichen) einfügen, ohne diese Zeichen mit Escapezeichen versehen zu müssen. Der Inhalt einer in Dollarzeichen eingeschlossenen Zeichenfolgenkonstante wird immer literal interpretiert.

Die folgenden Beispiele zeigen gleichwertige Möglichkeiten zur Angabe von Zeichenfolgenkonstanten:

Beispiel für die Verwendung von einfachen Anführungszeichen als Trennzeichen

Beispiel mit doppelten Dollarzeichen als Trennzeichen

'string with a \' character'
$$string with a ' character$$
'regular expression with \\ characters: \\d{2}-\\d{3}-\\d{4}'
$$regular expression with \ characters: \d{2}-\d{3}-\d{4}$$
'string with a newline\\ncharacter'
$$string with a newline
character$$

Im folgenden Beispiel wird eine in Dollarzeichen eingeschlossene Zeichenfolgenkonstante verwendet, die Zeilenumbrüche und mehrere Escapesequenzen enthält.

SELECT $1, $2 FROM VALUES ('row1', $$a
                                      ' \ \t
                                      \x21 z $ $$);

+------+-------------------------------------------------------+
| $1   | $2                                                    |
|------+-------------------------------------------------------|
| row1 | a                                                     |
|      |                                           ' \ \t      |
|      |                                           \x21 z $    |
+------+-------------------------------------------------------+

Beachten Sie, dass in diesem Beispiel die Escapesequenzen nicht als Escapesequenzen, sondern als einzelne Zeichen interpretiert werden (z. B. ein Backslash gefolgt von einem „t“).

Zurück zum Anfang