Files

Class Index [+]

Quicksearch

ActiveRecord::ConnectionAdapters::SchemaStatements

Public Instance Methods

add_column(table_name, column_name, type, options = {}) click to toggle source

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
add_index(table_name, column_name, options = {}) click to toggle source

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 lib/active_record/connection_adapters/abstract/schema_statements.rb, line 329
329:       def add_index(table_name, column_name, options = {})
330:         column_names = Array.wrap(column_name)
331:         index_name   = index_name(table_name, :column => column_names)
332: 
333:         if Hash === options # legacy support, since this param was a string
334:           index_type = options[:unique] ? "UNIQUE" : ""
335:           index_name = options[:name].to_s if options.key?(:name)
336:         else
337:           index_type = options
338:         end
339: 
340:         if index_name.length > index_name_length
341:           raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters"
342:         end
343:         if index_name_exists?(table_name, index_name, false)
344:           raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
345:         end
346:         quoted_column_names = quoted_columns_for_index(column_names, options).join(", ")
347: 
348:         execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})"
349:       end
add_timestamps(table_name) click to toggle source

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

Examples
 add_timestamps(:suppliers)
     # File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 515
515:       def add_timestamps(table_name)
516:         add_column table_name, :created_at, :datetime
517:         add_column table_name, :updated_at, :datetime
518:       end
assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path) click to toggle source
     # File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 445
445:       def assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path)
446:         version = version.to_i
447:         sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
448: 
449:         migrated = select_values("SELECT version FROM #{sm_table}").map { |v| v.to_i }
450:         versions = Dir["#{migrations_path}/[0-9]*_*.rb"].map do |filename|
451:           filename.split('/').last.split('_').first.to_i
452:         end
453: 
454:         unless migrated.include?(version)
455:           execute "INSERT INTO #{sm_table} (version) VALUES ('#{version}')"
456:         end
457: 
458:         inserted = Set.new
459:         (versions - migrated).each do |v|
460:           if inserted.include?(v)
461:             raise "Duplicate migration #{v}. Please renumber your migrations to resolve the conflict."
462:           elsif v < version
463:             execute "INSERT INTO #{sm_table} (version) VALUES ('#{v}')"
464:             inserted << v
465:           end
466:         end
467:       end
change_column(table_name, column_name, type, options = {}) click to toggle source

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)
     # 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
change_column_default(table_name, column_name, default) click to toggle source

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.

Examples
 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
change_table(table_name) click to toggle source

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
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 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
column_exists?(table_name, column_name, type = nil, options = {}) click to toggle source

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 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
columns(table_name, name = nil) click to toggle source

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
create_table(table_name, options = {}) click to toggle source

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 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
distinct(columns, order_by) click to toggle source

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 508
508:       def distinct(columns, order_by)
509:         "DISTINCT #{columns}"
510:       end
drop_table(table_name, options = {}) click to toggle source

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
index_exists?(table_name, column_name, options = {}) click to toggle source

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 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
index_name_exists?(table_name, index_name, default) click to toggle source

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 403
403:       def index_name_exists?(table_name, index_name, default)
404:         return default unless respond_to?(:indexes)
405:         index_name = index_name.to_s
406:         indexes(table_name).detect { |i| i.name == index_name }
407:       end
initialize_schema_migrations_table() click to toggle source

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 422
422:       def initialize_schema_migrations_table
423:         sm_table = ActiveRecord::Migrator.schema_migrations_table_name
424: 
425:         unless table_exists?(sm_table)
426:           create_table(sm_table, :id => false) do |schema_migrations_table|
427:             schema_migrations_table.column :version, :string, :null => false
428:           end
429:           add_index sm_table, :version, :unique => true,
430:             :name => "#{Base.table_name_prefix}unique_schema_migrations#{Base.table_name_suffix}"
431: 
432:           # Backwards-compatibility: if we find schema_info, assume we've
433:           # migrated up to that point:
434:           si_table = Base.table_name_prefix + 'schema_info' + Base.table_name_suffix
435: 
436:           if table_exists?(si_table)
437: 
438:             old_version = select_value("SELECT version FROM #{quote_table_name(si_table)}").to_i
439:             assume_migrated_upto_version(old_version)
440:             drop_table(si_table)
441:           end
442:         end
443:       end
native_database_types() click to toggle source

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
remove_column(table_name, *column_names) click to toggle source

Removes the column(s) from the table definition.

Examples
 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
Also aliased as: remove_columns
remove_columns(table_name, *column_names) click to toggle source
Alias for: remove_column
remove_index(table_name, options = {}) click to toggle source

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 361
361:       def remove_index(table_name, options = {})
362:         index_name = index_name(table_name, options)
363:         unless index_name_exists?(table_name, index_name, true)
364:           raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
365:         end
366:         remove_index!(table_name, index_name)
367:       end
remove_timestamps(table_name) click to toggle source

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

Examples
 remove_timestamps(:suppliers)
     # File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 523
523:       def remove_timestamps(table_name)
524:         remove_column table_name, :updated_at
525:         remove_column table_name, :created_at
526:       end
rename_column(table_name, column_name, new_column_name) click to toggle source

Renames a column.

Example
 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_index(table_name, old_name, new_name) click to toggle source

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 377
377:       def rename_index(table_name, old_name, new_name)
378:         # this is a naive implementation; some DBs may support this more efficiently (Postgres, for instance)
379:         old_index_def = indexes(table_name).detect { |i| i.name == old_name }
380:         return unless old_index_def
381:         remove_index(table_name, :name => old_name)
382:         add_index(table_name, old_index_def.columns, :name => new_name, :unique => old_index_def.unique)
383:       end
rename_table(table_name, new_name) click to toggle source

Renames a table.

Example
 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
structure_dump() click to toggle source

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 411
411:       def structure_dump
412:       end
table_alias_for(table_name) click to toggle source

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
table_exists?(table_name) click to toggle source

def tables(name = nil) end

    # File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 20
20:       def table_exists?(table_name)
21:         tables.include?(table_name.to_s)
22:       end

Protected Instance Methods

options_include_default?(options) click to toggle source
     # File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 534
534:         def options_include_default?(options)
535:           options.include?(:default) && !(options[:null] == false && options[:default].nil?)
536:         end
quoted_columns_for_index(column_names, options = {}) click to toggle source

Overridden by the mysql adapter for supporting index lengths

     # File lib/active_record/connection_adapters/abstract/schema_statements.rb, line 530
530:         def quoted_columns_for_index(column_names, options = {})
531:           column_names.map {|name| quote_column_name(name) }
532:         end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.