MariaDB JSON_OBJECTAGG() explicado

No MariaDB, JSON_OBJECTAGG() é uma função interna que retorna um objeto JSON contendo pares chave-valor, com base em seus dois argumentos.

Sintaxe

A sintaxe fica assim:

JSON_OBJECTAGG(key, value)

A função aceita duas expressões que avaliam um único valor, ou dois nomes de coluna, como argumentos. O primeiro argumento é a chave e o segundo é seu valor.

Exemplo

Aqui está um exemplo simples para demonstrar:

SELECT JSON_OBJECTAGG("name", "Homer");

Resultado:

+---------------------------------+
| JSON_OBJECTAGG("name", "Homer") |
+---------------------------------+
| {"name":"Homer"}                |
+---------------------------------+

Embora este exemplo demonstre como a função funciona, o benefício real vem ao trabalhar com colunas ou outras expressões.

Abaixo estão exemplos que usam colunas de banco de dados para os argumentos.

Um exemplo de banco de dados

Suponha que consultamos uma tabela:

SELECT 
    PetName,
    DOB
FROM Pets;

E obtenha o seguinte conjunto de resultados:

+---------+------------+
| PetName | DOB        |
+---------+------------+
| Fluffy  | 2020-11-20 |
| Fetch   | 2019-08-16 |
| Scratch | 2018-10-01 |
| Wag     | 2020-03-15 |
| Tweet   | 2020-11-28 |
| Fluffy  | 2020-09-17 |
| Bark    | NULL       |
| Meow    | NULL       |
+---------+------------+

Vamos agora executar uma consulta que passa cada coluna para o JSON_OBJECTAGG() função, para que os resultados sejam retornados como um objeto JSON:

SELECT JSON_OBJECTAGG(PetName, DOB)
FROM Pets
WHERE DOB < '2020-04-01';

Resultado:

+--------------------------------------------------------------------+
| JSON_OBJECTAGG(PetName, DOB)                                       |
+--------------------------------------------------------------------+
| {"Fetch":"2019-08-16", "Scratch":"2018-10-01", "Wag":"2020-03-15"} |
+--------------------------------------------------------------------+

Tudo o que fizemos foi passar os nomes das colunas para o JSON_OBJECTAGG() função.

Também usamos um WHERE cláusula para restringir um pouco os resultados.

Resultados agrupados

Podemos usar o SQL GROUP BY cláusula para produzir objetos JSON com base em um agrupamento de outra coluna.

Suponha que adicionamos uma coluna à nossa consulta original:

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

Resultado:

+-----------+---------+------------+
| PetTypeId | PetName | DOB        |
+-----------+---------+------------+
|         2 | Fluffy  | 2020-11-20 |
|         3 | Fetch   | 2019-08-16 |
|         2 | Scratch | 2018-10-01 |
|         3 | Wag     | 2020-03-15 |
|         1 | Tweet   | 2020-11-28 |
|         3 | Fluffy  | 2020-09-17 |
|         3 | Bark    | NULL       |
|         2 | Meow    | NULL       |
+-----------+---------+------------+

Agora temos um PetTypeId coluna, bem como o PetName e DOB colunas. Isso corresponde a um tipo de animal de estimação para cada animal de estimação.

Aqui está um exemplo de uso do GROUP BY cláusula para agrupar nossos resultados pelo PetTypeId coluna ao usar o JSON_OBJECTAGG() função:

SELECT 
    PetTypeId,
    JSON_OBJECTAGG(PetName, DOB)
FROM Pets
GROUP BY PetTypeId;

Resultado:

+-----------+--------------------------------------------------------------------------------+
| PetTypeId | JSON_OBJECTAGG(PetName, DOB)                                                   |
+-----------+--------------------------------------------------------------------------------+
|         1 | {"Tweet":"2020-11-28"}                                                         |
|         2 | {"Fluffy":"2020-11-20", "Scratch":"2018-10-01", "Meow":null}                   |
|         3 | {"Fetch":"2019-08-16", "Wag":"2020-03-15", "Fluffy":"2020-09-17", "Bark":null} |
+-----------+--------------------------------------------------------------------------------+

Isso nos permitiu criar um objeto JSON separado para cada tipo de animal de estimação.

A consulta a seguir usa um INNER JOIN em outra tabela para retornar o tipo de animal de estimação real, não apenas o ID.

SELECT 
    pt.PetType,
    p.PetName,
    p.DOB
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
ORDER BY PetType;

Resultado:

+---------+---------+------------+
| PetType | PetName | DOB        |
+---------+---------+------------+
| Bird    | Tweet   | 2020-11-28 |
| Cat     | Scratch | 2018-10-01 |
| Cat     | Fluffy  | 2020-11-20 |
| Cat     | Meow    | NULL       |
| Dog     | Wag     | 2020-03-15 |
| Dog     | Fetch   | 2019-08-16 |
| Dog     | Bark    | NULL       |
| Dog     | Fluffy  | 2020-09-17 |
+---------+---------+------------+

Podemos ver que o tipo de animal de estimação real agora está listado na primeira coluna, em vez de apenas o ID do tipo de animal de estimação.

Agora vamos usar o JSON_OBJECTAGG() função:

SELECT 
    pt.PetType,
    JSON_OBJECTAGG(p.PetName, p.DOB)
FROM Pets p 
INNER JOIN PetTypes pt 
ON pt.PetTypeId = p.PetTypeId
GROUP BY pt.PetType;

Resultado:

+---------+--------------------------------------------------------------------------------+
| PetType | JSON_OBJECTAGG(p.PetName, p.DOB)                                               |
+---------+--------------------------------------------------------------------------------+
| Bird    | {"Tweet":"2020-11-28"}                                                         |
| Cat     | {"Scratch":"2018-10-01", "Fluffy":"2020-11-20", "Meow":null}                   |
| Dog     | {"Wag":"2020-03-15", "Fetch":"2019-08-16", "Bark":null, "Fluffy":"2020-09-17"} |
+---------+--------------------------------------------------------------------------------+