Class: ActiveRecord::Migration

Inherits:
Object
  • Object
show all
Defined in:
lib/active_record/migration.rb,
lib/active_record/migration/join_table.rb,
lib/active_record/migration/compatibility.rb,
lib/active_record/migration/command_recorder.rb,
lib/active_record/migration/default_strategy.rb,
lib/active_record/migration/execution_strategy.rb

Overview

Active Record Migrations

Migrations can manage the evolution of a schema used by several physical databases. It’s a solution to the common problem of adding a field to make a new feature work in your local database, but being unsure of how to push that change to other developers and to the production server. With migrations, you can describe the transformations in self-contained classes that can be checked into version control systems and executed against another database that might be one, two, or five versions behind.

Example of a simple migration:

class AddSsl < ActiveRecord::Migration[7.2]
  def up
    add_column :accounts, :ssl_enabled, :boolean, default: true
  end

  def down
    remove_column :accounts, :ssl_enabled
  end
end

This migration will add a boolean flag to the accounts table and remove it if you’re backing out of the migration. It shows how all migrations have two methods up and down that describes the transformations required to implement or remove the migration. These methods can consist of both the migration specific methods like add_column and remove_column, but may also contain regular Ruby code for generating data needed for the transformations.

Example of a more complex migration that also needs to initialize data:

class AddSystemSettings < ActiveRecord::Migration[7.2]
  def up
    create_table :system_settings do |t|
      t.string  :name
      t.string  :label
      t.text    :value
      t.string  :type
      t.integer :position
    end

    SystemSetting.create  name:  'notice',
                          label: 'Use notice?',
                          value: 1
  end

  def down
    drop_table :system_settings
  end
end

This migration first adds the system_settings table, then creates the very first row in it using the Active Record model that relies on the table. It also uses the more advanced create_table syntax where you can specify a complete table schema in one block call.

Available transformations

Creation

  • create_join_table(table_1, table_2, options): Creates a join table having its name as the lexical order of the first two arguments. See ActiveRecord::ConnectionAdapters::SchemaStatements#create_join_table for details.

  • create_table(name, options): Creates a table called name and makes the table object available to a block that can then add columns to it, following the same format as add_column. See example above. The options hash is for fragments like “DEFAULT CHARSET=UTF-8” that are appended to the create table definition.

  • add_column(table_name, column_name, type, options): Adds a new column to the table called table_name named column_name specified to be one of the following types: :string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean. A default value can be specified by passing an options hash like { default: 11 }. Other options include :limit and :null (e.g. { limit: 50, null: false }) – see ActiveRecord::ConnectionAdapters::TableDefinition#column for details.

  • add_foreign_key(from_table, to_table, options): Adds a new foreign key. from_table is the table with the key column, to_table contains the referenced primary key.

  • add_index(table_name, column_names, options): Adds a new index with the name of the column. Other options include :name, :unique (e.g. { name: 'users_name_index', unique: true }) and :order (e.g. { order: { name: :desc } }).

  • add_reference(:table_name, :reference_name): Adds a new column reference_name_id by default an integer. See ActiveRecord::ConnectionAdapters::SchemaStatements#add_reference for details.

  • add_timestamps(table_name, options): Adds timestamps (created_at and updated_at) columns to table_name.

Modification

  • change_column(table_name, column_name, type, options): Changes the column to a different type using the same parameters as add_column.

  • change_column_default(table_name, column_name, default_or_changes): Sets a default value for column_name defined by default_or_changes on table_name. Passing a hash containing :from and :to as default_or_changes will make this change reversible in the migration.

  • change_column_null(table_name, column_name, null, default = nil): Sets or removes a NOT NULL constraint on column_name. The null flag indicates whether the value can be NULL. See ActiveRecord::ConnectionAdapters::SchemaStatements#change_column_null for details.

  • change_table(name, options): Allows to make column alterations to the table called name. It makes the table object available to a block that can then add/remove columns, indexes, or foreign keys to it.

  • rename_column(table_name, column_name, new_column_name): Renames a column but keeps the type and content.

  • rename_index(table_name, old_name, new_name): Renames an index.

  • rename_table(old_name, new_name): Renames the table called old_name to new_name.

