activerecord-trilogy-adapter 3.0.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 778687330e4ff0e83f8cf02ea27808b9e7197c625312611c0dd004d17627a29e
-  data.tar.gz: f3ddf11ab50accd31b5bd3a4b41899a781f4ac04555739d1e65eff3e884b8b38
+  metadata.gz: 0a3a2190bc8818bad95cf334d7e4b0c9108a9520f37a899ff356f36b2c067ef1
+  data.tar.gz: bf58ccfed24d5a7ecd17f6670d4a6fb623e27f862cbcbb87b408470b46fa44c0
 SHA512:
-  metadata.gz: 7b2e8b370f301aeda40bef4e1a66c16dc0351b245a5c967341a22e1ab05830e4e11d5cd1de2de2e38a246cbd5fb492e27d8e906770d4484707512a34e9d8430c
-  data.tar.gz: 3471e795e4942858134083a06f632da5afebb69c60a87001631486c79ecb81dc3f90e5c5cbdf5eb408c48ca125f47055ca8c08c0af945324e1043aa7996b104e
+  metadata.gz: 0b0991df8962bdfbe7d917aac03f224cbe919a3cef9113c39f1eab150d207c04b4a7db457404d492d3bb0e5b0e459d353f7511a1e82d7ff92c804d02353a8c34
+  data.tar.gz: 44a43a09ad1230250f29da21e941bc59a8f2d606f0716c7fc045ffba0b457e029fe01b34fade384b33277f06f2667cb8498c9b895fc7fce3461f7f07afacf332

data/README.md

@@ -1,27 +1,34 @@
 # Trilogy Adapter
 
