activerecord 5.0.7.2 → 6.1.1

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

@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     class TransactionState
-      VALID_STATES = Set.new([:committed, :rolledback, nil])
-
       def initialize(state = nil)
         @state = state
+        @children = nil
+      end
+
+      def add_child(state)
+        @children ||= []
+        @children << state
       end
 
       def finalized?
@@ -12,22 +18,49 @@ module ActiveRecord
       end
 
       def committed?
-        @state == :committed
+        @state == :committed || @state == :fully_committed
+      end
+
+      def fully_committed?
+        @state == :fully_committed
       end
 
       def rolledback?
-        @state == :rolledback
+        @state == :rolledback || @state == :fully_rolledback
+      end
+
+      def fully_rolledback?
+        @state == :fully_rolledback
+      end
+
+      def fully_completed?
+        completed?
       end
 
       def completed?
         committed? || rolledback?
       end
 
-      def set_state(state)
-        unless VALID_STATES.include?(state)
-          raise ArgumentError, "Invalid transaction state: #{state}"
-        end
-        @state = state
+      def rollback!
+        @children&.each { |c| c.rollback! }
+        @state = :rolledback
+      end
+
+      def full_rollback!
+        @children&.each { |c| c.rollback! }
+        @state = :fully_rolledback
+      end
+
+      def commit!
+        @state = :committed
+      end
+
+      def full_commit!
+        @state = :fully_committed
+      end
+
+      def nullify!
+        @state = nil
       end
     end
 
@@ -37,61 +70,87 @@ module ActiveRecord
       def closed?; true; end
       def open?; false; end
       def joinable?; false; end
-      def add_record(record); end
+      def add_record(record, _ = true); end
     end
 
     class Transaction #:nodoc:
+      attr_reader :connection, :state, :savepoint_name, :isolation_level
+      attr_accessor :written
 
-      attr_reader :connection, :state, :records, :savepoint_name
-      attr_writer :joinable
-
-      def initialize(connection, options, run_commit_callbacks: false)
+      def initialize(connection, isolation: nil, joinable: true, run_commit_callbacks: false)
         @connection = connection
         @state = TransactionState.new
-        @records = []
-        @joinable = options.fetch(:joinable, true)
+        @records = nil
+        @isolation_level = isolation
+        @materialized = false
+        @joinable = joinable
         @run_commit_callbacks = run_commit_callbacks
+        @lazy_enrollment_records = nil
       end
 
-      def add_record(record)
-        records << record
+      def add_record(record, ensure_finalize = true)
+        @records ||= []
+        if ensure_finalize
+          @records << record
+        else
+          @lazy_enrollment_records ||= ObjectSpace::WeakMap.new
+          @lazy_enrollment_records[record] = record
+        end
       end
 
-      def rollback
-        @state.set_state(:rolledback)
+      def records
+        if @lazy_enrollment_records
+          @records.concat @lazy_enrollment_records.values
+          @lazy_enrollment_records = nil
+        end
+        @records
+      end
+
+      def materialize!
+        @materialized = true
+      end
+
+      def materialized?
+        @materialized
       end
 
       def rollback_records
-        ite = records.uniq
+        return unless records
+        ite = records.uniq(&:__id__)
+        already_run_callbacks = {}
         while record = ite.shift
-          record.rolledback!(force_restore_state: full_rollback?)
+          trigger_callbacks = record.trigger_transactional_callbacks?
+          should_run_callbacks = !already_run_callbacks[record] && trigger_callbacks
+          already_run_callbacks[record] ||= trigger_callbacks
+          record.rolledback!(force_restore_state: full_rollback?, should_run_callbacks: should_run_callbacks)
         end
       ensure
-        ite.each do |i|
+        ite&.each do |i|
           i.rolledback!(force_restore_state: full_rollback?, should_run_callbacks: false)
         end
       end
 
-      def commit
-        @state.set_state(:committed)
-      end
-
       def before_commit_records
-        records.uniq.each(&:before_committed!) if @run_commit_callbacks
+        records.uniq.each(&:before_committed!) if records && @run_commit_callbacks
       end
 
       def commit_records
-        ite = records.uniq
+        return unless records
+        ite = records.uniq(&:__id__)
+        already_run_callbacks = {}
         while record = ite.shift
           if @run_commit_callbacks
-            record.committed!
+            trigger_callbacks = record.trigger_transactional_callbacks?
+            should_run_callbacks = !already_run_callbacks[record] && trigger_callbacks
+            already_run_callbacks[record] ||= trigger_callbacks
+            record.committed!(should_run_callbacks: should_run_callbacks)
           else
             # if not running callbacks, only adds the record to the parent transaction
-            record.add_to_transaction
+            connection.add_transaction_record(record)
           end
         end
       ensure
