Public Instance methods
add_column(table_name, column_name, type, options = {})

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

     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 187
187:       def add_column(table_name, column_name, type, options = {})
188:         add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
189:         add_column_options!(add_column_sql, options)
190:         execute(add_column_sql)
191:       end
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 first column name, unless you pass :name as an option.

When creating an index on multiple columns, the first column is used as a name for the index. For example, when you specify an index on two columns [:first, :last], the DBMS creates an index for both columns as well as an index for the first column :first. Using just the first name for this index makes sense, because you will never have to create a singular index with this name.

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

     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 271
271:       def add_index(table_name, column_name, options = {})
272:         column_names = Array(column_name)
273:         index_name   = index_name(table_name, :column => column_names)
275:         if Hash === options # legacy support, since this param was a string
276:           index_type = options[:unique] ? "UNIQUE" : ""
277:           index_name = options[:name].to_s if options[:name]
278:         else
279:           index_type = options
280:         end
282:         if index_name.length > index_name_length
283:           @logger.warn("Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters. Skipping.")
284:           return
285:         end
286:         if index_exists?(table_name, index_name, false)
287:           @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.")
288:           return
289:         end
290:         quoted_column_names = quoted_columns_for_index(column_names, options).join(", ")
292:         execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})"
293:       end
add_order_by_for_association_limiting!(sql, options)

ORDER BY clause for the passed order option. PostgreSQL overrides this due to its stricter standards compliance.

     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 459
459:       def add_order_by_for_association_limiting!(sql, options)
460:         sql << " ORDER BY #{options[:order]}"
461:       end

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

     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 466
466:       def add_timestamps(table_name)
467:         add_column table_name, :created_at, :datetime
468:         add_column table_name, :updated_at, :datetime
469:       end
assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path)
     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 390
390:       def assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path)
391:         version = version.to_i
392:         sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
394:         migrated = select_values("SELECT version FROM #{sm_table}").map(&:to_i)
395:         versions = Dir["#{migrations_path}/[0-9]*_*.rb"].map do |filename|
396:           filename.split('/').last.split('_').first.to_i
397:         end
399:         unless migrated.include?(version)
400:           execute "INSERT INTO #{sm_table} (version) VALUES ('#{version}')"
401:         end
403:         inserted =
404:         (versions - migrated).each do |v|
405:           if inserted.include?(v)
406:             raise "Duplicate migration #{v}. Please renumber your migrations to resolve the conflict."
407:           elsif v < version
408:             execute "INSERT INTO #{sm_table} (version) VALUES ('#{v}')"
409:             inserted << v
410:           end
411:         end
412:       end
change_column(table_name, column_name, type, options = {})

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)
     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 210
210:       def change_column(table_name, column_name, type, options = {})
211:         raise NotImplementedError, "change_column is not implemented"
212:       end
change_column_default(table_name, column_name, default)

Sets a new default value for a column. If you want to set the default value to NULL, you are out of luck. You need to DatabaseStatements#execute the appropriate SQL statement yourself.

 change_column_default(:suppliers, :qualification, 'new')
 change_column_default(:accounts, :authorized, 1)
     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 220
220:       def change_column_default(table_name, column_name, default)
221:         raise NotImplementedError, "change_column_default is not implemented"
222:       end
change_table(table_name) {|, self)| ...}

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
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 169
169:       def change_table(table_name)
170:         yield, self)
171:       end
columns(table_name, name = nil)

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 27
27:       def columns(table_name, name = nil) end
create_table(table_name, options = {}) {|table_definition if block_given?| ...}

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

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 :id => false.
The name of the primary key, if one is to be added automatically. Defaults to id.
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.
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

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

     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 95
 95:       def create_table(table_name, options = {})
 96:         table_definition =
 97:         table_definition.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
 99:         yield table_definition if block_given?
101:         if options[:force] && table_exists?(table_name)
102:           drop_table(table_name, options)
103:         end
105:         create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
106:         create_sql << "#{quote_table_name(table_name)} ("
107:         create_sql << table_definition.to_sql
108:         create_sql << ") #{options[:options]}"
109:         execute create_sql
110:       end
distinct(columns, order_by)

SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause. Both PostgreSQL and Oracle overrides this for custom DISTINCT syntax.

  distinct("", "posts.created_at desc")
     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 453
