SQL में इंटीग्रिटी कंस्ट्रेंट्स: उदाहरणों सहित मार्गदर्शिका

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

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

इस लेख में, हम SQL में आवश्यक इंटीग्रिटी कंस्ट्रेंट्स के प्रकारों को स्पष्ट व्याख्याओं और व्यावहारिक उदाहरणों के साथ समझेंगे, ताकि PostgreSQL डेटाबेस में उनके उपयोग को दर्शाया जा सके। हम PostgreSQL सिंटैक्स का उपयोग करेंगे, लेकिन अवधारणाएँ अन्य SQL डायलैक्ट्स पर भी आसानी से लागू होती हैं।

यदि आप SQL के बारे में और सीखना चाहते हैं, तो इस SQL पाठ्यक्रमों की सूची देखें।

SQL में इंटीग्रिटी कंस्ट्रेंट्स क्या हैं?

मान लीजिए हमारे पास एक टेबल है जो किसी वेब एप्लिकेशन के लिए उपयोगकर्ता जानकारी संग्रहीत करती है। कुछ डेटा, जैसे उपयोगकर्ता की आयु, वैकल्पिक हो सकता है क्योंकि यह उपयोगकर्ता को एप्लिकेशन तक पहुँचने से नहीं रोकता। हालाँकि, प्रत्येक उपयोगकर्ता के लिए लॉगिन हेतु पासवर्ड अनिवार्य है। इसे संबोधित करने के लिए, हम उपयोगकर्ता टेबल के पासवर्ड कॉलम पर एक इंटीग्रिटी कंस्ट्रेंट लागू करेंगे ताकि यह सुनिश्चित हो कि इस टेबल की हर एंट्री में पासवर्ड हो।

सार रूप में, इंटीग्रिटी कंस्ट्रेंट्स इन बातों के लिए महत्वपूर्ण हैं:

• डेटा के गायब होने से रोकना।
• सुनिश्चित करना कि सारा डेटा अपेक्षित प्रकारों और मान सीमाओं का पालन करे।
• विभिन्न टेबल्स में डेटा के बीच उचित लिंक बनाए रखना।

इस लेख में, हम SQL में निम्नलिखित आवश्यक इंटीग्रिटी कंस्ट्रेंट्स का अन्वेषण करेंगे:

• PRIMARY KEY: टेबल में प्रत्येक रिकॉर्ड की अद्वितीय पहचान करता है।
• NOT NULL: सुनिश्चित करता है कि कॉलम में NULL मान नहीं हो सकते।
• UNIQUE: सुनिश्चित करता है कि किसी कॉलम या कॉलमों के समूह में सभी मान अद्वितीय हों।
• DEFAULT: जब कोई मान निर्दिष्ट न किया गया हो तो कॉलम के लिए एक डिफ़ॉल्ट मान प्रदान करता है।
• CHECK: सुनिश्चित करता है कि किसी कॉलम के सभी मान एक विशेष शर्त को पूरा करें।
• FOREIGN KEY: किसी अन्य टेबल में प्राइमरी की को संदर्भित करके टेबल्स के बीच संबंध स्थापित करता है।

स्टडी केस: यूनिवर्सिटी डेटाबेस

आइए एक विश्वविद्यालय के लिए एक रिलेशनल डेटाबेस पर विचार करें। इस डेटाबेस में तीन टेबल्स हैं: students, courses, और enrollments।

Students टेबल

students टेबल में सभी विश्वविद्यालय छात्रों की जानकारी होती है।

• student_id: छात्र का पहचानकर्ता
• first_name: छात्र का पहला नाम।
• last_name: छात्र का अंतिम नाम।
• email: छात्र का ईमेल पता।
• major: छात्र का प्रमुख विषय (मेजर)।
• enrollment_year: वह वर्ष जिसमें छात्र ने नामांकन किया।

Courses टेबल

courses टेबल में विश्वविद्यालय में उपलब्ध पाठ्यक्रमों की जानकारी होती है।

• course_id: कोर्स का पहचानकर्ता।
• course_name: कोर्स का नाम।
• department: कोर्स का विभाग।

Enrollments टेबल

enrollments टेबल यह जानकारी रखती है कि कौन से छात्र किन कोर्सेज में नामांकित हैं।

• student_id: कोर्स में नामांकित छात्र का पहचानकर्ता।
• course_id: कोर्स का पहचानकर्ता।
• year: नामांकन वर्ष।
• grade: इस कोर्स में छात्र का ग्रेड।
• is_passing_grade: एक बूलियन जो बताता है कि ग्रेड पासिंग है या नहीं।

