activerecord-trilogy-adapter 2.2.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a64e0395be9ae813e0aec59643758f1a2cc813099c290d95b5c6fbbf8c03746e
-  data.tar.gz: 7a1e5be7180c1f84475a40b7a48fe3b717eca0b3c4550ec2e687351049dcfa4e
+  metadata.gz: 065e502503fb93e0e951b03e67c43b8ea257a01c681c077b5b904a95ddcb0c90
+  data.tar.gz: 2a85e79e0654196e0dba708f7bbc4146c413bf0f0b135894357bc174374c76fd
 SHA512:
-  metadata.gz: b4e7aa7c78d2773783d578708d8267633f006db9f89eba45d58fb172e5fcb8a0bc8b0b4b70542c6cc4900ad0fd217706765db035601b0b862df1bbbf3d79c02e
-  data.tar.gz: f508049eb78a987e12c2e18480516b2ffced87c41a8517aaa95a3e24585b2bbb6ae181e1dd4abf8f6889155bf76e351f5912bb74c5deeeff63fce970b303b835
+  metadata.gz: 7ed2509f2e8593d3d1b73c56b403875a1751f50c5e5ae99fc405fead7020ec43c5b9e0510e196b3818a5cc1335480062a8c75e2cfebb757ca19c46fa9d1404be
+  data.tar.gz: 45d9e001bee0aa227b2e7a7ac2f3b009d009f312cc2af128d5be0275c5f9ff2ce7b496ebde2ca7df1fedfd7a9a6b235df9fef1cfaf2309ca374357ba14d0a485

data/README.md

@@ -1,23 +1,34 @@
 # Trilogy Adapter
 
-Active Record database adapter for [Trilogy](https://github.com/github/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 Active Record prior to v7.1. Currently supports:
+
+- ⚠️ 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.1 or higher
-- [Trilogy](https://github.com/github/trilogy) 2.1.1 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,124 @@
+# 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 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 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
+
+        private
+          if ActiveRecord.version < ::Gem::Version.new('7.0.a') # ActiveRecord <= 6.1 support
+            def raw_execute(sql, name, uses_transaction: true, **_kwargs)
+              # Same as mark_transaction_written_if_write(sql)
+              transaction = current_transaction
+              if transaction.respond_to?(:written) && transaction.open?
+                transaction.written ||= write_query?(sql)
+              end
+
+              log(sql, name) do
+                with_trilogy_connection(uses_transaction: uses_transaction) do |conn|
+                  sync_timezone_changes(conn)
+                  conn.query(sql)
+                end
+              end
+            end
+
+            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(*args); end
+            end
+          else # ActiveRecord 7.0 support
+            def raw_execute(sql, name, uses_transaction: true, async: false, allow_retry: false)
+              mark_transaction_written_if_write(sql)
+              log(sql, name, async: async) do
+                with_trilogy_connection(uses_transaction: uses_transaction, allow_retry: allow_retry) do |conn|
+                  sync_timezone_changes(conn)
+                  conn.query(sql)
+                end
+              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
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -4,76 +4,82 @@ require "trilogy"
 require "active_record/connection_adapters/abstract_mysql_adapter"
 
 require "active_record/tasks/trilogy_database_tasks"
+require "active_record/connection_adapters/trilogy/database_statements"
 require "trilogy_adapter/lost_connection_exception_translator"
 
 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
-
-        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
+          - 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.
 
-        alias :exec_update :exec_delete
+          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_ACCESS_DENIED_ERROR = 1045
 
       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
 
@@ -81,7 +87,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)
@@ -94,15 +99,38 @@ 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
+
+        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)
+        super
+        # Ensure that we're treating prepared_statements in the same way that Rails 7.1 does
+        @prepared_statements = self.class.type_cast_config_to_boolean(
+          @config.fetch(:prepared_statements) { default_prepared_statements }
+        )
+      end
+
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
       def supports_json?
         !mariadb? && database_version >= "5.7.8"
       end
@@ -128,12 +156,41 @@ module ActiveRecord
       end
 
       def quote_string(string)
-        with_raw_connection(allow_retry: true, uses_transaction: false) do |conn|
+        with_trilogy_connection(allow_retry: true, uses_transaction: false) do |conn|
           conn.escape(string)
         end
       end
 
+      def connect!
+        verify!
+        self
+      end
+
+      def reconnect!
+        @lock.synchronize do
+          disconnect!
+          connect
+        end
+      end
+
+      def with_trilogy_connection(uses_transaction: true, **_kwargs)
+        @lock.synchronize do
+          verify!
+          materialize_transactions if uses_transaction
+          yield connection
+        end
+      end
+
+      def execute(sql, name = nil, allow_retry: false, **kwargs)
+        sql = transform_query(sql)
+        check_if_write_query(sql)
+
+        raw_execute(sql, name, allow_retry: allow_retry, **kwargs)
+      end
+
       def active?
+        return false if connection&.closed?
+
         connection&.ping || false
       rescue ::Trilogy::Error
         false
@@ -150,39 +207,41 @@ 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?
-
-        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
+      private
+        def text_type?(type)
+          TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
         end
 
-        nil
-      end
+        def each_hash(result)
+          return to_enum(:each_hash, result) unless block_given?
 
-      def error_number(exception)
-        exception.error_code if exception.respond_to?(:error_code)
-      end
+          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
 
-      private
-        def connection
-          @raw_connection
+          nil
         end
 
-        def connection=(conn)
-          @raw_connection = conn
+        def error_number(exception)
+          exception.error_code if exception.respond_to?(:error_code)
         end
 
+        attr_accessor :connection
+
         def connect
           self.connection = self.class.new_client(@config)
         end
