हमने पहले ही PostgreSQL इंडेक्सिंग इंजन , एक्सेस विधियों के इंटरफ़ेस और तीन विधियों: हैश इंडेक्स , बी-ट्री और GiST पर चर्चा की है । इस लेख में, हम SP-GiST का वर्णन करेंगे।

SP-सार

सबसे पहले, इस नाम के बारे में कुछ शब्द। "GiST" समान नाम एक्सेस पद्धति के साथ कुछ समानता के लिए भाग देता है। समानता मौजूद है: दोनों सामान्यीकृत खोज पेड़ हैं जो विभिन्न पहुंच विधियों के निर्माण के लिए एक रूपरेखा प्रदान करते हैं।

स्पेस विभाजन के लिए "एसपी" का अर्थ है। यहाँ अंतरिक्ष अक्सर बस है जिसे हम एक स्थान पर कॉल करने के लिए उपयोग किया जाता है, उदाहरण के लिए, दो-आयामी विमान। लेकिन हम देखेंगे कि किसी भी खोज स्थान का अर्थ है, वास्तव में कोई भी मूल्य डोमेन।

एसपी-जीएसटी उन संरचनाओं के लिए उपयुक्त है, जहां अंतरिक्ष को पुन: गैर -अंतरक्षेत्रीय क्षेत्रों में विभाजित किया जा सकता है। इस वर्ग में चतुष्कोण, k- आयामी वृक्ष (kD पेड़), और मूलांक वृक्ष शामिल हैं।

संरचना

इसलिए, एसपी-जीईएसटी एक्सेस पद्धति का विचार मूल्य डोमेन को गैर-अतिव्यापी उप - डोमेन में विभाजित करना है, जिनमें से प्रत्येक को बदले में भी विभाजित किया जा सकता है। इस तरह विभाजन गैर-संतुलित पेड़ों (बी-पेड़ों और नियमित जीएसटी के विपरीत) को प्रेरित करता है।

नॉन-इंटरसेक्टिंग होने का गुण सम्मिलन और खोज के दौरान निर्णय लेने को सरल बनाता है। दूसरी ओर, एक नियम के रूप में, प्रेरित पेड़ कम शाखाओं वाले होते हैं। उदाहरण के लिए, एक क्वाडट्री के नोड में आमतौर पर चार बाल नोड होते हैं (बी-पेड़ों के विपरीत, जहां नोड्स की मात्रा सैकड़ों होती है) और बड़ी गहराई। इन पेड़ों की तरह रैम में काम अच्छी तरह से होता है, लेकिन सूचकांक एक डिस्क पर संग्रहीत होता है और इसलिए, I / O संचालन की संख्या को कम करने के लिए, नोड्स को पृष्ठों में पैक करना पड़ता है, और यह कुशलतापूर्वक करना आसान नहीं है। इसके अलावा, सूचकांक में विभिन्न मूल्यों को खोजने में लगने वाला समय शाखा गहराई में अंतर के कारण भिन्न हो सकता है।

यह एक्सेस विधि, GiST के समान तरीका, निम्न-स्तरीय कार्यों (एक साथ एक्सेस और लॉक, लॉगिंग और एक शुद्ध खोज एल्गोरिदम) का ख्याल रखता है और नए डेटा प्रकारों के लिए और नए विभाजन एल्गोरिदम के लिए समर्थन जोड़ने में सक्षम करने के लिए एक विशेष सरलीकृत इंटरफ़ेस प्रदान करता है।

SP-GiST ट्री का आंतरिक नोड बाल नोड्स को संदर्भित करता है; प्रत्येक संदर्भ के लिए एक लेबल परिभाषित किया जा सकता है। इसके अलावा, एक आंतरिक नोड एक उपसर्ग नामक एक स्टोर कर सकता है। वास्तव में यह मूल्य उपसर्ग के लिए अनिवार्य नहीं है; इसे एक मनमाना विधेय के रूप में माना जा सकता है, जो सभी बच्चे नोड्स के लिए मिलता है।

SP-GiST के लीफ नोड्स में अनुक्रमित प्रकार का मान और तालिका पंक्ति (TID) का संदर्भ होता है। स्वयं अनुक्रमित डेटा (खोज कुंजी) का उपयोग मूल्य के रूप में किया जा सकता है, लेकिन अनिवार्य नहीं: एक छोटा मूल्य संग्रहीत किया जा सकता है।

