neo4j-ruby-driver 4.4.0.alpha.6 → 4.4.0.alpha.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1dc1f5cbdb0085a5e75fd3809b9e830c5c60e93f688e42c939c2fbe7015bde7
-  data.tar.gz: 81786afebfdb15a41550bf5997aef82adcb26ea8f5551a1e48e8c7571211e994
+  metadata.gz: a035a8385e54c70c851003ce4131072610617d515f118d2d4b03f6ada71de3a7
+  data.tar.gz: bc8dfddb76165d4aea25d702e1d4bb1be5db3bb375d25f48fab39acb7f247c07
 SHA512:
-  metadata.gz: 0ba9e1ff39437d069150c3d7706a93c7b21054d2fb5e03ecc1bdc2cd864145bd2609cfca46448b0a84354f78ab983164b25bdcc12e8fb8b6061eea498c4651c3
-  data.tar.gz: 3549a85e58efeb737c6d48cde04ce8da6bd2e2d07d2b927ff8669a4a9fca390f621e60e7e6670d286b66cb242aff625b1112760e8470632a8f6a89464bae4c20
+  metadata.gz: 17a1b5ada9f09120e7dda4316504d59fedf366696d27c26e87c5feeee381a876409a75eaa05cbc177af64415946af7ec8c1de7b4ed5e637ffc464a40c1fd4eea
+  data.tar.gz: aa41d20c4794dac6841aa1bf70cb0c3e8573a658e74d8aa4e475f45a2a0a9072056633a83f8744251014ab5a805b6ec368f4a75b036316c2179bc1bcc1f8f8fa

data/lib/neo4j/driver/exceptions/protocol_exception.rb

@@ -8,8 +8,8 @@ module Neo4j
       class ProtocolException < Neo4jException
         CODE = "Protocol violation: "
 
-        def initialize(message, e)
-          super("#{CODE}message", e)
+        def initialize(message, e = nil)
+          super(nil, "#{CODE}#{message}", e)
         end
       end
     end

data/lib/neo4j/driver/internal/bolt_server_address.rb

@@ -67,13 +67,15 @@ module Neo4j::Driver
       LOCAL_DEFAULT = new(host: 'localhost', port: DEFAULT_PORT)
 
       def self.from(address)
-        address.is_a?(BoltServerAddress) ? address : new(address.host, address.port)
+        address.is_a?(BoltServerAddress) ? address : new(host: address.host, port: address.port)
       end
 
-      def eql?(other)
-        attributes.eql?(other&.attributes)
+      def ==(other)
+        attributes == other&.attributes
       end
 