@@ -193,26 +252,85 @@ module ActiveRecord
           connect
         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
+        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
+
+        def max_allowed_packet_reached?(current_packet, previous_packet)
+          if current_packet.bytesize > max_allowed_packet
+            raise ActiveRecordError,
+              "Fixtures set is too large #{current_packet.bytesize}. Consider increasing the max_allowed_packet variable."
+          elsif previous_packet.nil?
+            true
           else
-            conn.query_flags &= ~::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
+            (current_packet.bytesize + previous_packet.bytesize + 2) > max_allowed_packet
           end
         end
 
+        def max_allowed_packet
+          @max_allowed_packet ||= show_variable("max_allowed_packet")
+        end
+
         def full_version
           schema_cache.database_version.full_version_string
         end
 
         def get_full_version
-          with_raw_connection(allow_retry: true, uses_transaction: false) do |conn|
+          with_trilogy_connection(allow_retry: true, uses_transaction: false) do |conn|
             conn.server_info[:version]
           end
         end
 
+        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 translate_exception(exception, message:, sql:, binds:)
+          if exception.is_a?(::Trilogy::TimeoutError) && !exception.error_code
+            return ActiveRecord::AdapterTimeout.new(message, sql: sql, binds: binds)
+          end
           error_code = exception.error_code if exception.respond_to?(:error_code)
 
           ::TrilogyAdapter::LostConnectionExceptionTranslator.
@@ -222,6 +340,61 @@ module ActiveRecord
         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
+
+        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/trilogy_adapter/errors.rb

@@ -1,45 +1,54 @@
 # frozen_string_literal: true
 
+if ActiveRecord.version < ::Gem::Version.new('6.1.a') # ActiveRecord <= 6.0 support
+  module ::ActiveRecord
+    class QueryAborted < ::ActiveRecord::StatementInvalid
+    end
+    class AdapterTimeout < ::ActiveRecord::QueryAborted
+    end
+  end
+end
+
 module TrilogyAdapter
   module Errors
     # ServerShutdown will be raised when the database server was shutdown.
-    class ServerShutdown < ActiveRecord::ConnectionFailed
+    class ServerShutdown < ::ActiveRecord::QueryAborted
     end
 
     # ServerLost will be raised when the database connection was lost.
-    class ServerLost < ActiveRecord::ConnectionFailed
+    class ServerLost < ::ActiveRecord::QueryAborted
     end
 
     # ServerGone will be raised when the database connection is gone.
-    class ServerGone < ActiveRecord::ConnectionFailed
+    class ServerGone < ::ActiveRecord::QueryAborted
     end
 
     # BrokenPipe will be raised when a system process connection fails.
-    class BrokenPipe < ActiveRecord::ConnectionFailed
+    class BrokenPipe < ::ActiveRecord::QueryAborted
     end
 
     # SocketError will be raised when Ruby encounters a network error.
-    class SocketError < ActiveRecord::ConnectionFailed
+    class SocketError < ::ActiveRecord::QueryAborted
     end
 
     # ConnectionResetByPeer will be raised when a network connection is closed
     # outside the sytstem process.
-    class ConnectionResetByPeer < ActiveRecord::ConnectionFailed
+    class ConnectionResetByPeer < ::ActiveRecord::QueryAborted
     end
 
     # ClosedConnection will be raised when the Trilogy encounters a closed
     # connection.
-    class ClosedConnection < ActiveRecord::ConnectionFailed
+    class ClosedConnection < ::ActiveRecord::QueryAborted
     end
 
     # InvalidSequenceId will be raised when Trilogy ecounters an invalid sequence
     # id.
-    class InvalidSequenceId < ActiveRecord::ConnectionFailed
+    class InvalidSequenceId < ::ActiveRecord::QueryAborted
     end
 
     # UnexpectedPacket will be raised when Trilogy ecounters an unexpected
     # response packet.
-    class UnexpectedPacket < ActiveRecord::ConnectionFailed
+    class UnexpectedPacket < ::ActiveRecord::QueryAborted
     end
   end
 end

data/lib/trilogy_adapter/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-trilogy-adapter
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.1.0
 platform: ruby
 authors:
 - GitHub Engineering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-02 00:00:00.000000000 Z
+date: 2023-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trilogy
@@ -16,26 +16,32 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.4.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.a
+    - - "<"
       - !ruby/object:Gem::Version
         version: 7.1.a
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.a
+    - - "<"
       - !ruby/object:Gem::Version
         version: 7.1.a
 - !ruby/object:Gem::Dependency
@@ -105,6 +111,7 @@ 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
@@ -113,13 +120,13 @@ files:
 - lib/trilogy_adapter/lost_connection_exception_translator.rb
 - lib/trilogy_adapter/railtie.rb
 - lib/trilogy_adapter/version.rb
-homepage: https://github.com/github/activerecord-trilogy-adapter
+homepage: https://github.com/trilogy-libraries/activerecord-trilogy-adapter
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/github/activerecord-trilogy-adapter
-  changelog_uri: https://github.com/github/activerecord-trilogy-adapter/blob/master/CHANGELOG.md
-  bug_tracker_uri: https://github.com/github/activerecord-trilogy-adapter/issues
+  source_code_uri: https://github.com/trilogy-libraries/activerecord-trilogy-adapter
+  changelog_uri: https://github.com/trilogy-libraries/activerecord-trilogy-adapter/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/trilogy-libraries/activerecord-trilogy-adapter/issues
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -138,5 +145,5 @@ requirements: []
 rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
-summary: Active Record adapter for https://github.com/github/trilogy.
+summary: Active Record adapter for https://github.com/trilogy-libraries/trilogy.
 test_files: []