Module: ActiveRecord::ConnectionAdapters::SchemaStatements

Includes:
Migration::JoinTable
Included in:
AbstractAdapter
Defined in:
lib/active_record/connection_adapters/abstract/schema_statements.rb

Instance Method Summary collapse

Instance Method Details

#add_column(table_name, column_name, type, options = {}) ⇒ Object

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



357
358
359
360
361
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 357

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
end

#add_column_options!(sql, options) ⇒ Object

:nodoc:



697
698
699
700
701
702
703
704
705
706
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 697

def add_column_options!(sql, options) #:nodoc:
  sql << " DEFAULT #{quote(options[:default], options[:column])}" if options_include_default?(options)
  # must explicitly check for :null to allow change_column to work on migrations
  if options[:null] == false
    sql << " NOT NULL"
  end
  if options[:auto_increment] == true
    sql << " AUTO_INCREMENT"
  end
end

#add_index(table_name, column_name, options = {}) ⇒ Object

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)

generates:

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

generates:

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')

generates:

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)

generates:

CREATE INDEX by_name ON accounts(name(10))

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

generates:

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})

generates:

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")

generates:

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')

generates:

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)

generates:

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

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



520
521
522
523
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 520

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}"
end

#add_reference(table_name, ref_name, options = {}) ⇒ Object Also known as: add_belongs_to

Adds a reference. Optionally adds a type column, if :polymorphic option is provided. add_reference and add_belongs_to are acceptable.

Create a user_id column
add_reference(:products, :user)
Create a supplier_id and supplier_type columns
add_belongs_to(:products, :supplier, polymorphic: true)
Create a supplier_id, supplier_type columns and appropriate index
add_reference(:products, :supplier, polymorphic: true, index: true)


604
605
606
607
608
609
610
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 604

def add_reference(table_name, ref_name, options = {})
  polymorphic = options.delete(:polymorphic)
  index_options = options.delete(:index)
  add_column(table_name, "#{ref_name}_id", :integer, options)
  add_column(table_name, "#{ref_name}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) if polymorphic
  add_index(table_name, polymorphic ? %w[id type].map{ |t| "#{ref_name}_#{t}" } : "#{ref_name}_id", index_options.is_a?(Hash) ? index_options : nil) if index_options
end

#add_timestamps(table_name) ⇒ Object

Adds timestamps (created_at and updated_at) columns to the named table.

add_timestamps(:suppliers)


730
731
732
733
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 730

def add_timestamps(table_name)
  add_column table_name, :created_at, :datetime
  add_column table_name, :updated_at, :datetime
end

#assume_migrated_upto_version(version, migrations_paths = ActiveRecord::Migrator.migrations_paths) ⇒ Object



644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 644

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 { |v| v.to_i }
  paths = migrations_paths.map {|p| "#{p}/[0-9]*_*.rb" }
  versions = Dir[*paths].map do |filename|
    filename.split('/').last.split('_').first.to_i
  end

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

  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
    end
  end
end

#change_column(table_name, column_name, type, options = {}) ⇒ Object

Changes the column’s definition according to the new options. See TableDefinition#column for details of the options you can use.

change_column(:suppliers, :name, :string, limit: 80)
change_column(:accounts, :description, :text)

Raises:

  • (NotImplementedError)


391
392
393
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 391

def change_column(table_name, column_name, type, options = {})
  raise NotImplementedError, "change_column is not implemented"
end

#change_column_default(table_name, column_name, default) ⇒ Object

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)

Raises:

  • (NotImplementedError)


404
405
406
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 404

def change_column_default(table_name, column_name, default)
  raise NotImplementedError, "change_column_default is not implemented"
end

#change_column_null(table_name, column_name, null, default = nil) ⇒ Object

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 NULLs 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.

Raises:

  • (NotImplementedError)


424
425
426
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 424

def change_column_null(table_name, column_name, null, default = nil)
  raise NotImplementedError, "change_column_null is not implemented"
end

#change_table(table_name, options = {}) ⇒ Object

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
end

The options hash can include the following keys:

:bulk

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

ALTER TABLE `users` ADD COLUMN age INT(11), ADD COLUMN birthdate DATETIME ...

Defaults to false.

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

Creates a company_id(integer) column.

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

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

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

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



