Contrainte de clé étrangère peut causer des cycles ou plusieurs cascade chemins?

J'ai un problème lorsque j'essaie d'ajouter des contraintes à mes tables. J'obtiens l'erreur:

L'introduction de la contrainte de CLÉ ÉTRANGÈRE 'FK74988DB24B3C886" sur la table "Employés" peut provoquer de cycles ou en cascade de plusieurs chemins. Spécifier on DELETE NO ACTION ou de la mise À JOUR, AUCUNE ACTION, ou modifier d'autres contraintes de CLÉS ÉTRANGÈRES.

Ma contrainte est entre un Code table et un employee table. Le Code table contient Id, Name, FriendlyName, Type et un Value. Le employee a un certain nombre de champs que les codes de référence, de sorte qu'il peut être une référence pour chaque type de code.

J'ai besoin que les champs soit défini comme null si le code est référencé est supprimé.

Des idées comment je peux faire cela?

L'une des solution est ici

InformationsquelleAutor | 2009-05-12

172

SQL Server n'est qu'un simple comptage de la cascade des chemins et, plutôt que d'essayer de déterminer si les cycles existent réellement, il suppose le pire et refuse de créer le référentiel des actions (en CASCADE): vous pouvez et devez toujours créer les contraintes sans les actions d'intégrité référentielle. Si vous ne pouvez pas modifier votre conception (ou cela pourrait compromettre les choses), alors vous devriez envisager d'utiliser des déclencheurs comme un dernier recours.

