SQL सर्वर डेटाबेस में सभी बाधा उल्लंघनों को कैसे खोजें

आप DBCC CHECKCONSTRAINTS चला सकते हैं SQL सर्वर डेटाबेस में सभी बाधा उल्लंघनों की सूची वापस करने के लिए कंसोल कमांड।

यह कमांड किसी निर्दिष्ट बाधा या वर्तमान डेटाबेस में एक निर्दिष्ट तालिका पर सभी बाधाओं की अखंडता की जाँच करता है। यह कोई भी विदेशी कुंजी देता है और CHECK बाधा उल्लंघन जो इसे पाता है।

आप ALL_CONSTRAINTS का उपयोग कर सकते हैं सक्षम और अक्षम दोनों बाधाओं की जाँच करने का विकल्प। यदि आप इसे छोड़ देते हैं, तो केवल सक्षम बाधाओं को वापस किया जाता है (जब तक कि आप स्पष्ट रूप से जांच करने के लिए एक बाधा निर्दिष्ट नहीं करते हैं, इस मामले में इसे वापस कर दिया जाएगा चाहे वह सक्षम या अक्षम हो)।

उदाहरण 1 - उल्लंघन की जांच की बाधाएं

मैंने इस उदाहरण को एक डेटाबेस के विरुद्ध चलाया जिसमें कुछ CHECK . शामिल हैं बाधा उल्लंघन।

USE Test;
DBCC CHECKCONSTRAINTS WITH ALL_CONSTRAINTS;

परिणाम:

+------------------------+-------------------+---------------------------------------------------------+
| Table                  | Constraint        | Where                                                   |
|------------------------+-------------------+---------------------------------------------------------|
| [dbo].[Occupation]     | [chkJobTitle]     | [JobTitle] = 'Digital Nomad'                            |
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2020-01-01' AND [EndDate] = '1999-01-01' |
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2021-10-25' AND [EndDate] = '2021-10-24' |
+------------------------+-------------------+---------------------------------------------------------+

इससे पता चलता है कि मेरे डेटाबेस में तीन बाधा उल्लंघन हैं।

कॉलम की व्याख्या

तीन कॉलम निम्नलिखित जानकारी लौटाते हैं:

तालिका

तालिका नाम का नाम जिसमें बाधा उल्लंघन शामिल है।

बाधा

बाधा का नाम जिसका उल्लंघन किया गया है।

कहां

कॉलम मान असाइनमेंट जो बाधा का उल्लंघन करने वाली पंक्ति या पंक्तियों की पहचान करते हैं। इस कॉलम के मान का उपयोग WHERE . में किया जा सकता है SELECT . का खंड उन पंक्तियों के लिए कथन क्वेरी करना जो बाधा का उल्लंघन करते हैं।

इसलिए, तीसरे कॉलम के लिए धन्यवाद, अब मैं सभी अमान्य डेटा ढूंढ (और अपडेट) कर सकता हूं।

अमान्य डेटा ढूंढें

तो अगर हम अपने DBCC CHECKCONSTRAINTS . से पहली पंक्ति को देखें परिणाम, हम देखते हैं कि हम [JobTitle] = 'Digital Nomad' का उपयोग करके आपत्तिजनक डेटा ढूंढ सकते हैं। एक WHERE . में खंड।

इस तरह:

SELECT *
FROM [dbo].[Occupation]
WHERE [JobTitle] = 'Digital Nomad';

परिणाम:

+----------------+---------------+
| OccupationId   | JobTitle      |
|----------------+---------------|
| 7              | Digital Nomad |
+----------------+---------------+

बाधा परिभाषा

आइए chkJobTitle . की वास्तविक परिभाषा पर एक नज़र डालें बाधा:

SELECT Definition 
FROM sys.check_constraints
WHERE name = 'chkJobTitle';

परिणाम:

+-------------------------------+
| Definition                    |
|-------------------------------|
| ([JobTitle]<>'Digital Nomad') |
+-------------------------------+

