activerecord 6.0.3.5 → 6.1.0.rc1

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/deprecation"
-
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseLimits
@@ -14,18 +12,6 @@ module ActiveRecord
         max_identifier_length
       end
 
-      # Returns the maximum length of a column name.
-      def column_name_length
-        max_identifier_length
-      end
-      deprecate :column_name_length
-
-      # Returns the maximum length of a table name.
-      def table_name_length
-        max_identifier_length
-      end
-      deprecate :table_name_length
-
       # Returns the maximum allowed length for an index name. This
       # limit is enforced by \Rails and is less than or equal to
       # #index_name_length. The gap between
@@ -34,47 +20,19 @@ module ActiveRecord
       def allowed_index_name_length
         index_name_length
       end
+      deprecate :allowed_index_name_length
 
       # Returns the maximum length of an index name.
       def index_name_length
         max_identifier_length
       end
 
-      # Returns the maximum number of columns per table.
-      def columns_per_table
-        1024
-      end
-      deprecate :columns_per_table
-
-      # Returns the maximum number of indexes per table.
-      def indexes_per_table
-        16
-      end
-      deprecate :indexes_per_table
-
-      # Returns the maximum number of columns in a multicolumn index.
-      def columns_per_multicolumn_index
-        16
-      end
-      deprecate :columns_per_multicolumn_index
-
       # Returns the maximum number of elements in an IN (x,y,z) clause.
       # +nil+ means no limit.
       def in_clause_length
         nil
       end
-
-      # Returns the maximum length of an SQL query.
-      def sql_query_length
-        1048575
-      end
-      deprecate :sql_query_length
-
-      # Returns maximum number of joins in a single query.
-      def joins_per_query
-        256
-      end
-      deprecate :joins_per_query
+      deprecate :in_clause_length
 
       private
         def bind_params_length

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

@@ -14,29 +14,32 @@ module ActiveRecord
         sql
       end
 
-      def to_sql_and_binds(arel_or_sql_string, binds = []) # :nodoc:
+      def to_sql_and_binds(arel_or_sql_string, binds = [], preparable = nil) # :nodoc:
         if arel_or_sql_string.respond_to?(:ast)
           unless binds.empty?
             raise "Passing bind parameters with an arel AST is forbidden. " \
               "The values must be stored on the AST directly"
           end
 
+          collector = collector()
+
           if prepared_statements
+            collector.preparable = true
             sql, binds = visitor.compile(arel_or_sql_string.ast, collector)
 
             if binds.length > bind_params_length
               unprepared_statement do
-                sql, binds = to_sql_and_binds(arel_or_sql_string)
-                visitor.preparable = false
+                return to_sql_and_binds(arel_or_sql_string)
               end
             end
+            preparable = collector.preparable
           else
             sql = visitor.compile(arel_or_sql_string.ast, collector)
           end
-          [sql.freeze, binds]
+          [sql.freeze, binds, preparable]
         else
-          visitor.preparable = false if prepared_statements
-          [arel_or_sql_string.dup.freeze, binds]
+          arel_or_sql_string = arel_or_sql_string.dup.freeze unless arel_or_sql_string.frozen?
+          [arel_or_sql_string, binds, preparable]
         end
       end
       private :to_sql_and_binds
@@ -58,17 +61,15 @@ module ActiveRecord
       # Returns an ActiveRecord::Result instance.
       def select_all(arel, name = nil, binds = [], preparable: nil)
         arel = arel_from_relation(arel)
-        sql, binds = to_sql_and_binds(arel, binds)
-
-        if preparable.nil?
-          preparable = prepared_statements ? visitor.preparable : false
-        end
+        sql, binds, preparable = to_sql_and_binds(arel, binds, preparable)
 
         if prepared_statements && preparable
           select_prepared(sql, name, binds)
         else
           select(sql, name, binds)
         end
