activerecord 7.0.8.6 → 7.2.2.1

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,70 +1,69 @@
 # frozen_string_literal: true
 
 require "active_record/connection_adapters/abstract_mysql_adapter"
-require "active_record/connection_adapters/mysql/database_statements"
+require "active_record/connection_adapters/mysql2/database_statements"
 
 gem "mysql2", "~> 0.5"
 require "mysql2"
 
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    # Establishes a connection to the database that's used by all Active Record objects.
-    def mysql2_connection(config)
-      config = config.symbolize_keys
-      config[:flags] ||= 0
-
-      if config[:flags].kind_of? Array
-        config[:flags].push "FOUND_ROWS"
-      else
-        config[:flags] |= Mysql2::Client::FOUND_ROWS
-      end
-
-      ConnectionAdapters::Mysql2Adapter.new(
-        ConnectionAdapters::Mysql2Adapter.new_client(config),
-        logger,
-        nil,
-        config,
-      )
-    end
-  end
-
   module ConnectionAdapters
+    # = Active Record MySQL2 Adapter
     class Mysql2Adapter < AbstractMysqlAdapter
-      ER_BAD_DB_ERROR        = 1049
-      ER_ACCESS_DENIED_ERROR = 1045
-      ER_CONN_HOST_ERROR     = 2003
-      ER_UNKNOWN_HOST_ERROR  = 2005
+      ER_BAD_DB_ERROR           = 1049
+      ER_DBACCESS_DENIED_ERROR  = 1044
+      ER_ACCESS_DENIED_ERROR    = 1045
+      ER_CONN_HOST_ERROR        = 2003
+      ER_UNKNOWN_HOST_ERROR     = 2005
 
       ADAPTER_NAME = "Mysql2"
 
-      include MySQL::DatabaseStatements
+      include Mysql2::DatabaseStatements
 
       class << self
         def new_client(config)
-          Mysql2::Client.new(config)
-        rescue Mysql2::Error => error
-          if error.error_number == ConnectionAdapters::Mysql2Adapter::ER_BAD_DB_ERROR
+          ::Mysql2::Client.new(config)
+        rescue ::Mysql2::Error => error
+          case error.error_number
+          when ER_BAD_DB_ERROR
             raise ActiveRecord::NoDatabaseError.db_error(config[:database])
-          elsif error.error_number == ConnectionAdapters::Mysql2Adapter::ER_ACCESS_DENIED_ERROR
+          when ER_DBACCESS_DENIED_ERROR, ER_ACCESS_DENIED_ERROR
             raise ActiveRecord::DatabaseConnectionError.username_error(config[:username])
-          elsif [ConnectionAdapters::Mysql2Adapter::ER_CONN_HOST_ERROR, ConnectionAdapters::Mysql2Adapter::ER_UNKNOWN_HOST_ERROR].include?(error.error_number)
+          when ER_CONN_HOST_ERROR, ER_UNKNOWN_HOST_ERROR
             raise ActiveRecord::DatabaseConnectionError.hostname_error(config[:host])
           else
             raise ActiveRecord::ConnectionNotEstablished, error.message
           end
         end
-      end
 
-      def initialize(connection, logger, connection_options, config)
-        superclass_config = config.reverse_merge(prepared_statements: false)
-        super(connection, logger, connection_options, superclass_config)
-        configure_connection
+        private
+          def initialize_type_map(m)
+            super
+
+            m.register_type(%r(char)i) do |sql_type|
+              limit = extract_limit(sql_type)
+              Type.lookup(:string, adapter: :mysql2, limit: limit)
+            end
+
+            m.register_type %r(^enum)i, Type.lookup(:string, adapter: :mysql2)
+            m.register_type %r(^set)i,  Type.lookup(:string, adapter: :mysql2)
+          end
       end
 
-      def self.database_exists?(config)
-        !!ActiveRecord::Base.mysql2_connection(config)
-      rescue ActiveRecord::NoDatabaseError
-        false
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
+      def initialize(...)
+        super
+
+        @config[:flags] ||= 0
+
+        if @config[:flags].kind_of? Array
+          @config[:flags].push "FOUND_ROWS"
+        else
+          @config[:flags] |= ::Mysql2::Client::FOUND_ROWS
+        end
+
+        @connection_parameters ||= @config
       end
 
       def supports_json?
@@ -83,6 +82,10 @@ module ActiveRecord
         true
       end
 
