activerecord 7.1.3.2 → 7.2.0.beta1

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

@@ -12,12 +12,12 @@ module ActiveRecord
           result
         end
 
-        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false) # :nodoc:
           sql = transform_query(sql)
           check_if_write_query(sql)
           mark_transaction_written_if_write(sql)
 
-          result = raw_execute(sql, name, async: async)
+          result = raw_execute(sql, name, async: async, allow_retry: allow_retry)
           ActiveRecord::Result.new(result.fields, result.to_a)
         end
 
@@ -26,7 +26,8 @@ module ActiveRecord
           check_if_write_query(sql)
           mark_transaction_written_if_write(sql)
 
-          raw_execute(to_sql(sql, binds), name)
+          sql, _binds = sql_for_insert(sql, pk, binds, returning)
+          raw_execute(sql, name)
         end
 
         def exec_delete(sql, name = nil, binds = []) # :nodoc:
@@ -42,19 +43,24 @@ module ActiveRecord
 
         private
           def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
-            log(sql, name, async: async) do
+            log(sql, name, async: async) do |notification_payload|
               with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
                 sync_timezone_changes(conn)
                 result = conn.query(sql)
                 verified!
                 handle_warnings(sql)
+                notification_payload[:row_count] = result.count
                 result
               end
             end
           end
 
           def last_inserted_id(result)
-            result.last_insert_id
+            if supports_insert_returning?
+              super
+            else
+              result.last_insert_id
+            end
           end
 
           def sync_timezone_changes(conn)
@@ -90,7 +96,7 @@ module ActiveRecord
 
               yield
             ensure
-              conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF)
+              conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF) if active?
             end
           end
       end

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -2,44 +2,17 @@
 
 require "active_record/connection_adapters/abstract_mysql_adapter"
 
-gem "trilogy", "~> 2.4"
+gem "trilogy", "~> 2.7"
 require "trilogy"
 
 require "active_record/connection_adapters/trilogy/database_statements"
 
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    def trilogy_adapter_class
-      ConnectionAdapters::TrilogyAdapter
-    end
-
-    # Establishes a connection to the database that's used by all Active Record objects.
-    def trilogy_connection(config)
-      configuration = config.dup
-
-      # Set FOUND_ROWS capability on the connection so UPDATE queries returns number of rows
-      # matched rather than number of rows updated.
-      configuration[:found_rows] = true
-
-      options = [
-        configuration[:host],
-        configuration[:port],
-        configuration[:database],
-        configuration[:username],
-        configuration[:password],
-        configuration[:socket],
-        0
-      ]
-
-      trilogy_adapter_class.new nil, logger, options, configuration
-    end
-  end
   module ConnectionAdapters
     class TrilogyAdapter < AbstractMysqlAdapter
       ER_BAD_DB_ERROR = 1049
       ER_DBACCESS_DENIED_ERROR = 1044
       ER_ACCESS_DENIED_ERROR = 1045
-      ER_SERVER_SHUTDOWN = 1053
 
       ADAPTER_NAME = "Trilogy"
 
@@ -99,12 +72,22 @@ module ActiveRecord
           end
       end
 
-      def initialize(...)
-        super
+      def initialize(config, *)
+        config = config.dup
 
-        # Trilogy ignore `socket` if `host is set. We want the opposite to allow
+        # Trilogy ignores `socket` if `host is set. We want the opposite to allow
         # configuring UNIX domain sockets via `DATABASE_URL`.
-        @config.delete(:host) if @config[:socket]
+        config.delete(:host) if config[:socket]
+
+        # Set FOUND_ROWS capability on the connection so UPDATE queries returns number of rows
+        # matched rather than number of rows updated.
+        config[:found_rows] = true
+
+        if config[:prepared_statements]
+          raise ArgumentError, "Trilogy currently doesn't support prepared statements. Remove `prepared_statements: true` from your database configuration."
+        end
+
+        super
       end
 
       TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
@@ -133,14 +116,12 @@ module ActiveRecord
         true
       end
 
-      def quote_string(string)
-        with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
-          conn.escape(string)
-        end
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.closed?)
       end
 
       def active?
-        connection&.ping || false
+        connected? && @lock.synchronize { @raw_connection&.ping } || false
       rescue ::Trilogy::Error
         false
       end
@@ -148,18 +129,18 @@ module ActiveRecord
       alias reset! reconnect!
 
       def disconnect!
