इंटरफ़ेस

पहले लेख में , हमने उल्लेख किया है कि एक एक्सेस विधि को अपने बारे में जानकारी प्रदान करनी होगी। आइए पहुंच विधि इंटरफ़ेस की संरचना में देखें।

गुण

एक्सेस विधियों के सभी गुणों को "pg_am" टेबल ("am" स्टैंड फॉर एक्सेस मेथड) में संग्रहित किया जाता है। हम इसी तालिका से उपलब्ध तरीकों की एक सूची भी प्राप्त कर सकते हैं:

postgres=# select amname from pg_am; 

  amname -------- btree hash gist gin spgist brin (6 rows) 

हालांकि अनुक्रमिक स्कैन को सही तरीके से एक्सेस विधियों में संदर्भित किया जा सकता है, यह ऐतिहासिक कारणों से इस सूची में नहीं है।

PostgreSQL के संस्करण 9.5 और उससे कम में, प्रत्येक संपत्ति को "pg_am" तालिका के एक अलग क्षेत्र के साथ दर्शाया गया था। संस्करण 9.6 से शुरू होकर, संपत्तियों को विशेष कार्यों से अलग किया जाता है और कई परतों में अलग किया जाता है:

• पहुँच विधि गुण - "pg_indexam_has_property"
• एक विशिष्ट सूचकांक के गुण - "pg_index_has_property"
• सूचकांक के व्यक्तिगत कॉलम के गुण - "pg_index_column_has_property"

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

निम्नलिखित चार गुण पहुँच विधि के हैं (उदाहरण के लिए "btree"):

 postgres=# select a.amname, p.name, pg_indexam_has_property(a.oid,p.name) from pg_am a, unnest(array['can_order','can_unique','can_multi_col','can_exclude']) p(name) where a.amname = 'btree' order by a.amname; 

  amname | name | pg_indexam_has_property --------+---------------+------------------------- btree | can_order | t btree | can_unique | t btree | can_multi_col | t btree | can_exclude | t (4 rows) 

• can_order।
  जब एक इंडेक्स बनाया जाता है, तो एक्सेस विधि हमें मूल्यों के लिए सॉर्ट ऑर्डर निर्दिष्ट करने में सक्षम बनाती है (केवल अब तक "btree" पर लागू होती है)।
• can_unique।
  अद्वितीय बाधा और प्राथमिक कुंजी का समर्थन (केवल "बीट्री" पर लागू होता है)।
• can_multi_col।
  एक सूचकांक कई स्तंभों पर बनाया जा सकता है।
• can_exclude।
  बहिष्करण बाधा का समर्थन।

एक अनुक्रमणिका से संबंधित निम्नलिखित गुण हैं (उदाहरण के लिए किसी मौजूदा पर विचार करें):

 postgres=# select p.name, pg_index_has_property('t_a_idx'::regclass,p.name) from unnest(array[ 'clusterable','index_scan','bitmap_scan','backward_scan' ]) p(name); 

  name | pg_index_has_property ---------------+----------------------- clusterable | t index_scan | t bitmap_scan | t backward_scan | t (4 rows) 

• clusterable।
  अनुक्रमणिका के अनुसार पंक्तियों को पुन: क्रमबद्ध करने की संभावना (समान-नाम कमांड क्लस्टर के साथ क्लस्टरिंग)।
• index_scan।
  सूचकांक स्कैन का समर्थन। हालांकि यह संपत्ति अजीब लग सकती है, सभी इंडेक्स एक-एक करके TID नहीं लौटा सकते हैं - कुछ रिटर्न एक ही बार में मिलते हैं और केवल बिटमैप स्कैन का समर्थन करते हैं।
• bitmap_scan।
  बिटमैप स्कैन का समर्थन।
• backward_scan।
  अनुक्रमणिका का निर्माण करते समय परिणाम एक के निर्दिष्ट क्रम में वापस किया जा सकता है।

