activerecord 6.1.7 → 7.1.0

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,62 +1,80 @@
 # 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:
+    def mysql2_adapter_class
+      ConnectionAdapters::Mysql2Adapter
+    end
+
     # 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,
-      )
+      mysql2_adapter_class.new(config)
     end
   end
 
   module ConnectionAdapters
+    # = Active Record MySQL2 Adapter
     class Mysql2Adapter < AbstractMysqlAdapter
-      ER_BAD_DB_ERROR = 1049
+      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
-            raise ActiveRecord::NoDatabaseError
+          ::Mysql2::Client.new(config)
+        rescue ::Mysql2::Error => error
+          case error.error_number
+          when ER_BAD_DB_ERROR
+            raise ActiveRecord::NoDatabaseError.db_error(config[:database])
+          when ER_DBACCESS_DENIED_ERROR, ER_ACCESS_DENIED_ERROR
+            raise ActiveRecord::DatabaseConnectionError.username_error(config[:username])
+          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?
@@ -75,17 +93,19 @@ module ActiveRecord
         true
       end
 
+      def savepoint_errors_invalidate_transactions?
+        true
+      end
+
       def supports_lazy_transactions?
         true
       end
 
       # HELPER METHODS ===========================================
 
-      def each_hash(result) # :nodoc:
+      def each_hash(result, &block) # :nodoc:
         if block_given?
-          result.each(as: :hash, symbolize_keys: true) do |row|
-            yield row
-          end
+          result.each(as: :hash, symbolize_keys: true, &block)
         else
           to_enum(:each_hash, result)
         end
@@ -99,10 +119,11 @@ module ActiveRecord
       # QUOTING ==================================================
       #++
 
+      # Quotes strings for use in SQL input.
       def quote_string(string)
-        @connection.escape(string)
-      rescue Mysql2::Error => error
-        raise translate_exception(error, message: error.message, sql: "<escape>", binds: [])
+        with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
+          connection.escape(string)
+        end
       end
 
       #--
@@ -110,37 +131,45 @@ module ActiveRecord
       #++
 
       def active?
-        @connection.ping
+        !!@raw_connection&.ping
       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
+        @raw_connection&.close
+        @raw_connection = nil
       end
 
       def discard! # :nodoc:
         super
-        @connection.automatic_close = false
-        @connection = nil
+        @raw_connection&.automatic_close = false
+        @raw_connection = nil
       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
+          @raw_connection&.close
+          @raw_connection = nil
+          connect
         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
 
@@ -149,16 +178,38 @@ module ActiveRecord
         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

@@ -5,8 +5,13 @@ module ActiveRecord
     class PoolConfig # :nodoc:
       include Mutex_m
 
-      attr_reader :db_config, :connection_klass
-      attr_accessor :schema_cache
+      attr_reader :db_config, :role, :shard
+      attr_writer :schema_reflection
+      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,27 +20,31 @@ 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_klass, db_config)
+      def initialize(connection_class, db_config, role, shard)
         super()
-        @connection_klass = connection_klass
+        @connection_class = connection_class
         @db_config = db_config
+        @role = role
+        @shard = shard
         @pool = nil
         INSTANCES[self] = self
       end
 
-      def connection_specification_name
-        if connection_klass.is_a?(String)
-          connection_klass
-        elsif connection_klass.primary_class?
+      def connection_name
+        if connection_class.primary_class?
           "ActiveRecord::Base"
         else
-          connection_klass.name
+          connection_class.name
         end
       end
 
-      def disconnect!
+      def disconnect!(automatic_reconnect: false)
         ActiveSupport::ForkTracker.check!
 
         return unless @pool
@@ -43,7 +52,7 @@ module ActiveRecord
         synchronize do
           return unless @pool
 
-          @pool.automatic_reconnect = false
+          @pool.automatic_reconnect = automatic_reconnect
           @pool.disconnect!
         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

