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

Chapter 15: Triggers
This is the same notion as the “Short and Sweet” section — long-running queries make for long-running
statements which, in turn, lead to long-running everything. Don’t forget your triggers when you optimize!
Try Not to Roll Back Within Triggers
This one’s hard since rollbacks are so often a major part of what you want to accomplish with your
triggers.
Just remember that AFTER triggers (which are far and away the most common type of trigger) happen
after most of the work is already done — that means a rollback is expensive. This is where DRI picks up
almost all of its performance advantage. If you are using many ROLLBACK TRAN statements in your triggers,
then make sure that you preprocess looking for errors before you execute the statement that fires
the trigger. Because SQL Server can’t be proactive in this situation, you need to be proactive for it. Test
for errors beforehand rather than waiting for the rollback.
Dropping Triggers
Dropping triggers works only slightly differently than it has worked for almost everything else thus far.
The only real trick is that, like tables, trigger names are scoped at the schema level. This means that you
can have two objects with a trigger of the same name, as long as the object the trigger is placed against it
in a different schema than the other trigger of the same name. Restated, the trigger is named in terms of
the schema it’s in, rather than the object it is associated with — odd when you realize it is subsidiary to
the table or view it is attached to. The syntax looks like:
DROP TRIGGER [.]
Other than the schema issue, dropping triggers is pretty much the same as any other drop.
Debugging Triggers
470
Most everything to do with the debugger works the same for triggers as it does for anything else. The
only real trick is a result of the fact that you can’t directly call triggers in the way you can scripts or
stored procedures.
Fortunately, most developer types are reasonably intelligent people, so, if you think about it, you probably
can anticipate how we can get around starting the debugger for triggers — we just need to debug a
statement that causes a trigger to fire.
In releases prior to SQL Server 2008, direct debugging of scripts wasn’t available in 2005 and earlier.
This meant you needed to create a stored procedure that would cause a trigger to be debugged if you
wanted to debug that trigger — happily, this is no longer the case.
Since we reviewed the basics of debugging fairly thoroughly in Chapter 12, let’s cut right to the proverbial
chase and look at debugging triggers in action. All we need to do to show this off is run a bit of code