पूरे लेख में, हम इसी उदाहरण डेटाबेस का उपयोग करेंगे और डेटा इंटीग्रिटी लागू करने के कई तरीके दिखाएँगे। हम अपनी क्वेरीज़ में PostgreSQL सिंटैक्स का उपयोग करेंगे, हालाँकि अवधारणाएँ अन्य SQL फ्लेवर्स पर भी आसानी से लागू होती हैं।

PRIMARY KEY कंस्ट्रेंट

विश्वविद्यालय प्रत्येक छात्र की अद्वितीय पहचान करना चाहता है। इस उद्देश्य के लिए केवल पहला और अंतिम नाम उपयोग करना उचित नहीं है, क्योंकि एक जैसे नाम वाले छात्र हो सकते हैं। उसी तरह, ईमेल पतों पर निर्भर रहना भी आदर्श नहीं है क्योंकि छात्र अपने ईमेल बदल सकते हैं।

अद्वितीय पहचान सुनिश्चित करने का सामान्य समाधान प्रत्येक छात्र को एक अद्वितीय पहचानकर्ता सौंपना है, जिसे हम student_id कॉलम में संग्रहीत करते हैं। हम student_id कॉलम पर PRIMARY KEY कंस्ट्रेंट लागू कर सकते हैं ताकि सुनिश्चित हो कि प्रत्येक छात्र का एक अद्वितीय पहचानकर्ता हो।

यह कंस्ट्रेंट CREATE TABLE कमांड में, कॉलम डेटा प्रकार के बाद परिभाषित की जाती है:

CREATE TABLE students (
    student_id INT PRIMARY KEY,
    first_name TEXT,
    last_name TEXT,
    email TEXT,
    major TEXT,
    enrollment_year INT
);

ऊपर दी गई क्वेरी हमारे द्वारा बताए गए छह कॉलम के साथ student टेबल बनाती है।

PRIMARY KEY कंस्ट्रेंट यह सुनिश्चित करती है कि:

1. प्रत्येक छात्र का एक student_id हो।
2. प्रत्येक student_id अद्वितीय हो।

कई कॉलम पर PRIMARY KEY कंस्ट्रेंट

कुछ स्थितियों में हमें प्रत्येक पंक्ति की अद्वितीय पहचान के लिए कई कॉलमों का उपयोग करना पड़ता है। उदाहरण के लिए, enrollments टेबल में एक छात्र कई कोर्सेज में नामांकन कर सकता है, जिससे एक ही student_id वाली कई पंक्तियाँ हो सकती हैं। इसी तरह, एक कोर्स में कई छात्र हो सकते हैं, जिससे एक ही course_id वाली कई पंक्तियाँ बन सकती हैं।

चूँकि कोई एकल फ़ील्ड किसी पंक्ति की अद्वितीय पहचान नहीं कर सकती, इसलिए प्रत्येक नामांकन रिकॉर्ड student_id, course_id और year के संयोजन से निर्धारित होता है।

जब कई कॉलम शामिल होते हैं, तो PRIMARY KEY कंस्ट्रेंट CREATE TABLE कमांड के अंत में दी जाती है।

CREATE TABLE enrollments (
    student_id INT,
    course_id INT,
    year INT,
    grade INT,
    is_passing_grade BOOLEAN,
    PRIMARY KEY (student_id, course_id, year)
);

टेबल बनने के बाद इंटीग्रिटी कंस्ट्रेंट्स

इंटीग्रिटी कंस्ट्रेंट्स जोड़ने के दो तरीके हैं। हमने अभी देखा कि इसे टेबल बनाते समय कैसे जोड़ा जाता है।

मान लीजिए टेबल पहले से मौजूद है, लेकिन आप PRIMARY KEY कंस्ट्रेंट निर्दिष्ट करना भूल गए। आप ALTER TABLE कमांड का उपयोग करके इसे बाद में भी परिभाषित कर सकते हैं, जैसे:

ALTER TABLE enrollments
ADD CONSTRAINT enroll_pk 
PRIMARY KEY (student_id, course_id, year);

ALTER TABLE क्वेरी में, हमने कंस्ट्रेंट का नाम enroll_pk रखा है (enrollment primary key का संक्षिप्त रूप)। यह नाम आपकी पसंद का कोई भी पहचानकर्ता हो सकता है, लेकिन सलाह है कि ऐसा नाम चुनें जो कंस्ट्रेंट के उद्देश्य को संक्षेप में व्यक्त करे।

