activerecord 7.0.8.6 → 7.2.2.1

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogy
+      module DatabaseStatements
+        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, allow_retry: allow_retry)
+          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)
+
+          sql, _binds = sql_for_insert(sql, pk, binds, returning)
+          raw_execute(sql, 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 |notification_payload|
+              with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+                sync_timezone_changes(conn)
+                result = conn.query(sql)
+                while conn.more_results_exist?
+                  conn.next_result
+                end
+                verified!
+                handle_warnings(sql)
+                notification_payload[:row_count] = result.count
+                result
+              end
+            end
+          end
+
+          def last_inserted_id(result)
+            if supports_insert_returning?
+              super
+            else
+              result.last_insert_id
+            end
+          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)
+              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) if active?
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/abstract_mysql_adapter"
+
+gem "trilogy", "~> 2.7"
+require "trilogy"
+
+require "active_record/connection_adapters/trilogy/database_statements"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TrilogyAdapter < AbstractMysqlAdapter
+      ER_BAD_DB_ERROR = 1049
+      ER_DBACCESS_DENIED_ERROR = 1044
+      ER_ACCESS_DENIED_ERROR = 1045
+
+      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::Error => 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
+
+      def initialize(config, *)
+        config = config.dup
+
+        # 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]
+
+        # 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) }
+
+      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 connected?
+        !(@raw_connection.nil? || @raw_connection.closed?)
+      end
+
+      def active?
+        connected? && @lock.synchronize { @raw_connection&.ping } || false
+      rescue ::Trilogy::Error
+        false
+      end
+
+      alias reset! reconnect!
+
+      def disconnect!
+        @lock.synchronize do
+          super
+          @raw_connection&.close
+          @raw_connection = nil
+        end
+      end
+
+      def discard!
+        @lock.synchronize do
+          super
+          @raw_connection&.discard!
+          @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 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 connect
+          @raw_connection = self.class.new_client(@config)
+        rescue ConnectionNotEstablished => ex
+          raise ex.set_pool(@pool)
+        end
+
+        def reconnect
+          @raw_connection&.close
+          @raw_connection = nil
+          connect
+        end
+
+        def full_version
+          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
+
+          case exception
+          when ::Trilogy::ConnectionClosed, ::Trilogy::EOFError
+            return ConnectionFailed.new(message, connection_pool: @pool)
+          when ::Trilogy::Error
+            if exception.is_a?(SystemCallError) || exception.message.include?("TRILOGY_INVALID_SEQUENCE_ID")
+              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

@@ -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
@@ -11,14 +132,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