Deletion

  • drop_table(name): Drops the table called name.

  • drop_join_table(table_1, table_2, options): Drops the join table specified by the given arguments.

  • remove_column(table_name, column_name, type, options): Removes the column named column_name from the table called table_name.

  • remove_columns(table_name, *column_names): Removes the given columns from the table definition.

  • remove_foreign_key(from_table, to_table = nil, **options): Removes the given foreign key from the table called table_name.

  • remove_index(table_name, column: column_names): Removes the index specified by column_names.

  • remove_index(table_name, name: index_name): Removes the index specified by index_name.

  • remove_reference(table_name, ref_name, options): Removes the reference(s) on table_name specified by ref_name.

  • remove_timestamps(table_name, options): Removes the timestamp columns (created_at and updated_at) from the table definition.

Irreversible transformations

Some transformations are destructive in a manner that cannot be reversed. Migrations of that kind should raise an ActiveRecord::IrreversibleMigration exception in their down method.

Running migrations from within Rails

The Rails package has several tools to help create and apply migrations.

To generate a new migration, you can use

$ bin/rails generate migration MyNewMigration

where MyNewMigration is the name of your migration. The generator will create an empty migration file timestamp_my_new_migration.rb in the db/migrate/ directory where timestamp is the UTC formatted date and time that the migration was generated.

There is a special syntactic shortcut to generate migrations that add fields to a table.

$ bin/rails generate migration add_fieldname_to_tablename fieldname:string

This will generate the file timestamp_add_fieldname_to_tablename.rb, which will look like this:

class AddFieldnameToTablename < ActiveRecord::Migration[7.2]
  def change
    add_column :tablenames, :fieldname, :string
  end
end

To run migrations against the currently configured database, use bin/rails db:migrate. This will update the database by running all of the pending migrations, creating the schema_migrations table (see “About the schema_migrations table” section below) if missing. It will also invoke the db:schema:dump command, which will update your db/schema.rb file to match the structure of your database.

To roll the database back to a previous migration version, use bin/rails db:rollback VERSION=X where X is the version to which you wish to downgrade. Alternatively, you can also use the STEP option if you wish to rollback last few migrations. bin/rails db:rollback STEP=2 will rollback the latest two migrations.

If any of the migrations throw an ActiveRecord::IrreversibleMigration exception, that step will fail and you’ll have some manual work to do.

More examples

Not all migrations change the schema. Some just fix the data:

class RemoveEmptyTags < ActiveRecord::Migration[7.2]
  def up
    Tag.all.each { |tag| tag.destroy if tag.pages.empty? }
  end

  def down
    # not much we can do to restore deleted data
    raise ActiveRecord::IrreversibleMigration, "Can't recover the deleted tags"
  end
end

Others remove columns when they migrate up instead of down:

class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[7.2]
  def up
    remove_column :items, :incomplete_items_count
    remove_column :items, :completed_items_count
  end

  def down
    add_column :items, :incomplete_items_count
    add_column :items, :completed_items_count
  end
end

And sometimes you need to do something in SQL not abstracted directly by migrations:

class MakeJoinUnique < ActiveRecord::Migration[7.2]
  def up
    execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
  end

  def down
    execute "ALTER TABLE `pages_linked_pages` DROP INDEX `page_id_linked_page_id`"
  end
end

Using a model after changing its table

Sometimes you’ll want to add a column in a migration and populate it immediately after. In that case, you’ll need to make a call to Base#reset_column_information in order to ensure that the model has the latest column data from after the new column was added. Example:

class AddPeopleSalary < ActiveRecord::Migration[7.2]
  def up
    add_column :people, :salary, :integer
    Person.reset_column_information
    Person.all.each do |p|
      p.update_attribute :salary, SalaryCalculator.compute(p)
    end
  end
