Cara Menemukan Semua Pelanggaran Batasan di Database SQL Server

Anda dapat menjalankan DBCC CHECKCONSTRAINTS konsol perintah untuk mengembalikan daftar semua pelanggaran kendala dalam database SQL Server.

Perintah ini memeriksa integritas batasan tertentu atau semua batasan pada tabel tertentu dalam database saat ini. Ini mengembalikan kunci asing dan CHECK pelanggaran kendala yang ditemukan.

Anda dapat menggunakan ALL_CONSTRAINTS opsi untuk memeriksa batasan yang diaktifkan dan dinonaktifkan. Jika Anda menghilangkan ini, maka hanya batasan yang diaktifkan yang dikembalikan (kecuali jika Anda secara eksplisit menentukan batasan untuk diperiksa, dalam hal ini batasan akan dikembalikan terlepas dari apakah itu diaktifkan atau dinonaktifkan).

Contoh 1 – Batasan CHECK yang Dilanggar

Saya menjalankan contoh ini terhadap database yang berisi beberapa CHECK pelanggaran batasan.

USE Test;
DBCC CHECKCONSTRAINTS WITH ALL_CONSTRAINTS;

Hasil:

+------------------------+-------------------+---------------------------------------------------------+
| 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' |
+------------------------+-------------------+---------------------------------------------------------+

Ini menunjukkan bahwa saya memiliki tiga pelanggaran batasan dalam database saya.

Penjelasan Kolom

Tiga kolom mengembalikan informasi berikut:

Tabel

Nama nama tabel yang berisi pelanggaran batasan.

Kendala

Nama batasan yang dilanggar.

Di mana

Penetapan nilai kolom yang mengidentifikasi baris atau baris yang melanggar batasan. Nilai dalam kolom ini dapat digunakan dalam WHERE klausa dari SELECT pernyataan yang menanyakan baris yang melanggar batasan.

Oleh karena itu, berkat kolom ketiga, saya sekarang dapat menemukan (dan memperbarui) semua data yang tidak valid.

Menemukan Data yang Tidak Valid

Jadi jika kita melihat baris pertama dari DBCC CHECKCONSTRAINTS saya hasilnya, kami melihat bahwa kami dapat menemukan data yang menyinggung dengan menggunakan [JobTitle] = 'Digital Nomad' dalam WHERE klausa.

Seperti ini:

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

Hasil:

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

Definisi Batasan

Mari kita lihat definisi sebenarnya untuk chkJobTitle kendala:

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

Hasil:

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

Batasan ini menyatakan bahwa nilai JobTitle kolom harus tidak jadilah Digital Nomad , namun seorang pengembara digital masih berhasil masuk ke database saya!

Perbarui Data yang Melanggar

Anda dapat memperbarui data yang menyinggung, menghapusnya, atau membiarkannya sendiri.

Dalam contoh ini saya menggunakan WHERE yang sama klausa untuk memperbarui nilai:

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

Sekarang jika saya menjalankan pemeriksaan lagi, catatan itu tidak lagi menjadi masalah, dan hanya dua masalah lainnya yang tersisa:

DBCC CHECKCONSTRAINTS WITH ALL_CONSTRAINTS;

Hasil:

+------------------------+-------------------+---------------------------------------------------------+
| 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' |
+------------------------+-------------------+---------------------------------------------------------+

Contoh 2 – Batasan Kunci Asing yang Dilanggar

Dalam contoh ini saya beralih ke database yang berisi beberapa pelanggaran batasan kunci asing.

USE Music;
DBCC CHECKCONSTRAINTS WITH ALL_CONSTRAINTS;

Hasil:

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

Dalam hal ini, tampaknya dua baris di Album tabel merujuk ke ArtistId itu tidak ada.

Menemukan Data yang Tidak Valid

Sekali lagi, kita dapat menggunakan Where kolom untuk membuat WHERE . kami ayat. Kali ini saya akan menambahkan kedua pelanggaran ke WHERE saya klausa:

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

Hasil:

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

Jadi sekarang kita bisa melihat dua baris yang melanggar batasan (walaupun hanya ArtistId kolom yang melanggar batasan).

Periksa Tabel Kunci Utama

Kami dapat mengonfirmasi pelanggaran dengan menanyakan Artis tabel (yaitu tabel yang berisi kunci utama untuk kunci asing ini).

Jadi, mari kita jalankan kueri yang sama terhadap Artis tabel.

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

Hasil:

(0 rows affected)

Seperti yang diharapkan, tidak ada nilai di tabel itu.

Kunci asing seharusnya mencegah hal ini terjadi. Entah data yang tidak valid masuk ke database saat kunci asing dinonaktifkan, atau dimasukkan sebelum kunci asing dibuat. Either way, saat membuat atau mengaktifkan kunci asing atau CHECK kendala, Anda harus menggunakan WITH CHECK untuk menentukan bahwa semua data yang ada harus diperiksa sebelum mengaktifkan batasan.

Contoh 3 – Periksa Hanya Batasan yang Diaktifkan

Jika Anda hanya ingin memeriksa batasan yang saat ini diaktifkan, hapus WITH ALL_CONSTRAINTS :

USE Test;
DBCC CHECKCONSTRAINTS;

Hasil:

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

Jadi dari dua batasan yang dilanggar, ternyata chkJobTitle adalah satu-satunya yang diaktifkan.

Kami selanjutnya dapat memverifikasi ini dengan kueri berikut:

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

Hasil:

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

Contoh 4 – Periksa Batasan Saja untuk Tabel yang Diberikan

Anda dapat menambahkan nama tabel dalam tanda kurung jika Anda hanya ingin memeriksa batasan untuk tabel tersebut:

USE Test;
DBCC CHECKCONSTRAINTS(ConstraintTest) WITH ALL_CONSTRAINTS;

Hasil:

+------------------------+-------------------+---------------------------------------------------------+
| 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' |
+------------------------+-------------------+---------------------------------------------------------+

Contoh 5 – Periksa Kendala Tunggal

Anda dapat memeriksa satu batasan dengan menyertakan namanya di dalam tanda kurung:

USE Test;
DBCC CHECKCONSTRAINTS(chkValidEndDate);

Hasil:

+------------------------+-------------------+---------------------------------------------------------+
| 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' |
+------------------------+-------------------+---------------------------------------------------------+

Saat Anda menentukan satu batasan, WITH ALL_CONSTRAINTS tidak berpengaruh:

USE Test;
DBCC CHECKCONSTRAINTS(chkValidEndDate) WITH ALL_CONSTRAINTS;

Hasil:

+------------------------+-------------------+---------------------------------------------------------+
| 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' |
+------------------------+-------------------+---------------------------------------------------------+