अंत में, निम्नलिखित स्तंभ गुण हैं:

 postgres=# select p.name, pg_index_column_has_property('t_a_idx'::regclass,1,p.name) from unnest(array[ 'asc','desc','nulls_first','nulls_last','orderable','distance_orderable', 'returnable','search_array','search_nulls' ]) p(name); 

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

• asc, desc, nulls_first, nulls_last, क्रमबद्ध।
  ये गुण मानों को क्रमबद्ध करने से संबंधित हैं (जब हम "btree" अनुक्रमित के विवरण तक पहुँचते हैं तो हम उनकी चर्चा करेंगे)।
• distance_orderable।
  परिणाम ऑपरेशन द्वारा निर्धारित क्रमबद्ध क्रम में वापस किया जा सकता है (केवल अब तक जीएसटी और आरयूएम अनुक्रमित पर लागू होता है)।
• वापस।
  तालिका तक पहुंच के बिना सूचकांक का उपयोग करने की संभावना, अर्थात, केवल-सूचकांक स्कैन का समर्थन।
• search_array।
  " अनुक्रमित-फ़ील्ड IN ( list_of_constants )", जो " अनुक्रमित-फ़ील्ड = कोई भी ( array_of_constants )" के समान है, के साथ कई मानों के लिए खोज का समर्थन।
• search_nulls।
  IS NULL और IS नॉट नाउल स्थितियों द्वारा खोज करने की संभावना।

हमने पहले ही कुछ गुणों के बारे में विस्तार से चर्चा की है। कुछ गुण कुछ एक्सेस विधियों के लिए विशिष्ट हैं। हम इन विशिष्ट तरीकों पर विचार करते समय ऐसे गुणों पर चर्चा करेंगे।

संचालक वर्ग और परिवार

वर्णित इंटरफ़ेस द्वारा उजागर एक्सेस पद्धति के गुणों के अलावा, यह जानने के लिए जानकारी की आवश्यकता है कि कौन से डेटा प्रकार और कौन से ऑपरेटर एक्सेस विधि को स्वीकार करते हैं। यह अंत करने के लिए, PostgreSQL ऑपरेटर वर्ग और ऑपरेटर परिवार अवधारणाओं का परिचय देता है।

एक ऑपरेटर वर्ग में एक निश्चित डेटा प्रकार में हेरफेर करने के लिए एक सूचकांक के लिए ऑपरेटरों (और शायद, सहायक कार्यों) का एक न्यूनतम सेट होता है।

एक ऑपरेटर वर्ग कुछ ऑपरेटर परिवार में शामिल है। इसके अलावा, एक सामान्य ऑपरेटर परिवार में कई ऑपरेटर वर्ग हो सकते हैं यदि उनके पास एक ही शब्दार्थ है। उदाहरण के लिए, "integer_ops" परिवार में "int8_ops", "int4_ops", और "int2_ops" प्रकार "bigint", "पूर्णांक" और "smallint" प्रकार के वर्ग शामिल हैं, जिनके अलग-अलग आकार हैं लेकिन एक ही अर्थ है:

 postgres=# select opfname, opcname, opcintype::regtype from pg_opclass opc, pg_opfamily opf where opf.opfname = 'integer_ops' and opc.opcfamily = opf.oid and opf.opfmethod = ( select oid from pg_am where amname = 'btree' ); 

  opfname | opcname | opcintype -------------+----------+----------- integer_ops | int2_ops | smallint integer_ops | int4_ops | integer integer_ops | int8_ops | bigint (3 rows) 

एक अन्य उदाहरण: "डेटाइम_ओप्स" परिवार में तारीखों में हेरफेर करने के लिए ऑपरेटर कक्षाएं शामिल हैं (समय के साथ और बिना दोनों):

 postgres=# select opfname, opcname, opcintype::regtype from pg_opclass opc, pg_opfamily opf where opf.opfname = 'datetime_ops' and opc.opcfamily = opf.oid and opf.opfmethod = ( select oid from pg_am where amname = 'btree' ); 

  opfname | opcname | opcintype --------------+-----------------+----------------------------- datetime_ops | date_ops | date datetime_ops | timestamptz_ops | timestamp with time zone datetime_ops | timestamp_ops | timestamp without time zone (3 rows) 

