activerecord 7.0.8 → 7.1.0

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogy
+      module DatabaseStatements
+        def select_all(*, **) # :nodoc:
+          result = super
+          with_raw_connection do |conn|
+            conn.next_result while conn.more_results_exist?
+          end
+          result
+        end
+
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:
+          sql = transform_query(sql)
+          check_if_write_query(sql)
+          mark_transaction_written_if_write(sql)
+
+          result = raw_execute(sql, name, async: async)
+          ActiveRecord::Result.new(result.fields, result.to_a)
+        end
+
+        def exec_insert(sql, name, binds, pk = nil, sequence_name = nil, returning: nil) # :nodoc:
+          sql = transform_query(sql)
+          check_if_write_query(sql)
+          mark_transaction_written_if_write(sql)
+
+          raw_execute(to_sql(sql, binds), name)
+        end
+
+        def exec_delete(sql, name = nil, binds = []) # :nodoc:
+          sql = transform_query(sql)
+          check_if_write_query(sql)
+          mark_transaction_written_if_write(sql)
+
+          result = raw_execute(to_sql(sql, binds), name)
+          result.affected_rows
+        end
+
+        alias :exec_update :exec_delete # :nodoc:
+
+        private
+          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|
+                sync_timezone_changes(conn)
+                result = conn.query(sql)
+                handle_warnings(sql)
+                result
+              end
+            end
+          end
+
+          def last_inserted_id(result)
+            result.last_insert_id
+          end
+
+          def sync_timezone_changes(conn)
+            # Sync any changes since connection last established.
+            if default_timezone == :local
+              conn.query_flags |= ::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
+            else
+              conn.query_flags &= ~::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
+            end
+          end
+
+          def execute_batch(statements, name = nil)
+            statements = statements.map { |sql| transform_query(sql) }
+            combine_multi_statements(statements).each do |statement|
+              with_raw_connection do |conn|
+                raw_execute(statement, name)
+                conn.next_result while conn.more_results_exist?
+              end
+            end
+          end
+
+          def multi_statements_enabled?
+            !!@config[:multi_statement]
+          end
+
+          def with_multi_statements
+            if multi_statements_enabled?
+              return yield
+            end
+
+            with_raw_connection do |conn|
+              conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_ON)
+
+              yield
+            ensure
+              conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/abstract_mysql_adapter"
+
+gem "trilogy", "~> 2.4"
+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"
+
+      include Trilogy::DatabaseStatements
+
+      SSL_MODES = {
+        SSL_MODE_DISABLED: ::Trilogy::SSL_DISABLED,
+        SSL_MODE_PREFERRED: ::Trilogy::SSL_PREFERRED_NOVERIFY,
+        SSL_MODE_REQUIRED: ::Trilogy::SSL_REQUIRED_NOVERIFY,
+        SSL_MODE_VERIFY_CA: ::Trilogy::SSL_VERIFY_CA,
+        SSL_MODE_VERIFY_IDENTITY: ::Trilogy::SSL_VERIFY_IDENTITY
+      }.freeze
+
+      class << self
+        def new_client(config)
+          config[:ssl_mode] = parse_ssl_mode(config[:ssl_mode]) if config[:ssl_mode]
+          ::Trilogy.new(config)
+        rescue ::Trilogy::ConnectionError, ::Trilogy::ProtocolError => error
+          raise translate_connect_error(config, error)
+        end
+
+        def parse_ssl_mode(mode)
+          return mode if mode.is_a? Integer
+
+          m = mode.to_s.upcase
+          m = "SSL_MODE_#{m}" unless m.start_with? "SSL_MODE_"
+
+          SSL_MODES.fetch(m.to_sym, mode)
+        end
+
+        def translate_connect_error(config, error)
+          case error.error_code
+          when ER_DBACCESS_DENIED_ERROR, ER_BAD_DB_ERROR
+            ActiveRecord::NoDatabaseError.db_error(config[:database])
+          when ER_ACCESS_DENIED_ERROR
+            ActiveRecord::DatabaseConnectionError.username_error(config[:username])
+          else
+            if error.message.include?("TRILOGY_DNS_ERROR")
+              ActiveRecord::DatabaseConnectionError.hostname_error(config[:host])
+            else
+              ActiveRecord::ConnectionNotEstablished.new(error.message)
+            end
+          end
+        end
+
+        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: :trilogy, limit: limit)
+            end
+
+            m.register_type %r(^enum)i, Type.lookup(:string, adapter: :trilogy)
+            m.register_type %r(^set)i,  Type.lookup(:string, adapter: :trilogy)
+          end
+      end
+
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
+      def supports_json?
+        !mariadb? && database_version >= "5.7.8"
+      end
+
+      def supports_comments?
+        true
+      end
+
+      def supports_comments_in_create?
+        true
+      end
+
+      def supports_savepoints?
+        true
+      end
+
+      def savepoint_errors_invalidate_transactions?
+        true
+      end
+
+      def supports_lazy_transactions?
+        true
+      end
+
+      def quote_string(string)
+        with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+          conn.escape(string)
+        end
+      end
+
+      def active?
+        connection&.ping || false
+      rescue ::Trilogy::Error
+        false
+      end
+
+      alias reset! reconnect!
+
+      def disconnect!
+        super
+        unless connection.nil?
+          connection.close
+          self.connection = nil
+        end
+      end
+
+      def discard!
+        super
+        unless connection.nil?
+          connection.discard!
+          self.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 each_hash(result)
+          return to_enum(:each_hash, result) unless block_given?
+
+          keys = result.fields.map(&:to_sym)
+          result.rows.each do |row|
+            hash = {}
+            idx = 0
+            row.each do |value|
+              hash[keys[idx]] = value
+              idx += 1
+            end
+            yield hash
+          end
+
+          nil
+        end
+
+        def error_number(exception)
+          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)
+        rescue ConnectionNotEstablished => ex
+          raise ex.set_pool(@pool)
+        end
+
+        def reconnect
+          connection&.close
+          self.connection = nil
+          connect
+        end
+
+        def full_version
+          schema_cache.database_version.full_version_string
+        end
+
+        def get_full_version
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.server_info[:version]
+          end
+        end
+
+        def translate_exception(exception, message:, sql:, binds:)
+          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
+            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)
+              return ConnectionFailed.new(message, connection_pool: @pool)
+            end
+          end
+
+          super
+        end
+
+        def default_prepared_statements
+          false
+        end
+
+        ActiveRecord::Type.register(:immutable_string, adapter: :trilogy) do |_, **args|
+          Type::ImmutableString.new(true: "1", false: "0", **args)
+        end
+
+        ActiveRecord::Type.register(:string, adapter: :trilogy) do |_, **args|
+          Type::String.new(true: "1", false: "0", **args)
+        end
+
+        ActiveRecord::Type.register(:unsigned_integer, Type::UnsignedInteger, adapter: :trilogy)
+    end
+
+    ActiveSupport.run_load_hooks(:active_record_trilogyadapter, TrilogyAdapter)
+  end
+end