इसके अलावा, लीफ नोड्स को सूचियों में बांटा जा सकता है। तो, एक आंतरिक नोड न केवल एक मूल्य, बल्कि एक पूरी सूची को संदर्भित कर सकता है।

ध्यान दें कि लीफ नोड्स में उपसर्ग, लेबल और मान एक दूसरे से स्वतंत्र अपने स्वयं के डेटा प्रकार हैं।

GiST की तरह ही, खोज के लिए परिभाषित करने के लिए मुख्य कार्य संगति फ़ंक्शन है । इस फ़ंक्शन को ट्री नोड के लिए कहा जाता है और बच्चे के नोड्स का एक सेट देता है, जिनके मान "खोज विधेय के साथ" सुसंगत हैं (हमेशा की तरह, " अनुक्रमित-फ़ील्ड ऑपरेटर अभिव्यक्ति ")। पत्ती नोड के लिए, संगतता फ़ंक्शन निर्धारित करता है कि क्या इस नोड में अनुक्रमित मान खोज विधेय से मिलता है।

खोज रूट नोड के साथ शुरू होती है। स्थिरता समारोह यह पता लगाने की अनुमति देता है कि कौन सा बच्चा यह यात्रा करने के लिए समझ में आता है। एल्गोरिथ्म में पाए गए प्रत्येक नोड के लिए दोहराता है। खोज गहराई-पहले है।

भौतिक स्तर पर, I / O संचालन के दृष्टिकोण से नोड्स के साथ काम करने के लिए इंडेक्स नोड्स को पृष्ठों में पैक किया जाता है। ध्यान दें कि एक पृष्ठ में आंतरिक या पत्ती नोड्स हो सकते हैं, लेकिन दोनों नहीं।

उदाहरण: चतुर्भुज

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

यह वही है जो आंकड़ों में दिखता है, उदाहरण के लिए साइट openflights.org से हवाई अड्डों द्वारा संवर्धित डेमो डेटाबेस । वैसे, हाल ही में हमने डेटाबेस का एक नया संस्करण जारी किया जिसमें, बाकी के बीच, हमने "पॉइंट" के एक क्षेत्र के साथ देशांतर और अक्षांश को बदल दिया।


सबसे पहले, हमने विमान को चार चतुर्भुजों में विभाजित किया ...


फिर हमने प्रत्येक चतुर्भुज को विभाजित किया ...


और इसलिए जब तक हम अंतिम विभाजन प्राप्त नहीं कर लेते।

आइए एक सरल उदाहरण के अधिक विवरण प्रदान करें जो हमने पहले ही GiST- संबंधित लेख में माना था। देखें कि इस मामले में विभाजन क्या दिख सकता है:



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



सीमा पर झूठ बोलने वाले बिंदु, छोटी संख्या के साथ चतुर्थांश से संबंधित हैं।

postgres=# create table points(p point); postgres=# insert into points(p) values (point '(1,1)'), (point '(3,2)'), (point '(6,3)'), (point '(5,5)'), (point '(7,8)'), (point '(8,6)'); postgres=# create index points_quad_idx on points using spgist(p); 

इस स्थिति में, "quad_point_ops" ऑपरेटर वर्ग डिफ़ॉल्ट रूप से उपयोग किया जाता है, जिसमें निम्नलिखित ऑपरेटर शामिल हैं:

 postgres=# select amop.amopopr::regoperator, amop.amopstrategy from pg_opclass opc, pg_opfamily opf, pg_am am, pg_amop amop where opc.opcname = 'quad_point_ops' and opf.oid = opc.opcfamily and am.oid = opf.opfmethod and amop.amopfamily = opc.opcfamily and am.amname = 'spgist' and amop.amoplefttype = opc.opcintype; 

  amopopr | amopstrategy -----------------+-------------- <<(point,point) | 1 strictly left >>(point,point) | 5 strictly right ~=(point,point) | 6 coincides <^(point,point) | 10 strictly below >^(point,point) | 11 strictly above <@(point,box) | 8 contained in rectangle (6 rows) 

उदाहरण के लिए, आइए देखें कि क्वेरी select * from points where p >^ point '(2,7)' कैसे select * from points where p >^ point '(2,7)' का प्रदर्शन किया जाएगा (सभी बिंदुओं को देखें जो किसी दिए गए के ऊपर स्थित हैं)।



