पोस्टग्रेज बाधा

यह "आसान" है क्योंकि PostgreSQL इतना एक्स्टेंसिबल है। आप btree के साथ उपयोग करने के लिए अपने स्वयं के प्रकार, प्रकार के लिए तुलना ऑपरेटर और ऑपरेटर वर्ग को परिभाषित कर सकते हैं अनुक्रमणिका ताकि PostgreSQL उनकी तुलना करना जानता हो।

चाल "बराबर" को इस तरह परिभाषित करना है कि परस्पर विरोधी मान समान हों।

सबसे पहले, हम अपने प्रकार को परिभाषित करते हैं:

CREATE TYPE tod AS ENUM ('morning', 'afternoon', 'anytime');

फिर हम एक इंडेक्स सपोर्ट रूटीन . को परिभाषित करते हैं ताकि btree सूचकांक मूल्यों की तुलना करना जानता है:

CREATE FUNCTION tod_compare(tod, tod) RETURNS integer
   IMMUTABLE LANGUAGE sql AS
$$SELECT CASE WHEN $1 = 'morning' AND $2 = 'afternoon' THEN -1
            WHEN $1 = 'afternoon' AND $2 = 'morning' THEN 1
            ELSE 0
       END$$;

इस तुलना फ़ंक्शन के आधार पर, हम उन कार्यों को परिभाषित करते हैं जो तुलना ऑपरेटरों को लागू करते हैं:

CREATE FUNCTION tod_eq(tod, tod) RETURNS boolean IMMUTABLE LANGUAGE sql
   AS 'SELECT tod_compare($1, $2) = 0';

CREATE FUNCTION tod_lt(tod, tod) RETURNS boolean IMMUTABLE LANGUAGE sql
   AS 'SELECT tod_compare($1, $2) = -1';

CREATE FUNCTION tod_le(tod, tod) RETURNS boolean IMMUTABLE LANGUAGE sql
   AS 'SELECT tod_compare($1, $2) <= 0';

CREATE FUNCTION tod_ge(tod, tod) RETURNS boolean IMMUTABLE LANGUAGE sql
   AS 'SELECT tod_compare($1, $2) >= 0';

CREATE FUNCTION tod_gt(tod, tod) RETURNS boolean IMMUTABLE LANGUAGE sql
   AS 'SELECT tod_compare($1, $2) = 1';

CREATE FUNCTION tod_ne(tod, tod) RETURNS boolean IMMUTABLE LANGUAGE sql
   AS 'SELECT tod_compare($1, $2) <> 0';

अब हम अपने प्रकार के अनुसार ऑपरेटरों को परिभाषित कर सकते हैं:

CREATE OPERATOR ~=~ (
   PROCEDURE = tod_eq,
   LEFTARG = tod,
   RIGHTARG = tod,
   COMMUTATOR = ~=~,
   NEGATOR = ~<>~
);

CREATE OPERATOR ~<>~ (
   PROCEDURE = tod_ne,
   LEFTARG = tod,
   RIGHTARG = tod,
   COMMUTATOR = ~<>~,
   NEGATOR = ~=~
);

CREATE OPERATOR ~<=~ (
   PROCEDURE = tod_le,
   LEFTARG = tod,
   RIGHTARG = tod,
   COMMUTATOR = ~>=~,
   NEGATOR = ~>~
); 

CREATE OPERATOR ~<~ (
   PROCEDURE = tod_lt,
   LEFTARG = tod,
   RIGHTARG = tod,
   COMMUTATOR = ~>~,
   NEGATOR = ~>=~
);

CREATE OPERATOR ~>~ (
   PROCEDURE = tod_gt,
   LEFTARG = tod,
   RIGHTARG = tod,
   COMMUTATOR = ~<~,
   NEGATOR = ~<=~
);

CREATE OPERATOR ~>=~ (
   PROCEDURE = tod_ge,
   LEFTARG = tod,
   RIGHTARG = tod,
   COMMUTATOR = ~<=~,
   NEGATOR = ~<~
);

अब जो कुछ बचा है वह एक ऑपरेटर वर्ग . को परिभाषित करना है जिसका उपयोग किसी इंडेक्स को परिभाषित करने के लिए किया जा सकता है (इसके लिए सुपरयुसर विशेषाधिकारों की आवश्यकता होती है):

CREATE OPERATOR CLASS tod_ops DEFAULT FOR TYPE tod USING btree AS
   OPERATOR 1 ~<~(tod,tod),
   OPERATOR 2 ~<=~(tod,tod),
   OPERATOR 3 ~=~(tod,tod),
   OPERATOR 4 ~>=~(tod,tod),
   OPERATOR 5 ~>~(tod,tod),
   FUNCTION 1 tod_compare(tod,tod);

अब हम एक तालिका परिभाषित कर सकते हैं जो नए डेटा प्रकार का उपयोग करती है।

चूंकि हमने tod_ops . को परिभाषित किया है tod . प्रकार के लिए डिफ़ॉल्ट ऑपरेटर वर्ग के रूप में , हम एक साधारण अद्वितीय बाधा बना सकते हैं, और अंतर्निहित अनुक्रमणिका हमारे ऑपरेटर वर्ग का उपयोग करेगी।

CREATE TABLE schedule (
   id integer PRIMARY KEY,
   day date NOT NULL,
   time_of_day tod NOT NULL,
   UNIQUE (day, time_of_day)
);

आइए इसका परीक्षण करें:

INSERT INTO schedule VALUES (1, '2018-05-01', 'morning');

INSERT INTO schedule VALUES (2, '2018-05-01', 'afternoon');

INSERT INTO schedule VALUES (3, '2018-05-02', 'anytime');

INSERT INTO schedule VALUES (4, '2018-05-02', 'morning');
ERROR:  duplicate key value violates unique constraint "schedule_day_time_of_day_key"
DETAIL:  Key (day, time_of_day)=(2018-05-02, morning) already exists.

क्या PostgreSQL अच्छा नहीं है?