data/lib/active_record/connection_adapters.rb

@@ -11,14 +11,16 @@ module ActiveRecord
     autoload :Column
     autoload :PoolConfig
     autoload :PoolManager
-    autoload :LegacyPoolManager
     autoload :SchemaCache
+    autoload :BoundSchemaReflection, "active_record/connection_adapters/schema_cache"
+    autoload :SchemaReflection, "active_record/connection_adapters/schema_cache"
     autoload :Deduplicable
 
     autoload_at "active_record/connection_adapters/abstract/schema_definitions" do
       autoload :IndexDefinition
       autoload :ColumnDefinition
       autoload :ChangeColumnDefinition
+      autoload :ChangeColumnDefaultDefinition
       autoload :ForeignKeyDefinition
       autoload :CheckConstraintDefinition
       autoload :TableDefinition

data/lib/active_record/connection_handling.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord
+  # = Active Record Connection Handling
   module ConnectionHandling
     RAILS_ENV   = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence }
     DEFAULT_ENV = -> { RAILS_ENV.call || "default_env" }
@@ -38,7 +39,7 @@ module ActiveRecord
     #   )
     #
     # In case {ActiveRecord::Base.configurations}[rdoc-ref:Core.configurations]
-    # is set (Rails automatically loads the contents of config/database.yml into it),
+    # is set (\Rails automatically loads the contents of config/database.yml into it),
     # a symbol can also be given as argument, representing a key in the
     # configuration hash:
     #
@@ -48,16 +49,15 @@ module ActiveRecord
     # may be returned on an error.
     def establish_connection(config_or_env = nil)
       config_or_env ||= DEFAULT_ENV.call.to_sym
-      db_config, owner_name = resolve_config_for_connection(config_or_env)
-      connection_handler.establish_connection(db_config, owner_name: owner_name, role: current_role, shard: current_shard)
+      db_config = resolve_config_for_connection(config_or_env)
+      connection_handler.establish_connection(db_config, owner_name: self, role: current_role, shard: current_shard)
     end
 
     # Connects a model to the databases specified. The +database+ keyword
     # takes a hash consisting of a +role+ and a +database_key+.
     #
