Adds a new column to the named table. See TableDefinition#column for details of the options you can use.
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 245 245: def add_column(table_name, column_name, type, options = {}) 246: 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])}" 247: add_column_options!(add_column_sql, options) 248: execute(add_column_sql) 249: 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.
add_index(:suppliers, :name)
generates
CREATE INDEX suppliers_name_index ON suppliers(name)
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)
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)
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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 329 329: def add_index(table_name, column_name, options = {}) 330: options[:name] = options[:name].to_s if options.key?(:name) 331: 332: column_names = Array.wrap(column_name) 333: index_name = index_name(table_name, :column => column_names) 334: 335: if Hash === options # legacy support, since this param was a string 336: index_type = options[:unique] ? "UNIQUE" : "" 337: index_name = options[:name] || index_name 338: else 339: index_type = options 340: end 341: 342: if index_name.length > index_name_length 343: @logger.warn("Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters. Skipping.") 344: return 345: end 346: if index_name_exists?(table_name, index_name, false) 347: @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.") 348: return 349: end 350: quoted_column_names = quoted_columns_for_index(column_names, options).join(", ") 351: 352: execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})" 353: end
Adds timestamps (created_at and updated_at) columns to the named table.
add_timestamps(:suppliers)
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 519 519: def add_timestamps(table_name) 520: add_column table_name, :created_at, :datetime 521: add_column table_name, :updated_at, :datetime 522: end
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 449 449: def assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path) 450: version = version.to_i 451: sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name) 452: 453: migrated = select_values("SELECT version FROM #{sm_table}").map { |v| v.to_i } 454: versions = Dir["#{migrations_path}/[0-9]*_*.rb"].map do |filename| 455: filename.split('/').last.split('_').first.to_i 456: end 457: 458: unless migrated.include?(version) 459: execute "INSERT INTO #{sm_table} (version) VALUES ('#{version}')" 460: end 461: 462: inserted = Set.new 463: (versions - migrated).each do |v| 464: if inserted.include?(v) 465: raise "Duplicate migration #{v}. Please renumber your migrations to resolve the conflict." 466: elsif v < version 467: execute "INSERT INTO #{sm_table} (version) VALUES ('#{v}')" 468: inserted << v 469: end 470: end 471: end
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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 268 268: def change_column(table_name, column_name, type, options = {}) 269: raise NotImplementedError, "change_column is not implemented" 270: end
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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 278 278: def change_column_default(table_name, column_name, default) 279: raise NotImplementedError, "change_column_default is not implemented" 280: end
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
change_table(:suppliers) do |t| t.column :name, :string, :limit => 60 end
change_table(:suppliers) do |t| t.integer :width, :height, :null => false, :default => 0 end
change_table(:suppliers) do |t| t.timestamps end
change_table(:suppliers) do |t| t.references :company end
Creates a company_id(integer) column
change_table(:suppliers) do |t| t.belongs_to :company, :polymorphic => true end
Creates company_type(varchar) and company_id(integer) columns
change_table(:suppliers) do |t| t.remove :company end
change_table(:suppliers) do |t| t.remove :company_id t.remove :width, :height end
change_table(:suppliers) do |t| t.remove_index :company_id end
See also Table for details on all of the various column transformation
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 227 227: def change_table(table_name) 228: yield Table.new(table_name, self) 229: end
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)
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 66 66: def column_exists?(table_name, column_name, type = nil, options = {}) 67: columns(table_name).any?{ |c| c.name == column_name.to_s && 68: (!type || c.type == type) && 69: (!options[:limit] || c.limit == options[:limit]) && 70: (!options[:precision] || c.precision == options[:precision]) && 71: (!options[:scale] || c.scale == options[:scale]) } 72: 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.
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 53 53: def columns(table_name, name = nil) end
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:
# 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
# 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
# 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:
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.
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.
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.
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
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) )
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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 153 153: def create_table(table_name, options = {}) 154: table_definition = TableDefinition.new(self) 155: table_definition.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false 156: 157: yield table_definition if block_given? 158: 159: if options[:force] && table_exists?(table_name) 160: drop_table(table_name, options) 161: end 162: 163: create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE " 164: create_sql << "#{quote_table_name(table_name)} (" 165: create_sql << table_definition.to_sql 166: create_sql << ") #{options[:options]}" 167: execute create_sql 168: 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")
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 512 512: def distinct(columns, order_by) 513: "DISTINCT #{columns}" 514: end
Drops a table from the database.
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 239 239: def drop_table(table_name, options = {}) 240: execute "DROP TABLE #{quote_table_name(table_name)}" 241: end
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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 41 41: def index_exists?(table_name, column_name, options = {}) 42: column_names = Array.wrap(column_name) 43: index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, :column => column_names) 44: if options[:unique] 45: indexes(table_name).any?{ |i| i.unique && i.name == index_name } 46: else 47: indexes(table_name).any?{ |i| i.name == index_name } 48: end 49: 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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 408 408: def index_name_exists?(table_name, index_name, default) 409: return default unless respond_to?(:indexes) 410: indexes(table_name).detect { |i| i.name == index_name } 411: end
Should not be called normally, but this operation is non-destructive. The migrations module handles this automatically.
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 426 426: def initialize_schema_migrations_table 427: sm_table = ActiveRecord::Migrator.schema_migrations_table_name 428: 429: unless table_exists?(sm_table) 430: create_table(sm_table, :id => false) do |schema_migrations_table| 431: schema_migrations_table.column :version, :string, :null => false 432: end 433: add_index sm_table, :version, :unique => true, 434: :name => "#{Base.table_name_prefix}unique_schema_migrations#{Base.table_name_suffix}" 435: 436: # Backwards-compatibility: if we find schema_info, assume we've 437: # migrated up to that point: 438: si_table = Base.table_name_prefix + 'schema_info' + Base.table_name_suffix 439: 440: if table_exists?(si_table) 441: 442: old_version = select_value("SELECT version FROM #{quote_table_name(si_table)}").to_i 443: assume_migrated_upto_version(old_version) 444: drop_table(si_table) 445: end 446: end 447: 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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 9 9: def native_database_types 10: {} 11: end
Removes the column(s) from the table definition.
remove_column(:suppliers, :qualification) remove_columns(:suppliers, :qualification, :experience)
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 255 255: def remove_column(table_name, *column_names) 256: raise ArgumentError.new("You must specify at least one column name. Example: remove_column(:people, :first_name)") if column_names.empty? 257: column_names.flatten.each do |column_name| 258: execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}" 259: end 260: end
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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 365 365: def remove_index(table_name, options = {}) 366: index_name = index_name(table_name, options) 367: unless index_name_exists?(table_name, index_name, true) 368: @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.") 369: return 370: end 371: remove_index!(table_name, index_name) 372: end
Removes the timestamp columns (created_at and updated_at) from the table definition.
remove_timestamps(:suppliers)
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 527 527: def remove_timestamps(table_name) 528: remove_column table_name, :updated_at 529: remove_column table_name, :created_at 530: end
Renames a column.
rename_column(:suppliers, :description, :name)
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 285 285: def rename_column(table_name, column_name, new_column_name) 286: raise NotImplementedError, "rename_column is not implemented" 287: end
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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 382 382: def rename_index(table_name, old_name, new_name) 383: # this is a naive implementation; some DBs may support this more efficiently (Postgres, for instance) 384: old_index_def = indexes(table_name).detect { |i| i.name == old_name } 385: return unless old_index_def 386: remove_index(table_name, :name => old_name) 387: add_index(table_name, old_index_def.columns, :name => new_name, :unique => old_index_def.unique) 388: end
Renames a table.
rename_table('octopuses', 'octopi')
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 234 234: def rename_table(table_name, new_name) 235: raise NotImplementedError, "rename_table is not implemented" 236: end
Returns a string of CREATE TABLE SQL statement(s) for recreating the entire structure of the database.
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 415 415: def structure_dump 416: end
Truncates a table alias according to the limits of the current adapter.
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 14 14: def table_alias_for(table_name) 15: table_name[0..table_alias_length-1].gsub(/\./, '_') 16: end
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 538 538: def options_include_default?(options) 539: options.include?(:default) && !(options[:null] == false && options[:default].nil?) 540: end
Overridden by the mysql adapter for supporting index lengths
# File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 534 534: def quoted_columns_for_index(column_names, options = {}) 535: column_names.map {|name| quote_column_name(name) } 536: end
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.