activerecord 5.0.7.2 → 6.1.1

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module Savepoints
@@ -6,15 +8,15 @@ module ActiveRecord
       end
 
       def create_savepoint(name = current_savepoint_name)
-        execute("SAVEPOINT #{name}")
+        execute("SAVEPOINT #{name}", "TRANSACTION")
       end
 
       def exec_rollback_to_savepoint(name = current_savepoint_name)
-        execute("ROLLBACK TO SAVEPOINT #{name}")
+        execute("ROLLBACK TO SAVEPOINT #{name}", "TRANSACTION")
       end
 
       def release_savepoint(name = current_savepoint_name)
-        execute("RELEASE SAVEPOINT #{name}")
+        execute("RELEASE SAVEPOINT #{name}", "TRANSACTION")
       end
     end
   end

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

@@ -1,147 +1,189 @@
-require 'active_support/core_ext/string/strip'
+# frozen_string_literal: true
 
 module ActiveRecord
   module ConnectionAdapters
-    class AbstractAdapter
-      class SchemaCreation # :nodoc:
-        def initialize(conn)
-          @conn = conn
-          @cache = {}
+    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
+
+      delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
+        :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys?, :foreign_key_options,
+        :quoted_columns_for_index, :supports_partial_index?, :supports_check_constraints?, :check_constraint_options,
+        to: :@conn, private: true
+
+      private
+        def visit_AlterTable(o)
+          sql = +"ALTER TABLE #{quote_table_name(o.name)} "
+          sql << o.adds.map { |col| accept col }.join(" ")
+          sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(" ")
+          sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
+          sql << o.check_constraint_adds.map { |con| visit_AddCheckConstraint con }.join(" ")
+          sql << o.check_constraint_drops.map { |con| visit_DropCheckConstraint con }.join(" ")
+        end
+
+        def visit_ColumnDefinition(o)
+          o.sql_type = type_to_sql(o.type, **o.options)
+          column_sql = +"#{quote_column_name(o.name)} #{o.sql_type}"
+          add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
+          column_sql
         end
 
-        def accept(o)
-          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
-          send m, o
+        def visit_AddColumnDefinition(o)
+          +"ADD #{accept(o.column)}"
         end
 
-        delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
-          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys?, :foreign_key_options, to: :@conn
-        private :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
-          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys?, :foreign_key_options
+        def visit_TableDefinition(o)
+          create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
+          create_sql << "IF NOT EXISTS " if o.if_not_exists
+          create_sql << "#{quote_table_name(o.name)} "
 
