Events

Introduction

Triggers react to changes as they happen. But sometimes you want MySQL to run a task on its own, at a specific time or on a repeating interval — without waiting for any INSERT, UPDATE, or DELETE to happen first. That is what MySQL Events are for.

An Event is essentially a scheduled task stored inside the database itself, similar to a cron job on an operating system, except it lives in MySQL and runs SQL directly. This lesson shows you how to enable, create, and manage events.

What is a MySQL Event?

A MySQL Event is a named, scheduled block of SQL that the database server runs automatically at a set time or on a repeating interval — think of it as a cron job built directly into MySQL, requiring no external scheduler or script.

Events are managed by a background process inside MySQL called the event scheduler, which must be turned on before any event will actually run.

Enabling the Event Scheduler

By default, the event scheduler is often turned off. You can check its status, and turn it on, with the following statements.

SHOW VARIABLES LIKE 'event_scheduler';

SET GLOBAL event_scheduler = ON;

+------------------+-------+
| Variable_name    | Value |
+------------------+-------+
| event_scheduler  | ON    |
+------------------+-------+

Creating an Event

An event is created with CREATE EVENT, naming a schedule with ON SCHEDULE, and the SQL to run with DO.

CREATE EVENT event_name
ON SCHEDULE schedule_expression
DO
    -- SQL statement(s) to run
;

The schedule_expression tells MySQL exactly when, and how often, to run the event body.

One-Time vs Recurring Events

An event can run exactly once at a specific moment (AT), or repeatedly on an interval (EVERY).

-- Runs a single time, at a specific timestamp
CREATE EVENT one_time_cleanup
ON SCHEDULE AT '2026-08-01 00:00:00'
DO
    DELETE FROM temp_sessions WHERE expired = 1;

-- Runs forever, once every day, starting now
CREATE EVENT daily_cleanup
ON SCHEDULE EVERY 1 DAY
STARTS CURRENT_TIMESTAMP
DO
    DELETE FROM temp_sessions WHERE expired = 1;

EVERY accepts any interval, such as EVERY 1 HOUR, EVERY 30 MINUTE, or EVERY 1 WEEK. STARTS controls when the first run happens, and an optional ENDS can give a recurring event a final cutoff date.

Worked Example: Deleting Old Logs

A common real use of events is automatic cleanup: deleting log records that have grown old enough that nobody needs them anymore.

CREATE TABLE logs (
    id INT AUTO_INCREMENT PRIMARY KEY,
    message VARCHAR(255),
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

Now create an event that runs once every day and removes any log row older than 30 days.

CREATE EVENT delete_old_logs
ON SCHEDULE EVERY 1 DAY
STARTS CURRENT_TIMESTAMP
DO
    DELETE FROM logs
    WHERE created_at < NOW() - INTERVAL 30 DAY;

Viewing, Altering, and Dropping Events

You can list every event in the current database, temporarily disable one, or remove it entirely.

SHOW EVENTS;

ALTER EVENT delete_old_logs DISABLE;

ALTER EVENT delete_old_logs ENABLE;

DROP EVENT delete_old_logs;

+----------------+----------------+-----------+---------------+--------+
| Db             | Name           | Definer   | Type          | Status |
+----------------+----------------+-----------+---------------+--------+
| company_db     | delete_old_logs| root@host | RECURRING     | ENABLED|
+----------------+----------------+-----------+---------------+--------+

SHOW EVENTS is useful for confirming an event actually exists, checking whether it is currently ENABLED or DISABLED, and seeing whether it is a ONE TIME or RECURRING event.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Events give MySQL the ability to run SQL on its own schedule, which is perfect for routine maintenance tasks like cleaning up old data, without relying on an external scheduler.

In this lesson, you learned what an event is, how to enable the event scheduler, how to create both one-time and recurring events, and how to manage them with SHOW, ALTER, and DROP. Next, you will learn about Transactions — how to group multiple SQL statements into a single, safe unit of work.