edge badge
Instance Public methods
add_belongs_to(table_name, *args)
Alias for: add_reference
add_column(table_name, column_name, type, options = {})

Adds a new column to the named table. See ActiveRecord::ConnectionAdapters::TableDefinition#column for details of the options you can use.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 390
def add_column(table_name, column_name, type, options = {})
  at = create_alter_table table_name
  at.add_column(column_name, type, options)
  execute schema_creation.accept at
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.

The foreign key will be named after the following pattern: fk_rails_<identifier>. identifier is a 10 character long random string. A custom name can be specified with the :name option.

Creating a simple foreign key
add_foreign_key :articles, :authors


ALTER TABLE "articles" ADD CONSTRAINT articles_author_id_fk FOREIGN KEY ("author_id") REFERENCES "authors" ("id")
Creating a foreign key on a specific column
add_foreign_key :articles, :users, column: :author_id, primary_key: "lng_id"


ALTER TABLE "articles" ADD CONSTRAINT fk_rails_58ca3d3a82 FOREIGN KEY ("author_id") REFERENCES "users" ("lng_id")
Creating a cascading foreign key
add_foreign_key :articles, :authors, on_delete: :cascade


ALTER TABLE "articles" ADD CONSTRAINT articles_author_id_fk FOREIGN KEY ("author_id") REFERENCES "authors" ("id") ON DELETE CASCADE

The options hash can include the following keys:


The foreign key column name on from_table. Defaults to to_table.singularize + "_id"


The primary key column name on to_table. Defaults to id.


The constraint name. Defaults to fk_rails_<identifier>.


Action that happens ON DELETE. Valid values are :nullify, :cascade: and :restrict


Action that happens ON UPDATE. Valid values are :nullify, :cascade: and :restrict

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 725
def add_foreign_key(from_table, to_table, options = {})
  return unless supports_foreign_keys?

  options[:column] ||= foreign_key_column_for(to_table)

  options = {
    column: options[:column],
    primary_key: options[:primary_key],
    name: foreign_key_name(from_table, options),
    on_delete: options[:on_delete],
    on_update: options[:on_update]
  at = create_alter_table from_table
  at.add_foreign_key to_table, options

  execute schema_creation.accept(at)
add_index(table_name, column_name, options = {})

Adds a new index to the table. column_name can be a single Symbol, or an Array of Symbols.

The index will be named after the table and the column name(s), unless you pass :name as an option.

Creating a simple index
add_index(:suppliers, :name)


CREATE INDEX suppliers_name_index ON suppliers(name)
Creating a unique index
add_index(:accounts, [:branch_id, :party_id], unique: true)


CREATE UNIQUE INDEX accounts_branch_id_party_id_index ON accounts(branch_id, party_id)
Creating a named index
add_index(:accounts, [:branch_id, :party_id], unique: true, name: 'by_branch_party')


CREATE UNIQUE INDEX by_branch_party ON accounts(branch_id, party_id)
Creating an index with specific key length
add_index(:accounts, :name, name: 'by_name', length: 10)


CREATE INDEX by_name ON accounts(name(10))

add_index(:accounts, [:name, :surname], name: 'by_name_surname', length: {name: 10, surname: 15})


CREATE INDEX by_name_surname ON accounts(name(10), surname(15))

Note: SQLite doesn't support index length.

Creating an index with a sort order (desc or asc, asc is the default)
add_index(:accounts, [:branch_id, :party_id, :surname], order: {branch_id: :desc, party_id: :asc})


CREATE INDEX by_branch_desc_party ON accounts(branch_id DESC, party_id ASC, surname)

Note: MySQL doesn't yet support index order (it accepts the syntax but ignores it).

Creating a partial index
add_index(:accounts, [:branch_id, :party_id], unique: true, where: "active")


CREATE UNIQUE INDEX index_accounts_on_branch_id_and_party_id ON accounts(branch_id, party_id) WHERE active
Creating an index with a specific method
add_index(:developers, :name, using: 'btree')


CREATE INDEX index_developers_on_name ON developers USING btree (name) -- PostgreSQL
CREATE INDEX index_developers_on_name USING btree ON developers (name) -- MySQL

Note: only supported by PostgreSQL and MySQL

Creating an index with a specific type
add_index(:developers, :name, type: :fulltext)


CREATE FULLTEXT INDEX index_developers_on_name ON developers (name) -- MySQL

Note: only supported by MySQL. Supported: :fulltext and :spatial on MyISAM tables.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 553
def add_index(table_name, column_name, options = {})
  index_name, index_type, index_columns, index_options = add_index_options(table_name, column_name, options)
  execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{index_columns})#{index_options}"
