Hur man aktiverar alla CHECK &främmande nyckelbegränsningar för en tabell i SQL Server (T-SQL-exempel)

Du kan använda koden nedan för att aktivera alla CHECK och främmande nyckelbegränsningar för en specifik tabell i SQL Server.

När du aktiverar en begränsning i SQL Server måste du bestämma om den ska kontrollera befintliga data eller inte. Detta är ett viktigt övervägande om tabellen redan innehåller data, eftersom den befintliga informationen potentiellt kan bryta mot begränsningens regler.

Exempel på uttalanden

Nedan finns två exempelsatser som visar skillnaden mellan att kontrollera befintlig data och att inte kontrollera den när du aktiverar begränsningarna.

För att kontrollera befintliga data, använd WITH CHECK i ditt uttalande när du aktiverar begränsningarna, använd annars WITH NOCHECK .

Med Check:

ALTER TABLE TableName 
WITH CHECK 
CHECK CONSTRAINT ALL

Utan kontroll:

ALTER TABLE TableName 
WITH NOCHECK 
CHECK CONSTRAINT ALL

Byt bara ut TableName med namnet på den tillämpliga tabellen.

Nedan är ett exempel där jag gör detta och kontrollerar resultaten.

Exempel 1 – Granska begränsningarna

Först ska jag ta en snabb titt på den nuvarande CHECK begränsningar i databasen, för att se om de är aktiverade eller inaktiverade.

SELECT
  OBJECT_NAME(parent_object_id) AS 'Table',
  name AS 'Constraint',
  is_disabled, 
  is_not_trusted
FROM sys.foreign_keys
UNION
SELECT 
  OBJECT_NAME(parent_object_id),
  name,
  is_disabled, 
  is_not_trusted
FROM sys.check_constraints;

Resultat:

+----------------+-----------------+---------------+------------------+
| Table          | Constraint      | is_disabled   | is_not_trusted   |
|----------------+-----------------+---------------+------------------|
| ConstraintTest | chkPrice        | 1             | 1                |
| ConstraintTest | chkValidEndDate | 1             | 1                |
| ConstraintTest | chkTeamSize     | 1             | 1                |
| Occupation     | chkJobTitle     | 0             | 0                |
+----------------+-----------------+---------------+------------------+

Så det finns för närvarande fyra CHECK begränsningar i databasen, varav tre är för ConstraintTest bord.

Vi kan se att alla begränsningar för tabellen är inaktiverade eftersom is_disabled är inställd på 1 .

Vi kan också se att is_not_trusted kolumnen är inställd på 1 för dessa begränsningar. Det betyder att de inte är betrodda. De kan inte litas på när de är inaktiverade, eftersom ogiltiga data kan komma in i databasen utan att kontrolleras. Mer om detta nedan.

Den andra begränsningen (för en annan tabell) är redan aktiverad och pålitlig (men vi kan ignorera den tabellen/restriktionen i den här artikeln).

Exempel 2 – Aktivera begränsningarna med MED KONTROLL

Nu kommer jag att aktivera alla begränsningar för ConstraintTest tabell:

ALTER TABLE ConstraintTest 
WITH CHECK CHECK CONSTRAINT ALL;

Det är allt – klart.

Låt oss nu köra samma fråga från det första exemplet för att se resultatet.

SELECT
  OBJECT_NAME(parent_object_id) AS 'Table',
  name AS 'Constraint',
  is_disabled, 
  is_not_trusted
FROM sys.foreign_keys
UNION
SELECT 
  OBJECT_NAME(parent_object_id),
  name,
  is_disabled, 
  is_not_trusted
FROM sys.check_constraints;

Resultat:

+----------------+-----------------+---------------+------------------+
| Table          | Constraint      | is_disabled   | is_not_trusted   |
|----------------+-----------------+---------------+------------------|
| ConstraintTest | chkPrice        | 0             | 0                |
| ConstraintTest | chkValidEndDate | 0             | 0                |
| ConstraintTest | chkTeamSize     | 0             | 0                |
| Occupation     | chkJobTitle     | 0             | 0                |
+----------------+-----------------+---------------+------------------+

Alla tre begränsningarna för ConstraintTest Tabellen är nu aktiverad och betrodd.

De är betrodda eftersom jag använde WITH CHECK i mitt uttalande. Om jag inte hade det, skulle jag ha fått ett annat resultat, som du ser nedan.

Genom att använda WITH CHECK , jag kan vara säker på att alla befintliga data i tabellen faktiskt överensstämmer med begränsningarna.

Exempel 3 – Aktivera begränsningarna med WITH NOCHECK

Nu ska jag återaktivera begränsningarna med WITH CHECK så vi kan se hur detta påverkar resultatet.

Men först måste jag inaktivera dem:

ALTER TABLE ConstraintTest 
NOCHECK CONSTRAINT ALL;

Kontrollera att de är inaktiverade:

SELECT
  OBJECT_NAME(parent_object_id) AS 'Table',
  name AS 'Constraint',
  is_disabled, 
  is_not_trusted
FROM sys.foreign_keys
UNION
SELECT 
  OBJECT_NAME(parent_object_id),
  name,
  is_disabled, 
  is_not_trusted
FROM sys.check_constraints;

Resultat:

+----------------+-----------------+---------------+------------------+
| Table          | Constraint      | is_disabled   | is_not_trusted   |
|----------------+-----------------+---------------+------------------|
| ConstraintTest | chkPrice        | 1             | 1                |
| ConstraintTest | chkValidEndDate | 1             | 1                |
| ConstraintTest | chkTeamSize     | 1             | 1                |
| Occupation     | chkJobTitle     | 0             | 0                |
+----------------+-----------------+---------------+------------------+

Så de är inaktiverade igen.

Återaktivera dem nu med WITH NOCHECK :

ALTER TABLE ConstraintTest 
WITH NOCHECK CHECK CONSTRAINT ALL;

Kontrollera igen:

SELECT
  OBJECT_NAME(parent_object_id) AS 'Table',
  name AS 'Constraint',
  is_disabled, 
  is_not_trusted
FROM sys.foreign_keys
UNION
SELECT 
  OBJECT_NAME(parent_object_id),
  name,
  is_disabled, 
  is_not_trusted
FROM sys.check_constraints;

Resultat:

+----------------+-----------------+---------------+------------------+
| Table          | Constraint      | is_disabled   | is_not_trusted   |
|----------------+-----------------+---------------+------------------|
| ConstraintTest | chkPrice        | 0             | 1                |
| ConstraintTest | chkValidEndDate | 0             | 1                |
| ConstraintTest | chkTeamSize     | 0             | 1                |
| Occupation     | chkJobTitle     | 0             | 0                |
+----------------+-----------------+---------------+------------------+

Vi kan se att begränsningarna har aktiverats, men den här gången förblir de opålitliga.

Begränsningarna är otillförlitliga eftersom de inte kontrollerade någon befintlig data innan de aktiverades.

Så det viktigaste här är att om du vill att dina begränsningar ska vara pålitliga, se till att använda WITH CHECK när du aktiverar dem.

Aktivera begränsningar individuellt

Om du inte vill aktivera alla begränsningar på en gång kan du aktivera dem individuellt. Detta kan också vara användbart om du behöver aktivera alla begränsningar, men du behöver använda andra inställningar (t.ex. WITH CHECK för vissa och WITH NOCHECK för andra).

Se hur man aktiverar en CHECK-begränsning i SQL Server och hur man aktiverar en främmande nyckel i SQL Server.