web-dev-qa-db-fra.com

Comment répertorier toutes les clés étrangères avec "WITH NOCHECK" dans SQL Server

Est-ce que quelqu'un connaît une requête pour lister toutes les clés étrangères d'une base de données avec la description "WITH NOCHECK"? (les supprimer augmentera les performances et la stabilité).

sql-serversql-server-2005foreign-keyssystem
35
digiguru

Les éléments suivants renverront le nom des clés étrangères de la base de données actuelle qui sont désactivées, c’est-à-dire WITH NOCHECK.

Pour SQL Server 2005/2008:

select * from sys.foreign_keys where is_disabled=1



Il y avait quelques discussions dans la réponse sur la différence entre les personnes handicapées et non fiables. Ce qui suit explique la différence Voici du code permettant de clarifier la différence entre is_disabled et isnotrusted.

-- drop table t1
-- drop table t2
create table t1(i int not null, fk int not null)
create table t2(i int not null)
-- create primary key on t2
alter table t2
add constraint pk_1 primary key (i)
-- create foriegn key on t1
alter table t1
add constraint fk_1 foreign key (fk)
    references t2 (i)
--insert some records
insert t2 values(100)
insert t2 values(200)
insert t2 values(300)
insert t2 values(400)
insert t2 values(500)
insert t1 values(1,100)
insert t1 values(2,100)
insert t1 values(3,500)
insert t1 values(4,500)
----------------------------
-- 1. enabled and trusted
select name,is_disabled,is_not_trusted from sys.foreign_keys
GO

-- 2. disable the constraint
alter table t1 NOCHECK CONSTRAINT fk_1
select name,is_disabled,is_not_trusted from sys.foreign_keys
GO

-- 3. re-enable constraint, data isnt checked, so not trusted.
-- this means the optimizer will still have to check the column
alter table  t1 CHECK CONSTRAINT fk_1 
select name,is_disabled,is_not_trusted from sys.foreign_keys
GO

--4. drop the foreign key constraint & re-add 
-- it making sure its checked
-- constraint is then enabled and trusted
alter table t1  DROP CONSTRAINT fk_1
alter table t1 WITH CHECK 
add constraint fk_1 foreign key (fk)
    references t2 (i)
select name,is_disabled,is_not_trusted from sys.foreign_keys
GO


--5. drop the foreign key constraint & add but dont check
-- constraint is then enabled, but not trusted
alter table t1  DROP CONSTRAINT fk_1
alter table t1 WITH NOCHECK 
add constraint fk_1 foreign key (fk)
    references t2 (i)
select name,is_disabled,is_not_trusted from sys.foreign_keys
GO

is_disabled signifie que la contrainte est désactivée

isnottrusted signifie que SQL Server ne fait pas confiance à la vérification de la colonne par rapport à la table de clés étrangères.

Ainsi, on ne peut pas supposer que la réactivation de la contrainte de clé étrangère sera optimisée. Pour vous assurer que l'optimiseur approuve la colonne, il est préférable de supprimer la contrainte de clé étrangère et de la recréer avec l'option WITH CHECK (4.).

34
Nick Kavadias
SELECT * FROM sys.foreign_keys AS f Where Is_Not_Trusted = 1
10
digiguru

Le script suivant générera les instructions alter qui vérifieront les données existantes et empêcheront toute nouvelle violation des clés étrangères non approuvées pour le moment ('with nocheck').

Exécutez-le dans SQL Server Management Studio pour générer les scripts, puis copiez-les dans une fenêtre de requête pour les exécuter.

select
    'alter table ' + quotename(s.name) + '.' + quotename(t.name) + ' with check check constraint ' + fk.name +';'
from 
    sys.foreign_keys fk
inner join
    sys.tables t
on
    fk.parent_object_id = t.object_id
inner join
    sys.schemas s
on
    t.schema_id = s.schema_id
where 
    fk.is_not_trusted = 1
7
Scott Munro

WITH NOCHECK ne devrait être appliqué que temporairement aux FK, sinon ils deviennent inutiles pour l'optimiseur, comme le souligne votre article lié. De BOL:

L'optimiseur de requête ne considère pas contraintes définies avec WITH NOCHECK. Ces contraintes sont ignorées jusqu'à ce qu'ils soient réactivés à l'aide de Table ALTER TABLE VÉRIFIEZ LES CONTRAINTES TOUT.

Ceci identifiera toutes vos clés étrangères: (travail sur le bit WITH NOCHECK ...)

