activerecord-trilogy-adapter 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 778687330e4ff0e83f8cf02ea27808b9e7197c625312611c0dd004d17627a29e
-  data.tar.gz: f3ddf11ab50accd31b5bd3a4b41899a781f4ac04555739d1e65eff3e884b8b38
+  metadata.gz: 065e502503fb93e0e951b03e67c43b8ea257a01c681c077b5b904a95ddcb0c90
+  data.tar.gz: 2a85e79e0654196e0dba708f7bbc4146c413bf0f0b135894357bc174374c76fd
 SHA512:
-  metadata.gz: 7b2e8b370f301aeda40bef4e1a66c16dc0351b245a5c967341a22e1ab05830e4e11d5cd1de2de2e38a246cbd5fb492e27d8e906770d4484707512a34e9d8430c
-  data.tar.gz: 3471e795e4942858134083a06f632da5afebb69c60a87001631486c79ecb81dc3f90e5c5cbdf5eb408c48ca125f47055ca8c08c0af945324e1043aa7996b104e
+  metadata.gz: 7ed2509f2e8593d3d1b73c56b403875a1751f50c5e5ae99fc405fead7020ec43c5b9e0510e196b3818a5cc1335480062a8c75e2cfebb757ca19c46fa9d1404be
+  data.tar.gz: 45d9e001bee0aa227b2e7a7ac2f3b009d009f312cc2af128d5be0275c5f9ff2ce7b496ebde2ca7df1fedfd7a9a6b235df9fef1cfaf2309ca374357ba14d0a485

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,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,83 +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
-
-        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP(6)").freeze # :nodoc:
-        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+  # 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
 
-        def write_query?(sql) # :nodoc:
-          !READ_QUERY.match?(sql)
-        rescue ArgumentError # Invalid encoding
-          !READ_QUERY.match?(sql.b)
+      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 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
-
-          MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
+        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
 
-        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)
-        end
+    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.
 
-        alias exec_without_stmt exec_query
+          To resolve this error:
 
-        def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-          execute(to_sql(sql, binds), name)
-        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.
 
-        def exec_delete(sql, name = nil, binds = [])
-          result = execute(to_sql(sql, binds), name)
-          result.affected_rows
-        end
-
-        alias :exec_update :exec_delete
-
-        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_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
 
@@ -88,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)
@@ -101,13 +99,26 @@ 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)
@@ -118,6 +129,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
@@ -157,8 +170,6 @@ module ActiveRecord
         @lock.synchronize do
           disconnect!
           connect
-        rescue StandardError => original_exception
-          raise translate_exception_class(original_exception, nil, nil)
         end
       end
 
@@ -170,21 +181,11 @@ module ActiveRecord
         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)
+      def execute(sql, name = nil, allow_retry: false, **kwargs)
         sql = transform_query(sql)
         check_if_write_query(sql)
-        super
+
+        raw_execute(sql, name, allow_retry: allow_retry, **kwargs)
       end
 
       def active?
@@ -206,31 +207,39 @@ 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?
+      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
+          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
-          yield hash
-        end
 
-        nil
-      end
+          nil
+        end
 
-      def error_number(exception)
-        exception.error_code if exception.respond_to?(:error_code)
-      end
+        def error_number(exception)
+          exception.error_code if exception.respond_to?(:error_code)
+        end
 
-      private
         attr_accessor :connection
 
         def connect
@@ -243,17 +252,8 @@ module ActiveRecord
           connect
         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 execute_batch(statements, name = nil)
-          statements = statements.map { |sql| transform_query(sql) }
+          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)
@@ -272,11 +272,11 @@ module ActiveRecord
           end
 
           with_trilogy_connection do |conn|
-            conn.set_server_option(Trilogy::SET_SERVER_MULTI_STATEMENTS_ON)
+            conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_ON)
 
             yield
           ensure
-            conn.set_server_option(Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF)
+            conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF)
           end
         end
 
@@ -317,7 +317,20 @@ module ActiveRecord
           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.
@@ -327,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,5 +1,14 @@
 # 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.

data/lib/trilogy_adapter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TrilogyAdapter
-  VERSION = "3.0.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: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - GitHub Engineering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-16 00:00:00.000000000 Z
+date: 2023-07-07 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,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