-        super
-        unless connection.nil?
-          connection.close
-          self.connection = nil
+        @lock.synchronize do
+          super
+          @raw_connection&.close
+          @raw_connection = nil
         end
       end
 
       def discard!
-        super
-        unless connection.nil?
-          connection.discard!
-          self.connection = nil
+        @lock.synchronize do
+          super
+          @raw_connection&.discard!
+          @raw_connection = nil
         end
       end
 
@@ -189,28 +170,20 @@ module ActiveRecord
           exception.error_code if exception.respond_to?(:error_code)
         end
 
-        def connection
-          @raw_connection
-        end
-
-        def connection=(conn)
-          @raw_connection = conn
-        end
-
         def connect
-          self.connection = self.class.new_client(@config)
+          @raw_connection = self.class.new_client(@config)
         rescue ConnectionNotEstablished => ex
           raise ex.set_pool(@pool)
         end
 
         def reconnect
-          connection&.close
-          self.connection = nil
+          @raw_connection&.close
+          @raw_connection = nil
           connect
         end
 
         def full_version
-          schema_cache.database_version.full_version_string
+          database_version.full_version_string
         end
 
         def get_full_version
@@ -223,18 +196,12 @@ module ActiveRecord
           if exception.is_a?(::Trilogy::TimeoutError) && !exception.error_code
             return ActiveRecord::AdapterTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
           end
-          error_code = exception.error_code if exception.respond_to?(:error_code)
-
-          case error_code
-          when ER_SERVER_SHUTDOWN
-            return ConnectionFailed.new(message, connection_pool: @pool)
-          end
 
           case exception
-          when Errno::EPIPE, SocketError, IOError
+          when ::Trilogy::ConnectionClosed, ::Trilogy::EOFError
             return ConnectionFailed.new(message, connection_pool: @pool)
           when ::Trilogy::Error
-            if /Connection reset by peer|TRILOGY_CLOSED_CONNECTION|TRILOGY_INVALID_SEQUENCE_ID|TRILOGY_UNEXPECTED_PACKET/.match?(exception.message)
+            if exception.is_a?(SystemCallError) || exception.message.include?("TRILOGY_INVALID_SEQUENCE_ID")
               return ConnectionFailed.new(message, connection_pool: @pool)
             end
           end

data/lib/active_record/connection_adapters.rb

@@ -1,9 +1,130 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/string/filters"
+
 module ActiveRecord
   module ConnectionAdapters
     extend ActiveSupport::Autoload
 