add_reference(table_name, *args)

Adds a reference. Optionally adds a type column, if :polymorphic option is provided. The reference column is an integer by default, the :type option can be used to specify a different type. add_reference and add_belongs_to are acceptable.

Create a user_id integer column
add_reference(:products, :user)
Create a user_id string column
add_reference(:products, :user, type: :string)
Create a supplier_id and supplier_type columns
add_belongs_to(:products, :supplier, polymorphic: true)
Create supplier_id, supplier_type columns and appropriate index
add_reference(:products, :supplier, polymorphic: true, index: true)
Create a supplier_id column and appropriate foreign key
add_reference(:products, :supplier, foreign_key: true)
Also aliased as: add_belongs_to
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 649
def add_reference(table_name, *args)
  ReferenceDefinition.new(*args).add_to(update_table_definition(table_name, self))
add_timestamps(table_name, options = {})

Adds timestamps (created_at and updated_at) columns to table_name. Additional options (like null: false) are forwarded to add_column.

add_timestamps(:suppliers, null: false)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 884
def add_timestamps(table_name, options = {})
  options[:null] = false if options[:null].nil?

  add_column table_name, :created_at, :datetime, options
  add_column table_name, :updated_at, :datetime, options
assume_migrated_upto_version(version, migrations_paths = ActiveRecord::Migrator.migrations_paths)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 811
def assume_migrated_upto_version(version, migrations_paths = ActiveRecord::Migrator.migrations_paths)
  migrations_paths = Array(migrations_paths)
  version = version.to_i
  sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)

  migrated = select_values("SELECT version FROM #{sm_table}").map(&:to_i)
  paths = migrations_paths.map {|p| "#{p}/[0-9]*_*.rb" }
  versions = Dir[*paths].map do |filename|

  unless migrated.include?(version)
    execute "INSERT INTO #{sm_table} (version) VALUES ('#{version}')"

  inserted = Set.new
  (versions - migrated).each do |v|
    if inserted.include?(v)
      raise "Duplicate migration #{v}. Please renumber your migrations to resolve the conflict."
    elsif v < version
      execute "INSERT INTO #{sm_table} (version) VALUES ('#{v}')"
      inserted << v
change_column(table_name, column_name, type, options = {})

Changes the column's definition according to the new options. See ActiveRecord::ConnectionAdapters::TableDefinition#column for details of the options you can use.

change_column(:suppliers, :name, :string, limit: 80)
change_column(:accounts, :description, :text)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 424
def change_column(table_name, column_name, type, options = {})
  raise NotImplementedError, "change_column is not implemented"
change_column_default(table_name, column_name, default)

Sets a new default value for a column:

change_column_default(:suppliers, :qualification, 'new')
change_column_default(:accounts, :authorized, 1)

Setting the default to nil effectively drops the default:

change_column_default(:users, :email, nil)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 437
def change_column_default(table_name, column_name, default)
  raise NotImplementedError, "change_column_default is not implemented"
change_column_null(table_name, column_name, null, default = nil)

Sets or removes a +NOT NULL+ constraint on a column. The null flag indicates whether the value can be NULL. For example

change_column_null(:users, :nickname, false)

says nicknames cannot be NULL (adds the constraint), whereas

change_column_null(:users, :nickname, true)

allows them to be NULL (drops the constraint).

The method accepts an optional fourth argument to replace existing +NULL+s with some other value. Use that one when enabling the constraint if needed, since otherwise those rows would not be valid.

Please note the fourth argument does not set a column's default.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 457
def change_column_null(table_name, column_name, null, default = nil)
  raise NotImplementedError, "change_column_null is not implemented"
change_table(table_name, options = {})

A block for changing columns in table.

# change_table() yields a Table instance
change_table(:suppliers) do |t|
  t.column :name, :string, limit: 60
  # Other column alterations here

