PostgreSQL के भीतर JSON क्षमताओं का अवलोकन

JSON क्या है?

JSON का अर्थ "जावास्क्रिप्ट ऑब्जेक्ट नोटेशन" है जो एक प्रकार का डेटा प्रारूप है जो वेब अनुप्रयोगों द्वारा लोकप्रिय रूप से उपयोग किया जाता है। इसका मतलब है, डेटा को वेब एप्लिकेशन और सर्वर के बीच इस तरह के प्रारूप में प्रसारित किया जाएगा। JSON को XML प्रारूप के विकल्प के रूप में पेश किया गया था। "अच्छे पुराने दिनों" में डेटा एक्सएमएल प्रारूप में प्रसारित होता था जो जेएसओएन की तुलना में भारी वजन डेटा प्रकार होता है। नीचे JSON स्वरूपित स्ट्रिंग का एक उदाहरण है:

{ "ID":"001","name": "Ven", "Country": "Australia",  "city": "Sydney", "Job Title":"Database Consultant"}

एक JSON स्ट्रिंग में एक अन्य JSON ऑब्जेक्ट हो सकता है, जैसा कि नीचे दिखाया गया है:

{ "ID":"001", "name": "Ven", "Job Title":"Database Consultant", "Location":{"Suburb":"Dee Why","city": "Sydney","State":"NSW","Country": "Australia"}}

आधुनिक दिन वेब और मोबाइल एप्लिकेशन ज्यादातर JSON प्रारूप में डेटा उत्पन्न करते हैं, जिसे "JSON बाइट्स" भी कहा जाता है, जिसे एप्लिकेशन सर्वर द्वारा उठाया जाता है और डेटाबेस में भेजा जाता है। JSON बाइट्स को बारी-बारी से संसाधित किया जाता है, अलग-अलग कॉलम मानों में विभाजित किया जाता है और एक RDBMS तालिका में डाला जाता है।
उदाहरण:

{ "ID":"001","name": "Ven", "Country": "Australia",  "city": "Sydney", "Job Title":"Database Consultant"}

ऊपर की तरह JSON डेटा को नीचे की तरह SQL में बदल दिया जाता है..

Insert into test (id, name, country,city,job_title) values  (001,'Ven','Australia','Sydney','Database Consultant');

जब JSON डेटा को संग्रहीत और संसाधित करने की बात आती है, तो इसका समर्थन करने वाले विभिन्न NoSQL डेटाबेस हैं और सबसे लोकप्रिय एक MongoDB है। जब आरडीबीएमएस डेटाबेस की बात आती है, हाल के दिनों तक, JSON स्ट्रिंग्स को सामान्य टेक्स्ट के रूप में माना जाता था और कोई डेटा प्रकार नहीं था जो विशेष रूप से JSON प्रारूप स्ट्रिंग्स को पहचानता, संग्रहीत या संसाधित करता था। PostgreSQL, सबसे लोकप्रिय ओपन-सोर्स RDBMS डेटाबेस JSON डेटा-प्रकार के साथ आया है, जो JSON डेटा को संभालने के लिए प्रदर्शन, कार्यक्षमता और मापनीयता के लिए अत्यधिक फायदेमंद साबित हुआ है।

PostgreSQL + JSON

JSON डेटा-प्रकार पेश किए जाने के बाद से PostgreSQL डेटाबेस अधिक से अधिक लोकप्रिय हो गया है। वास्तव में, जब JSON डेटा की एक बड़ी मात्रा को संसाधित करने की बात आती है, तो PostgreSQL MongoDB से बेहतर प्रदर्शन कर रहा है। एप्लिकेशन JSON स्ट्रिंग्स को PostgreSQL डेटाबेस में मानक JSON प्रारूप में संग्रहीत कर सकते हैं। डेवलपर्स को केवल JSON स्ट्रिंग्स को डेटाबेस में एक json डेटा-प्रकार के रूप में भेजने और JSON प्रारूप में वापस प्राप्त करने के लिए एप्लिकेशन को बताने की आवश्यकता है। JSON डेटा-प्रकार में JSON स्ट्रिंग को संग्रहीत करना टेक्स्ट डेटा-प्रकार में संग्रहीत करने की तुलना में कई फायदेमंद है। JSON डेटा-प्रकार केवल मान्य JSON स्वरूपित स्ट्रिंग्स को स्वीकार कर सकता है, यदि स्ट्रिंग सही JSON प्रारूप में नहीं है, तो एक त्रुटि उत्पन्न होती है। JSON डेटा-प्रकार एप्लिकेशन को कुशल और अनुक्रमणिका आधारित खोज करने में मदद करता है, जिसे हम जल्द ही विस्तार से देखेंगे।

