SQLite JSON_EACH ()

SQLite में, json_each() एक तालिका-मूल्यवान फ़ंक्शन है जो अपने पहले तर्क के रूप में प्रदान किए गए JSON मान पर चलता है और प्रत्येक सरणी तत्व या ऑब्जेक्ट सदस्य के लिए एक पंक्ति वाली तालिका देता है।

जब हम फ़ंक्शन को कॉल करते हैं तो हम JSON मान को तर्क के रूप में प्रदान करते हैं।

हम वैकल्पिक रूप से एक दूसरा तर्क पारित कर सकते हैं, जो शुरू करने के लिए एक पथ निर्दिष्ट करता है। जब हम ऐसा करते हैं, json_each() उस पथ को शीर्ष-स्तरीय तत्व के रूप में मानता है।

json_each() फ़ंक्शन केवल शीर्ष-स्तरीय सरणी या ऑब्जेक्ट के तत्काल बच्चों को चलता है, या केवल शीर्ष-स्तरीय तत्व ही चलता है यदि शीर्ष-स्तरीय तत्व एक आदिम मान है। JSON सबस्ट्रक्चर के माध्यम से पुनरावर्ती रूप से चलने के लिए, json_tree() . का उपयोग करें इसके बजाय।

सिंटैक्स

हम निम्नलिखित तरीकों से फ़ंक्शन का उपयोग कर सकते हैं:

json_each(X)
json_each(X,P)

जहां X JSON का प्रतिनिधित्व करता है, और P एक वैकल्पिक तर्क है जो शीर्ष-स्तर के रूप में व्यवहार करने के पथ का प्रतिनिधित्व करता है।

उदाहरण

यह कैसे काम करता है यह दिखाने के लिए यहां एक उदाहरण दिया गया है:

SELECT * FROM json_each('{ "name" : "Woof", "age" : 10 }');

परिणाम:

+------+-------+---------+------+----+--------+---------+------+
| key  | value |  type   | atom | id | parent | fullkey | path |
+------+-------+---------+------+----+--------+---------+------+
| name | Woof  | text    | Woof | 2  | null   | $.name  | $    |
| age  | 10    | integer | 10   | 4  | null   | $.age   | $    |
+------+-------+---------+------+----+--------+---------+------+

हम देख सकते हैं कि प्रत्येक ऑब्जेक्ट सदस्य की कुछ उपयोगी जानकारी के साथ अपनी पंक्ति होती है, जैसे कि उसका प्रकार (एसक्यूएल टेक्स्ट वैल्यू), पथ इत्यादि।

id के बारे में कॉलम, SQLite दस्तावेज़ीकरण के अनुसार यह एक आंतरिक हाउसकीपिंग नंबर है, जिसकी गणना भविष्य के रिलीज में बदल सकती है। केवल गारंटी है कि id कॉलम हर पंक्ति के लिए अलग होगा।

पैरेंट कॉलम हमेशा null होता है कॉल करते समय json_each() . json_tree() . का उपयोग करते समय यह कॉलम अधिक अर्थपूर्ण हो जाता है ।

सरणी

इस उदाहरण में, JSON मान एक सरणी है:

SELECT * FROM json_each('[ 10, 30, 45 ]');

परिणाम:

+-----+-------+---------+------+----+--------+---------+------+
| key | value |  type   | atom | id | parent | fullkey | path |
+-----+-------+---------+------+----+--------+---------+------+
| 0   | 10    | integer | 10   | 1  | null   | $[0]    | $    |
| 1   | 30    | integer | 30   | 2  | null   | $[1]    | $    |
| 2   | 45    | integer | 45   | 3  | null   | $[2]    | $    |
+-----+-------+---------+------+----+--------+---------+------+

पथ निर्दिष्ट करें

हम शीर्ष-स्तर के रूप में व्यवहार करने के लिए पथ निर्दिष्ट करने के लिए दूसरे तर्क का उपयोग कर सकते हैं।

उदाहरण:

SELECT * FROM json_each('{ "a" : 1, "b" : [ 4, 7, 8 ] }', '$.b');

परिणाम:

+-----+-------+---------+------+----+--------+---------+------+
| key | value |  type   | atom | id | parent | fullkey | path |
+-----+-------+---------+------+----+--------+---------+------+
| 0   | 4     | integer | 4    | 5  | null   | $.b[0]  | $.b  |
| 1   | 7     | integer | 7    | 6  | null   | $.b[1]  | $.b  |
| 2   | 8     | integer | 8    | 7  | null   | $.b[2]  | $.b  |
+-----+-------+---------+------+----+--------+---------+------+

बड़ा दस्तावेज़

इस उदाहरण में हम एक बड़े JSON दस्तावेज़ का उपयोग करेंगे। सबसे पहले, json_each() पर कॉल करें पथ निर्दिष्ट किए बिना:

SELECT * FROM json_each('[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]'
    );

परिणाम:

+-----+----------------------------------------------+--------+------+----+--------+---------+------+
| key |                    value                     |  type  | atom | id | parent | fullkey | path |
+-----+----------------------------------------------+--------+------+----+--------+---------+------+
| 0   | {"user":"Spike","age":30,"scores":[9,7,3]}   | object | N/A  | 1  | N/A    | $[0]    | $    |
| 1   | {"user":"Faye","age":25,"scores":[90,87,93]} | object | N/A  | 11 | N/A    | $[1]    | $    |
| 2   | {"user":"Jet","age":40,"scores":[50,38,67]}  | object | N/A  | 21 | N/A    | $[2]    | $    |
+-----+----------------------------------------------+--------+------+----+--------+---------+------+

इस मामले में, हमारा JSON मान एक सरणी है जिसमें तीन ऑब्जेक्ट होते हैं। प्रत्येक वस्तु परिणामों में सूचीबद्ध है।

अब, json_each() पर कॉल करें फिर से, लेकिन इस बार हम एक पथ निर्दिष्ट करेंगे:

SELECT * FROM json_each('[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]',
        '$[1]'
    );

परिणाम:

+--------+------------+---------+------+----+--------+-------------+------+
|  key   |   value    |  type   | atom | id | parent |   fullkey   | path |
+--------+------------+---------+------+----+--------+-------------+------+
| user   | Faye       | text    | Faye | 13 | null   | $[1].user   | $[1] |
| age    | 25         | integer | 25   | 15 | null   | $[1].age    | $[1] |
| scores | [90,87,93] | array   | null | 17 | null   | $[1].scores | $[1] |
+--------+------------+---------+------+----+--------+-------------+------+

इस मामले में मैंने [1] . निर्दिष्ट करके दूसरा सरणी तत्व चुना है (सरणी SQLite में शून्य आधारित हैं)।

नतीजा यह है कि आउटपुट में दूसरे सरणी तत्व के बारे में जानकारी होती है।

इस बार हम देख सकते हैं कि path कॉलम में $[1] . है ।

आइए गहराई में जाएं:

SELECT * FROM json_each('[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]',
        '$[1].scores'
    );

परिणाम:

+-----+-------+---------+------+----+--------+----------------+-------------+
| key | value |  type   | atom | id | parent |    fullkey     |    path     |
+-----+-------+---------+------+----+--------+----------------+-------------+
| 0   | 90    | integer | 90   | 18 | null   | $[1].scores[0] | $[1].scores |
| 1   | 87    | integer | 87   | 19 | null   | $[1].scores[1] | $[1].scores |
| 2   | 93    | integer | 93   | 20 | null   | $[1].scores[2] | $[1].scores |
+-----+-------+---------+------+----+--------+----------------+-------------+

अब हमें scores . में प्रत्येक तत्व के लिए एक पंक्ति मिलती है सरणी।

क्वेरी को फ़िल्टर करना

हम दिए गए मानदंड के आधार पर परिणामों को फ़िल्टर करने के लिए अपनी क्वेरी को संशोधित कर सकते हैं। उदाहरण के लिए:

SELECT 
    fullkey, 
    value 
FROM json_each('[
        { 
        "user" : "Spike",
        "age" : 30,
        "scores" : [ 9, 7, 3 ]
        },
        { 
        "user" : "Faye",
        "age" : 25,
        "scores" : [ 90, 87, 93 ]
        },
        { 
        "user" : "Jet",
        "age" : 40,
        "scores" : [ 50, 38, 67 ]
        }
        ]'
    )
WHERE json_each.value LIKE '%Faye%';

परिणाम:

+---------+----------------------------------------------+
| fullkey |                    value                     |
+---------+----------------------------------------------+
| $[1]    | {"user":"Faye","age":25,"scores":[90,87,93]} |
+---------+----------------------------------------------+

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

मान लीजिए हमारे पास निम्न तालिका है:

SELECT * FROM guests;

परिणाम:

+-------+--------------------------------------------------+
| guest |                      lunch                       |
+-------+--------------------------------------------------+
| Zohan | ["Beef Pie", "Fruit Salad", "Apple Juice"]       |
| Amy   | ["Vegetable Quiche", "Apple", "Fruit Juice"]     |
| Rohit | ["Beef Curry", "Dragonfruit", "Vegetable Juice"] |
| Igor  | ["Chicken Pie", "Jackfruit", "Fruit Juice"]      |
| Stacy | ["Chicken Curry", "Fruit Salad", "Apple Juice"]  |
| Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"]    |
+-------+--------------------------------------------------+

इस तालिका को guests . कहा जाता है दो कॉलम हैं। पहले कॉलम में गेस्ट का नाम होता है और दूसरे कॉलम में उनका लंच ऑर्डर होता है। वे दोपहर के भोजन के लिए तीन व्यंजन ऑर्डर कर सकते हैं। उनका लंच ऑर्डर एक ऐरे के रूप में होता है, जहां हर डिश ऐरे में एक एलिमेंट होता है।

यहां एक क्वेरी चलाने का एक उदाहरण दिया गया है जिसमें json_each() शामिल है इस तालिका के विरुद्ध:

SELECT DISTINCT
    guest,
    lunch
FROM 
    guests, 
    json_each(lunch)
WHERE json_each.value LIKE 'Apple Juice';

परिणाम:

+-------+-------------------------------------------------+
| guest |                      lunch                      |
+-------+-------------------------------------------------+
| Zohan | ["Beef Pie", "Fruit Salad", "Apple Juice"]      |
| Stacy | ["Chicken Curry", "Fruit Salad", "Apple Juice"] |
| Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"]   |
+-------+-------------------------------------------------+

यहां, हमने उन सभी मेहमानों को लौटा दिया, जिन्होंने दोपहर के भोजन के साथ सेब का जूस ऑर्डर किया था, साथ ही लंच का पूरा ऑर्डर भी दिया था।

अगर हम उन सभी मेहमानों को वापस करना चाहते हैं जिन्होंने सेब "कुछ" ऑर्डर किया है, तो हम ऐसा कर सकते हैं:

SELECT
    guest,
    lunch
FROM 
    guests, 
    json_each(lunch)
WHERE json_each.value LIKE 'Apple%';

परिणाम:

+-------+-------------------------------------------------+
| guest |                      lunch                      |
+-------+-------------------------------------------------+
| Zohan | ["Beef Pie", "Fruit Salad", "Apple Juice"]      |
| Amy   | ["Vegetable Quiche", "Apple", "Fruit Juice"]    |
| Stacy | ["Chicken Curry", "Fruit Salad", "Apple Juice"] |
| Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"]   |
+-------+-------------------------------------------------+

ध्यान दें कि मैंने DISTINCT . का उपयोग किया है मेरी क्वेरी में खंड। यह सुनिश्चित करता है कि हमें एक ही अतिथि के लिए कई पंक्तियाँ वापस नहीं मिलेंगी। मेरा क्या मतलब है, यह दिखाने के लिए, यहां फिर से क्वेरी है, लेकिन DISTINCT . के बिना खंड:

SELECT
    guest,
    lunch
FROM 
    guests, 
    json_each(lunch)
WHERE json_each.value LIKE 'Apple%';

परिणाम:

+-------+-------------------------------------------------+
| guest |                      lunch                      |
+-------+-------------------------------------------------+
| Zohan | ["Beef Pie", "Fruit Salad", "Apple Juice"]      |
| Amy   | ["Vegetable Quiche", "Apple", "Fruit Juice"]    |
| Stacy | ["Chicken Curry", "Fruit Salad", "Apple Juice"] |
| Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"]   |
| Aisha | ["Chicken Curry", "Apple Pie", "Apple Juice"]   |
+-------+-------------------------------------------------+

इस बार आयशा दो बार नजर आई। ऐसा इसलिए है क्योंकि उसने दोपहर के भोजन के लिए सेब के दो व्यंजन ऑर्डर किए - सेब पाई और सेब का रस।