The options hash can include the following keys:


Set this to true to make this a bulk alter query, such as


Defaults to false.

Add a column
change_table(:suppliers) do |t|
  t.column :name, :string, limit: 60
Add 2 integer columns
change_table(:suppliers) do |t|
  t.integer :width, :height, null: false, default: 0
Add created_at/updated_at columns
change_table(:suppliers) do |t|
Add a foreign key column
change_table(:suppliers) do |t|
  t.references :company

Creates a company_id(integer) column.

Add a polymorphic foreign key column
change_table(:suppliers) do |t|
  t.belongs_to :company, polymorphic: true

Creates company_type(varchar) and company_id(integer) columns.

Remove a column
change_table(:suppliers) do |t|
  t.remove :company
Remove several columns
change_table(:suppliers) do |t|
  t.remove :company_id
  t.remove :width, :height
Remove an index
change_table(:suppliers) do |t|
  t.remove_index :company_id

See also Table for details on all of the various column transformation.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 357
def change_table(table_name, options = {})
  if supports_bulk_alter? && options[:bulk]
    recorder = ActiveRecord::Migration::CommandRecorder.new(self)
    yield update_table_definition(table_name, recorder)
    bulk_change_table(table_name, recorder.commands)
    yield update_table_definition(table_name, self)
column_exists?(table_name, column_name, type = nil, options = {})

Checks to see if a column exists in a given table.

# Check a column exists
column_exists?(:suppliers, :name)

# Check a column exists of a particular type
column_exists?(:suppliers, :name, :string)

# Check a column exists with a specific definition
column_exists?(:suppliers, :name, :string, limit: 100)
column_exists?(:suppliers, :name, :string, default: 'default')
column_exists?(:suppliers, :name, :string, null: false)
column_exists?(:suppliers, :tax, :decimal, precision: 8, scale: 2)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 76
def column_exists?(table_name, column_name, type = nil, options = {})
  column_name = column_name.to_s
  columns(table_name).any?{ |c| c.name == column_name &&
                                (!type                     || c.type == type) &&
                                (!options.key?(:limit)     || c.limit == options[:limit]) &&
                                (!options.key?(:precision) || c.precision == options[:precision]) &&
                                (!options.key?(:scale)     || c.scale == options[:scale]) &&
                                (!options.key?(:default)   || c.default == options[:default]) &&
                                (!options.key?(:null)      || c.null == options[:null]) }

Returns an array of Column objects for the table specified by table_name. See the concrete implementation for details on the expected parameter values.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 60
def columns(table_name) end
create_join_table(table_1, table_2, options = {})

Creates a new join table with the name created using the lexical order of the first two arguments. These arguments can be a String or a Symbol.

# Creates a table called 'assemblies_parts' with no id.
create_join_table(:assemblies, :parts)

You can pass a options hash can include the following keys:


Sets the table name overriding the default


Any extra options you want appended to the columns definition.


Any extra options you want appended to the table definition.


Make a temporary table.


Set to true to drop the table before creating it. Defaults to false.

Note that create_join_table does not create any indices by default; you can use its block form to do so yourself:

create_join_table :products, :categories do |t|
  t.index :product_id
  t.index :category_id