हम रूट नोड के साथ शुरू करते हैं और जो बच्चे को उतरने के लिए नोड्स का चयन करने के लिए संगतता फ़ंक्शन का उपयोग करते हैं। ऑपरेटर >^ , यह फ़ंक्शन नोड (4,4) के केंद्रीय बिंदु के साथ बिंदु (2,7) की तुलना करता है और उन क्वैडेंट्स का चयन करता है जिनमें मांगे गए बिंदु हो सकते हैं, इस मामले में, पहला और चौथा क्वाड्रंट।

पहले चतुर्थांश के अनुरूप नोड में, हम फिर से स्थिरता फ़ंक्शन का उपयोग करके बच्चे के नोड्स का निर्धारण करते हैं। केंद्रीय बिंदु (6,6) है, और हमें फिर से पहले और चौथे चतुर्थांश के माध्यम से देखने की जरूरत है।



लीफ नोड्स (8.6) और (7.8) की सूची पहले चतुर्थांश से मेल खाती है, जिसमें से केवल बिंदु (7.8) क्वेरी स्थिति से मिलता है। चौथे चतुर्थांश का संदर्भ खाली है।

आंतरिक नोड (4.4) में, चौथे चतुर्थांश का संदर्भ रिक्त है, जो खोज को पूरा करता है।

 postgres=# set enable_seqscan = off; postgres=# explain (costs off) select * from points where p >^ point '(2,7)'; 

  QUERY PLAN ------------------------------------------------ Index Only Scan using points_quad_idx on points Index Cond: (p >^ '(2,7)'::point) (2 rows) 

internals

हम एसपी-जीईएसटी इंडेक्स की आंतरिक संरचना का पता लगा सकते हैं, जो " जवेल " एक्सटेंशन का उपयोग कर रहा है, जो पहले उल्लेख किया गया था। बुरी खबर यह है कि बग के कारण, यह एक्सटेंशन PostgreSQL के आधुनिक संस्करणों के साथ गलत तरीके से काम करता है। अच्छी खबर यह है कि हम "जिवल" ( चर्चा ) की कार्यक्षमता के साथ "पेजिन्सपेक्ट" को बढ़ाने की योजना बना रहे हैं। और बग पहले से ही "पेजिन्सपैक्ट" में तय किया गया है।

फिर, बुरी खबर यह है कि पैच प्रगति के साथ नहीं अटक गया है।

उदाहरण के लिए, चलो विस्तारित डेमो डेटाबेस लेते हैं, जिसका उपयोग दुनिया के नक्शे के साथ चित्र बनाने के लिए किया गया था।

 demo=# create index airports_coordinates_quad_idx on airports_ml using spgist(coordinates); 

सबसे पहले, हम सूचकांक के लिए कुछ आँकड़े प्राप्त कर सकते हैं:

 demo=# select * from spgist_stats('airports_coordinates_quad_idx'); 

  spgist_stats ---------------------------------- totalPages: 33 + deletedPages: 0 + innerPages: 3 + leafPages: 30 + emptyPages: 2 + usedSpace: 201.53 kbytes+ usedInnerSpace: 2.17 kbytes + usedLeafSpace: 199.36 kbytes+ freeSpace: 61.44 kbytes + fillRatio: 76.64% + leafTuples: 5993 + innerTuples: 37 + innerAllTheSame: 0 + leafPlaceholders: 725 + innerPlaceholders: 0 + leafRedirects: 0 + innerRedirects: 0 (1 row) 

और दूसरा, हम इंडेक्स ट्री को स्वयं आउटपुट कर सकते हैं:

 demo=# select tid, n, level, tid_ptr, prefix, leaf_value from spgist_print('airports_coordinates_quad_idx') as t( tid tid, allthesame bool, n int, level int, tid_ptr tid, prefix point, -- prefix type node_label int, -- label type (unused here) leaf_value point -- list value type ) order by tid, n; 

  tid | n | level | tid_ptr | prefix | leaf_value ---------+---+-------+---------+------------------+------------------ (1,1) | 0 | 1 | (5,3) | (-10.220,53.588) | (1,1) | 1 | 1 | (5,2) | (-10.220,53.588) | (1,1) | 2 | 1 | (5,1) | (-10.220,53.588) | (1,1) | 3 | 1 | (5,14) | (-10.220,53.588) | (3,68) | | 3 | | | (86.107,55.270) (3,70) | | 3 | | | (129.771,62.093) (3,85) | | 4 | | | (57.684,-20.430) (3,122) | | 4 | | | (107.438,51.808) (3,154) | | 3 | | | (-51.678,64.191) (5,1) | 0 | 2 | (24,27) | (-88.680,48.638) | (5,1) | 1 | 2 | (5,7) | (-88.680,48.638) | ... 