-        ite.each { |i| i.committed!(should_run_callbacks: false) }
+        ite&.each { |i| i.committed!(should_run_callbacks: false) }
       end
 
       def full_rollback?; true; end
@@ -101,47 +160,55 @@ module ActiveRecord
     end
 
     class SavepointTransaction < Transaction
+      def initialize(connection, savepoint_name, parent_transaction, **options)
+        super(connection, **options)
+
+        parent_transaction.state.add_child(@state)
 
-      def initialize(connection, savepoint_name, options, *args)
-        super(connection, options, *args)
-        if options[:isolation]
+        if isolation_level
           raise ActiveRecord::TransactionIsolationError, "cannot set transaction isolation in a nested transaction"
         end
-        connection.create_savepoint(@savepoint_name = savepoint_name)
+
+        @savepoint_name = savepoint_name
       end
 
-      def rollback
-        connection.rollback_to_savepoint(savepoint_name)
+      def materialize!
+        connection.create_savepoint(savepoint_name)
         super
       end
 
+      def rollback
+        connection.rollback_to_savepoint(savepoint_name) if materialized?
+        @state.rollback!
+      end
+
       def commit
-        connection.release_savepoint(savepoint_name)
-        super
+        connection.release_savepoint(savepoint_name) if materialized?
+        @state.commit!
       end
 
       def full_rollback?; false; end
     end
 
     class RealTransaction < Transaction
-
-      def initialize(connection, options, *args)
-        super
-        if options[:isolation]
-          connection.begin_isolated_db_transaction(options[:isolation])
+      def materialize!
+        if isolation_level
+          connection.begin_isolated_db_transaction(isolation_level)
         else
           connection.begin_db_transaction
         end
+
+        super
       end
 
       def rollback
-        connection.rollback_db_transaction
-        super
+        connection.rollback_db_transaction if materialized?
+        @state.full_rollback!
       end
 
       def commit
-        connection.commit_db_transaction
-        super
+        connection.commit_db_transaction if materialized?
+        @state.full_commit!
       end
     end
 
@@ -149,60 +216,133 @@ module ActiveRecord
       def initialize(connection)
         @stack = []
         @connection = connection
+        @has_unmaterialized_transactions = false
+        @materializing_transactions = false
+        @lazy_transactions_enabled = true
       end
 
-      def begin_transaction(options = {})
-        run_commit_callbacks = !current_transaction.joinable?
-        transaction =
-          if @stack.empty?
-            RealTransaction.new(@connection, options, run_commit_callbacks: run_commit_callbacks)
+      def begin_transaction(isolation: nil, joinable: true, _lazy: true)
+        @connection.lock.synchronize do
+          run_commit_callbacks = !current_transaction.joinable?
+          transaction =
+            if @stack.empty?
+              RealTransaction.new(
+                @connection,
+                isolation: isolation,
+                joinable: joinable,
+                run_commit_callbacks: run_commit_callbacks
+              )
+            else
+              SavepointTransaction.new(
+                @connection,
+                "active_record_#{@stack.size}",
+                @stack.last,
+                isolation: isolation,
+                joinable: joinable,
+                run_commit_callbacks: run_commit_callbacks
+              )
+            end
+
+          if @connection.supports_lazy_transactions? && lazy_transactions_enabled? && _lazy
+            @has_unmaterialized_transactions = true
           else
-            SavepointTransaction.new(@connection, "active_record_#{@stack.size}", options,
-                                     run_commit_callbacks: run_commit_callbacks)
+            transaction.materialize!
           end
+          @stack.push(transaction)
+          transaction
+        end
+      end
 
-        @stack.push(transaction)
-        transaction
+      def disable_lazy_transactions!
+        materialize_transactions
+        @lazy_transactions_enabled = false
       end
 
-      def commit_transaction
-        transaction = @stack.last
+      def enable_lazy_transactions!
+        @lazy_transactions_enabled = true
+      end
 
-        begin
-          transaction.before_commit_records
-        ensure
-          @stack.pop
+      def lazy_transactions_enabled?
+        @lazy_transactions_enabled
+      end
+
+      def materialize_transactions
+        return if @materializing_transactions
+        return unless @has_unmaterialized_transactions
+
+        @connection.lock.synchronize do
+          begin
+            @materializing_transactions = true
+            @stack.each { |t| t.materialize! unless t.materialized? }
+          ensure
+            @materializing_transactions = false
+          end
+          @has_unmaterialized_transactions = false
         end
+      end
 
-        transaction.commit
-        transaction.commit_records
+      def commit_transaction
+        @connection.lock.synchronize do
+          transaction = @stack.last
+
+          begin
+            transaction.before_commit_records
+          ensure
+            @stack.pop
+          end
+
+          transaction.commit
+          transaction.commit_records
+        end
       end
 
       def rollback_transaction(transaction = nil)