इंटीग्रिटी कंस्ट्रेंट्स का नामकरण सर्वोत्तम अभ्यास है क्योंकि इससे कई लाभ मिलते हैं:

• भविष्य में कंस्ट्रेंट्स को संशोधित या हटाने की आवश्यकता होने पर संदर्भ देना आसान हो जाता है।
• कंस्ट्रेंट्स के प्रबंधन और संगठन में सहायता मिलती है, विशेषकर उन डेटाबेस में जहाँ कंस्ट्रेंट्स की संख्या अधिक होती है।

NOT NULL कंस्ट्रेंट

विश्वविद्यालय यह सुनिश्चित करना चाहता है कि हर छात्र का नाम और ईमेल डेटाबेस में दर्ज हो। वे नहीं चाहते कि स्टाफ गलती से इनमें से किसी भी फ़ील्ड को छोड़ दे।

इसे रोकने के लिए, हम टेबल बनाते समय इन तीन कॉलमों पर NOT NULL कंस्ट्रेंट्स उपयोग कर सकते हैं:

CREATE TABLE students (
    student_id INT,
    first_name TEXT NOT NULL,
    last_name TEXT NOT NULL,
    email TEXT NOT NULL,
    major TEXT,
    enrollment_year INT
);

ऊपर दी गई क्वेरी NOT NULL कंस्ट्रेंट्स का उपयोग करती है ताकि first_name, last_name और email कॉलम में NULL (अपरिभाषित) मान न हो सकें।

मौजूदा टेबल में NOT NULL कंस्ट्रेंट जोड़ना ALTER TABLE कमांड से किया जा सकता है। NOT NULL कंस्ट्रेंट जोड़ने का सिंटैक्स इस प्रकार है:

ALTER TABLE students
ALTER COLUMN first_name SET NOT NULL,
ALTER COLUMN last_name SET NOT NULL,
ALTER COLUMN email SET NOT NULL;

UNIQUE कंस्ट्रेंट

ईमेल पते स्वभावतः प्रत्येक व्यक्ति के लिए अद्वितीय होते हैं। जहाँ हमें यकीन है कि किसी फ़ील्ड में कभी भी डुप्लिकेट मान नहीं होना चाहिए, वहाँ डेटाबेस स्तर पर इसे लागू करना एक अच्छा अभ्यास है। इससे गलतियों को रोका जा सकता है और डेटा इंटीग्रिटी सुनिश्चित होती है।

यह कंस्ट्रेंट अन्य कंस्ट्रेंट्स की तरह ही जोड़ी जाती है।

CREATE TABLE students (
    ...
    email TEXT UNIQUE,
    ...
);

हालाँकि, हमारे मामले में हम NOT NULL कंस्ट्रेंट भी लागू करना चाहते हैं। हम एक ही कॉलम पर स्पेस से अलग करके कई कंस्ट्रेंट्स लागू कर सकते हैं: 

CREATE TABLE students (
    ...
    email TEXT UNIQUE NOT NULL,
    ...
);

ध्यान दें कि क्रम मायने नहीं रखता, हम NOT NULL UNIQUE भी लिख सकते थे।

मौजूदा टेबल में UNIQUE कंस्ट्रेंट जोड़ना इस प्रकार किया जाता है:

ALTER TABLE students 
ADD CONSTRAINT unique_emails UNIQUE (email);

कई कॉलमों पर UNIQUE कंस्ट्रेंट

मान लीजिए हम यह सुनिश्चित करना चाहते हैं कि courses टेबल में प्रत्येक विभाग के भीतर कोर्स का नाम अद्वितीय हो। इस स्थिति में, course_name और department कॉलम एक साथ मिलकर अद्वितीय होने चाहिए।

जब कई कॉलम शामिल होते हैं, तो कंस्ट्रेंट CREATE TABLE कमांड के अंत में जोड़ी जाती है:

CREATE TABLE courses (
    course_id INT,
    course_name TEXT,
    department TEXT,
    UNIQUE (course_name, department)
);

वैकल्पिक रूप से, हम मौजूदा टेबल को बदलकर भी कंस्ट्रेंट जोड़ सकते हैं। इस मामले में, हम कॉलमों के नामों के साथ एक टपल प्रदान करते हैं:

ALTER TABLE courses 
ADD CONSTRAINT unique_course_name_department 
UNIQUE (course_name, department);

NOT NULL UNIQUE बनाम PRIMARY KEY कंस्ट्रेंट्स 

हमने सीखा कि PRIMARY KEY कंस्ट्रेंट अद्वितीयता भी लागू करती है और यह भी कि मान गायब नहीं हो सकते। तो आप सोच सकते हैं कि इनमें क्या अंतर है:

course_id INT PRIMARY KEY

course_id INT UNIQUE NOT NULL

किसी टेबल पर NOT NULL UNIQUE और PRIMARY KEY के बीच अंतर उनके प्रयोजन और उपयोग में है। 

हालाँकि दोनों किसी कॉलम(ज़) पर अद्वितीयता और नॉन-नलाबिलिटी लागू करते हैं, एक टेबल में केवल एक PRIMARY KEY हो सकती है, जिसका उद्देश्य टेबल में प्रत्येक रिकॉर्ड की अद्वितीय पहचान करना है।

दूसरी ओर, NOT NULL UNIQUE का संयोजन अतिरिक्त कॉलमों पर लागू किया जा सकता है ताकि प्रत्येक पंक्ति में बिना NULL मानों के अद्वितीय मान लागू हों, जो विशिष्ट व्यावसायिक नियमों के लिए डेटा इंटीग्रिटी बनाए रखने का कार्य करता है। एक टेबल में किसी भी संख्या में NOT NULL UNIQUE कंस्ट्रेंट्स हो सकती हैं।

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

DEFAULT कंस्ट्रेंट

छात्रों को विश्वविद्यालय में पंजीकरण के बाद अपना मेजर चुनने में कुछ समय लग सकता है। विश्वविद्यालय चाहता है कि जिन छात्रों ने अभी अपना मेजर नहीं चुना है, उनके लिए major कॉलम का मान ’Undeclared’ स्ट्रिंग हो।

ऐसा करने के लिए, हम DEFAULT कंस्ट्रेंट का उपयोग करके इस कॉलम का डिफ़ॉल्ट मान सेट कर सकते हैं। हम students टेबल को इस प्रकार बदल सकते हैं:

ALTER TABLE students
ALTER COLUMN major SET DEFAULT 'Undeclared';

यदि हम टेबल बनाते समय ही DEFAULT कंस्ट्रेंट सेट करना चाहें, तो इसे कॉलम डेटा प्रकार के बाद घोषित कर सकते हैं:

CREATE TABLE students (
    ...
    major TEXT DEFAULT 'Undeclared',
    ...
);

CHECK कंस्ट्रेंट

इस विशेष विश्वविद्यालय में ग्रेड 0 से 100 तक होते हैं। बिना किसी कंस्ट्रेंट के, enrollment टेबल का grade कॉलम कोई भी पूर्णांक मान स्वीकार कर सकता है। हम CHECK कंस्ट्रेंट का उपयोग करके इसे ठीक कर सकते हैं ताकि मान 0 और 100 के बीच सीमित रहें।

ALTER TABLE enrollments
ADD CONSTRAINT grade_range CHECK (grade BETWEEN 0 AND 100);

सामान्य रूप से, CHECK कंस्ट्रेंट्स हमें विशिष्ट शर्तों का सत्यापन करने देती हैं जिन्हें हम चाहते हैं कि डेटा पूरा करे। ये डेटा की सुसंगति और इंटीग्रिटी सुनिश्चित करने के लिए महत्वपूर्ण हैं।

एक CHECK कंस्ट्रेंट में एक से अधिक कॉलम शामिल हो सकते हैं। आइए इसका उपयोग यह सुनिश्चित करने के लिए करें कि grade और is_passing_grade के मान आपस में सुसंगत हों। मान लीजिए ग्रेड पासिंग है यदि उसका मान कम से कम 60 है। तब हम सुनिश्चित कर सकते हैं कि is_passing_grade तब और केवल तब TRUE हो जब ग्रेड कम से कम 60 हो। आइए इसे टेबल निर्माण में करें ताकि दिखाया जा सके कि CHECK कंस्ट्रेंट्स CREATE TABLE कमांड में कैसे घोषित किए जाते हैं:

CREATE TABLE enrollments (
    ...
    grade INT,
    is_passing_grade BOOLEAN,
    CONSTRAINT grade_check CHECK (grade BETWEEN 0 AND 100),
    CONSTRAINT is_passing_grade CHECK (
        (grade >= 60 AND is_passing_grade = TRUE) OR
        (grade < 60 AND is_passing_grade = FALSE)
    )
);