+      rescue ::RangeError
+        ActiveRecord::Result.new([], [])
       end
 
       # Returns a record hash with the column names as keys and column values
@@ -153,6 +154,10 @@ module ActiveRecord
         exec_query(sql, name)
       end
 
+      def explain(arel, binds = []) # :nodoc:
+        raise NotImplementedError
+      end
+
       # Executes an INSERT query and returns the new record's ID
       #
       # +id_value+ will be returned unless the value is +nil+, in
@@ -186,6 +191,8 @@ module ActiveRecord
       end
 
       def truncate_tables(*table_names) # :nodoc:
+        table_names -= [schema_migration.table_name, InternalMetadata.table_name]
+
         return if table_names.empty?
 
         with_multi_statements do
@@ -201,15 +208,30 @@ module ActiveRecord
       #
       # == Nested transactions support
       #
+      # #transaction calls can be nested. By default, this makes all database
+      # statements in the nested transaction block become part of the parent
+      # transaction. For example, the following behavior may be surprising:
+      #
+      #   ActiveRecord::Base.transaction do
+      #     Post.create(title: 'first')
+      #     ActiveRecord::Base.transaction do
+      #       Post.create(title: 'second')
+      #       raise ActiveRecord::Rollback
+      #     end
+      #   end
+      #
+      # This creates both "first" and "second" posts. Reason is the
+      # ActiveRecord::Rollback exception in the nested block does not issue a
+      # ROLLBACK. Since these exceptions are captured in transaction blocks,
+      # the parent block does not see it and the real transaction is committed.
+      #
       # Most databases don't support true nested transactions. At the time of
       # writing, the only database that supports true nested transactions that
       # we're aware of, is MS-SQL.
       #
       # In order to get around this problem, #transaction will emulate the effect
       # of nested transactions, by using savepoints:
-      # https://dev.mysql.com/doc/refman/5.7/en/savepoint.html
-      # Savepoints are supported by MySQL and PostgreSQL. SQLite3 version >= '3.6.8'
-      # supports savepoints.
+      # https://dev.mysql.com/doc/refman/en/savepoint.html.
       #
       # It is safe to call this method if a database transaction is already open,
       # i.e. if #transaction is called within another #transaction block. In case
@@ -221,6 +243,24 @@ module ActiveRecord
       # - However, if +:requires_new+ is set, the block will be wrapped in a
       #   database savepoint acting as a sub-transaction.
       #
+      # In order to get a ROLLBACK for the nested transaction you may ask for a
+      # real sub-transaction by passing <tt>requires_new: true</tt>.
+      # If anything goes wrong, the database rolls back to the beginning of
+      # the sub-transaction without rolling back the parent transaction.
+      # If we add it to the previous example:
+      #
+      #   ActiveRecord::Base.transaction do
+      #     Post.create(title: 'first')
+      #     ActiveRecord::Base.transaction(requires_new: true) do
+      #       Post.create(title: 'second')
+      #       raise ActiveRecord::Rollback
+      #     end
+      #   end
+      #
+      # only post with title "first" is created.
+      #
+      # See ActiveRecord::Transactions to learn more.
+      #
       # === Caveats
       #
       # MySQL doesn't support DDL transactions. If you perform a DDL operation,
@@ -260,7 +300,7 @@ module ActiveRecord
       # semantics of these different levels:
       #
       # * https://www.postgresql.org/docs/current/static/transaction-iso.html
-      # * https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html
+      # * https://dev.mysql.com/doc/refman/en/set-transaction.html
       #
       # An ActiveRecord::TransactionIsolationError will be raised if:
       #
@@ -289,6 +329,13 @@ module ActiveRecord
                :commit_transaction, :rollback_transaction, :materialize_transactions,
                :disable_lazy_transactions!, :enable_lazy_transactions!, to: :transaction_manager
 