453:       def distinct(columns, order_by)
454:         "DISTINCT #{columns}"
455:       end
drop_table(table_name, options = {})

Drops a table from the database.

     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 181
181:       def drop_table(table_name, options = {})
182:         execute "DROP TABLE #{quote_table_name(table_name)}"
183:       end
index_exists?(table_name, index_name, default)

Verify the existence of an index.

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 348
348:       def index_exists?(table_name, index_name, default)
349:         return default unless respond_to?(:indexes)
350:         index_name = index_name.to_s
351:         indexes(table_name).detect { |i| == index_name }
352:       end

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 367
367:       def initialize_schema_migrations_table
368:         sm_table = ActiveRecord::Migrator.schema_migrations_table_name
370:         unless tables.detect { |t| t == sm_table }
371:           create_table(sm_table, :id => false) do |schema_migrations_table|
372:             schema_migrations_table.column :version, :string, :null => false
373:           end
374:           add_index sm_table, :version, :unique => true,
375:             :name => "#{Base.table_name_prefix}unique_schema_migrations#{Base.table_name_suffix}"
377:           # Backwards-compatibility: if we find schema_info, assume we've
378:           # migrated up to that point:
379:           si_table = Base.table_name_prefix + 'schema_info' + Base.table_name_suffix
381:           if tables.detect { |t| t == si_table }
383:             old_version = select_value("SELECT version FROM #{quote_table_name(si_table)}").to_i
384:             assume_migrated_upto_version(old_version)
385:             drop_table(si_table)
386:           end
387:         end
388:       end

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.

   # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 7
7:       def native_database_types
8:         {}
9:       end
remove_column(table_name, *column_names)

Removes the column(s) from the table definition.

 remove_column(:suppliers, :qualification)
 remove_columns(:suppliers, :qualification, :experience)
This method is also aliased as remove_columns
     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 197
197:       def remove_column(table_name, *column_names)
198:         raise"You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
199:         column_names.flatten.each do |column_name|
200:           execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
201:         end
202:       end
remove_columns(table_name, *column_names)

Alias for remove_column

remove_index(table_name, options = {})

Remove the given index from the table.

Remove the suppliers_name_index in the suppliers table.

  remove_index :suppliers, :name

Remove the index named accounts_branch_id_index in the accounts table.

  remove_index :accounts, :column => :branch_id

Remove the index named accounts_branch_id_party_id_index in the accounts table.

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

Remove 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 305
305:       def remove_index(table_name, options = {})
306:         index_name = index_name(table_name, options)
307:         unless index_exists?(table_name, index_name, true)
308:           @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.")
309:           return
310:         end
311:         remove_index!(table_name, index_name)
312:       end

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 474
474:       def remove_timestamps(table_name)
475:         remove_column table_name, :updated_at
476:         remove_column table_name, :created_at
477:       end
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 227
227:       def rename_column(table_name, column_name, new_column_name)
228:         raise NotImplementedError, "rename_column is not implemented"
229:       end
rename_index(table_name, old_name, new_name)

Rename 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 322
322:       def rename_index(table_name, old_name, new_name)
323:         # this is a naive implementation; some DBs may support this more efficiently (Postgres, for instance)
324:         old_index_def = indexes(table_name).detect { |i| == old_name }
325:         return unless old_index_def
326:         remove_index(table_name, :name => old_name)
327:         add_index(table_name, old_index_def.columns, :name => new_name, :unique => old_index_def.unique)
328:       end
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 176
176:       def rename_table(table_name, new_name)
177:         raise NotImplementedError, "rename_table is not implemented"
178:       end

Returns a string of CREATE TABLE SQL statement(s) for recreating the entire structure of the database.

     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 356
356:       def structure_dump
357:       end

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

    # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 12
12:       def table_alias_for(table_name)
13:         table_name[0..table_alias_length-1].gsub(/\./, '_')
14:       end

def tables(name = nil) end

    # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 18
18:       def table_exists?(table_name)
19:         tables.include?(table_name.to_s)
20:       end
Protected Instance methods
     # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 485
485:         def options_include_default?(options)
486:           options.include?(:default) && !(options[:null] == false && options[:default].nil?)
487:         end
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 481
481:         def quoted_columns_for_index(column_names, options = {})
482:  {|name| quote_column_name(name) }
483:         end