-    # This will create a connection handler for switching between connections,
-    # look up the config hash using the +database_key+ and finally
-    # establishes a connection to that config.
+    # This will look up the database config using the +database_key+ and
+    # establish a connection to that config.
     #
     #   class AnimalsModel < ApplicationRecord
     #     self.abstract_class = true
@@ -66,7 +66,7 @@ module ActiveRecord
     #   end
     #
     # +connects_to+ also supports horizontal sharding. The horizontal sharding API
-    # also supports read replicas. Connect a model to a list of shards like this:
+    # supports read replicas as well. You can connect a model to a list of shards like this:
     #
     #   class AnimalsModel < ApplicationRecord
     #     self.abstract_class = true
@@ -87,21 +87,18 @@ module ActiveRecord
 
       connections = []
 
-      database.each do |role, database_key|
-        db_config, owner_name = resolve_config_for_connection(database_key)
-        handler = lookup_connection_handler(role.to_sym)
-
-        self.connection_class = true
-        connections << handler.establish_connection(db_config, owner_name: owner_name, role: role)
+      if shards.empty?
+        shards[:default] = database
       end
 
+      self.default_shard = shards.keys.first
+
       shards.each do |shard, database_keys|
         database_keys.each do |role, database_key|
-          db_config, owner_name = resolve_config_for_connection(database_key)
-          handler = lookup_connection_handler(role.to_sym)
+          db_config = resolve_config_for_connection(database_key)
 
           self.connection_class = true
-          connections << handler.establish_connection(db_config, owner_name: owner_name, role: role, shard: shard.to_sym)
+          connections << connection_handler.establish_connection(db_config, owner_name: self, role: role, shard: shard.to_sym)
         end
       end
 
@@ -135,18 +132,12 @@ module ActiveRecord
     #     Dog.first # finds first Dog record stored on the shard one replica
     #   end
     def connected_to(role: nil, shard: nil, prevent_writes: false, &blk)
-      if ActiveRecord.legacy_connection_handling
-        if self != Base
-          raise NotImplementedError, "`connected_to` can only be called on ActiveRecord::Base with legacy connection handling."
-        end
-      else
-        if self != Base && !abstract_class
-          raise NotImplementedError, "calling `connected_to` is only allowed on ActiveRecord::Base or abstract classes."
-        end
+      if self != Base && !abstract_class
+        raise NotImplementedError, "calling `connected_to` is only allowed on ActiveRecord::Base or abstract classes."
+      end
 
-        if name != connection_specification_name && !primary_class?
-          raise NotImplementedError, "calling `connected_to` is only allowed on the abstract class that established the connection."
-        end
+      if !connection_class? && !primary_class?
+        raise NotImplementedError, "calling `connected_to` is only allowed on the abstract class that established the connection."
       end
 
       unless role || shard
@@ -172,10 +163,6 @@ module ActiveRecord
     def connected_to_many(*classes, role:, shard: nil, prevent_writes: false)
       classes = classes.flatten
 
-      if ActiveRecord.legacy_connection_handling
-        raise NotImplementedError, "connected_to_many is not available with legacy connection handling"
-      end
-
       if self != Base || classes.include?(Base)
         raise NotImplementedError, "connected_to_many can only be called on ActiveRecord::Base."
       end
@@ -196,10 +183,6 @@ module ActiveRecord
     # It is not recommended to use this method in a request since it
     # does not yield to a block like +connected_to+.
     def connecting_to(role: default_role, shard: default_shard, prevent_writes: false)
-      if ActiveRecord.legacy_connection_handling
-        raise NotImplementedError, "`connecting_to` is not available with `legacy_connection_handling`."
-      end
-
       prevent_writes = true if role == ActiveRecord.reading_role
 
       append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
@@ -236,40 +219,31 @@ module ActiveRecord
     # See +READ_QUERY+ for the queries that are blocked by this
     # method.
     def while_preventing_writes(enabled = true, &block)
-      if ActiveRecord.legacy_connection_handling
-        connection_handler.while_preventing_writes(enabled, &block)
-      else
-        connected_to(role: current_role, prevent_writes: enabled, &block)
-      end
+      connected_to(role: current_role, prevent_writes: enabled, &block)
     end
 