+      alias eql? ==
+
       def to_s
         "#{host}#{"(#{connection_host})" unless host == connection_host}:#{port}"
       end
@@ -84,11 +86,9 @@ module Neo4j::Driver
 
       # @return stream of unicast addresses.
       def unicast_stream
-        [self]
+        Set[self]
       end
 
-      private
-
       def attributes
         [@host, @connection_host, @port]
       end

data/lib/neo4j/driver/types/time.rb

@@ -30,10 +30,12 @@ module Neo4j
           end
         end
 
-        def eql?(other)
-          other.is_a?(self.class) && self.class.significant_fields.all? { |elem| send(elem).eql?(other.send(elem)) }
+        def ==(other)
+          other.is_a?(self.class) && self.class.significant_fields.all? { |elem| send(elem) == other.send(elem) }
         end
 
+        alias eql? ==
+
         def +(numeric)
           self.class.new(@time + numeric)
         end

data/ruby/neo4j/driver/internal/async/network_session.rb

@@ -10,8 +10,8 @@ module Neo4j::Driver
           @retry_logic = retry_logic
           @log = Logging::PrefixedLogger.new("[#{hash}]", logger)
           @bookmark_holder = bookmark_holder
-          @database_name = database_name.database_name
-          @connection_context = NetworkSessionConnectionContext.new(@database_name, @bookmark_holder.bookmark, impersonated_user)
+          # @database_name = database_name.database_name
+          @connection_context = NetworkSessionConnectionContext.new(database_name, @bookmark_holder.bookmark, impersonated_user)
           @fetch_size = fetch_size
           @open = Concurrent::AtomicBoolean.new(true)
         end
@@ -133,7 +133,8 @@ module Neo4j::Driver
           # This bookmark is only used for rediscovery.
           # It has to be the initial bookmark given at the creation of the session.
           # As only that bookmark could carry extra system bookmarks
-          attr_reader :database_name, :mode, :rediscovery_bookmark, :impersonated_user
+          attr_accessor :database_name
+          attr :mode, :rediscovery_bookmark, :impersonated_user
 
           def initialize(database_name, bookmark, impersonated_user)
             @database_name = database_name

data/ruby/neo4j/driver/internal/async/pool/{netty_channel_tracker.rb → channel_tracker.rb}

@@ -2,22 +2,20 @@ module Neo4j::Driver
   module Internal
     module Async
       module Pool
-        class NettyChannelTracker
+        class ChannelTracker
           attr_reader :lock, :read, :write, :address_to_in_use_channel_count, :address_to_idle_channel_count, :log,
                       :metrics_listener, :close_listener, :all_channels
 
-          def initialize(metrics_listener, logger, options = {},event_executor = nil, channels = nil)
+          def initialize(metrics_listener, logger, **options)
             @metrics_listener = metrics_listener
             @log = logger
-            @all_channels = options[:channels] ? channels : Java::IoNettyChannelGroup::DefaultChannelGroup.new("all-connections", options[:event_executor])
-            @lock = java.util.concurrent.locks.ReentrantReadWriteLock.new
-            @read = lock.read_lock
-            @write = lock.write_lock
-            @close_listener = -> (future) { channel_closed(future.channel) }
+            @all_channels = options[:channels]
+            @lock = Concurrent::ReentrantReadWriteLock.new
+            @close_listener = method(:channel_closed)
           end
 
           def channel_released(channel)
-            do_in_write_lock do
+            @lock.with_write_lock do
               decrement_in_use(channel)
               increment_idle(channel)
               channel.close_future.add_listener(close_listener)

data/ruby/neo4j/driver/internal/async/pool/connection_pool_impl.rb

@@ -32,8 +32,7 @@ module Neo4j::Driver
             @address_to_pool_lock.with_write_lock do
               @address_to_pool.each do |address, pool|
                 unless addresses_to_retain.include?(address)
-                  active_channels = @netty_channel_tracker.in_use_channel_count(address)
-                  if active_channels.zero?
+                  unless pool.busy?
                     # address is not present in updated routing table and has no active connections
                     # it's now safe to terminate corresponding connection pool and forget about it
                     @address_to_pool.delete(address)
@@ -48,7 +47,8 @@ module Neo4j::Driver
           end
 
           def in_use_connections(address)
-            @netty_channel_tracker.in_use_channel_count(address)
+            @address_to_pool[address]&.size || 0
+            # @netty_channel_tracker.in_use_channel_count(address)
           end
 
           def idle_connections(address)

data/ruby/neo4j/driver/internal/cluster/cluster_composition.rb

@@ -2,45 +2,35 @@ module Neo4j::Driver
   module Internal
     module Cluster
       class ClusterComposition < Struct.new(:expiration_timestamp, :readers, :writers, :routers, :database_name)
-        private
-
-        MAX_LONG = 2 ^ 63 - 1
-        MAX_TTL = MAX_LONG / 1000
-
-        public
-
         def initialize(expiration_timestamp:, database_name:, readers: [], writers: [], routers: [])
           super(expiration_timestamp, readers, writers, routers, database_name)
         end
 
         def has_writers?
-          @writers.present?
+          writers.present?
         end
 
         def has_routers_and_readers?
-          @routers.present? && @readers.present?
+          routers.present? && readers.present?
         end
 
         def self.parse(record, now)
-          return if record.nil?
-          new(expiration_timestamp: expiration_timestamp(now, record), database_name: record['db'],
-              **record['servers'].to_h { |value| [servers(value['role']), BoltServerAddress.new(value['addresses'])] })
+          return unless record
+          new(expiration_timestamp: expiration_timestamp(now, record), database_name: record[:db],
+              **record[:servers].to_h do |value|
+                [servers(value[:role]),
+                 value[:addresses].map { |address| BoltServerAddress.new(uri: BoltServerAddress.uri_from(address)) }]
+              end)
         end
 
         private
 
         def self.expiration_timestamp(now, record)
           ttl = record['ttl']
-          expiration_timestamp = now + ttl * 1000
-
-          if ttl < 0 || ttl >= MAX_TTL || expiration_timestamp < 0
-            expiration_timestamp = MAX_LONG
-          end
-
-          expiration_timestamp
+          now + (ttl.negative? ? 1000.years : ttl.seconds)
         end
 
-        def servers(role)
+        def self.servers(role)
           case role
           when 'READ'
             :readers

data/ruby/neo4j/driver/internal/cluster/cluster_composition_lookup_result.rb

@@ -2,10 +2,10 @@ module Neo4j::Driver
   module Internal
     module Cluster
       class ClusterCompositionLookupResult
-        attr_reader :composition, :resolved_initial_routers
+        attr_reader :cluster_composition, :resolved_initial_routers
 
         def initialize(composition, resolved_initial_routers = nil)
-          @composition = composition
+          @cluster_composition = composition
           @resolved_initial_routers = resolved_initial_routers
         end
       end

data/ruby/neo4j/driver/internal/cluster/cluster_routing_table.rb

@@ -4,39 +4,32 @@ module Neo4j::Driver
       class ClusterRoutingTable
         MIN_ROUTERS = 1
 
-        attr_reader :database_name
-
-        def initialize(of_database, clock, routing_addresses)
+        def initialize(of_database, _clock, *routing_addresses)
           @database_name = of_database
-          @clock = clock
-          @expiration_timestamp = clock.millis - 1
-          @routers = routing_addresses.freeze
-          @table_lock = java.util.concurrent.locks.ReentrantReadWriteLock.new
+          @expiration_timestamp = Time.now
+          @routers = routing_addresses.to_set.freeze
+          @table_lock = Concurrent::ReentrantReadWriteLock.new
           @prefer_initial_router = true
-          @disused = {}
-          @readers = []
-          @writers = []
+          @disused = Set.new
+          @readers = Set.new
+          @writers = Set.new
         end
 
         def stale_for?(mode)
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock) do
-            @expiration_timestamp < @clock.millis ||
-            routers.size < MIN_ROUTERS ||
-            (mode == AccessMode::READ && @readers.size == 0) ||
-            (mode == AccessMode::WRITE && @writers.size == 0)
+          @table_lock.with_read_lock do
+            @expiration_timestamp <= Time.now ||
+              routers.size < MIN_ROUTERS ||
+              (mode == AccessMode::READ && @readers.size == 0) ||
+              (mode == AccessMode::WRITE && @writers.size == 0)
           end
         end
 
         def has_been_stale_for?(extra_time)