+      def savepoint_errors_invalidate_transactions?
+        true
+      end
+
       def supports_lazy_transactions?
         true
       end
@@ -102,69 +105,99 @@ module ActiveRecord
       end
 
       #--
-      # QUOTING ==================================================
+      # CONNECTION MANAGEMENT ====================================
       #++
 
-      def quote_string(string)
-        @connection.escape(string)
-      rescue Mysql2::Error => error
-        raise translate_exception(error, message: error.message, sql: "<escape>", binds: [])
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.closed?)
       end
 
-      #--
-      # CONNECTION MANAGEMENT ====================================
-      #++
-
       def active?
-        @connection.ping
+        connected? && @lock.synchronize { @raw_connection&.ping } || false
       end
 
-      def reconnect!
-        super
-        disconnect!
-        connect
-      end
       alias :reset! :reconnect!
 
       # Disconnects from the database if already connected.
       # Otherwise, this method does nothing.
       def disconnect!
-        super
-        @connection.close
+        @lock.synchronize do
+          super
+          @raw_connection&.close
+          @raw_connection = nil
+        end
       end
 
       def discard! # :nodoc:
-        super
-        @connection.automatic_close = false
-        @connection = nil
+        @lock.synchronize do
+          super
+          @raw_connection&.automatic_close = false
+          @raw_connection = nil
+        end
       end
 
       private
+        def text_type?(type)
+          TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
+        end
+
         def connect
-          @connection = self.class.new_client(@config)
-          configure_connection
+          @raw_connection = self.class.new_client(@connection_parameters)
+        rescue ConnectionNotEstablished => ex
+          raise ex.set_pool(@pool)
+        end
+
+        def reconnect
+          @lock.synchronize do
+            @raw_connection&.close
+            @raw_connection = nil
+            connect
+          end
         end
 
         def configure_connection
-          @connection.query_options[:as] = :array
+          @raw_connection.query_options[:as] = :array
+          @raw_connection.query_options[:database_timezone] = default_timezone
           super
         end
 
         def full_version
-          schema_cache.database_version.full_version_string
+          database_version.full_version_string
         end
 
         def get_full_version
-          @connection.server_info[:version]
+          any_raw_connection.server_info[:version]
         end
 
         def translate_exception(exception, message:, sql:, binds:)
-          if exception.is_a?(Mysql2::Error::TimeoutError) && !exception.error_number
-            ActiveRecord::AdapterTimeout.new(message, sql: sql, binds: binds)
+          if exception.is_a?(::Mysql2::Error::TimeoutError) && !exception.error_number
+            ActiveRecord::AdapterTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
+          elsif exception.is_a?(::Mysql2::Error::ConnectionError)
+            if exception.message.match?(/MySQL client is not connected/i)
+              ActiveRecord::ConnectionNotEstablished.new(exception, connection_pool: @pool)
+            else
+              ActiveRecord::ConnectionFailed.new(message, sql: sql, binds: binds, connection_pool: @pool)
+            end
           else
             super
           end
         end
+
+        def default_prepared_statements
+          false
+        end
+
+        ActiveRecord::Type.register(:immutable_string, adapter: :mysql2) do |_, **args|
+          Type::ImmutableString.new(true: "1", false: "0", **args)
+        end
+
+        ActiveRecord::Type.register(:string, adapter: :mysql2) do |_, **args|
+          Type::String.new(true: "1", false: "0", **args)
+        end
+
+        ActiveRecord::Type.register(:unsigned_integer, Type::UnsignedInteger, adapter: :mysql2)
     end
+
+    ActiveSupport.run_load_hooks(:active_record_mysql2adapter, Mysql2Adapter)
   end
 end

data/lib/active_record/connection_adapters/pool_config.rb

@@ -3,10 +3,15 @@
 module ActiveRecord
   module ConnectionAdapters
     class PoolConfig # :nodoc:
-      include Mutex_m
+      include MonitorMixin
 
-      attr_reader :db_config, :connection_class, :role, :shard
-      attr_accessor :schema_cache
+      attr_reader :db_config, :role, :shard
+      attr_writer :schema_reflection, :server_version
+      attr_accessor :connection_class
+
+      def schema_reflection
+        @schema_reflection ||= SchemaReflection.new(db_config.lazy_schema_cache_path)
+      end
 
       INSTANCES = ObjectSpace::WeakMap.new
       private_constant :INSTANCES