-    # Returns true if role is the current connected role.
+    # Returns true if role is the current connected role and/or
+    # current connected shard. If no shard is passed, the default will be
+    # used.
     #
     #   ActiveRecord::Base.connected_to(role: :writing) do
     #     ActiveRecord::Base.connected_to?(role: :writing) #=> true
     #     ActiveRecord::Base.connected_to?(role: :reading) #=> false
     #   end
+    #
+    #   ActiveRecord::Base.connected_to(role: :reading, shard: :shard_one) do
+    #     ActiveRecord::Base.connected_to?(role: :reading, shard: :shard_one) #=> true
+    #     ActiveRecord::Base.connected_to?(role: :reading, shard: :default) #=> false
+    #     ActiveRecord::Base.connected_to?(role: :writing, shard: :shard_one) #=> true
+    #   end
     def connected_to?(role:, shard: ActiveRecord::Base.default_shard)
       current_role == role.to_sym && current_shard == shard.to_sym
     end
 
-    def lookup_connection_handler(handler_key) # :nodoc:
-      if ActiveRecord.legacy_connection_handling
-        handler_key ||= ActiveRecord.writing_role
-        connection_handlers[handler_key] ||= ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-      else
-        ActiveRecord::Base.connection_handler
-      end
-    end
-
     # Clears the query cache for all connections associated with the current thread.
     def clear_query_caches_for_current_thread
-      if ActiveRecord.legacy_connection_handling
-        ActiveRecord::Base.connection_handlers.each_value do |handler|
-          clear_on_handler(handler)
-        end
-      else
-        clear_on_handler(ActiveRecord::Base.connection_handler)
+      connection_handler.each_connection_pool do |pool|
+        pool.connection.clear_query_cache if pool.active_connection?
       end
     end
 
@@ -298,7 +272,7 @@ module ActiveRecord
     #
     #  ActiveRecord::Base.connection_db_config
     #    #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10 @env_name="development",
-    #      @name="primary", @config={pool: 5, timeout: 5000, database: "db/development.sqlite3", adapter: "sqlite3"}>
+    #      @name="primary", @config={pool: 5, timeout: 5000, database: "storage/development.sqlite3", adapter: "sqlite3"}>
     #
     # Use only for reading.
     def connection_db_config
@@ -319,6 +293,14 @@ module ActiveRecord
     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
+
       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
@@ -334,47 +316,51 @@ module ActiveRecord
       connection.schema_cache.clear!
     end
 
-    delegate :clear_active_connections!, :clear_reloadable_connections!,
-      :clear_all_connections!, :flush_idle_connections!, to: :connection_handler
+    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)
+    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)
+    end
 
     private
-      def clear_on_handler(handler)
-        handler.all_connection_pools.each do |pool|
-          pool.connection.clear_query_cache if pool.active_connection?
-        end
+      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
 
-        owner_name = primary_class? ? Base.name : name
-        self.connection_specification_name = owner_name
+        connection_name = primary_class? ? Base.name : name
+        self.connection_specification_name = connection_name
 
-        db_config = Base.configurations.resolve(config_or_env)
-        [db_config, self]
-      end
-
-      def with_handler(handler_key, &blk)
-        handler = lookup_connection_handler(handler_key)
-        swap_connection_handler(handler, &blk)
+        Base.configurations.resolve(config_or_env)
       end
 
       def with_role_and_shard(role, shard, prevent_writes)
         prevent_writes = true if role == ActiveRecord.reading_role
 
-        if ActiveRecord.legacy_connection_handling
-          with_handler(role.to_sym) do
-            connection_handler.while_preventing_writes(prevent_writes) do
-              append_to_connected_to_stack(shard: shard, klasses: [self])
-              yield
-            end
-          end
-        else
-          append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
-          return_value = yield
-          return_value.load if return_value.is_a? ActiveRecord::Relation
-          return_value
-        end
+        append_to_connected_to_stack(role: role, shard: shard, prevent_writes: prevent_writes, klasses: [self])
+        return_value = yield
+        return_value.load if return_value.is_a? ActiveRecord::Relation
+        return_value
       ensure
         self.connected_to_stack.pop
       end
@@ -386,14 +372,5 @@ module ActiveRecord
 
         connected_to_stack << entry
       end
-
-      def swap_connection_handler(handler, &blk) # :nodoc:
-        old_handler, ActiveRecord::Base.connection_handler = ActiveRecord::Base.connection_handler, handler
-        return_value = yield
-        return_value.load if return_value.is_a? ActiveRecord::Relation
-        return_value
-      ensure
-        ActiveRecord::Base.connection_handler = old_handler
-      end
   end
 end