activerecord-trilogy-adapter 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 065e502503fb93e0e951b03e67c43b8ea257a01c681c077b5b904a95ddcb0c90
-  data.tar.gz: 2a85e79e0654196e0dba708f7bbc4146c413bf0f0b135894357bc174374c76fd
+  metadata.gz: 0a3a2190bc8818bad95cf334d7e4b0c9108a9520f37a899ff356f36b2c067ef1
+  data.tar.gz: bf58ccfed24d5a7ecd17f6670d4a6fb623e27f862cbcbb87b408470b46fa44c0
 SHA512:
-  metadata.gz: 7ed2509f2e8593d3d1b73c56b403875a1751f50c5e5ae99fc405fead7020ec43c5b9e0510e196b3818a5cc1335480062a8c75e2cfebb757ca19c46fa9d1404be
-  data.tar.gz: 45d9e001bee0aa227b2e7a7ac2f3b009d009f312cc2af128d5be0275c5f9ff2ce7b496ebde2ca7df1fedfd7a9a6b235df9fef1cfaf2309ca374357ba14d0a485
+  metadata.gz: 0b0991df8962bdfbe7d917aac03f224cbe919a3cef9113c39f1eab150d207c04b4a7db457404d492d3bb0e5b0e459d353f7511a1e82d7ff92c804d02353a8c34
+  data.tar.gz: 44a43a09ad1230250f29da21e941bc59a8f2d606f0716c7fc045ffba0b457e029fe01b34fade384b33277f06f2667cb8498c9b895fc7fce3461f7f07afacf332

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

@@ -12,6 +12,15 @@ module ActiveRecord
         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
@@ -35,6 +44,21 @@ module ActiveRecord
           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
@@ -71,41 +95,44 @@ module ActiveRecord
           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
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
 
-              log(sql, name) do
-                with_trilogy_connection(uses_transaction: uses_transaction) do |conn|
-                  sync_timezone_changes(conn)
-                  conn.query(sql)
-                end
-              end
-            end
+          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(*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)
+              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
@@ -118,6 +145,46 @@ module ActiveRecord
               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

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -5,7 +5,6 @@ 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
   # ActiveRecord <= 6.1 support
@@ -61,7 +60,9 @@ module ActiveRecord
   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"
 
@@ -107,6 +108,38 @@ module ActiveRecord
           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')
@@ -156,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
@@ -173,21 +206,14 @@ module ActiveRecord
         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 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?
 
@@ -214,6 +240,34 @@ module ActiveRecord
         end
       end
 
+      def self.find_cmd_and_exec(commands, *args) # :doc:
+        commands = Array(commands)
+
+        dirs_on_path = ENV["PATH"].to_s.split(File::PATH_SEPARATOR)
+        unless (ext = RbConfig::CONFIG["EXEEXT"]).empty?
+          commands = commands.map { |cmd| "#{cmd}#{ext}" }
+        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
+
+        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
         def text_type?(type)
           TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
@@ -222,7 +276,7 @@ module ActiveRecord
         def each_hash(result)
           return to_enum(:each_hash, result) unless block_given?
 
-          keys = result.fields.map(&:to_sym)
+          keys = result.columns.map(&:to_sym)
           result.rows.each do |row|
             hash = {}
             idx = 0
@@ -244,6 +298,7 @@ module ActiveRecord
 
         def connect
           self.connection = self.class.new_client(@config)
+          configure_connection
         end
 
         def reconnect
@@ -252,46 +307,6 @@ module ActiveRecord
           connect
         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
-
         def max_allowed_packet_reached?(current_packet, previous_packet)
           if current_packet.bytesize > max_allowed_packet
             raise ActiveRecordError,
@@ -312,7 +327,7 @@ 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
@@ -327,16 +342,6 @@ module ActiveRecord
           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.
-            new(exception, message, error_code).translate || super
-        end
-
         def default_prepared_statements
           false
         end
@@ -347,6 +352,15 @@ module ActiveRecord
           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

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.1.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.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - GitHub Engineering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-07 00:00:00.000000000 Z
+date: 2023-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trilogy
@@ -116,8 +116,7 @@ files:
 - 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,54 +0,0 @@
-# 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::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