-          total_time = Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @expiration_timestamp }) + extra_time
-
-          total_time = java.lang.Long::MAX_VALUE if total_time < 0
-
-          total_time < @clock.millis
+          Time.now - @table_lock.with_read_lock { @expiration_timestamp } >= extra_time
         end
 
         def update(cluster)
-          Util::LockUtil.execute_with_lock(@table_lock.write_lock) do
+          @table_lock.with_write_lock do
             @expiration_timestamp = cluster.expiration_timestamp
             @readers = new_with_reused_addresses(@readers, @disused, cluster.readers)
             @writers = new_with_reused_addresses(@writers, @disused, cluster.writers)
@@ -47,7 +40,7 @@ module Neo4j::Driver
         end
 
         def forget(address)
-          Util::LockUtil.execute_with_lock(@table_lock.write_lock) do
+          @table_lock.with_write_lock do
             @routers = new_without_address_if_present(@routers, address)
             @readers = new_without_address_if_present(@readers, address)
             @writers = new_without_address_if_present(@writers, address)
@@ -56,27 +49,27 @@ module Neo4j::Driver
         end
 
         def readers
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @readers })
+          @table_lock.with_read_lock { @readers }
         end
 
         def writers
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @writers })
+          @table_lock.with_read_lock { @writers }
         end
 
         def routers
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @routers })
+          @table_lock.with_read_lock { @routers }
         end
 
         def servers
-          Util::LockUtil.execute_with_lock(@table_lock.write_lock) do
-            servers = []
-            servers << (@readers)
-            servers << (@writers)
-            servers << (@routers)
-            servers << (@disused)
+          @table_lock.with_write_lock do
+            [@readers, @writers, @routers, @disused].reduce(&:+)
           end
         end
 
+        def database
+          @database_name
+        end
+
         def forget_writer(to_remove)
           Util::LockUtil.execute_with_lock(@table_lock.write_lock) do
             @writers = new_without_address_if_present(@writers, to_remove)