end

Controlling verbosity

By default, migrations will describe the actions they are taking, writing them to the console as they happen, along with benchmarks describing how long each step took.

You can quiet them down by setting ActiveRecord::Migration.verbose = false.

You can also insert your own messages and benchmarks by using the say_with_time method:

def up
  ...
  say_with_time "Updating salaries..." do
    Person.all.each do |p|
      p.update_attribute :salary, SalaryCalculator.compute(p)
    end
  end
  ...
end

The phrase “Updating salaries…” would then be printed, along with the benchmark for the block when the block completes.

Timestamped Migrations

By default, Rails generates migrations that look like:

20080717013526_your_migration_name.rb

The prefix is a generation timestamp (in UTC). Timestamps should not be modified manually. To validate that migration timestamps adhere to the format Active Record expects, you can use the following configuration option:

config.active_record.validate_migration_timestamps = true

If you’d prefer to use numeric prefixes, you can turn timestamped migrations off by setting:

config.active_record.timestamped_migrations = false

In application.rb.

Reversible Migrations

Reversible migrations are migrations that know how to go down for you. You simply supply the up logic, and the Migration system figures out how to execute the down commands for you.

To define a reversible migration, define the change method in your migration like this:

class TenderloveMigration < ActiveRecord::Migration[7.2]
  def change
    create_table(:horses) do |t|
      t.column :content, :text
      t.column :remind_at, :datetime
    end
  end
end

This migration will create the horses table for you on the way up, and automatically figure out how to drop the table on the way down.

Some commands cannot be reversed. If you care to define how to move up and down in these cases, you should define the up and down methods as before.

If a command cannot be reversed, an ActiveRecord::IrreversibleMigration exception will be raised when the migration is moving down.

For a list of commands that are reversible, please see ActiveRecord::Migration::CommandRecorder.

Transactional Migrations

If the database adapter supports DDL transactions, all migrations will automatically be wrapped in a transaction. There are queries that you can’t execute inside a transaction though, and for these situations you can turn the automatic transactions off.

class ChangeEnum < ActiveRecord::Migration[7.2]
  disable_ddl_transaction!

  def up
    execute "ALTER TYPE model_size ADD VALUE 'new_value'"
  end
end

Remember that you can still open your own transactions, even if you are in a Migration with self.disable_ddl_transaction!.

Direct Known Subclasses

Current

Defined Under Namespace

Modules: Compatibility, JoinTable Classes: CheckPending, CommandRecorder, Current, DefaultStrategy, ExecutionStrategy, ReversibleBlockHelper

Constant Summary collapse

MigrationFilenameRegexp =

:nodoc:

/\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name = self.class.name, version = nil) ⇒ Migration

Returns a new instance of Migration.



803
804
805
806
807
808
 
# File 'lib/active_record/migration.rb', line 803

def initialize(name = self.class.name, version = nil)
  @name       = name
  @version    = version
  @connection = nil
  @pool       = nil
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *arguments, &block) ⇒ Object 



1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
 
# File 'lib/active_record/migration.rb', line 1047

def method_missing(method, *arguments, &block)
  say_with_time "#{method}(#{format_arguments(arguments)})" do
    unless connection.respond_to? :revert
      unless arguments.empty? || [:execute, :enable_extension, :disable_extension].include?(method)
        arguments[0] = proper_table_name(arguments.first, table_name_options)
        if method == :rename_table ||
          (method == :remove_foreign_key && !arguments.second.is_a?(Hash))
          arguments[1] = proper_table_name(arguments.second, table_name_options)
        end
      end
    end
    return super unless execution_strategy.respond_to?(method)
    execution_strategy.send(method, *arguments, &block)
  end
end

Class Attribute Details

.delegate ⇒ Object

:nodoc:



691
692
693
 
# File 'lib/active_record/migration.rb', line 691

def delegate
  @delegate
end

.disable_ddl_transaction ⇒ Object

:nodoc:



692
693
694
 
