Generic selectors
Exact matches only
Search in title
Search in content
Post Type Selectors

Triggers: mutating errors, instead of triggers


A trigger is a stored procedure that automatically executes in response to a specific event in the database, such as an INSERT, UPDATE, or DELETE statement on a particular table.

Triggers can be used to enforce data integrity, perform complex calculations, audit changes, or perform other actions automatically.

Example: SQL Query for Trigger

CREATE TRIGGER log_emp_inserts
  INSERT INTO logs (message, created_at)
  VALUES ('Employee inserted: ' ||, sysdate);

Explanation: This trigger creates a new row in the “logs” table whenever a new row is inserted into the “employees” table. The message stored in the “logs” table includes the name of the employee and the date and time of the insertion.

Mutating Errors

Mutating errors occur when a trigger attempts to modify the data in the table that triggered the trigger itself.

This can lead to unexpected behavior and data inconsistencies.

Common causes of mutating errors include:

  • Directly modifying the triggering table: This can lead to infinite loops or inconsistencies in the data.
  • Reading from the triggering table: Even reading from the triggering table can lead to unexpected results if the trigger is also modifying the table.
  • Using pseudo-columns like :old and :new: If you access these pseudo-columns before the UPDATE or DELETE statement has been fully executed, you may encounter a mutating error.

Example: SQL Query for Mutating trigger

CREATE TRIGGER update_employee_salary
  UPDATE employees SET salary = salary * 1.1
  WHERE employee_id = :old.employee_id;

Explanation: This trigger attempts to update the salary of the employee who just had their record updated. However, this will result in a mutating error because the trigger is modifying the “employees” table, which is the same table that triggered the trigger.

Instead of Triggers

Instead of triggers are a special type of trigger that can be used to replace the default behavior of an INSERT, UPDATE, or DELETE statement.

Instead of executing the original statement, the trigger code is executed instead.

This can be useful for situations where you want to completely customize the behavior of an operation.

Benefits of using instead of triggers over regular triggers

  • Prevents mutating errors: Since the original statement is not executed, there is no risk of modifying the triggering table and causing errors.
  • Improves performance: Instead of triggers can be more efficient than regular triggers because they avoid the overhead of executing the original statement.
  • Offers greater flexibility: Instead of triggers allow for complete customization of the behavior of an operation, which is not possible with regular triggers.

Limitations of instead of triggers

  • Less intuitive: The code for an instead of trigger can be more complex and difficult to understand than the code for a regular trigger.
  • Limited scope: Instead of triggers can only be used for INSERT, UPDATE, and DELETE statements.
  • Debugging can be challenging: Debugging an instead of trigger can be more difficult than debugging a regular trigger because the original statement is not executed.

Example: SQL Query for Instead trigger

CREATE TRIGGER calculate_employee_bonus
  IF :new.salary > 50000 THEN
    INSERT INTO employee_bonuses (employee_id, bonus)
    VALUES (:new.employee_id, :new.salary * 0.1);
  INSERT INTO employees (employee_id, name, salary)
  VALUES (:new.employee_id,, :new.salary);

Explanation: This instead of trigger replaces the default behavior of the INSERT statement on the “employees” table. It checks the salary of the newly inserted employee and if it is above a certain threshold, it calculates and inserts a bonus record for the employee. It then finally inserts the new employee record into the “employees” table.

Choosing between triggers and instead of triggers

The choice between a trigger and an instead of trigger depends on specific needs. If there is a requirement to simply perform an action after an event occurs, a regular trigger may suffice.

However, in cases where data modification or the complete replacement of operation behavior is necessary, an instead of trigger might be a more suitable option.

Differences between triggers and instead of triggers

FeatureTriggerInstead of Trigger
Execution timingAfter an eventInstead of the original statement
Data modificationCan modifyCannot modify
PerformanceMay be less efficientMay be more efficient
FlexibilityLess flexibleMore flexible
DebuggingEasierMore challenging