- Catégories :
Fonctions de données semi-structurées et structurées (extraction)
GET_PATH , :¶
Extrait une valeur des données semi-structurées à l’aide d’un nom de chemin.
GET_PATH est une variation de GET. Il prend comme premier argument un nom de colonne VARIANT, OBJECT ou ARRAY et extrait la valeur du champ ou de l’élément en fonction du nom de chemin d’accès fourni comme deuxième argument.
Syntaxe¶
GET_PATH( <column_identifier> , '<path_name>' )
<column_identifier>:<path_name>
:( <column_identifier> , '<path_name>' )
Arguments¶
column_identifierUne expression qui donne une colonne VARIANT, OBJECT ou ARRAY.
path_nameUne expression qui donne une valeur VARCHAR. Cette valeur indique le chemin d’accès au champ ou à l’élément à extraire.
Pour les types structurés, vous devez spécifier une constante de chaîne.
Renvoie¶
La valeur renvoyée est l’élément spécifié du ARRAY ou la valeur qui correspond à la clé spécifiée d’une paire clé-valeur dans l’OBJECT.
Si l’objet d’entrée est une valeur OBJECT, ARRAY ou VARIANT semi-structurée, la fonction renvoie une valeur VARIANT. Le type de données de la valeur est VARIANT car :
Dans une valeur ARRAY, chaque élément est de type VARIANT.
Dans une valeur OBJECT, la valeur de chaque paire clé-valeur est du type VARIANT.
Si l’objet d’entrée est un OBJECT structuré, un ARRAY structuré ou une MAP, la fonction renvoie une valeur du type spécifié pour l’objet.
Par exemple, si le type de l’objet d’entrée est ARRAY(NUMBER), la fonction renvoie une valeur NUMBER.
Notes sur l’utilisation¶
GET_PATH est équivalent à une chaîne de fonctions GET. Elle renvoie NULL si le nom du chemin ne correspond à aucun élément.
La syntaxe du nom de chemin est la notation standard JavaScript ; elle consiste en une concaténation de noms de champs (identificateurs) précédés de points (par exemple,
.) et d’opérateurs d’index (par exemple,[<index>]) :Le premier nom de champ ne nécessite pas que la période de tête soit spécifiée.
Les valeurs d’index dans les opérateurs d’index peuvent être des nombres décimaux non négatifs (pour les tableaux) ou des littéraux de chaîne entre guillemets simples ou doubles (pour les champs d’objet).
Pour plus de détails, voir Interrogation de données semi-structurées.
GET_PATH prend également en charge un raccourci syntaxique utilisant le caractère
:en tant qu’opérateur d’extraction séparant le nom de la colonne (pouvant contenir des points) du spécificateur de chemin d’accès.Pour maintenir la cohérence syntaxique, la notation de chemin prend également en charge les identificateurs entre guillemets de style SQL et l’utilisation de
:comme séparateurs de chemin.Lorsque l’opérateur
:est utilisé, toutes les expressions de type entier ou chaîne peuvent être incluses dans[].
Exemples¶
Créez une table avec une colonne VARIANT et insérez des données. Utilisez la fonction PARSE_JSON pour insérer les données VARIANT. Les valeurs VARIANT contiennent des valeurs imbriquées ARRAY et 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;
+----+----------------------------------------+
| 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" |
| | } |
| | } |
+----+----------------------------------------+
Extrayez la valeur id3 à partir de array2 dans chaque ligne :
SELECT id,
GET_PATH(
v,
'array2[0].id3') AS id3_in_array2
FROM get_path_demo;
+----+---------------+
| ID | ID3_IN_ARRAY2 |
|----+---------------|
| 1 | "value_b3" |
| 2 | "value_d3" |
+----+---------------+
Utilisez l’opérateur : pour extraire la même valeur id3 de array2 dans chaque ligne :
SELECT id,
v:array2[0].id3 AS id3_in_array2
FROM get_path_demo;
+----+---------------+
| ID | ID3_IN_ARRAY2 |
|----+---------------|
| 1 | "value_b3" |
| 2 | "value_d3" |
+----+---------------+
Cet exemple est le même que le précédent, mais il utilise des identificateurs à double guillemet de type SQL :
SELECT id,
v:"array2"[0]."id3" AS id3_in_array2
FROM get_path_demo;
+----+---------------+
| ID | ID3_IN_ARRAY2 |
|----+---------------|
| 1 | "value_b3" |
| 2 | "value_d3" |
+----+---------------+
Extrayez la valeur object_inner_key1a de la valeur OBJECT imbriquée dans chaque ligne :
SELECT id,
GET_PATH(
v,
'object_outer_key1:object_inner_key1a') AS object_inner_key1A_values
FROM get_path_demo;
+----+---------------------------+
| ID | OBJECT_INNER_KEY1A_VALUES |
|----+---------------------------|
| 1 | "object_x1" |
| 2 | "object_y1" |
+----+---------------------------+
Utilisez l’opérateur : pour extraire les mêmes valeurs object_inner_key1a :
SELECT id,
v:object_outer_key1.object_inner_key1a AS object_inner_key1a_values
FROM get_path_demo;
+----+---------------------------+
| ID | OBJECT_INNER_KEY1A_VALUES |
|----+---------------------------|
| 1 | "object_x1" |
| 2 | "object_y1" |
+----+---------------------------+
Cet exemple est le même que le précédent, mais il utilise des identificateurs à double guillemet de type SQL :
SELECT id,
v:"object_outer_key1":"object_inner_key1a" AS object_inner_key1a_values
FROM get_path_demo;
+----+---------------------------+
| ID | OBJECT_INNER_KEY1A_VALUES |
|----+---------------------------|
| 1 | "object_x1" |
| 2 | "object_y1" |
+----+---------------------------+