# File 'lib/active_record/migration.rb', line 692

def disable_ddl_transaction
  @disable_ddl_transaction
end

Instance Attribute Details

#name ⇒ Object

Returns the value of attribute name.



801
802
803
 
# File 'lib/active_record/migration.rb', line 801

def name
  @name
end

#version ⇒ Object

Returns the value of attribute version.



801
802
803
 
# File 'lib/active_record/migration.rb', line 801

def version
  @version
end

Class Method Details

.[](version) ⇒ Object 



632
633
634
 
# File 'lib/active_record/migration.rb', line 632

def self.[](version)
  Compatibility.find(version)
end

.check_all_pending! ⇒ Object

Raises ActiveRecord::PendingMigrationError error if any migrations are pending for all database configurations in an environment.



700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
 
# File 'lib/active_record/migration.rb', line 700

def check_all_pending!
  pending_migrations = []

  ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: env) do |pool|
    if pending = pool.migration_context.open.pending_migrations
      pending_migrations << pending
    end
  end

  migrations = pending_migrations.flatten

  if migrations.any?
    raise ActiveRecord::PendingMigrationError.new(pending_migrations: migrations)
  end
end

.check_pending_migrations ⇒ Object

:nodoc:



752
753
754
755
756
757
758
 
# File 'lib/active_record/migration.rb', line 752

def check_pending_migrations # :nodoc:
  migrations = pending_migrations

  if migrations.any?
    raise ActiveRecord::PendingMigrationError.new(pending_migrations: migrations)
  end
end

.current_version ⇒ Object 



636
637
638
 
# File 'lib/active_record/migration.rb', line 636

def self.current_version
  ActiveRecord::VERSION::STRING.to_f
end

.disable_ddl_transaction! ⇒ Object

Disable the transaction wrapping this migration. You can still create your own transactions even after calling #disable_ddl_transaction!

For more details read the “Transactional Migrations” section above.



748
749
750
 
# File 'lib/active_record/migration.rb', line 748

def disable_ddl_transaction!
  @disable_ddl_transaction = true
end

.inherited(subclass) ⇒ Object

:nodoc:



620
621
622
623
624
625
626
627
628
629
630
 
# File 'lib/active_record/migration.rb', line 620

def self.inherited(subclass) # :nodoc:
  super
  if subclass.superclass == Migration
    major = ActiveRecord::VERSION::MAJOR
    minor = ActiveRecord::VERSION::MINOR
    raise StandardError, "Directly inheriting from ActiveRecord::Migration is not supported. " \
      "Please specify the Active Record release the migration was written for:\n" \
      "\n" \
      "  class #{subclass} < ActiveRecord::Migration[#{major}.#{minor}]"
  end
end

.load_schema_if_pending! ⇒ Object 



716
717
718
719
720
721
722
723
724
725
726
727
728
 
# File 'lib/active_record/migration.rb', line 716

def load_schema_if_pending!
  if any_schema_needs_update?
    # Roundtrip to Rake to allow plugins to hook into database initialization.
    root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root

    FileUtils.cd(root) do
      Base.connection_handler.clear_all_connections!(:all)
      system("bin/rails db:test:prepare")
    end
  end

  check_pending_migrations
end

.maintain_test_schema! ⇒ Object

:nodoc:



730
731
732
733
734
 
# File 'lib/active_record/migration.rb', line 730

def maintain_test_schema! # :nodoc:
  if ActiveRecord.maintain_test_schema
    suppress_messages { load_schema_if_pending! }
  end
end

.method_missing(name) ⇒ Object

:nodoc:



736
737
738
 
# File 'lib/active_record/migration.rb', line 736

def method_missing(name, ...) # :nodoc:
  nearest_delegate.send(name, ...)
end

.migrate(direction) ⇒ Object 



740
741
742
 
# File 'lib/active_record/migration.rb', line 740

def migrate(direction)
  new.migrate direction
end

.nearest_delegate ⇒ Object

:nodoc:



694
695
696
 
