एक्स्टेंसिबल पोस्टग्रेज

अंतिम PGConf.Russia में, MobilityDB एक्सटेंशन के बारे में एक रिपोर्ट थी, और आंद्रेई बोरोडिन ने कार्य के लिए सूचकांक विधियों के विस्तार का विचार प्रस्तावित किया था ।

मैं कार्य के लिए पोस्टग्रेज एक्सटेंशन के साथ विषय को जारी रखूंगा , जो कि हाईलाड कप 2018 के हिस्से के रूप में किए गए एक्सटेंशन के उदाहरण का उपयोग करके हल किया जाएगा, कोड GithHub पर उपलब्ध है। हबल पर पहले से ही ब्लैकमास्टर का एक लेख है। एक्सटेंशन btree और GIN इंडेक्स के समर्थन के साथ दो प्रकार जोड़ता है।

प्रारंभिक योजना:

CREATE TABLE accounts ( id INTEGER PRIMARY KEY, email VARCHAR(100) UNIQUE, fname SMALLINT, sname VARCHAR(50), phone VARCHAR(16) UNIQUE, birth TIMESTAMP NOT NULL, country SMALLINT, city SMALLINT, email_domain SMALLINT, joined TIMESTAMP NOT NULL, status status, sex sex NOT NULL, interests SMALLINT[], premium tsrange, likes_ids INTEGER[], likes_tss INTEGER[], CHECK ( joined >= '01.01.2011'::timestamp ), CHECK ( joined <= '01.01.2018'::timestamp ) ); CREATE INDEX IF NOT EXISTS interests_ids_index ON accounts USING GIN(interests); 

रिकॉर्ड की संख्या 1,300,000 है , और ब्याज के संबंध का आकार:

अंतिम सर्किट:

 CREATE UNLOGGED TABLE accounts ( id INTEGER PRIMARY KEY, email VARCHAR(100) UNIQUE, fname SMALLINT, sname VARCHAR(50), phone phone UNIQUE, birth TIMESTAMP NOT NULL, country SMALLINT, city SMALLINT, email_domain SMALLINT, joined TIMESTAMP NOT NULL, status status, sex sex NOT NULL, interests bit128, premium tsrange, likes_ids INTEGER[], likes_tss INTEGER[], CHECK ( joined >= '01.01.2011'::timestamp ), CHECK ( joined <= '01.01.2018'::timestamp ) ); 

आयाम:

दो प्रकार जोड़े गए: फोन और बिट128 ।

फ़ोन

फोन नंबर 8 (929) 5481819 है , आठ को खारिज किया जा सकता है। ऑपरेटर कोड 10 बिट्स, संख्या 24 बिट्स में फिट बैठता है, यह पता चला है कि आपको 5 बाइट्स की आवश्यकता है। मेमोरी में डेटा संरेखण के कारण बहुत सुविधाजनक संख्या नहीं है। 5, 6 या 8 बाइट्स में डेटा को कैसे फिट किया जाए, इस सवाल पर, केवल परीक्षण ही जवाब दे सकते हैं।

यदि आप प्रलेखन से उदाहरण का पालन करते हैं, तो आपको थोड़ी जरूरत है। परिभाषित प्रकार:

 class Phone : public PAllocNew<Phone> { public: bool fromCString(char* str) noexcept; char* toCString() const noexcept; int code() const noexcept; bool operator==(const Phone& b) const noexcept; bool operator<(const Phone& b) const noexcept; bool operator<=(const Phone& b) const noexcept; bool operator>(const Phone& b) const noexcept; bool operator>=(const Phone& b) const noexcept; private: uint64_t m_data = 0; }; #define GETARG_PHONE(x) reinterpret_cast<Phone*>(PG_GETARG_POINTER(x)) 

PAllocNew सहायक वर्ग ओवरलोडिंग new :

 template<typename T> class PAllocNew { public: static void* operator new(std::size_t count, const std::nothrow_t& tag) { return palloc(count); } }; 

पैलोक के माध्यम से आवंटित मेमोरी को लेनदेन पूरा होने पर मुक्त किया जाता है। I / O कार्य जोड़ें:

 Datum phone_in(PG_FUNCTION_ARGS) { char* str = PG_GETARG_CSTRING(0); auto v = new(std::nothrow) Phone; if (!v->fromCString(str)) { ereport(ERROR, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg( "invalid input syntax for phone: \"%s\"", str ))); } PG_RETURN_POINTER(v); } Datum phone_out(PG_FUNCTION_ARGS) { const auto phone = GETARG_PHONE(0); PG_RETURN_CSTRING(phone->toCString()); } 

