Module: ActiveRecord::ConnectionAdapters::SchemaStatements

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.



245
246
247
248
249
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 245

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

#add_column_options!(sql, options) ⇒ Object

:nodoc:



500
501
502
503
504
505
506
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 500

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



329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 329

def add_index(table_name, column_name, options = {})
  options[:name] = options[:name].to_s if options.key?(:name)

  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] || index_name
  else
    index_type = options
  end

  if index_name.length > index_name_length
    @logger.warn("Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters. Skipping.")
    return
  end
  if index_name_exists?(table_name, index_name, false)
    @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.")
    return
  end
  quoted_column_names = quoted_columns_for_index(column_names, options).join(", ")

  execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})"
end

#add_timestamps(table_name) ⇒ Object

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

Examples
add_timestamps(:suppliers)



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

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_path = ActiveRecord::Migrator.migrations_path) ⇒ Object 



449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 449

def assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path)
  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 }
  versions = Dir["#{migrations_path}/[0-9]*_*.rb"].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.

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

Raises:

  • (NotImplementedError) 


268
269
270
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 268

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

Raises:

  • (NotImplementedError) 


278
279
280
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 278

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

#change_table(table_name) {|Table.new(table_name, self)| ... } ⇒ Object

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

Yields:

  • (Table.new(table_name, self)) 


227
228
229
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 227

def change_table(table_name)
  yield Table.new(table_name, self)
end

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

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)

Returns:

  • (Boolean) 


66
67
68
69
70
71
72
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 66

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

#columns(table_name, name = nil) ⇒ 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.



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

def columns(table_name, name = nil) end

#create_table(table_name, options = {}) {|table_definition| ... } ⇒ 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.

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.

Yields:

  • (table_definition) 


153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 153

def create_table(table_name, options = {})
  table_definition = TableDefinition.new(self)
  table_definition.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false

  yield table_definition 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 << table_definition.to_sql
  create_sql << ") #{options[:options]}"
  execute create_sql
end

#distinct(columns, order_by) ⇒ Object

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



512
513
514
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 512

def distinct(columns, order_by)
  "DISTINCT #{columns}"
end

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

Drops a table from the database.



239
240
241
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 239

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

#dump_schema_information ⇒ Object

:nodoc:



418
419
420
421
422
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 418

def dump_schema_information #:nodoc:
  sm_table = ActiveRecord::Migrator.schema_migrations_table_name
  migrated = select_values("SELECT version FROM #{sm_table}")
  migrated.map { |v| "INSERT INTO #{sm_table} (version) VALUES ('#{v}');" }.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

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"

Returns:

  • (Boolean) 


41
42
43
44
45
46
47
48
49
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 41

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

#index_name(table_name, options) ⇒ Object

:nodoc:



390
391
392
393
394
395
396
397
398
399
400
401
402
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 390

def index_name(table_name, options) #:nodoc:
  if Hash === options # legacy support
    if options[:column]
      "index_#{table_name}_on_#{Array.wrap(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

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.

Returns:

  • (Boolean) 


408
409
410
411
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 408

def index_name_exists?(table_name, index_name, default)
  return default unless respond_to?(:indexes)
  indexes(table_name).detect { |i| i.name == index_name }
end

#initialize_schema_migrations_table ⇒ Object

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



426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 426

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

#native_database_types ⇒ Object

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.



9
10
11
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 9

def native_database_types
  {}
end

#remove_column(table_name, *column_names) ⇒ Object Also known as: remove_columns

Removes the column(s) from the table definition.

Examples
remove_column(:suppliers, :qualification)
remove_columns(:suppliers, :qualification, :experience)

Raises:

  • (ArgumentError) 


255
256
257
258
259
260
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 255

def remove_column(table_name, *column_names)
  raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
  column_names.flatten.each do |column_name|
    execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
  end
end

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

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



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

def remove_index(table_name, options = {})
  index_name = index_name(table_name, options)
  unless index_name_exists?(table_name, index_name, true)
    @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.")
    return
  end
  remove_index!(table_name, index_name)
end

#remove_index!(table_name, index_name) ⇒ Object

:nodoc:



374
375
376
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 374

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

#remove_timestamps(table_name) ⇒ Object

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

Examples
remove_timestamps(:suppliers)



527
528
529
530
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 527

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.

Example
rename_column(:suppliers, :description, :name)

Raises:

  • (NotImplementedError) 


285
286
287
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 285

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

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'



382
383
384
385
386
387
388
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 382

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.

Example
rename_table('octopuses', 'octopi')

Raises:

  • (NotImplementedError) 


234
235
236
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 234

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

#structure_dump ⇒ Object

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



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

def structure_dump
end

#table_alias_for(table_name) ⇒ Object

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



14
15
16
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 14

def table_alias_for(table_name)
  table_name[0..table_alias_length-1].gsub(/\./, '_')
end

#table_exists?(table_name) ⇒ Boolean

def tables(name = nil) end

Returns:

  • (Boolean) 


20
21
22
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 20

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

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

:nodoc:



473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
 
# File 'lib/active_record/connection_adapters/abstract/schema_statements.rb', line 473

def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
  if native = native_database_types[type]
    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 if specified"
      end

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

    column_type_sql
  else
    type
  end
end