Catégories :: Fonctions de chaîne et fonctions binaires (général)

SPLIT_PART¶

Fractionne une chaîne donnée et renvoie la partie demandée.

Pour renvoyer tous les caractères après un caractère spécifié, vous pouvez utiliser les fonctions POSITION et SUBSTR. Pour un exemple, voir Renvoyer des sous-chaînes pour les chaînes d’e-mail, de téléphone et de date.

Astuce

Vous pouvez utiliser le service d’optimisation de recherche pour améliorer les performances des requêtes qui appellent cette fonction. Pour plus de détails, voir Service d’optimisation de la recherche.

Voir aussi ::: SPLIT, STRTOK

Syntaxe¶

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

Copy

Arguments¶

string

Texte à scinder en plusieurs parties.

delimiter

Texte représentant le délimiteur à scinder. La chaîne entière du séparateur est traitée comme un seul délimiteur, même si elle contient plusieurs caractères. Ce comportement diffère de STRTOK, qui traite chaque caractère du délimiteur comme un délimiteur distinct.

partNumber

Partie demandée du fractionnement, qui utilise une numérotation à partir de 1, de sorte que le premier jeton porte le numéro 1 et non le numéro 0.

Si la valeur est négative, les parties sont comptées à l’envers à partir de la fin de la chaîne.

Renvoie¶

La fonction renvoie une valeur de type VARCHAR.

Si l’un des arguments est NULL, la fonction renvoie NULL.

Notes sur l’utilisation¶

Si le partNumber est hors limites, la valeur renvoyée est une chaîne vide.
Si la chaîne commence ou se termine par le délimiteur, le système considère respectivement les espaces vides avant ou après le délimiteur comme faisant partie du résultat de la division. Pour obtenir un exemple, consultez la section Exemples ci-dessous. Cela signifie que SPLIT_PART peut renvoyer des chaînes vides en tant que parties, contrairement à STRTOK, qui ne renvoie jamais de chaînes vides.
Si le partNumber est 0, il est traité comme 1. En d’autres termes, il obtient le premier élément de la scission. Pour éviter toute confusion quant à savoir si les index sont basés sur 1 ou sur 0, Snowflake recommande d’éviter l’utilisation de 0 comme synonyme de 1.
Si le délimiteur est une chaîne vide, après le fractionnement, la valeur renvoyée est la chaîne d’entrée (la chaîne n’est pas fractionnée).

Détails du classement¶

The collation specifications of all input arguments must be compatible.

Cette fonction ne fonctionne pas avec les spécifications de classement suivantes :

pi (insensible à la ponctuation).
cs-ai (sensible à la casse, insensible aux accents)

Exemples¶

Les exemples suivants appellent la fonction SPLIT_PART :

Démontrer les parties renvoyées pour différentes valeurs de numéro de partie¶

L’exemple suivant montre les portions renvoyées par différentes valeurs partNumber :

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 |         |
+-------------------+---------+

Renvoyer la première et la dernière partie d’une adresse IP¶

L’exemple suivant renvoie la première et la dernière partie de l’adresse IP de l’hôte local 127.0.0.1 :

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         |
+------------+-----------+

Démontrer le délimiteur comme premier caractère¶

L’exemple suivant renvoie les première et deuxième parties d’une chaîne de caractères séparées par des barres verticales. Le délimiteur étant la première partie de la chaîne d’entrée, le premier élément obtenu après le fractionnement est une chaîne vide.

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         |
+------------+-----------+

Démontrer un délimiteur à plusieurs caractères¶

L’exemple suivant montre un délimiteur à plusieurs caractères :

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

Copy

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

Démontrer le délimiteur comme une chaîne vide¶

L’exemple suivant montre que si le délimiteur est une chaîne vide, alors après le fractionnement, il n’y a toujours qu’une seule chaîne :

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 |                    |
+-------------------+--------------------+

Démontrer les différences entre STRTOK et SPLIT_PART¶

Cet exemple montre la différence entre STRTOK etSPLIT_PART lorsque vous utilisez des délimiteurs répétés. STRTOK traite chaque caractère de la chaîne du délimiteur:code:'|-' comme délimiteur distinct, en la divisant à chaque caractère '|' et '-'. En revanche, SPLIT_PART traite toute la chaîne du délimiteur '|-' en tant que délimiteur unique, de sorte qu’il ne se fractionne que là où cette séquence exacte apparaît :

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|              |
+----------+----------+----------+----------+-----------------+--------------+--------------+