aws_advanced_ruby_driver_wrapper 1.0.0

data/lib/aws_advanced_ruby_driver_wrapper/driver_dialects/driver_dialect.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require_relative '../ruby_method'
+require_relative '../logging'
+
+module AwsAdvancedRubyDriverWrapper
+  module DriverDialects
+    module DriverDialect
+      include Logging
+
+      COMMON_NETWORK_BOUND_METHODS = Set[
+        RubyMethod::CONNECT.name,
+        RubyMethod::CONNECTION_CLOSE.name,
+        RubyMethod::CONNECTION_RESET.name,
+        RubyMethod::CONNECTION_PREPARE.name,
+        RubyMethod::STATEMENT_EXECUTE.name,
+        RubyMethod::STATEMENT_CLOSE.name
+      ].freeze
+
+      DEFAULT_MONITORING_TIMEOUT_SEC = 5
+
+      def connect(host_info, config)
+        raise NotImplementedError
+      end
+
+      def execute(connection, sql)
+        raise NotImplementedError
+      end
+
+      def execute_with_params(connection, sql, params)
+        raise NotImplementedError
+      end
+
+      # Rewrites +?+ placeholders into the driver's native placeholder syntax.
+      # @param sql [String] SQL written with +?+ placeholders
+      # @return [String]
+      def translate_placeholders(sql)
+        raise NotImplementedError
+      end
+
+      # Wraps binary data as the bind value the driver needs for a bytea/blob parameter.
+      # @param bytes [String] binary data
+      # @return [Object] the driver-specific bind value
+      def binary_param(bytes)
+        raise NotImplementedError
+      end
+
+      # Reads a bytea/blob column value back into binary data.
+      # @param value [String] the raw column value
+      # @return [String] binary data
+      def read_binary(value)
+        raise NotImplementedError
+      end
+
+      # The number of rows an INSERT, UPDATE, or DELETE changed.
+      # @param connection [Object] the driver connection
+      # @param result [Object] the value the statement returned
+      # @return [Integer]
+      def affected_rows(connection, result)
+        raise NotImplementedError
+      end
+
+      # Runs an INSERT and returns the id it generated.
+      # @param sql [String] native SQL for the INSERT, without a RETURNING clause
+      # @param id_column [String] the generated column to return
+      # @return [Integer, nil]
+      def insert_returning_id(connection, sql, params, id_column)
+        raise NotImplementedError
+      end
+
+      # The trailing upsert clause for an INSERT, in the driver's own grammar.
+      # @param conflict_columns [Array<String>] the columns whose conflict triggers the update
+      # @param update_columns [Array<String>] the columns to overwrite from the incoming row
+      # @return [String]
+      def upsert_clause(conflict_columns, update_columns)
+        raise NotImplementedError
+      end
+
+      # The equality operator for the wrapper's own SQL, in the driver's own grammar.
+      # @return [String]
+      def equals_operator
+        raise NotImplementedError
+      end
+
+      # A query returning a table's foreign keys as rows with +from_column+, +to_table+, and
+      # +to_column+, using +?+ placeholders for the schema and table names.
+      # @return [String]
+      def foreign_key_query
+        raise NotImplementedError
+      end
+
+      def ping(connection)
+        raise NotImplementedError
+      end
+
+      def closed?(connection)
+        raise NotImplementedError
+      end
+
+      def close_connection(connection)
+        raise NotImplementedError
+      end
+
+      def sql_state(_exception)
+        nil
+      end
+
+      def network_bound_methods
+        COMMON_NETWORK_BOUND_METHODS
+      end
+
+      def prepare_connect_config(host_info, config)
+        raise NotImplementedError
+      end
+
+      # Returns the property key the underlying driver expects for the database username.
+      # Override in driver-specific dialects where the key differs.
+      def user_property_key
+        :user
+      end
+
+      # Applies default socket/connect timeouts to monitoring connection driver props.
+      # These ensure that a query or close on a dead connection raises a timeout error
+      # rather than hanging indefinitely or segfaulting.
+      # Implementations should only apply these properties if the user hasn't already set them.
+      # @param driver_props [Hash] the monitoring connection driver props (mutated in place)
+      def apply_monitoring_defaults(driver_props)
+        # No-op by default; driver-specific dialects override.
+      end
+
+      # Returns +true+/+false+ if the driver can report transaction state directly,
+      # or +nil+ if it cannot (SQL inference is used as fallback).
+      # @param connection [Object]
+      # @return [Boolean, nil]
+      def reported_in_transaction(_connection)
+        nil
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/driver_dialects/driver_dialect_manager.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require_relative 'mysql_driver_dialect'
+require_relative 'pg_driver_dialect'
+require_relative '../errors'
+require_relative '../errors/mysql_error_handler'
+require_relative '../errors/pg_error_handler'
+
+module AwsAdvancedRubyDriverWrapper
+  module DriverDialects
+    module DriverDialectManager
+      MYSQL_DIALECT = MysqlDriverDialect.new.freeze
+      PG_DIALECT = PgDriverDialect.new.freeze
+
+      REGISTRY = {
+        mysql2: {
+          driver_dialect: MYSQL_DIALECT,
+          error_handler: Errors::MysqlErrorHandler.new(MYSQL_DIALECT)
+        },
+        postgresql: {
+          driver_dialect: PG_DIALECT,
+          error_handler: Errors::PgErrorHandler.new(PG_DIALECT)
+        }
+      }.freeze
+
+      def self.get_dialect(driver_name)
+        fetch_entry(driver_name)[:driver_dialect]
+      end
+
+      def self.get_error_handler(driver_name)
+        fetch_entry(driver_name)[:error_handler]
+      end
+
+      def self.fetch_entry(driver_name)
+        REGISTRY.fetch(driver_name) do
+          raise Errors::AwsError, "Unknown driver: #{driver_name}"
+        end
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/driver_dialects/mysql_driver_dialect.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require_relative 'driver_dialect'
+require_relative '../host/connection_string_host_list_provider'
+
+module AwsAdvancedRubyDriverWrapper
+  module DriverDialects
+    class MysqlDriverDialect
+      include DriverDialect
+
+      # Every mysql2 call that talks to the server. A call that is not listed here is handed straight
+      # to the driver, bypassing the plugin pipeline.
+      #
+      # Not listed, because libmysql answers them without talking to the server: escape, the row and
+      # column counts, last_id, affected_rows, info, warning_count, thread_id, server_info,
+      # session_track, and the connection's own settings.
+      NETWORK_BOUND_METHODS = (COMMON_NETWORK_BOUND_METHODS | Set[
+        RubyMethod::CONNECTION_QUERY.name,
+        RubyMethod::CONNECTION_ASYNC_RESULT.name,
+        RubyMethod::CONNECTION_SELECT_DB.name,
+        RubyMethod::CONNECTION_MORE_RESULTS.name,
+        RubyMethod::CONNECTION_NEXT_RESULT.name,
+        RubyMethod::CONNECTION_STORE_RESULT.name,
+        RubyMethod::CONNECTION_ABANDON_RESULTS.name,
+        RubyMethod::CONNECTION_SET_SERVER_OPTION.name,
+        RubyMethod::RESULT_EACH.name,
+        RubyMethod::RESULT_FREE.name
+      ]).freeze
+
+      def connect(host_info, config)
+        ::Mysql2::Client.new(**prepare_connect_config(host_info, config))
+      end
+
+      def execute(connection, sql)
+        raise Mysql2::Error, 'MySQL client is not connected' if connection.nil? || connection.closed?
+
+        connection.query(sql)
+      end
+
+      def execute_with_params(connection, sql, params)
+        raise Mysql2::Error, 'MySQL client is not connected' if connection.nil? || connection.closed?
+
+        stmt = connection.prepare(sql)
+        result = stmt.execute(*params)
+        # Everything the caller needs must be read off the statement before the ensure closes its
+        # handle. A SELECT result is bound to the handle, so materialize its rows now - otherwise a
+        # later iteration (e.g. SqlRunner calling #to_a) raises "Statement handle already closed".
+        # A non-SELECT statement returns nil, and its affected-row count must come from the statement
+        # too: once the handle is closed the connection-level mysql_affected_rows returns its -1 error
+        # sentinel and mysql2 raises. So return that count for #affected_rows to hand back.
+        result.is_a?(::Mysql2::Result) ? result.to_a : stmt.affected_rows
+      ensure
+        stmt&.close
+      end
+
+      # mysql2 uses +?+ placeholders, so the SQL is already in its native form.
+      def translate_placeholders(sql)
+        sql
+      end
+
+      # mysql2 binds a blob parameter as raw binary bytes.
+      def binary_param(bytes)
+        bytes.b
+      end
+
+      # mysql2 hands back a blob column as a string that only needs its encoding forced to binary.
+      def read_binary(value)
+        value.b
+      end
+
+      # A prepared statement (execute_with_params) hands back its own affected-row count, since the
+      # connection-level count is unreadable once the statement handle is closed. A plain
+      # connection.query (execute) leaves nil, so the count is read off the connection instead.
+      def affected_rows(connection, result)
+        result.is_a?(Integer) ? result : connection.affected_rows.to_i
+      end
+
+      # mysql2 has no RETURNING clause, so the generated id is read from the connection afterwards.
+      def insert_returning_id(connection, sql, params, _id_column)
+        execute_with_params(connection, sql, params)
+        id = connection.last_id
+        id&.positive? ? id : nil
+      end
+
+      # mysql2 upserts with ON DUPLICATE KEY UPDATE, reading the incoming row from VALUES().
+      def upsert_clause(_conflict_columns, update_columns)
+        assignments = update_columns.map { |column| "#{column} = VALUES(#{column})" }.join(', ')
+        "ON DUPLICATE KEY UPDATE #{assignments}"
+      end
+
+      # MySQL has no user-defined operators, so the plain operator always means the built-in one.
+      def equals_operator
+        '='
+      end
+
+      def foreign_key_query
+        'SELECT column_name AS from_column, referenced_table_name AS to_table, ' \
+          'referenced_column_name AS to_column FROM information_schema.key_column_usage ' \
+          'WHERE table_schema = ? AND table_name = ? AND referenced_table_name IS NOT NULL'
+      end
+
+      def ping(connection)
+        connection.ping
+      rescue StandardError
+        false
+      end
+
+      def closed?(connection)
+        connection.nil? || connection.closed?
+      end
+
+      def close_connection(connection)
+        return if connection.nil? || connection.closed?
+
+        connection.close
+      rescue StandardError => e
+        logger.error("Failed to close MySQL connection: #{e.message}")
+      end
+
+      def sql_state(exception)
+        return nil unless exception.respond_to?(:sql_state)
+
+        exception.sql_state
+      end
+
+      def network_bound_methods
+        NETWORK_BOUND_METHODS
+      end
+
+      def prepare_connect_config(host_info, config)
+        cfg = {}
+        config.each { |k, v| cfg[k] = v }
+        cfg[:host] = host_info.host if host_info.host_specified?
+        cfg[:port] = host_info.port.to_i if host_info.port_specified?
+        cfg
+      end
+
+      def user_property_key
+        :username
+      end
+
+      def apply_monitoring_defaults(driver_props)
+        # mysql2 read_timeout / write_timeout (in seconds) ensure that queries and closes
+        # on a dead socket raise Mysql2::Error::TimeoutError instead of segfaulting.
+        driver_props[:read_timeout] ||= DEFAULT_MONITORING_TIMEOUT_SEC
+        driver_props[:write_timeout] ||= DEFAULT_MONITORING_TIMEOUT_SEC
+        driver_props[:connect_timeout] ||= DEFAULT_MONITORING_TIMEOUT_SEC
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/driver_dialects/pg_driver_dialect.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require_relative 'driver_dialect'
+
+module AwsAdvancedRubyDriverWrapper
+  module DriverDialects
+    class PgDriverDialect
+      include DriverDialect
+
+      # Every pg call that talks to the server. A call that is not listed here is handed straight
+      # to the driver, bypassing the plugin pipeline.
+      #
+      # pg gives most of these operations several spellings (+query+ and +async_query+ for +exec+, an
+      # +async_+ and a +sync_+ form for many others, a short +lo*+ form for every large object call).
+      # One entry covers every spelling of a libpq operation: WrapperPgConnection recognizes which operation a
+      # spelling performs and enters the pipeline under that name, then asks the driver for the spelling
+      # it was given. Its OPERATIONS table has an entry per name listed here.
+      #
+      # Not listed, because libpq performs them without talking to the server: enter_pipeline_mode,
+      # exit_pipeline_mode, is_busy, setnonblocking, set_single_row_mode, set_chunked_rows_mode, the
+      # escaping and quoting calls, and the accessors for connection parameters and type maps.
+      NETWORK_BOUND_METHODS = (COMMON_NETWORK_BOUND_METHODS | Set[
+        RubyMethod::CONNECTION_EXEC.name,
+        RubyMethod::CONNECTION_ASYNC_EXEC.name,
+        RubyMethod::CONNECTION_EXEC_PARAMS.name,
+        RubyMethod::CONNECTION_EXEC_PREPARED.name,
+        RubyMethod::CONNECTION_DESCRIBE_PREPARED.name,
+        RubyMethod::CONNECTION_DESCRIBE_PORTAL.name,
+        RubyMethod::CONNECTION_TRANSACTION.name,
+        RubyMethod::CONNECTION_COPY_DATA.name,
+        RubyMethod::CONNECTION_PUT_COPY_DATA.name,
+        RubyMethod::CONNECTION_GET_COPY_DATA.name,
+        RubyMethod::CONNECTION_PUT_COPY_END.name,
+        RubyMethod::CONNECTION_SEND_QUERY.name,
+        RubyMethod::CONNECTION_SEND_QUERY_PARAMS.name,
+        RubyMethod::CONNECTION_SEND_QUERY_PREPARED.name,
+        RubyMethod::CONNECTION_SEND_PREPARE.name,
+        RubyMethod::CONNECTION_GET_RESULT.name,
+        RubyMethod::CONNECTION_GET_LAST_RESULT.name,
+        RubyMethod::CONNECTION_CANCEL.name,
+        RubyMethod::CONNECTION_SET_CLIENT_ENCODING.name,
+        RubyMethod::CONNECTION_WAIT_FOR_NOTIFY.name,
+        RubyMethod::CONNECTION_NOTIFIES.name,
+        RubyMethod::CONNECTION_CONSUME_INPUT.name,
+        RubyMethod::CONNECTION_FLUSH.name,
+        RubyMethod::CONNECTION_LO_OPEN.name,
+        RubyMethod::CONNECTION_LO_READ.name,
+        RubyMethod::CONNECTION_LO_WRITE.name,
+        RubyMethod::CONNECTION_LO_CLOSE.name,
+        RubyMethod::CONNECTION_CLOSE_PREPARED.name,
+        RubyMethod::CONNECTION_CLOSE_PORTAL.name,
+        RubyMethod::CONNECTION_DISCARD_RESULTS.name,
+        RubyMethod::CONNECTION_SEND_DESCRIBE_PREPARED.name,
+        RubyMethod::CONNECTION_SEND_DESCRIBE_PORTAL.name,
+        RubyMethod::CONNECTION_SEND_FLUSH_REQUEST.name,
+        RubyMethod::CONNECTION_PIPELINE_SYNC.name,
+        RubyMethod::CONNECTION_SEND_PIPELINE_SYNC.name,
+        RubyMethod::CONNECTION_BLOCK.name,
+        RubyMethod::CONNECTION_RESET_START.name,
+        RubyMethod::CONNECTION_RESET_POLL.name,
+        RubyMethod::CONNECTION_ENCRYPT_PASSWORD.name,
+        RubyMethod::CONNECTION_SET_DEFAULT_ENCODING.name,
+        RubyMethod::CONNECTION_INTERNAL_ENCODING_SET.name,
+        RubyMethod::CONNECTION_LO_CREAT.name,
+        RubyMethod::CONNECTION_LO_CREATE.name,
+        RubyMethod::CONNECTION_LO_IMPORT.name,
+        RubyMethod::CONNECTION_LO_EXPORT.name,
+        RubyMethod::CONNECTION_LO_UNLINK.name,
+        RubyMethod::CONNECTION_LO_LSEEK.name,
+        RubyMethod::CONNECTION_LO_TELL.name,
+        RubyMethod::CONNECTION_LO_TRUNCATE.name
+      ]).freeze
+
+      def connect(host_info, config)
+        ::PG::Connection.new(**prepare_connect_config(host_info, config))
+      end
+
+      def execute(connection, sql)
+        connection.exec(sql)
+      end
+
+      def execute_with_params(connection, sql, params)
+        connection.exec_params(sql, params)
+      end
+
+      # pg uses numbered +$1+, +$2+ ... placeholders.
+      def translate_placeholders(sql)
+        index = 0
+        sql.gsub('?') do
+          index += 1
+          "$#{index}"
+        end
+      end
+
+      # pg binds a bytea parameter as a value tagged with binary format 1.
+      def binary_param(bytes)
+        { value: bytes, format: 1 }
+      end
+
+      # pg hands back a bytea column in its hex (or older octal) text format.
+      def read_binary(value)
+        ::PG::Connection.unescape_bytea(value)
+      end
+
+      # pg reports the affected row count on the result.
+      def affected_rows(_connection, result)
+        result.respond_to?(:cmd_tuples) ? result.cmd_tuples.to_i : 0
+      end
+
+      # pg returns the generated id with a RETURNING clause.
+      def insert_returning_id(connection, sql, params, id_column)
+        row = execute_with_params(connection, "#{sql} RETURNING #{id_column}", params)&.first
+        row && row[id_column].to_i
+      end
+
+      # pg upserts with ON CONFLICT ... DO UPDATE, reading the incoming row from EXCLUDED.
+      def upsert_clause(conflict_columns, update_columns)
+        assignments = update_columns.map { |column| "#{column} = EXCLUDED.#{column}" }.join(', ')
+        "ON CONFLICT (#{conflict_columns.join(', ')}) DO UPDATE SET #{assignments}"
+      end
+
+      # pg resolves an unqualified operator through the search_path, where a user-defined operator
+      # with a closer type match would be chosen over the built-in one, so pin it to pg_catalog.
+      def equals_operator
+        'OPERATOR(pg_catalog.=)'
+      end
+
+      def foreign_key_query
+        eq = equals_operator
+        'SELECT kcu.column_name AS from_column, ccu.table_name AS to_table, ccu.column_name AS to_column ' \
+          'FROM information_schema.table_constraints tc ' \
+          'JOIN information_schema.key_column_usage kcu ' \
+          "ON tc.constraint_name #{eq} kcu.constraint_name AND tc.table_schema #{eq} kcu.table_schema " \
+          'JOIN information_schema.constraint_column_usage ccu ' \
+          "ON tc.constraint_name #{eq} ccu.constraint_name AND tc.table_schema #{eq} ccu.table_schema " \
+          "WHERE tc.constraint_type #{eq} 'FOREIGN KEY' AND tc.table_schema #{eq} $1 AND tc.table_name #{eq} $2"
+      end
+
+      def closed?(connection)
+        connection.finished? || connection.status != ::PG::CONNECTION_OK
+      end
+
+      def close_connection(connection)
+        return if connection.nil? || connection.finished?
+
+        connection.close
+      rescue StandardError => e
+        logger.error("Failed to close PostgreSQL connection: #{e.message}")
+      end
+
+      def sql_state(exception)
+        return nil unless exception.is_a?(::PG::Error) && exception.result
+
+        exception.result.error_field(::PG::PG_DIAG_SQLSTATE)
+      end
+
+      def network_bound_methods
+        NETWORK_BOUND_METHODS
+      end
+
+      def prepare_connect_config(host_info, config)
+        cfg = {}
+        config.each { |k, v| cfg[k] = v }
+        cfg[:host] = host_info.host if host_info.host_specified?
+        cfg[:port] = host_info.port if host_info.port_specified?
+        cfg[:dbname] = cfg.delete(:database) if !cfg.key?(:dbname) && cfg.key?(:database)
+        cfg
+      end
+
+      def apply_monitoring_defaults(driver_props)
+        driver_props[:connect_timeout] ||= DEFAULT_MONITORING_TIMEOUT_SEC
+      end
+
+      # PG reads transaction state directly from the connection.
+      # Returns nil for PQTRANS_UNKNOWN (broken) and PQTRANS_ACTIVE (command in flight)
+      # so SessionStateService falls back to SQL inference.
+      def reported_in_transaction(connection)
+        case connection.transaction_status
+        when ::PG::PQTRANS_INTRANS, ::PG::PQTRANS_INERROR then true
+        when ::PG::PQTRANS_IDLE then false
+        end
+      rescue ::PG::ConnectionBad
+        false
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/errors/error_handler.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module AwsAdvancedRubyDriverWrapper
+  module Errors
+    module ErrorHandler
+      def network_error?(error)
+        check_cause_chain(error) { |sql_state, _| network_error_by_sql_state?(sql_state) }
+      end
+
+      def network_error_by_sql_state?(sql_state)
+        raise NotImplementedError
+      end
+
+      def login_error?(error)
+        check_cause_chain(error) { |sql_state, _| login_error_by_sql_state?(sql_state) }
+      end
+
+      def login_error_by_sql_state?(sql_state)
+        raise NotImplementedError
+      end
+
+      def read_only_error?(error)
+        check_cause_chain(error) { |sql_state, _| read_only_error_by_sql_state?(sql_state) }
+      end
+
+      def read_only_error_by_sql_state?(sql_state, error_code = nil)
+        raise NotImplementedError
+      end
+
+      private
+
+      def extract_sql_state(error)
+        @driver_dialect.sql_state(error)
+      end
+
+      def check_cause_chain(error)
+        current = error
+        while current
+          sql_state = extract_sql_state(current)
+          return true if yield(sql_state, current)
+
+          current = current.cause
+        end
+        false
+      end
+    end
+  end
+end