-        transaction ||= @stack.pop
-        transaction.rollback
-        transaction.rollback_records
-      end
-
-      def within_new_transaction(options = {})
-        transaction = begin_transaction options
-        yield
-      rescue Exception => error
-        if transaction
-          rollback_transaction
-          after_failure_actions(transaction, error)
+        @connection.lock.synchronize do
+          transaction ||= @stack.pop
+          transaction.rollback
+          transaction.rollback_records
         end
-        raise
-      ensure
-        unless error
-          if Thread.current.status == 'aborting'
-            rollback_transaction if transaction
-          else
-            begin
-              commit_transaction
-            rescue Exception
-              rollback_transaction(transaction) unless transaction.state.completed?
-              raise
+      end
+
+      def within_new_transaction(isolation: nil, joinable: true)
+        @connection.lock.synchronize do
+          transaction = begin_transaction(isolation: isolation, joinable: joinable)
+          ret = yield
+          completed = true
+          ret
+        rescue Exception => error
+          if transaction
+            rollback_transaction
+            after_failure_actions(transaction, error)
+          end
+          raise
+        ensure
+          if transaction
+            if error
+              # @connection still holds an open transaction, so we must not
+              # put it back in the pool for reuse
+              @connection.throw_away! unless transaction.state.rolledback?
+            else
+              if Thread.current.status == "aborting"
+                rollback_transaction
+              else
+                if !completed && transaction.written
+                  ActiveSupport::Deprecation.warn(<<~EOW)
+                    Using `return`, `break` or `throw` to exit a transaction block is
+                    deprecated without replacement. If the `throw` came from
+                    `Timeout.timeout(duration)`, pass an exception class as a second
+                    argument so it doesn't use `throw` to abort its block. This results
+                    in the transaction being committed, but in the next release of Rails
+                    it will rollback.
+                  EOW
+                end
+                begin
+                  commit_transaction
+                rescue Exception
+                  rollback_transaction(transaction) unless transaction.state.completed?
+                  raise
+                end
+              end
             end
           end
         end
@@ -217,7 +357,6 @@ module ActiveRecord
       end
 
       private
-
         NULL_TRANSACTION = NullTransaction.new
 
         # Deallocate invalidated prepared statements outside of the transaction
@@ -226,7 +365,6 @@ module ActiveRecord
           return unless error.is_a?(ActiveRecord::PreparedStatementCacheExpired)
           @connection.clear_cache!
         end
-
     end
   end
 end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -1,52 +1,18 @@
-require 'active_record/type'
-require 'active_record/connection_adapters/determine_if_preparable_visitor'
-require 'active_record/connection_adapters/schema_cache'
-require 'active_record/connection_adapters/sql_type_metadata'
-require 'active_record/connection_adapters/abstract/schema_dumper'
-require 'active_record/connection_adapters/abstract/schema_creation'
-require 'arel/collectors/bind'
-require 'arel/collectors/sql_string'
+# frozen_string_literal: true
+
+require "set"
+require "active_record/connection_adapters/schema_cache"
+require "active_record/connection_adapters/sql_type_metadata"
+require "active_record/connection_adapters/abstract/schema_dumper"
+require "active_record/connection_adapters/abstract/schema_creation"
+require "active_support/concurrency/load_interlock_aware_monitor"
+require "arel/collectors/bind"
+require "arel/collectors/composite"
+require "arel/collectors/sql_string"
+require "arel/collectors/substitute_binds"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
-    extend ActiveSupport::Autoload
-
-    autoload :Column
-    autoload :ConnectionSpecification
-
-    autoload_at 'active_record/connection_adapters/abstract/schema_definitions' do
-      autoload :IndexDefinition
-      autoload :ColumnDefinition
-      autoload :ChangeColumnDefinition
-      autoload :ForeignKeyDefinition
-      autoload :TableDefinition
-      autoload :Table
-      autoload :AlterTable
-      autoload :ReferenceDefinition
-    end
-
-    autoload_at 'active_record/connection_adapters/abstract/connection_pool' do
-      autoload :ConnectionHandler
-    end
-
-    autoload_under 'abstract' do
-      autoload :SchemaStatements
-      autoload :DatabaseStatements
-      autoload :DatabaseLimits
-      autoload :Quoting
-      autoload :ConnectionPool
-      autoload :QueryCache
-      autoload :Savepoints
-    end
-
-    autoload_at 'active_record/connection_adapters/abstract/transaction' do
-      autoload :TransactionManager
-      autoload :NullTransaction
-      autoload :RealTransaction
-      autoload :SavepointTransaction
-      autoload :TransactionState
-    end
-
     # Active Record supports multiple database systems. AbstractAdapter and
     # related classes form the abstraction layer which makes this possible.
     # An AbstractAdapter represents a connection to a database, and provides an
@@ -61,24 +27,28 @@ module ActiveRecord
     # Most of the methods in the adapter are useful during migrations. Most
     # notably, the instance methods provided by SchemaStatements are very useful.
     class AbstractAdapter
