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

मारियाडीबी में, JSON_TABLE() एक अंतर्निहित फ़ंक्शन है जो JSON डेटा को एक संबंधपरक रूप में परिवर्तित करता है।

दूसरे शब्दों में, यह आपको एक JSON दस्तावेज़ को तालिका के रूप में वापस करने देता है।

JSON_TABLE() मारियाडीबी 10.6.0 में फ़ंक्शन पेश किया गया था।

सिंटैक्स

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

JSON_TABLE(json_doc, 
          context_path COLUMNS (column_list)
) [AS] alias

जहां column_list इस तरह जाता है:

column[, column][, ...]

जहां कॉलम इस तरह जाता है:

name FOR ORDINALITY
    |  name type PATH value_path path [on_empty] [on_error]
    |  name type EXISTS PATH value_path
    |  NESTED [PATH] path COLUMNS (column_list)

जहां पर_खाली इस तरह जाता है:

{NULL | DEFAULT string | ERROR} ON EMPTY

और on_error इस तरह जाता है:

{NULL | DEFAULT string | ERROR} ON ERROR

उदाहरण

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

SET @json_document = '
[
    { "name": "Wag", "type": "Dog", "weight": 20 },
    { "name": "Bark", "type": "Dog", "weight": 10 },
    { "name": "Meow", "type": "Cat", "weight": 7 }
]
';

SELECT * FROM JSON_TABLE(@json_document, '$[*]'
    COLUMNS (
    name VARCHAR(255) PATH '$.name', 
    type VARCHAR(50) PATH '$.type',
    weight INT PATH '$.weight' 
    )
) AS json_table;

परिणाम:

+------+------+--------+
| name | type | weight |
+------+------+--------+
| Wag  | Dog  |     20 |
| Bark | Dog  |     10 |
| Meow | Cat  |      7 |
+------+------+--------+

यहां, हम तालिका के लिए प्रत्येक कॉलम को नाम देते हैं, उसके डेटा प्रकार को निर्दिष्ट करते हैं, और फिर उस कॉलम पर लागू होने वाले JSON दस्तावेज़ से पथ निर्दिष्ट करते हैं।

इसलिए, हमने अपना पहला कॉलम name . कहा , और फिर name . नामक नोड को मैप किया JSON दस्तावेज़ से उस कॉलम तक।

साधारण कॉलम

ऑर्डिनैलिटी के लिए 1 . से शुरू करके पंक्तियों को गिनने के लिए विकल्प का उपयोग किया जा सकता है ।

SET @json_document = '
[
    { "name": "Scratch", "type": "Cat", "weight": 8 },
    { "name": "Bruce", "type": "Kangaroo", "weight": 100 },
    { "name": "Hop", "type": "Kangaroo", "weight": 130 }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
    COLUMNS (
    id FOR ORDINALITY,
    name VARCHAR(255) PATH '$.name', 
    type VARCHAR(50) PATH '$.type',
    weight INT PATH '$.weight' 
    )
) AS json_table;

परिणाम:

+------+---------+----------+--------+
| id   | name    | type     | weight |
+------+---------+----------+--------+
|    1 | Scratch | Cat      |      8 |
|    2 | Bruce   | Kangaroo |    100 |
|    3 | Hop     | Kangaroo |    130 |
+------+---------+----------+--------+

पथ के अस्तित्व की जांच करना

आप EXISTS . का उपयोग कर सकते हैं पथ के अस्तित्व की जाँच करने के लिए खंड। यदि पथ JSON दस्तावेज़ में मौजूद है, तो परिणाम 1 . है . अगर यह मौजूद नहीं है, तो 0 लौटा दिया गया है।

SET @json_document = '
[
    { "name": "Punch", "type": "Kangaroo", "weight": 200 },
    { "name": "Snap", "type": "Cat", "weight": 12 },
    { "name": "Ruff", "type": "Dog" }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
    COLUMNS (
    name  VARCHAR(255) PATH '$.name', 
    type VARCHAR(50) PATH '$.type',
    has_weight INT EXISTS PATH '$.weight' 
    )
) AS json_table;

परिणाम:

+-------+----------+------------+
| name  | type     | has_weight |
+-------+----------+------------+
| Punch | Kangaroo |          1 |
| Snap  | Cat      |          1 |
| Ruff  | Dog      |          0 |
+-------+----------+------------+

नेस्टेड पथ

नेस्टेड पथ क्लॉज आपको नेस्टेड JSON दस्तावेज़ों से निपटने की अनुमति देता है। जब आप इस क्लॉज का इस्तेमाल करते हैं, तो यह नेस्टेड JSON स्ट्रक्चर को कई पंक्तियों में बदल देता है।

उदाहरण:

SET @json_document = '
[
    { "product": "Left Handed Screwdriver", "sizes": [ "S", "M", "L" ] },
    { "product": "Long Weight", "sizes": [ "S", "L", "XL" ] },
    { "product": "Bottomless Coffee Cup" }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
    COLUMNS (
    product  VARCHAR(255) PATH '$.product', 
    NESTED PATH '$.sizes[*]' columns (
        size VARCHAR(2) PATH '$'
        )
    )
) AS json_table;

परिणाम:

