PostgreSQL के लिए सीरियल छद्म-डेटाटाइप का अवलोकन

परिचय

PostgreSQL मूल रूप से कई व्यावहारिक उपयोग के मामलों का समर्थन करने वाले डेटा प्रकारों की एक समृद्ध विविधता प्रदान करता है। यह लेख विशेष रूप से सिंथेटिक प्राथमिक कुंजियों के निर्माण के लिए उपयोग किए जाने वाले सीरियल डेटा प्रकारों के विशेष कार्यान्वयन का परिचय देता है।

अद्वितीय कुंजी

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

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

सीरियल डेटा प्रकार घोषित करना

PostgreSQL सिंथेटिक कुंजी की इस आवश्यकता को पूरा करने के लिए एक विशेष डेटाटाइप घोषणा प्रदान करता है। डेटाबेस टेबल कॉलम को सीरियल प्रकार के रूप में घोषित करना नए टुपल्स के सम्मिलन पर अद्वितीय पूर्णांक की आपूर्ति करके सिंथेटिक कुंजी की आवश्यकता को पूरा करता है। यह छद्म-डेटाटाइप एक पूर्णांक डेटा प्रकार कॉलम को एक फ़ंक्शन कॉल के माध्यम से प्राप्त एक संबद्ध डिफ़ॉल्ट मान के साथ लागू करता है जो वृद्धिशील पूर्णांक मानों की आपूर्ति करता है। सीरियल प्रकार के आईडी कॉलम के साथ एक साधारण तालिका बनाने के लिए निम्न कोड निष्पादित करना:

CREATE TABLE person (id serial, full_name text);
actually executes the following DDL
CREATE TABLE person (
    id integer NOT NULL,
    full_name text
);

CREATE SEQUENCE person_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;
ALTER SEQUENCE person_id_seq OWNED BY person.id;
ALTER TABLE ONLY person
    ALTER COLUMN id
    SET DEFAULT nextval('person_id_seq'::regclass);

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

बिल्ट-इन फ़ंक्शन नेक्स्टवल एक ऑटोइनक्रिकमेंट सेवा करता है:हर बार नेक्स्टवल को कहा जाता है कि यह निर्दिष्ट अनुक्रम काउंटर को बढ़ाता है और नए-इन्क्रीमेंट किए गए मान को लौटाता है।

आप तालिका परिभाषा की जांच करके इस आशय का परिणाम देख सकते हैं:

postgres=# \d person
                   Table "public.person"
  Column   |  Type   |         Modifiers
-----------+---------+-----------------------------------------
 Id        | integer | not null default nextval('person_id_seq'::regclass)
 full_name | text    |

सीरियल मान सम्मिलित करना

ऑटो-इन्क्रीमेंट कार्यक्षमता का उपयोग करने के लिए, हम सीरियल कॉलम के लिए डिफ़ॉल्ट मान पर निर्भर करते हुए, केवल पंक्तियों को सम्मिलित करते हैं:

INSERT INTO person (full_name) VALUES ('Alice');
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
(1 row)

हम देखते हैं कि नई "एलिस" पंक्ति के अनुरूप आईडी कॉलम के लिए एक मान स्वचालित रूप से उत्पन्न हो गया है। वैकल्पिक रूप से, यदि सभी कॉलम नामों को स्पष्ट रूप से सूचीबद्ध करना वांछित है, तो कोई व्यक्ति डिफ़ॉल्ट कीवर्ड का उपयोग कर सकता है:

INSERT INTO person (id, full_name) VALUES (DEFAULT, 'Bob');
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
  2 | Bob
(2 rows)

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

कई पंक्तियों को सम्मिलित करना भी काम करता है:

INSERT INTO person (full_name) VALUES ('Cathy'), ('David');
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
  2 | Bob
  3 | Cathy
  4 | David
(4 rows)

अनुपलब्ध सीरियल मान

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

BEGIN TRANSACTION;
INSERT INTO person (full_name) VALUES ('Eve');
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
  2 | Bob
  3 | Cathy
  4 | David
  5 | Eve
(5 rows)
ROLLBACK;
INSERT INTO person (full_name) VALUES ('Fred');
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
  2 | Bob
  3 | Cathy
  4 | David
  6 | Fred
(5 rows)

रोलबैक का सम्मान न करने का लाभ यह है कि समवर्ती सम्मिलन का प्रयास करने वाले अन्य सत्र अन्य सम्मिलन सत्रों द्वारा अवरुद्ध नहीं होते हैं।

अनुपलब्ध मानों को समाप्त करने का दूसरा तरीका यह है कि यदि पंक्तियाँ हटा दी जाती हैं:

DELETE FROM person WHERE full_name = 'Cathy';
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
  2 | Bob
  4 | David
  6 | Fred
(4 rows)

ध्यान दें कि सबसे बड़ी ऑटो-इंक्रीमेंट आईडी कॉलम वैल्यू के अनुरूप सबसे हाल ही में डाली गई पंक्ति को हटाने के बाद भी, अनुक्रम काउंटर वापस नहीं आता है, यानी, 'फ्रेड' से संबंधित पंक्ति को हटाने के बाद भी, बाद के सम्मिलन के लिए अनुक्रम काउंटर अभी भी बरकरार रहता है पहले से ज्ञात सबसे बड़ा मूल्य और वहां से वेतन वृद्धि:

DELETE FROM person WHERE full_name = 'Fred';
INSERT INTO person (full_name) VALUES ('Gina');
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
  2 | Bob
  4 | David
  7 | Gina
(4 rows)

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

नहीं आप नहीं कर सकते - हाँ आप कर सकते हैं!

सीरियल स्यूडो-डेटाटाइप द्वारा लगाए गए नॉट न्यूल बाधा इस तरह के इंसर्ट प्रयासों को अस्वीकार करके आईडी कॉलम के लिए NULL के सम्मिलन से बचाता है:

INSERT INTO person (id, full_name) VALUES (NULL, 'Henry');
ERROR:  null value in column "id" violates not-null constraint
DETAIL:  Failing row contains (null, Henry).

इस प्रकार, हमें उस विशेषता के लिए एक मूल्य होने का आश्वासन दिया जाता है।

हालांकि, कुछ लोगों का सामना करने वाली समस्या यह है कि, जैसा कि ऊपर घोषित किया गया है, कुछ भी मूल्यों के स्पष्ट सम्मिलन को रोकता है, अगले फ़ंक्शन के आह्वान के माध्यम से प्राप्त डिफ़ॉल्ट ऑटोइनक्रिकमेंट मान को छोड़कर:

INSERT INTO person (id, full_name) VALUES (9, 'Ingrid');
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
  2 | Bob
  4 | David
  7 | Gina
  9 | Ingrid
(5 rows)

लेकिन बाद में डिफ़ॉल्ट का उपयोग करते हुए दो प्रविष्टियां आईडी कॉलम के लिए एक डुप्लिकेट मान उत्पन्न करती हैं यदि अनुक्रम मान के विरुद्ध कॉलम मानों की कोई बाधा जांच नहीं है:

INSERT INTO person (full_name) VALUES ('James');
INSERT INTO person (full_name) VALUES ('Karen');
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
  2 | Bob
  4 | David
  7 | Gina
  9 | Ingrid
  8 | James
  9 | Karen
(7 rows)

यदि हम वास्तव में सीरियल आईडी कॉलम को एक कुंजी के रूप में उपयोग कर रहे थे, तो हम इसे प्राथमिक कुंजी के रूप में घोषित कर देते थे या कम से कम एक अद्वितीय इंडेक्स बनाते थे। अगर हमने ऐसा किया होता, तो ऊपर दिया गया 'करेन' इंसर्ट डुप्लीकेट कुंजी त्रुटि के साथ विफल हो जाता। पोस्टग्रेएसक्यूएल की सबसे हालिया रिलीज़ में एक नया बाधा घोषणा सिंटैक्स शामिल है जो 'पहचान के रूप में डिफ़ॉल्ट रूप से उत्पन्न होता है' जो इस नुकसान और सीरियल छद्म-डेटाटाइप से संबंधित कुछ अन्य विरासत मुद्दों से बचा जाता है।

अनुक्रम हेरफेर कार्य

नेक्स्टवल फंक्शन के अलावा हमने पहले ही उल्लेख किया है कि कौन सी सीक्वेंस को आगे बढ़ाता है और नया वैल्यू देता है, सीक्वेंस वैल्यू को क्वेरी और सेट करने के लिए कुछ अन्य फंक्शन हैं:कर्वल फंक्शन रिटर्न वैल्यू सबसे हाल ही में निर्दिष्ट सीक्वेंस के लिए नेक्स्टवल के साथ प्राप्त होता है, लास्टवल फंक्शन किसी भी अनुक्रम के लिए नेक्स्टवल के साथ हाल ही में प्राप्त मूल्य लौटाता है, और सेटवल फ़ंक्शन अनुक्रम का वर्तमान मान सेट करता है। इन कार्यों को सरल प्रश्नों के साथ बुलाया जाता है। उदाहरण के लिए

SELECT currval('person_id_seq');
 currval
---------
       9
(1 row)

और ध्यान दें कि अगर नेक्स्टवल फंक्शन में कॉल वास्तव में इंसर्ट करने से स्वतंत्र रूप से की जाती है, तो यह सीक्वेंस को बढ़ा देता है, और यह बाद के इंसर्ट में दिखाई देगा:

SELECT nextval('person_id_seq');
 nextval
---------
      10
(1 row)
INSERT INTO person (full_name) VALUES ('Larry');
SELECT * FROM person;
 id | full_name
----+-----------
  1 | Alice
  2 | Bob
  4 | David
  7 | Gina
  9 | Ingrid
  8 | James
  9 | Karen
 11 | Larry
(8 rows)

निष्कर्ष

हमने ऑटो-इंक्रीमेंटेड सिंथेटिक कुंजियों के लिए PostgreSQL SERIAL छद्म-डेटाटाइप की एक बुनियादी समझ पेश की है। इस आलेख में उदाहरण के लिए, हमने सीरियल प्रकार की घोषणा का उपयोग किया, जो 4-बाइट पूर्णांक कॉलम बनाता है। PostgreSQL क्रमशः 2-बाइट और 8-बाइट कॉलम आकार के लिए SMALLSERIAL और BIGSERIAL छद्म-डेटाटाइप के साथ विभिन्न श्रेणी की जरूरतों को समायोजित करता है। बिना किसी लापता मान वाले अनुक्रमों की आवश्यकता को संबोधित करने के एक माध्यम पर भविष्य के लेख की तलाश करें।