FWIW résoudre cascade de chemins est un problème complexe. D'autres produits SQL va simplement ignorer le problème et vous permettent de créer des cycles, auquel cas ce sera une course pour voir qui va remplacer la valeur du dernier, probablement à cause de l'ignorance de la créatrice (p. ex. ACE/Jet n'est présent). Je comprends certains produits SQL va tenter de résoudre les cas les plus simples. Reste que, SQL Server n'essayez même pas, il joue ultra sécuritaire en interdisant l'accès de plus d'un chemin et au moins il vous dise de le faire.

Microsoft eux-mêmes conseille l'utilisation de déclencheurs à la place de contraintes FK.
- Je suis venu à la même conclution à la fin, et a fini par le résoudre à l'aide de déclencheurs. Bon à savoir il y a cette différence entre le SGBD et que c'est en fait une décision de conception, je suis coincé sur. Merci beaucoup 🙂
- une chose que je ne peux toujours pas comprendre, c'est que, si ce "problème" peut être résolu en utilisant un déclencheur, alors comment se fait qu'un déclencheur ne sera pas "provoquer des cycles ou en cascade de plusieurs chemins d'accès ..." ?
- parce que votre détente explicitement d'alimentation de la logique que le système ne pouvait pas implicitement figure sur c'est propre, par exemple s'il y a plusieurs chemins pour supprimer un référentiel d'action puis votre code de déclencheur permettra de définir les tables qui sont supprimés, et dans quel ordre.
- Et aussi le déclencheur s'exécute après la première opération est terminée, donc il n'y a pas de course en cours.
- Grande réponse, mais je suis confus par "en dernier recours". Ils semblent être grande pour ce problème, alors pourquoi seulement comme un dernier recours?
- Je veux dire, que l'utilisation des déclencheurs lorsque les contraintes (peut-être sur la combinaison) ne peut pas faire le travail. Les contraintes sont déclaratives et leur mise en œuvre sont à la charge du système. Les déclencheurs sont code de procédure et vous devez le code (et debug) la mise en œuvre et d'endurer leurs inconvénients (le pire de la performance, etc).
- Est-ce la réponse reste correct en 2019?
InformationsquelleAutor onedaywhen
89

Une situation typique avec de multiples cascasing chemins de ceci:
Une table de maître avec deux détails, disons-le, "Master" et "Detail1" et "Detail2". Deux détails sont à supprimer en cascade. Jusqu'ici pas de problèmes. Mais que faire si les détails ont un un-à-plusieurs-relation avec un autre tableau (dire "SomeOtherTable"). SomeOtherTable a un Detail1ID-colonne ET un Detail2ID-colonne.
```
Master { ID, masterfields }

Detail1 { ID, MasterID, detail1fields }

Detail2 { ID, MasterID, detail2fields }

SomeOtherTable {ID, Detail1ID, Detail2ID, someothertablefields }
```
En d'autres termes: une partie des enregistrements dans SomeOtherTable sont liés avec Detail1-dossiers et que certains enregistrements dans SomeOtherTable sont liés avec Detail2 enregistrements. Même si il est garanti que SomeOtherTable-enregistrements de ne jamais appartenir à deux Détails, il est maintenant impossible de faire SomeOhterTable dossiers de l'effacer en cascade pour les détails, parce qu'il y a de multiples en cascade des chemins de Maître à SomeOtherTable (une via Detail1 et via Detail2).
Maintenant, vous pouvez déjà avoir compris cela. Voici une solution possible:
```
Master { ID, masterfields }

DetailMain { ID, MasterID }

Detail1 { DetailMainID, detail1fields }

Detail2 { DetailMainID, detail2fields }

SomeOtherTable {ID, DetailMainID, someothertablefields }
```
Tous les champs ID sont la clé des champs et de l'auto-incrémentation. Le point crucial réside dans la DetailMainId champs des tableaux détaillés. Ces champs sont à la fois importants et référentiel de contrainte. Il est maintenant possible de supprimer en cascade tout en ne supprimant maître-dossiers. L'inconvénient est que pour chaque detail1-enregistrement ET pour chaque detail2, il doit également être un DetailMain-enregistrement (qui est en fait créé d'abord pour obtenir la bonne et unique id).
- Votre commentaire m'a beaucoup aidé à comprendre le problème que je suis confronté. Merci!!!! Je préfère éteindre la supprimer en cascade, pour l'un, le chemin d'accès, puis de gérer la supprimer d'autres documents d'autres moyens(procédures stockées; les déclencheurs; par le code etc). Mais je garde ta solution(regroupement dans un seul chemin d'accès) à l'esprit pour d'éventuelles applications différentes du même problème...
- Pour l'utilisation du mot crux (et aussi pour expliquer)
- Est-ce mieux que d'écrire des déclencheurs? Il semble étrange pour ajouter une table supplémentaire juste pour obtenir la cascade de travail.
InformationsquelleAutor hans riesebos
12

Je tiens à souligner qu' (fonctionnellement) il y a une GRANDE différence entre les cycles et/ou plusieurs chemins d'accès dans le SCHÉMA et les DONNÉES. Alors que les cycles et peut-être multipaths dans les DONNÉES pourraient certainement compliqué de traitement et de provoquer des problèmes de performances (coût de la "correctement", manutention), le coût de ces caractéristiques dans le schéma doit être proche de zéro.

Depuis plus apparent des cycles de Rdb se produire dans des structures hiérarchiques (organigramme, partie, sous-partie, etc.) il est regrettable que SQL Server suppose le pire; c'est à dire, le schéma du cycle == cycle de collecte de données. En fait, si vous utilisez RI contraintes que vous ne pouvez pas construire un cycle dans les données!

Je soupçonne le multipath problème est similaire; c'est à dire, plusieurs chemins d'accès dans le schéma n'implique pas nécessairement de multiples chemins d'accès dans les données, mais j'ai moins d'expérience avec le multipath problème.

Bien sûr, si SQL Server ne permettent de cycles qu'il avait encore fait l'objet d'une profondeur de 32, mais c'est probablement suffisant pour la plupart des cas. (Dommage que ce n'est pas un paramètre de base de données, cependant!)

"Au lieu de Supprimer les" déclencheurs ne fonctionnent pas non plus. La deuxième fois qu'une table est visité, le déclencheur est ignoré. Donc, si vous voulez vraiment pour simuler une cascade, vous aurez à utiliser des procédures stockées dans la présence de cycles. Au Lieu de Supprimer un Déclencheur pourrait fonctionner pour les trajets multiples cas, cependant.

Celko suggère une "meilleure" manière de représenter des hiérarchies qui n'introduisent pas de cycles, mais il y a des différences.
- "si vous utilisez des RI contraintes que vous ne pouvez pas construire un cycle dans les données!" -- bon point!
- Bien sûr, vous pouvez construire des données de la circularité, mais avec MSSQL uniquement à l'aide de mise à JOUR. D'autres Sgbdr différés contraintes (intégrité de l'assuré au moment de la commettre, et non pas au moment de l'insert/update/delete).
InformationsquelleAutor Bill Cohagan
7

Il y a un article qui explique comment effectuer la suppression multiple chemins à l'aide de déclencheurs. C'est peut-être utile pour des scénarios complexes.

http://www.mssqltips.com/sqlservertip/2733/solving-the-sql-server-multiple-cascade-path-issue-with-a-trigger/

InformationsquelleAutor Javier
3

Par les sons de celui-ci, vous avez un OnDelete/OnUpdate action sur l'un de vos Clés Étrangères, qui va modifier vos codes table.

Par la création de cette Clé Étrangère, vous auriez du créer un problème cyclique,

E. g. Mise à jour des Employés, des causes, des Codes de changé par une Action de mise à Jour, amène les Employés à être modifié par une Action de mise à Jour... etc...

Si vous publiez votre Table de Définitions pour les deux tableaux, & votre Clé Étrangère/les définitions de contraintes, nous devrions être en mesure de vous dire où est le problème...
- Ils sont assez long, donc je ne pense pas que je peux les poster ici, mais j'aimerais beaucoup avoir votre aide ne sais pas si il y a une façon pour moi de les envoyer pour vous? Ill essayer et de le décrire: Les seules contraintes qui existent sont de 3 tables que tous les champs sont que des codes de référence par un simple INT Id de la clé. Le problème semble être que l'Employé a plusieurs champs de référence, la table de code et que je les veux tous en cascade pour DÉFINIR la valeur NULL. Tout ce que je besoin est que lorsque les codes sont supprimés, les références doivent être null partout.
- post de toute façon... je ne pense pas que quiconque ici de l'esprit, et la fenêtre de code de formater correctement dans un bloc de défilement 🙂
InformationsquelleAutor Eoin Campbell

C'est parce que Emplyee pourrait ont Collection d'une autre entité dire Qualifications et de Qualification peut avoir quelques autres de la collection des Universités
par exemple,

public class Employee{
public virtual ICollection<Qualification> Qualifications {get;set;}

}

public class Qualification{

public Employee Employee {get;set;}

public virtual ICollection<University> Universities {get;set;}

}

public class University{

public Qualification Qualification {get;set;}

}

Sur DataContext il pourrait être comme ci-dessous

protected override void OnModelCreating(DbModelBuilder modelBuilder){

modelBuilder.Entity<Qualification>().HasRequired(x=> x.Employee).WithMany(e => e.Qualifications);
modelBuilder.Entity<University>.HasRequired(x => x.Qualification).WithMany(e => e.Universities);

}

dans ce cas, il est de la chaîne de l'Employé de Qualification et De Qualification pour les Universités. Donc, il jetait même exception pour moi.

Il a travaillé pour moi quand j'ai changé de

    modelBuilder.Entity<Qualification>().**HasRequired**(x=> x.Employee).WithMany(e => e.Qualifications);

    modelBuilder.Entity<Qualification>().**HasOptional**(x=> x.Employee).WithMany(e => e.Qualifications);

InformationsquelleAutor RAJ

Déclencheur est la solution pour ce problème:

IF OBJECT_ID('dbo.fktest2', 'U') IS NOT NULL
drop table fktest2
IF OBJECT_ID('dbo.fktest1', 'U') IS NOT NULL
drop table fktest1
IF EXISTS (SELECT name FROM sysobjects WHERE name = 'fkTest1Trigger' AND type = 'TR')
DROP TRIGGER dbo.fkTest1Trigger
go
create table fktest1 (id int primary key, anQId int identity)
go  
create table fktest2 (id1 int, id2 int, anQId int identity,
FOREIGN KEY (id1) REFERENCES fktest1 (id)
ON DELETE CASCADE
ON UPDATE CASCADE/*,    
FOREIGN KEY (id2) REFERENCES fktest1 (id) this causes compile error so we have to use triggers
ON DELETE CASCADE
ON UPDATE CASCADE*/ 
)
go
CREATE TRIGGER fkTest1Trigger
ON fkTest1
AFTER INSERT, UPDATE, DELETE
AS
if @@ROWCOUNT = 0
return
set nocount on
-- This code is replacement for foreign key cascade (auto update of field in destination table when its referenced primary key in source table changes.
-- Compiler complains only when you use multiple cascased. It throws this compile error:
-- Rrigger Introducing FOREIGN KEY constraint on table may cause cycles or multiple cascade paths. Specify ON DELETE NO ACTION or ON UPDATE NO ACTION, 
-- or modify other FOREIGN KEY constraints.
IF ((UPDATE (id) and exists(select 1 from fktest1 A join deleted B on B.anqid = A.anqid where B.id <> A.id)))
begin       
update fktest2 set id2 = i.id
from deleted d
join fktest2 on d.id = fktest2.id2
join inserted i on i.anqid = d.anqid        
end         
if exists (select 1 from deleted)       
DELETE one FROM fktest2 one LEFT JOIN fktest1 two ON two.id = one.id2 where two.id is null -- drop all from dest table which are not in source table
GO
insert into fktest1 (id) values (1)
insert into fktest1 (id) values (2)
insert into fktest1 (id) values (3)
insert into fktest2 (id1, id2) values (1,1)
insert into fktest2 (id1, id2) values (2,2)
insert into fktest2 (id1, id2) values (1,3)
select * from fktest1
select * from fktest2
update fktest1 set id=11 where id=1
update fktest1 set id=22 where id=2
update fktest1 set id=33 where id=3
delete from fktest1 where id > 22
select * from fktest1
select * from fktest2

InformationsquelleAutor Tone Škoda

0

C'est une erreur de base de données de type trigger politiques. Un déclencheur est code et pouvez ajouter quelques intelligences ou de conditions une Cascade de relation comme la Cascade de Suppression. Vous pouvez avoir besoin de spécialiser les tables liées options autour de ce comme éteindre CascadeOnDelete:
```
protected override void OnModelCreating( DbModelBuilder modelBuilder )
{
modelBuilder.Entity<TableName>().HasMany(i => i.Member).WithRequired().WillCascadeOnDelete(false);
}
```
Ou désactiver cette fonctionnalité complètement:
```
modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
```
InformationsquelleAutor Amirhossein Mehrvarzi
-2

Ma solution à ce problème rencontré dans l'utilisation ASP.NET Core 2.0 et EF Core 2.0 est à effectuer les opérations suivantes dans l'ordre:
1. Exécuter update-database de commande dans le Paquet de la Console de Gestion (PMC) pour créer la base de données (ce résultat "de l'Introduction de la contrainte de CLÉ ÉTRANGÈRE ... peut causer des cycles ou en cascade de plusieurs chemins." erreur)
2. Exécuter script-migration -Idempotent commande PMC pour créer un script qui peut être exécuté indépendamment des tables existantes et des contraintes
3. Prendre le script obtenu et trouver ON DELETE CASCADE et de le remplacer avec ON DELETE NO ACTION
4. Exécuter la modification de SQL sur la base de données
Maintenant, les migrations doivent être à jour et les suppressions en cascade ne devrait pas se produire.

Dommage que je n'était pas en mesure de trouver un moyen de le faire dans Entity Framework Core 2.0.

Bonne chance!
- Vous pouvez modifier votre fichier de migration de le faire (sans changer le script sql), c'est à dire dans votre fichier de migration, vous pouvez définir onDelete des mesures de restriction de la Cascade
- Il est préférable de spécifier en utilisant couramment les annotations de sorte que vous n'avez pas à vous rappeler de le faire si vous vous retrouvez supprimer et recréer votre migrations dossier.
- Dans mon expérience, la fluidité, les annotations peuvent être utilisés et doivent être utilisés (j'utilise), mais ils sont souvent assez buggé. Simplement en spécifiant dans le code ne fonctionne pas toujours de produire le résultat attendu.
InformationsquelleAutor user1477388

Vous devez vous connecter pour publier un commentaire.