# File 'lib/active_record/migration.rb', line 694

def nearest_delegate # :nodoc:
  delegate || superclass.nearest_delegate
end

.valid_version_format?(version_string) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


642
643
644
645
646
647
 
# File 'lib/active_record/migration.rb', line 642

def self.valid_version_format?(version_string) # :nodoc:
  [
    MigrationFilenameRegexp,
    /\A\d(_?\d)*\z/ # integer with optional underscores
  ].any? { |pattern| pattern.match?(version_string) }
end

Instance Method Details

#announce(message) ⇒ Object 



1008
1009
1010
1011
1012
 
# File 'lib/active_record/migration.rb', line 1008

def announce(message)
  text = "#{version} #{name}: #{message}"
  length = [0, 75 - text.length].max
  write "== %s %s" % [text, "=" * length]
end

#connection ⇒ Object 



1039
1040
1041
 
# File 'lib/active_record/migration.rb', line 1039

def connection
  @connection || ActiveRecord::Tasks::DatabaseTasks.migration_connection
end

#connection_pool ⇒ Object 



1043
1044
1045
 
# File 'lib/active_record/migration.rb', line 1043

def connection_pool
  @pool || ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool
end

#copy(destination, sources, options = {}) ⇒ Object 



1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
 
# File 'lib/active_record/migration.rb', line 1064