ऊपर दिए गए कंस्ट्रेंट में एक समस्या है। जब कोई छात्र किसी कोर्स में नामांकन करता है, तो उसके पास अभी ग्रेड नहीं होगा। इसलिए हमें ग्रेड पर NULL मानों की अनुमति देनी चाहिए। ऐसा करते समय, हमें पासिंग ग्रेड कंस्ट्रेंट को भी अपडेट करना होगा ताकि ग्रेड अभी अपरिभाषित होने पर वह भी NULL हो। इन्हें ध्यान में रखते हुए कंस्ट्रेंट को इस तरह अपडेट किया जा सकता है:

CREATE TABLE enrollments (
    ...    
    grade INT NULL DEFAULT NULL,
    is_passing_grade BOOLEAN NULL DEFAULT NULL,
    CONSTRAINT grade_check CHECK (grade BETWEEN 0 AND 100),
    CONSTRAINT is_passing_grade CHECK (
        (grade IS NULL AND is_passing_grade IS NULL) OR
        (grade >= 60 AND is_passing_grade = TRUE) OR
        (grade < 60 AND is_passing_grade = FALSE)
    ),
    ...
);

ध्यान दें कि हमने grade और is_passing_grade दोनों कॉलमों पर डेटा प्रकार में और डिफ़ॉल्ट मान के रूप में NULL जोड़ा है। इसका उद्देश्य सिर्फ पठनीयता बढ़ाना है।

अब देखते हैं कि हम CHECK कंस्ट्रेंट से किन-किन प्रकार की शर्तें लागू कर सकते हैं।

रेंज (सीमा) शर्तें

हम सुनिश्चित कर सकते हैं कि किसी कॉलम के मान एक विशिष्ट सीमा के भीतर हों।

ALTER TABLE table_name
ADD CONSTRAINT constraint_name 
CHECK (column_name BETWEEN min_value AND max_value);

सूची आधारित शर्तें

हम यह वैधित कर सकते हैं कि किसी कॉलम का मान किसी विशिष्ट मानों की सूची में से एक हो।

ALTER TABLE table_name
ADD CONSTRAINT constraint_name 
CHECK (column_name IN ('Value1', 'Value2', 'Value3'));

तुलनात्मक शर्तें

हम किसी कॉलम के मानों की तुलना कर सकते हैं ताकि वे दी गई शर्त (बड़ा, छोटा, आदि) को पूरा करें।

ALTER TABLE table_name
ADD CONSTRAINT constraint_name 
CHECK (column_name > some_value);

पैटर्न मिलान शर्तें

हम टेक्स्ट डेटा के सत्यापन के लिए पैटर्न मिलान (जैसे LIKE या SIMILAR TO) का उपयोग कर सकते हैं।

ALTER TABLE table_name
ADD CONSTRAINT constraint_name 
CHECK (column_name LIKE 'pattern');

तार्किक शर्तें

हम लॉजिकल ऑपरेटर (AND, OR, NOT) का उपयोग करके कई शर्तों की अनुमति दे सकते हैं।

ALTER TABLE table_name
ADD CONSTRAINT constraint_name 
CHECK (condition1 AND condition2 OR condition3);

समग्र (कम्पोज़िट) शर्तें

कई कॉलमों पर एक शर्त लागू करता है।

ALTER TABLE table_name
ADD CONSTRAINT constraint_name 
CHECK (column1 + column2 < some_value);

FOREIGN KEY कंस्ट्रेंट

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

हमारे उदाहरण में, enrollments टेबल का प्रत्येक रिकॉर्ड क्रमशः student_id और course_id कॉलमों के माध्यम से किसी छात्र और किसी कोर्स को संदर्भित करता है। बिना किसी कंस्ट्रेंट के, enrollments टेबल में इन पहचानकर्ताओं के मानों के students और courses टेबल्स में मौजूदा प्रविष्टियों से मेल खाने की कोई गारंटी नहीं है।

enrollments टेबल बनाते समय इसे इस तरह सुनिश्चित किया जाता है:

CREATE TABLE enrollments (
    student_id INT,
    course_id INT,
    ...
    FOREIGN KEY (student_id) REFERENCES Students(student_id),
    FOREIGN KEY (course_id) REFERENCES Courses(course_id)
);