328
329
330
331
332
333
334
335
336
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 328

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)
  else
    yield update_table_definition(table_name, self)
  end
end

#column_exists?(table_name, column_name, type = nil, options = {}) ⇒ Boolean

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)

Returns:

  • (Boolean)


73
74
75
76
77
78
79
80
81
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 73

def column_exists?(table_name, column_name, type = nil, options = {})
  columns(table_name).any?{ |c| c.name == column_name.to_s &&
                                (!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]) }
end

#columns(table_name) ⇒ Object

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



57
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 57

def columns(table_name) end

#columns_for_distinct(columns, orders) ⇒ Object

Given a set of columns and an ORDER BY clause, returns the columns for a SELECT DISTINCT. Both PostgreSQL and Oracle overrides this for custom DISTINCT syntax - they require the order columns appear in the SELECT.

columns_for_distinct("posts.id", ["posts.created_at desc"])


722
723
724
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 722

def columns_for_distinct(columns, orders) #:nodoc:
  columns
end

#create_join_table(table_1, table_2, options = {}) ⇒ Object

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:

:table_name

Sets the table name overriding the default

:column_options

Any extra options you want appended to the columns definition.

:options

Any extra options you want appended to the table definition.

:temporary

Make a temporary table.

:force

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
end
Add a backend specific option to the generated SQL (MySQL)
create_join_table(:assemblies, :parts, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8')

generates:

CREATE TABLE assemblies_parts (
  assembly_id int NOT NULL,
  part_id int NOT NULL,
) ENGINE=InnoDB DEFAULT CHARSET=utf8


232
233
234
235
236
237
238
239
240
241
242
243
244
245
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 232

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?
  end
end

#create_table(table_name, options = {}) {|td| ... } ⇒ Object

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
end

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
end

Regular form

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

The options hash can include the following keys:

:id

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

:primary_key

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.

:options

Any extra options you want appended to the table definition.

:temporary

Make a temporary table.

:force

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

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

generates:

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

generates:

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
end

generates:

CREATE TABLE categories_suppliers (
  category_id int,
  supplier_id int
)

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

Yields:

  • (td)


173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 173

def create_table(table_name, options = {})
  td = create_table_definition table_name, options[:temporary], options[:options]

  unless options[:id] == false
    pk = options.fetch(:primary_key) {
      Base.get_primary_key table_name.to_s.singularize
    }

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

  yield td if block_given?

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

  execute schema_creation.accept td
  td.indexes.each_pair { |c,o| add_index table_name, c, o }
end

#distinct(columns, order_by) ⇒ Object

SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.

distinct("posts.id", ["posts.created_at desc"])


712
713
714
715
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 712

def distinct(columns, order_by)
  ActiveSupport::Deprecation.warn("#distinct is deprecated and shall be removed from future releases.")
  "DISTINCT #{columns_for_distinct(columns, order_by)}"
end

#drop_join_table(table_1, table_2, options = {}) ⇒ Object

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.



253
254
255
256
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 253

def drop_join_table(table_1, table_2, options = {})
  join_table_name = find_join_table_name(table_1, table_2, options)
  drop_table(join_table_name)
end

#drop_table(table_name, options = {}) ⇒ Object

Drops a table from the database.

Although this command ignores 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.



351
352
353
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 351

def drop_table(table_name, options = {})
  execute "DROP TABLE #{quote_table_name(table_name)}"
end

#dump_schema_informationObject

:nodoc:



630
631
632
633
634
635
636
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 630

def dump_schema_information #:nodoc:
  sm_table = ActiveRecord::Migrator.schema_migrations_table_name

  ActiveRecord::SchemaMigration.order('version').map { |sm|
    "INSERT INTO #{sm_table} (version) VALUES ('#{sm.version}');"
  }.join "\n\n"
end

#index_exists?(table_name, column_name, options = {}) ⇒ Boolean

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"

Returns:

  • (Boolean)


45
46
47
48
49
50
51
52
53
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 45

def index_exists?(table_name, column_name, options = {})
  column_names = Array(column_name)
  index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, :column => column_names)
  if options[:unique]
    indexes(table_name).any?{ |i| i.unique && i.name == index_name }
  else
    indexes(table_name).any?{ |i| i.name == index_name }
  end
end

#index_name(table_name, options) ⇒ Object

