Catégories :

Fonctions de données semi-structurées et structurées (tableau/objet)

OBJECT_CONSTRUCT

Renvoie un OBJECT construit à partir des arguments.

Voir aussi :

OBJECT_CONSTRUCT_KEEP_NULL

Syntaxe

OBJECT_CONSTRUCT( [<key>, <value> [, <key>, <value> , ...]] )

OBJECT_CONSTRUCT(*)
Copy

Arguments

key

Clé dans une paire clé-valeur. Chaque clé est une valeur VARCHAR.

value

Valeur associée à la clé. La valeur peut être n’importe quel type de données.

*

Lorsqu’elle est invoquée avec un astérisque (caractère générique), la valeur OBJECT est construite à partir des données spécifiées en utilisant les noms d’attributs comme clés et les valeurs associées comme valeurs. Voir les exemples ci-dessous.

Lorsque vous transmettez un caractère générique à la fonction, vous pouvez qualifier le caractère générique avec le nom ou l’alias de la table. Par exemple, pour transmettre toutes les colonnes de la table nommée mytable, précisez les éléments suivants :

(mytable.*)
Copy

Vous pouvez également utiliser les mots-clés ILIKE et EXCLUDE pour le filtrage :

  • ILIKE filtre les noms de colonnes qui correspondent au motif spécifié. Un seul motif est autorisé. Par exemple :

    (* ILIKE 'col1%')
    Copy

  • EXCLUDE filtre les noms de colonnes qui ne correspondent pas à la / aux colonnes spécifiées. Par exemple :

    (* EXCLUDE col1)

(* EXCLUDE (col1, col2))
    Copy

Les qualificatifs sont valides lorsque vous utilisez ces mots-clés. L’exemple suivant utilise le mot-clé ILIKE pour filtrer toutes les colonnes qui correspondent au motif col1% dans la table mytable :

(mytable.* ILIKE 'col1%')
Copy

Les mots-clés ILIKE et EXCLUDE ne peuvent pas être combinés dans un seul appel de fonction.

Vous pouvez également spécifier le caractère générique dans une constante d’objet.

Pour cette fonction, les mots-clés ILIKE et EXCLUDE ne sont valables que dans une liste SELECT ou une clause GROUP BY.

Pour plus d’informations sur les mots-clés ILIKE et EXCLUDE, voir la section « Paramètres » dans SELECT.

Renvoie

Renvoie une valeur de type OBJECT.

Notes sur l’utilisation

  • Si la clé ou la valeur est NULL (c’est-à-dire SQL NULL), la paire clé-valeur est omise de l’objet résultant. Une paire clé-valeur constituée d’une chaîne qui n’est pas NULL comme la clé et un JSON null car la valeur (c’est-à-dire PARSE_JSON('NULL')) n’est pas omise. Pour plus d’informations, voir VARIANT null.

  • L’objet construit ne conserve pas nécessairement l’ordre d’origine des paires clé-valeur.

  • Dans de nombreux contextes, vous pouvez utiliser une constante OBJECT (également appelée OBJECT littéral) au lieu de la fonction OBJECT_CONSTRUCT.

Exemples

Cet exemple montre comment construire un objet simple :

SELECT OBJECT_CONSTRUCT('a', 1, 'b', 'BBBB', 'c', NULL);
Copy
+--------------------------------------------------+
| OBJECT_CONSTRUCT('A', 1, 'B', 'BBBB', 'C', NULL) |
|--------------------------------------------------|
| {                                                |
|   "a": 1,                                        |
|   "b": "BBBB"                                    |
| }                                                |
+--------------------------------------------------+

Cet exemple utilise * pour obtenir le nom d’attribut et la valeur de la clause FROM :

CREATE OR REPLACE TABLE demo_table_1 (province VARCHAR, created_date DATE);
INSERT INTO demo_table_1 (province, created_date) VALUES
  ('Manitoba', '2024-01-18'::DATE),
  ('Alberta', '2024-01-19'::DATE);
Copy
SELECT province, created_date
  FROM demo_table_1
  ORDER BY province;
Copy
+----------+--------------+
| PROVINCE | CREATED_DATE |
|----------+--------------|
| Alberta  | 2024-01-19   |
| Manitoba | 2024-01-18   |
+----------+--------------+

