Categorias:

Funções de dados semiestruturados e estruturados (Matriz/objeto)

OBJECT_CONSTRUCT

Devolve um OBJECT construído a partir dos argumentos.

Consulte também:

OBJECT_CONSTRUCT_KEEP_NULL

Sintaxe

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

OBJECT_CONSTRUCT(*)

Argumentos

key

A chave em um par chave-valor. Cada chave é um valor VARCHAR.

value

O valor que está associado à chave. O valor pode ser qualquer tipo de dados.

*

Quando invocado com um asterisco (curinga), o valor de OBJECT é construído a partir dos dados especificados usando os nomes de atributo como chaves e os valores associados como valores. Consulte os exemplos abaixo.

Ao passar um curinga para a função, você pode qualificar o curinga com o nome ou alias da tabela. Por exemplo, para passar todas as colunas da tabela nomeadas mytable, especifique o seguinte:

(mytable.*)

Também é possível usar as palavras-chave ILIKE e EXCLUDE para filtrar:

  • ILIKE filtra nomes de colunas que correspondem ao padrão especificado. Apenas um padrão é permitido. Por exemplo:

    (* ILIKE 'col1%')

  • EXCLUDE filtra nomes de coluna que não correspondem à coluna ou colunas especificadas. Por exemplo:

    (* EXCLUDE col1)

(* EXCLUDE (col1, col2))

Os qualificadores são válidos quando você usa essas palavras-chave. O exemplo a seguir usa a palavra-chave ILIKE para filtrar todas as colunas que correspondem ao padrão col1% na tabela mytable:

(mytable.* ILIKE 'col1%')

As palavras-chave ILIKE e EXCLUDE não podem ser combinadas em uma única chamada de função.

Também é possível especificar o curinga em uma constante de objeto.

Para esta função, as palavras-chave ILIKE e EXCLUDE são válidas somente em uma lista SELECT ou cláusula GROUP BY.

Para obter mais informações sobre as palavras-chave ILIKE e EXCLUDE, consulte a seção «Parâmetros» em SELECT.

Retornos

Retorna um valor do tipo OBJECT.

Notas de uso

  • Se a chave ou o valor for NULL (ou seja, SQL NULL), o par chave-valor é omitido do objeto resultante. Um par chave-valor composto por uma cadeia de caracteres que não seja NULL como chave e um valor nulo JSON como valor (ou seja, PARSE_JSON('NULL')) não é omitido. Para obter mais informações, consulte Valores NULL.

  • O objeto construído não preserva necessariamente a ordem original dos pares chave-valor.

  • Em muitos contextos, você pode usar uma constante de OBJECT (também chamada de literal de OBJECT) em vez da função OBJECT_CONSTRUCT.

Exemplos

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

Construir um objeto simples

Este exemplo mostra como construir um objeto simples:

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

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

Construir objetos usando o caractere curinga (*)

Este exemplo usa o caractere curinga (*) para obter o nome do atributo e o valor da cláusula 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"        |
| }                               |
+---------------------------------+

Este exemplo usa * e inclui a palavra-chave ILIKE para filtrar a saída:

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

+--------------------------+
| OC                       |
|--------------------------|
| {                        |
|   "PROVINCE": "Alberta"  |
| }                        |
| {                        |
|   "PROVINCE": "Manitoba" |
| }                        |
+--------------------------+

Este exemplo usa * e inclui a palavra-chave EXCLUDE para filtrar a saída:

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

Este exemplo é equivalente ao exemplo anterior, mas usa uma constante de objeto em vez da função 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" |
| }                              |
+--------------------------------+

Este é outro exemplo usando *. Neste caso, os nomes dos atributo não são especificados, então o Snowflake usa COLUMN1, COLUMN2 e assim por diante:

SELECT OBJECT_CONSTRUCT(*) FROM VALUES(1,'x'), (2,'y');

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

Construir objetos usando SQL NULL e um valor nulo JSON

Este exemplo constrói um objeto usando SQL NULL e a cadeia de caracteres 'null':

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

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

Para obter mais informações, consulte Valores NULL.

Construir objetos usando expressões

OBJECT_CONSTRUCT oferece suporte a expressões e consultas para adicionar, modificar ou omitir valores do objeto 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                      |
| }                                     |
+---------------------------------------+

Construir valores OBJECT aninhados

O exemplo a seguir cria uma tabela e insere valores OBJECT com dois níveis de aninhamento:

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