activerecord 4.2.0

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -0,0 +1,133 @@
+require 'active_support/core_ext/big_decimal/conversions'
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module Quoting
+      # Quotes the column value to help prevent
+      # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+      def quote(value, column = nil)
+        # records are quoted as their primary key
+        return value.quoted_id if value.respond_to?(:quoted_id)
+
+        if column
+          value = column.cast_type.type_cast_for_database(value)
+        end
+
+        _quote(value)
+      end
+
+      # Cast a +value+ to a type that the database understands. For example,
+      # SQLite does not understand dates, so this method will convert a Date
+      # to a String.
+      def type_cast(value, column)
+        if value.respond_to?(:quoted_id) && value.respond_to?(:id)
+          return value.id
+        end
+
+        if column
+          value = column.cast_type.type_cast_for_database(value)
+        end
+
+        _type_cast(value)
+      rescue TypeError
+        to_type = column ? " to #{column.type}" : ""
+        raise TypeError, "can't cast #{value.class}#{to_type}"
+      end
+
+      # Quotes a string, escaping any ' (single quote) and \ (backslash)
+      # characters.
+      def quote_string(s)
+        s.gsub(/\\/, '\&\&').gsub(/'/, "''") # ' (for ruby-mode)
+      end
+
+      # Quotes the column name. Defaults to no quoting.
+      def quote_column_name(column_name)
+        column_name
+      end
+
+      # Quotes the table name. Defaults to column name quoting.
+      def quote_table_name(table_name)
+        quote_column_name(table_name)
+      end
+
+      # Override to return the quoted table name for assignment. Defaults to
+      # table quoting.
+      #
+      # This works for mysql and mysql2 where table.column can be used to
+      # resolve ambiguity.
+      #
+      # We override this in the sqlite3 and postgresql adapters to use only
+      # the column name (as per syntax requirements).
+      def quote_table_name_for_assignment(table, attr)
+        quote_table_name("#{table}.#{attr}")
+      end
+
+      def quoted_true
+        "'t'"
+      end
+
+      def unquoted_true
+        't'
+      end
+
+      def quoted_false
+        "'f'"
+      end
+
+      def unquoted_false
+        'f'
+      end
+
+      def quoted_date(value)
+        if value.acts_like?(:time)
+          zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+
+          if value.respond_to?(zone_conversion_method)
+            value = value.send(zone_conversion_method)
+          end
+        end
+
+        value.to_s(:db)
+      end
+
+      private
+
+      def types_which_need_no_typecasting
+        [nil, Numeric, String]
+      end
+
+      def _quote(value)
+        case value
+        when String, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+          "'#{quote_string(value.to_s)}'"
+        when true       then quoted_true
+        when false      then quoted_false
+        when nil        then "NULL"
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s('F')
+        when Numeric, ActiveSupport::Duration then value.to_s
+        when Date, Time then "'#{quoted_date(value)}'"
+        when Symbol     then "'#{quote_string(value.to_s)}'"
+        when Class      then "'#{value}'"
+        else
+          "'#{quote_string(YAML.dump(value))}'"
+        end
+      end
+
+      def _type_cast(value)
+        case value
+        when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+          value.to_s
+        when true       then unquoted_true
+        when false      then unquoted_false
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s('F')
+        when Date, Time then quoted_date(value)
+        when *types_which_need_no_typecasting
+          value
+        else raise TypeError
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/savepoints.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Savepoints #:nodoc:
+      def supports_savepoints?
+        true
+      end
+
+      def create_savepoint(name = current_savepoint_name)
+        execute("SAVEPOINT #{name}")
+      end
+
+      def rollback_to_savepoint(name = current_savepoint_name)
+        execute("ROLLBACK TO SAVEPOINT #{name}")
+      end
+
+      def release_savepoint(name = current_savepoint_name)
+        execute("RELEASE SAVEPOINT #{name}")
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/schema_creation.rb

@@ -0,0 +1,125 @@
+require 'active_support/core_ext/string/strip'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      class SchemaCreation # :nodoc:
+        def initialize(conn)
+          @conn = conn
+          @cache = {}
+        end
+
+        def accept(o)
+          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
+          send m, o
+        end
+
+        def visit_AddColumn(o)
+          "ADD #{accept(o)}"
+        end
+
+        private
+
+          def visit_AlterTable(o)
+            sql = "ALTER TABLE #{quote_table_name(o.name)} "
+            sql << o.adds.map { |col| visit_AddColumn col }.join(' ')
+            sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(' ')
+            sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(' ')
+          end
+
+          def visit_ColumnDefinition(o)
+            sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale)
+            column_sql = "#{quote_column_name(o.name)} #{sql_type}"
+            add_column_options!(column_sql, column_options(o)) unless o.primary_key?
+            column_sql
+          end
+
+          def visit_TableDefinition(o)
+            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE "
+            create_sql << "#{quote_table_name(o.name)} "
+            create_sql << "(#{o.columns.map { |c| accept c }.join(', ')}) " unless o.as
+            create_sql << "#{o.options}"
+            create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+            create_sql
+          end
+
+          def visit_AddForeignKey(o)
+            sql = <<-SQL.strip_heredoc
+              ADD CONSTRAINT #{quote_column_name(o.name)}
+              FOREIGN KEY (#{quote_column_name(o.column)})
+                REFERENCES #{quote_table_name(o.to_table)} (#{quote_column_name(o.primary_key)})
+            SQL
+            sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
+            sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
+            sql
+          end
+
+          def visit_DropForeignKey(name)
+            "DROP CONSTRAINT #{quote_column_name(name)}"
+          end
+
+          def column_options(o)
+            column_options = {}
+            column_options[:null] = o.null unless o.null.nil?
+            column_options[:default] = o.default unless o.default.nil?
+            column_options[:column] = o
+            column_options[:first] = o.first
+            column_options[:after] = o.after
+            column_options
+          end
+
+          def quote_column_name(name)
+            @conn.quote_column_name name
+          end
+
+          def quote_table_name(name)
+            @conn.quote_table_name name
+          end
+
+          def type_to_sql(type, limit, precision, scale)
+            @conn.type_to_sql type.to_sym, limit, precision, scale
+          end
+
+          def add_column_options!(sql, options)
+            sql << " DEFAULT #{quote_value(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
+            if options[:auto_increment] == true
+              sql << " AUTO_INCREMENT"
+            end
+            sql
+          end
+
+          def quote_value(value, column)
+            column.sql_type ||= type_to_sql(column.type, column.limit, column.precision, column.scale)
+            column.cast_type ||= type_for_column(column)
+
+            @conn.quote(value, column)
+          end
+
+          def options_include_default?(options)
+            options.include?(:default) && !(options[:null] == false && options[:default].nil?)
+          end
+
+          def action_sql(action, dependency)
+            case dependency
+            when :nullify then "ON #{action} SET NULL"
+            when :cascade  then "ON #{action} CASCADE"
+            when :restrict then "ON #{action} RESTRICT"
+            else
+              raise ArgumentError, <<-MSG.strip_heredoc
+                '#{dependency}' is not supported for :on_update or :on_delete.
+                Supported values are: :nullify, :cascade, :restrict
+              MSG
+            end
+          end
+
+          def type_for_column(column)
+            @conn.lookup_cast_type(column.sql_type)
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -0,0 +1,574 @@
+require 'date'
+require 'set'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    # Abstract representation of an index definition on a table. Instances of
+    # this type are typically created and returned by methods in database
+    # adapters. e.g. ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter#indexes
+    class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :type, :using) #:nodoc:
+    end
+
+    # Abstract representation of a column definition. Instances of this type
+    # are typically created by methods in TableDefinition, and added to the
+    # +columns+ attribute of said TableDefinition object, in order to be used
+    # for generating a number of table creation or table changing SQL statements.
+    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :primary_key, :sql_type, :cast_type) #:nodoc:
+
+      def primary_key?
+        primary_key || type.to_sym == :primary_key
+      end
+    end
+
+    class ChangeColumnDefinition < Struct.new(:column, :type, :options) #:nodoc:
+    end
+
+    class ForeignKeyDefinition < Struct.new(:from_table, :to_table, :options) #:nodoc:
+      def name
+        options[:name]
+      end
+
+      def column
+        options[:column]
+      end
+
+      def primary_key
+        options[:primary_key] || default_primary_key
+      end
+
+      def on_delete
+        options[:on_delete]
+      end
+
+      def on_update
+        options[:on_update]
+      end
+
+      def custom_primary_key?
+        options[:primary_key] != default_primary_key
+      end
+
+      private
+      def default_primary_key
+        "id"
+      end
+    end
+
+    module TimestampDefaultDeprecation # :nodoc:
+      def emit_warning_if_null_unspecified(options)
+        return if options.key?(:null)
+
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          `#timestamp` was called without specifying an option for `null`. In Rails 5,
+          this behavior will change to `null: false`. You should manually specify
+         `null: true` to prevent the behavior of your existing migrations from changing.
+        MSG
+      end
+    end
+
+    # 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
+    #     def up
+    #       create_table :foo do |t|
+    #         puts t.class  # => "ActiveRecord::ConnectionAdapters::TableDefinition"
+    #       end
+    #     end
+    #
+    #     def down
+    #       ...
+    #     end
+    #   end
+    #
+    # The table definitions
+    # The Columns are stored as a ColumnDefinition in the +columns+ attribute.
+    class TableDefinition
+      include TimestampDefaultDeprecation
+
+      # An array of ColumnDefinition objects, representing the column changes
+      # that have been defined.
+      attr_accessor :indexes
+      attr_reader :name, :temporary, :options, :as
+
+      def initialize(types, name, temporary, options, as = nil)
+        @columns_hash = {}
+        @indexes = {}
+        @native = types
+        @temporary = temporary
+        @options = options
+        @as = as
+        @name = name
+      end
+
+      def columns; @columns_hash.values; end
+
+      # Appends a primary key definition to the table definition.
+      # Can be called multiple times, but this is probably not a good idea.
+      def primary_key(name, type = :primary_key, options = {})
+        column(name, type, options.merge(:primary_key => true))
+      end
+
+      # Returns a ColumnDefinition for the column with name +name+.
+      def [](name)
+        @columns_hash[name.to_s]
+      end
+
+      # Instantiates a new column for the table.
+      # The +type+ parameter is normally one of the migrations native types,
+      # which is one of the following:
+      # <tt>:primary_key</tt>, <tt>:string</tt>, <tt>:text</tt>,
+      # <tt>:integer</tt>, <tt>:float</tt>, <tt>:decimal</tt>,
+      # <tt>:datetime</tt>, <tt>:time</tt>, <tt>:date</tt>,
+      # <tt>:binary</tt>, <tt>:boolean</tt>.
+      #
+      # 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):
+      # * <tt>:limit</tt> -
+      #   Requests a maximum column length. This is number of characters for <tt>:string</tt> and
+      #   <tt>:text</tt> columns and number of bytes for <tt>:binary</tt> and <tt>:integer</tt> columns.
+      # * <tt>:default</tt> -
+      #   The column's default value. Use nil for NULL.
+      # * <tt>:null</tt> -
+      #   Allows or disallows +NULL+ values in the column. This option could
+      #   have been named <tt>:null_allowed</tt>.
+      # * <tt>:precision</tt> -
+      #   Specifies the precision for a <tt>:decimal</tt> column.
+      # * <tt>:scale</tt> -
+      #   Specifies the scale for a <tt>:decimal</tt> column.
+      # * <tt>:index</tt> -
+      #   Create an index for the column. Can be either <tt>true</tt> or an options hash.
+      #
+      # Note: The precision is the total number of significant digits
+      # and the scale is the number of digits that can be stored following
+      # the decimal point. For example, the number 123.45 has a precision of 5
+      # and a scale of 2. A decimal with a precision of 5 and a scale of 2 can
+      # range from -999.99 to 999.99.
+      #
+      # Please be aware of different RDBMS implementations behavior with
+      # <tt>:decimal</tt> columns:
+      # * The SQL standard says the default scale should be 0, <tt>:scale</tt> <=
+      #   <tt>:precision</tt>, and makes no comments about the requirements of
+      #   <tt>:precision</tt>.
+      # * MySQL: <tt>:precision</tt> [1..63], <tt>:scale</tt> [0..30].
+      #   Default is (10,0).
+      # * PostgreSQL: <tt>:precision</tt> [1..infinity],
+      #   <tt>:scale</tt> [0..infinity]. No default.
+      # * SQLite2: Any <tt>:precision</tt> and <tt>:scale</tt> may be used.
+      #   Internal storage as strings. No default.
+      # * SQLite3: No restrictions on <tt>:precision</tt> and <tt>:scale</tt>,
+      #   but the maximum supported <tt>:precision</tt> is 16. No default.
+      # * Oracle: <tt>:precision</tt> [1..38], <tt>:scale</tt> [-84..127].
+      #   Default is (38,0).
+      # * DB2: <tt>:precision</tt> [1..63], <tt>:scale</tt> [0..62].
+      #   Default unknown.
+      # * SqlServer?: <tt>:precision</tt> [1..38], <tt>:scale</tt> [0..38].
+      #   Default (38,0).
+      #
+      # This method returns <tt>self</tt>.
+      #
+      # == 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
+      #
+      #  td.column(:bill_gates_money, :decimal, precision: 15, scale: 2)
+      #  # => bill_gates_money DECIMAL(15,2)
+      #
+      #  td.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.
+      #  td.column(:huge_integer, :decimal, precision: 30)
+      #  # => huge_integer DECIMAL(30)
+      #
+      #  # Defines a column with a database-specific type.
+      #  td.column(:foo, 'polygon')
+      #  # => foo polygon
+      #
+      # == 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 <tt>:polymorphic</tt> option is supplied. If <tt>:polymorphic</tt> is a hash of
+      # options, these will be used when creating the <tt>_type</tt> column. The <tt>:index</tt> option
+      # will also create an index, similar to calling <tt>add_index</tt>. 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
+      def column(name, type, options = {})
+        name = name.to_s
+        type = type.to_sym
+
+        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
+
+      def remove_column(name)
+        @columns_hash.delete name.to_s
+      end
+
+      [:string, :text, :integer, :bigint, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean].each do |column_type|
+        define_method column_type do |*args|
+          options = args.extract_options!
+          column_names = args
+          column_names.each { |name| column(name, column_type, options) }
+        end
+      end
+
+      # 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')
+      def index(column_name, options = {})
+        indexes[column_name] = options
+      end
+
+      # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and
+      # <tt>:updated_at</tt> to the table. See SchemaStatements#add_timestamps
+      #
+      #   t.timestamps null: false
+      def timestamps(*args)
+        options = args.extract_options!
+        emit_warning_if_null_unspecified(options)
+        column(:created_at, :datetime, options)
+        column(:updated_at, :datetime, options)
+      end
+
+      # Adds a reference. Optionally adds a +type+ column, if <tt>:polymorphic</tt> option is provided.
+      # <tt>references</tt> and <tt>belongs_to</tt> are acceptable. The reference column will be an +integer+
+      # by default, the <tt>:type</tt> option can be used to specify a different type.
+      #
+      #  t.references(:user)
+      #  t.references(:user, type: "string")
+      #  t.belongs_to(:supplier, polymorphic: true)
+      #
+      # See SchemaStatements#add_reference
+      def references(*args)
+        options = args.extract_options!
+        polymorphic = options.delete(:polymorphic)
+        index_options = options.delete(:index)
+        type = options.delete(:type) || :integer
+        args.each do |col|
+          column("#{col}_id", type, options)
+          column("#{col}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) if polymorphic
+          index(polymorphic ? %w(type id).map { |t| "#{col}_#{t}" } : "#{col}_id", index_options.is_a?(Hash) ? index_options : {}) if index_options
+        end
+      end
+      alias :belongs_to :references
+
+      def new_column_definition(name, type, options) # :nodoc:
+        type = aliased_types(type.to_s, type)
+        column = create_column_definition name, type
+        limit = options.fetch(:limit) do
+          native[type][:limit] if native[type].is_a?(Hash)
+        end
+
+        column.limit       = 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.primary_key = type == :primary_key || options[:primary_key]
+        column
+      end
+
+      private
+      def create_column_definition(name, type)
+        ColumnDefinition.new name, type
+      end
+
+      def native
+        @native
+      end
+
+      def aliased_types(name, fallback)
+        'timestamp' == name ? :datetime : fallback
+      end
+    end
+
+    class AlterTable # :nodoc:
+      attr_reader :adds
+      attr_reader :foreign_key_adds
+      attr_reader :foreign_key_drops
+
+      def initialize(td)
+        @td   = td
+        @adds = []
+        @foreign_key_adds = []
+        @foreign_key_drops = []
+      end
+
+      def name; @td.name; end
+
+      def add_foreign_key(to_table, options)
+        @foreign_key_adds << ForeignKeyDefinition.new(name, to_table, options)
+      end
+
+      def drop_foreign_key(name)
+        @foreign_key_drops << name
+      end
+
+      def add_column(name, type, options)
+        name = name.to_s
+        type = type.to_sym
+        @adds << @td.new_column_definition(name, type, options)
+      end
+    end
+
+    # Represents an SQL table in an abstract way for updating a table.
+    # Also see TableDefinition and SchemaStatements#create_table
+    #
+    # Available transformations are:
+    #
+    #   change_table :table do |t|
+    #     t.column
+    #     t.index
+    #     t.rename_index
+    #     t.timestamps
+    #     t.change
+    #     t.change_default
+    #     t.rename
+    #     t.references
+    #     t.belongs_to
+    #     t.string
+    #     t.text
+    #     t.integer
+    #     t.float
+    #     t.decimal
+    #     t.datetime
+    #     t.timestamp
+    #     t.time
+    #     t.date
+    #     t.binary
+    #     t.boolean
+    #     t.remove
+    #     t.remove_references
+    #     t.remove_belongs_to
+    #     t.remove_index
+    #     t.remove_timestamps
+    #   end
+    #
+    class Table
+      attr_reader :name
+
+      def initialize(table_name, base)
+        @name = table_name
+        @base = base
+      end
+
+      # Adds a new column to the named table.
+      # See TableDefinition#column for details of the options you can use.
+      #
+      # ====== Creating a simple column
+      #  t.column(:name, :string)
+      def column(column_name, type, options = {})
+        @base.add_column(name, column_name, type, options)
+      end
+
+      # Checks to see if a column exists. See SchemaStatements#column_exists?
+      def column_exists?(column_name, type = nil, options = {})
+        @base.column_exists?(name, column_name, type, options)
+      end
+
+      # Adds a new index to the table. +column_name+ can be a single Symbol, or
+      # an Array of Symbols. See SchemaStatements#add_index
+      #
+      # ====== Creating a simple index
+      #  t.index(:name)
+      # ====== Creating a unique index
+      #  t.index([:branch_id, :party_id], unique: true)
+      # ====== Creating a named index
+      #  t.index([:branch_id, :party_id], unique: true, name: 'by_branch_party')
+      def index(column_name, options = {})
+        @base.add_index(name, column_name, options)
+      end
+
+      # Checks to see if an index exists. See SchemaStatements#index_exists?
+      def index_exists?(column_name, options = {})
+        @base.index_exists?(name, column_name, options)
+      end
+
+      # Renames the given index on the table.
+      #
+      #  t.rename_index(:user_id, :account_id)
+      def rename_index(index_name, new_index_name)
+        @base.rename_index(name, index_name, new_index_name)
+      end
+
+      # Adds timestamps (+created_at+ and +updated_at+) columns to the table. See SchemaStatements#add_timestamps
+      #
+      #  t.timestamps null: false
+      def timestamps(options = {})
+        @base.add_timestamps(name, options)
+      end
+
+      # Changes the column's definition according to the new options.
+      # See TableDefinition#column for details of the options you can use.
+      #
+      #  t.change(:name, :string, limit: 80)
+      #  t.change(:description, :text)
+      def change(column_name, type, options = {})
+        @base.change_column(name, column_name, type, options)
+      end
+
+      # Sets a new default value for a column. See SchemaStatements#change_column_default
+      #
+      #  t.change_default(:qualification, 'new')
+      #  t.change_default(:authorized, 1)
+      def change_default(column_name, default)
+        @base.change_column_default(name, column_name, default)
+      end
+
+      # Removes the column(s) from the table definition.
+      #
+      #  t.remove(:qualification)
+      #  t.remove(:qualification, :experience)
+      def remove(*column_names)
+        @base.remove_columns(name, *column_names)
+      end
+
+      # Removes the given index from the table.
+      #
+      # ====== Remove the index_table_name_on_column in the table_name table
+      #   t.remove_index :column
+      # ====== Remove the index named index_table_name_on_branch_id in the table_name table
+      #   t.remove_index column: :branch_id
+      # ====== Remove the index named index_table_name_on_branch_id_and_party_id in the table_name table
+      #   t.remove_index column: [:branch_id, :party_id]
+      # ====== Remove the index named by_branch_party in the table_name table
+      #   t.remove_index name: :by_branch_party
+      def remove_index(options = {})
+        @base.remove_index(name, options)
+      end
+
+      # Removes the timestamp columns (+created_at+ and +updated_at+) from the table.
+      #
+      #  t.remove_timestamps
+      def remove_timestamps(options = {})
+        @base.remove_timestamps(name, options)
+      end
+
+      # Renames a column.
+      #
+      #  t.rename(:description, :name)
+      def rename(column_name, new_column_name)
+        @base.rename_column(name, column_name, new_column_name)
+      end
+
+      # Adds a reference. Optionally adds a +type+ column, if <tt>:polymorphic</tt> option is provided.
+      # <tt>references</tt> and <tt>belongs_to</tt> are acceptable. The reference column will be an +integer+
+      # by default, the <tt>:type</tt> option can be used to specify a different type.
+      #
+      #  t.references(:user)
+      #  t.references(:user, type: "string")
+      #  t.belongs_to(:supplier, polymorphic: true)
+      #
+      # See SchemaStatements#add_reference
+      def references(*args)
+        options = args.extract_options!
+        args.each do |ref_name|
+          @base.add_reference(name, ref_name, options)
+        end
+      end
+      alias :belongs_to :references
+
+      # Removes a reference. Optionally removes a +type+ column.
+      # <tt>remove_references</tt> and <tt>remove_belongs_to</tt> are acceptable.
+      #
+      #  t.remove_references(:user)
+      #  t.remove_belongs_to(:supplier, polymorphic: true)
+      #
+      # See SchemaStatements#remove_reference
+      def remove_references(*args)
+        options = args.extract_options!
+        args.each do |ref_name|
+          @base.remove_reference(name, ref_name, options)
+        end
+      end
+      alias :remove_belongs_to :remove_references
+
+      # Adds a column or columns of a specified type
+      #
+      #  t.string(:goat)
+      #  t.string(:goat, :sheep)
+      [:string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean].each do |column_type|
+        define_method column_type do |*args|
+          options = args.extract_options!
+          args.each do |column_name|
+            @base.add_column(name, column_name, column_type, options)
+          end
+        end
+      end
+
+      private
+        def native
+          @base.native_database_types
+        end
+    end
+  end
+end