+      def mark_transaction_written_if_write(sql) # :nodoc:
+        transaction = current_transaction
+        if transaction.open?
+          transaction.written ||= write_query?(sql)
+        end
+      end
+
       def transaction_open?
         current_transaction.open?
       end
@@ -299,12 +346,8 @@ module ActiveRecord
 
       # Register a record with the current transaction so that its after_commit and after_rollback callbacks
       # can be called.
-      def add_transaction_record(record)
-        current_transaction.add_record(record)
-      end
-
-      def transaction_state
-        current_transaction.state
+      def add_transaction_record(record, ensure_finalize = true)
+        current_transaction.add_record(record, ensure_finalize)
       end
 
       # Begins the transaction (and turns off auto-committing).
@@ -351,7 +394,7 @@ module ActiveRecord
       end
 
       # Inserts the given fixture into the table. Overridden in adapters that require
-      # something beyond a simple insert (eg. Oracle).
+      # something beyond a simple insert (e.g. Oracle).
       # Most of adapters should implement `insert_fixtures_set` that leverages bulk SQL insert.
       # We keep this method to provide fallback
       # for databases like sqlite that do not support bulk inserts.

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

@@ -18,7 +18,7 @@ module ActiveRecord
           method_names.each do |method_name|
             base.class_eval <<-end_code, __FILE__, __LINE__ + 1
               def #{method_name}(*)
-                ActiveRecord::Base.clear_query_caches_for_current_thread if @query_cache_enabled
+                ActiveRecord::Base.clear_query_caches_for_current_thread
                 super
               end
             end_code
@@ -96,11 +96,7 @@ module ActiveRecord
       def select_all(arel, name = nil, binds = [], preparable: nil)
         if @query_cache_enabled && !locked?(arel)
           arel = arel_from_relation(arel)
-          sql, binds = to_sql_and_binds(arel, binds)
-
-          if preparable.nil?
-            preparable = prepared_statements ? visitor.preparable : false
-          end
+          sql, binds, preparable = to_sql_and_binds(arel, binds, preparable)
 
           cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable) }
         else
@@ -133,7 +129,6 @@ module ActiveRecord
             binds: binds,
             type_casted_binds: -> { type_casted_binds(binds) },
             name: name,
-            connection_id: object_id,
             connection: self,
             cached: true
           }

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

@@ -9,10 +9,12 @@ module ActiveRecord
       # Quotes the column value to help prevent
       # {SQL injection attacks}[https://en.wikipedia.org/wiki/SQL_injection].
       def quote(value)
-        value = id_value_for_database(value) if value.is_a?(Base)
-
-        if value.respond_to?(:value_for_database)
-          value = value.value_for_database
+        if value.is_a?(Base)
+          ActiveSupport::Deprecation.warn(<<~MSG)
+            Passing an Active Record object to `quote` directly is deprecated
+            and will be no longer quoted as id value in Rails 6.2.
+          MSG
+          value = value.id_for_database
         end
 
         _quote(value)
@@ -22,16 +24,23 @@ module ActiveRecord
       # SQLite does not understand dates, so this method will convert a Date
       # to a String.
       def type_cast(value, column = nil)
-        value = id_value_for_database(value) if value.is_a?(Base)
+        if value.is_a?(Base)
+          ActiveSupport::Deprecation.warn(<<~MSG)
+            Passing an Active Record object to `type_cast` directly is deprecated
+            and will be no longer type casted as id value in Rails 6.2.
+          MSG
+          value = value.id_for_database
+        end
 
         if column
-          value = type_cast_from_column(column, value)
+          ActiveSupport::Deprecation.warn(<<~MSG)
+            Passing a column to `type_cast` is deprecated and will be removed in Rails 6.2.
+          MSG
+          type = lookup_cast_type_from_column(column)
+          value = type.serialize(value)
         end
 
         _type_cast(value)
-      rescue TypeError
-        to_type = column ? " to #{column.type}" : ""
-        raise TypeError, "can't cast #{value.class}#{to_type}"
       end
 
       # If you are having to call this function, you are likely doing something
