SQLite में

-> और ->> ऑपरेटरों को SQLite संस्करण 3.38.0 में पेश किया गया था, जो 22 फरवरी 2022 को जारी किया गया था। दोनों ऑपरेटरों का उपयोग JSON के उप-घटकों को निकालने के लिए किया जाता है। लेकिन उनके बीच एक सूक्ष्म अंतर है।

अंतर

इन ऑपरेटरों के बीच का अंतर इस प्रकार है:

• द -> ऑपरेटर हमेशा एक JSON लौटाता है निर्दिष्ट उपघटक का प्रतिनिधित्व
• द ->> ऑपरेटर हमेशा एक SQL लौटाता है निर्दिष्ट उपघटक का प्रतिनिधित्व

उदाहरण

यहां एक उदाहरण दिया गया है जो इन दो ऑपरेटरों के बीच अंतर को दर्शाता है:

SELECT 
    '{ "name" : "Wag", "type" : "Dog" }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : "Dog" }' ->> '$.type' AS "->>";

परिणाम:

+-------+-----+
|  ->   | ->> |
+-------+-----+
| "Dog" | Dog |
+-------+-----+

हम देख सकते हैं कि -> डबल कोट्स में संलग्न मान लौटा दिया जबकि ->> नहीं किया।

ऐसा इसलिए है क्योंकि -> मान का JSON प्रतिनिधित्व लौटाया, और ->> एक SQL प्रतिनिधित्व लौटाया।

नंबर

यहां एक उदाहरण दिया गया है जो संख्याओं का उपयोग करता है:

SELECT 
    '{ "age" : 10 }' -> '$.age' AS "->",
    '{ "age" : 10 }' ->> '$.age' AS "->>";

परिणाम:

+----+-----+
| -> | ->> |
+----+-----+
| 10 | 10  |
+----+-----+

यहाँ क्या होता है जब हम typeof() . का उपयोग करते हैं SQL प्रकार प्राप्त करने के लिए कार्य करें:

SELECT 
    typeof('{ "age" : 10 }' -> '$.age') AS "->",
    typeof('{ "age" : 10 }' ->> '$.age') AS "->>";

परिणाम:

+------+---------+
|  ->  |   ->>   |
+------+---------+
| text | integer |
+------+---------+

हालांकि, अगर हम json_type() . का उपयोग करते हैं , हमें JSON प्रकार मिलेगा:

SELECT 
    json_type('{ "age" : 10 }' -> '$.age') AS "->",
    json_type('{ "age" : 10 }' ->> '$.age') AS "->>";

परिणाम:

+---------+---------+
|   ->    |   ->>   |
+---------+---------+
| integer | integer |
+---------+---------+

यहां एक उदाहरण दिया गया है जो वास्तविक संख्या का उपयोग करता है:

SELECT 
    typeof('{ "age" : 1.2 }' -> '$.age') AS "->",
    typeof('{ "age" : 1.2 }' ->> '$.age') AS "->>";

परिणाम:

+------+------+
|  ->  | ->>  |
+------+------+
| text | real |
+------+------+

और json_type() . के साथ :

SELECT 
    json_type('{ "age" : 1.2 }' -> '$.age') AS "->",
    json_type('{ "age" : 1.2 }' ->> '$.age') AS "->>";

परिणाम:

+------+------+
|  ->  | ->>  |
+------+------+
| real | real |
+------+------+

शून्य मान

यदि JSON दस्तावेज़ में null शामिल है , फिर -> शून्य का JSON प्रतिनिधित्व लौटाएगा, और ->> बस एक शून्य मान लौटाएगा।

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

SELECT 
    '{ "name" : "Wag", "type" : null }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : null }' ->> '$.type' AS "->>";

परिणाम:

+------+-----+
|  ->  | ->> |
+------+-----+
| null |     |
+------+-----+

डिफ़ॉल्ट रूप से, SQLite कमांड लाइन इंटरफ़ेस (CLI) जब भी शून्य मान लौटाता है तो खाली स्ट्रिंग देता है। तो हम अपने उदाहरण से देख सकते हैं कि -> वास्तविक JSON मान शून्य लौटा दिया, जबकि ->> एक वास्तविक शून्य मान लौटाया।

इसे और अधिक प्रदर्शित करने के लिए, हम अपना .nullvalue . सेट कर सकते हैं खाली स्ट्रिंग के अलावा किसी और चीज़ के लिए:

.nullvalue n/a

अब पिछली क्वेरी को फिर से चलाते हैं:

SELECT 
    '{ "name" : "Wag", "type" : null }' -> '$.type' AS "->",
    '{ "name" : "Wag", "type" : null }' ->> '$.type' AS "->>";

परिणाम:

+------+-----+
|  ->  | ->> |
+------+-----+
| null | n/a |
+------+-----+

इस बार n/a ->> . के लिए आउटपुट था खाली स्ट्रिंग के बजाय ऑपरेटर।

और यहाँ क्या होता है जब हम आउटपुट को typeof() . पर पास करते हैं और json_type() कार्य:

SELECT 
    typeof('{ "name" : "Wag", "type" : null }' -> '$.type') AS "->",
    typeof('{ "name" : "Wag", "type" : null }' ->> '$.type') AS "->>";

SELECT 
    json_type('{ "name" : "Wag", "type" : null }' -> '$.type') AS "->",
    json_type('{ "name" : "Wag", "type" : null }' ->> '$.type') AS "->>";

परिणाम:

+------+------+
|  ->  | ->>  |
+------+------+
| text | null |
+------+------+
+------+-----+
|  ->  | ->> |
+------+-----+
| null | n/a |
+------+-----+

एक वैकल्पिक:json_extract()

SQLite में JSON दस्तावेज़ से मान निकालने का दूसरा तरीका json_extract() का उपयोग करना है समारोह। यह फ़ंक्शन -> . से थोड़ा अलग तरीके से काम करता है और ->> उसमें वापसी का प्रकार संदर्भ पर निर्भर करता है।

json_extract() फ़ंक्शन केवल JSON देता है यदि दो या अधिक पथ तर्क हैं (क्योंकि परिणाम तब एक JSON सरणी है) या यदि एकल पथ तर्क किसी सरणी या ऑब्जेक्ट को संदर्भित करता है।

यदि केवल एक पथ तर्क है और वह पथ JSON नल या स्ट्रिंग या संख्यात्मक मान को संदर्भित करता है, तो json_extract() संबंधित SQL NULL, TEXT, INTEGER, या REAL मान लौटाता है।