SELECT OBJECT_CONSTRUCT(*) AS oc
  FROM demo_table_1
  ORDER BY oc['PROVINCE'];
Copy
+---------------------------------+
| OC                              |
|---------------------------------|
| {                               |
|   "CREATED_DATE": "2024-01-19", |
|   "PROVINCE": "Alberta"         |
| }                               |
| {                               |
|   "CREATED_DATE": "2024-01-18", |
|   "PROVINCE": "Manitoba"        |
| }                               |
+---------------------------------+

Cet exemple utilise * et comprend le mot-clé ILIKE pour filtrer la sortie :

SELECT OBJECT_CONSTRUCT(* ILIKE 'prov%') AS oc
  FROM demo_table_1
  ORDER BY oc['PROVINCE'];
Copy
+--------------------------+
| OC                       |
|--------------------------|
| {                        |
|   "PROVINCE": "Alberta"  |
| }                        |
| {                        |
|   "PROVINCE": "Manitoba" |
| }                        |
+--------------------------+

Cet exemple utilise * et comprend le mot-clé EXCLUDE pour filtrer la sortie :

SELECT OBJECT_CONSTRUCT(* EXCLUDE province) AS oc
  FROM demo_table_1
  ORDER BY oc['PROVINCE'];
Copy
+--------------------------------+
| OC                             |
|--------------------------------|
| {                              |
|   "CREATED_DATE": "2024-01-18" |
| }                              |
| {                              |
|   "CREATED_DATE": "2024-01-19" |
| }                              |
+--------------------------------+

Cet exemple est équivalent à l’exemple précédent, mais il utilise une constante d’objet au lieu de la fonction OBJECT_CONSTRUCT :

SELECT {* EXCLUDE province} AS oc
  FROM demo_table_1
  ORDER BY oc['PROVINCE'];
Copy
+--------------------------------+
| OC                             |
|--------------------------------|
| {                              |
|   "CREATED_DATE": "2024-01-18" |
| }                              |
| {                              |
|   "CREATED_DATE": "2024-01-19" |
| }                              |
+--------------------------------+

Ceci est un autre exemple utilisant *. Dans ce cas, les noms d’attribut ne sont pas spécifiés, donc Snowflake utilise COLUMN1, COLUMN2, etc. :

SELECT OBJECT_CONSTRUCT(*) FROM VALUES(1,'x'), (2,'y');
Copy
+---------------------+
| OBJECT_CONSTRUCT(*) |
|---------------------|
| {                   |
|   "COLUMN1": 1,     |
|   "COLUMN2": "x"    |
| }                   |
| {                   |
|   "COLUMN1": 2,     |
|   "COLUMN2": "y"    |
| }                   |
+---------------------+

Cet exemple utilise SQL NULL et la chaîne 'null' :

SELECT OBJECT_CONSTRUCT(
  'Key_One', PARSE_JSON('NULL'), 
  'Key_Two', NULL, 
  'Key_Three', 'null') AS obj;
Copy
+-----------------------+
| OBJ                   |
|-----------------------|
| {                     |
|   "Key_One": null,    |
|   "Key_Three": "null" |
| }                     |
+-----------------------+

OBJECT_CONSTRUCT prend en charge les expressions et les requêtes pour ajouter, modifier ou omettre des valeurs de l’objet JSON.

SELECT OBJECT_CONSTRUCT(
    'foo', 1234567,
    'dataset_size', (SELECT COUNT(*) FROM demo_table_1),
    'distinct_province', (SELECT COUNT(DISTINCT province) FROM demo_table_1),
    'created_date_seconds', extract(epoch_seconds, created_date)
  )  AS json_object
  FROM demo_table_1;
Copy
+---------------------------------------+
| JSON_OBJECT                           |
|---------------------------------------|
| {                                     |
|   "created_date_seconds": 1705536000, |
|   "dataset_size": 2,                  |
|   "distinct_province": 2,             |
|   "foo": 1234567                      |
| }                                     |
| {                                     |
|   "created_date_seconds": 1705622400, |
|   "dataset_size": 2,                  |
|   "distinct_province": 2,             |
|   "foo": 1234567                      |
| }                                     |
+---------------------------------------+
Langage: Français