Class: ActiveRecord::ConnectionAdapters::TableDefinition

Inherits:
Object
  • Object
show all
Includes:
ColumnMethods
Defined in:
lib/active_record/connection_adapters/abstract/schema_definitions.rb

Overview

Represents the schema of an SQL table in an abstract way. This class provides methods for manipulating the schema representation.

Inside migration files, the t object in create_table is actually of this type:

class SomeMigration < ActiveRecord::Migration[5.0]
  def up
    create_table :foo do |t|
      puts t.class  # => "ActiveRecord::ConnectionAdapters::TableDefinition"
    end
  end

  def down
    ...
  end
end

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from ColumnMethods

#primary_key

Constructor Details

#initialize(name, temporary = false, options = nil, as = nil, comment: nil) ⇒ TableDefinition

Returns a new instance of TableDefinition.



209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 209

def initialize(name, temporary = false, options = nil, as = nil, comment: nil)
  @columns_hash = {}
  @indexes = []
  @foreign_keys = []
  @primary_keys = nil
  @temporary = temporary
  @options = options
  @as = as
  @name = name
  @comment = comment
end

Instance Attribute Details

#as ⇒ Object (readonly)

Returns the value of attribute as.



207
208
209
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 207

def as
  @as
end

#comment ⇒ Object (readonly)

Returns the value of attribute comment.



207
208
209
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 207

def comment
  @comment
end

#foreign_keys ⇒ Object (readonly)

Returns the value of attribute foreign_keys.



207
208
209
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 207

def foreign_keys
  @foreign_keys
end

#indexes ⇒ Object

Returns the value of attribute indexes.



206
207
208
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 206

def indexes
  @indexes
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



207
208
209
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 207

def name
  @name
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



207
208
209
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 207

def options
  @options
end

#temporary ⇒ Object (readonly)

Returns the value of attribute temporary.



207
208
209
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 207

def temporary
  @temporary
end

Instance Method Details

#[](name) ⇒ Object

Returns a ColumnDefinition for the column with name name.



230
231
232
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 230

def [](name)
  @columns_hash[name.to_s]
end

#column(name, type, options = {}) ⇒ Object

Instantiates a new column for the table. See connection.add_column for available options.

Additional options are:

  • :index - Create an index for the column. Can be either true or an options hash.

This method returns self.

Examples

# Assuming +td+ is an instance of TableDefinition
td.column(:granted, :boolean, index: true)

Short-hand examples

Instead of calling #column directly, you can also work with the short-hand definitions for the default types. They use the type as the method name instead of as a parameter and allow for multiple columns to be defined in a single statement.

What can be written like this with the regular calls to column:

create_table :products do |t|
  t.column :shop_id,     :integer
  t.column :creator_id,  :integer
  t.column :item_number, :string
  t.column :name,        :string, default: "Untitled"
  t.column :value,       :string, default: "Untitled"
  t.column :created_at,  :datetime
  t.column :updated_at,  :datetime
end
add_index :products, :item_number

can also be written as follows using the short-hand:

create_table :products do |t|
  t.integer :shop_id, :creator_id
  t.string  :item_number, index: true
  t.string  :name, :value, default: "Untitled"
  t.timestamps null: false
end

There’s a short-hand method for each of the type values declared at the top. And then there’s TableDefinition#timestamps that’ll add created_at and updated_at as datetimes.

TableDefinition#references will add an appropriately-named _id column, plus a corresponding _type column if the :polymorphic option is supplied. If :polymorphic is a hash of options, these will be used when creating the _type column. The :index option will also create an index, similar to calling add_index. So what can be written like this:

create_table :taggings do |t|
  t.integer :tag_id, :tagger_id, :taggable_id
  t.string  :tagger_type
  t.string  :taggable_type, default: 'Photo'
end
add_index :taggings, :tag_id, name: 'index_taggings_on_tag_id'
add_index :taggings, [:tagger_id, :tagger_type]

Can also be written as follows using references:

create_table :taggings do |t|
  t.references :tag, index: { name: 'index_taggings_on_tag_id' }
  t.references :tagger, polymorphic: true, index: true
  t.references :taggable, polymorphic: { default: 'Photo' }
end



301
302
303
304
305
306
307
308
309
310
311
312
313
314
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 301

def column(name, type, options = {})
  name = name.to_s
  type = type.to_sym if type
  options = options.dup

  if @columns_hash[name] && @columns_hash[name].primary_key?
    raise ArgumentError, "you can't redefine the primary key column '#{name}'. To define a custom primary key, pass { id: false } to create_table."
  end

  index_options = options.delete(:index)
  index(name, index_options.is_a?(Hash) ? index_options : {}) if index_options
  @columns_hash[name] = new_column_definition(name, type, options)
  self
end

#columns ⇒ Object

Returns an array of ColumnDefinition objects for the columns of the table.



227
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 227

def columns; @columns_hash.values; end

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

:nodoc:



330
331
332
333
334
335
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 330

def foreign_key(table_name, options = {}) # :nodoc:
  table_name_prefix = ActiveRecord::Base.table_name_prefix
  table_name_suffix = ActiveRecord::Base.table_name_suffix
  table_name = "#{table_name_prefix}#{table_name}#{table_name_suffix}"
  foreign_keys.push([table_name, options])
end

#index(column_name, options = {}) ⇒ Object

Adds index options to the indexes hash, keyed by column name This is primarily used to track indexes that need to be created after the table

index(:account_id, name: 'index_projects_on_account_id')



326
327
328
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 326

def index(column_name, options = {})
  indexes << [column_name, options]
end

#new_column_definition(name, type, options) ⇒ Object

:nodoc:



363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 363

def new_column_definition(name, type, options) # :nodoc:
  type = aliased_types(type.to_s, type)
  column = create_column_definition name, type

  column.limit       = options[:limit]
  column.precision   = options[:precision]
  column.scale       = options[:scale]
  column.default     = options[:default]
  column.null        = options[:null]
  column.first       = options[:first]
  column.after       = options[:after]
  column.auto_increment = options[:auto_increment]
  column.primary_key = type == :primary_key || options[:primary_key]
  column.collation   = options[:collation]
  column.comment     = options[:comment]
  column
end

#primary_keys(name = nil) ⇒ Object

:nodoc:



221
222
223
224
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 221

def primary_keys(name = nil) # :nodoc:
  @primary_keys = PrimaryKeyDefinition.new(name) if name
  @primary_keys
end

#references(*args, **options) ⇒ Object Also known as: belongs_to

Adds a reference.

t.references(:user)
t.belongs_to(:supplier, foreign_key: true)

See connection.add_reference for details of the options you can use.



356
357
358
359
360
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 356

def references(*args, **options)
  args.each do |col|
    ReferenceDefinition.new(col, **options).add_to(self)
  end
end

#remove_column(name) ⇒ Object

remove the column name from the table.

remove_column(:account_id)



318
319
320
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 318

def remove_column(name)
  @columns_hash.delete name.to_s
end

#timestamps(*args) ⇒ Object

Appends :datetime columns :created_at and :updated_at to the table. See connection.add_timestamps

t.timestamps null: false



341
342
343
344
345
346
347
348
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 341

def timestamps(*args)
  options = args.extract_options!

  options[:null] = false if options[:null].nil?

  column(:created_at, :datetime, options)
  column(:updated_at, :datetime, options)
end