Categorias:: Funções de dados semiestruturados e estruturados (Extração)

GET_PATH , `:`¶

Extrai um valor de dados semiestruturados usando um nome de caminho.

GET_PATH é uma variação de GET; toma como primeiro argumento um nome de coluna de VARIANT, OBJECT ou ARRAY e extrai o valor do campo ou o elemento de acordo com o nome do caminho fornecido como segundo argumento.

Sintaxe¶

GET_PATH( <column_identifier> , '<path_name>' )

<column_identifier>:<path_name>

:( <column_identifier> , '<path_name>' )

Copy

Argumentos¶

column_identifier

Uma expressão que é avaliada como uma coluna VARIANT, OBJECT ou ARRAY.

path_name

Uma expressão que é avaliada como um valor VARCHAR. Esse valor especifica o caminho para o campo ou elemento que você deseja extrair.

Para tipos estruturados, você deve especificar uma constante de cadeia de caracteres.

Retornos¶

O valor retornado é o elemento especificado do ARRAY, ou o valor que corresponde à chave especificada de um par chave-valor no OBJECT.
Se o objeto de entrada for um valor semiestruturado OBJECT, ARRAY ou VARIANT, a função retornará um valor VARIANT. O tipo de dados do valor é VARIANT porque:
- Em um valor ARRAY, cada elemento é do tipo VARIANT.
- Em um valor OBJECT, o valor em cada par chave-valor é do tipo VARIANT.
Se o objeto de entrada for OBJECT estruturado, ARRAY estruturado ou MAP, a função retornará um valor do tipo especificado para o objeto.

Por exemplo, se o tipo do objeto de entrada for ARRAY(NUMBER), a função retornará um valor NUMBER.

Notas de uso¶

GET_PATH é equivalente a uma cadeia de funções GET. Ele retorna NULL se o nome do caminho não corresponder a nenhum elemento.
A sintaxe do nome do caminho é a notação padrão do JavaScript; ela consiste em uma concatenação de nomes de campos (identificadores) precedidos por pontos (por exemplo, .) e operadores de índice (por exemplo, [<index>]):
- O primeiro nome de campo não requer que o ponto inicial seja especificado.
- Os valores do índice nos operadores de índice podem ser números decimais não negativos (para matrizes) ou literais de cadeia de caracteres de caracteres com aspas simples ou duplas (para campos de objetos).
Para obter mais detalhes, consulte Consulta de dados semiestruturados.
GET_PATH também oferece suporte a um atalho sintático que usa o caractere : como operador de extração que separa o nome da coluna (que pode conter pontos) do especificador de caminho.

Para manter a consistência sintática, a notação do caminho também oferece suporte a identificadores no estilo SQL de aspas duplas, e o uso de : como separadores de caminho.

Quando o operador : é usado, qualquer número inteiro ou subexpressão de cadeia de caracteres pode ser incluída dentro do [].

Exemplos¶

Crie uma tabela com uma coluna VARIANT e insira dados. Use a função PARSE_JSON para inserir os dados de VARIANT. Os valores VARIANT contêm valores ARRAY aninhados e OBJECT.

CREATE OR REPLACE TABLE get_path_demo(
  id INTEGER,
  v  VARIANT);

INSERT INTO get_path_demo (id, v)
  SELECT 1,
         PARSE_JSON('{
           "array1" : [
             {"id1": "value_a1", "id2": "value_a2", "id3": "value_a3"}
           ],
           "array2" : [
             {"id1": "value_b1", "id2": "value_b2", "id3": "value_b3"}
           ],
           "object_outer_key1" : {
             "object_inner_key1a": "object_x1",
             "object_inner_key1b": "object_x2"
           }
         }');

INSERT INTO get_path_demo (id, v)
  SELECT 2,
         PARSE_JSON('{
           "array1" : [
             {"id1": "value_c1", "id2": "value_c2", "id3": "value_c3"}
           ],
           "array2" : [
             {"id1": "value_d1", "id2": "value_d2", "id3": "value_d3"}
           ],
           "object_outer_key1" : {
             "object_inner_key1a": "object_y1",
             "object_inner_key1b": "object_y2"
           }
         }');

SELECT * FROM get_path_demo;