और पंजीकरण प्रकार:

 CREATE TYPE phone; CREATE OR REPLACE FUNCTION phone_in ( cstring ) RETURNS phone AS 'libhighloadcup' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION phone_out ( phone ) RETURNS cstring AS 'libhighloadcup' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE TYPE phone ( INTERNALLENGTH = 8, INPUT = phone_in, OUTPUT = phone_out, ALIGNMENT = int4, COLLATE TRUE ); 

क्योंकि नए प्रकार का आकार 8 बाइट्स से अधिक नहीं है, इसे संदर्भ द्वारा नहीं, बल्कि मूल्य द्वारा प्रेषित किया जा सकता है। इस स्थिति में, आपको CREATE TYPE में PASSEDBYVALUE ध्वज को निर्दिष्ट करना होगा। या LIKE उपयोग करें:

 CREATE TYPE phone ( INPUT = phone_in, OUTPUT = phone_out, LIKE = int8, COLLATE TRUE ); 

इसके बाद PASSEDBYVALUE ALIGNMENT PASSEDBYVALUE ALIGNMENT और PASSEDBYVALUE विरासत PASSEDBYVALUE मिला है।

btree सूचकांक

विशिष्ट बी-ट्री इंडेक्स बनाकर क्षेत्र की विशिष्टता का समर्थन किया जाता है। यह ऑपरेटरों और रणनीतियों की कक्षाओं के माध्यम से किया जाता है।

 CREATE OPERATOR = ( PROCEDURE = phone_equal, LEFTARG = phone, RIGHTARG = phone, COMMUTATOR = =, NEGATOR = != ); CREATE OPERATOR < ( PROCEDURE = phone_lt, LEFTARG = phone, RIGHTARG = phone, NEGATOR = > ); CREATE OPERATOR <= ( PROCEDURE = phone_le, LEFTARG = phone, RIGHTARG = phone ); CREATE OPERATOR >= ( PROCEDURE = phone_ge, LEFTARG = phone, RIGHTARG = phone ); CREATE OPERATOR > ( PROCEDURE = phone_gt, LEFTARG = phone, RIGHTARG = phone, NEGATOR = < ); CREATE OPERATOR CLASS btree_phone_ops DEFAULT FOR TYPE phone USING btree AS OPERATOR 1 <, OPERATOR 2 <=, OPERATOR 3 =, OPERATOR 4 >=, OPERATOR 5 >, FUNCTION 1 phone_equal_internal ( phone, phone ); 

ऑपरेटर bool लौटाते हैं, और phone_equal_internal int:

 Datum phone_equal_internal(PG_FUNCTION_ARGS) { const auto a = GETARG_PHONE(0); const auto b = GETARG_PHONE(1); if (*a < *b) { PG_RETURN_INT32(-1); } if (*a > *b) { PG_RETURN_INT32(1); } PG_RETURN_INT32(0); } 

यह सब डेटा में थोड़ी कमी आई:

533,289 संख्या वाले खातों की संख्या, जो कि 41% है। सूचकांक के साथ काम करते समय कम से कम कोई स्ट्रिंग तुलना नहीं है।

bit128

मैं चौराहे के संचालन (&&), घटना (<@) के साथ और GIN समर्थन के साथ एक सा क्षेत्र रखना चाहता था। यह 96 बिट पर्याप्त था, लेकिन एक सरल पथ पर चला गया और uint128 ले लिया।

 class BitSet128: public PAllocNew<BitSet128> { public: bool haveIntersection(const BitSet128& b) const noexcept; bool contains(const BitSet128& b) const noexcept; bool operator==(const BitSet128& b) const noexcept; bool operator<(const BitSet128& b) const noexcept; bool operator>(const BitSet128& b) const noexcept; bool fromCString(char* str) noexcept; char* toCString() const noexcept; std::vector<uint8_t> keys() const; private: uint128 m_bits = 0; }; #define GETARG_BIT128(x) reinterpret_cast<BitSet128*>(PG_GETARG_POINTER(x)) 

