MariaDB JSON_OBJECTAGG() uitgelegd

In MariaDB, JSON_OBJECTAGG() is een ingebouwde functie die een JSON-object retourneert dat sleutel-waardeparen bevat, op basis van zijn twee argumenten.

Syntaxis

De syntaxis gaat als volgt:

JSON_OBJECTAGG(key, value)

De functie accepteert twee expressies die resulteren in een enkele waarde, of twee kolomnamen, als argumenten. Het eerste argument is de sleutel en het tweede is de waarde ervan.

Voorbeeld

Hier is een eenvoudig voorbeeld om te demonstreren:

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

Resultaat:

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

Hoewel dit voorbeeld laat zien hoe de functie werkt, komt het echte voordeel van het werken met kolommen of andere uitdrukkingen.

Hieronder staan ​​voorbeelden die databasekolommen gebruiken voor de argumenten.

Een databasevoorbeeld

Stel dat we een tabel opvragen:

SELECT 
    PetName,
    DOB
FROM Pets;

En krijg de volgende resultatenset:

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

Laten we nu een query uitvoeren die elke kolom doorgeeft aan de JSON_OBJECTAGG() functie, zodat de resultaten worden geretourneerd als een JSON-object:

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

Resultaat:

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

Het enige wat we deden was de kolomnamen doorgeven aan de JSON_OBJECTAGG() functie.

We gebruikten ook een WHERE clausule om de resultaten een beetje te verfijnen.

Gegroepeerde resultaten

We kunnen de SQL GROUP BY . gebruiken clausule om JSON-objecten te produceren op basis van een groepering van een andere kolom.

Stel dat we een kolom toevoegen aan onze oorspronkelijke zoekopdracht:

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

Resultaat:

+-----------+---------+------------+
| 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 hebben we een PetTypeId kolom en de PetName en DOB kolommen. Dit komt overeen met een huisdiertype voor elk huisdier.

Hier is een voorbeeld van het gebruik van de GROUP BY clausule om onze resultaten te groeperen op de PetTypeId kolom bij gebruik van de JSON_OBJECTAGG() functie:

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

Resultaat:

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

Hierdoor konden we voor elk huisdiertype een apart JSON-object maken.

De volgende query gebruikt een INNER JOIN op een andere tafel om het werkelijke huisdiertype terug te geven, niet alleen de ID.

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

Resultaat:

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

We kunnen zien dat het werkelijke huisdiertype nu in de eerste kolom wordt vermeld, in plaats van alleen het huisdiertype-ID.

Laten we nu de JSON_OBJECTAGG() . gebruiken functie:

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;

Resultaat:

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