Categorias:: Funções de cadeia de caracteres e binários (General)

SPLIT_PART¶

Divide uma determinada cadeia em um caractere especificado e retorna a parte solicitada.

Para retornar todos os caracteres após um caractere especificado, você pode usar as funções POSITION e SUBSTR. Para obter um exemplo, consulte Como retornar substrings para cadeias de caracteres de e-mail, telefone e data.

Dica

Você pode usar o serviço de otimização de pesquisa para melhorar o desempenho de consultas que chamam essa função. Para obter mais detalhes, consulte Serviço de otimização de pesquisa.

Consulte também:: SPLIT, STRTOK

Sintaxe¶

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

Copy

Argumentos¶

string

Texto a ser dividido em partes.

delimiter

Texto representando o delimitador para divisão. A cadeia de caracteres inteira do delimitador é tratada como um único delimitador, mesmo que contenha vários caracteres. Esse comportamento é diferente do STRTOK, que trata cada caractere no delimitador como um delimitador separado.

partNumber

A parte solicitada da divisão, que é baseada em 1 para que o primeiro token seja o token número 1, não o token número 0.

Se o valor for negativo, as peças são contadas de trás para frente a partir do fim da cadeia de caracteres.

Retornos¶

Esta função retorna um valor do tipo VARCHAR.

Se algum argumento for NULL, a função retornará NULL.

Notas de uso¶

Se partNumber estiver fora do intervalo, o valor retornado é uma cadeia de caracteres vazia.
Se a cadeia de caracteres começar ou terminar com o delimitador, o sistema considera o espaço vazio antes ou depois do delimitador, respectivamente, como uma parte válida do resultado da divisão. Para ver um exemplo, consulte a seção Exemplos abaixo. Isso significa que SPLIT_PART pode retornar cadeias de caracteres vazias como partes, ao contrário do STRTOK, que nunca retorna cadeias de caracteres vazias.
Se partNumber for 0, ele será tratado como 1. Em outras palavras, ele recebe o primeiro elemento da divisão. Para evitar confusão sobre se os índices são baseados em 1 ou em 0, o Snowflake recomenda evitar o uso de 0 como sinônimo de 1.
Se o separador for uma cadeia de caracteres vazia, após a divisão, o valor retornado será a cadeia de caracteres de entrada (a cadeia de caracteres não é dividida).

Detalhes do agrupamento¶

The collation specifications of all input arguments must be compatible.

Esta função não oferece suporte às seguintes especificações de agrupamento:

pi (não identifica pontuação).
cs-ai (diferencia maiúsculas e minúsculas, não identifica acentos).

Exemplos¶

Os exemplos a seguir chamam a função SPLIT_PART:

Demonstrar as partes retornadas para valores de números de parte diferentes¶

Este exemplo mostra as partes retornadas por valores partNumber diferentes:

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

Retornar a primeira e última partes de um endereço IP¶

Este exemplo retorna a primeira e última partes do endereço IP do host 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         |
+------------+-----------+

Demonstrar o delimitador como o primeiro caractere¶

O exemplo a seguir retorna a primeira e a segunda partes de uma cadeia de caracteres separadas por barras verticais. O separador é a primeira parte da cadeia de caracteres de entrada, portanto, o primeiro elemento após a divisão é uma cadeia de caracteres vazia.

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

Demonstrar um delimitador de vários caracteres¶

O exemplo a seguir mostra um delimitador de vários caracteres:

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

Copy

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

Demonstrar o delimitador como uma cadeia de caracteres vazia¶

O seguinte exemplo mostra que, se o delimitador for uma cadeia de caracteres vazia, após a divisão, ainda haverá apenas uma cadeia de caracteres:

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

Demonstrar as diferenças entre STRTOK e SPLIT_PART¶

Este exemplo demonstra a diferença entre STRTOK eSPLIT_PART ao usar delimitadores repetidos. O STRTOK trata cada caractere na cadeia de caracteres do delimitador '|-' como um delimitador separado, dividindo a cada caractere '|' e '-'. Ao contrário, o SPLIT_PART trata a cadeia de caracteres inteira do delimitador '|-' como um único delimitador, portanto, ele só divide onde esta sequência exata aparece:

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