Reversing The Irreversible Migration

If you've been writing migrations for ActiveRecord for very long, you have eventually encountered this error when trying to rollback a migration.

== 20160607145211 Irreversible: reverting =====================================
rake aborted!
StandardError: An error has occurred, this and all later migrations canceled:

ActiveRecord::IrreversibleMigration

This typically occurs because the previous state is unknown when rolling back, so a reversal can't be generated. For example, we cannot rollback this migration.

class MyMigration < ActiveRecord::Migration
  def change
    change_column :children, :id, :bigint
  end
end

Nothing in this migration indicates what the previous type was, so ActiveRecord cannot generate the reverse statement. Fortunately, there are a couple of ways to fix this problem. First, we could split the change method out into up and down methods.

class MyMigration < ActiveRecord::Migration
  def up
    change_column :children, :id, :bigint
  end

  def down
    change_column :children, :id, :integer
  end
end

This works great in this simple example, but what if you have a longer migration and only part of it is irreversible?

class MyMigration < ActiveRecord::Migration
  def change

    # This is reversible
    add_index :children, :parent_id
    add_index :children, :active

    # This is irreversible
    change_column :children, :id, :bigint

  end
end

You could rewrite this as up and down methods.

class MyMigration < ActiveRecord::Migration
  def up

    add_index :children, :parent_id
    add_index :children, :active

    change_column :children, :id, :bigint

  end

  def down
    change_column :children, :id, :integer

    remove_index :children, :active
    remove_index :children, :parent_id
  end
end

This will work, but is undesirable for a couple of reasons. First, the remove_index calls are duplicating functionality that ActiveRecord migrations already provide. This is a pretty straightforward example, but for some other migration commands, it would be best to allow the tested framework code to do this.

Also, by explicitly calling the add_index and remove_index statements, we have introduced the possibility of a bug by typing the wrong table or column names.

Finally, in this case, the order of the statements is not significant, but if it were, this would be a much more complex down method to implement because we would need to call them in the reverse order of the up method.

Fortunately, ActiveRecord migrations already provide a solution for us. The reversible method. Basically, this method allows you to specify up and down behavior for part of the migration.

class Irreversible < ActiveRecord::Migration
  def change

    add_index :children, :parent_id
    add_index :children, :active

    reversible do |dir|
      dir.up do
        change_column :children, :id, :bigint
      end
      dir.down do
        change_column :children, :id, :int

      end
    end
  end
end

By using the reversible method, we can define the up and down behavior in blocks that will execute when the change method is migrating up or down. In addition to removing the duplication and complexity of the previous example, this clearly specifies the fact that there is an irreversible task occurring. Since this is often a task that should be inspected carefully because of it's possible data loss effects, this is a nice benefit.

It's a good habit to test the rollback of every migration that you write to make sure that it will work when you need it. I like to run my migration when I write it with rake db:migrate and then immediately re-run it with rake db:migrate:redo to verify the rollback. And, now that you know how to reverse "irreversible" migrations, you can save the exception for times when the migration truly cannot be reversed.

Posted by on June 07, 2016