- A
- C
- D
- I
- N
- O
- Q
- R
- S
- T
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 262 def add_column(table_name, column_name, type, options = {}) 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])}" add_column_options!(add_column_sql, options) execute(add_column_sql) end
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.
Examples
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
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 342 def add_index(table_name, column_name, options = {}) index_name, index_type, index_columns = 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})" end
Adds timestamps (created_at and updated_at) columns to the named table.
Examples
add_timestamps(:suppliers)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 437 def assume_migrated_upto_version(version, migrations_paths = ActiveRecord::Migrator.migrations_paths) migrations_paths = Array.wrap(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
Changes the column’s definition according to the new options. See TableDefinition#column for details of the options you can use.
Examples
change_column(:suppliers, :name, :string, :limit => 80) change_column(:accounts, :description, :text)
Sets a new default value for a column.
Examples
change_column_default(:suppliers, :qualification, 'new') change_column_default(:accounts, :authorized, 1) change_column_default(:users, :email, nil)
A block for changing columns in table.
Example
# 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.
Examples
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
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 238 def change_table(table_name, options = {}) if supports_bulk_alter? && options[:bulk] recorder = ActiveRecord::Migration::CommandRecorder.new(self) yield Table.new(table_name, recorder) bulk_change_table(table_name, recorder.commands) else yield Table.new(table_name, self) end end
Checks to see if a column exists in a given table.
Examples
# 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)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 70 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[:limit] || c.limit == options[:limit]) && (!options[:precision] || c.precision == options[:precision]) && (!options[:scale] || c.scale == options[:scale]) } end
Returns an array of Column objects for the table specified by table_name. See the concrete implementation for details on the expected parameter values.
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.
Also note that this just sets the primary key in the table. You additionally need to configure the primary key in the model via the set_primary_key macro. Models do NOT auto-detect the primary key from their table 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.
Examples
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.
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 157 def create_table(table_name, options = {}) td = table_definition td.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false yield td if block_given? if options[:force] && table_exists?(table_name) drop_table(table_name, options) end create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE " create_sql << "#{quote_table_name(table_name)} (" create_sql << td.to_sql create_sql << ") #{options[:options]}" execute create_sql end
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.id", "posts.created_at desc")
Drops a table from the database.
Checks to see if an index exists on a table for a given index definition.
Examples
# 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 45 def index_exists?(table_name, column_name, options = {}) column_names = Array.wrap(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
Verify 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 395 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
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 414 def initialize_schema_migrations_table sm_table = ActiveRecord::Migrator.schema_migrations_table_name unless table_exists?(sm_table) create_table(sm_table, :id => false) do |schema_migrations_table| schema_migrations_table.column :version, :string, :null => false end add_index sm_table, :version, :unique => true, :name => "#{Base.table_name_prefix}unique_schema_migrations#{Base.table_name_suffix}" # Backwards-compatibility: if we find schema_info, assume we've # migrated up to that point: si_table = Base.table_name_prefix + 'schema_info' + Base.table_name_suffix if table_exists?(si_table) old_version = select_value("SELECT version FROM #{quote_table_name(si_table)}").to_i assume_migrated_upto_version(old_version) drop_table(si_table) end end 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.
Removes the column(s) from the table definition.
Examples
remove_column(:suppliers, :qualification) remove_columns(:suppliers, :qualification, :experience)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 272 def remove_column(table_name, *column_names) columns_for_remove(table_name, *column_names).each {|column_name| execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{column_name}" } end
Remove the given index from the table.
Remove the index_accounts_on_column in the accounts table.
remove_index :accounts, :column
Remove the index named index_accounts_on_branch_id in the accounts table.
remove_index :accounts, :column => :branch_id
Remove the index named index_accounts_on_branch_id_and_party_id 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
Removes the timestamp columns (created_at and updated_at) from the table definition.
Examples
remove_timestamps(:suppliers)
Renames a column.
Example
rename_column(:suppliers, :description, :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 369 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
Renames a table.
Example
rename_table('octopuses', 'octopi')
Returns a string of CREATE TABLE SQL statement(s) for recreating the entire structure of the database.
Truncates a table alias according to the limits of the current adapter.
Checks to see if the table table_name exists on the database.
Example
table_exists?(:developers)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 532 def add_index_options(table_name, column_name, options = {}) column_names = Array.wrap(column_name) index_name = index_name(table_name, :column => column_names) if Hash === options # legacy support, since this param was a string index_type = options[:unique] ? "UNIQUE" : "" index_name = options[:name].to_s if options.key?(:name) else index_type = options end if index_name.length > index_name_length raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters" end if index_name_exists?(table_name, index_name, false) raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists" end index_columns = quoted_columns_for_index(column_names, options).join(", ") [index_name, index_type, index_columns] end
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 564 def columns_for_remove(table_name, *column_names) column_names = column_names.flatten raise ArgumentError.new("You must specify at least one column name. Example: remove_column(:people, :first_name)") if column_names.blank? column_names.map {|column_name| quote_column_name(column_name) } end
# File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 554 def index_name_for_remove(table_name, options = {}) index_name = index_name(table_name, options) unless index_name_exists?(table_name, index_name, true) raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist" end index_name end
Overridden by the mysql adapter for supporting index lengths