def copy(destination, sources, options = {})
  copied = []

  FileUtils.mkdir_p(destination) unless File.exist?(destination)
  schema_migration = SchemaMigration::NullSchemaMigration.new
  internal_metadata = InternalMetadata::NullInternalMetadata.new

  destination_migrations = ActiveRecord::MigrationContext.new(destination, schema_migration, internal_metadata).migrations
  last = destination_migrations.last
  sources.each do |scope, path|
    source_migrations = ActiveRecord::MigrationContext.new(path, schema_migration, internal_metadata).migrations

    source_migrations.each do |migration|
      source = File.binread(migration.filename)
      inserted_comment = "# This migration comes from #{scope} (originally #{migration.version})\n"
      magic_comments = +""
      loop do
        # If we have a magic comment in the original migration,
        # insert our comment after the first newline(end of the magic comment line)
        # so the magic keep working.
        # Note that magic comments must be at the first line(except sh-bang).
        source.sub!(/\A(?:#.*\b(?:en)?coding:\s*\S+|#\s*frozen_string_literal:\s*(?:true|false)).*\n/) do |magic_comment|
          magic_comments << magic_comment; ""
        end || break
      end

      if !magic_comments.empty? && source.start_with?("\n")
        magic_comments << "\n"
        source = source[1..-1]
      end

      source = "#{magic_comments}#{inserted_comment}#{source}"

      if duplicate = destination_migrations.detect { |m| m.name == migration.name }
        if options[:on_skip] && duplicate.scope != scope.to_s
          options[:on_skip].call(scope, migration)
        end
        next
      end

      migration.version = next_migration_number(last ? last.version + 1 : 0).to_i
      new_path = File.join(destination, "#{migration.version}_#{migration.name.underscore}.#{scope}.rb")
      old_path, migration.filename = migration.filename, new_path
      last = migration

      File.binwrite(migration.filename, source)
      copied << migration
      options[:on_copy].call(scope, migration, old_path) if options[:on_copy]
      destination_migrations << migration
    end
  end

  copied
end

#disable_ddl_transaction ⇒ Object

:nodoc:



790
791
792
 
# File 'lib/active_record/migration.rb', line 790

def disable_ddl_transaction # :nodoc:
  self.class.disable_ddl_transaction
end

#down ⇒ Object 



960
961
962
963
964
 
# File 'lib/active_record/migration.rb', line 960

def down
  self.class.delegate = self
  return unless self.class.respond_to?(:down)
  self.class.down
end

#exec_migration(conn, direction) ⇒ Object 



988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
 
# File 'lib/active_record/migration.rb', line 988

def exec_migration(conn, direction)
  @connection = conn
  if respond_to?(:change)
    if direction == :down
      revert { change }
    else
      change
    end
  else
    public_send(direction)
  end
ensure
  @connection = nil
  @execution_strategy = nil
end

#execution_strategy ⇒ Object 



810
811
812
 
# File 'lib/active_record/migration.rb', line 810

def execution_strategy
  @execution_strategy ||= ActiveRecord.migration_strategy.new(self)
end

#migrate(direction) ⇒ Object

Execute this migration in the named direction



967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
 
# File 'lib/active_record/migration.rb', line 967

def migrate(direction)
  return unless respond_to?(direction)

  case direction
  when :up   then announce "migrating"
  when :down then announce "reverting"
  end

  time = nil
  ActiveRecord::Tasks::DatabaseTasks.migration_connection.pool.with_connection do |conn|
    time = Benchmark.measure do
      exec_migration(conn, direction)
    end
  end

  case direction
  when :up   then announce "migrated (%.4fs)" % time.real; write
  when :down then announce "reverted (%.4fs)" % time.real; write
  end
end

#next_migration_number(number) ⇒ Object

Determines the version number of the next migration.



1131
1132
1133
1134
1135
1136
1137
 
# File 'lib/active_record/migration.rb', line 1131

def next_migration_number(number)
  if ActiveRecord.timestamped_migrations
    [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % number].max
  else
    "%.3d" % number.to_i
  end
end

#proper_table_name(name, options = {}) ⇒ Object

Finds the correct table name given an Active Record object. Uses the Active Record object’s own table_name, or pre/suffix from the options passed in.



1122
1123
1124
1125
1126
1127
1128
 
# File 'lib/active_record/migration.rb', line 1122

def proper_table_name(name, options = {})
  if name.respond_to? :table_name
    name.table_name
  else
    "#{options[:table_name_prefix]}#{name}#{options[:table_name_suffix]}"
  end
end

#reversible ⇒ Object

Used to specify an operation that can be run in one direction or another. Call the methods up and down of the yielded object to run a block only in one given direction. The whole block will be called in the right order within the migration.

In the following example, the looping on users will always be done when the three columns ‘first_name’, ‘last_name’ and ‘full_name’ exist, even when migrating down:

class SplitNameMigration < ActiveRecord::Migration[7.2]
  def change
    add_column :users, :first_name, :string
    add_column :users, :last_name, :string

    reversible do |dir|
      User.reset_column_information
      User.all.each do |u|
        dir.up   { u.first_name, u.last_name = u.full_name.split(' ') }
        dir.down { u.full_name = "#{u.first_name} #{u.last_name}" }
        u.save
      end
    end

    revert { add_column :users, :full_name, :string }
  end
end



912
913
914
915
 
# File 'lib/active_record/migration.rb', line 912

def reversible
  helper = ReversibleBlockHelper.new(reverting?)
  execute_block { yield helper }
end

#revert(*migration_classes, &block) ⇒ Object

Reverses the migration commands for the given block and the given migrations.

The following migration will remove the table ‘horses’ and create the table ‘apples’ on the way up, and the reverse on the way down.

class FixTLMigration < ActiveRecord::Migration[7.2]
  def change
    revert do
      create_table(:horses) do |t|
        t.text :content
        t.datetime :remind_at
      end
    end
    create_table(:apples) do |t|
      t.string :variety
    end
  end
end

Or equivalently, if TenderloveMigration is defined as in the documentation for Migration:

require_relative "20121212123456_tenderlove_migration"

class FixupTLMigration < ActiveRecord::Migration[7.2]
  def change
    revert TenderloveMigration

    create_table(:apples) do |t|
      t.string :variety
    end
  end
end

This command can be nested.



855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
 
# File 'lib/active_record/migration.rb', line 855

def revert(*migration_classes, &block)
  run(*migration_classes.reverse, revert: true) unless migration_classes.empty?
  if block_given?
    if connection.respond_to? :revert
      connection.revert(&block)
    else
      recorder = command_recorder
      @connection = recorder
      suppress_messages do
        connection.revert(&block)
      end
      @connection = recorder.delegate
      recorder.replay(self)
    end
  end
end

#reverting? ⇒ Boolean

Returns:

  • (Boolean) 


872
873
874
 
# File 'lib/active_record/migration.rb', line 872

def reverting?
  connection.respond_to?(:reverting) && connection.reverting
end

#run(*migration_classes) ⇒ Object

Runs the given migration classes. Last argument can specify options:

  • :direction - Default is :up.

  • :revert - Default is false.



940
941
942
943
944
945
946
947
948
949
950
951
952
 
# File 'lib/active_record/migration.rb', line 940

def run(*migration_classes)
  opts = migration_classes.extract_options!
  dir = opts[:direction] || :up
  dir = (dir == :down ? :up : :down) if opts[:revert]
  if reverting?
    # If in revert and going :up, say, we want to execute :down without reverting, so
    revert { run(*migration_classes, direction: dir, revert: true) }
  else
    migration_classes.each do |migration_class|
      migration_class.new.exec_migration(connection, dir)
    end
  end
end

#say(message, subitem = false) ⇒ Object

Takes a message argument and outputs it as is. A second boolean argument can be passed to specify whether to indent or not.



1016
1017
1018
 
# File 'lib/active_record/migration.rb', line 1016

def say(message, subitem = false)
  write "#{subitem ? "   ->" : "--"} #{message}"
end

#say_with_time(message) ⇒ Object

Outputs text along with how long it took to run its block. If the block returns an integer it assumes it is the number of rows affected.



1022
1023
1024
1025
1026
1027
1028
1029
 
# File 'lib/active_record/migration.rb', line 1022

def say_with_time(message)
  say(message)
  result = nil
  time = Benchmark.measure { result = yield }
  say "%.4fs" % time.real, :subitem
  say("#{result} rows", :subitem) if result.is_a?(Integer)
  result
end

#suppress_messages ⇒ Object

Takes a block as an argument and suppresses any output generated by the block.



1032
1033
1034
1035
1036
1037
 
# File 'lib/active_record/migration.rb', line 1032

def suppress_messages
  save, self.verbose = verbose, false
  yield
ensure
  self.verbose = save
end

#table_name_options(config = ActiveRecord::Base) ⇒ Object

Builds a hash for use in ActiveRecord::Migration#proper_table_name using the Active Record object’s table_name prefix and suffix



1141
1142
1143
1144
1145
1146
 
# File 'lib/active_record/migration.rb', line 1141

def table_name_options(config = ActiveRecord::Base) # :nodoc:
  {
    table_name_prefix: config.table_name_prefix,
    table_name_suffix: config.table_name_suffix
  }
end

#up ⇒ Object 



954
955
956
957
958
 
# File 'lib/active_record/migration.rb', line 954

def up
  self.class.delegate = self
  return unless self.class.respond_to?(:up)
  self.class.up
end

#up_only(&block) ⇒ Object

Used to specify an operation that is only run when migrating up (for example, populating a new column with its initial values).

In the following example, the new column published will be given the value true for all existing records.

class AddPublishedToPosts < ActiveRecord::Migration[7.2]
  def change
    add_column :posts, :published, :boolean, default: false
    up_only do
      execute "update posts set published = 'true'"
    end
  end
end



931
932
933
 
# File 'lib/active_record/migration.rb', line 931

def up_only(&block)
  execute_block(&block) unless reverting?
end

#verbose ⇒ Object

:singleton-method: verbose

Specifies if migrations will write the actions they are taking to the console as they happen, along with benchmarks describing how long each step took. Defaults to true.



800
 
# File 'lib/active_record/migration.rb', line 800

cattr_accessor :verbose

#write(text = "") ⇒ Object 



1004
1005
1006
 
# File 'lib/active_record/migration.rb', line 1004

def write(text = "")
  puts(text) if verbose
end