-      ADAPTER_NAME = "Abstract".freeze
+      ADAPTER_NAME = "Abstract"
       include ActiveSupport::Callbacks
       define_callbacks :checkout, :checkin
 
       include Quoting, DatabaseStatements, SchemaStatements
       include DatabaseLimits
       include QueryCache
-      include ColumnDumper
       include Savepoints
 
       SIMPLE_INT = /\A\d+\z/
+      COMMENT_REGEX = %r{(?:\-\-.*\n)*|/\*(?:[^\*]|\*[^/])*\*/}m
 
-      attr_accessor :visitor, :pool
-      attr_reader :schema_cache, :owner, :logger
+      attr_accessor :pool
+      attr_reader :visitor, :owner, :logger, :lock
       alias :in_use? :owner
 
+      set_callback :checkin, :after, :enable_lazy_transactions!
+
       def self.type_cast_config_to_integer(config)
-        if config =~ SIMPLE_INT
+        if config.is_a?(Integer)
+          config
+        elsif SIMPLE_INT.match?(config)
           config.to_i
         else
           config
@@ -93,7 +63,22 @@ module ActiveRecord
         end
       end
 
-      attr_reader :prepared_statements
+      DEFAULT_READ_QUERY = [:begin, :commit, :explain, :release, :rollback, :savepoint, :select, :with] # :nodoc:
+      private_constant :DEFAULT_READ_QUERY
+
+      def self.build_read_query_regexp(*parts) # :nodoc:
+        parts += DEFAULT_READ_QUERY
+        parts = parts.map { |part| /#{part}/i }
+        /\A(?:[\(\s]|#{COMMENT_REGEX})*#{Regexp.union(*parts)}/
+      end
+
+      def self.quoted_column_names # :nodoc:
+        @quoted_column_names ||= {}
+      end
+
+      def self.quoted_table_names # :nodoc:
+        @quoted_table_names ||= {}
+      end
 
       def initialize(connection, logger = nil, config = {}) # :nodoc:
         super()
@@ -103,72 +88,112 @@ module ActiveRecord
         @instrumenter        = ActiveSupport::Notifications.instrumenter
         @logger              = logger
         @config              = config
-        @pool                = nil
-        @schema_cache        = SchemaCache.new self
-        @quoted_column_names, @quoted_table_names = {}, {}
-        @visitor             = arel_visitor
-
-        if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
-          @prepared_statements = true
-          @visitor.extend(DetermineIfPreparableVisitor)
-        else
-          @prepared_statements = false
-        end
+        @pool                = ActiveRecord::ConnectionAdapters::NullPool.new
+        @idle_since          = Concurrent.monotonic_time
+        @visitor = arel_visitor
+        @statements = build_statement_pool
+        @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
+
+        @prepared_statements = self.class.type_cast_config_to_boolean(
+          config.fetch(:prepared_statements, true)
+        )
+
+        @advisory_locks_enabled = self.class.type_cast_config_to_boolean(
+          config.fetch(:advisory_locks, true)
+        )
       end
 
-      class Version
-        include Comparable
+      def replica?
+        @config[:replica] || false
+      end
 
-        def initialize(version_string)
-          @version = version_string.split('.').map(&:to_i)
-        end
+      def use_metadata_table?
+        @config.fetch(:use_metadata_table, true)
+      end
 
-        def <=>(version_string)
-          @version <=> version_string.split('.').map(&:to_i)
-        end
+      # Determines whether writes are currently being prevents.
+      #
+      # Returns true if the connection is a replica.
+      #
+      # If the application is using legacy handling, returns
+      # true if `connection_handler.prevent_writes` is set.
+      #
+      # If the application is using the new connection handling
+      # will return true based on `current_preventing_writes`.
+      def preventing_writes?
+        return true if replica?
+        return ActiveRecord::Base.connection_handler.prevent_writes if ActiveRecord::Base.legacy_connection_handling
+        return false if owner_name.nil?
+
+        klass = self.owner_name.safe_constantize
+        klass&.current_preventing_writes
       end
 
-      class BindCollector < Arel::Collectors::Bind
-        def compile(bvs, conn)
-          casted_binds = conn.prepare_binds_for_database(bvs)
-          super(casted_binds.map { |value| conn.quote(value) })
-        end
+      def migrations_paths # :nodoc:
+        @config[:migrations_paths] || Migrator.migrations_paths
       end
 
-      class SQLString < Arel::Collectors::SQLString
-        def compile(bvs, conn)
-          super(bvs)
-        end
+      def migration_context # :nodoc:
+        MigrationContext.new(migrations_paths, schema_migration)
       end
 
-      def collector
-        if prepared_statements
-          SQLString.new
-        else
-          BindCollector.new
-        end
+      def schema_migration # :nodoc:
+        @schema_migration ||= begin
+                                conn = self
+                                spec_name = conn.pool.pool_config.connection_specification_name
+
+                                return ActiveRecord::SchemaMigration if spec_name == "ActiveRecord::Base"
+
+                                schema_migration_name = "#{spec_name}::SchemaMigration"
+
+                                Class.new(ActiveRecord::SchemaMigration) do
+                                  define_singleton_method(:name) { schema_migration_name }
+                                  define_singleton_method(:to_s) { schema_migration_name }
+
+                                  self.connection_specification_name = spec_name
+                                end
+                              end
       end
 
-      def arel_visitor # :nodoc:
-        Arel::Visitors::ToSql.new(self)
+      def prepared_statements
+        @prepared_statements && !prepared_statements_disabled_cache.include?(object_id)
       end
 
-      def valid_type?(type)
-        false
+      def prepared_statements_disabled_cache # :nodoc:
+        Thread.current[:ar_prepared_statements_disabled_cache] ||= Set.new
       end
 
-      def schema_creation
-        SchemaCreation.new self
+      class Version
+        include Comparable
+
+        attr_reader :full_version_string
+
+        def initialize(version_string, full_version_string = nil)
+          @version = version_string.split(".").map(&:to_i)
+          @full_version_string = full_version_string
+        end
+
+        def <=>(version_string)
+          @version <=> version_string.split(".").map(&:to_i)
+        end
+
+        def to_s
+          @version.join(".")
+        end
+      end
+
+      def valid_type?(type) # :nodoc:
+        !native_database_types[type].nil?
       end
 
       # this method must only be called while holding connection pool's mutex
       def lease
         if in_use?
-          msg = 'Cannot lease connection, '
+          msg = +"Cannot lease connection, "
           if @owner == Thread.current
-            msg << 'it is already leased by the current thread.'
+            msg << "it is already leased by the current thread."
           else
-            msg << "it is already in use by a different thread: #{@owner}. " <<
+            msg << "it is already in use by a different thread: #{@owner}. " \
                    "Current thread: #{Thread.current}."
           end
           raise ActiveRecordError, msg
@@ -177,23 +202,32 @@ module ActiveRecord
         @owner = Thread.current
       end
 
+      def owner_name # :nodoc:
+        @pool.owner_name
+      end
+
+      def schema_cache
+        @pool.get_schema_cache(self)
+      end
+
       def schema_cache=(cache)
         cache.connection = self
-        @schema_cache = cache
+        @pool.set_schema_cache(cache)
       end
 
       # this method must only be called while holding connection pool's mutex
       def expire
         if in_use?
           if @owner != Thread.current
-            raise ActiveRecordError, "Cannot expire connection, " <<
-              "it is owned by a different thread: #{@owner}. " <<
+            raise ActiveRecordError, "Cannot expire connection, " \
+              "it is owned by a different thread: #{@owner}. " \
               "Current thread: #{Thread.current}."
           end
 
+          @idle_since = Concurrent.monotonic_time
           @owner = nil
         else
-          raise ActiveRecordError, 'Cannot expire connection, it is not currently leased.'
+          raise ActiveRecordError, "Cannot expire connection, it is not currently leased."
         end
       end
 
@@ -206,15 +240,21 @@ module ActiveRecord
             @owner = Thread.current
           end
         else
-          raise ActiveRecordError, 'Cannot steal connection, it is not currently leased.'
+          raise ActiveRecordError, "Cannot steal connection, it is not currently leased."
         end
       end
 
+      # Seconds since this connection was returned to the pool
+      def seconds_idle # :nodoc:
+        return 0 if in_use?
+        Concurrent.monotonic_time - @idle_since
+      end
+
       def unprepared_statement
-        old_prepared_statements, @prepared_statements = @prepared_statements, false
+        cache = prepared_statements_disabled_cache.add(object_id) if @prepared_statements
         yield
       ensure
-        @prepared_statements = old_prepared_statements
+        cache&.delete(object_id)
       end
 
       # Returns the human-readable name of the adapter. Use mixed case - one
@@ -223,15 +263,9 @@ module ActiveRecord
         self.class::ADAPTER_NAME
       end
 
-      # Does this adapter support migrations?
-      def supports_migrations?
-        false
-      end
-
-      # Can this adapter determine the primary key for tables not attached
-      # to an Active Record class, such as join tables?
-      def supports_primary_key?
-        false
+      # Does the database for this adapter exist?
+      def self.database_exists?(config)
+        raise NotImplementedError
       end
 
       # Does this adapter support DDL rollbacks in transactions? That is, would
@@ -261,6 +295,10 @@ module ActiveRecord
         false
       end
 
+      def supports_partitioned_indexes?
+        false
+      end
+
       # Does this adapter support index sort order?
       def supports_index_sort_order?
         false
@@ -302,11 +340,26 @@ module ActiveRecord
         false
       end
 
+      # Does this adapter support creating invalid constraints?
+      def supports_validate_constraints?
+        false
+      end
+
+      # Does this adapter support creating check constraints?
+      def supports_check_constraints?
+        false
+      end
+
       # Does this adapter support views?
       def supports_views?
         false
       end
 
+      # Does this adapter support materialized views?
+      def supports_materialized_views?
+        false
+      end
+
       # Does this adapter support datetime with precision?
       def supports_datetime_with_precision?
         false
@@ -327,9 +380,43 @@ module ActiveRecord
         false
       end
 
-      # Does this adapter support multi-value insert?
-      def supports_multi_insert?
-        true
+      # Does this adapter support virtual columns?
+      def supports_virtual_columns?
+        false
+      end
+
+      # Does this adapter support foreign/external tables?
+      def supports_foreign_tables?
+        false
+      end
+
+      # Does this adapter support optimizer hints?
+      def supports_optimizer_hints?
+        false
+      end
+
+      def supports_common_table_expressions?
+        false
+      end
+
+      def supports_lazy_transactions?
+        false
+      end
+
+      def supports_insert_returning?
+        false
+      end
+
+      def supports_insert_on_duplicate_skip?
+        false
+      end
+
+      def supports_insert_on_duplicate_update?
+        false
+      end
+
+      def supports_insert_conflict_target?
+        false
       end
 
       # This is meant to be implemented by the adapters that support extensions
@@ -340,6 +427,10 @@ module ActiveRecord
       def enable_extension(name)
       end
 
+      def advisory_locks_enabled? # :nodoc:
+        supports_advisory_locks? && @advisory_locks_enabled
+      end
+
       # This is meant to be implemented by the adapters that support advisory
       # locks
       #
@@ -394,6 +485,22 @@ module ActiveRecord
         reset_transaction
       end
 
+      # Immediately forget this connection ever existed. Unlike disconnect!,
+      # this will not communicate with the server.
+      #
+      # After calling this method, the behavior of all other methods becomes
+      # undefined. This is called internally just before a forked process gets
+      # rid of a connection that belonged to its parent.
+      def discard!
+        # This should be overridden by concrete adapters.
+        #
+        # Prevent @connection's finalizer from touching the socket, or
+        # otherwise communicating with its server, when it is collected.
+        if schema_cache.connection == self
+          schema_cache.connection = nil
+        end
+      end
+
       # Reset the state of this connection, directing the DBMS to clear
       # transactions and other connection-related server-side state. Usually a
       # database-dependent operation.
@@ -404,11 +511,15 @@ module ActiveRecord
         # this should be overridden by concrete adapters
       end
 
-      ###
-      # Clear any caching the database adapter may be doing, for example
-      # clearing the prepared statement cache. This is database specific.
+      # Removes the connection from the pool and disconnect it.
+      def throw_away!
+        pool.remove self
+        disconnect!
+      end
+
+      # Clear any caching the database adapter may be doing.
       def clear_cache!
-        # this should be overridden by concrete adapters
+        @lock.synchronize { @statements.clear } if @statements
       end
 
       # Returns true if its required to reload the connection between requests for development mode.
@@ -419,7 +530,7 @@ module ActiveRecord
       # Checks whether the connection to the database is still active (i.e. not stale).
       # This is done under the hood by calling #active?. If the connection
       # is no longer active, then this method will reconnect to the database.
-      def verify!(*ignored)
+      def verify!
         reconnect! unless active?
       end
 
@@ -430,22 +541,25 @@ module ActiveRecord
       # This is useful for when you need to call a proprietary method such as
       # PostgreSQL's lo_* methods.
       def raw_connection
+        disable_lazy_transactions!
         @connection
       end
 
-      def case_sensitive_comparison(table, attribute, column, value)
-        if value.nil?
-          table[attribute].eq(value)
-        else
-          table[attribute].eq(Arel::Nodes::BindParam.new)
-        end
+      def default_uniqueness_comparison(attribute, value) # :nodoc:
+        attribute.eq(value)
       end
 
-      def case_insensitive_comparison(table, attribute, column, value)
+      def case_sensitive_comparison(attribute, value) # :nodoc:
+        attribute.eq(value)
+      end
+
+      def case_insensitive_comparison(attribute, value) # :nodoc:
+        column = column_for_attribute(attribute)
+
         if can_perform_case_insensitive_comparison_for?(column)
-          table[attribute].lower.eq(table.lower(Arel::Nodes::BindParam.new))
+          attribute.lower.eq(attribute.relation.lower(value))
         else
-          table[attribute].eq(Arel::Nodes::BindParam.new)
+          attribute.eq(value)
         end
       end
 
@@ -459,153 +573,187 @@ module ActiveRecord
         pool.checkin self
       end
 
-      def type_map # :nodoc:
-        @type_map ||= Type::TypeMap.new.tap do |mapping|
-          initialize_type_map(mapping)
+      def default_index_type?(index) # :nodoc:
+        index.using.nil?
+      end
+
+      # Called by ActiveRecord::InsertAll,
+      # Passed an instance of ActiveRecord::InsertAll::Builder,
+      # This method implements standard bulk inserts for all databases, but
+      # should be overridden by adapters to implement common features with
+      # non-standard syntax like handling duplicates or returning values.
+      def build_insert_sql(insert) # :nodoc:
+        if insert.skip_duplicates? || insert.update_duplicates?
+          raise NotImplementedError, "#{self.class} should define `build_insert_sql` to implement adapter-specific logic for handling duplicates during INSERT"
         end
+
+        "INSERT #{insert.into} #{insert.values_list}"
       end
 
-      def new_column(name, default, sql_type_metadata, null, table_name, default_function = nil, collation = nil) # :nodoc:
-        Column.new(name, default, sql_type_metadata, null, table_name, default_function, collation)
+      def get_database_version # :nodoc:
       end
 
-      def lookup_cast_type(sql_type) # :nodoc:
-        type_map.lookup(sql_type)
+      def database_version # :nodoc:
+        schema_cache.database_version
       end
 
-      def column_name_for_operation(operation, node) # :nodoc:
-        visitor.accept(node, collector).value
+      def check_version # :nodoc:
       end
 
-      def combine_bind_parameters(
-        from_clause: [],
-        join_clause: [],
-        where_clause: [],
-        having_clause: [],
-        limit: nil,
-        offset: nil
-      ) # :nodoc:
-        result = from_clause + join_clause + where_clause + having_clause
-        if limit
-          result << limit
-        end
-        if offset
-          result << offset
+      private
+        def type_map
+          @type_map ||= Type::TypeMap.new.tap do |mapping|
+            initialize_type_map(mapping)
+          end
         end
-        result
-      end
-
-      protected
-
-      def initialize_type_map(m) # :nodoc:
-        register_class_with_limit m, %r(boolean)i,       Type::Boolean
-        register_class_with_limit m, %r(char)i,          Type::String
-        register_class_with_limit m, %r(binary)i,        Type::Binary
-        register_class_with_limit m, %r(text)i,          Type::Text
-        register_class_with_precision m, %r(date)i,      Type::Date
-        register_class_with_precision m, %r(time)i,      Type::Time
-        register_class_with_precision m, %r(datetime)i,  Type::DateTime
-        register_class_with_limit m, %r(float)i,         Type::Float
-        register_class_with_limit m, %r(int)i,           Type::Integer
-
-        m.alias_type %r(blob)i,      'binary'
-        m.alias_type %r(clob)i,      'text'
-        m.alias_type %r(timestamp)i, 'datetime'
-        m.alias_type %r(numeric)i,   'decimal'
-        m.alias_type %r(number)i,    'decimal'
-        m.alias_type %r(double)i,    'float'
-
-        m.register_type(%r(decimal)i) do |sql_type|
-          scale = extract_scale(sql_type)
-          precision = extract_precision(sql_type)
-
-          if scale == 0
-            # FIXME: Remove this class as well
-            Type::DecimalWithoutScale.new(precision: precision)
-          else
-            Type::Decimal.new(precision: precision, scale: scale)
+
+        def initialize_type_map(m = type_map)
+          register_class_with_limit m, %r(boolean)i,       Type::Boolean
+          register_class_with_limit m, %r(char)i,          Type::String
+          register_class_with_limit m, %r(binary)i,        Type::Binary
+          register_class_with_limit m, %r(text)i,          Type::Text
+          register_class_with_precision m, %r(date)i,      Type::Date
+          register_class_with_precision m, %r(time)i,      Type::Time
+          register_class_with_precision m, %r(datetime)i,  Type::DateTime
+          register_class_with_limit m, %r(float)i,         Type::Float
+          register_class_with_limit m, %r(int)i,           Type::Integer
+
+          m.alias_type %r(blob)i,      "binary"
+          m.alias_type %r(clob)i,      "text"
+          m.alias_type %r(timestamp)i, "datetime"
+          m.alias_type %r(numeric)i,   "decimal"
+          m.alias_type %r(number)i,    "decimal"
+          m.alias_type %r(double)i,    "float"
+
+          m.register_type %r(^json)i, Type::Json.new
+
+          m.register_type(%r(decimal)i) do |sql_type|
+            scale = extract_scale(sql_type)
+            precision = extract_precision(sql_type)
+
+            if scale == 0
+              # FIXME: Remove this class as well
+              Type::DecimalWithoutScale.new(precision: precision)
+            else
+              Type::Decimal.new(precision: precision, scale: scale)
+            end
           end
         end
-      end
 
-      def reload_type_map # :nodoc:
-        type_map.clear
-        initialize_type_map(type_map)
-      end
+        def reload_type_map
+          type_map.clear
+          initialize_type_map
+        end
 
-      def register_class_with_limit(mapping, key, klass) # :nodoc:
-        mapping.register_type(key) do |*args|
-          limit = extract_limit(args.last)
-          klass.new(limit: limit)
+        def register_class_with_limit(mapping, key, klass)
+          mapping.register_type(key) do |*args|
+            limit = extract_limit(args.last)
+            klass.new(limit: limit)
+          end
         end
-      end
 
-      def register_class_with_precision(mapping, key, klass) # :nodoc:
-        mapping.register_type(key) do |*args|
-          precision = extract_precision(args.last)
-          klass.new(precision: precision)
+        def register_class_with_precision(mapping, key, klass)
+          mapping.register_type(key) do |*args|
+            precision = extract_precision(args.last)
+            klass.new(precision: precision)
+          end
         end
-      end
 
-      def extract_scale(sql_type) # :nodoc:
-        case sql_type
+        def extract_scale(sql_type)
+          case sql_type
           when /\((\d+)\)/ then 0
           when /\((\d+)(,(\d+))\)/ then $3.to_i
+          end
         end
-      end
 
-      def extract_precision(sql_type) # :nodoc:
-        $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
-      end
+        def extract_precision(sql_type)
+          $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
+        end
 
-      def extract_limit(sql_type) # :nodoc:
-        case sql_type
-        when /^bigint/i
-          8
-        when /\((.*)\)/
-          $1.to_i
+        def extract_limit(sql_type)
+          $1.to_i if sql_type =~ /\((.*)\)/
         end
-      end
 
-      def translate_exception_class(e, sql)
-        begin
-          message = "#{e.class.name}: #{e.message}: #{sql}"
-        rescue Encoding::CompatibilityError
-          message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
+        def translate_exception_class(e, sql, binds)
+          message = "#{e.class.name}: #{e.message}"
+
+          exception = translate_exception(
+            e, message: message, sql: sql, binds: binds
+          )
+          exception.set_backtrace e.backtrace
+          exception
         end
 
-        exception = translate_exception(e, message)
-        exception.set_backtrace e.backtrace
-        exception
-      end
+        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
+          @instrumenter.instrument(
+            "sql.active_record",
+            sql:               sql,
+            name:              name,
+            binds:             binds,
+            type_casted_binds: type_casted_binds,
+            statement_name:    statement_name,
+            connection:        self) do
+            @lock.synchronize do
+              yield
+            end
+          rescue => e
+            raise translate_exception_class(e, sql, binds)
+          end
+        end
 
-      def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
-        @instrumenter.instrument(
-          "sql.active_record",
-          sql:               sql,
-          name:              name,
-          binds:             binds,
-          type_casted_binds: type_casted_binds,
-          statement_name:    statement_name,
-          connection_id:     object_id) { yield }
-      rescue => e
-        raise translate_exception_class(e, sql)
-      end
+        def translate_exception(exception, message:, sql:, binds:)
+          # override in derived class
+          case exception
+          when RuntimeError
+            exception
+          else
+            ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+          end
+        end
 
-      def translate_exception(exception, message)
-        # override in derived class
-        ActiveRecord::StatementInvalid.new(message)
-      end
+        def without_prepared_statement?(binds)
+          !prepared_statements || binds.empty?
+        end
 
-      def without_prepared_statement?(binds)
-        !prepared_statements || binds.empty?
-      end
+        def column_for(table_name, column_name)
+          column_name = column_name.to_s
+          columns(table_name).detect { |c| c.name == column_name } ||
+            raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}")
+        end
 
-      def column_for(table_name, column_name) # :nodoc:
-        column_name = column_name.to_s
-        columns(table_name).detect { |c| c.name == column_name } ||
-          raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}")
-      end
+        def column_for_attribute(attribute)
+          table_name = attribute.relation.name
+          schema_cache.columns_hash(table_name)[attribute.name.to_s]
+        end
+
+        def collector
+          if prepared_statements
+            Arel::Collectors::Composite.new(
+              Arel::Collectors::SQLString.new,
+              Arel::Collectors::Bind.new,
+            )
+          else
+            Arel::Collectors::SubstituteBinds.new(
+              self,
+              Arel::Collectors::SQLString.new,
+            )
+          end
+        end
+
+        def arel_visitor
+          Arel::Visitors::ToSql.new(self)
+        end
+
+        def build_statement_pool
+        end
+
+        # Builds the result object.
+        #
+        # This is an internal hook to make possible connection adapters to build
+        # custom result objects with connection-specific data.
+        def build_result(columns:, rows:, column_types: {})
+          ActiveRecord::Result.new(columns, rows, column_types)
+        end
     end
   end
 end