मारियाडीबी JSON_OBJECTAGG () समझाया गया

मारियाडीबी में, JSON_OBJECTAGG() एक अंतर्निहित फ़ंक्शन है जो अपने दो तर्कों के आधार पर एक JSON ऑब्जेक्ट देता है जिसमें कुंजी-मूल्य जोड़े होते हैं।

सिंटैक्स

वाक्य रचना इस प्रकार है:

JSON_OBJECTAGG(key, value)

फ़ंक्शन दो अभिव्यक्तियों को स्वीकार करता है जो एक मान, या दो कॉलम नामों का मूल्यांकन तर्क के रूप में करते हैं। पहला तर्क कुंजी है, और दूसरा इसका मान है।

उदाहरण

प्रदर्शित करने के लिए यहां एक सरल उदाहरण दिया गया है:

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

परिणाम:

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

हालांकि यह उदाहरण दर्शाता है कि फ़ंक्शन कैसे काम करता है, वास्तविक लाभ कॉलम या अन्य अभिव्यक्तियों के साथ काम करते समय आता है।

नीचे ऐसे उदाहरण दिए गए हैं जो तर्कों के लिए डेटाबेस कॉलम का उपयोग करते हैं।

एक डेटाबेस उदाहरण

मान लीजिए कि हम एक टेबल को क्वेरी करते हैं:

SELECT 
    PetName,
    DOB
FROM Pets;

और निम्न परिणाम सेट प्राप्त करें:

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

आइए अब एक क्वेरी चलाते हैं जो प्रत्येक कॉलम को JSON_OBJECTAGG() तक पहुंचाती है फ़ंक्शन, ताकि परिणाम JSON ऑब्जेक्ट के रूप में वापस आ जाएं:

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

परिणाम:

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

हमने केवल JSON_OBJECTAGG() में कॉलम नामों को पास किया था समारोह।

हमने WHERE . का भी उपयोग किया है परिणामों को थोड़ा कम करने के लिए क्लॉज।

समूहीकृत परिणाम

हम SQL का उपयोग कर सकते हैं GROUP BY किसी अन्य कॉलम के समूह के आधार पर JSON ऑब्जेक्ट बनाने के लिए क्लॉज।

मान लीजिए कि हम अपनी मूल क्वेरी में एक कॉलम जोड़ते हैं:

SELECT 
    PetTypeId,
    PetName,
    DOB
FROM Pets;

परिणाम:

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

अब हमारे पास एक PetTypeId है कॉलम और साथ ही PetName और DOB स्तंभ। यह प्रत्येक पालतू जानवर से एक पालतू प्रकार से मेल खाता है।

यहां GROUP BY . का उपयोग करने का एक उदाहरण दिया गया है हमारे परिणामों को PetTypeId . द्वारा समूहीकृत करने के लिए क्लॉज JSON_OBJECTAGG() . का उपयोग करते समय कॉलम समारोह:

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

परिणाम:

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

इसने हमें प्रत्येक पालतू प्रकार के लिए एक अलग JSON ऑब्जेक्ट बनाने की अनुमति दी।

निम्न क्वेरी INNER JOIN का उपयोग करती है वास्तविक पालतू प्रकार को वापस करने के लिए किसी अन्य तालिका पर, न केवल आईडी।

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

परिणाम:

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

हम देख सकते हैं कि वास्तविक पालतू प्रकार अब केवल पालतू प्रकार आईडी के बजाय पहले कॉलम में सूचीबद्ध है।

आइए अब JSON_OBJECTAGG() . का उपयोग करें समारोह:

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;

परिणाम:

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