JSON डेटा-प्रकार को PostgreSQL-9.2 पोस्ट में पेश किया गया था, जिसमें महत्वपूर्ण संवर्द्धन किए गए थे। JSONB डेटा-टाइप को जोड़ने के साथ PostgreSQL-9.4 में प्रमुख जोड़ आया। JSONB JSON डेटा-प्रकार का एक उन्नत संस्करण है जो JSON डेटा को बाइनरी प्रारूप में संग्रहीत करता है। यह प्रमुख वृद्धि है जिसने पोस्टग्रेएसक्यूएल में जेएसओएन डेटा की खोज और संसाधित करने के तरीके में बड़ा अंतर डाला। आइए JSON डेटा प्रकारों के लाभों पर एक विस्तृत नज़र डालें।

JSON और JSONB डेटा प्रकार

JSON डेटा-प्रकार एक पाठ के रूप में json स्वरूपित स्ट्रिंग्स को संग्रहीत करता है जो बहुत शक्तिशाली नहीं है और खोजों के लिए उपयोग किए जाने वाले कई JSON संबंधित कार्यों का समर्थन नहीं करता है। यह केवल पारंपरिक बी-ट्री इंडेक्सिंग का समर्थन करता है और अन्य इंडेक्स प्रकारों का समर्थन नहीं करता है जो जेएसओएन डेटा में तेज और कुशल खोज संचालन के लिए अनिवार्य हैं।

JSONB, JSON डेटा प्रकार का उन्नत संस्करण, JSON दस्तावेज़ों को संग्रहीत और संसाधित करने के लिए अत्यधिक अनुशंसित है। यह जेसन ऑपरेटरों की एक विस्तृत श्रृंखला का समर्थन करता है और जेएसओएन पर कई फायदे हैं, जैसे बाइनरी प्रारूप में जेएसओएन प्रारूपित स्ट्रिंग्स को स्टोर करना, और कुशल खोजों को करने के लिए जेएसओएन फ़ंक्शंस और इंडेक्सिंग का समर्थन करना।

आइए मतभेदों को देखें।

	JSON	JSONB
1	काफी हद तक एक टेक्स्ट डेटा प्रकार की तरह है जो केवल वैध JSON दस्तावेज़ संग्रहीत करता है।	JSON दस्तावेज़ों को बाइनरी प्रारूप में संग्रहीत करता है।
2	JSON दस्तावेज़ों को सफेद रिक्त स्थान सहित-जैसे संग्रहीत करता है।	सफेद रिक्त स्थान और स्टोर को तेज और कुशल खोजों के लिए अनुकूल प्रारूप में ट्रिम करता है
3	पूर्ण-पाठ-खोज अनुक्रमण का समर्थन नहीं करता	पूर्ण-पाठ-खोज अनुक्रमण का समर्थन करता है
4	JSON फ़ंक्शंस और ऑपरेटरों की विस्तृत श्रृंखला का समर्थन नहीं करता	सभी JSON फ़ंक्शन और ऑपरेटरों का समर्थन करता है

ऊपर सूचीबद्ध #4 के लिए उदाहरण

JSON

नीचे JSON डेटा प्रकार वाली एक तालिका है

dbt3=# \d product
                   Table "dbt3.product"
     Column     |  Type  | Collation | Nullable | Default
----------------+--------+-----------+----------+---------
 item_code      | bigint |           | not null |
 productdetails | json   |           |          |
Indexes:
    "product_pkey" PRIMARY KEY, btree (item_code)