-        private
+          statements = o.columns.map { |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
 
-          def visit_AlterTable(o)
-            sql = "ALTER TABLE #{quote_table_name(o.name)} "
-            sql << o.adds.map { |col| accept col }.join(' ')
-            sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(' ')
-            sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(' ')
+          if supports_indexes_in_create?
+            statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
           end
 
-          def visit_ColumnDefinition(o)
-            o.sql_type ||= type_to_sql(o.type, o.limit, o.precision, o.scale)
-            column_sql = "#{quote_column_name(o.name)} #{o.sql_type}"
-            add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
-            column_sql
+          if supports_foreign_keys?
+            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
           end
 
-          def visit_AddColumnDefinition(o)
-            "ADD #{accept(o.column)}"
+          if supports_check_constraints?
+            statements.concat(o.check_constraints.map { |expression, options| check_constraint_in_create(o.name, expression, options) })
           end
 
-          def visit_TableDefinition(o)
-            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+          create_sql << "(#{statements.join(', ')})" if statements.present?
+          add_table_options!(create_sql, o)
+          create_sql << " AS #{to_sql(o.as)}" if o.as
+          create_sql
+        end
 
-            statements = o.columns.map { |c| accept c }
-            statements << accept(o.primary_keys) if o.primary_keys
+        def visit_PrimaryKeyDefinition(o)
+          "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
+        end
 
-            if supports_indexes_in_create?
-              statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
-            end
+        def visit_ForeignKeyDefinition(o)
+          sql = +<<~SQL
+            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
 
-            if supports_foreign_keys?
-              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
-            end
+        def visit_AddForeignKey(o)
+          "ADD #{accept(o)}"
+        end
 
-            create_sql << "(#{statements.join(', ')})" if statements.present?
-            add_table_options!(create_sql, table_options(o))
-            create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
-            create_sql
-          end
+        def visit_DropForeignKey(name)
+          "DROP CONSTRAINT #{quote_column_name(name)}"
+        end
 
-          def visit_PrimaryKeyDefinition(o)
-            "PRIMARY KEY (#{o.name.join(', ')})"
-          end
+        def visit_CreateIndexDefinition(o)
+          index = o.index
+
+          sql = ["CREATE"]
+          sql << "UNIQUE" if index.unique
+          sql << "INDEX"
+          sql << "IF NOT EXISTS" if o.if_not_exists
+          sql << o.algorithm if o.algorithm
+          sql << index.type if index.type
+          sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
+          sql << "USING #{index.using}" if supports_index_using? && index.using
+          sql << "(#{quoted_columns(index)})"
+          sql << "WHERE #{index.where}" if supports_partial_index? && index.where
+
+          sql.join(" ")
+        end
 
-          def visit_ForeignKeyDefinition(o)
-            sql = <<-SQL.strip_heredoc
-              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_CheckConstraintDefinition(o)
+          "CONSTRAINT #{o.name} CHECK (#{o.expression})"
+        end
 
-          def visit_AddForeignKey(o)
-            "ADD #{accept(o)}"
-          end
+        def visit_AddCheckConstraint(o)
+          "ADD #{accept(o)}"
+        end
 
-          def visit_DropForeignKey(name)
-            "DROP CONSTRAINT #{quote_column_name(name)}"
-          end
+        def visit_DropCheckConstraint(name)
+          "DROP CONSTRAINT #{quote_column_name(name)}"
+        end
 
-          def table_options(o)
-            table_options = {}
-            table_options[:comment] = o.comment
-            table_options[:options] = o.options
-            table_options
-          end
+        def quoted_columns(o)
+          String === o.columns ? o.columns : quoted_columns_for_index(o.columns, o.column_options)
+        end
 
-          def add_table_options!(create_sql, options)
-            if options_sql = options[:options]
-              create_sql << " #{options_sql}"
-            end
-          end
+        def supports_index_using?
+          true
+        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[:auto_increment] = o.auto_increment
-            column_options[:primary_key] = o.primary_key
-            column_options[:collation] = o.collation
-            column_options[:comment] = o.comment
-            column_options
-          end
+        def add_table_options!(create_sql, o)
+          create_sql << " #{o.options}" if o.options
+          create_sql
+        end
 
-          def add_column_options!(sql, options)
-            sql << " DEFAULT #{quote_default_expression(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
-            if options[:primary_key] == true
-              sql << " PRIMARY KEY"
-            end
-            sql
-          end
+        def column_options(o)
+          o.options.merge(column: o)
+        end
 
-          def foreign_key_in_create(from_table, to_table, options)
-            options = foreign_key_options(from_table, to_table, options)
-            accept ForeignKeyDefinition.new(from_table, to_table, options)
+        def add_column_options!(sql, options)
+          sql << " DEFAULT #{quote_default_expression(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
+          if options[:primary_key] == true
+            sql << " PRIMARY KEY"
+          end
+          sql
+        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
+        def to_sql(sql)
+          sql = sql.to_sql if sql.respond_to?(:to_sql)
+          sql
+        end
+
+        # Returns any SQL string to go between CREATE and TABLE. May be nil.
+        def table_modifier_in_create(o)
+          " TEMPORARY" if o.temporary
+        end
+
+        def foreign_key_in_create(from_table, to_table, options)
+          prefix = ActiveRecord::Base.table_name_prefix
+          suffix = ActiveRecord::Base.table_name_suffix
+          to_table = "#{prefix}#{to_table}#{suffix}"
+          options = foreign_key_options(from_table, to_table, options)
+          accept ForeignKeyDefinition.new(from_table, to_table, options)
+        end
+
+        def check_constraint_in_create(table_name, expression, options)
+          options = check_constraint_options(table_name, expression, options)
+          accept CheckConstraintDefinition.new(table_name, expression, options)
+        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
+              '#{dependency}' is not supported for :on_update or :on_delete.
+              Supported values are: :nullify, :cascade, :restrict
+            MSG
           end
-      end
+        end
     end
   end
 end

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

@@ -1,32 +1,87 @@
+# frozen_string_literal: true
+
 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, :comment) #:nodoc:
+    # adapters. e.g. ActiveRecord::ConnectionAdapters::MySQL::SchemaStatements#indexes
+    class IndexDefinition # :nodoc:
+      attr_reader :table, :name, :unique, :columns, :lengths, :orders, :opclasses, :where, :type, :using, :comment
+
+      def initialize(
+        table, name,
+        unique = false,
+        columns = [],
+        lengths: {},
+        orders: {},
+        opclasses: {},
+        where: nil,
+        type: nil,
+        using: nil,
+        comment: nil
+      )
+        @table = table
+        @name = name
+        @unique = unique
+        @columns = columns
+        @lengths = concise_options(lengths)
+        @orders = concise_options(orders)
+        @opclasses = concise_options(opclasses)
+        @where = where
+        @type = type
+        @using = using
+        @comment = comment
+      end
+
+      def column_options
+        {
+          length: lengths,
+          order: orders,
+          opclass: opclasses,
+        }
+      end
+
+      private
+        def concise_options(options)
+          if columns.size == options.size && options.values.uniq.size == 1
+            options.values.first
+          else
+            options
+          end
+        end
     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, :auto_increment, :primary_key, :collation, :sql_type, :comment) #:nodoc:
-
+    ColumnDefinition = Struct.new(:name, :type, :options, :sql_type) do # :nodoc:
       def primary_key?
-        primary_key || type.to_sym == :primary_key
+        options[:primary_key]
       end
-    end
 