@@ -85,53 +78,43 @@ module Neo4j::Driver
         end
 
         def replace_router_if_present(old_router, new_router)
-          Util::LockUtil.execute_with_lock(@table_lock.write_lock, -> () { @routers = new_with_address_replaced_if_present(@routers, old_router, new_router) } )
+          @table_lock.with_write_lock { @routers = new_with_address_replaced_if_present(@routers, old_router, new_router) }
         end
 
         def prefer_initial_router
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @prefer_initial_router })
+          @table_lock.with_read_lock { @prefer_initial_router }
         end
 
         def expiration_timestamp
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @expiration_timestamp })
+          @table_lock.with_read_lock { @expiration_timestamp }
         end
 
         def to_s
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock) do
-            "Ttl #{@expiration_timestamp}, currentTime #{@clock.millis}, routers #{@routers}, writers #{@writers}, readers #{@readers}, database '#{database_name.description}'"
+          @table_lock.with_read_lock do
+            "Ttl #{@expiration_timestamp}, currentTime #{Time.now}, routers #{@routers}, writers #{@writers}, readers #{@readers}, database '#{@database_name.description}'"
           end
         end
 
         private
 
         def new_without_address_if_present(addresses, address_to_skip)
-          new_list = []
-
-          addresses.each do |address|
-            new_list << address unless address.eql?(address_to_skip)
-          end
-
-          new_list.freeze
+          (addresses - [address_to_skip]).freeze
         end
 
         def new_with_address_replaced_if_present(addresses, old_address, new_address)
-          new_list = []
-
-          addresses.each { |address| new_list << address.eql?(old_address) ? new_address : address }
-
-          new_list.freeze
+          addresses.map { |address| address == old_address ? new_address : address }.freeze
         end
 
         def new_with_reused_addresses(current_addresses, disused_addresses, new_addresses)
-          new_list = java.util.stream.Stream.concat(current_addresses.stream, disused_addresses.stream)
-                                            .filter(-> (address) { new_addresses.remove(to_bolt_server_address(address)) })
-                                            .collect(java.util.stream.Collectors.to_collection(-> () { Array.new(new_addresses.size) }))
-          new_list << new_addresses
-          new_list.freeze
+          (current_addresses + disused_addresses + new_addresses).freeze
         end
 
         def to_bolt_server_address(address)
-          BoltServerAddress.class.eql?(address.class) ? address : BoltServerAddress.new(address.host, address.port)
+          if BoltServerAddress.class == address.class
+            address
+          else
+            BoltServerAddress.new(host: address.host, port: address.port)
+          end
         end
       end
     end

data/ruby/neo4j/driver/internal/cluster/identity_resolver.rb

@@ -3,10 +3,7 @@ module Neo4j::Driver
     module Cluster
       class IdentityResolver
         IDENTITY_RESOLVER = new
-
-        def resolve(initial_router)
-          java.util.Collections.singleton(initial_router)
-        end
+        alias resolve Array
       end
     end
   end

data/ruby/neo4j/driver/internal/cluster/loadbalancing/least_connected_load_balancing_strategy.rb

@@ -28,10 +28,9 @@ module Neo4j::Driver
 
           def select(addresses, addresses_index, address_type)
             size = addresses.size
-
             if size == 0
               @log.debug("Unable to select #{address_type}, no known addresses given")
-              return nil
+              return
             end
 
             # choose start index for iteration in round-robin fashion
@@ -39,22 +38,23 @@ module Neo4j::Driver
             index = start_index
 
             least_connected_address = nil
-            least_active_connections = java.lang.Integer::MAX_VALUE
+            least_active_connections = nil
 
             # iterate over the array to find the least connected address
+            addresses = addresses.to_a
             loop do
               address = addresses[index]
               active_connections = @connection_pool.in_use_connections(address)
 
-              if active_connections < least_active_connections
+              if least_active_connections.nil? || active_connections < least_active_connections
                 least_connected_address = address
                 least_active_connections = active_connections
               end
 
               # loop over to the start of the array when end is reached
-              index = (index == size - 1) ? 0 : index += 1
+              index = (index + 1) % size
 
-              break if index != start_index
+              break if index == start_index
             end
 
             @log.debug("Selected #{address_type} with address: '#{least_connected_address}' and active connections: #{least_active_connections}")