पारंपरिक JSON ऑपरेटरों (जैसे "@>" या "#>") का समर्थन नहीं करता है। JSON डेटा के माध्यम से पूर्ण-पाठ-खोज एक SQL में "@>" या "#>" का उपयोग करके की जाती है जो JSON डेटा प्रकार द्वारा समर्थित नहीं है

dbt3=# select * from product where productdetails @> '{"l_shipmode":"AIR"}' and productdetails @> '{"l_quantity":"27"}';
ERROR:  operator does not exist: json @> unknown
LINE 1: select * from product where productdetails @> '{"l_shipmode"...
                                                   ^
HINT:  No operator matches the given name and argument types. You might need to add explicit type casts.
dbt3=#

JSONB

नीचे JSONB डेटा प्रकार वाली एक तालिका है

dbt3=# \d products
                  Table "dbt3.products"
    Column     |  Type  | Collation | Nullable | Default
---------------+--------+-----------+----------+---------
 item_code     | bigint |           | not null |
 order_details | jsonb  |           |          |
Indexes:
    "products_pkey" PRIMARY KEY, btree (item_code)

ऑपरेटरों का उपयोग करके JSON डेटा के माध्यम से पूर्ण-पाठ-खोज का समर्थन करता है (जैसे "@>")

dbt3=# select * from products where order_details @> '{"l_shipmode" : "AIR"}' limit 2;
 item_code |                                                                                        order_details
-----------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
         4 | {"l_partkey": 21315, "l_orderkey": 1, "l_quantity": 28, "l_shipdate": "1996-04-21", "l_shipmode": "AIR", "l_commitdate": "1996-03-30", "l_shipinstruct": "NONE", "l_extendedprice": 34616.7}
         8 | {"l_partkey": 42970, "l_orderkey": 3, "l_quantity": 45, "l_shipdate": "1994-02-02", "l_shipmode": "AIR", "l_commitdate": "1994-01-04", "l_shipinstruct": "NONE", "l_extendedprice": 86083.6}
(2 rows)

आज श्वेतपत्र डाउनलोड करें क्लस्टरकंट्रोल के साथ पोस्टग्रेएसक्यूएल प्रबंधन और स्वचालन इस बारे में जानें कि पोस्टग्रेएसक्यूएल को तैनात करने, मॉनिटर करने, प्रबंधित करने और स्केल करने के लिए आपको क्या जानना चाहिए। श्वेतपत्र डाउनलोड करें

JSON डेटा की क्वेरी कैसे करें

आइए डेटा संचालन से संबंधित कुछ PostgreSQL JSON क्षमताओं पर एक नज़र डालें, नीचे तालिका में JSON डेटा कैसा दिखता है। कॉलम “order_details” JSONB प्रकार का है

dbt3=# select * from product_details ;
 item_code |                                                                                                 order_details