-    class AddColumnDefinition < Struct.new(:column) # :nodoc:
-    end
+      [:limit, :precision, :scale, :default, :null, :collation, :comment].each do |option_name|
+        module_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{option_name}
+            options[:#{option_name}]
+          end
 
-    class ChangeColumnDefinition < Struct.new(:column, :name) #:nodoc:
+          def #{option_name}=(value)
+            options[:#{option_name}] = value
+          end
+        CODE
+      end
     end
 
-    class PrimaryKeyDefinition < Struct.new(:name) # :nodoc:
-    end
+    AddColumnDefinition = Struct.new(:column) # :nodoc:
+
+    ChangeColumnDefinition = Struct.new(:column, :name) #:nodoc:
+
+    CreateIndexDefinition = Struct.new(:index, :algorithm, :if_not_exists) # :nodoc:
+
+    PrimaryKeyDefinition = Struct.new(:name) # :nodoc:
 
-    class ForeignKeyDefinition < Struct.new(:from_table, :to_table, :options) #:nodoc:
+    ForeignKeyDefinition = Struct.new(:from_table, :to_table, :options) do #:nodoc:
       def name
         options[:name]
       end
@@ -51,18 +106,39 @@ module ActiveRecord
         options[:primary_key] != default_primary_key
       end
 
-      def defined_for?(to_table_ord = nil, to_table: nil, **options)
-        if to_table_ord
-          self.to_table == to_table_ord.to_s
-        else
-          (to_table.nil? || to_table.to_s == self.to_table) &&
-            options.all? { |k, v| self.options[k].to_s == v.to_s }
-        end
+      def validate?
+        options.fetch(:validate, true)
+      end
+      alias validated? validate?
+
+      def export_name_on_schema_dump?
+        !ActiveRecord::SchemaDumper.fk_ignore_pattern.match?(name) if name
+      end
+
+      def defined_for?(to_table: nil, validate: nil, **options)
+        (to_table.nil? || to_table.to_s == self.to_table) &&
+          (validate.nil? || validate == options.fetch(:validate, validate)) &&
+          options.all? { |k, v| self.options[k].to_s == v.to_s }
       end
 
       private
-      def default_primary_key
-        "id"
+        def default_primary_key
+          "id"
+        end
+    end
+
+    CheckConstraintDefinition = Struct.new(:table_name, :expression, :options) do
+      def name
+        options[:name]
+      end
+
+      def validate?
+        options.fetch(:validate, true)
+      end
+      alias validated? validate?
+
+      def export_name_on_schema_dump?
+        !ActiveRecord::SchemaDumper.chk_ignore_pattern.match?(name) if name
       end
     end
 
@@ -72,7 +148,7 @@ module ActiveRecord
         polymorphic: false,
         index: true,
         foreign_key: false,
-        type: :integer,
+        type: :bigint,
         **options
       )
         @name = name
@@ -88,98 +164,107 @@ module ActiveRecord
       end
 
       def add_to(table)
-        columns.each do |column_options|
-          table.column(*column_options)
+        columns.each do |name, type, options|
+          table.column(name, type, **options)
         end
 
         if index
-          table.index(column_names, index_options)
+          table.index(column_names, **index_options(table.name))
         end
 
         if foreign_key
-          table.foreign_key(foreign_table_name, foreign_key_options)
+          table.foreign_key(foreign_table_name, **foreign_key_options)
         end
       end
 
-      protected
-
-      attr_reader :name, :polymorphic, :index, :foreign_key, :type, :options
-
       private
+        attr_reader :name, :polymorphic, :index, :foreign_key, :type, :options
 
-      def as_options(value)
-        value.is_a?(Hash) ? value : {}
-      end
+        def as_options(value)
+          value.is_a?(Hash) ? value : {}
+        end
 
-      def polymorphic_options
-        as_options(polymorphic).merge(null: options[:null])
-      end
+        def polymorphic_options
+          as_options(polymorphic).merge(options.slice(:null, :first, :after))
+        end
 
-      def index_options
-        as_options(index)
-      end
+        def polymorphic_index_name(table_name)
+          "index_#{table_name}_on_#{name}"
+        end
 
-      def foreign_key_options
-        as_options(foreign_key).merge(column: column_name)
-      end
+        def index_options(table_name)
+          index_options = as_options(index)
+          index_options[:name] ||= polymorphic_index_name(table_name) if polymorphic
+          index_options
+        end
 
-      def columns
-        result = [[column_name, type, options]]
-        if polymorphic
-          result.unshift(["#{name}_type", :string, polymorphic_options])
+        def foreign_key_options
+          as_options(foreign_key).merge(column: column_name)
         end
-        result
-      end
 
-      def column_name
-        "#{name}_id"
-      end
+        def columns
+          result = [[column_name, type, options]]
+          if polymorphic
+            result.unshift(["#{name}_type", :string, polymorphic_options])
+          end
+          result
+        end
 
-      def column_names
-        columns.map(&:first)
-      end
+        def column_name
+          "#{name}_id"
+        end
 
-      def foreign_table_name
-        foreign_key_options.fetch(:to_table) do
-          Base.pluralize_table_names ? name.to_s.pluralize : name
+        def column_names
+          columns.map(&:first)
+        end
+
+        def foreign_table_name
+          foreign_key_options.fetch(:to_table) do
+            Base.pluralize_table_names ? name.to_s.pluralize : name
+          end
         end
-      end
     end
 
     module ColumnMethods
+      extend ActiveSupport::Concern
+
       # 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))
+        column(name, type, **options.merge(primary_key: true))
       end
 
+      ##
+      # :method: column
+      # :call-seq: column(name, type, **options)
+      #
       # Appends a column or columns of a specified type.
       #
       #  t.string(:goat)
       #  t.string(:goat, :sheep)
       #
       # See TableDefinition#column
-      [
-        :bigint,
-        :binary,
-        :boolean,
-        :date,
-        :datetime,
-        :decimal,
-        :float,
-        :integer,
-        :string,
-        :text,
-        :time,
-        :timestamp,
-      ].each do |column_type|
-        module_eval <<-CODE, __FILE__, __LINE__ + 1
-          def #{column_type}(*args, **options)
-            args.each { |name| column(name, :#{column_type}, options) }
+
+      included do
+        define_column_methods :bigint, :binary, :boolean, :date, :datetime, :decimal,
+          :float, :integer, :json, :string, :text, :time, :timestamp, :virtual
+
+        alias :numeric :decimal
+      end
+
+      class_methods do
+        def define_column_methods(*column_types) # :nodoc:
+          column_types.each do |column_type|
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{column_type}(*names, **options)
+                raise ArgumentError, "Missing column name(s) for #{column_type}" if names.empty?
+                names.each { |name| column(name, :#{column_type}, **options) }
+              end
+            RUBY
           end
-        CODE
+        end
+        private :define_column_methods
       end
-      alias_method :numeric, :decimal
     end
 
     # Represents the schema of an SQL table in an abstract way. This class
@@ -188,7 +273,7 @@ module ActiveRecord
     # Inside migration files, the +t+ object in {create_table}[rdoc-ref:SchemaStatements#create_table]
     # is actually of this type:
     #
-    #   class SomeMigration < ActiveRecord::Migration[5.0]
+    #   class SomeMigration < ActiveRecord::Migration[6.0]
     #     def up
     #       create_table :foo do |t|
     #         puts t.class  # => "ActiveRecord::ConnectionAdapters::TableDefinition"
@@ -203,15 +288,26 @@ module ActiveRecord
     class TableDefinition
       include ColumnMethods
 
-      attr_accessor :indexes
-      attr_reader :name, :temporary, :options, :as, :foreign_keys, :comment
+      attr_reader :name, :temporary, :if_not_exists, :options, :as, :comment, :indexes, :foreign_keys, :check_constraints
 
-      def initialize(name, temporary = false, options = nil, as = nil, comment: nil)
+      def initialize(
+        conn,
+        name,
+        temporary: false,
+        if_not_exists: false,
+        options: nil,
+        as: nil,
+        comment: nil,
+        **
+      )
+        @conn = conn
         @columns_hash = {}
         @indexes = []
         @foreign_keys = []
         @primary_keys = nil
+        @check_constraints = []
         @temporary = temporary
+        @if_not_exists = if_not_exists
         @options = options
         @as = as
         @name = name
@@ -295,21 +391,28 @@ module ActiveRecord
       #
       #   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' }
+      #     t.references :tagger, polymorphic: true
+      #     t.references :taggable, polymorphic: { default: 'Photo' }, index: false
       #   end
-      def column(name, type, options = {})
+      def column(name, type, index: nil, **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."
+        if @columns_hash[name]
+          if @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."
+          else
+            raise ArgumentError, "you can't define an already defined column '#{name}'."
+          end
+        end
+
+        @columns_hash[name] = new_column_definition(name, type, **options)
+
+        if index
+          index_options = index.is_a?(Hash) ? index : {}
+          index(name, **index_options)
         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
 
@@ -323,81 +426,87 @@ module ActiveRecord
       # 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 = {})
+      def index(column_name, **options)
         indexes << [column_name, options]
       end
 
-      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])
+      def foreign_key(table_name, **options) # :nodoc:
+        foreign_keys << [table_name, options]
+      end
+
+      def check_constraint(expression, **options)
+        check_constraints << [expression, options]
       end
 
       # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and
       # <tt>:updated_at</tt> to the table. See {connection.add_timestamps}[rdoc-ref:SchemaStatements#add_timestamps]
       #
       #   t.timestamps null: false
-      def timestamps(*args)
-        options = args.extract_options!
-
+      def timestamps(**options)
         options[:null] = false if options[:null].nil?
 
-        column(:created_at, :datetime, options)
-        column(:updated_at, :datetime, options)
+        if !options.key?(:precision) && @conn.supports_datetime_with_precision?
+          options[:precision] = 6
+        end
+
+        column(:created_at, :datetime, **options)
+        column(:updated_at, :datetime, **options)
       end
 
       # Adds a reference.
       #
       #  t.references(:user)
       #  t.belongs_to(:supplier, foreign_key: true)
+      #  t.belongs_to(:supplier, foreign_key: true, type: :integer)
       #
       # See {connection.add_reference}[rdoc-ref:SchemaStatements#add_reference] for details of the options you can use.
       def references(*args, **options)
-        args.each do |col|
-          ReferenceDefinition.new(col, **options).add_to(self)
+        args.each do |ref_name|
+          ReferenceDefinition.new(ref_name, **options).add_to(self)
         end
       end
       alias :belongs_to :references
 
-      def new_column_definition(name, type, options) # :nodoc:
+      def new_column_definition(name, type, **options) # :nodoc:
+        if integer_like_primary_key?(type, options)
+          type = integer_like_primary_key_type(type, options)
+        end
         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
+        options[:primary_key] ||= type == :primary_key
+        options[:null] = false if options[:primary_key]
+        create_column_definition(name, type, options)
       end
 
       private
-      def create_column_definition(name, type)
-        ColumnDefinition.new name, type
-      end
+        def create_column_definition(name, type, options)
+          ColumnDefinition.new(name, type, options)
+        end
 
-      def aliased_types(name, fallback)
-        'timestamp' == name ? :datetime : fallback
-      end
+        def aliased_types(name, fallback)
+          "timestamp" == name ? :datetime : fallback
+        end
+
+        def integer_like_primary_key?(type, options)
+          options[:primary_key] && [:integer, :bigint].include?(type) && !options.key?(:default)
+        end
+
+        def integer_like_primary_key_type(type, options)
+          type
+        end
     end
 
     class AlterTable # :nodoc:
       attr_reader :adds
-      attr_reader :foreign_key_adds
-      attr_reader :foreign_key_drops
+      attr_reader :foreign_key_adds, :foreign_key_drops
+      attr_reader :check_constraint_adds, :check_constraint_drops
 
       def initialize(td)
         @td   = td
         @adds = []
         @foreign_key_adds = []
         @foreign_key_drops = []
+        @check_constraint_adds = []
+        @check_constraint_drops = []
       end
 
       def name; @td.name; end
@@ -410,10 +519,18 @@ module ActiveRecord
         @foreign_key_drops << name
       end
 
-      def add_column(name, type, options)
+      def add_check_constraint(expression, options)
+        @check_constraint_adds << CheckConstraintDefinition.new(name, expression, options)
+      end
+
+      def drop_check_constraint(constraint_name)
+        @check_constraint_drops << constraint_name
+      end
+
+      def add_column(name, type, **options)
         name = name.to_s
         type = type.to_sym
-        @adds << AddColumnDefinition.new(@td.new_column_definition(name, type, options))
+        @adds << AddColumnDefinition.new(@td.new_column_definition(name, type, **options))
       end
     end
 
@@ -430,9 +547,11 @@ module ActiveRecord
     #     t.timestamps
     #     t.change
     #     t.change_default
+    #     t.change_null
     #     t.rename
     #     t.references
     #     t.belongs_to
+    #     t.check_constraint
     #     t.string
     #     t.text
     #     t.integer
@@ -446,10 +565,15 @@ module ActiveRecord
     #     t.date
     #     t.binary
     #     t.boolean
+    #     t.foreign_key
+    #     t.json
+    #     t.virtual
     #     t.remove
+    #     t.remove_foreign_key
     #     t.remove_references
     #     t.remove_belongs_to
     #     t.remove_index
+    #     t.remove_check_constraint
     #     t.remove_timestamps
     #   end
     #
@@ -468,17 +592,21 @@ module ActiveRecord
       #  t.column(:name, :string)
       #
       # See TableDefinition#column for details of the options you can use.
-      def column(column_name, type, options = {})
-        @base.add_column(name, column_name, type, options)
+      def column(column_name, type, index: nil, **options)
+        @base.add_column(name, column_name, type, **options)
+        if index
+          index_options = index.is_a?(Hash) ? index : {}
+          index(column_name, **index_options)
+        end
       end
 
       # Checks to see if a column exists.
       #
-      # t.string(:name) unless t.column_exists?(:name, :string)
+      #  t.string(:name) unless t.column_exists?(:name, :string)
       #
       # See {connection.column_exists?}[rdoc-ref:SchemaStatements#column_exists?]
-      def column_exists?(column_name, type = nil, options = {})
-        @base.column_exists?(name, column_name, type, options)
+      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
@@ -489,15 +617,15 @@ module ActiveRecord
       #  t.index([:branch_id, :party_id], unique: true, name: 'by_branch_party')
       #
       # See {connection.add_index}[rdoc-ref:SchemaStatements#add_index] for details of the options you can use.
-      def index(column_name, options = {})
-        @base.add_index(name, column_name, options)
+      def index(column_name, **options)
+        @base.add_index(name, column_name, **options)
       end
 
       # Checks to see if an index exists.
       #
-      # unless t.index_exists?(:branch_id)
-      #   t.index(:branch_id)
-      # end
+      #  unless t.index_exists?(:branch_id)
+      #    t.index(:branch_id)
+      #  end
       #
       # See {connection.index_exists?}[rdoc-ref:SchemaStatements#index_exists?]
       def index_exists?(column_name, options = {})
@@ -518,8 +646,8 @@ module ActiveRecord
       #  t.timestamps(null: false)
       #
       # See {connection.add_timestamps}[rdoc-ref:SchemaStatements#add_timestamps]
-      def timestamps(options = {})
-        @base.add_timestamps(name, options)
+      def timestamps(**options)
+        @base.add_timestamps(name, **options)
       end
 
       # Changes the column's definition according to the new options.
@@ -528,8 +656,8 @@ module ActiveRecord
       #  t.change(:description, :text)
       #
       # See TableDefinition#column for details of the options you can use.
-      def change(column_name, type, options = {})
-        @base.change_column(name, column_name, type, options)
+      def change(column_name, type, **options)
+        @base.change_column(name, column_name, type, **options)
       end
 
       # Sets a new default value for a column.
@@ -543,14 +671,24 @@ module ActiveRecord
         @base.change_column_default(name, column_name, default_or_changes)
       end
 
+      # Sets or removes a NOT NULL constraint on a column.
+      #
+      #  t.change_null(:qualification, true)
+      #  t.change_null(:qualification, false, 0)
+      #
+      # See {connection.change_column_null}[rdoc-ref:SchemaStatements#change_column_null]
+      def change_null(column_name, null, default = nil)
+        @base.change_column_null(name, column_name, null, default)
+      end
+
       # Removes the column(s) from the table definition.
       #
       #  t.remove(:qualification)
       #  t.remove(:qualification, :experience)
       #
       # See {connection.remove_columns}[rdoc-ref:SchemaStatements#remove_columns]
-      def remove(*column_names)
-        @base.remove_columns(name, *column_names)
+      def remove(*column_names, **options)
+        @base.remove_columns(name, *column_names, **options)
       end
 
       # Removes the given index from the table.
@@ -558,10 +696,11 @@ module ActiveRecord
       #   t.remove_index(:branch_id)
       #   t.remove_index(column: [:branch_id, :party_id])
       #   t.remove_index(name: :by_branch_party)
+      #   t.remove_index(:branch_id, name: :by_branch_party)
       #
       # See {connection.remove_index}[rdoc-ref:SchemaStatements#remove_index]
-      def remove_index(options = {})
-        @base.remove_index(name, options)
+      def remove_index(column_name = nil, **options)
+        @base.remove_index(name, column_name, **options)
       end
 
       # Removes the timestamp columns (+created_at+ and +updated_at+) from the table.
@@ -569,8 +708,8 @@ module ActiveRecord
       #  t.remove_timestamps
       #
       # See {connection.remove_timestamps}[rdoc-ref:SchemaStatements#remove_timestamps]
-      def remove_timestamps(options = {})
-        @base.remove_timestamps(name, options)
+      def remove_timestamps(**options)
+        @base.remove_timestamps(name, **options)
       end
 
       # Renames a column.
@@ -588,10 +727,9 @@ module ActiveRecord
       #  t.belongs_to(:supplier, foreign_key: true)
       #
       # See {connection.add_reference}[rdoc-ref:SchemaStatements#add_reference] for details of the options you can use.
-      def references(*args)
-        options = args.extract_options!
+      def references(*args, **options)
         args.each do |ref_name|
-          @base.add_reference(name, ref_name, options)
+          @base.add_reference(name, ref_name, **options)
         end
       end
       alias :belongs_to :references
@@ -602,30 +740,58 @@ module ActiveRecord
       #  t.remove_belongs_to(:supplier, polymorphic: true)
       #
       # See {connection.remove_reference}[rdoc-ref:SchemaStatements#remove_reference]
-      def remove_references(*args)
-        options = args.extract_options!
+      def remove_references(*args, **options)
         args.each do |ref_name|
-          @base.remove_reference(name, ref_name, options)
+          @base.remove_reference(name, ref_name, **options)
         end
       end
       alias :remove_belongs_to :remove_references
 
-      # Adds a foreign key.
+      # Adds a foreign key to the table using a supplied table name.
       #
-      # t.foreign_key(:authors)
+      #  t.foreign_key(:authors)
+      #  t.foreign_key(:authors, column: :author_id, primary_key: "id")
       #
       # See {connection.add_foreign_key}[rdoc-ref:SchemaStatements#add_foreign_key]
-      def foreign_key(*args) # :nodoc:
-        @base.add_foreign_key(name, *args)
+      def foreign_key(*args, **options)
+        @base.add_foreign_key(name, *args, **options)
+      end
+
+      # Removes the given foreign key from the table.
+      #
+      #  t.remove_foreign_key(:authors)
+      #  t.remove_foreign_key(column: :author_id)
+      #
+      # See {connection.remove_foreign_key}[rdoc-ref:SchemaStatements#remove_foreign_key]
+      def remove_foreign_key(*args, **options)
+        @base.remove_foreign_key(name, *args, **options)
       end
 
       # Checks to see if a foreign key exists.
       #
-      # t.foreign_key(:authors) unless t.foreign_key_exists?(:authors)
+      #  t.foreign_key(:authors) unless t.foreign_key_exists?(:authors)
       #
       # See {connection.foreign_key_exists?}[rdoc-ref:SchemaStatements#foreign_key_exists?]
-      def foreign_key_exists?(*args) # :nodoc:
-        @base.foreign_key_exists?(name, *args)
+      def foreign_key_exists?(*args, **options)
+        @base.foreign_key_exists?(name, *args, **options)
+      end
+
+      # Adds a check constraint.
+      #
+      #  t.check_constraint("price > 0", name: "price_check")
+      #
+      # See {connection.add_check_constraint}[rdoc-ref:SchemaStatements#add_check_constraint]
+      def check_constraint(*args)
+        @base.add_check_constraint(name, *args)
+      end
+
+      # Removes the given check constraint from the table.
+      #
+      #  t.remove_check_constraint(name: "price_check")
+      #
+      # See {connection.remove_check_constraint}[rdoc-ref:SchemaStatements#remove_check_constraint]
+      def remove_check_constraint(*args)
+        @base.remove_check_constraint(name, *args)
       end
     end
   end