यह बाधा कहती है कि JobTitle . का मान कॉलम नहीं होना चाहिए हो डिजिटल खानाबदोश , फिर भी एक डिजिटल खानाबदोश अभी भी मेरे डेटाबेस में आने में कामयाब रहा!

अपमानजनक डेटा अपडेट करें

आप या तो आपत्तिजनक डेटा को अपडेट कर सकते हैं, उसे हटा सकते हैं या उसे अकेला छोड़ सकते हैं।

इस उदाहरण में मैं उसी WHERE . का उपयोग करता हूं मूल्य अद्यतन करने के लिए खंड:

UPDATE [dbo].[Occupation]
SET [JobTitle] = 'Unemployed'
WHERE [JobTitle] = 'Digital Nomad';

अब अगर मैं फिर से चेक चलाता हूं, तो वह रिकॉर्ड अब कोई समस्या नहीं है, और केवल अन्य दो मुद्दे शेष हैं:

DBCC CHECKCONSTRAINTS WITH ALL_CONSTRAINTS;

परिणाम:

+------------------------+-------------------+---------------------------------------------------------+
| Table                  | Constraint        | Where                                                   |
|------------------------+-------------------+---------------------------------------------------------|
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2020-01-01' AND [EndDate] = '1999-01-01' |
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2021-10-25' AND [EndDate] = '2021-10-24' |
+------------------------+-------------------+---------------------------------------------------------+

उदाहरण 2 - विदेशी प्रमुख बाधाओं का उल्लंघन

इस उदाहरण में मैं एक डेटाबेस पर स्विच करता हूं जिसमें कुछ विदेशी कुंजी बाधा उल्लंघन होते हैं।

USE Music;
DBCC CHECKCONSTRAINTS WITH ALL_CONSTRAINTS;

परिणाम:

+----------------+---------------------+--------------------+
| Table          | Constraint          | Where              |
|----------------+---------------------+--------------------|
| [dbo].[Albums] | [FK_Albums_Artists] | [ArtistId] = '123' |
| [dbo].[Albums] | [FK_Albums_Artists] | [ArtistId] = '17'  |
+----------------+---------------------+--------------------+

इस मामले में, ऐसा प्रतीत होता है कि एल्बम . में दो पंक्तियाँ तालिका एक ArtistId . का संदर्भ दे रही है जो मौजूद नहीं है।

अमान्य डेटा ढूंढें

फिर से, हम कहां . का उपयोग कर सकते हैं हमारा WHERE . बनाने के लिए कॉलम खंड। इस बार मैं दोनों उल्लंघनों को अपने WHERE . में जोड़ दूंगा खंड:

SELECT *
FROM [dbo].[Albums]
WHERE [ArtistId] = '123' OR [ArtistId] = '17';

परिणाम:

+-----------+-------------+---------------+------------+-----------+
| AlbumId   | AlbumName   | ReleaseDate   | ArtistId   | GenreId   |
|-----------+-------------+---------------+------------+-----------|
| 21        | Yo Wassup   | 2019-03-12    | 17         | 3         |
| 22        | Busted      | 1901-05-11    | 123        | 3         |
+-----------+-------------+---------------+------------+-----------+

तो अब हम उन दो पंक्तियों को देख सकते हैं जो बाधा का उल्लंघन करती हैं (हालाँकि यह केवल ArtistId है स्तंभ जो बाधा का उल्लंघन करता है)।

प्राथमिक कुंजी तालिका जांचें

हम कलाकारों . से पूछताछ करके उल्लंघन की पुष्टि कर सकते हैं तालिका (अर्थात वह तालिका जिसमें इस विदेशी कुंजी के लिए प्राथमिक कुंजी है)।

तो चलिए उसी क्वेरी को कलाकारों . के खिलाफ चलाते हैं टेबल।

SELECT *
FROM [dbo].[Artists]
WHERE [ArtistId] = '123' OR [ArtistId] = '17';

परिणाम:

(0 rows affected)

जैसा कि अपेक्षित था, उस तालिका में कोई भी मान नहीं है।