लेकिन ध्यान रखें कि "स्पिगिस्ट_प्रिंट" सभी पत्ती मानों का उत्पादन नहीं करता है, लेकिन सूची से केवल पहला ही है, और इसलिए इसकी पूर्ण सामग्री के बजाय सूचकांक की संरचना को दर्शाता है।

उदाहरण: k- आयामी पेड़

विमान में समान बिंदुओं के लिए, हम अंतरिक्ष को विभाजित करने का एक और तरीका भी सुझा सकते हैं।

पहले बिंदु को अनुक्रमित करने के माध्यम से एक क्षैतिज रेखा खींचते हैं। यह विमान को दो भागों में विभाजित करता है: ऊपरी और निचला। अनुक्रमित होने वाला दूसरा बिंदु इनमें से एक भाग में आता है। इस बिंदु के माध्यम से, एक ऊर्ध्वाधर रेखा खींचते हैं, जो इस हिस्से को दो भागों में विभाजित करती है: दाएं और बाएं। हम फिर से अगले बिंदु के माध्यम से एक क्षैतिज रेखा खींचते हैं और एक ऊर्ध्वाधर रेखा अभी तक अगले बिंदु के माध्यम से, और इसी तरह।

इस तरह से बनाए गए पेड़ के सभी आंतरिक नोड्स में केवल दो बाल नोड होंगे। दो संदर्भों में से प्रत्येक या तो आंतरिक नोड तक ले जा सकता है जो पदानुक्रम में बगल में या पत्ती नोड्स की सूची में है।

इस पद्धति को k- आयामी रिक्त स्थान के लिए आसानी से सामान्यीकृत किया जा सकता है, और इसलिए, पेड़ों को साहित्य में k- आयामी (kD पेड़) भी कहा जाता है।

हवाई अड्डों के उदाहरण द्वारा विधि की व्याख्या:


पहले हम प्लेन को ऊपरी और निचले हिस्सों में विभाजित करते हैं ...


फिर हम प्रत्येक भाग को बाएँ और दाएँ भागों में विभाजित करते हैं ...


और इसलिए जब तक हम अंतिम विभाजन प्राप्त नहीं कर लेते।

इस तरह एक विभाजन का उपयोग करने के लिए, हमें इंडेक्स बनाते समय ऑपरेटर वर्ग "kd_point_ops" को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता होती है।

 postgres=# create index points_kd_idx on points using spgist(p kd_point_ops); 

इस वर्ग में ठीक उसी तरह के ऑपरेटर शामिल हैं जैसे "डिफ़ॉल्ट" वर्ग "quad_point_ops"।

internals

जब पेड़ की संरचना को देखते हैं, तो हमें यह ध्यान रखना चाहिए कि इस मामले में उपसर्ग केवल एक बिंदु के बजाय एक समन्वय है:

 demo=# select tid, n, level, tid_ptr, prefix, leaf_value from spgist_print('airports_coordinates_kd_idx') as t( tid tid, allthesame bool, n int, level int, tid_ptr tid, prefix float, -- prefix type node_label int, -- label type (unused here) leaf_value point -- list node type ) order by tid, n; 

  tid | n | level | tid_ptr | prefix | leaf_value ---------+---+-------+---------+------------+------------------ (1,1) | 0 | 1 | (5,1) | 53.740 | (1,1) | 1 | 1 | (5,4) | 53.740 | (3,113) | | 6 | | | (-7.277,62.064) (3,114) | | 6 | | | (-85.033,73.006) (5,1) | 0 | 2 | (5,12) | -65.449 | (5,1) | 1 | 2 | (5,2) | -65.449 | (5,2) | 0 | 3 | (5,6) | 35.624 | (5,2) | 1 | 3 | (5,3) | 35.624 | ... 

उदाहरण: मूलांक वृक्ष

हम स्ट्रिंग्स के लिए एक मूलांक वृक्ष को लागू करने के लिए SP-GiST का भी उपयोग कर सकते हैं। मूलांक वृक्ष का विचार यह है कि एक स्ट्रिंग को अनुक्रमित किया जाना पूरी तरह से एक पत्ती के नोड में संग्रहीत नहीं किया जाता है, लेकिन नोड्स में संग्रहीत मानों को एक से ऊपर जड़ तक समेट कर प्राप्त किया जाता है।