-----------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
         1 | {"l_partkey": 1551894, "l_orderkey": 1, "l_quantity": 17, "l_shipdate": "1996-03-13", "l_shipmode": "TRUCK", "l_commitdate": "1996-02-12", "l_shipinstruct": "DELIVER IN PERSON", "l_extendedprice": 33078.9}
         2 | {"l_partkey": 673091, "l_orderkey": 1, "l_quantity": 36, "l_shipdate": "1996-04-12", "l_shipmode": "MAIL", "l_commitdate": "1996-02-28", "l_shipinstruct": "TAKE BACK RETURN", "l_extendedprice": 38306.2}
         3 | {"l_partkey": 636998, "l_orderkey": 1, "l_quantity": 8, "l_shipdate": "1996-01-29", "l_shipmode": "REG AIR", "l_commitdate": "1996-03-05", "l_shipinstruct": "TAKE BACK RETURN", "l_extendedprice": 15479.7}
         4 | {"l_partkey": 21315, "l_orderkey": 1, "l_quantity": 28, "l_shipdate": "1996-04-21", "l_shipmode": "AIR", "l_commitdate": "1996-03-30", "l_shipinstruct": "NONE", "l_extendedprice": 34616.7}
         5 | {"l_partkey": 240267, "l_orderkey": 1, "l_quantity": 24, "l_shipdate": "1996-03-30", "l_shipmode": "FOB", "l_commitdate": "1996-03-14", "l_shipinstruct": "NONE", "l_extendedprice": 28974}
         6 | {"l_partkey": 156345, "l_orderkey": 1, "l_quantity": 32, "l_shipdate": "1996-01-30", "l_shipmode": "MAIL", "l_commitdate": "1996-02-07", "l_shipinstruct": "DELIVER IN PERSON", "l_extendedprice": 44842.9}
         7 | {"l_partkey": 1061698, "l_orderkey": 2, "l_quantity": 38, "l_shipdate": "1997-01-28", "l_shipmode": "RAIL", "l_commitdate": "1997-01-14", "l_shipinstruct": "TAKE BACK RETURN", "l_extendedprice": 63066.3}
         8 | {"l_partkey": 42970, "l_orderkey": 3, "l_quantity": 45, "l_shipdate": "1994-02-02", "l_shipmode": "AIR", "l_commitdate": "1994-01-04", "l_shipinstruct": "NONE", "l_extendedprice": 86083.6}
         9 | {"l_partkey": 190355, "l_orderkey": 3, "l_quantity": 49, "l_shipdate": "1993-11-09", "l_shipmode": "RAIL", "l_commitdate": "1993-12-20", "l_shipinstruct": "TAKE BACK RETURN", "l_extendedprice": 70822.1}
        10 | {"l_partkey": 1284483, "l_orderkey": 3, "l_quantity": 27, "l_shipdate": "1994-01-16", "l_shipmode": "SHIP", "l_commitdate": "1993-11-22", "l_shipinstruct": "DELIVER IN PERSON", "l_extendedprice": 39620.3}
(10 rows)

उनके शिपमेंट तिथियों सहित सभी आइटम कोड चुनें

dbt3=# select item_code, order_details->'l_shipdate' as shipment_date from product_details ;

 item_code | shipment_date
-----------+---------------
         1 | "1996-03-13"
         2 | "1996-04-12"
         3 | "1996-01-29"
         4 | "1996-04-21"
         5 | "1996-03-30"
         6 | "1996-01-30"
         7 | "1997-01-28"
         8 | "1994-02-02"
         9 | "1993-11-09"
        10 | "1994-01-16"
(10 rows)

हवाई मार्ग से आने वाले सभी ऑर्डर का आइटम_कोड, मात्रा और मूल्य प्राप्त करें

dbt3=# select item_code, order_details->'l_quantity' as quantity, order_details->'l_extendedprice' as price, order_details->'l_shipmode' as price from product_details where order_details->>'l_shipmode'='AIR';

 item_code | quantity |  price  | price
-----------+----------+---------+-------
         4 | 28       | 34616.7 | "AIR"
         8 | 45       | 86083.6 | "AIR"
(2 rows)

JSON ऑपरेटरों "->" और "->>" का उपयोग SQL क्वेरी में चयन और तुलना के लिए किया जाता है। "->" ऑपरेटर JSON ऑब्जेक्ट फ़ील्ड को उद्धरणों में फ़ील्ड के रूप में देता है और ऑपरेटर "->>" JSON ऑब्जेक्ट फ़ील्ड को टेक्स्ट के रूप में देता है। उपरोक्त दो एसक्यूएल जेएसओएन फ़ील्ड मानों को प्रदर्शित करने के उदाहरण हैं। नीचे टेक्स्ट फॉर्म में JSON फ़ील्ड निकालने का उदाहरण दिया गया है।
नीचे JSON फ़ील्ड को टेक्स्ट के रूप में लाने का एक उदाहरण है

dbt3=# select item_code, order_details->>'l_shipdate' as shipment_date from product_details ;
 item_code | shipment_date
-----------+---------------
         1 | 1996-03-13
         2 | 1996-04-12
         3 | 1996-01-29
         4 | 1996-04-21
         5 | 1996-03-30
         6 | 1996-01-30
         7 | 1997-01-28
         8 | 1994-02-02
         9 | 1993-11-09
        10 | 1994-01-16