Add a backend specific option to the generated SQL (MySQL)
create_join_table(:assemblies, :parts, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8')


CREATE TABLE assemblies_parts (
  assembly_id int NOT NULL,
  part_id int NOT NULL,
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 261
def create_join_table(table_1, table_2, options = {})
  join_table_name = find_join_table_name(table_1, table_2, options)

  column_options = options.delete(:column_options) || {}
  column_options.reverse_merge!(null: false)

  t1_column, t2_column = [table_1, table_2].map{ |t| t.to_s.singularize.foreign_key }

  create_table(join_table_name, options.merge!(id: false)) do |td|
    td.integer t1_column, column_options
    td.integer t2_column, column_options
    yield td if block_given?
create_table(table_name, options = {})

Creates a new table with the name table_name. table_name may either be a String or a Symbol.

There are two ways to work with create_table. You can use the block form or the regular form, like this:

Block form

# create_table() passes a TableDefinition object to the block.
# This form will not only create the table, but also columns for the
# table.

create_table(:suppliers) do |t|
  t.column :name, :string, limit: 60
  # Other fields here

Block form, with shorthand

# You can also use the column types as method calls, rather than calling the column method.
create_table(:suppliers) do |t|
  t.string :name, limit: 60
  # Other fields here

Regular form

# Creates a table called 'suppliers' with no columns.
# Add a column to 'suppliers'.
add_column(:suppliers, :name, :string, {limit: 60})

The options hash can include the following keys:


Whether to automatically add a primary key column. Defaults to true. Join tables for has_and_belongs_to_many should set it to false.


The name of the primary key, if one is to be added automatically. Defaults to id. If :id is false this option is ignored.

Note that Active Record models will automatically detect their primary key. This can be avoided by using self.primary_key= on the model to define the key explicitly.


Any extra options you want appended to the table definition.


Make a temporary table.


Set to true to drop the table before creating it. Set to :cascade to drop dependent objects as well. Defaults to false.


SQL to use to generate the table. When this option is used, the block is ignored, as are the :id and :primary_key options.

Add a backend specific option to the generated SQL (MySQL)
create_table(:suppliers, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8')


CREATE TABLE suppliers (
  id int(11) DEFAULT NULL auto_increment PRIMARY KEY
Rename the primary key column
create_table(:objects, primary_key: 'guid') do |t|
  t.column :name, :string, limit: 80


CREATE TABLE objects (
  guid int(11) DEFAULT NULL auto_increment PRIMARY KEY,
  name varchar(80)
Do not add a primary key column
create_table(:categories_suppliers, id: false) do |t|
  t.column :category_id, :integer
  t.column :supplier_id, :integer


CREATE TABLE categories_suppliers (
  category_id int,
  supplier_id int
Create a temporary table based on a query
create_table(:long_query, temporary: true,
  as: "SELECT * FROM orders INNER JOIN line_items ON order_id=orders.id")


  SELECT * FROM orders INNER JOIN line_items ON order_id=orders.id

See also ActiveRecord::ConnectionAdapters::TableDefinition#column for details on how to create columns.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 191
def create_table(table_name, options = {})
  td = create_table_definition table_name, options[:temporary], options[:options], options[:as]

  if options[:id] != false && !options[:as]
    pk = options.fetch(:primary_key) do
      Base.get_primary_key table_name.to_s.singularize

    td.primary_key pk, options.fetch(:id, :primary_key), options

  yield td if block_given?

  if options[:force] && table_exists?(table_name)
    drop_table(table_name, options)

  result = execute schema_creation.accept td

  unless supports_indexes_in_create?
    td.indexes.each_pair do |column_name, index_options|
      add_index(table_name, column_name, index_options)

  td.foreign_keys.each_pair do |other_table_name, foreign_key_options|
    add_foreign_key(table_name, other_table_name, foreign_key_options)

drop_join_table(table_1, table_2, options = {})

Drops the join table specified by the given arguments. See create_join_table for details.

Although this command ignores the block if one is given, it can be helpful to provide one in a migration's change method so it can be reverted. In that case, the block will be used by create_join_table.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 282
def drop_join_table(table_1, table_2, options = {})
  join_table_name = find_join_table_name(table_1, table_2, options)
drop_table(table_name, options = {})

Drops a table from the database.


Set to :cascade to drop dependent objects as well. Defaults to false.

Although this command ignores most options and the block if one is given, it can be helpful to provide these in a migration's change method so it can be reverted. In that case, options and the block will be used by create_table.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 384
def drop_table(table_name, options = {})
  execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}"
foreign_key_exists?(from_table, options_or_to_table = {})

Checks to see if a foreign key exists on a table for a given foreign key definition.

# Check a foreign key exists
foreign_key_exists?(:accounts, :branches)

# Check a foreign key on a specified column exists
foreign_key_exists?(:accounts, column: :owner_id)

# Check a foreign key with a custom name exists
foreign_key_exists?(:accounts, name: "special_fk_name")
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 779
def foreign_key_exists?(from_table, options_or_to_table = {})
  foreign_key_for(from_table, options_or_to_table).present?

Returns an array of foreign keys for the given table. The foreign keys are represented as ForeignKeyDefinition objects.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 679
def foreign_keys(table_name)
  raise NotImplementedError, "foreign_keys is not implemented"
index_exists?(table_name, column_name, options = {})

Checks to see if an index exists on a table for a given index definition.

# Check an index exists
index_exists?(:suppliers, :company_id)

# Check an index on multiple columns exists
index_exists?(:suppliers, [:company_id, :company_type])

# Check a unique index exists
index_exists?(:suppliers, :company_id, unique: true)

# Check an index with a custom name exists
index_exists?(:suppliers, :company_id, name: "idx_company_id")
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 47
def index_exists?(table_name, column_name, options = {})
  column_names = Array(column_name).map(&:to_s)
  index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, column: column_names)
  checks = []
  checks << lambda { |i| i.name == index_name }
  checks << lambda { |i| i.columns == column_names }
  checks << lambda { |i| i.unique } if options[:unique]

  indexes(table_name).any? { |i| checks.all? { |check| check[i] } }
index_name_exists?(table_name, index_name, default)

Verifies the existence of an index with a given name.

The default argument is returned if the underlying implementation does not define the indexes method, as there's no way to determine the correct answer in that case.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 618
def index_name_exists?(table_name, index_name, default)
  return default unless respond_to?(:indexes)
  index_name = index_name.to_s
  indexes(table_name).detect { |i| i.name == index_name }

Should not be called normally, but this operation is non-destructive. The migrations module handles this automatically.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 807
def initialize_schema_migrations_table

Returns a hash of mappings from the abstract data types to the native database types. See ActiveRecord::ConnectionAdapters::TableDefinition#column for details on the recognized abstract data types.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 13
def native_database_types
remove_belongs_to(table_name, ref_name, options = {})
Alias for: remove_reference
remove_column(table_name, column_name, type = nil, options = {})

Removes the column from the table definition.

remove_column(:suppliers, :qualification)

The type and options parameters will be ignored if present. It can be helpful to provide these in a migration's change method so it can be reverted. In that case, type and options will be used by add_column.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 414
def remove_column(table_name, column_name, type = nil, options = {})
  execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
remove_columns(table_name, *column_names)

Removes the given columns from the table definition.

remove_columns(:suppliers, :qualification, :experience)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 400
def remove_columns(table_name, *column_names)
  raise ArgumentError.new("You must specify at least one column name. Example: remove_columns(:people, :first_name)") if column_names.empty?
  column_names.each do |column_name|
    remove_column(table_name, column_name)
remove_foreign_key(from_table, options_or_to_table = {})

Removes the given foreign key from the table.

Removes the foreign key on accounts.branch_id.

remove_foreign_key :accounts, :branches

Removes the foreign key on accounts.owner_id.

remove_foreign_key :accounts, column: :owner_id

Removes the foreign key named special_fk_name on the accounts table.

remove_foreign_key :accounts, name: :special_fk_name
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 757
def remove_foreign_key(from_table, options_or_to_table = {})
  return unless supports_foreign_keys?

  fk_name_to_delete = foreign_key_for!(from_table, options_or_to_table).name

  at = create_alter_table from_table
  at.drop_foreign_key fk_name_to_delete

  execute schema_creation.accept(at)
remove_index(table_name, options = {})

Removes the given index from the table.

Removes the index_accounts_on_column in the accounts table.

remove_index :accounts, :column

Removes the index named index_accounts_on_branch_id in the accounts table.

remove_index :accounts, column: :branch_id

Removes the index named index_accounts_on_branch_id_and_party_id in the accounts table.

remove_index :accounts, column: [:branch_id, :party_id]

Removes the index named by_branch_party in the accounts table.

remove_index :accounts, name: :by_branch_party
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 576
def remove_index(table_name, options = {})
  remove_index!(table_name, index_name_for_remove(table_name, options))
remove_reference(table_name, ref_name, options = {})

Removes the reference(s). Also removes a type column if one exists. remove_reference, remove_references and remove_belongs_to are acceptable.

Remove the reference
remove_reference(:products, :user, index: true)
Remove polymorphic reference
remove_reference(:products, :supplier, polymorphic: true)
Remove the reference with a foreign key
remove_reference(:products, :user, index: true, foreign_key: true)
Also aliased as: remove_belongs_to
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 669
def remove_reference(table_name, ref_name, options = {})
  remove_foreign_key table_name, ref_name.to_s.pluralize if options[:foreign_key]

  remove_column(table_name, "#{ref_name}_id")
  remove_column(table_name, "#{ref_name}_type") if options[:polymorphic]
remove_timestamps(table_name, options = {})

Removes the timestamp columns (created_at and updated_at) from the table definition.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 895
def remove_timestamps(table_name, options = {})
  remove_column table_name, :updated_at
  remove_column table_name, :created_at
rename_column(table_name, column_name, new_column_name)

Renames a column.

rename_column(:suppliers, :description, :name)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 465
def rename_column(table_name, column_name, new_column_name)
  raise NotImplementedError, "rename_column is not implemented"
rename_index(table_name, old_name, new_name)

Renames an index.

Rename the index_people_on_last_name index to index_users_on_last_name:

rename_index :people, 'index_people_on_last_name', 'index_users_on_last_name'
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 590
def rename_index(table_name, old_name, new_name)
  validate_index_length!(table_name, new_name)

  # this is a naive implementation; some DBs may support this more efficiently (Postgres, for instance)
  old_index_def = indexes(table_name).detect { |i| i.name == old_name }
  return unless old_index_def
  add_index(table_name, old_index_def.columns, name: new_name, unique: old_index_def.unique)
  remove_index(table_name, name: old_name)
rename_table(table_name, new_name)

Renames a table.

rename_table('octopuses', 'octopi')
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 371
def rename_table(table_name, new_name)
  raise NotImplementedError, "rename_table is not implemented"

Truncates a table alias according to the limits of the current adapter.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 18
def table_alias_for(table_name)
  table_name[0...table_alias_length].tr('.', '_')

Checks to see if the table table_name exists on the database.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 26
def table_exists?(table_name)
Instance Protected methods
add_index_sort_order(option_strings, column_names, options = {})
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 939
def add_index_sort_order(option_strings, column_names, options = {})
  if options.is_a?(Hash) && order = options[:order]
    case order
    when Hash
      column_names.each {|name| option_strings[name] += " #{order[name].upcase}" if order.has_key?(name)}
    when String
      column_names.each {|name| option_strings[name] += " #{order.upcase}"}

  return option_strings
index_name_for_remove(table_name, options = {})
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 968
def index_name_for_remove(table_name, options = {})
  index_name = index_name(table_name, options)

  unless index_name_exists?(table_name, index_name, true)
    if options.is_a?(Hash) && options.has_key?(:name)
      options_without_column = options.dup
      options_without_column.delete :column
      index_name_without_column = index_name(table_name, options_without_column)

      return index_name_without_column if index_name_exists?(table_name, index_name_without_column, false)

    raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 964
def options_include_default?(options)
  options.include?(:default) && !(options[:null] == false && options[:default].nil?)
quoted_columns_for_index(column_names, options = {})

Overridden by the MySQL adapter for supporting index lengths

# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 953
def quoted_columns_for_index(column_names, options = {})
  option_strings = Hash[column_names.map {|name| [name, '']}]

  # add index sort order if supported
  if supports_index_sort_order?
    option_strings = add_index_sort_order(option_strings, column_names, options)

  column_names.map {|name| quote_column_name(name) + option_strings[name]}
rename_column_indexes(table_name, column_name, new_column_name)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 995
def rename_column_indexes(table_name, column_name, new_column_name)
  column_name, new_column_name = column_name.to_s, new_column_name.to_s
  indexes(table_name).each do |index|
    next unless index.columns.include?(new_column_name)
    old_columns = index.columns.dup
    old_columns[old_columns.index(new_column_name)] = column_name
    generated_index_name = index_name(table_name, column: old_columns)
    if generated_index_name == index.name
      rename_index table_name, generated_index_name, index_name(table_name, column: index.columns)
rename_table_indexes(table_name, new_name)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 986
def rename_table_indexes(table_name, new_name)
  indexes(new_name).each do |index|
    generated_index_name = index_name(table_name, column: index.columns)
    if generated_index_name == index.name
      rename_index new_name, generated_index_name, index_name(new_name, column: index.columns)