@@ -15,10 +20,15 @@ module ActiveRecord
         def discard_pools!
           INSTANCES.each_key(&:discard_pool!)
         end
+
+        def disconnect_all!
+          INSTANCES.each_key { |c| c.disconnect!(automatic_reconnect: true) }
+        end
       end
 
       def initialize(connection_class, db_config, role, shard)
         super()
+        @server_version = nil
         @connection_class = connection_class
         @db_config = db_config
         @role = role
@@ -27,7 +37,11 @@ module ActiveRecord
         INSTANCES[self] = self
       end
 
-      def connection_specification_name
+      def server_version(connection)
+        @server_version || synchronize { @server_version ||= connection.get_database_version }
+      end
+
+      def connection_name
         if connection_class.primary_class?
           "ActiveRecord::Base"
         else
@@ -35,15 +49,13 @@ module ActiveRecord
         end
       end
 
-      def disconnect!
-        ActiveSupport::ForkTracker.check!
-
+      def disconnect!(automatic_reconnect: false)
         return unless @pool
 
         synchronize do
           return unless @pool
 
-          @pool.automatic_reconnect = false
+          @pool.automatic_reconnect = automatic_reconnect
           @pool.disconnect!
         end
 
@@ -51,8 +63,6 @@ module ActiveRecord
       end
 
       def pool
-        ActiveSupport::ForkTracker.check!
-
         @pool || synchronize { @pool ||= ConnectionAdapters::ConnectionPool.new(self) }
       end
 

data/lib/active_record/connection_adapters/pool_manager.rb

@@ -4,40 +4,50 @@ module ActiveRecord
   module ConnectionAdapters
     class PoolManager # :nodoc:
       def initialize
-        @name_to_role_mapping = Hash.new { |h, k| h[k] = {} }
+        @role_to_shard_mapping = Hash.new { |h, k| h[k] = {} }
       end
 
       def shard_names
-        @name_to_role_mapping.values.flat_map { |shard_map| shard_map.keys }
+        @role_to_shard_mapping.values.flat_map { |shard_map| shard_map.keys }.uniq
       end
 
       def role_names
-        @name_to_role_mapping.keys
+        @role_to_shard_mapping.keys
       end
 
       def pool_configs(role = nil)
         if role
-          @name_to_role_mapping[role].values
+          @role_to_shard_mapping[role].values
         else
-          @name_to_role_mapping.flat_map { |_, shard_map| shard_map.values }
+          @role_to_shard_mapping.flat_map { |_, shard_map| shard_map.values }
+        end
+      end
+
+      def each_pool_config(role = nil, &block)
+        if role
+          @role_to_shard_mapping[role].each_value(&block)
+        else
+          @role_to_shard_mapping.each_value do |shard_map|
+            shard_map.each_value(&block)
+          end
         end
       end
 
       def remove_role(role)
-        @name_to_role_mapping.delete(role)
+        @role_to_shard_mapping.delete(role)
       end
 
       def remove_pool_config(role, shard)
-        @name_to_role_mapping[role].delete(shard)
+        @role_to_shard_mapping[role].delete(shard)
       end
 
       def get_pool_config(role, shard)
-        @name_to_role_mapping[role][shard]
+        @role_to_shard_mapping[role][shard]
       end
 
       def set_pool_config(role, shard, pool_config)
         if pool_config
-          @name_to_role_mapping[role][shard] = pool_config
+          @role_to_shard_mapping[role][shard] = pool_config
         else
           raise ArgumentError, "The `pool_config` for the :#{role} role and :#{shard} shard was `nil`. Please check your configuration. If you want your writing role to be something other than `:writing` set `config.active_record.writing_role` in your application configuration. The same setting should be applied for the `reading_role` if applicable."
         end

data/lib/active_record/connection_adapters/postgresql/column.rb

@@ -1,23 +1,30 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/blank"
-
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       class Column < ConnectionAdapters::Column # :nodoc:
         delegate :oid, :fmod, to: :sql_type_metadata
 
-        def initialize(*, serial: nil, generated: nil, **)
+        def initialize(*, serial: nil, identity: nil, generated: nil, **)
           super
           @serial = serial
+          @identity = identity
           @generated = generated
         end
 
+        def identity?
+          @identity
+        end
+
         def serial?
           @serial
         end
 
+        def auto_incremented_by_db?
+          serial? || identity?
+        end
+
         def virtual?
           # We assume every generated column is virtual, no matter the concrete type
           @generated.present?