+    @adapters = {}
+
+    class << self
+      # Registers a custom database adapter.
+      #
+      # Can also be used to define aliases.
+      #
+      # == Example
+      #
+      #   ActiveRecord::ConnectionAdapters.register("megadb", "MegaDB::ActiveRecordAdapter", "mega_db/active_record_adapter")
+      #
+      #   ActiveRecord::ConnectionAdapters.register("mysql", "ActiveRecord::ConnectionAdapters::TrilogyAdapter", "active_record/connection_adapters/trilogy_adapter")
+      #
+      def register(name, class_name, path = class_name.underscore)
+        @adapters[name.to_s] = [class_name, path]
+      end
+
+      def resolve(adapter_name) # :nodoc:
+        # Require the adapter itself and give useful feedback about
+        #   1. Missing adapter gems.
+        #   2. Incorrectly registered adapters.
+        #   3. Adapter gems' missing dependencies.
+        class_name, path_to_adapter = @adapters[adapter_name.to_s]
+
+        unless class_name
+          # To provide better error messages for adapters expecting the pre-7.2 adapter registration API, we attempt
+          # to load the adapter file from the old location which was required by convention, and then raise an error
+          # describing how to upgrade the adapter to the new API.
+          legacy_adapter_path = "active_record/connection_adapters/#{adapter_name}_adapter"
+          legacy_adapter_connection_method_name = "#{adapter_name}_connection".to_sym
+
+          begin
+            require legacy_adapter_path
+            # If we reach here it means we found the found a file that may be the legacy adapter and should raise.
+            if ActiveRecord::ConnectionHandling.method_defined?(legacy_adapter_connection_method_name)
+              # If we find the connection method then we care certain it is a legacy adapter.
+              deprecation_message = <<~MSG.squish
+                Database configuration specifies '#{adapter_name}' adapter but that adapter has not been registered.
+                Rails 7.2 has changed the way Active Record database adapters are loaded. The adapter needs to be
+                updated to register itself rather than being loaded by convention.
+                Ensure that the adapter in the Gemfile is at the latest version. If it is, then the adapter may need to
+                be modified.
+                See:
+                https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters.html#method-c-register
+              MSG
+
+              exception_message = <<~MSG.squish
+                Database configuration specifies '#{adapter_name}' adapter but that adapter has not been registered.
+                Ensure that the adapter in the Gemfile is at the latest version. If it is, then the adapter may need to
+                be modified.
+              MSG
+            else
+              # If we do not find the connection method we are much less certain it is a legacy adapter. Even though the
+              # file exists in the location defined by convenntion, it does not necessarily mean that file is supposed
+              # to define the adapter the legacy way. So raise an error that explains both possibilities.
+              deprecation_message = <<~MSG.squish
+                Database configuration specifies nonexistent '#{adapter_name}' adapter.
+                Available adapters are: #{@adapters.keys.sort.join(", ")}.
+                Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+                adapter gem to your Gemfile if it's not in the list of available adapters.
+                Rails 7.2 has changed the way Active Record database adapters are loaded. Ensure that the adapter in
+                the Gemfile is at the latest version. If it is up to date, the adapter may need to be modified.
+                See:
+                https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters.html#method-c-register
+              MSG
+
+              exception_message = <<~MSG.squish
+                Database configuration specifies nonexistent '#{adapter_name}' adapter.
+                Available adapters are: #{@adapters.keys.sort.join(", ")}.
+                Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+                adapter gem to your Gemfile and that it is at its latest version. If it is up to date, the adapter may
+                need to be modified.
+              MSG
+            end
+
+            ActiveRecord.deprecator.warn(deprecation_message)
+            raise AdapterNotFound, exception_message
+          rescue LoadError => error
+            # The adapter was not found in the legacy location so fall through to the error handling for a missing adapter.
+          end
+
+          raise AdapterNotFound, <<~MSG.squish
+            Database configuration specifies nonexistent '#{adapter_name}' adapter.
+            Available adapters are: #{@adapters.keys.sort.join(", ")}.
+            Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+            adapter gem to your Gemfile if it's not in the list of available adapters.
+          MSG
+        end
+
+        unless Object.const_defined?(class_name)
+          begin
+            require path_to_adapter
+          rescue LoadError => error
+            # We couldn't require the adapter itself.
+            if error.path == path_to_adapter
+              # We can assume here that a non-builtin adapter was specified and the path
+              # registered by the adapter gem is incorrect.
+              raise LoadError, "Error loading the '#{adapter_name}' Active Record adapter. Ensure that the path registered by the adapter gem is correct. #{error.message}", error.backtrace
+            else
+              # Bubbled up from the adapter require. Prefix the exception message
+              # with some guidance about how to address it and reraise.
+              raise LoadError, "Error loading the '#{adapter_name}' Active Record adapter. Missing a gem it depends on? #{error.message}", error.backtrace
+            end
+          end
+        end
+
+        begin
+          Object.const_get(class_name)
+        rescue NameError => error
+          raise AdapterNotFound, "Could not load the #{class_name} Active Record adapter (#{error.message})."
+        end
+      end
+    end
+
+    register "sqlite3", "ActiveRecord::ConnectionAdapters::SQLite3Adapter", "active_record/connection_adapters/sqlite3_adapter"
+    register "mysql2", "ActiveRecord::ConnectionAdapters::Mysql2Adapter", "active_record/connection_adapters/mysql2_adapter"
+    register "trilogy", "ActiveRecord::ConnectionAdapters::TrilogyAdapter", "active_record/connection_adapters/trilogy_adapter"
+    register "postgresql", "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter", "active_record/connection_adapters/postgresql_adapter"
+
     eager_autoload do
       autoload :AbstractAdapter
     end

data/lib/active_record/connection_handling.rb

@@ -243,22 +243,64 @@ module ActiveRecord
     # Clears the query cache for all connections associated with the current thread.
     def clear_query_caches_for_current_thread
       connection_handler.each_connection_pool do |pool|
-        pool.connection.clear_query_cache if pool.active_connection?
+        pool.clear_query_cache
       end
     end
 
     # Returns the connection currently associated with the class. This can
     # also be used to "borrow" the connection to do database work unrelated
     # to any of the specific Active Records.