:nodoc:



565
566
567
568
569
570
571
572
573
574
575
576
577
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 565

def index_name(table_name, options) #:nodoc:
  if Hash === options
    if options[:column]
      "index_#{table_name}_on_#{Array(options[:column]) * '_and_'}"
    elsif options[:name]
      options[:name]
    else
      raise ArgumentError, "You must specify the index name"
    end
  else
    index_name(table_name, :column => options)
  end
end

#index_name_exists?(table_name, index_name, default) ⇒ Boolean

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.

Returns:

  • (Boolean)


583
584
585
586
587
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 583

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 }
end

#initialize_schema_migrations_tableObject

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



640
641
642
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 640

def initialize_schema_migrations_table
  ActiveRecord::SchemaMigration.create_table
end

#native_database_typesObject

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



11
12
13
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 11

def native_database_types
  {}
end

#remove_column(table_name, column_name, type = nil, options = {}) ⇒ Object

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.



381
382
383
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 381

def remove_column(table_name, column_name, type = nil, options = {})
  execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
end

#remove_columns(table_name, *column_names) ⇒ Object

Removes the given columns from the table definition.

remove_columns(:suppliers, :qualification, :experience)

Raises:

  • (ArgumentError)


367
368
369
370
371
372
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 367

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)
  end
end

#remove_index(table_name, options = {}) ⇒ Object

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


543
544
545
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 543

def remove_index(table_name, options = {})
  remove_index!(table_name, index_name_for_remove(table_name, options))
end

#remove_index!(table_name, index_name) ⇒ Object

:nodoc:



547
548
549
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 547

def remove_index!(table_name, index_name) #:nodoc:
  execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
end

#remove_reference(table_name, ref_name, options = {}) ⇒ Object Also known as: remove_belongs_to

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)


624
625
626
627
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 624

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

#remove_timestamps(table_name) ⇒ Object

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

remove_timestamps(:suppliers)


739
740
741
742
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 739

def remove_timestamps(table_name)
  remove_column table_name, :updated_at
  remove_column table_name, :created_at
end

#rename_column(table_name, column_name, new_column_name) ⇒ Object

Renames a column.

rename_column(:suppliers, :description, :name)

Raises:

  • (NotImplementedError)


432
433
434
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 432

def rename_column(table_name, column_name, new_column_name)
  raise NotImplementedError, "rename_column is not implemented"
end

#rename_index(table_name, old_name, new_name) ⇒ Object

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'


557
558
559
560
561
562
563
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 557

def rename_index(table_name, old_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
  remove_index(table_name, :name => old_name)
  add_index(table_name, old_index_def.columns, :name => new_name, :unique => old_index_def.unique)
end

#rename_table(table_name, new_name) ⇒ Object

Renames a table.

rename_table('octopuses', 'octopi')

Raises:

  • (NotImplementedError)


342
343
344
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 342

def rename_table(table_name, new_name)
  raise NotImplementedError, "rename_table is not implemented"
end

#table_alias_for(table_name) ⇒ Object

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



16
17
18
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 16

def table_alias_for(table_name)
  table_name[0...table_alias_length].tr('.', '_')
end

#table_exists?(table_name) ⇒ Boolean

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

table_exists?(:developers)

Returns:

  • (Boolean)


24
25
26
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 24

def table_exists?(table_name)
  tables.include?(table_name.to_s)
end

#type_to_sql(type, limit = nil, precision = nil, scale = nil) ⇒ Object

:nodoc:



670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 670

def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
  if native = native_database_types[type.to_sym]
    column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup

    if type == :decimal # ignore limit, use precision and scale
      scale ||= native[:scale]

      if precision ||= native[:precision]
        if scale
          column_type_sql << "(#{precision},#{scale})"
        else
          column_type_sql << "(#{precision})"
        end
      elsif scale
        raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale is specified"
      end

    elsif (type != :primary_key) && (limit ||= native.is_a?(Hash) && native[:limit])
      column_type_sql << "(#{limit})"
    end

    column_type_sql
  else
    type.to_s
  end
end

#update_table_definition(table_name, base) ⇒ Object

:nodoc:



744
745
746
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 744

def update_table_definition(table_name, base) #:nodoc:
  Table.new(table_name, base)
end