(10 rows)

"#>" नामक एक अन्य ऑपरेटर है जिसका उपयोग JSON तत्व के डेटा भाग को क्वेरी करने के लिए किया जाता है जो कि JSON स्ट्रिंग का इन-टर्न भाग है। आइए एक उदाहरण देखें।
नीचे तालिका में डेटा है।

dbt3=# select * from test_json ;
  id   |                                                                                                details
-------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 10000 | {"Job": "Database Consultant", "name": "Venkata", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Dee Why", "Country": "Australia"}}
 20000 | {"Job": "Database Consultant", "name": "Smith", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Manly", "Country": "Australia"}}
 30000 | {"Job": "Developer", "name": "John", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Brookvale", "Country": "Australia"}}
 50000 | {"cars": {"Ford": [{"doors": 4, "model": "Taurus"}, {"doors": 4, "model": "Escort"}], "Nissan": [{"doors": 4, "model": "Sentra"}, {"doors": 4, "model": "Maxima"}, {"doors": 2, "model": "Skyline"}]}}
 40000 | {"Job": "Architect", "name": "James", "Location": {"city": "Melbourne", "State": "NSW", "Suburb": "Trugnania", "Country": "Australia"}}

मैं "राज्य" "एनएसडब्ल्यू" के साथ सभी विवरण देखना चाहता हूं और "राज्य" JSON ऑब्जेक्ट कुंजी है जो कुंजी "स्थान" का हिस्सा है। नीचे बताया गया है कि इसे कैसे क्वेरी करें।

dbt3=# select * from test_json where details #> '{Location,State}'='"NSW"';
  id   |                                                                    details
-------+------------------------------------------------------------------------------------------------------------------------------------------------
 10000 | {"Job": "Database Consultant", "name": "Venkata", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Dee Why", "Country": "Australia"}}
 20000 | {"Job": "Database Consultant", "name": "Smith", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Manly", "Country": "Australia"}}
 30000 | {"Job": "Developer", "name": "John", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Brookvale", "Country": "Australia"}}
 30000 | {"Job": "Architect", "name": "James", "Location": {"city": "Melbourne", "State": "NSW", "Suburb": "Trugnania", "Country": "Australia"}}
(4 rows)

JSON डेटा पर अंकगणितीय संचालन किया जा सकता है। टाइप कास्टिंग की आवश्यकता है क्योंकि JSON कॉलम का डेटा भाग टेक्स्ट है।

dbt3=# select item_code, order_details->'l_quantity' as quantity, order_details->'l_extendedprice' as price, order_details->'l_shipmode' as price from product_details where (order_details->'l_quantity')::int > 10;
 item_code | quantity |  price  |  price
-----------+----------+---------+---------
         1 | 17       | 33078.9 | "TRUCK"
         2 | 36       | 38306.2 | "MAIL"
         4 | 28       | 34616.7 | "AIR"
         5 | 24       | 28974   | "FOB"
         6 | 32       | 44842.9 | "MAIL"
         7 | 38       | 63066.3 | "RAIL"
         8 | 45       | 86083.6 | "AIR"
         9 | 49       | 70822.1 | "RAIL"
        10 | 27       | 39620.3 | "SHIP"
(9 rows)

उपरोक्त सभी के अलावा, जेएसओएन पर जॉइन सहित एसक्यूएल का उपयोग करके निम्नलिखित ऑपरेशन भी किए जा सकते हैं

ORDER BY क्लॉज का उपयोग करके डेटा को सॉर्ट करना
सम, औसत, मिन, मैक्स आदि जैसे समग्र कार्यों का उपयोग करके एकत्रीकरण
ग्रुप बाय क्लॉज का उपयोग करके डेटा को समूहीकृत करें

प्रदर्शन के बारे में कैसे?

JSON कॉलम में डेटा प्रकृति में टेक्स्ट का होगा और डेटा आकार के आधार पर प्रदर्शन समस्याओं की उम्मीद की जा सकती है। JSON डेटा के माध्यम से खोज करने में समय और कंप्यूटिंग शक्ति लग सकती है जिसके परिणामस्वरूप एप्लिकेशन को धीमी प्रतिक्रिया मिल सकती है। डीबीए के लिए यह सुनिश्चित करना अनिवार्य है कि जेएसओएन कॉलम को मारने वाले एसक्यूएल पर्याप्त तेजी से प्रतिक्रिया दे रहे हैं और अच्छा प्रदर्शन प्रदान कर रहे हैं। चूंकि डेटा निष्कर्षण एसक्यूएल के माध्यम से किया जाता है, डीबीए जिस विकल्प की तलाश करेगा वह इंडेक्सिंग की संभावना है और हां, जेएसओएन डेटा प्रकार इंडेक्सिंग विकल्पों का समर्थन करते हैं।

आइए एक नज़र डालते हैं इंडेक्सिंग विकल्पों पर जो JSON हमारे लिए लाता है।

JSONB को इंडेक्स करना

JSONB डेटा प्रकार पूर्ण-पाठ-खोज अनुक्रमण का समर्थन करता है। यह JSONB की सबसे महत्वपूर्ण क्षमता है जिसे JSONB डेटा प्रकारों का उपयोग करते समय DBA आगे देखेगा। JSON ऑब्जेक्ट कुंजी पर एक सामान्य अनुक्रमणिका खोज क्वेरी में JSON विशिष्ट ऑपरेटरों का उपयोग करते समय मदद नहीं कर सकती है। नीचे एक टेक्स्ट खोज क्वेरी है जो एक पूर्ण-तालिका-स्कैन के लिए जाती है

dbt3=# explain select * from products where order_details @> '{"l_shipmode" : "AIR"}';
                             QUERY PLAN
--------------------------------------------------------------------
 Seq Scan on products  (cost=0.00..4205822.65 rows=59986 width=252)
   Filter: (order_details @> '{"l_shipmode": "AIR"}'::jsonb)
(2 rows)

JSONB GIN नामक पूर्ण-पाठ-खोज सूचकांक प्रकार का समर्थन करता है जो ऊपर की तरह प्रश्नों में सहायता करता है।
अब, मुझे एक GIN अनुक्रमणिका बनाने दें और देखें कि क्या इससे मदद मिलती है

dbt3=# create index od_gin_idx on products using gin(order_details jsonb_path_ops);
CREATE INDEX

यदि आप नीचे देख सकते हैं, तो क्वेरी GIN इंडेक्स को पिक करती है

dbt3=# explain select * from products where order_details @> '{"l_shipmode" : "AIR"}';
                                  QUERY PLAN
-------------------------------------------------------------------------------
 Bitmap Heap Scan on products  (cost=576.89..215803.18 rows=59986 width=252)
   Recheck Cond: (order_details @> '{"l_shipmode": "AIR"}'::jsonb)
   ->  Bitmap Index Scan on od_gin_idx  (cost=0.00..561.90 rows=59986 width=0)
         Index Cond: (order_details @> '{"l_shipmode": "AIR"}'::jsonb)

और GIN के बजाय B-TREE इंडेक्स मदद नहीं करेगा

dbt3=# create index idx on products((order_details->>'l_shipmode'));
CREATE INDEX

dbt3=# \d products
                  Table "dbt3.products"
    Column     |  Type  | Collation | Nullable | Default
---------------+--------+-----------+----------+---------
 item_code     | bigint |           | not null |
 order_details | jsonb  |           |          |
Indexes:
    "products_pkey" PRIMARY KEY, btree (item_code)
    "idx" btree ((order_details ->> 'l_shipmode'::text))

आप नीचे देख सकते हैं, क्वेरी फुल-टेबल-स्कैन पसंद करती है

dbt3=# explain select * from products where order_details @> '{"l_shipmode" : "AIR"}';
                             QUERY PLAN
--------------------------------------------------------------------
 Seq Scan on products  (cost=0.00..4205822.65 rows=59986 width=252)
   Filter: (order_details @> '{"l_shipmode": "AIR"}'::jsonb)

GIN इंडेक्स क्या है?

GIN का मतलब सामान्यीकृत उलटा सूचकांक है। GIN इंडेक्स की मुख्य क्षमता पूर्ण टेक्स्ट खोजों को गति देना है। किसी टेक्स्ट या दस्तावेज़ में विशिष्ट कुंजी या तत्वों के आधार पर खोज करते समय, GIN इंडेक्स जाने का रास्ता है। GIN इंडेक्स "कुंजी" (या एक तत्व या एक मान) और "स्थिति सूची" जोड़े को संग्रहीत करता है। स्थिति सूची कुंजी की पंक्ति आईडी है। इसका मतलब है, यदि दस्तावेज़ में "कुंजी" कई स्थानों पर होती है, तो जीआईएन इंडेक्स केवल एक बार कुंजी को इसकी घटनाओं की स्थिति के साथ स्टोर करता है जो न केवल जीआईएन इंडेक्स को आकार में कॉम्पैक्ट रखता है और खोजों को तेज करने में भी मदद करता है मार्ग। यह Postgres-9.4 में वृद्धि है।

GIN इंडेक्स के साथ चुनौतियां

डेटा की जटिलता के आधार पर, GIN इंडेक्स को बनाए रखना महंगा हो सकता है। GIN इंडेक्स के निर्माण में समय और संसाधनों की खपत होती है क्योंकि इंडेक्स को कुंजी और उनकी पंक्ति आईडी खोजने के लिए पूरे दस्तावेज़ की खोज करनी होती है। यदि GIN इंडेक्स फूला हुआ हो तो यह और भी चुनौतीपूर्ण हो सकता है। साथ ही, डेटा आकार और जटिलता के आधार पर GIN इंडेक्स का आकार बहुत बड़ा हो सकता है।

JSON को इंडेक्स करना

JSON टेक्स्ट खोज और GIN जैसे इंडेक्स का समर्थन नहीं करता है

dbt3=# create index pd_gin_idx on product using gin(productdetails jsonb_path_ops);
ERROR:  operator class "jsonb_path_ops" does not accept data type json

B-TREE जैसी सामान्य अनुक्रमण JSON और JSONB दोनों द्वारा समर्थित है

हां, बी-ट्री इंडेक्स जैसे सामान्य इंडेक्स JSON और JSONB डेटा प्रकारों द्वारा समर्थित हैं और टेक्स्ट सर्च ऑपरेशन के लिए अनुकूल नहीं हैं। प्रत्येक JSON ऑब्जेक्ट कुंजी को व्यक्तिगत रूप से अनुक्रमित किया जा सकता है जो वास्तव में केवल तभी मदद करेगा जब WHERE क्लॉज में एक ही ऑब्जेक्ट कुंजी का उपयोग किया जाता है।
मुझे JSONB पर एक B-TREE इंडेक्स बनाने दें और देखें कि यह कैसे काम करता है

dbt3=# create index idx on products((order_details->>'l_shipmode'));
CREATE INDEX

dbt3=# \d products
                  Table "dbt3.products"
    Column     |  Type  | Collation | Nullable | Default
---------------+--------+-----------+----------+---------
 item_code     | bigint |           | not null |
 order_details | jsonb  |           |          |
Indexes:
    "products_pkey" PRIMARY KEY, btree (item_code)
    "idx" btree ((order_details ->> 'l_shipmode'::text))

हम पहले ही ऊपर जान चुके हैं कि बी-ट्री इंडेक्स, ऑपरेटरों (जैसे "@>") का उपयोग करके जेएसओएन डेटा पर पूर्ण-पाठ-खोज करने वाले एसक्यूएल को तेज करने के लिए उपयोगी नहीं है, और ऐसे इंडेक्स केवल प्रश्नों को गति देने में मदद करेंगे जैसे नीचे दिया गया, जो कि विशिष्ट RDBMS प्रकार के SQL हैं (जो खोज क्वेरी नहीं हैं)। प्रत्येक JSON ऑब्जेक्ट कुंजी को व्यक्तिगत रूप से अनुक्रमित किया जा सकता है, जो उन अनुक्रमित JSON ऑब्जेक्ट कुंजियों का WHERE क्लॉज का उपयोग करने पर प्रश्नों को गति देने में मदद करेगा।
नीचे दिए गए उदाहरण में WHERE क्लॉज में "l_shipmode" ऑब्जेक्ट कुंजी का उपयोग किया गया है यह अनुक्रमित है क्वेरी एक अनुक्रमणिका स्कैन के लिए जा रही है। यदि आप किसी भिन्न ऑब्जेक्ट कुंजी का उपयोग करके खोज करना चाहते हैं, तो, क्वेरी एक पूर्ण-तालिका-स्कैन करना चुनेगी।

dbt3=# explain select * from products where order_details->>'l_shipmode'='AIR';
                                   QUERY PLAN
---------------------------------------------------------------------------------
 Index Scan using idx on products  (cost=0.56..1158369.34 rows=299930 width=252)
   Index Cond: ((order_details ->> 'l_shipmode'::text) = 'AIR'::text)

JSON डेटा प्रकार के साथ भी यही काम करता है

dbt3=# create index idx on products((order_details->>'l_shipmode'));
CREATE INDEX

dbt3=# \d products
                  Table "dbt3.products"
    Column     |  Type  | Collation | Nullable | Default
---------------+--------+-----------+----------+---------
 item_code     | bigint |           | not null |
 order_details | json  |           |          |
Indexes:
    "products_pkey" PRIMARY KEY, btree (item_code)
    "idx" btree ((order_details ->> 'l_shipmode'::text))

यदि आप देख सकते हैं, क्वेरी इंडेक्स का उपयोग कर रही है

dbt3=# explain select * from products where order_details->>'l_shipmode'='AIR';
                                   QUERY PLAN
---------------------------------------------------------------------------------
 Index Scan using idx on products  (cost=0.56..1158369.34 rows=299930 width=252)
   Index Cond: ((order_details ->> 'l_shipmode'::text) = 'AIR'::text)

निष्कर्ष

PostgreSQL JSON डेटा का उपयोग करते समय याद रखने योग्य कुछ बातें यहां दी गई हैं...

JSON डेटा को स्टोर और प्रोसेस करने के लिए PostgreSQL सबसे अच्छे विकल्पों में से एक है
सभी शक्तिशाली सुविधाओं के साथ, PostgreSQL आपका दस्तावेज़ डेटाबेस हो सकता है
मैंने ऐसे आर्किटेक्चर देखे हैं जहां दो या दो से अधिक डेटा स्टोर चुने जाते हैं, जिसमें PostgreSQL और NoSQL डेटाबेस जैसे MongoDB या Couchbase डेटाबेस का मिश्रण होता है। एक आरईएसटी एपीआई अनुप्रयोगों को डेटा को विभिन्न डेटा स्टोरों में धकेलने में मदद करेगा। पोस्टग्रेएसक्यूएल के साथ जेएसओएन का समर्थन करने से आर्किटेक्चर में इस जटिलता को केवल एक डेटा स्टोर चुनकर टाला जा सकता है।
पोस्टग्रेएसक्यूएल में JSON डेटा को क्वेरी और इंडेक्स किया जा सकता है जो अविश्वसनीय प्रदर्शन और मापनीयता प्रदान करता है
JSONB डेटा प्रकार सबसे पसंदीदा विकल्प है क्योंकि यह भंडारण और प्रदर्शन में अच्छा है। पूर्ण-पाठ-खोज और अनुक्रमण का पूरी तरह से समर्थन करता है। अच्छा प्रदर्शन करता है
JSON डेटा प्रकार का उपयोग केवल तभी करें जब आप JSON स्ट्रिंग्स को JSON के रूप में संग्रहीत करना चाहते हैं और आप अधिक जटिल टेक्स्ट खोज नहीं कर रहे हैं
पोस्टग्रेएसक्यूएल में JSON होने का सबसे बड़ा फायदा यह है कि SQL का उपयोग करके खोज की जा सकती है
पोस्टग्रेएसक्यूएल में जेएसओएन खोज प्रदर्शन मोंगोडीबी जैसे सर्वश्रेष्ठ नोएसक्यूएल डेटाबेस के बराबर रहा है