Kategorien:: Zeichenfolgen- und Binärfunktionen (Allgemein)

SPLIT_PART¶

Trennt eine gegebene Zeichenfolge auf und gibt den angeforderten Teil zurück.

Um alle Zeichen nach einem bestimmten Zeichen zurückzugeben, können Sie die Funktionen POSITION und SUBSTR verwenden. Ein Beispiel dazu finden Sie unter Rückgabe von Teilzeichenfolgen für E-Mail, Telefon und Datum.

Tipp

Sie können den Suchoptimierungsdienst verwenden, um die Leistung von Abfragen zu verbessern, die diese Funktion aufrufen. Weitere Details dazu finden Sie unter Suchoptimierungsdienst.

Siehe auch::: SPLIT, STRTOK

Syntax¶

SPLIT_PART(<string>, <delimiter>, <partNumber>)

Copy

Argumente¶

string

In Teile aufzuteilender Text.

delimiter

Text, der das Trennzeichen darstellt, das zum Auftrennen verwendet werden soll. Die gesamte Trennzeichenfolge wird als ein einziges Trennzeichen behandelt, auch wenn sie mehrere Zeichen enthält. Dieses Verhalten unterscheidet sich von:doc:strtok, wodurch jedes Zeichen im Trennzeichen als separates Trennzeichen behandelt wird.

partNumber

Angeforderter Teil der Aufteilung, der 1-basiert ist, sodass das erste Token Token Nummer 1 ist, nicht Token Nummer 0.

Wenn der Wert negativ ist, werden die Teile von vom Ende der Zeichenfolge rückwärts gezählt.

Rückgabewerte¶

Gibt einen Wert vom Typ VARCHAR zurück.

Wenn eines der Argumente NULL ist, gibt die Funktion NULL zurück.

Nutzungshinweise¶

Wenn die partNumber außerhalb des Bereichs liegt, ist der zurückgegebene Wert eine leere Zeichenfolge.
Wenn die Zeichenfolge mit dem Trennzeichen beginnt oder endet, betrachtet das System Leerzeichen vor bzw. nach dem Trennzeichen als gültigen Teil des geteilten Ergebnisses. Ein Beispiel dazu finden Sie unter ` Beispiele`_ weiter unten. Das bedeutet, dass SPLIT_PART im Gegensatz zu STRTOK, das niemals leere Zeichenfolgen zurückgibt, leeren Zeichenfolgen als Teile zurückgeben kann.
Wenn die partNumber 0 ist, wird sie als 1 behandelt. Mit anderen Worten, es erhält das erste Element der Aufteilung. Um Verwirrung darüber zu vermeiden, ob Indizes auf 1- oder 0-basiert sind, empfiehlt Snowflake, die Verwendung von 0 als Synonym für 1 zu vermeiden.
Wenn das Trennzeichen eine leere Zeichenfolge ist, ist der zurückgegebene Wert nach der Teilung die Eingabezeichenfolge (die Zeichenfolge wird nicht geteilt).

Sortierungsdetails¶

The collation specifications of all input arguments must be compatible.

Diese Funktion bietet keine Unterstützung für folgende Sortierungsspezifikationen:

pi (ohne Beachtung der Interpunktion)
cs-ai (Beachtung von Groß-/Kleinschreibung, keine Beachtung von Akzenten)

Beispiele¶

Die folgenden Beispiele rufen die Funktion SPLIT_PART auf.

Anzeigen der Teile, die für verschiedene Teilenummerwerte zurückgegeben werden¶

Das folgende Beispiel zeigt die Teile, die von verschiedenen Werten für partNumber zurückgegeben werden.

SELECT column1 part_number_value, column2 portion
  FROM VALUES
    (0, SPLIT_PART('11.22.33', '.',  0)),
    (1, SPLIT_PART('11.22.33', '.',  1)),
    (2, SPLIT_PART('11.22.33', '.',  2)),
    (3, SPLIT_PART('11.22.33', '.',  3)),
    (4, SPLIT_PART('11.22.33', '.',  4)),
    (-1, SPLIT_PART('11.22.33', '.',  -1)),
    (-2, SPLIT_PART('11.22.33', '.',  -2)),
    (-3, SPLIT_PART('11.22.33', '.',  -3)),
    (-4, SPLIT_PART('11.22.33', '.',  -4));

Copy