data/ruby/neo4j/driver/internal/cluster/loadbalancing/load_balancer.rb

@@ -8,8 +8,6 @@ module Neo4j::Driver
           CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE = "Failed to obtain a connection towards address %s, will try other addresses if available. Complete failure is reported separately from this entry."
           BOLT_SERVER_ADDRESSES_EMPTY_ARRAY = []
 
-          attr_reader :routing_tables
-
           delegate :close, to: :@connection_pool
 
           def initialize(initial_router, settings, connection_pool, event_executor_group, logger, load_balancing_strategy, resolver, &domain_name_resolver)
@@ -23,106 +21,72 @@ module Neo4j::Driver
           end
 
           def acquire_connection(context)
-            @routing_tables.ensure_routing_table(context).then_flat do |handler|
-              acquire(context.mode, handler.routing_table).then do |connection|
-                Async::Connection::RoutingConnection.new(connection,
-                                                         Util::Futures.join_now_or_else_throw(context.database_name, Async::ConnectionContext::PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER),
-                                                         context.mode, context.impersonated_user, handler)
-              end
-            end
+            handler = @routing_tables.ensure_routing_table(context)
+            connection = acquire(context.mode, handler.routing_table)
+            Async::Connection::RoutingConnection.new(connection, context.database_name, context.mode,
+                                                     context.impersonated_user, handler)
           end
 
           def verify_connectivity
-            supports_multi_db?.then_flat do |supports|
-              @routing_tables.ensure_routing_table(Async::ImmutableConnectionContext.simple(supports)) do |_, error|
-                if error.is_a? Exceptions::ServiceUnavailableException
-                  raise Exceptions::ServiceUnavailableException.new(
-                    'Unable to connect to database management service, ensure the database is running and that there is a working network connection to it.',
-                    error)
-                end
-              end
-            end
+            @routing_tables.ensure_routing_table(Async::ImmutableConnectionContext.simple(supports_multi_db?))
+          rescue Exceptions::ServiceUnavailableException
+            raise Exceptions::ServiceUnavailableException,
+                  'Unable to connect to database management service, ensure the database is running and that there is a working network connection to it.'
           end
 
-          def supports_multi_db?
-            begin
-              addresses = @rediscovery.resolve
-            rescue StandardError => error
-              return Util::Futures.failed_future(error)
-            end
+          def routing_table_registry
+            @routing_tables
+          end
 
-            result = Util::Futures.completed_with_null
+          def supports_multi_db?
+            addresses = @rediscovery.resolve
             base_error = Exceptions::ServiceUnavailableException.new("Failed to perform multi-databases feature detection with the following servers: #{addresses}")
-
-            addresses.each do |address|
-              result = Util::Futures.on_error_continue(result, base_error) do |error|
-                # We fail fast on security errors
-                if error.is_a? Exceptions::SecurityException
-                  Util::Futures.failed_future(error)
-                else
-                  private_suports_multi_db?(address)
-                end
-              end
-            end
-
-            Util::Futures.on_error_continue(result, base_error) do |error|
-              # If we failed with security errors, then we rethrow the security error out, otherwise we throw the chained errors.
-              Util::Futures.failed_future((error.is_a? Exceptions::SecurityException) ? error : base_error)
-            end
+            addresses.lazy.map do |address|
+              private_suports_multi_db?(address)
+            rescue Exceptions::SecurityException
+              raise
+            rescue => error
+              Util::Futures.combine_errors(base_error, error)
+            end.find { |result| !result.nil? } or raise base_error
           end
 
           private
 
           def private_suports_multi_db?(address)
-            @connection_pool.acquire(address).then_flat do |conn|
-              supports_multi_database = Messaging::Request::MultiDatabaseUtil.supports_multi_database(conn)
-              conn.release.then_apply(-> (_ignored) { supports_multi_database })
-            end
+            conn = @connection_pool.acquire(address)
+            Messaging::Request::MultiDatabaseUtil.supports_multi_database?(conn)
+          ensure
+            conn&.release
           end
 
-          def acquire(mode, routing_table, result = nil, attempt_errors = nil)
-            unless result.present? && attempt_errors.present?
-              result = java.util.concurrent.CompletableFuture.new
-              attempt_exceptions = []
-            end
-
+          def acquire(mode, routing_table, attempt_errors = [])
             addresses = addresses_by_mode(mode, routing_table)
             address = select_address(mode, addresses)
 