@@ -6,31 +6,48 @@ module ActiveRecord
       class Column < ConnectionAdapters::Column # :nodoc:
         delegate :oid, :fmod, to: :sql_type_metadata
 
-        def initialize(*, serial: nil, **)
+        def initialize(*, serial: nil, generated: nil, **)
           super
           @serial = serial
+          @generated = generated
         end
 
         def serial?
           @serial
         end
+        alias_method :auto_incremented_by_db?, :serial?
+
+        def virtual?
+          # We assume every generated column is virtual, no matter the concrete type
+          @generated.present?
+        end
+
+        def has_default?
+          super && !virtual?
+        end
 
         def array
           sql_type_metadata.sql_type.end_with?("[]")
         end
         alias :array? :array
 
+        def enum?
+          type == :enum
+        end
+
         def sql_type
           super.delete_suffix("[]")
         end
 
         def init_with(coder)
           @serial = coder["serial"]
+          @generated = coder["generated"]
           super
         end
 
         def encode_with(coder)
           coder["serial"] = @serial
+          coder["generated"] = @generated
           super
         end
 

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

@@ -4,19 +4,19 @@ 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
+        def query(sql, name = nil) # :nodoc:
           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
+            with_raw_connection do |conn|
+              conn.async_exec(sql).map_types!(@type_map_for_results).values
             end
           end
         end
@@ -34,65 +34,52 @@ 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)
-          if preventing_writes? && write_query?(sql)
-            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
-          end
-
-          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
+            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+              result = conn.async_exec(sql)
+              handle_warnings(result)
+              result
             end
           end
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false)
-          execute_and_clear(sql, name, binds, prepare: prepare) 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|
               ftype = result.ftype i
               fmod  = result.fmod i
-              case type = get_oid_type(ftype, fmod, fname)
-              when Type::Integer, Type::Float, OID::Decimal, Type::String, Type::DateTime, Type::Boolean
-                # skip if a column has already been type casted by pg decoders
-              else types[fname] = type
-              end
+              types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
             end
             build_result(columns: fields, rows: result.values, column_types: types)
           end
         end
 
-        def exec_delete(sql, name = nil, binds = [])
+        def exec_delete(sql, name = nil, binds = []) # :nodoc:
           execute_and_clear(sql, name, binds) { |result| result.cmd_tuples }
         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)
+        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
@@ -107,26 +94,56 @@ module ActiveRecord
         end
 
         # Begins a transaction.
-        def begin_db_transaction
-          execute("BEGIN", "TRANSACTION")
+        def begin_db_transaction # :nodoc:
+          internal_execute("BEGIN", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         end
 
-        def begin_isolated_db_transaction(isolation)
-          begin_db_transaction
-          execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
+        def begin_isolated_db_transaction(isolation) # :nodoc:
+          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
-          execute("COMMIT", "TRANSACTION")
+        def commit_db_transaction # :nodoc:
+          internal_execute("COMMIT", "TRANSACTION", allow_retry: false, materialize_transactions: true)
         end
 
         # Aborts a transaction.
-        def exec_rollback_db_transaction
-          execute("ROLLBACK", "TRANSACTION")
+        def exec_rollback_db_transaction # :nodoc:
+          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:
+        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
 
         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
@@ -137,12 +154,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/array.rb

@@ -65,7 +65,7 @@ module ActiveRecord
           end
 
           def map(value, &block)
-            value.map(&block)
+            value.map { |v| subtype.map(v, &block) }
           end
 
           def changed_in_place?(raw_old_value, new_value)

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

@@ -16,6 +16,14 @@ module ActiveRecord
               super
             end
           end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
         end
       end
     end

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

@@ -24,6 +24,11 @@ module ActiveRecord
             else super
             end
           end
+
+          protected
+            def real_type_unless_aliased(real_type)
+              ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type == real_type ? :datetime : real_type
+            end
         end
       end
     end