MariaDB JSON_OBJECTAGG() Förklarad

I MariaDB, JSON_OBJECTAGG() är en inbyggd funktion som returnerar ett JSON-objekt som innehåller nyckel-värdepar, baserat på dess två argument.

Syntax

Syntaxen ser ut så här:

JSON_OBJECTAGG(key, value)

Funktionen accepterar två uttryck som utvärderas till ett enda värde, eller två kolumnnamn, som argument. Det första argumentet är nyckeln och det andra är dess värde.

Exempel

Här är ett enkelt exempel att visa:

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

Resultat:

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

Även om det här exemplet visar hur funktionen fungerar, kommer den verkliga fördelen in när man arbetar med kolumner eller andra uttryck.

Nedan finns exempel som använder databaskolumner för argumenten.

Ett databasexempel

Anta att vi frågar en tabell:

SELECT 
    PetName,
    DOB
FROM Pets;

Och få följande resultatuppsättning:

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

Låt oss nu köra en fråga som skickar varje kolumn till JSON_OBJECTAGG() funktion, så att resultaten returneras som ett 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"} |
+--------------------------------------------------------------------+

Allt vi gjorde var att skicka kolumnnamnen till JSON_OBJECTAGG() fungera.

Vi använde också en WHERE klausul för att begränsa resultaten lite.

Grupperade resultat

Vi kan använda SQL GROUP BY sats för att producera JSON-objekt baserat på en gruppering av en annan kolumn.

Anta att vi lägger till en kolumn i vår ursprungliga fråga:

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 ett PetTypeId kolumnen samt PetName och DOB kolumner. Detta matchar en husdjurstyp till varje husdjur.

Här är ett exempel på hur du använder GROUP BY klausul för att gruppera våra resultat efter PetTypeId kolumnen medan du använder 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} |
+-----------+--------------------------------------------------------------------------------+

Detta gjorde det möjligt för oss att skapa ett separat JSON-objekt för varje husdjurstyp.

Följande fråga använder en INNER JOIN på ett annat bord för att returnera den faktiska husdjurstypen, inte bara ID.

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 att den faktiska husdjurstypen nu är listad i den första kolumnen, istället för bara husdjurstypens ID.

Låt oss nu använda 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"} |
+---------+--------------------------------------------------------------------------------+