SQL à l'aide de déclencheur pour la contrainte

Tout d'abord, je pense que c'est une règle de données et, par conséquent, devraient être appliquées de manière centralisée. C'est, il devrait y avoir une contrainte de base de données (ou l'équivalent) appliquée par le SGBD qui empêche toutes les applications pour l'écriture des données de mauvaise qualité (plutôt que de compter sur l'individu codeurs de chaque demande de s'abstenir d'écrire des données de mauvaise qualité).

Deuxième, je pense qu'une AFTER déclencheur est approprié (plutôt qu'une INSTEAD OF de déclenchement).

Troisième, cela peut être appliqué à l'aide de la clé étrangère et et au niveau de la ligne CHECK contraintes.

Pour une contrainte de type de déclenchement, l'idée générale est d'écrire une requête pour renvoyer des données de mauvaise qualité alors dans le test du déclencheur que ce résultat est vide.

Vous n'avez pas posté de nombreux détails de vos tables, donc je vais essayer de le deviner. Je suppose student_number est destiné à être un comptage des élèves; comme il est, il sonne comme un identificateur donc je vais changer le nom et d'assumer l'identificateur pour les étudiants est student_id:

WITH EnrolmentTallies
     AS
     (
      SELECT teacher_id, COUNT(*) AS students_tally
        FROM Enrolment
       GROUP 
          BY teacher_id      
     ) 
SELECT * 
  FROM Teachers AS T
       INNER JOIN EnrolmentTallies AS E
         ON T.teacher_id = E.teacher_id
            AND E.students_tally > T.students_tally;

Dans SQL Server, la définition du déclencheur ressemblerait à quelque chose comme ceci:

CREATE TRIGGER student_tally_too_high ON Enrolment
AFTER INSERT, UPDATE
AS
IF EXISTS (
           SELECT * 
             FROM Teachers AS T
                  INNER JOIN (
                              SELECT teacher_id, COUNT(*) AS students_tally
                                FROM Enrolment
                               GROUP 
                                  BY teacher_id      
                             ) AS E
                                  ON T.teacher_id = E.teacher_id
                                     AND E.students_tally > T.students_tally
          )
BEGIN
RAISERROR ('A teachers''s student tally is too high to accept new students.', 16, 1);
ROLLBACK TRANSACTION;
RETURN 
END;

Il y a quelques autres considérations, cependant. L'exécution de cette requête après chaque UPDATE de la table peut être très inefficace. Vous devez utiliser UPDATE() (ou COLUMNS_UPDATED si vous pensez que la colonne de commande peut être invoqué) et/ou la deleted et inserted conceptuel tables de limiter la portée de la requête et quand c'est le feu. Vous aurez également besoin de s'assurer que les opérations sont correctement sérialisé pour éviter les problèmes de simultanéité. Bien que la cause, il n'est pas très complexe.

Je recommande fortement le livre Mathématiques appliquées à la Base de données des Professionnels de la  de la Lex de Haan, Toon Koppelaars, chapitre 11 (les exemples de code sont Oracle, mais peut être facilement porté à SQL Server).

---

Il peut être possible d'atteindre le même sans les déclencheurs. L'idée est de faire un superkey sur (teacher_id, students_tally) pour être référencé dans l'Inscription, pour lequel une séquence unique d'étudiant occurrences seront maintenus avec un test que la séquence ne pourra jamais dépasser le maximum de pointage.

Voici quelques os à nu SQL DDL:

CREATE TABLE Students 
(
 student_id INTEGER NOT NULL,
 UNIQUE (student_id)
);

CREATE TABLE Teachers 
(
 teacher_id INTEGER NOT NULL,
 students_tally INTEGER NOT NULL CHECK (students_tally > 0), 
 UNIQUE (teacher_id), 
 UNIQUE (teacher_id, students_tally)
);

CREATE TABLE Enrolment
(
 teacher_id INTEGER NOT NULL UNIQUE,
 students_tally INTEGER NOT NULL CHECK (students_tally > 0), 
 FOREIGN KEY (teacher_id, students_tally)
    REFERENCES Teachers (teacher_id, students_tally)
    ON DELETE CASCADE
    ON UPDATE CASCADE, 
 student_id INTEGER NOT NULL UNIQUE 
    REFERENCES Students (student_id),
 student_teacher_sequence INTEGER NOT NULL
    CHECK (student_teacher_sequence BETWEEN 1 AND students_tally)
 UNIQUE (teacher_id, student_id), 
 UNIQUE (teacher_id, student_id, student_teacher_sequence)
);

Puis ajouter quelques 'aider' stored proc/fonctions pour maintenir la séquence de mise à jour.

OriginalL'auteur onedaywhen