SELECT C.TABLE_CATALOG [PKTABLE_QUALIFIER], 
       C.TABLE_SCHEMA [PKTABLE_OWNER], 
       C.TABLE_NAME [PKTABLE_NAME], 
       KCU.COLUMN_NAME [PKCOLUMN_NAME], 
       C2.TABLE_CATALOG [FKTABLE_QUALIFIER], 
       C2.TABLE_SCHEMA [FKTABLE_OWNER], 
       C2.TABLE_NAME [FKTABLE_NAME], 
       KCU2.COLUMN_NAME [FKCOLUMN_NAME], 
       RC.UPDATE_RULE, 
       RC.DELETE_RULE, 
       C.CONSTRAINT_NAME [FK_NAME], 
       C2.CONSTRAINT_NAME [PK_NAME], 
       CAST(7 AS SMALLINT) [DEFERRABILITY] 
FROM   INFORMATION_SCHEMA.TABLE_CONSTRAINTS C 
       INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE KCU 
         ON C.CONSTRAINT_SCHEMA = KCU.CONSTRAINT_SCHEMA 
            AND C.CONSTRAINT_NAME = KCU.CONSTRAINT_NAME 
       INNER JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS RC 
         ON C.CONSTRAINT_SCHEMA = RC.CONSTRAINT_SCHEMA 
            AND C.CONSTRAINT_NAME = RC.CONSTRAINT_NAME 
       INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS C2 
         ON RC.UNIQUE_CONSTRAINT_SCHEMA = C2.CONSTRAINT_SCHEMA 
            AND RC.UNIQUE_CONSTRAINT_NAME = C2.CONSTRAINT_NAME 
       INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE KCU2 
         ON C2.CONSTRAINT_SCHEMA = KCU2.CONSTRAINT_SCHEMA 
            AND C2.CONSTRAINT_NAME = KCU2.CONSTRAINT_NAME 
            AND KCU.ORDINAL_POSITION = KCU2.ORDINAL_POSITION 
WHERE  C.CONSTRAINT_TYPE = 'FOREIGN KEY'

Réf .

Par ailleurs, dans SQL Server 2000 et 2005, vous pouvez vérifier si des données violent une contrainte en utilisant:

DBCC CHECKCONSTRAINTS (table_name)
5
Mitch Wheat

Le code suivant récupère toutes les clés étrangères marquées 'WITH NOCHECK', puis utilise une instruction ALTER pour les réparer:

-- configure cursor on all FKs with "WITH NOCHECK"
DECLARE UntrustedForeignKeysCursor CURSOR STATIC FOR
    SELECT  f.name,
            t.name 
    FROM    sys.foreign_keys AS f
            LEFT JOIN sys.tables AS t 
                ON f.parent_object_id = t.object_id 
    Where   Is_Not_Trusted = 1
OPEN UntrustedForeignKeysCursor

-- loop through the untrusted FKs
DECLARE @FKName varchar(100)
DECLARE @TableName varchar(100)
FETCH NEXT FROM UntrustedForeignKeysCursor INTO @FKName, @TableName
WHILE @@FETCH_STATUS = 0
BEGIN

    -- Rebuild the FK constraint WITH CHECK
    EXEC ('ALTER TABLE ' + @TableName + ' WITH CHECK CHECK CONSTRAINT ' + @FKName)

    -- get next user
    FETCH NEXT FROM UntrustedForeignKeysCursor INTO @FKName, @TableName

END

-- cleanup
CLOSE UntrustedForeignKeysCursor
3
CodeGrue

Je sais que c’est une vieille question avec de vieilles réponses qui contiennent de bonnes informations. Cependant, je souhaitais simplement partager un script que j'utilisais pour résoudre ce problème dans plusieurs bases de données différentes pour nous:

-- Foreign Keys
SELECT 'ALTER TABLE ' + o.name + ' WITH CHECK CHECK CONSTRAINT ' + i.name + ';' AS AlterStatement
from sys.foreign_keys i
INNER JOIN sys.objects o ON i.parent_object_id = o.object_id
INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
WHERE i.is_not_trusted = 1 AND i.is_not_for_replication = 0;
GO

-- Constraints
SELECT 'ALTER TABLE ' + o.name + ' WITH CHECK CHECK CONSTRAINT ' + i.name + ';' AS AlterStatement
from sys.check_constraints i
INNER JOIN sys.objects o ON i.parent_object_id = o.object_id
INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
WHERE i.is_not_trusted = 1 AND i.is_not_for_replication = 0 AND i.is_disabled = 0;
GO

Cela générera une collection d'instructions ALTER pour résoudre ce problème "NOCHECK" avec des clés étrangères et des contraintes. Ceci est basé sur certaines requêtes fournies par Brent Ozar mais modifié par moi pour mes besoins et sa facilité d'utilisation. Cela pourrait facilement être modifié avec une UNION pour en faire une requête unique.

Pour votre information, je l’utilise exclusivement dans les environnements de base de données SQL Azure. Je ne sais pas s'il existe des limitations sur les anciennes versions de SQL Server, mais cela fonctionne parfaitement dans Azure.

0
Jaxidian