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(*)

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.*)

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%')

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

    (* EXCLUDE col1)

(* EXCLUDE (col1, col2))

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%')

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 autre que NULL comme clé et d’une valeur JSON null (c’est-à-dire PARSE_JSON('NULL')) n’est pas omise. Pour plus d’informations, voir Valeurs 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

Les exemples suivants appellent la fonction OBJECT_CONSTRUCT :

Créer un objet simple

Cet exemple montre comment construire un objet simple :

SELECT OBJECT_CONSTRUCT('a', 1, 'b', 'BBBB', 'c', NULL);

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

Créer des objets en utilisant le caractère générique (*)

Cet exemple utilise le caractère générique (*) 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);

SELECT province, created_date
  FROM demo_table_1
  ORDER BY province;

+----------+--------------+
| PROVINCE | CREATED_DATE |
|----------+--------------|
| Alberta  | 2024-01-19   |
| Manitoba | 2024-01-18   |
+----------+--------------+

SELECT OBJECT_CONSTRUCT(*) AS oc
  FROM demo_table_1
  ORDER BY oc['PROVINCE'];

+---------------------------------+
| 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'];

+--------------------------+
| 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'];

+--------------------------------+
| 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'];

+--------------------------------+
| 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');

+---------------------+
| OBJECT_CONSTRUCT(*) |
|---------------------|
| {                   |
|   "COLUMN1": 1,     |
|   "COLUMN2": "x"    |
| }                   |
| {                   |
|   "COLUMN1": 2,     |
|   "COLUMN2": "y"    |
| }                   |
+---------------------+

Créer des objets à l’aide d’un SQLNULL et d’un JSON null

Cet exemple crée un objet en utilisant SQL NULL et la chaîne 'null' :

SELECT OBJECT_CONSTRUCT(
  'Key_One', PARSE_JSON('NULL'),
  'Key_Two', NULL,
  'Key_Three', 'null') AS obj;

+-----------------------+
| OBJ                   |
|-----------------------|
| {                     |
|   "Key_One": null,    |
|   "Key_Three": "null" |
| }                     |
+-----------------------+

Pour plus d’informations, voir Valeurs NULL.

Créer des objets à l’aide d’expressions

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;

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

Créer des valeurs OBJECT imbriquées

L’exemple suivant crée une table et insère des valeurs OBJECT avec deux niveaux d’imbrication :

CREATE OR REPLACE TABLE sample_nested_object (
  id INTEGER,
  nested_object OBJECT);

INSERT INTO sample_nested_object (id, nested_object)
  SELECT 1,
         OBJECT_CONSTRUCT(
           'outer_key1', OBJECT_CONSTRUCT('inner_key1A', 'example1', 'inner_key1B', 'example2'),
           'outer_key2', OBJECT_CONSTRUCT('inner_key2', 5)
         );

INSERT INTO sample_nested_object (id, nested_object)
  SELECT 2,
         OBJECT_CONSTRUCT(
           'outer_key1', OBJECT_CONSTRUCT('inner_key1A', 'example3', 'inner_key1B', 'example4'),
           'outer_key2', OBJECT_CONSTRUCT('inner_key2', 7)
         );

SELECT * FROM sample_nested_object;

+----+--------------------------------+
| ID | NESTED_OBJECT                  |
+----+--------------------------------+
| 1  | {                              |
|    |   "outer_key1": {              |
|    |     "inner_key1A": "example1", |
|    |     "inner_key1B": "example2"  |
|    |   },                           |
|    |   "outer_key2": {              |
|    |     "inner_key2": 5            |
|    |   }                            |
|    | }                              |
| 2  | {                              |
|    |   "outer_key1": {              |
|    |     "inner_key1A": "example3", |
|    |     "inner_key1B": "example4"  |
|    |   },                           |
|    |   "outer_key2": {              |
|    |     "inner_key2": 7            |
|    |   }                            |
|    | }                              |
+----+--------------------------------+