Trigger best practices and limitations in MySQL

Introduction

Triggers help automate actions in the database when data changes, but using them carefully avoids problems.

Automatically update a timestamp when a record changes.

Keep audit logs of data changes without changing application code.

Enforce complex rules that cannot be done with simple constraints.

Prevent invalid data changes by checking conditions before insert or update.

Syntax

MySQL

CREATE TRIGGER trigger_name
BEFORE|AFTER INSERT|UPDATE|DELETE
ON table_name
FOR EACH ROW
BEGIN
  -- trigger logic here
END

Triggers run automatically when the specified event happens on the table.

You can choose BEFORE or AFTER the event to run the trigger.

Examples

This trigger updates the last_modified column before any update on employees.

MySQL

CREATE TRIGGER update_timestamp
BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
  SET NEW.last_modified = NOW();
END

This trigger stops updates that try to set a negative salary.

MySQL

CREATE TRIGGER prevent_negative_salary
BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
  IF NEW.salary < 0 THEN
    SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Salary cannot be negative';
  END IF;
END

Sample Program

This example creates a table and a trigger that updates last_modified automatically when salary changes.

MySQL

CREATE TABLE employees (
  id INT PRIMARY KEY,
  name VARCHAR(50),
  salary DECIMAL(10,2),
  last_modified TIMESTAMP
);

DELIMITER $$
CREATE TRIGGER update_last_modified
BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
  SET NEW.last_modified = NOW();
END$$
DELIMITER ;

INSERT INTO employees (id, name, salary) VALUES (1, 'Alice', 5000);
UPDATE employees SET salary = 5500 WHERE id = 1;
SELECT id, name, salary, last_modified FROM employees WHERE id = 1;

Important Notes

Triggers can slow down database operations if they have complex logic.

Avoid recursive triggers that call themselves, it can cause errors.

Not all errors inside triggers are easy to debug; test carefully.

Summary

Triggers automate actions on data changes without extra application code.

Use BEFORE triggers to modify data before saving, AFTER triggers for actions after changes.

Keep trigger logic simple and avoid recursion to prevent performance issues.

Practice

1. Which of the following is a best practice when creating MySQL triggers?

easy

A. Keep trigger logic simple to avoid performance issues.

B. Use triggers to replace all application logic.

C. Allow triggers to call themselves recursively without limits.

D. Write triggers that perform complex calculations on large datasets.

Solution

1. Step 1: Understand trigger performance impact

   Triggers run automatically on data changes, so complex logic can slow down database operations.

2. Step 2: Identify best practice for trigger design

   Keeping trigger logic simple helps maintain good performance and avoids unexpected delays.

3. Final Answer:

   Keep trigger logic simple to avoid performance issues. -> Option A

4. Quick Check:

   Simple trigger logic = Better performance [OK]

Hint: Keep triggers simple to avoid slowdowns [OK]

Common Mistakes:

• Trying to put all business logic inside triggers
• Allowing infinite recursion in triggers
• Using triggers for heavy data processing

2. Which syntax correctly defines a BEFORE INSERT trigger in MySQL?

easy

A. CREATE TRIGGER trg BEFORE INSERT ON table_name FOR EACH ROW BEGIN ... END;

B. CREATE TRIGGER trg AFTER INSERT ON table_name FOR EACH ROW BEGIN ... END;

C. CREATE TRIGGER trg BEFORE UPDATE ON table_name FOR EACH ROW BEGIN ... END;

D. CREATE TRIGGER trg BEFORE DELETE ON table_name FOR EACH ROW BEGIN ... END;

Solution

1. Step 1: Identify trigger timing and event

   BEFORE INSERT triggers run before a new row is inserted.

2. Step 2: Match syntax to BEFORE INSERT event

   CREATE TRIGGER trg BEFORE INSERT ON table_name FOR EACH ROW BEGIN ... END; uses BEFORE INSERT, correct timing and event for this trigger.

3. Final Answer:

   CREATE TRIGGER trg BEFORE INSERT ON table_name FOR EACH ROW BEGIN ... END; -> Option A

4. Quick Check:

   BEFORE INSERT syntax = CREATE TRIGGER trg BEFORE INSERT ON table_name FOR EACH ROW BEGIN ... END; [OK]

Hint: BEFORE triggers run before data changes [OK]

Common Mistakes:

• Confusing BEFORE and AFTER keywords
• Using wrong event like UPDATE or DELETE
• Missing FOR EACH ROW clause

3. Given this trigger, what happens when a new row is inserted?

CREATE TRIGGER trg BEFORE INSERT ON employees FOR EACH ROW BEGIN SET NEW.salary = NEW.salary * 1.1; END;

medium

A. The trigger causes a syntax error.

B. The salary is increased by 10% before insertion.

C. The salary remains unchanged.

D. The insertion fails due to recursion.

Solution

1. Step 1: Analyze trigger action on BEFORE INSERT

   The trigger modifies the NEW.salary value by multiplying it by 1.1 before the row is inserted.

2. Step 2: Understand effect on inserted data

   The inserted row will have salary increased by 10% automatically.

3. Final Answer:

   The salary is increased by 10% before insertion. -> Option B

4. Quick Check:

   BEFORE INSERT modifies NEW.salary = increased salary [OK]

Hint: BEFORE triggers can modify NEW row data [OK]

Common Mistakes:

• Thinking triggers run after insertion
• Assuming salary stays the same
• Confusing NEW and OLD keywords

4. What is wrong with this trigger definition?

CREATE TRIGGER trg AFTER UPDATE ON employees FOR EACH ROW BEGIN UPDATE employees SET salary = salary * 1.05 WHERE id = NEW.id; END;

medium

A. It will not update any rows because NEW.id is invalid.

B. Syntax error due to missing DELIMITER statement.

C. Triggers cannot use UPDATE statements inside their body.

D. It causes infinite recursion by updating the same table inside the trigger.

Solution

1. Step 1: Identify trigger action on AFTER UPDATE

   The trigger updates the same table employees inside an AFTER UPDATE trigger.

2. Step 2: Understand recursion risk

   Updating the same table inside its own UPDATE trigger causes the trigger to call itself repeatedly, causing infinite recursion.

3. Final Answer:

   It causes infinite recursion by updating the same table inside the trigger. -> Option D

4. Quick Check:

   Trigger updating same table = recursion risk [OK]

Hint: Avoid updating same table inside its trigger [OK]

Common Mistakes:

• Ignoring recursion risk
• Assuming syntax error without DELIMITER
• Thinking triggers can't run UPDATE statements

5. You want to log every DELETE action on the orders table without slowing down the delete operation. Which trigger design is best?

hard

A. Use a BEFORE DELETE trigger that updates the orders table with a log message.

B. Use an AFTER DELETE trigger that updates the orders table itself.

C. Use an AFTER DELETE trigger that inserts a log record into a separate table.

D. Use a BEFORE DELETE trigger that performs complex calculations before deleting.

Solution

1. Step 1: Choose trigger timing for logging

   AFTER DELETE triggers run after the row is deleted, so they don't block the delete operation.

2. Step 2: Select action that avoids slowing delete

   Inserting a log record into a separate table is efficient and safe, avoiding recursion or delays.

3. Final Answer:

   Use an AFTER DELETE trigger that inserts a log record into a separate table. -> Option C

4. Quick Check:

   AFTER DELETE + separate log table = best practice [OK]

Hint: Log deletes AFTER action to avoid delays [OK]

Common Mistakes:

• Updating same table inside trigger causing recursion
• Using BEFORE DELETE for logging causing delays
• Doing heavy calculations inside triggers