@@ -42,12 +49,14 @@ module ActiveRecord
 
         def init_with(coder)
           @serial = coder["serial"]
+          @identity = coder["identity"]
           @generated = coder["generated"]
           super
         end
 
         def encode_with(coder)
           coder["serial"] = @serial
+          coder["identity"] = @identity
           coder["generated"] = @generated
           super
         end
@@ -55,6 +64,7 @@ module ActiveRecord
         def ==(other)
           other.is_a?(Column) &&
             super &&
+            identity? == other.identity? &&
             serial? == other.serial?
         end
         alias :eql? :==
@@ -62,6 +72,7 @@ module ActiveRecord
         def hash
           Column.hash ^
             super.hash ^
+            identity?.hash ^
             serial?.hash
         end
       end

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

@@ -4,19 +4,22 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module DatabaseStatements
-        def explain(arel, binds = [])
-          sql = "EXPLAIN #{to_sql(arel, binds)}"
-          PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN", binds))
+        def explain(arel, binds = [], options = [])
+          sql    = build_explain_clause(options) + " " + to_sql(arel, binds)
+          result = internal_exec_query(sql, "EXPLAIN", binds)
+          PostgreSQL::ExplainPrettyPrinter.new.pp(result)
         end
 
         # Queries the database and returns the results in an Array-like object
         def query(sql, name = nil) # :nodoc:
-          materialize_transactions
           mark_transaction_written_if_write(sql)
 
-          log(sql, name) do
-            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              @connection.async_exec(sql).map_types!(@type_map_for_results).values
+          log(sql, name) do |notification_payload|
+            with_raw_connection do |conn|
+              result = conn.async_exec(sql).map_types!(@type_map_for_results).values
+              verified!
+              notification_payload[:row_count] = result.count
+              result
             end
           end
         end
@@ -34,24 +37,33 @@ module ActiveRecord
 
         # Executes an SQL statement, returning a PG::Result object on success
         # or raising a PG::Error exception otherwise.
+        #
+        # Setting +allow_retry+ to true causes the db to reconnect and retry
+        # executing the SQL statement in case of a connection-related exception.
+        # This option should only be enabled for known idempotent queries.
+        #
         # Note: the PG::Result object is manually memory managed; if you don't
         # need it specifically, you may want consider the <tt>exec_query</tt> wrapper.
-        def execute(sql, name = nil)
-          sql = transform_query(sql)
-          check_if_write_query(sql)
-
-          materialize_transactions
-          mark_transaction_written_if_write(sql)
+        def execute(...) # :nodoc:
+          super
+        ensure
+          @notice_receiver_sql_warnings = []
+        end
 
-          log(sql, name) do
-            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              @connection.async_exec(sql)
+        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+          log(sql, name, async: async) do |notification_payload|
+            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+              result = conn.async_exec(sql)
+              verified!
+              handle_warnings(result)
+              notification_payload[:row_count] = result.count
+              result
             end
           end
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:
-          execute_and_clear(sql, name, binds, prepare: prepare, async: async) do |result|
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true) # :nodoc:
+          execute_and_clear(sql, name, binds, prepare: prepare, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |result|
             types = {}
             fields = result.fields
             fields.each_with_index do |fname, i|
@@ -59,7 +71,7 @@ module ActiveRecord
               fmod  = result.fmod i
               types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
             end
-            build_result(columns: fields, rows: result.values, column_types: types)
+            build_result(columns: fields, rows: result.values, column_types: types.freeze)
           end
         end
 
@@ -68,26 +80,11 @@ module ActiveRecord
         end
         alias :exec_update :exec_delete
 
-        def sql_for_insert(sql, pk, binds) # :nodoc:
-          if pk.nil?
-            # Extract the table from the insert sql. Yuck.
-            table_ref = extract_table_ref_from_insert_sql(sql)
-            pk = primary_key(table_ref) if table_ref
-          end
-
-          if pk = suppress_composite_primary_key(pk)
-            sql = "#{sql} RETURNING #{quote_column_name(pk)}"
-          end
-
-          super
-        end
-        private :sql_for_insert
-
-        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil) # :nodoc:
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
           if use_insert_returning? || pk == false
             super
           else
-            result = exec_query(sql, name, binds)
+            result = internal_exec_query(sql, name, binds)
             unless sequence_name
               table_ref = extract_table_ref_from_insert_sql(sql)
               if table_ref
