MariaDB JSON_OBJECTAGG() Forklaret

I MariaDB, JSON_OBJECTAGG() er en indbygget funktion, der returnerer et JSON-objekt, der indeholder nøgle-værdi-par, baseret på dets to argumenter.

Syntaks

Syntaksen ser sådan ud:

JSON_OBJECTAGG(key, value)

Funktionen accepterer to udtryk, der evalueres til en enkelt værdi, eller to kolonnenavne, som argumenter. Det første argument er nøglen, og det andet er dets værdi.

Eksempel

Her er et simpelt eksempel til at demonstrere:

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

Resultat:

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

Selvom dette eksempel viser, hvordan funktionen fungerer, kommer den virkelige fordel ind, når du arbejder med kolonner eller andre udtryk.

Nedenfor er eksempler, der bruger databasekolonner til argumenterne.

Et databaseeksempel

Antag, at vi forespørger i en tabel:

SELECT 
    PetName,
    DOB
FROM Pets;

Og få følgende resultatsæt:

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

Lad os nu køre en forespørgsel, der sender hver kolonne til JSON_OBJECTAGG() funktion, så resultaterne returneres som et JSON-objekt:

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

Resultat:

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

Det eneste, vi gjorde, var at sende kolonnenavnene til JSON_OBJECTAGG() fungere.

Vi brugte også en WHERE klausul for at indsnævre resultaterne en smule.

Grupperte resultater

Vi kan bruge SQL GROUP BY klausul for at producere JSON-objekter baseret på en gruppering af en anden kolonne.

Antag, at vi tilføjer en kolonne til vores oprindelige forespørgsel:

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

Resultat:

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

Nu har vi et PetTypeId kolonnen samt PetName og DOB kolonner. Dette matcher en kæledyrstype til hvert kæledyr.

Her er et eksempel på brug af GROUP BY klausul for at gruppere vores resultater efter PetTypeId kolonne, mens du bruger JSON_OBJECTAGG() funktion:

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

Resultat:

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

Dette gjorde det muligt for os at oprette et separat JSON-objekt for hver kæledyrstype.

Følgende forespørgsel bruger en INNER JOIN på et andet bord for at returnere den faktiske kæledyrstype, ikke kun ID'et.

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

Resultat:

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

Vi kan se, at den faktiske kæledyrstype nu er angivet i den første kolonne i stedet for kun kæledyrstype-id'et.

Lad os nu bruge JSON_OBJECTAGG() funktion:

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;

Resultat:

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