DELETE Trigger vs Stored Procedure pour gérer la suppression des lignes dépendantes

J'ai vu divers messages sur la façon d'implémenter la suppression de lignes dépendantes d'autres tables en utilisant CASCADE DELETE ou de diverses façons de créer ou de searchr des dependencies et de créer un SQL dynamic.

Je ne suis pas folle de l'idée d'utiliser CASCADE delete si ce n'est pour d'autres raisons que les problèmes de surchauffe dus au fait que CASCADE émet tant de DELETE pour les loggings qui ont de nombreuses dependencies qui ont leurs propres dependencies (sans parler du fait que les résultats peuvent être difficiles à suivre et pas très bien adaptés aux environnements de production).

Alors, s'étant résigné à les écrire d'une manière ou d'une autre, je me request quel est le compromis à faire pour mettre toutes les suppressions nécessaires dans une procédure stockée ou un triggersur de suppression.

J'aime l'option DELETE sortinggger, car elle permet de garder la sémantique de la suppression tout droit. C'est:

DELETE FROM [SomeTable] WHERE [SomeColumn] = VAL

Prendra soin de toutes les suppressions qui doivent être sockets en charge et aucun développeur ne peut faire l'erreur de ne pas appeler la procédure de suppression:

 EXECUTE [prc_SomeTable_Delete] VAL

Cependant, je suis inquiet au sujet de l'utilisation de TRIGGER, car il semble y avoir un bon nombre de recommandations «d'experts» contre leur utilisation [fréquente].

De mon sharepoint vue, l'implémentation réelle de TRIGGER par rapport à la procédure stockée semble presque identique. Donc, à l'interne, nous adoptons une pratique cohérente, il semble que la solution TRIGGER devrait fonctionner très bien.

Y a-t-il une meilleure pratique [ou la plus courante] qui devrait être suivie? Quelles devraient être mes préoccupations à court et à long terme? Pour la plupart, ces suppressions vont être émises à partir d'une application client .NET – plus que probablement s'appuyer sur Entity Framework pour l'access aux données / manipulation; Comment cela devrait-il affecter ma décision?

N'hésitez pas à postr des liens vers des considérations exhaustives sur le sujet car mes efforts n'en ont pas encore donné.

Merci a tous.

Les triggersurs ont l'inconvénient évident qu'ils tirent tout de suite, sans que vous soyez en mesure de reporter leur exécution. Sous une utilisation intensive, votre système peut être si occupé à exécuter tous ces triggersurs, il s'arrêtera.

Si vous pouvez faire quelque chose comme:

faire une "note" dans une table dont les lignes dépendantes doivent être supprimées
planifier une tâche de nettoyage qui fait son travail pendant les heures creuses, par exemple pendant la nuit

la performance globale de votre système devrait être bien meilleure. Cela nécessite toutefois que vous puissiez attendre un certain time entre le moment où la ligne "parent" est supprimée, jusqu'à ce que vous supprimiez réellement les lignes enfant dépendantes.

Mais comme vous le dites – le code écrit est presque le même, donc vous pouvez certainement utiliser un triggersur d'abord et voir comment il se comporte et comment cela affecte les performances de votre système. Si cela devient trop lourd sur votre système, "découpler" ces events (une ligne parente étant supprimée et les lignes enfants dépendantes supprimées) en utilisant un tel model "asynchronous" avec un proc stocké appelé à intervalles donnés pour faire le nettoyage.

Il n'y a rien de mal avec des triggersurs appropriés. Les gens qui sont contre eux ont souvent eu de mauvaises expériences parce qu'ils étaient mal écrits ou parce que leurs développeurs étaient trop inconsistants pour penser que quelque chose pouvait se passer dans un triggersur.

Dans ce cas, je ne ferais pas cette tâche dans un triggersur. La raison pour laquelle est la même raison pour laquelle vous ne voulez pas le faire en utilisant supprimer en cascade. Si quelqu'un délivre quelque chose qui a un million de dossiers d'enfant, vous avez enfermé les choses.

Les suppressions ne se produisent pas seulement à partir d'une interface, mais dans ce cas je préfère l'approche proc stockée car vous pouvez l'utiliser pour supprimer des loggings qui ont une quantité ordinaire d'loggings et si quelqu'un doit supprimer des millions d'loggings dans une requête ad hoc peut écrire le code à supprimer en utilisant le traitement par lots plutôt que tous à la fois.

Toute personne qui essaie de supprimer manuellement (pour des choses comme le dédoublement par exemple ou le déplacement des données d'un client vers une autre database) obtiendra des erreurs s'il y a des dossiers enfants, ce qui est une bonne chose dans mon esprit. l'logging devrait être supprimé. Par exemple, si vous supprimez un tas d'loggings en double, vous ne voudrez peut-être pas supprimer ces commands, mais plutôt les déplacer vers un client différent (l'logging que vous retenez). Ainsi, si votre process atteint la contrainte FK, vous savez que votre process de dédupping a un problème et vous pouvez le résoudre. Et parfois ces erreurs FKs sont juste une idée que vous ne voulez pas supprimer. SO peut-être que vous pouvez supprimer un client et ses loggings dans la table d'adresses, mais si vous frappez une table d'ordre FK inteh, vous ne voudrez pas la supprimer. Il est trop facile de faire des suppressions automatiques comme des suppressions en cascade et des triggersments où vous oubliez que l'erreur FK vous indique que vous ne devriez pas supprimer.