@@ -43,16 +52,6 @@ module ActiveRecord
       # represent the type doesn't sufficiently reflect the differences
       # (varchar vs binary) for example. The type used to get this primitive
       # should have been provided before reaching the connection adapter.
-      def type_cast_from_column(column, value) # :nodoc:
-        if column
-          type = lookup_cast_type_from_column(column)
-          type.serialize(value)
-        else
-          value
-        end
-      end
-
-      # See docs for #type_cast_from_column
       def lookup_cast_type_from_column(column) # :nodoc:
         lookup_cast_type(column.sql_type)
       end
@@ -114,16 +113,16 @@ module ActiveRecord
       # if the value is a Time responding to usec.
       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)
+          if ActiveRecord::Base.default_timezone == :utc
+            value = value.getutc if value.respond_to?(:getutc) && !value.utc?
+          else
+            value = value.getlocal if value.respond_to?(:getlocal)
           end
         end
 
         result = value.to_s(:db)
         if value.respond_to?(:usec) && value.usec > 0
-          "#{result}.#{sprintf("%06d", value.usec)}"
+          result << "." << sprintf("%06d", value.usec)
         else
           result
         end
@@ -162,7 +161,7 @@ module ActiveRecord
             # table_name.column_name | function(one or no argument)
             ((?:\w+\.)?\w+) | \w+\((?:|\g<2>)\)
           )
-          (?:\s+AS\s+\w+)?
+          (?:(?:\s+AS)?\s+\w+)?
         )
         (?:\s*,\s*\g<1>)*
         \z
@@ -197,10 +196,17 @@ module ActiveRecord
 
       private
         def type_casted_binds(binds)
-          if binds.first.is_a?(Array)
+          case binds.first
+          when Array
             binds.map { |column, value| type_cast(value, column) }
           else
-            binds.map { |attr| type_cast(attr.value_for_database) }
+            binds.map do |value|
+              if ActiveModel::Attribute === value
+                type_cast(value.value_for_database)
+              else
+                type_cast(value)
+              end
+            end
           end
         end
 
@@ -208,12 +214,6 @@ module ActiveRecord
           type_map.lookup(sql_type)
         end
 
-        def id_value_for_database(value)
-          if primary_key = value.class.primary_key
-            value.instance_variable_get(:@attributes)[primary_key].value_for_database
-          end
-        end
-
         def _quote(value)
           case value
           when String, Symbol, ActiveSupport::Multibyte::Chars
@@ -243,7 +243,7 @@ module ActiveRecord
           when nil, Numeric, String then value
           when Type::Time::Value then quoted_time(value)
           when Date, Time then quoted_date(value)
-          else raise TypeError
+          else raise TypeError, "can't cast #{value.class.name}"
           end
         end
     end

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

@@ -8,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

@@ -2,151 +2,188 @@
 
 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: true
+        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
-          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(" ")
+          statements = o.columns.map { |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
+
+          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.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
+          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#{table_modifier_in_create(o)} TABLE "
-            create_sql << "IF NOT EXISTS " if o.if_not_exists
-            create_sql << "#{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 #{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.map { |name| quote_column_name(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
-              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
-            create_sql
-          end
+        def supports_index_using?
+          true
+        end
 
-          def column_options(o)
-            o.options.merge(column: o)
-          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 to_sql(sql)
-            sql = sql.to_sql if sql.respond_to?(:to_sql)
-            sql
+        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
-
-          # Returns any SQL string to go between CREATE and TABLE. May be nil.
-          def table_modifier_in_create(o)
-            " TEMPORARY" if o.temporary
+          if options[:auto_increment] == true
+            sql << " AUTO_INCREMENT"
           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)
+          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
-                '#{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
-    SchemaCreation = AbstractAdapter::SchemaCreation # :nodoc:
   end
 end