ध्यान दें कि इनके फॉरेन की होने के लिए, ये क्रमशः students और courses टेबल्स में प्राइमरी की होने चाहिए।

अन्य कंस्ट्रेंट्स की तरह, हम इन्हें टेबल बनने के बाद भी ALTER TABLE कमांड का उपयोग करके घोषित कर सकते हैं:

ALTER TABLE enrollments
ADD CONSTRAINT fk_student_id
FOREIGN KEY (student_id)
REFERENCES students(student_id);

ALTER TABLE enrollments
ADD CONSTRAINT fk_course_id
FOREIGN KEY (course_id)
REFERENCES courses(course_id);

सब कुछ एक साथ जोड़ना

इस लेख के दौरान, हमने कई इंटीग्रिटी कंस्ट्रेंट्स दिखाए और यह भी कि उन्हें विश्वविद्यालय के डेटाबेस में कैसे उपयोग करें। यहाँ CREATE TABLE कमांड का अंतिम संस्करण है, जो अब तक सीखी गई हर चीज़ को जोड़ता है।

पहले, हम students टेबल परिभाषित करेंगे:

CREATE TABLE students (
    student_id INT PRIMARY KEY,
    first_name TEXT NOT NULL,
    last_name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL,
    major TEXT DEFAULT 'Undeclared',
    enrollment_year INT,
    CONSTRAINT year_check CHECK (enrollment_year >= 1900),
    CHECK (major IN (
        'Undeclared',
        'Computer Science',
        'Mathematics',
        'Biology',
        'Physics',
        'Chemistry',
        'Biochemistry'
    ))
);

अगला, हम courses टेबल परिभाषित करेंगे:

CREATE TABLE courses (
    course_id INT PRIMARY KEY,
    course_name TEXT NOT NULL,
    department TEXT NOT NULL,
    UNIQUE (course_name, department),
    CHECK (department IN (
        'Physics & Mathematics',
        'Sciences'
    ))
);

अंत में, हम enrollments टेबल परिभाषित करेंगे, जो छात्रों और कोर्सेज के बीच संबंध स्थापित करेगी:

CREATE TABLE enrollments (
    student_id INT,
    course_id INT,
    year INT CHECK (year >= 1900),
    grade INT NULL DEFAULT NULL,
    is_passing_grade BOOLEAN NULL DEFAULT NULL,
    CONSTRAINT grade_check CHECK (grade BETWEEN 0 AND 100),
    CONSTRAINT is_passing_grade CHECK (
        (grade IS NULL AND is_passing_grade IS NULL) OR
        (grade >= 60 AND is_passing_grade = TRUE) OR
        (grade < 60 AND is_passing_grade = FALSE)
    ),
    FOREIGN KEY (student_id) REFERENCES students(student_id),
    FOREIGN KEY (course_id) REFERENCES courses(course_id),
    PRIMARY KEY (student_id, course_id, year)
);

हमने इस अंतिम उदाहरण में कुछ अतिरिक्त कंस्ट्रेंट्स जोड़ी हैं। किसी विश्वविद्यालय में विभागों और मेजर्स का एक निर्धारित सेट होता है। इसलिए, major और department कॉलम जिन मानों को ले सकते हैं, उनका समूह सीमित और पहले से ज्ञात होता है। ऐसी स्थितियों में, CHECK कंस्ट्रेंट का उपयोग करना अनुशंसित है ताकि ये कॉलम केवल उसी ज्ञात सेट के मान ले सकें।

निष्कर्ष

इस लेख में, हमने SQL में विभिन्न प्रकार के इंटीग्रिटी कंस्ट्रेंट्स और उन्हें PostgreSQL का उपयोग करके कैसे लागू किया जाए, इसका अन्वेषण किया। हमने प्राइमरी की, NOT NULL कंस्ट्रेंट्स, UNIQUE कंस्ट्रेंट्स, DEFAULT कंस्ट्रेंट्स, CHECK कंस्ट्रेंट्स, और FOREIGN KEY कंस्ट्रेंट्स को शामिल किया और प्रत्येक के व्यावहारिक उदाहरण प्रदान किए।

इन अवधारणाओं को समझकर, हम अपने डेटा की शुद्धता, सुसंगति और विश्वसनीयता सुनिश्चित कर सकते हैं।

यदि आप डेटा को कुशलतापूर्वक संगठित करने के बारे में और सीखना चाहते हैं, तो Database Design पर यह कोर्स देखें।