-Active Record database adapter for [Trilogy](https://github.com/trilogy-libraries/trilogy)
+Ruby on Rails Active Record database adapter for [Trilogy](https://github.com/trilogy-libraries/trilogy), a client library for MySQL-compatible database servers, designed for performance, flexibility, and ease of embedding.
 
-This gem offers Trilogy support for versions of ActiveRecord prior to 7.1. Currently supports:
+This gem offers Trilogy support for versions of Active Record prior to v7.1. Currently supports:
 
-- Rails v7.0.x
+- ⚠️ Rails v7.1+ includes Trilogy support by default making this gem unnecessary
+- ✅ Rails v7.0.x
+- ✅ Rails v6.1.x
+- ✅ Rails v6.0.x
 
 ## Requirements
 
-- [Ruby](https://www.ruby-lang.org) 2.7 or higher
-- [Active Record](https://github.com/rails/rails) 7.0.x
-- [Trilogy](https://github.com/trilogy-libraries/trilogy) 2.4.0 or higher
+- [Ruby](https://www.ruby-lang.org) v2.7 or higher
+- [Active Record](https://github.com/rails/rails) v6.0.x or higher
+- [Trilogy](https://github.com/trilogy-libraries/trilogy) v2.4.0 or higher, which is included as a dependency of this gem.
 
 ## Setup
 
-* Add the following to your Gemfile:
+1. Add the following to your `Gemfile` and run `bundle install`:
 
-  ```rb
-  gem "activerecord-trilogy-adapter"
-  ```
+    ```rb
+    # Gemfile
+    gem "activerecord-trilogy-adapter"
+    ```
+2. Update your application's database configuration to use `trilogy` as the adapter:
 
-* Update your database configuration (e.g. `config/database.yml`) to use
-  `trilogy` as the adapter.
+   ```yaml
+   # config/database.yml
+   adapter: trilogy
+   ```
 
 ## Versioning
 

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogy
+      module DatabaseStatements
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :desc, :describe, :set, :show, :use
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP(6)").freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+        def execute(sql, name = nil, **kwargs)
+          sql = transform_query(sql)
+          check_if_write_query(sql)
+          mark_transaction_written_if_write(sql)
+
+          result = raw_execute(sql, name, **kwargs)
+          ActiveRecord::Result.new(result.fields, result.to_a)
+        end
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
+        end
+
+        def explain(arel, binds = [])
+          sql     = "EXPLAIN #{to_sql(arel, binds)}"
+          start   = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result  = internal_exec_query(sql, "EXPLAIN", binds)
+          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+
+          MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
+        end
+
+        def select_all(*, **) # :nodoc:
+          result = super
+          with_trilogy_connection do |conn|
+            conn.next_result while conn.more_results_exist?
+          end
+          result
+        end
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
+        end
+
+        def explain(arel, binds = [], options = [])
+          sql     = build_explain_clause(options) + " " + to_sql(arel, binds)
+          start   = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result  = internal_exec_query(sql, "EXPLAIN", binds)
+          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+
+          MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
+        end
+
+        def exec_query(sql, name = "SQL", binds = [], prepare: false, **kwargs)
+          internal_exec_query(sql, name, binds, prepare: prepare, **kwargs)
+        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:
+
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
+        end
+
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
+
+          explain_clause = "EXPLAIN #{options.join(" ").upcase}"
+
+          if analyze_without_explain? && explain_clause.include?("ANALYZE")
+            explain_clause.sub("EXPLAIN ", "")
+          else
+            explain_clause
+          end
+        end
+
+        private
+          if ActiveRecord.version < ::Gem::Version.new('7.0.a') # ActiveRecord <= 6.1 support
+            def transform_query(sql); sql; end
+            def check_if_write_query(*args); end
+
+            if ActiveRecord.version < ::Gem::Version.new('6.1.a') # ActiveRecord <= 6.0 support
+              def mark_transaction_written_if_write(sql)
+                transaction = current_transaction
+                if transaction.respond_to?(:written) && transaction.open?
+                  transaction.written ||= write_query?(sql)
+                end
+              end
+            end
+          end
+
+          def raw_execute(sql, name, async: false, materialize_transactions: true)
+            log_kwargs = {}
+            log_kwargs[:async] = async if ActiveRecord.version >= ::Gem::Version.new('7.0.a')
+            log(sql, name, **log_kwargs) do
+              with_trilogy_connection(materialize_transactions: materialize_transactions) do |conn|
+                sync_timezone_changes(conn)
+                conn.query(sql)
+              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) } if respond_to?(:transform_query)
+            combine_multi_statements(statements).each do |statement|
+              with_trilogy_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_trilogy_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
+
+          def combine_multi_statements(total_sql)
+            total_sql.each_with_object([]) do |sql, total_sql_chunks|
+              previous_packet = total_sql_chunks.last
+              if max_allowed_packet_reached?(sql, previous_packet)
+                total_sql_chunks << +sql
+              else
+                previous_packet << ";\n"
+                previous_packet << sql
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -4,83 +4,83 @@ require "trilogy"
 require "active_record/connection_adapters/abstract_mysql_adapter"
 
 require "active_record/tasks/trilogy_database_tasks"
-require "trilogy_adapter/lost_connection_exception_translator"
+require "active_record/connection_adapters/trilogy/database_statements"
 
 module ActiveRecord
-  module ConnectionAdapters
-    class TrilogyAdapter < ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
-      module DatabaseStatements
-        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
-          :desc, :describe, :set, :show, :use
-        ) # :nodoc:
-        private_constant :READ_QUERY
-
-        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP(6)").freeze # :nodoc:
-        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
-
-        def write_query?(sql) # :nodoc:
-          !READ_QUERY.match?(sql)
-        rescue ArgumentError # Invalid encoding
-          !READ_QUERY.match?(sql.b)
-        end
-
-        def explain(arel, binds = [])
-          sql     = "EXPLAIN #{to_sql(arel, binds)}"
-          start   = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          result  = exec_query(sql, "EXPLAIN", binds)
-          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+  # ActiveRecord <= 6.1 support
+  if ActiveRecord.version < ::Gem::Version.new('7.0.a')
+    class DatabaseConnectionError < ConnectionNotEstablished
+      def initialize(message = nil)
+        super(message || "Database connection error")
+      end
 
-          MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
+      class << self
+        def hostname_error(hostname)
+          DatabaseConnectionError.new(<<~MSG)
+            There is an issue connecting with your hostname: #{hostname}.\n
+            Please check your database configuration and ensure there is a valid connection to your database.
+          MSG
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false)
-          result = execute(sql, name, async: async)
-          ActiveRecord::Result.new(result.fields, result.to_a)
+        def username_error(username)
+          DatabaseConnectionError.new(<<~MSG)
+            There is an issue connecting to your database with your username/password, username: #{username}.\n
+            Please check your database configuration to ensure the username/password are valid.
+          MSG
         end
+      end
+    end
 
-        alias exec_without_stmt exec_query
+    NoDatabaseError.class_exec do
+      def self.db_error(db_name)
+        NoDatabaseError.new(<<~MSG)
+          We could not find your database: #{db_name}. Available database configurations can be found in config/database.yml file.
 
-        def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-          execute(to_sql(sql, binds), name)
-        end
+          To resolve this error:
 
-        def exec_delete(sql, name = nil, binds = [])
-          result = execute(to_sql(sql, binds), name)
-          result.affected_rows
-        end
-
-        alias :exec_update :exec_delete
+          - Did you create the database for this app, or delete it? You may need to create your database.
+          - Has the database name changed? Check your database.yml config has the correct database name.
 
-        def high_precision_current_timestamp
-          HIGH_PRECISION_CURRENT_TIMESTAMP
-        end
+          To create your database, run:\n\n        bin/rails db:create
+        MSG
+      end
+    end
+  end
 
-        private
-          def last_inserted_id(result)
-            result.last_insert_id
-          end
+  if ActiveRecord.version < ::Gem::Version.new('6.1.a') # ActiveRecord <= 6.0 support
+    require "active_record/database_configurations"
+    DatabaseConfigurations.class_exec do
+      def resolve(config) # :nodoc:
+        @resolver ||= ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(::ActiveRecord::Base.configurations)
+        @resolver.resolve(config)
       end
+    end
+  end
 
+  module ConnectionAdapters
+    class TrilogyAdapter < ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
       ER_BAD_DB_ERROR = 1049
+      ER_DBACCESS_DENIED_ERROR = 1044
       ER_ACCESS_DENIED_ERROR = 1045
+      ER_SERVER_SHUTDOWN = 1053
 
       ADAPTER_NAME = "Trilogy"
 
-      include DatabaseStatements
+      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
+        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
+        rescue ::Trilogy::ConnectionError, ::Trilogy::ProtocolError => error
           raise translate_connect_error(config, error)
         end
 
@@ -88,7 +88,6 @@ module ActiveRecord
           return mode if mode.is_a? Integer
 
           m = mode.to_s.upcase
-          # enable Mysql2 client compatibility
           m = "SSL_MODE_#{m}" unless m.start_with? "SSL_MODE_"
 
           SSL_MODES.fetch(m.to_sym, mode)
@@ -101,13 +100,58 @@ module ActiveRecord
           when ER_ACCESS_DENIED_ERROR
             ActiveRecord::DatabaseConnectionError.username_error(config[:username])
           else
-            if error.message.match?(/TRILOGY_DNS_ERROR/)
+            if error.message.include?("TRILOGY_DNS_ERROR")
               ActiveRecord::DatabaseConnectionError.hostname_error(config[:host])
             else
               ActiveRecord::ConnectionNotEstablished.new(error.message)
             end
           end
         end
+
+        def dbconsole(config, options = {})
+          mysql_config = if ActiveRecord.version < ::Gem::Version.new('6.1.a')
+                           config.config
+                         else
+                           config.configuration_hash
+                         end
+
+          args = {
+            host: "--host",
+            port: "--port",
+            socket: "--socket",
+            username: "--user",
+            encoding: "--default-character-set",
+            sslca: "--ssl-ca",
+            sslcert: "--ssl-cert",
+            sslcapath: "--ssl-capath",
+            sslcipher: "--ssl-cipher",
+            sslkey: "--ssl-key",
+            ssl_mode: "--ssl-mode"
+          }.filter_map { |opt, arg| "#{arg}=#{mysql_config[opt]}" if mysql_config[opt] }
+
+          if mysql_config[:password] && options[:include_password]
+            args << "--password=#{mysql_config[:password]}"
+          elsif mysql_config[:password] && !mysql_config[:password].to_s.empty?
+            args << "-p"
+          end
+
+          args << mysql_config[:database]
+
+          find_cmd_and_exec(["mysql", "mysql5"], *args)
+        end
+
+        private
+          def initialize_type_map(m)
+            super if ActiveRecord.version >= ::Gem::Version.new('7.0.a')
+
+            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(connection, logger, connection_options, config)
@@ -118,6 +162,8 @@ module ActiveRecord
         )
       end
 
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
       def supports_json?
         !mariadb? && database_version >= "5.7.8"
       end
@@ -143,7 +189,7 @@ module ActiveRecord
       end
 
       def quote_string(string)
-        with_trilogy_connection(allow_retry: true, uses_transaction: false) do |conn|
+        with_trilogy_connection(allow_retry: true, materialize_transactions: false) do |conn|
           conn.escape(string)
         end
       end
@@ -157,36 +203,17 @@ module ActiveRecord
         @lock.synchronize do
           disconnect!
           connect
-        rescue StandardError => original_exception
-          raise translate_exception_class(original_exception, nil, nil)
         end
       end
 
-      def with_trilogy_connection(uses_transaction: true, **_kwargs)
+      def with_trilogy_connection(materialize_transactions: true, **_kwargs)
         @lock.synchronize do
           verify!
-          materialize_transactions if uses_transaction
+          materialize_transactions if materialize_transactions
           yield connection
         end
       end
 
-      def raw_execute(sql, name, async: false, allow_retry: false, uses_transaction: true)
-        mark_transaction_written_if_write(sql)
-
-        log(sql, name, async: async) do
-          with_trilogy_connection(allow_retry: allow_retry, uses_transaction: uses_transaction) do |conn|
-            sync_timezone_changes(conn)
-            conn.query(sql)
-          end
-        end
-      end
-
-      def execute(sql, name = nil, **kwargs)
-        sql = transform_query(sql)
-        check_if_write_query(sql)
-        super
-      end
-
       def active?
         return false if connection&.closed?
 
@@ -206,90 +233,78 @@ module ActiveRecord
       end
 
       def discard!
-        self.connection = nil
+        super
+        unless connection.nil?
+          connection.discard!
+          self.connection = nil
+        end
       end
 
-      def each_hash(result)
-        return to_enum(:each_hash, result) unless block_given?
+      def self.find_cmd_and_exec(commands, *args) # :doc:
+        commands = Array(commands)
 
-        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
+        dirs_on_path = ENV["PATH"].to_s.split(File::PATH_SEPARATOR)
+        unless (ext = RbConfig::CONFIG["EXEEXT"]).empty?
+          commands = commands.map { |cmd| "#{cmd}#{ext}" }
         end
 
-        nil
-      end
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            begin
+              stat = File.stat(full_path_command)
+            rescue SystemCallError
+            else
+              stat.file? && stat.executable?
+            end
+          end
+        end
 
-      def error_number(exception)
-        exception.error_code if exception.respond_to?(:error_code)
+        if found
+          exec full_path_command, *args
+        else
+          abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
+        end
       end
 
       private
-        attr_accessor :connection
-
-        def connect
-          self.connection = self.class.new_client(@config)
-        end
-
-        def reconnect
-          connection&.close
-          self.connection = nil
-          connect
+        def text_type?(type)
+          TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
         end
 
-        def sync_timezone_changes(conn)
-          # Sync any changes since connection last established.
-          if ActiveRecord.default_timezone == :local
-            conn.query_flags |= ::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
-          else
-            conn.query_flags &= ~::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
-          end
-        end
+        def each_hash(result)
+          return to_enum(:each_hash, result) unless block_given?
 
-        def execute_batch(statements, name = nil)
-          statements = statements.map { |sql| transform_query(sql) }
-          combine_multi_statements(statements).each do |statement|
-            with_trilogy_connection do |conn|
-              raw_execute(statement, name)
-              conn.next_result while conn.more_results_exist?
+          keys = result.columns.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
-        end
 
-        def multi_statements_enabled?
-          !!@config[:multi_statement]
+          nil
         end
 
-        def with_multi_statements
-          if multi_statements_enabled?
-            return yield
-          end
+        def error_number(exception)
+          exception.error_code if exception.respond_to?(:error_code)
+        end
 
-          with_trilogy_connection do |conn|
-            conn.set_server_option(Trilogy::SET_SERVER_MULTI_STATEMENTS_ON)
+        attr_accessor :connection
 
-            yield
-          ensure
-            conn.set_server_option(Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF)
-          end
+        def connect
+          self.connection = self.class.new_client(@config)
+          configure_connection
         end
 
-        def combine_multi_statements(total_sql)
-          total_sql.each_with_object([]) do |sql, total_sql_chunks|
-            previous_packet = total_sql_chunks.last
-            if max_allowed_packet_reached?(sql, previous_packet)
-              total_sql_chunks << +sql
-            else
-              previous_packet << ";\n"
-              previous_packet << sql
-            end
-          end
+        def reconnect
+          connection&.close
+          self.connection = nil
+          connect
         end
 
         def max_allowed_packet_reached?(current_packet, previous_packet)
@@ -312,21 +327,88 @@ module ActiveRecord
         end
 
         def get_full_version
-          with_trilogy_connection(allow_retry: true, uses_transaction: false) do |conn|
+          with_trilogy_connection(allow_retry: true, materialize_transactions: false) do |conn|
             conn.server_info[:version]
           end
         end
 
-        def translate_exception(exception, message:, sql:, binds:)
-          error_code = exception.error_code if exception.respond_to?(:error_code)
-
-          ::TrilogyAdapter::LostConnectionExceptionTranslator.
-            new(exception, message, error_code).translate || super
+        if ActiveRecord.version < ::Gem::Version.new('7.0.a') # For ActiveRecord <= 6.1
+          def default_timezone
+            ActiveRecord::Base.default_timezone
+          end
+        else # For ActiveRecord 7.0
+          def default_timezone
+            ActiveRecord.default_timezone
+          end
         end
 
         def default_prepared_statements
           false
         end
+
+        if ActiveRecord.version < ::Gem::Version.new('6.1.a') # For ActiveRecord <= 6.0
+          def prepared_statements?
+            @prepared_statements && !prepared_statements_disabled_cache.include?(object_id)
+          end
+        end
+
+        def default_insert_value(column)
+          super unless column.auto_increment?
+        end
+
+        # https://mariadb.com/kb/en/analyze-statement/
+        def analyze_without_explain?
+          mariadb? && database_version >= "10.1.0"
+        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
+
+    if ActiveRecord.version < ::Gem::Version.new('6.1.a') # For ActiveRecord <= 6.0
+      class PoolConfig < ConnectionSpecification
+        def initialize(connection_class, db_config, *args)
+          super("primary", db_config, "#{db_config[:adapter]}_connection")
+        end
+      end
+
+      SchemaCache.class_exec do
+        def self.load_from(filename)
+          return unless File.file?(filename)
+
+          read(filename) do |file|
+            if filename.include?(".dump")
+              Marshal.load(file)
+            else
+              if YAML.respond_to?(:unsafe_load)
+                YAML.unsafe_load(file)
+              else
+                YAML.load(file)
+              end
+            end
+          end
+        end
+
+        def self.read(filename, &block)
+          if File.extname(filename) == ".gz"
+            Zlib::GzipReader.open(filename) { |gz|
+              yield gz.read
+            }
+          else
+            yield File.read(filename)
+          end
+        end
+        private_class_method :read
+      end
     end
+
+    ActiveSupport.run_load_hooks(:active_record_trilogyadapter, TrilogyAdapter)
   end
 end

data/lib/activerecord-trilogy-adapter.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
 
 require "active_record"
-require "trilogy_adapter/errors"
 require "trilogy_adapter/railtie"

data/lib/trilogy_adapter/rails/dbconsole.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module TrilogyAdapter
+  module Rails
+    module DBConsole
+      class AdapterAdapter < SimpleDelegator
+        def adapter
+          "mysql"
+        end
+      end
+
+      def db_config
+        if super.adapter == "trilogy"
+          AdapterAdapter.new(super)
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+module Rails
+  class DBConsole
+    # require "rails/commands/dbconsole/dbconsole_command"
+    if ActiveRecord.version < ::Gem::Version.new('6.1.a')
+      alias _brick_start start
+      def start
+        ENV["RAILS_ENV"] ||= @options[:environment] || environment
+
+        if config["adapter"] == "trilogy"
+          begin
+            ::ActiveRecord::ConnectionAdapters::TrilogyAdapter.dbconsole(config, @options)
+          rescue NotImplementedError
+            abort "Unknown command-line client for #{db_config.database}."
+          end
+        else
+          _brick_start
+        end
+      end
+    end
+  end
+end

data/lib/trilogy_adapter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TrilogyAdapter
-  VERSION = "3.0.0"
+  VERSION = "3.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-trilogy-adapter
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.1
 platform: ruby
 authors:
 - GitHub Engineering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-16 00:00:00.000000000 Z
+date: 2023-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trilogy
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: 6.0.a
     - - "<"
       - !ruby/object:Gem::Version
-        version: 7.1a
+        version: 7.1.a
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: 6.0.a
     - - "<"
       - !ruby/object:Gem::Version
-        version: 7.1a
+        version: 7.1.a
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -111,12 +111,12 @@ extra_rdoc_files:
 files:
 - LICENSE.md
 - README.md
+- lib/active_record/connection_adapters/trilogy/database_statements.rb
 - lib/active_record/connection_adapters/trilogy_adapter.rb
 - lib/active_record/tasks/trilogy_database_tasks.rb
 - lib/activerecord-trilogy-adapter.rb
 - lib/trilogy_adapter/connection.rb
-- lib/trilogy_adapter/errors.rb
-- lib/trilogy_adapter/lost_connection_exception_translator.rb
+- lib/trilogy_adapter/rails/dbconsole.rb
 - lib/trilogy_adapter/railtie.rb
 - lib/trilogy_adapter/version.rb
 homepage: https://github.com/trilogy-libraries/activerecord-trilogy-adapter

data/lib/trilogy_adapter/errors.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module TrilogyAdapter
-  module Errors
-    # ServerShutdown will be raised when the database server was shutdown.
-    class ServerShutdown < ::ActiveRecord::QueryAborted
-    end
-
-    # ServerLost will be raised when the database connection was lost.
-    class ServerLost < ::ActiveRecord::QueryAborted
-    end
-
-    # ServerGone will be raised when the database connection is gone.
-    class ServerGone < ::ActiveRecord::QueryAborted
-    end
-
-    # BrokenPipe will be raised when a system process connection fails.
-    class BrokenPipe < ::ActiveRecord::QueryAborted
-    end
-
-    # SocketError will be raised when Ruby encounters a network error.
-    class SocketError < ::ActiveRecord::QueryAborted
-    end
-
-    # ConnectionResetByPeer will be raised when a network connection is closed
-    # outside the sytstem process.
-    class ConnectionResetByPeer < ::ActiveRecord::QueryAborted
-    end
-
-    # ClosedConnection will be raised when the Trilogy encounters a closed
-    # connection.
-    class ClosedConnection < ::ActiveRecord::QueryAborted
-    end
-
-    # InvalidSequenceId will be raised when Trilogy ecounters an invalid sequence
-    # id.
-    class InvalidSequenceId < ::ActiveRecord::QueryAborted
-    end
-
-    # UnexpectedPacket will be raised when Trilogy ecounters an unexpected
-    # response packet.
-    class UnexpectedPacket < ::ActiveRecord::QueryAborted
-    end
-  end
-end

data/lib/trilogy_adapter/lost_connection_exception_translator.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module TrilogyAdapter
-  class LostConnectionExceptionTranslator
-    attr_reader :exception, :message, :error_number
-
-    def initialize(exception, message, error_number)
-      @exception = exception
-      @message = message
-      @error_number = error_number
-    end
-
-    def translate
-      translate_database_exception || translate_ruby_exception || translate_trilogy_exception
-    end
-
-    private
-      ER_SERVER_SHUTDOWN = 1053
-      CR_SERVER_LOST = 2013
-      CR_SERVER_LOST_EXTENDED = 2055
-      CR_SERVER_GONE_ERROR = 2006
-
-      def translate_database_exception
-        case error_number
-        when ER_SERVER_SHUTDOWN
-          Errors::ServerShutdown.new(message)
-        when CR_SERVER_LOST, CR_SERVER_LOST_EXTENDED
-          Errors::ServerLost.new(message)
-        when CR_SERVER_GONE_ERROR
-          Errors::ServerGone.new(message)
-        end
-      end
-
-      def translate_ruby_exception
-        case exception
-        when Errno::EPIPE
-          Errors::BrokenPipe.new(message)
-        when SocketError, IOError
-          Errors::SocketError.new(message)
-        when Trilogy::ConnectionError
-          if message.match?(/Connection reset by peer/)
-            Errors::ConnectionResetByPeer.new(message)
-          end
-        end
-      end
-
-      def translate_trilogy_exception
-        return unless exception.is_a?(Trilogy::Error)
-
-        case message
-        when /TRILOGY_CLOSED_CONNECTION/
-          Errors::ClosedConnection.new(message)
-        when /TRILOGY_INVALID_SEQUENCE_ID/
-          Errors::InvalidSequenceId.new(message)
-        when /TRILOGY_UNEXPECTED_PACKET/
-          Errors::UnexpectedPacket.new(message)
-        end
-      end
-  end
-end