मान लें, हमें साइट URL को अनुक्रमित करने की आवश्यकता है: "postgrespro.ru", "postgrespro.com", "postgresql.org", और "planet.postgresql.org"।

 postgres=# create table sites(url text); postgres=# insert into sites values ('postgrespro.ru'),('postgrespro.com'),('postgresql.org'),('planet.postgresql.org'); postgres=# create index on sites using spgist(url); 

पेड़ इस प्रकार दिखेगा:



ट्री स्टोर के आंतरिक नोड्स सभी बाल नोड्स के लिए आम उपसर्ग करते हैं। उदाहरण के लिए, "stgres" के बाल नोड्स में, मान "p" + "o" + "stgres" से शुरू होते हैं।

Quadtrees के विपरीत, एक बच्चे के नोड के लिए प्रत्येक सूचक अतिरिक्त रूप से एक वर्ण के साथ लेबल किया जाता है (अधिक सटीक रूप से, दो बाइट्स के साथ, लेकिन यह इतना महत्वपूर्ण नहीं है)।

"Text_ops" ऑपरेटर वर्ग बी-ट्री-जैसे ऑपरेटरों का समर्थन करता है: "बराबर", "अधिक", और "कम":

 postgres=# select amop.amopopr::regoperator, amop.amopstrategy from pg_opclass opc, pg_opfamily opf, pg_am am, pg_amop amop where opc.opcname = 'text_ops' and opf.oid = opc.opcfamily and am.oid = opf.opfmethod and amop.amopfamily = opc.opcfamily and am.amname = 'spgist' and amop.amoplefttype = opc.opcintype; 

  amopopr | amopstrategy -----------------+-------------- ~<~(text,text) | 1 ~<=~(text,text) | 2 =(text,text) | 3 ~>=~(text,text) | 4 ~>~(text,text) | 5 <(text,text) | 11 <=(text,text) | 12 >=(text,text) | 14 >(text,text) | 15 (9 rows) 

टिल्ड्स के साथ ऑपरेटरों का भेद यह है कि वे पात्रों के बजाय बाइट्स में हेरफेर करते हैं।

कभी-कभी, मूलांक वृक्ष के रूप में एक प्रतिनिधित्व बी-वृक्ष की तुलना में बहुत अधिक कॉम्पैक्ट हो सकता है क्योंकि मूल्य पूरी तरह से संग्रहीत नहीं होते हैं, लेकिन पेड़ के माध्यम से उतरते समय आवश्यकता के रूप में फिर से संगठित किया जाता है।

एक क्वेरी पर विचार करें: select * from sites where url like 'postgresp%ru' । यह सूचकांक का उपयोग करके किया जा सकता है:

 postgres=# explain (costs off) select * from sites where url like 'postgresp%ru'; 

  QUERY PLAN ------------------------------------------------------------------------------ Index Only Scan using sites_url_idx on sites Index Cond: ((url ~>=~ 'postgresp'::text) AND (url ~<~ 'postgresq'::text)) Filter: (url ~~ 'postgresp%ru'::text) (3 rows) 

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

सबसे पहले, स्थिरता समारोह को तय करना होगा कि "पी" रूट के कौन से बच्चे को हमें उतरना है। दो विकल्प उपलब्ध हैं: "पी" + "एल" (उतरने की कोई आवश्यकता नहीं है, जो कि गहराई से गोताखोरी के बिना भी स्पष्ट है) और "पी" + "ओ" + "स्ट्रेस" (वंश को जारी रखें)।

"Stgres" नोड के लिए, "postgres" + "p" + "ro" की जांच करने के लिए संगतता फ़ंक्शन के लिए एक कॉल फिर से आवश्यक है। (वंश जारी रखें) और "पोस्टग्रेज" + "क्यू" (उतरने की आवश्यकता नहीं)।

"आरओ" के लिए। नोड और उसके सभी बाल पत्ती नोड्स, स्थिरता फ़ंक्शन "हां" का जवाब देगा, इसलिए सूचकांक विधि दो मान लौटाएगी: "postgrespro.com" और "postgrespro.ru"। एक मिलान मूल्य उन्हें फ़िल्टरिंग चरण में चुना जाएगा।

internals

जब पेड़ की संरचना को देखते हैं, तो हमें डेटा प्रकारों को ध्यान में रखना होगा:

 postgres=# select * from spgist_print('sites_url_idx') as t( tid tid, allthesame bool, n int, level int, tid_ptr tid, prefix text, -- prefix type node_label smallint, -- label type leaf_value text -- leaf node type ) order by tid, n; 

गुण