Copy

+----+----------------------------------------+
| ID | V                                      |
|----+----------------------------------------|
|  1 | {                                      |
|    |   "array1": [                          |
|    |     {                                  |
|    |       "id1": "value_a1",               |
|    |       "id2": "value_a2",               |
|    |       "id3": "value_a3"                |
|    |     }                                  |
|    |   ],                                   |
|    |   "array2": [                          |
|    |     {                                  |
|    |       "id1": "value_b1",               |
|    |       "id2": "value_b2",               |
|    |       "id3": "value_b3"                |
|    |     }                                  |
|    |   ],                                   |
|    |   "object_outer_key1": {               |
|    |     "object_inner_key1a": "object_x1", |
|    |     "object_inner_key1b": "object_x2"  |
|    |   }                                    |
|    | }                                      |
|  2 | {                                      |
|    |   "array1": [                          |
|    |     {                                  |
|    |       "id1": "value_c1",               |
|    |       "id2": "value_c2",               |
|    |       "id3": "value_c3"                |
|    |     }                                  |
|    |   ],                                   |
|    |   "array2": [                          |
|    |     {                                  |
|    |       "id1": "value_d1",               |
|    |       "id2": "value_d2",               |
|    |       "id3": "value_d3"                |
|    |     }                                  |
|    |   ],                                   |
|    |   "object_outer_key1": {               |
|    |     "object_inner_key1a": "object_y1", |
|    |     "object_inner_key1b": "object_y2"  |
|    |   }                                    |
|    | }                                      |
+----+----------------------------------------+

Extraia o valor id3 de array2 em cada linha:

SELECT id,
       GET_PATH(
         v,
         'array2[0].id3') AS id3_in_array2
  FROM get_path_demo;

Copy

+----+---------------+
| ID | ID3_IN_ARRAY2 |
|----+---------------|
|  1 | "value_b3"    |
|  2 | "value_d3"    |
+----+---------------+

Use o operador : para extrair o mesmo valor id3 de array2 em cada linha:

SELECT id,
       v:array2[0].id3 AS id3_in_array2
  FROM get_path_demo;

Copy

+----+---------------+
| ID | ID3_IN_ARRAY2 |
|----+---------------|
|  1 | "value_b3"    |
|  2 | "value_d3"    |
+----+---------------+

Este exemplo é igual ao anterior, mas usa identificadores entre aspas duplas no estilo SQL:

SELECT id,
       v:"array2"[0]."id3" AS id3_in_array2
  FROM get_path_demo;

Copy

+----+---------------+
| ID | ID3_IN_ARRAY2 |
|----+---------------|
|  1 | "value_b3"    |
|  2 | "value_d3"    |
+----+---------------+

Extraia o valor object_inner_key1a do valor OBJECT aninhado em cada linha:

SELECT id,
       GET_PATH(
         v,
         'object_outer_key1:object_inner_key1a') AS object_inner_key1A_values
  FROM get_path_demo;

Copy

+----+---------------------------+
| ID | OBJECT_INNER_KEY1A_VALUES |
|----+---------------------------|
|  1 | "object_x1"               |
|  2 | "object_y1"               |
+----+---------------------------+

Use o operador : para extrair os mesmos valores de object_inner_key1a:

SELECT id,
       v:object_outer_key1.object_inner_key1a AS object_inner_key1a_values
  FROM get_path_demo;

Copy

+----+---------------------------+
| ID | OBJECT_INNER_KEY1A_VALUES |
|----+---------------------------|
|  1 | "object_x1"               |
|  2 | "object_y1"               |
+----+---------------------------+

Este exemplo é igual ao anterior, mas usa identificadores entre aspas duplas no estilo SQL:

SELECT id,
       v:"object_outer_key1":"object_inner_key1a" AS object_inner_key1a_values
  FROM get_path_demo;

Copy

+----+---------------------------+
| ID | OBJECT_INNER_KEY1A_VALUES |
|----+---------------------------|
|  1 | "object_x1"               |
|  2 | "object_y1"               |
+----+---------------------------+

GET_PATH , :¶

Sintaxe¶

Argumentos¶

Retornos¶

Notas de uso¶

Exemplos¶

GET_PATH , `:`¶