-            if address.nil?
-              completion_error = Exceptions::SessionExpiredException.new(CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE % [mode, routing_table])
-              attempt_errors.each { completion_error::add_suppressed }
-
-              @log.error(CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE % completion_error)
-              result.complete_exceptionally(completion_error)
-              return
+            unless address
+              error = Exceptions::SessionExpiredException.new(CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE % [mode, routing_table])
+              attempt_errors.each(&error.method(:add_suppressed))
+              @log.error(CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE)
+              @log.error(error)
+              raise error
             end
 
-            @connection_pool.acquire(address).when_complete do |connection, completion_error|
-              error = Util::Futures.completion_exception_cause(completion_error)
-
-              if error.nil?
-                result.complete(connection)
-              else
-                if !error.is_a? Exceptions::ServiceUnavailableException
-                  result.complete_exceptionally(error)
-                else
-                  attempt_message = CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE % address
-                  @log.warn(attempt_message)
-                  @log.debug(attempt_message, error)
-                  attempt_errors << error
-                  routing_table.forget(address)
-                  @event_executor_group.next.execute(-> () { acquire(mode, routing_table, result, attempt_errors) })
-                end
-              end
+            begin
+              @connection_pool.acquire(address)
+            rescue Exceptions::ServiceUnavailableException => error
+              @log.warn { CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE % address }
+              @log.debug(error)
+              attempt_errors << error
+              routing_table.forget(address)
+              acquire(mode, routing_table, attempt_errors)
             end
           end
 
           def addresses_by_mode(mode, routing_table)
             case mode
-            when READ
+            when AccessMode::READ
               routing_table.readers
-            when WRITE
+            when AccessMode::WRITE
               routing_table.writers
             else
               raise unknown_mode mode
@@ -131,9 +95,9 @@ module Neo4j::Driver
 
           def select_address(mode, addresses)
             case mode
-            when READ
+            when AccessMode::READ
               @load_balancing_strategy.select_reader(addresses)
-            when WRITE
+            when AccessMode::WRITE
               @load_balancing_strategy.select_writer(addresses)
             else
               raise unknown_mode mode
@@ -141,7 +105,7 @@ module Neo4j::Driver
           end
 
           def create_routing_tables(connection_pool, rediscovery, settings, clock, logger)
-            RoutingTableRegistryImpl.new(connection_pool, rediscovery, clock, logger, DurationNormalizer.milliseconds(settings.routing_table_purge_delay))
+            RoutingTableRegistryImpl.new(connection_pool, rediscovery, clock, logger, settings.routing_table_purge_delay)
           end
 
           def create_rediscovery(event_executor_group, initial_router, resolver, settings, clock, logger, domain_name_resolver)

data/ruby/neo4j/driver/internal/cluster/multi_databases_routing_procedure_runner.rb

@@ -5,13 +5,9 @@ module Neo4j::Driver
       # This implementation of the {@link RoutingProcedureRunner} works with multi database versions of Neo4j calling
       # the procedure `dbms.routing.getRoutingTable`
       class MultiDatabasesRoutingProcedureRunner < SingleDatabaseRoutingProcedureRunner
-        DATABASE_NAME = 'database'
+        DATABASE_NAME = :database
         MULTI_DB_GET_ROUTING_TABLE = "CALL dbms.routing.getRoutingTable($%s, $%s)" % [SingleDatabaseRoutingProcedureRunner::ROUTING_CONTEXT, DATABASE_NAME]
 
-        def initialize(context)
-          super(context)
-        end
-
         private
 
         def bookmark_holder(bookmark)
@@ -19,10 +15,11 @@ module Neo4j::Driver
         end
 
         def procedure_query(server_version, database_name)
-          map = {}
-          map[SingleDatabaseRoutingProcedureRunner::ROUTING_CONTEXT] = Values.value(context.to_map)
-          map[DATABASE_NAME] = Values.value(database_name.database_name)
-          Query.new(MULTI_DB_GET_ROUTING_TABLE, Values.value(map))
+          map = {
+            SingleDatabaseRoutingProcedureRunner::ROUTING_CONTEXT => @context.to_h,
+            DATABASE_NAME => database_name.database_name
+          }
+          Query.new(MULTI_DB_GET_ROUTING_TABLE, **map)
         end
 
         def connection(connection)