+-------------------------+------+
| product                 | size |
+-------------------------+------+
| Left Handed Screwdriver | S    |
| Left Handed Screwdriver | M    |
| Left Handed Screwdriver | L    |
| Long Weight             | S    |
| Long Weight             | L    |
| Long Weight             | XL   |
| Bottomless Coffee Cup   | NULL |
+-------------------------+------+

खाली रास्तों से निपटना

खाली पर क्लॉज निर्दिष्ट करता है कि क्या किया जाएगा जब खोज पथ द्वारा निर्दिष्ट तत्व JSON दस्तावेज़ में अनुपलब्ध है।

उदाहरण:

SET @json_document = '
[
    { "name": "Punch", "type": "Kangaroo", "weight": 200 },
    { "name": "Snap", "type": "Cat", "weight": 12 },
    { "name": "Ruff"}
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
    COLUMNS (
    name  VARCHAR(255) PATH '$.name', 
    type VARCHAR(50) PATH '$.type' DEFAULT "N/A" ON EMPTY,
    weight INT PATH '$.weight'
    )
) AS json_table;

परिणाम:

+-------+----------+--------+
| name  | type     | weight |
+-------+----------+--------+
| Punch | Kangaroo |    200 |
| Snap  | Cat      |     12 |
| Ruff  | N/A      |   NULL |
+-------+----------+--------+

इस उदाहरण में, रफ़ कोई प्रकार फ़ील्ड नहीं है और इसलिए N/A वापस किया जाता है। ऐसा इसलिए है क्योंकि मैंने निर्दिष्ट किया है कि खाली पर उस क्षेत्र के लिए खंड।

त्रुटियों से निपटना

त्रुटि पर क्लॉज निर्दिष्ट करता है कि यदि दस्तावेज़ से मान निकालने का प्रयास करते समय JSON संरचना त्रुटि होती है तो क्या किया जाना चाहिए।

JSON संरचना त्रुटि केवल तब होती है जब आप JSON गैर-स्केलर (सरणी या ऑब्जेक्ट) को स्केलर मान में बदलने का प्रयास करते हैं। जब त्रुटि पर क्लॉज मौजूद नहीं है, नल ऑन एरर निहित है।

JSON संरचना त्रुटि को संभालने का एक उदाहरण यहां दिया गया है:

SET @json_document = '
[
    { "product": "Left Handed Screwdriver", "sizes": [ "S", "M", "L" ] },
    { "product": "Long Weight", "sizes": [ "S", "L", "XL" ] },
    { "product": "Bottomless Coffee Cup" }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
    COLUMNS (
    product  VARCHAR(255) PATH '$.product', 
    sizes VARCHAR(5) PATH '$.sizes' 
        DEFAULT 'Oops!' ON ERROR
        DEFAULT 'None' ON EMPTY
    )
) AS json_table;

परिणाम:

+-------------------------+-------+
| product                 | sizes |
+-------------------------+-------+
| Left Handed Screwdriver | Oops! |
| Long Weight             | Oops! |
| Bottomless Coffee Cup   | None  |
+-------------------------+-------+

यहाँ, मैंने एक स्ट्रिंग निर्दिष्ट की है (ओह! ) JSON संरचना त्रुटि होने पर उपयोग करने के लिए।

इस मामले में, मैंने खाली पर . भी शामिल किया है खंड। यह दर्शाता है कि दोनों ON ERROR और खाली पर खंड का उपयोग उसी कथन में किया जा सकता है।

हालांकि, यह ध्यान रखना महत्वपूर्ण है कि एक डेटाटाइप रूपांतरण त्रुटि (उदाहरण के लिए, एक गैर-पूर्णांक मान को एक पूर्णांक फ़ील्ड में संग्रहीत करने का प्रयास, या एक वर्चर कॉलम छोटा किया जा रहा है) को JSON त्रुटि नहीं माना जाता है और इसलिए यह <कोड को ट्रिगर नहीं करेगा>त्रुटि पर खंड। इसके बजाय, यह चेतावनियाँ देगा।

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

SET @json_document = '
[
    { "name": "Punch", "type": "Kangaroo" },
    { "name": "Snap", "type": "Cat" },
    { "name": "Ruff", "type": "Dog" }
]
';
SELECT * FROM JSON_TABLE(@json_document, '$[*]'
    COLUMNS (
    name  VARCHAR(255) PATH '$.name', 
    type INT PATH '$.type' DEFAULT 'Oops!' ON ERROR
    )
) AS json_table;

परिणाम:

+-------+------+
| name  | type |
+-------+------+
| Punch |    0 |
| Snap  |    0 |
| Ruff  |    0 |
+-------+------+
3 rows in set, 3 warnings (0.000 sec)

आइए चेतावनियां दिखाएं:

SHOW WARNINGS;

परिणाम:

+---------+------+---------------------------------------------------------------------------------+
| Level   | Code | Message                                                                         |
+---------+------+---------------------------------------------------------------------------------+
| Warning | 1366 | Incorrect integer value: 'Kangaroo' for column ``.`(temporary)`.`type` at row 1 |
| Warning | 1366 | Incorrect integer value: 'Cat' for column ``.`(temporary)`.`type` at row 2      |
| Warning | 1366 | Incorrect integer value: 'Dog' for column ``.`(temporary)`.`type` at row 3      |
+---------+------+---------------------------------------------------------------------------------+