Beginning Microsoft SQL Server 2008 ... - S3 Tech Training

Chapter 15: Triggers
the world’s problems. The right answer in this respect is that triggers can do a lot for you, but they can
also cause a lot of problems. The trick is to use them when they are the right things to use, and not to use
them when they aren’t.
Some common uses of triggers include:
❑ Enforcing referential integrity: Although I recommend using Declarative Referential Integrity
(DRI) whenever possible, there are many things that DRI won’t do (for example, referential
integrity across databases or even servers, many complex types of relationships, and so on).
❑ Creating audit trails, which means writing out records that keep track of not just the most current
data, but also the actual change history for each record. This may become less popular with
the new change-data tracking that SQL Server 2008 adds, but triggers are the way it has been done
historically.
❑ Cresting functionality similar to a CHECK constraint, but which works across tables, databases,
or even servers.
❑ Substituting your own statements in the place of a user’s action statement (usually used to
enable inserts in complex views).
In addition, you have the new, but likely much more rare case (like I said, they are new, so only time will
tell for sure), Data Definition Language (DDL) trigger, which is about monitoring changes in the structure
of your table.
And these are just a few. So, with no further ado, let’s look at exactly what a trigger is.
What Is a T rigger?
452
A trigger is a special kind of stored procedure that responds to specific events. There are two kinds of
triggers: Data Definition Language (DDL) triggers and Data Manipulation Language (DML) triggers.
DDL triggers fire in response to someone changing the structure of your database in some way (CREATE,
ALTER, DROP, and similar statements). These are critical to some installations (particularly high-security
installations), but are pretty narrow in use. In general, you will only need to look into using these where
you need extreme auditing of changes/history of your database structure. Their use is a fairly advanced
concept and, as such, I’m covering them here as mostly a “be aware these exist” thing, and we’ll move
on to the meatier version of triggers.
DML triggers are pieces of code that you attach to a particular table or view. Unlike sprocs, where
you need to explicitly invoke the code, the code in triggers is automatically run whenever the event(s) you
attached the trigger to occur in the table. Indeed, you can’t explicitly invoke triggers — the only way to
do this is by performing the required action in the table that they are assigned to.
Beyond not being able to explicitly invoke a trigger, you’ll find two other things that exist for sprocs but
are missing from triggers: parameters and return codes.