Resolving Django Migration Errors from Triggers

This frustrating error blocks you from executing schema changes on a table that has triggers enabled. In this post, we’ll explore why this error occurs and how to resolve it.

When running migrations in Django, you may encounter an error like:

django.db.utils.OperationalError: cannot ALTER TABLE "mytable" because it has pending trigger events

Understanding Django Migration Errors

First, let’s review what’s happening when you get this error.

In Django, makemigrations generates migration files that describe schema changes to your models. For example, adding a new field. migrate then applies these migrations by running ALTER TABLE statements.

However, PostgreSQL does not allow ALTER TABLE on tables that have enabled trigger’s. So if your table has triggers, the migrate step fails with the “pending trigger events” error.

Why Triggers Block Alters

To understand why, we need to explain a bit about PostgreSQL trigger’s. Trigger’s fire in response to events like inserts, updates or deletes. They allow you to perform actions like validating input or logging history.

However, trigger’s also introduce some database locking issues. If PostgreSQL allowed an ALTER while trigger’s were enabled, it could lead to inconsistent data.

As a result, PostgreSQL completely blocks ALTER TABLE unless you disable or drop existing trigger’s first. Django migrations obey this constraint and error out.

Solutions for Applying Migrations

Now that we understand the cause, what solutions exist for applying migrations?

1. Temporarily Disable Triggers

One option is to temporarily disable existing trigger’s on the table during the migrate:


# Run migrations with python migrate


This unblocks Django from running ALTER TABLE, allowing the schema changes to apply.

However, directly manipulating trigger’s can be tedious and error-prone. You need to remember to re-enable the trigger’s after.

2. Manually Drop and Recreate Triggers

Another approach is dropping trigger’s before migrating:

DROP TRIGGER IF EXISTS my_insert_trigger on mytable;

# Run migrations  


This also gets Django migrations working. But again, it requires manually rebuilding your trigger logic.

3. Use Django’s SchemaEditor

Fortunately, Django offers a higher level API for managing trigger’s and migrations cleanly.

The django.db.backends.base.schema.BaseDatabaseSchemaEditor class allows overriding schema modifying commands. This includes hooks to drop and recreate trigger’s automatically around a migration.

For example:

from django.db import migrations

class Migration(migrations.Migration):

    operations = [
        migrations.AddField( ... ) 

    def drop_triggers(self, schema_editor, schema_migration):
        schema_editor.execute("DROP TRIGGER...") 

    def recreate_triggers(self, schema_editor, schema_migration):
        schema_editor.execute("CREATE TRIGGER...")

Now triggers will automatically drop and recreate around the migration operation!

Other Solutions

There are a few other less common options as well:

  • Create a replica PostgreSQL database for running migrations, without triggers enabled. Then sync the applied schema changes back to the primary database.
  • Disable trigger’s directly in PostgreSQL by setting session_replication_role to replica during migration.
  • ImproperlyConfigured the migration files to temporarily drop triggers by overriding SchemaEditor commands.

In most cases, the Django SchemaEditor hooks provide the best development experience for managing triggers. But in complex deployments, alternate solutions like migrations replicas may be necessary.


Django migration errors due to PostgreSQL triggers can certainly be frustrating. But by understanding what’s occurring, you can find a suitable workaround.

Temporarily dropping triggers, manually or via SchemaEditor, allows migrations to run while keeping the rest of your trigger logic intact. With the right strategy, you can stay productive on Django schema migrations even with triggers enabled.