आइए SP-GiST पहुंच विधि के गुणों को देखें (प्रश्न पहले प्रदान किए गए थे ):

  amname | name | pg_indexam_has_property --------+---------------+------------------------- spgist | can_order | f spgist | can_unique | f spgist | can_multi_col | f spgist | can_exclude | t 

SP-GiST इंडेक्स का उपयोग छँटाई के लिए और अद्वितीय अवरोध के समर्थन के लिए नहीं किया जा सकता है। इसके अतिरिक्त, इस तरह के सूचकांक कई स्तंभों पर (जीएसटी के विपरीत) नहीं बनाए जा सकते हैं। लेकिन बहिष्करण बाधाओं का समर्थन करने के लिए इस तरह के सूचकांक का उपयोग करने की अनुमति है।

निम्नलिखित सूचकांक-परत गुण उपलब्ध हैं:

  name | pg_index_has_property ---------------+----------------------- clusterable | f index_scan | t bitmap_scan | t backward_scan | f 

यहां जीएसटी से अंतर यह है कि क्लस्टरिंग असंभव है।

और अंततः निम्नलिखित स्तंभ-परत गुण हैं:

  name | pg_index_column_has_property --------------------+------------------------------ asc | f desc | f nulls_first | f nulls_last | f orderable | f distance_orderable | f returnable | t search_array | f search_nulls | t 

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

यह निकिता Glukhov द्वारा आगामी PostgreSQL 12, पैच में समर्थित है।

SP-GiST का उपयोग केवल इंडेक्स-स्कैन के लिए किया जा सकता है, कम से कम चर्चा किए गए ऑपरेटर वर्गों के लिए। जैसा कि हमने देखा है, कुछ उदाहरणों में, अनुक्रमित मूल्यों को स्पष्ट रूप से पत्ती के नोड्स में संग्रहीत किया जाता है, जबकि अन्य में, पेड़ के वंश के दौरान मानों को आंशिक रूप से पुनर्निर्मित किया जाता है।

NULLs

चित्र को जटिल नहीं करने के लिए, हमने अब तक NULLs का उल्लेख नहीं किया है। यह सूचकांक गुणों से स्पष्ट है कि NULLs समर्थित हैं। सच:

 postgres=# explain (costs off) select * from sites where url is null; 

  QUERY PLAN ---------------------------------------------- Index Only Scan using sites_url_idx on sites Index Cond: (url IS NULL) (2 rows) 

हालाँकि, NULL SP-GiST के लिए कुछ विदेशी है। "स्पेगिस्ट" ऑपरेटर वर्ग के सभी ऑपरेटरों को सख्त होना चाहिए: एक ऑपरेटर को NULL वापस करना होगा जब भी उसका कोई भी पैरामीटर NULL हो। यह विधि स्वयं यह सुनिश्चित करती है: NULLs केवल ऑपरेटरों के लिए पारित नहीं होते हैं।

लेकिन इंडेक्स-ओनली स्कैन के लिए एक्सेस विधि का उपयोग करने के लिए, NULLs को वैसे भी इंडेक्स में संग्रहीत किया जाना चाहिए। और वे संग्रहीत हैं, लेकिन अपनी जड़ के साथ एक अलग पेड़ में।

अन्य डेटा प्रकार

स्ट्रिंग्स के लिए अंक और मूलांक के पेड़ के अलावा, SP-GiST पर आधारित अन्य तरीकों को भी पोस्टग्रेक्यूएल लागू किया जाता है:

• Box_ops ऑपरेटर वर्ग आयतों के लिए एक चतुष्कोण प्रदान करता है।
  प्रत्येक आयत को एक चार-आयामी स्थान में एक बिंदु द्वारा दर्शाया जाता है , इसलिए क्वाडंटेंट्स की संख्या 16 के बराबर होती है। इस तरह एक सूचकांक प्रदर्शन में GiST को हरा सकता है जब आयतों के बहुत सारे चौराहे होते हैं: GiST में सीमाओं को खींचना असंभव है ताकि वस्तुओं को एक दूसरे से अलग करने के लिए, जबकि अंक (यहां तक ​​कि चार आयामी) के साथ इस तरह के मुद्दे नहीं हैं।
  
• "Range_ops" ऑपरेटर वर्ग अंतराल के लिए एक क्वाडट्री प्रदान करता है।
  एक अंतराल को दो-आयामी बिंदु द्वारा दर्शाया जाता है : निचली सीमा अनुपस्थिति बन जाती है, और ऊपरी सीमा समन्वय बन जाती है।
  

पर पढ़ें ।