Class: ActiveRecord::ConnectionAdapters::TableDefinition

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

Overview

Represents a SQL table in an abstract way. Columns are stored as a ColumnDefinition in the #columns attribute.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(base) ⇒ TableDefinition 



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

def initialize(base)
  @columns = []
  @base = base
end

Instance Attribute Details

#columns ⇒ Object

Returns the value of attribute columns.



276
277
278
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 276

def columns
  @columns
end

Instance Method Details

#[](name) ⇒ Object

Returns a ColumnDefinition for the column with name name.



290
291
292
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 290

def [](name)
  @columns.find {|column| column.name.to_s == name.to_s}
end

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

Instantiates a new column for the table. The type parameter is normally one of the migrations native types, which is one of the following: :primary_key, :string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean.

You may use a type not in this list as long as it is supported by your database (for example, “polygon” in MySQL), but this will not be database agnostic and should usually be avoided.

Available options are (none of these exists by default):

  • :limit - Requests a maximum column length (:string, :text, :binary or :integer columns only)

  • :default - The column’s default value. Use nil for NULL.

  • :null - Allows or disallows NULL values in the column. This option could have been named :null_allowed.

  • :precision - Specifies the precision for a :decimal column.

  • :scale - Specifies the scale for a :decimal column.

Please be aware of different RDBMS implementations behavior with :decimal columns:

  • The SQL standard says the default scale should be 0, :scale <= :precision, and makes no comments about the requirements of :precision.

  • MySQL: :precision [1..63], :scale [0..30]. Default is (10,0).

  • PostgreSQL: :precision [1..infinity], :scale [0..infinity]. No default.

  • SQLite2: Any :precision and :scale may be used. Internal storage as strings. No default.

  • SQLite3: No restrictions on :precision and :scale, but the maximum supported :precision is 16. No default.

  • Oracle: :precision [1..38], :scale [-84..127]. Default is (38,0).

  • DB2: :precision [1..63], :scale [0..62]. Default unknown.

  • Firebird: :precision [1..18], :scale [0..18]. Default (9,0). Internal types NUMERIC and DECIMAL have different storage rules, decimal being better.

  • FrontBase?: :precision [1..38], :scale [0..38]. Default (38,0). WARNING Max :precision/:scale for NUMERIC is 19, and DECIMAL is 38.

  • SqlServer?: :precision [1..38], :scale [0..38]. Default (38,0).

  • Sybase: :precision [1..38], :scale [0..38]. Default (38,0).

  • OpenBase?: Documentation unclear. Claims storage in double.

This method returns self.

Examples

# Assuming td is an instance of TableDefinition
td.column(:granted, :boolean)
  #=> granted BOOLEAN

td.column(:picture, :binary, :limit => 2.megabytes)
  #=> picture BLOB(2097152)

td.column(:sales_stage, :string, :limit => 20, :default => 'new', :null => false)
  #=> sales_stage VARCHAR(20) DEFAULT 'new' NOT NULL

def.column(:bill_gates_money, :decimal, :precision => 15, :scale => 2)
  #=> bill_gates_money DECIMAL(15,2)

def.column(:sensor_reading, :decimal, :precision => 30, :scale => 20)
  #=> sensor_reading DECIMAL(30,20)

# While <tt>:scale</tt> defaults to zero on most databases, it
# probably wouldn't hurt to include it.
def.column(:huge_integer, :decimal, :precision => 30)
  #=> huge_integer DECIMAL(30)

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", :force => true do |t|
  t.column "shop_id",    :integer
  t.column "creator_id", :integer
  t.column "name",       :string,   :default => "Untitled"
  t.column "value",      :string,   :default => "Untitled"
  t.column "created_at", :datetime
  t.column "updated_at", :datetime
end

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

create_table :products do |t|
  t.integer :shop_id, :creator_id
  t.string  :name, :value, :default => "Untitled"
  t.timestamps
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. 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

Can also be written as follows using references:

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



418
419
420
421
422
423
424
425
426
427
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 418

def column(name, type, options = {})
  column = self[name] || ColumnDefinition.new(@base, name, type)
  column.limit = options[:limit] || native[type.to_sym][:limit] if options[:limit] or native[type.to_sym]
  column.precision = options[:precision]
  column.scale = options[:scale]
  column.default = options[:default]
  column.null = options[:null]
  @columns << column unless @columns.include? column
  self
end

#primary_key(name) ⇒ Object

Appends a primary key definition to the table definition. Can be called multiple times, but this is probably not a good idea.



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

def primary_key(name)
  column(name, :primary_key)
end

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



447
448
449
450
451
452
453
454
455
456
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 447

def references(*args)
  options = args.extract_options!
  polymorphic = options.delete(:polymorphic)
  args.each do |col|
    column("#{col}_id", :integer, options)
    unless polymorphic.nil?
      column("#{col}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : {})
    end
  end
end

#timestamps ⇒ Object

Appends :datetime columns :created_at and :updated_at to the table.



442
443
444
445
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 442

def timestamps
  column(:created_at, :datetime)
  column(:updated_at, :datetime)
end

#to_sql ⇒ Object

Returns a String whose contents are the column definitions concatenated together. This string can then be prepended and appended to to generate the final SQL to create the table.



462
463
464
 
# File 'lib/active_record/connection_adapters/abstract/schema_definitions.rb', line 462

def to_sql
  @columns * ', '
end