+-------------------+---------+
| PART_NUMBER_VALUE | PORTION |
|-------------------+---------|
|                 0 | 11      |
|                 1 | 11      |
|                 2 | 22      |
|                 3 | 33      |
|                 4 |         |
|                -1 | 33      |
|                -2 | 22      |
|                -3 | 11      |
|                -4 |         |
+-------------------+---------+

Zurückgeben des ersten und letzten Teils einer IP-Adresse¶

Das folgende Beispiel gibt den ersten und letzten Teil der localhost-IP-Adresse 127.0.0.1 zurück:

SELECT SPLIT_PART('127.0.0.1', '.', 1) AS first_part,
       SPLIT_PART('127.0.0.1', '.', -1) AS last_part;

Copy

+------------+-----------+
| FIRST_PART | LAST_PART |
|------------+-----------|
| 127        | 1         |
+------------+-----------+

Anzeigen des Trennzeichens als erstes Zeichen¶

Das folgende Beispiel gibt den ersten und zweiten Teil einer Zeichenfolge zurück, die durch senkrechte Striche getrennt sind. Das Trennzeichen ist der erste Teil der Eingabezeichenfolge, sodass das erste Element nach dem Teilen eine leere Zeichenfolge ist.

SELECT SPLIT_PART('|a|b|c|', '|', 1) AS first_part,
       SPLIT_PART('|a|b|c|', '|', 2) AS last_part;

Copy

+------------+-----------+
| FIRST_PART | LAST_PART |
|------------+-----------|
|            | a         |
+------------+-----------+

Anzeigen eines Trennzeichens mit mehreren Zeichen¶

Das folgende Beispiel zeigt ein Trennzeichen mit mehreren Zeichen:

SELECT SPLIT_PART('aaa--bbb-BBB--ccc', '--', 2) AS multi_character_delimiter;

Copy

+---------------------------+
| MULTI_CHARACTER_DELIMITER |
|---------------------------|
| bbb-BBB                   |
+---------------------------+

Anzeigen des Trennzeichens als leere Zeichenfolge¶

Das folgende Beispiel zeigt, dass bei einer leeren Zeichenfolge als Trennzeichen, nach dem Teilen immer noch nur eine Zeichenfolge vorhanden ist:

SELECT column1 part_number_value, column2 portion
  FROM VALUES
    (1, SPLIT_PART('user@snowflake.com', '',  1)),
    (-1, SPLIT_PART('user@snowflake.com', '', -1)),
    (2, SPLIT_PART('user@snowflake.com', '',  2)),
    (-2, SPLIT_PART('user@snowflake.com', '', -2));

Copy

+-------------------+--------------------+
| PART_NUMBER_VALUE | PORTION            |
|-------------------+--------------------|
|                 1 | user@snowflake.com |
|                -1 | user@snowflake.com |
|                 2 |                    |
|                -2 |                    |
+-------------------+--------------------+

Demonstrieren von Unterschieden zwischen STRTOK und SPLIT_PART¶

Dieses Beispiel zeigt den Unterschied zwischen STRTOK und SPLIT_PART bei Verwendung von wiederholten Trennzeichen. STRTOK behandelt jedes Zeichen in der Trennzeichenfolge '|-' als separates Trennzeichen, das an jedem '|'- und '-'-Zeichen geteilt wird. Im Gegensatz dazu behandelt SPLIT_PART die gesamte Trennzeichenfolge '|-' als ein einziges Trennzeichen, sodass es nur dort geteilt wird, wo diese exakte Sequenz erscheint:

SELECT STRTOK('data1||data2|-data3---data4', '|-', 1) AS strtok_1,
       STRTOK('data1||data2|-data3---data4', '|-', 2) AS strtok_2,
       STRTOK('data1||data2|-data3---data4', '|-', 3) AS strtok_3,
       STRTOK('data1||data2|-data3---data4', '|-', 4) AS strtok_4,
       SPLIT_PART('data1||data2|-data3---data4', '|-', 1) AS split_part_1,
       SPLIT_PART('data1||data2|-data3---data4', '|-', 2) AS split_part_2,
       SPLIT_PART('data1||data2|-data3---data4', '|-', 3) AS split_part_3;

Copy

+----------+----------+----------+----------+-----------------+--------------+--------------+
| STRTOK_1 | STRTOK_2 | STRTOK_3 | STRTOK_4 | SPLIT_PART_1    | SPLIT_PART_2 | SPLIT_PART_3 |
|----------+----------+----------+----------+-----------------+--------------+--------------|
| data1    | data2    | data3    | data4    | data1||data2    | data3---data4|              |
+----------+----------+----------+----------+-----------------+--------------+--------------+