An abstract definition of a column in a table.

Namespace
Methods
B
E
F
H
K
M
N
S
T
V
Constants
TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
 
FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
 
Attributes
[R] default
[R] limit
[R] name
[R] null
[R] precision
[RW] primary
[R] scale
[R] sql_type
[R] type
Class Public methods
binary_to_string(value)

Used to convert from BLOBs to Strings

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 121
def binary_to_string(value)
  value
end
new(name, default, sql_type = nil, null = true)

Instantiates a new column in the table.

nameis the column's name, such as supplier_idin supplier_id int(11). defaultis the type-casted default value, such as newin sales_stage varchar(20) default 'new' . sql_typeis only used to extract the column's length, if necessary. For example 60in company_name varchar(60). nulldetermines if this column allows NULLvalues.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 27
def initialize(name, default, sql_type = nil, null = true)
  @name, @sql_type, @null = name, sql_type, null
  @limit, @precision, @scale = extract_limit(sql_type), extract_precision(sql_type), extract_scale(sql_type)
  @type = simplified_type(sql_type)
  @default = extract_default(default)
  @primary = nil
end
string_to_binary(value)

Used to convert from Strings to BLOBs

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 116
def string_to_binary(value)
  value
end
string_to_date(string)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 125
def string_to_date(string)
  return string unless string.is_a?(String)
  return nil if string.empty?
  fast_string_to_date(string) || fallback_string_to_date(string)
end
string_to_dummy_time(string)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 139
def string_to_dummy_time(string)
  return string unless string.is_a?(String)
  return nil if string.empty?
  string_to_time "2000-01-01 #{string}"
end
string_to_time(string)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 132
def string_to_time(string)
  return string unless string.is_a?(String)
  return nil if string.empty?
  fast_string_to_time(string) || fallback_string_to_time(string)
end
value_to_boolean(value)

convert something to a boolean

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 147
def value_to_boolean(value)
  if value.is_a?(String) && value.blank?
    nil
  else
    TRUE_VALUES.include?(value)
  end
end
value_to_decimal(value)

convert something to a BigDecimal

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 156
def value_to_decimal(value)
  # Using .class is faster than .is_a? and
  # subclasses of BigDecimal will be handled
  # in the else clause
  if value.class == BigDecimal
    value
  elsif value.respond_to?(:to_d)
    value.to_d
  else
    value.to_s.to_d
  end
end
Class Protected methods
fallback_string_to_date(string)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 203
def fallback_string_to_date(string)
  new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
end
fallback_string_to_time(string)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 207
def fallback_string_to_time(string)
  time_hash = Date._parse(string)
  time_hash[:sec_fraction] = microseconds(time_hash)
  new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
end
fast_string_to_date(string)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 189
def fast_string_to_date(string)
  if string =~ Format::ISO_DATE
    new_date $1.to_i, $2.to_i, $3.to_i
  end
end
fast_string_to_time(string)

Doesn't handle time zones.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 196
def fast_string_to_time(string)
  if string =~ Format::ISO_DATETIME
    microsec = ($7.to_f * 1_000_000).to_i
    new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
  end
end
microseconds(time)

'0.123456' -> 123456 '1.123456' -> 123456

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 172
def microseconds(time)
  ((time[:sec_fraction].to_f % 1) * 1_000_000).to_i
end
new_date(year, mon, mday)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 176
def new_date(year, mon, mday)
  if year && year != 0
    Date.new(year, mon, mday) rescue nil
  end
end
new_time(year, mon, mday, hour, min, sec, microsec)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 182
def new_time(year, mon, mday, hour, min, sec, microsec)
  # Treat 0000-00-00 00:00:00 as nil.
  return nil if year.nil? || year == 0
  Time.time_with_datetime_fallback(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
end
Instance Public methods
extract_default(default)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 110
def extract_default(default)
  type_cast(default)
end
has_default?()
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 46
def has_default?
  !default.nil?
end
human_name()

Returns the human name of the column name.

Examples
Column.new('sales_stage', ...).human_name # => 'Sales stage'
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 106
def human_name
  Base.human_attribute_name(@name)
end
klass()

Returns the Ruby class that corresponds to the abstract data type.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 51
def klass
  case type
    when :integer       then Fixnum
    when :float         then Float
    when :decimal       then BigDecimal
    when :datetime      then Time
    when :date          then Date
    when :timestamp     then Time
    when :time          then Time
    when :text, :string then String
    when :binary        then String
    when :boolean       then Object
  end
end
number?()

Returns trueif the column is either of type integer, float or decimal.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 42
def number?
  type == :integer || type == :float || type == :decimal
end
text?()

Returns trueif the column is either of type string or text.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 37
def text?
  type == :string || type == :text
end
type_cast(value)

Casts value (which is a String) to an appropriate instance.

# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 67
def type_cast(value)
  return nil if value.nil?
  case type
    when :string    then value
    when :text      then value
    when :integer   then value.to_i rescue value ? 1 : 0
    when :float     then value.to_f
    when :decimal   then self.class.value_to_decimal(value)
    when :datetime  then self.class.string_to_time(value)
    when :timestamp then self.class.string_to_time(value)
    when :time      then self.class.string_to_dummy_time(value)
    when :date      then self.class.string_to_date(value)
    when :binary    then self.class.binary_to_string(value)
    when :boolean   then self.class.value_to_boolean(value)
    else value
  end
end
type_cast_code(var_name)
# File activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb, line 85
def type_cast_code(var_name)
  case type
    when :string    then nil
    when :text      then nil
    when :integer   then "(#{var_name}.to_i rescue #{var_name} ? 1 : 0)"
    when :float     then "#{var_name}.to_f"
    when :decimal   then "#{self.class.name}.value_to_decimal(#{var_name})"
    when :datetime  then "#{self.class.name}.string_to_time(#{var_name})"
    when :timestamp then "#{self.class.name}.string_to_time(#{var_name})"
    when :time      then "#{self.class.name}.string_to_dummy_time(#{var_name})"
    when :date      then "#{self.class.name}.string_to_date(#{var_name})"
    when :binary    then "#{self.class.name}.binary_to_string(#{var_name})"
    when :boolean   then "#{self.class.name}.value_to_boolean(#{var_name})"
    else nil
  end
end