@@ -103,33 +100,76 @@ module ActiveRecord
 
         # Begins a transaction.
         def begin_db_transaction # :nodoc:
-          execute("BEGIN", "TRANSACTION")
+          internal_execute("BEGIN", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         end
 
         def begin_isolated_db_transaction(isolation) # :nodoc:
-          begin_db_transaction
-          execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
+          internal_execute("BEGIN ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         end
 
         # Commits a transaction.
         def commit_db_transaction # :nodoc:
-          execute("COMMIT", "TRANSACTION")
+          internal_execute("COMMIT", "TRANSACTION", allow_retry: false, materialize_transactions: true)
         end
 
         # Aborts a transaction.
         def exec_rollback_db_transaction # :nodoc:
-          execute("ROLLBACK", "TRANSACTION")
+          cancel_any_running_query
+          internal_execute("ROLLBACK", "TRANSACTION", allow_retry: false, materialize_transactions: true)
+        end
+
+        def exec_restart_db_transaction # :nodoc:
+          cancel_any_running_query
+          internal_execute("ROLLBACK AND CHAIN", "TRANSACTION", allow_retry: false, materialize_transactions: true)
         end
 
         # From https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-CURRENT
-        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP").freeze # :nodoc:
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP", retryable: true).freeze # :nodoc:
         private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
 
         def high_precision_current_timestamp
           HIGH_PRECISION_CURRENT_TIMESTAMP
         end
 
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
+
+          "EXPLAIN (#{options.join(", ").upcase})"
+        end
+
+        # Set when constraints will be checked for the current transaction.
+        #
+        # Not passing any specific constraint names will set the value for all deferrable constraints.
+        #
+        # [<tt>deferred</tt>]
+        #   Valid values are +:deferred+ or +:immediate+.
+        #
+        # See https://www.postgresql.org/docs/current/sql-set-constraints.html
+        def set_constraints(deferred, *constraints)
+          unless %i[deferred immediate].include?(deferred)
+            raise ArgumentError, "deferred must be :deferred or :immediate"
+          end
+
+          constraints = if constraints.empty?
+            "ALL"
+          else
+            constraints.map { |c| quote_table_name(c) }.join(", ")
+          end
+          execute("SET CONSTRAINTS #{constraints} #{deferred.to_s.upcase}")
+        end
+
         private
+          IDLE_TRANSACTION_STATUSES = [PG::PQTRANS_IDLE, PG::PQTRANS_INTRANS, PG::PQTRANS_INERROR]
+          private_constant :IDLE_TRANSACTION_STATUSES
+
+          def cancel_any_running_query
+            return if @raw_connection.nil? || IDLE_TRANSACTION_STATUSES.include?(@raw_connection.transaction_status)
+
+            @raw_connection.cancel
+            @raw_connection.block
+          rescue PG::Error
+          end
+
           def execute_batch(statements, name = nil)
             execute(combine_multi_statements(statements))
           end
@@ -140,12 +180,29 @@ module ActiveRecord
 
           # Returns the current ID of a table's sequence.
           def last_insert_id_result(sequence_name)
-            exec_query("SELECT currval(#{quote(sequence_name)})", "SQL")
+            internal_exec_query("SELECT currval(#{quote(sequence_name)})", "SQL")
+          end
+
+          def returning_column_values(result)
+            result.rows.first
           end
 
           def suppress_composite_primary_key(pk)
             pk unless pk.is_a?(Array)
           end
+
+          def handle_warnings(sql)
+            @notice_receiver_sql_warnings.each do |warning|
+              next if warning_ignored?(warning)
+
+              warning.sql = sql
+              ActiveRecord.db_warnings_action.call(warning)
+            end
+          end
+
+          def warning_ignored?(warning)
+            ["WARNING", "ERROR", "FATAL", "PANIC"].exclude?(warning.level) || super
+          end
       end
     end
   end

data/lib/active_record/connection_adapters/postgresql/oid/cidr.rb

@@ -28,6 +28,12 @@ module ActiveRecord
             end
           end
 
+          # TODO: Remove when IPAddr#== compares IPAddr#prefix. See
+          # https://github.com/ruby/ipaddr/issues/21
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            !old_value.eql?(new_value) || !old_value.nil? && old_value.prefix != new_value.prefix
+          end
+
           def cast_value(value)
             if value.nil?
               nil