ऐसा होने से रोकने के लिए विदेशी कुंजी माना जाता है। विदेशी कुंजी अक्षम होने पर या तो अमान्य डेटा डेटाबेस में दर्ज किया गया था, या इसे विदेशी कुंजी बनाने से पहले दर्ज किया गया था। किसी भी तरह से, विदेशी कुंजी बनाते या सक्षम करते समय या CHECK बाधा, आपको WITH CHECK का उपयोग करना चाहिए यह निर्दिष्ट करने के लिए कि बाधा को सक्षम करने से पहले सभी मौजूदा डेटा की जाँच की जानी चाहिए।

उदाहरण 3 - केवल सक्षम बाधाओं की जांच करें

यदि आप केवल उन बाधाओं की जांच करना चाहते हैं जो वर्तमान में सक्षम हैं, तो WITH ALL_CONSTRAINTS हटा दें :

USE Test;
DBCC CHECKCONSTRAINTS;

परिणाम:

+--------------------+---------------+------------------------------+
| Table              | Constraint    | Where                        |
|--------------------+---------------+------------------------------|
| [dbo].[Occupation] | [chkJobTitle] | [JobTitle] = 'Digital Nomad' |
+--------------------+---------------+------------------------------+

तो जिन दो बाधाओं का उल्लंघन किया गया, उनमें से ऐसा प्रतीत होता है कि chkJobTitle केवल वही है जिसे सक्षम किया गया था।

हम निम्नलिखित क्वेरी के साथ इसे और सत्यापित कर सकते हैं:

SELECT 
  name,
  is_disabled
FROM sys.check_constraints
WHERE name = 'chkValidEndDate' OR name = 'chkJobTitle';

परिणाम:

+-----------------+---------------+
| name            | is_disabled   |
|-----------------+---------------|
| chkJobTitle     | 0             |
| chkValidEndDate | 1             |
+-----------------+---------------+

उदाहरण 4 - किसी दी गई तालिका के लिए केवल बाधाओं की जांच करें

यदि आप केवल उस तालिका के लिए बाधाओं की जांच करना चाहते हैं तो आप कोष्ठक में तालिका का नाम जोड़ सकते हैं:

USE Test;
DBCC CHECKCONSTRAINTS(ConstraintTest) WITH ALL_CONSTRAINTS;

परिणाम:

+------------------------+-------------------+---------------------------------------------------------+
| Table                  | Constraint        | Where                                                   |
|------------------------+-------------------+---------------------------------------------------------|
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2020-01-01' AND [EndDate] = '1999-01-01' |
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2021-10-25' AND [EndDate] = '2021-10-24' |
+------------------------+-------------------+---------------------------------------------------------+

उदाहरण 5 - एकल बाधा की जांच करें

आप किसी एक बाधा को उसके नाम को कोष्ठक के अंदर संलग्न करके देख सकते हैं:

USE Test;
DBCC CHECKCONSTRAINTS(chkValidEndDate);

परिणाम:

+------------------------+-------------------+---------------------------------------------------------+
| Table                  | Constraint        | Where                                                   |
|------------------------+-------------------+---------------------------------------------------------|
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2020-01-01' AND [EndDate] = '1999-01-01' |
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2021-10-25' AND [EndDate] = '2021-10-24' |
+------------------------+-------------------+---------------------------------------------------------+

जब आप किसी एक बाधा को निर्दिष्ट करते हैं, तो WITH ALL_CONSTRAINTS कोई प्रभाव नहीं पड़ता:

USE Test;
DBCC CHECKCONSTRAINTS(chkValidEndDate) WITH ALL_CONSTRAINTS;

परिणाम:

+------------------------+-------------------+---------------------------------------------------------+
| Table                  | Constraint        | Where                                                   |
|------------------------+-------------------+---------------------------------------------------------|
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2020-01-01' AND [EndDate] = '1999-01-01' |
| [dbo].[ConstraintTest] | [chkValidEndDate] | [StartDate] = '2021-10-25' AND [EndDate] = '2021-10-24' |
+------------------------+-------------------+---------------------------------------------------------+