+    # The connection will remain leased for the entire duration of the request
+    # or job, or until +#release_connection+ is called.
+    def lease_connection
+      connection_pool.lease_connection
+    end
+
+    # Soft deprecated. Use +#with_connection+ or +#lease_connection+ instead.
     def connection
-      retrieve_connection
+      pool = connection_pool
+      if pool.permanent_lease?
+        case ActiveRecord.permanent_connection_checkout
+        when :deprecated
+          ActiveRecord.deprecator.warn <<~MESSAGE
+            Called deprecated `ActiveRecord::Base.connection` method.
+
+            Either use `with_connection` or `lease_connection`.
+          MESSAGE
+        when :disallowed
+          raise ActiveRecordError, <<~MESSAGE
+            Called deprecated `ActiveRecord::Base.connection` method.
+
+            Either use `with_connection` or `lease_connection`.
+          MESSAGE
+        end
+        pool.lease_connection
+      else
+        pool.active_connection
+      end
+    end
+
+    # Return the currently leased connection into the pool
+    def release_connection
+      connection_pool.release_connection
+    end
+
+    # Checkouts a connection from the pool, yield it and then check it back in.
+    # If a connection was already leased via #lease_connection or a parent call to
+    # #with_connection, that same connection is yieled.
+    # If #lease_connection is called inside the block, the connection won't be checked
+    # back in.
+    # If #connection is called inside the block, the connection won't be checked back in
+    # unless the +prevent_permanent_checkout+ argument is set to +true+.
+    def with_connection(prevent_permanent_checkout: false, &block)
+      connection_pool.with_connection(prevent_permanent_checkout: prevent_permanent_checkout, &block)
     end
 
     attr_writer :connection_specification_name
 
     # Returns the connection specification name from the current class or its parent.
     def connection_specification_name
-      if !defined?(@connection_specification_name) || @connection_specification_name.nil?
+      if @connection_specification_name.nil?
         return self == Base ? Base.name : superclass.connection_specification_name
       end
       @connection_specification_name
@@ -279,8 +321,12 @@ module ActiveRecord
       connection_pool.db_config
     end
 
+    def adapter_class # :nodoc:
+      connection_pool.db_config.adapter_class
+    end
+
     def connection_pool
-      connection_handler.retrieve_connection_pool(connection_specification_name, role: current_role, shard: current_shard) || raise(ConnectionNotEstablished)
+      connection_handler.retrieve_connection_pool(connection_specification_name, role: current_role, shard: current_shard, strict: true)
     end
 
     def retrieve_connection
@@ -292,16 +338,9 @@ module ActiveRecord
       connection_handler.connected?(connection_specification_name, role: current_role, shard: current_shard)
     end
 
-    def remove_connection(name = nil)
-      if name
-        ActiveRecord.deprecator.warn(<<-MSG.squish)
-          The name argument for `#remove_connection` is deprecated without replacement
-          and will be removed in Rails 7.2. `#remove_connection` should always be called
-          on the connection class directly, which makes the name argument obsolete.
-        MSG
-      end
+    def remove_connection
+      name = @connection_specification_name if defined?(@connection_specification_name)
 
-      name ||= @connection_specification_name if defined?(@connection_specification_name)
       # if removing a connection that has a pool, we reset the
       # connection_specification_name so it will use the parent
       # pool.
@@ -312,39 +351,15 @@ module ActiveRecord
       connection_handler.remove_connection_pool(name, role: current_role, shard: current_shard)
     end
 
-    def clear_cache! # :nodoc:
-      connection.schema_cache.clear!
-    end
-
-    def clear_active_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.clear_active_connections!(role)
-    end
-
-    def clear_reloadable_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.clear_reloadable_connections!(role)
+    def schema_cache # :nodoc:
+      connection_pool.schema_cache
     end
 
-    def clear_all_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.clear_all_connections!(role)
-    end
-
-    def flush_idle_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.flush_idle_connections!(role)
+    def clear_cache! # :nodoc:
+      connection_pool.schema_cache.clear!
     end
 
     private
-      def deprecation_for_delegation(method)
-        ActiveRecord.deprecator.warn(<<-MSG.squish)
-          Calling `ActiveRecord::Base.#{method} is deprecated. Please
-          call the method directly on the connection handler; for
-          example: `ActiveRecord::Base.connection_handler.#{method}`.
-        MSG
-      end
-
       def resolve_config_for_connection(config_or_env)
         raise "Anonymous class is not allowed." unless name