एक ऑपरेटर परिवार विभिन्न प्रकारों के मूल्यों की तुलना करने के लिए अतिरिक्त ऑपरेटरों को भी शामिल कर सकता है। परिवारों में समूहन विभिन्न प्रकार के मूल्यों के साथ विधेयकों के लिए एक सूचकांक का उपयोग करने के लिए योजनाकार को सक्षम करता है। एक परिवार में अन्य सहायक कार्य भी हो सकते हैं।

ज्यादातर मामलों में, हमें ऑपरेटर परिवारों और कक्षाओं के बारे में कुछ भी जानने की आवश्यकता नहीं है। आमतौर पर हम डिफ़ॉल्ट रूप से एक निश्चित ऑपरेटर वर्ग का उपयोग करके, केवल एक इंडेक्स बनाते हैं।

हालांकि, हम ऑपरेटर वर्ग को स्पष्ट रूप से निर्दिष्ट कर सकते हैं। जब स्पष्ट विनिर्देश आवश्यक हो तो यह एक सरल उदाहरण है: सी से अलग कोलाजेशन वाले डेटाबेस में, एक नियमित सूचकांक LIKE ऑपरेशन का समर्थन नहीं करता है:

 postgres=# show lc_collate; 

  lc_collate ------------- en_US.UTF-8 (1 row) 

 postgres=# explain (costs off) select * from t where b like 'A%'; 

  QUERY PLAN ----------------------------- Seq Scan on t Filter: (b ~~ 'A%'::text) (2 rows) 

हम ऑपरेटर श्रेणी "text_pattern_ops" के साथ एक इंडेक्स बनाकर इस सीमा को पार कर सकते हैं (ध्यान दें कि योजना में स्थिति कैसे बदल जाती है):

 postgres=# create index on t(b text_pattern_ops); postgres=# explain (costs off) select * from t where b like 'A%'; 

  QUERY PLAN ---------------------------------------------------------------- Bitmap Heap Scan on t Filter: (b ~~ 'A%'::text) -> Bitmap Index Scan on t_b_idx1 Index Cond: ((b ~>=~ 'A'::text) AND (b ~<~ 'B'::text)) (4 rows) 

सिस्टम कैटलॉग

इस लेख के निष्कर्ष में, हम सिस्टम कैटलॉग में तालिकाओं का एक सरल आरेख प्रदान करते हैं जो सीधे ऑपरेटर वर्गों और परिवारों से संबंधित हैं।



यह बिना कहे चला जाता है कि इन सभी तालिकाओं का विस्तार से वर्णन किया गया है ।

सिस्टम कैटलॉग हमें प्रलेखन में देखे बिना कई सवालों के जवाब खोजने में सक्षम बनाता है। उदाहरण के लिए, कौन से डेटा प्रकार एक निश्चित पहुंच विधि में हेरफेर कर सकते हैं?

 postgres=# select opcname, opcintype::regtype from pg_opclass where opcmethod = (select oid from pg_am where amname = 'btree') order by opcintype::regtype::text; 

  opcname | opcintype ---------------------+----------------------------- abstime_ops | abstime array_ops | anyarray enum_ops | anyenum ... 

एक ऑपरेटर वर्ग में कौन से ऑपरेटर शामिल हैं (और इसलिए, ऐसी स्थिति के लिए इंडेक्स एक्सेस का उपयोग किया जा सकता है जिसमें ऐसा ऑपरेटर शामिल है)?

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

  amopopr ----------------------- <(anyarray,anyarray) <=(anyarray,anyarray) =(anyarray,anyarray) >=(anyarray,anyarray) >(anyarray,anyarray) (5 rows) 

पर पढ़ें ।