प्रकार और संचालन का पंजीकरण:

 CREATE TYPE bit128 ( INTERNALLENGTH = 16, INPUT = bit128_in, OUTPUT = bit128_out, ALIGNMENT = int4 ); CREATE OPERATOR = ( PROCEDURE = bit128_equal, LEFTARG = bit128, RIGHTARG = bit128, COMMUTATOR = =, NEGATOR = != ); CREATE OPERATOR && ( PROCEDURE = bit128_intersection, LEFTARG = bit128, RIGHTARG = bit128 ); CREATE OPERATOR @> ( PROCEDURE = bit128_containts, LEFTARG = bit128, RIGHTARG = bit128 ); 

सामान्यीकृत उल्टा सूचकांक / GIN

Egor Rogov erogov ने PostgreSQL - 7 में लेख इंडेक्स में पोस्टग्रेज में GIN के बारे में अच्छी तरह से लिखा, इसे पूर्ण-पाठ खोज कार्य पर लागू किया। GIN एक्स्टेंसिबिलिटी डॉक्यूमेंटेशन बताता है कि 4 कार्यों को लागू करने के लिए यह पर्याप्त है:

अनुक्रमित ऑब्जेक्ट से कुंजियों की एक सरणी को प्राप्त करना:

 Datum *extractValue(Datum itemValue, int32 *nkeys, bool **nullFlags) 

अनुरोधित मान के लिए कुंजियाँ निकालता है:

 Datum *extractQuery(Datum query, int32 *nkeys, StrategyNumber n, bool **pmatch, Pointer **extra_data, bool **nullFlags, int32 *searchMode) 

उदाहरण के लिए, एक प्रश्न में:

 SELECT * FROM test WHERE a && ARRAY[1, 2, 3] 

extractQuery को ARRAY[1, 2, 3] सरणी पर लागू किया जाता है, और कुंजियाँ 1, 2, 3 हो सकती हैं।
जाँचता है कि क्या मान क्वेरी से मेल खाता है:

 bool consistent(bool check[], StrategyNumber n, Datum query, int32 nkeys, Pointer extra_data[], bool *recheck, Datum queryKeys[], bool nullFlags[]) 

चूंकि निकाले गए कुंजियों को खोज ट्री में संग्रहीत किया जाता है, हमें एक तुलना फ़ंक्शन की आवश्यकता होती है:

 int compare(Datum a, Datum b) 

एपीआई बेमानी लग सकता है, लेकिन वह सब कुछ प्रदान करता है जो काम में आ सकता है। आइए कार्यान्वयन के लिए आगे बढ़ें। मुख्य निष्कर्षण:

 Datum gin_extract_value_bit128(PG_FUNCTION_ARGS) { auto bitset = GETARG_BIT128(0); const auto bits = bitset->keys(); int32* nentries = (int32*) PG_GETARG_POINTER(1); *nentries = bits.size(); Datum* entries = NULL; entries = (Datum*) palloc(sizeof(Datum) * bits.size()); for (int i = 0; i < bits.size(); ++i) { entries[i] = DatumGetInt16(bits[i]); } PG_RETURN_POINTER(entries); } 

आउटपुट पैरामीटर nentries कुंजियों की संख्या लिखें और कुंजी entries की एक सरणी लौटाएं। प्रमुख तुलना:

 Datum bit128_cmp(PG_FUNCTION_ARGS) { const auto a = PG_GETARG_INT16(0); const auto b = PG_GETARG_INT16(1); if (a < b) { PG_RETURN_INT32(-1); } if (a > b) { PG_RETURN_INT32(1); } PG_RETURN_INT32(0); } 

इंडेक्स बनाने के लिए ये दो कार्य पर्याप्त हैं। सूचकांक द्वारा खोज करने पर अन्य कार्यों का उपयोग किया जाता है। अनुरोध से कुंजियाँ निकालना:

 Datum gin_extract_query_bit128(PG_FUNCTION_ARGS) { const auto a = GETARG_BIT128(0); int32* nentries = (int32*) PG_GETARG_POINTER(1); StrategyNumber strategy = PG_GETARG_UINT16(2); int32* searchMode = (int32*) PG_GETARG_POINTER(6); Datum* res = nullptr; const auto keys = a->keys(); *nentries = keys.size(); res = (Datum*) palloc(sizeof(Datum) * keys.size()); for (int i = 0; i < keys.size(); ++i) { res[i] = DatumGetInt16(keys[i]); } switch (strategy) { case RTOverlapStrategyNumber: // && if (*nentries > 0) { *searchMode = GIN_SEARCH_MODE_DEFAULT; } else { *searchMode = GIN_SEARCH_MODE_ALL; } break; case RTContainsStrategyNumber: // @> if (*nentries > 0) { *searchMode = GIN_SEARCH_MODE_DEFAULT; } else { *searchMode = GIN_SEARCH_MODE_ALL; } break; } PG_RETURN_POINTER(res); } 

पहला पैरामीटर मान ऑपरेटर के दाईं ओर से गुजरता है, तीसरा पैरामीटर रणनीति (ऑपरेटर) के लिए जिम्मेदार है जिसके द्वारा खोज की जाती है। खोज के तरीकों के बारे में प्रलेखन में बेहतर परिचित है। अनुपालन समारोह:

 Datum gin_bit128_consistent(PG_FUNCTION_ARGS) { bool* check = (bool*) PG_GETARG_POINTER(0); StrategyNumber strategy = PG_GETARG_UINT16(1); int32 nkeys = PG_GETARG_INT32(3); bool* recheck = (bool*) PG_GETARG_POINTER(5); bool res = true; switch (strategy) { case RTOverlapStrategyNumber: // && { for (int i = 0; i < nkeys; ++i) { if (check[i]) { res = true; } }; *recheck = false; } break; case RTContainsStrategyNumber: // @> { for (int i = 0; i < nkeys; ++i) { if (check[i]) { res = true; } }; *recheck = true; } break; } PG_RETURN_BOOL(res); } 

यदि अनुक्रमित ऑब्जेक्ट रणनीति संख्या के साथ क्वेरी ऑपरेटर को संतुष्ट करता true तो true । चेक ऐरे की लंबाई लंबी होती है, जो कि gin_extract_query_bit128 द्वारा दी गई चाबियों की संख्या से मेल खाती है। चेकिंग check[i] = true अर्थ है कि gin_extract_query_bit128 से i-th कुंजी अनुक्रमित वस्तु में मौजूद है। यह पार करने के लिए पर्याप्त है, लेकिन क्योंकि GIN में हम स्वयं मानों के साथ काम नहीं करते हैं, फिर प्रवेश रणनीति के लिए हम सही पर रीचेक करते हैं। यह परिणाम की जांच करने के लिए उपयुक्त ऑपरेटर को बुलाएगा। ऑपरेटर वर्ग:

 CREATE OR REPLACE FUNCTION gin_extract_value_bit128 ( bit128, internal, internal) RETURNS internal AS 'libhighloadcup' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION gin_extract_query_bit128(bit128, internal, int2, internal, internal) RETURNS internal AS 'libhighloadcup' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION gin_bit128_consistent(internal, int2, anyelement, int4, internal, internal) RETURNS bool AS 'libhighloadcup' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OPERATOR CLASS bit128_ops DEFAULT FOR TYPE bit128 USING gin AS OPERATOR 3 &&, OPERATOR 6 =, OPERATOR 7 @>, FUNCTION 1 bit128_cmp (int2, int2 ), FUNCTION 2 gin_extract_value_bit128(bit128, internal, internal), FUNCTION 3 gin_extract_query_bit128(bit128, internal, int2, internal, internal), FUNCTION 4 gin_bit128_consistent(internal, int2, anyelement, int4, internal, internal), STORAGE int2; 

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

एक दिलचस्प परिणाम है, क्योंकि बारीकियां हैं:

• डेटाबेस का भौतिक भंडारण;
• डेटा वितरण।

सभी बनाए गए प्रकारों का एक निश्चित आकार होता है, इसलिए उनके लिए PLAIN संग्रहण का चयन किया जाता है। संपीड़न और अलग भंडारण उन पर लागू नहीं होता है। चर-लंबाई प्रकारों के अर्रे और तार टोस्ट से होकर गुजरते हैं। हां, भंडारण के आकार के लिए ओवरहेड है, लेकिन संपीड़न भी है।

हितों का वितरण निम्नानुसार है:

ईमानदारी से, मैं नहीं जानता कि कैसे SMALLINT[] जारी किया जाता है, लेकिन मान लें कि प्रति आकार 4 बाइट्स और 2 बाइट्स प्रति मान हैं। फिर 16 बाइट्स में आप 6 तत्वों की एक सरणी फिट कर सकते हैं। और 98% तत्व 16 बाइट्स और 16 एमबी के अंतर में फिट होंगे। ऐसा लगता है कि bit128 प्रकार निरर्थक है, लेकिन इस डेटा सेट पर मानक प्रकार निरर्थक है।