neo4j-ruby-driver 4.4.0.alpha.5 → 4.4.0.alpha.8

data/ruby/neo4j/driver/internal/handlers/legacy_pull_all_response_handler.rb

@@ -4,7 +4,7 @@ module Neo4j::Driver
       # This is the Pull All response handler that handles pull all messages in Bolt v3 and previous protocol versions.
       class LegacyPullAllResponseHandler
         include Spi::ResponseHandler
-        UNINITIALIZED_RECORDS = []
+        include Enumerable
         RECORD_BUFFER_LOW_WATERMARK = ENV['record_buffer_low_watermark']&.to_i || 300
         RECORD_BUFFER_HIGH_WATERMARK = ENV['record_buffer_high_watermark']&.to_i || 1000
 
@@ -14,7 +14,7 @@ module Neo4j::Driver
           @metadata_extractor = Internal::Validator.require_non_nil!(metadata_extractor)
           @connection = Internal::Validator.require_non_nil!(connection)
           @completion_listener = Internal::Validator.require_non_nil!(completion_listener)
-          @records = UNINITIALIZED_RECORDS
+          @records = ::Async::Queue.new
         end
 
         def can_manage_auto_read?
@@ -39,7 +39,7 @@ module Neo4j::Driver
 
           failed_record_future = fail_record_future(error)
 
-          if fail_record_future
+          if failed_record_future
             # error propagated through the record future
             complete_failure_future(nil)
           else
@@ -54,7 +54,7 @@ module Neo4j::Driver
           if @ignore_records
             complete_record_future(nil)
           else
-            record = InternalRecord.new(run_response_handler.query_keys, fields)
+            record = InternalRecord.new(@run_response_handler.query_keys, fields)
             enqueue_record(record)
             complete_record_future(record)
           end
@@ -65,45 +65,74 @@ module Neo4j::Driver
         end
 
         def peek_async
-          record = @records.first
+          while @records.empty? && !(@ignore_records || @finished)
+            @records.wait
+          end
+          record = @records.items.first
 
-          if record.nil?
-            return Util::Futures.failed_future(extract_failure) unless @failure.nil?
+          Util::ResultHolder.successful(record)
 
-            return Util::Futures.completed_with_null if @ignore_records || @finished
+          # if record.nil?
+          #   return Util::Futures.failed_future(extract_failure) unless @failure.nil?
 
-            @record_future = java.util.concurrent.CompletableFuture.new if @record_future.nil?
+          #   return Util::Futures.completed_with_null if @ignore_records || @finished
 
-            @record_future
-          else
-            java.util.concurrent.CompletableFuture.completed_future(record)
-          end
+          #   @record_future = java.util.concurrent.CompletableFuture.new if @record_future.nil?
+
+          #   @record_future
+          # else
+          #   # java.util.concurrent.CompletableFuture.completed_future(record)
+          #   record
+          # end
         end
 
         def next_async
-          peek_async.then_apply(-> (_ignore) { dequeue_record })
+          # dequeue_record if peek_async
+          peek_async.then { |record| dequeue_record if record }
         end
 
         def consume_async
           @ignore_records = true
-          @records.clear
+          @records.items.clear
 
-          pull_all_failure_async.then_apply do |error|
-            unless error.nil?
-              raise Util::Futures.as_completion_exception, error
-            end
+          # if pull_all_failure_async.nil?
+          #   # @summary.then(&Util::ResultHolder.method(:successful))
+          #   Util::ResultHolder.successful(@summary)
+          # else
+          #   raise pull_all_failure_async
+          # end
 
-            @summary
+          if @failure
+            Util::ResultHolder.failed(extract_failure)
+          else
+            Util::ResultHolder.successful(@summary)
           end
+
+          # pull_all_failure_async do |error|
+          #   unless error.nil?
+          #     raise Util::Futures.as_completion_exception, error
+          #   end
+
+          #   @summary
+          # end
         end
 
-        def list_async(map_function)
-          pull_all_failure_async.then_apply do |error|
-            unless error.nil?
-              raise Util::Futures.as_completion_exception, error
-            end
+        # def list_async(map_function)
+        #   pull_all_failure_async.then_apply do |error|
+        #     unless error.nil?
+        #       raise Util::Futures.as_completion_exception, error
+        #     end
 
-            records_as_list(map_function)
+        #     records_as_list(map_function)
+        #   end
+        # end
+
+        def each
+          pull_all_failure_async.then do
+            unless @finished
+              raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
+            end
+            @records.each { |record| yield record }
           end
         end
 
@@ -113,9 +142,11 @@ module Neo4j::Driver
 
         def pull_all_failure_async
           if !@failure.nil?
-            return java.util.concurrent.CompletableFuture.completed_future(extract_failure)
+            return Util::ResultHolder.failed(extract_failure)
+            # return java.util.concurrent.CompletableFuture.completed_future(extract_failure)
           elsif @finished
-            return Util::Futures.completed_with_null
+            return nil
+            # return Util::Futures.completed_with_null
           else
             if @failure_future.nil?
               # neither SUCCESS nor FAILURE message has arrived, register future to be notified when it arrives
@@ -139,7 +170,7 @@ module Neo4j::Driver
           # when failure is requested we have to buffer all remaining records and then return the error
           # do not disable auto-read in this case, otherwise records will not be consumed and trailing
           # SUCCESS or FAILURE message will not arrive as well, so callers will get stuck waiting for the error
-          if !should_buffer_all_records && records.size > RECORD_BUFFER_HIGH_WATERMARK
+          if !should_buffer_all_records && @records.size > RECORD_BUFFER_HIGH_WATERMARK
             # more than high watermark records are already queued, tell connection to stop auto-reading from network
             # this is needed to deal with slow consumers, we do not want to buffer all records in memory if they are
             # fetched from network faster than consumed
@@ -148,7 +179,7 @@ module Neo4j::Driver
         end
 
         def dequeue_record
-          record = @records.drop(1)
+          record = @records.dequeue
 
           if @records.size < RECORD_BUFFER_LOW_WATERMARK
             # less than low watermark records are now available in the buffer, tell connection to pre-fetch more
@@ -170,7 +201,7 @@ module Neo4j::Driver
             result << map_function.apply(record)
           end
 
-          @records.clear
+          @records.items.clear
           result
         end
 
@@ -181,33 +212,41 @@ module Neo4j::Driver
         end
 
         def complete_record_future(record)
-          unless @record_future.nil?
-            future = @record_future
-            @record_future = nil
-            future.complete(record)
-          end
+          # unless @record_future.nil?
+          #   future = @record_future
+          #   @record_future = nil
+          #   future.complete(record)
+          # end
+          @record_future&.succeed(record)
+          @record_future = nil
         end
 
         def fail_record_future(error)
-          unless @record_future.nil?
-            future = @record_future
+          # unless @record_future.nil?
+          #   future = @record_future
+          #   @record_future = nil
+          #   future.complete_exceptionally(error)
+          #   return true
+          # end
+
+          # false
+            @record_future&.fail(error)
+          ensure
             @record_future = nil
-            future.complete_exceptionally(error)
-            return true
-          end
-
-          false
         end
 
         def complete_failure_future(error)
-          unless @failure_future.nil?
-            future = @failure_future
-            @failure_future = nil
-            future.complete(error)
-            return true
-          end
-
-          false
+          # unless @failure_future.nil?
+          #   future = @failure_future
+          #   @failure_future = nil
+          #   future.complete(error)
+          #   return true
+          # end
+
+          # false
+          @failure_future&.fail(error)
+        ensure
+          @failure_future = nil
         end
 
         def extract_result_summary(metadata)

data/ruby/neo4j/driver/internal/handlers/pulln/auto_pull_response_handler.rb

@@ -3,6 +3,7 @@ module Neo4j::Driver
     module Handlers
       module Pulln
         class AutoPullResponseHandler < BasicPullResponseHandler
+          include Enumerable
           delegate :signal, to: :@records
           LONG_MAX_VALUE = 2 ** 63 - 1
 
@@ -55,7 +56,7 @@ module Neo4j::Driver
 
           private def handle_failure(error)
             # error has not been propagated to the user, remember it
-            unless fail_record_future(error) && fail_summary_future(error)
+            unless fail_record_future(error) || fail_summary_future(error)
               @failure = error
             end
           end
@@ -64,26 +65,31 @@ module Neo4j::Driver
             while @records.empty? && !done?
               @records.wait
             end
-            @records.items.first
+            @records.items.first&.then(&Util::ResultHolder.method(:successful)) or
+              completed_with_value_if_no_failure(nil)
           end
 
           def next_async
-            dequeue_record if peek_async
+            peek_async.then { |record| dequeue_record if record }
           end
 
           def consume_async
             @records.items.clear
-            return completed_with_value_if_no_failure(@summary) if done?
-            cancel
-            @summary
+            cancel unless done?
+            completed_with_value_if_no_failure(@summary)
           end
 
-          def list_async(&map_function)
-            pull_all_async.then_apply(-> (summary) { records_as_list(&map_function) })
+          def each
+            pull_all_async.then do
+              unless done?
+                raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
+              end
+              @records.each { |record| yield record }
+            end
           end
 
           def pull_all_failure_async
-            pull_all_async
+            pull_all_async.chain { |_, error| error }
           end
 
           def pre_populate_records
@@ -94,12 +100,8 @@ module Neo4j::Driver
 
           def pull_all_async
             return completed_with_value_if_no_failure(@summary) if done?
-
             request(FetchSizeUtil::UNLIMITED_FETCH_SIZE)
-
-            @summary_future = java.util.concurrent.CompletableFuture.new if @summary_future.nil?
-
-            @summary_future
+            @summary_future ||= Util::ResultHolder.new
           end
 
           def enqueue_record(record)
@@ -122,14 +124,6 @@ module Neo4j::Driver
             record
           end
 
-          def records_as_list(&map_function)
-            unless done?
-              raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
-            end
-
-            @records.each.map(&map_function)
-          end
-
           def extract_failure
             @failure or raise Exceptions::IllegalStateException, "Can't extract failure because it does not exist"
           ensure
@@ -137,39 +131,34 @@ module Neo4j::Driver
           end
 
           def complete_record_future(record)
-            unless @record_future.nil?
-              future = @record_future
-              @record_future = nil
-              future.complete(record)
-            end
+            @record_future&.succeed(record)
+            @record_future = nil
           end
 
           def complete_summary_future(summary)
-            unless @summary_future.nil?
-              future = @summary_future
-              @summary_future = nil
-              future.complete(summary)
-            end
+            @summary_future&.succeed(summary)
+            @summary_future = nil
           end
 
           def fail_record_future(error)
-            unless @record_future.nil?
-              future = @record_future
-              @record_future = nil
-              future.complete(record)
-              return true
-            end
+            @record_future&.fail(error)
+          ensure
+            @record_future = nil
+          end
 
-            false
+          def fail_summary_future(error)
+            @summary_future&.fail(error)
+          ensure
+            @summary_future = nil
           end
 
           def completed_with_value_if_no_failure(value)
-            @failure ? extract_failure : value
+            if @failure
+              Util::ResultHolder.failed(extract_failure)
+            else
+              Util::ResultHolder.successful(value)
+            end
           end
-
-          # def request(size)
-          #   @auto_pull_enabled ? Async { super } : super
-          # end
         end
       end
     end

data/ruby/neo4j/driver/internal/handlers/rollback_tx_response_handler.rb

@@ -3,11 +3,17 @@ module Neo4j::Driver
     module Handlers
       class RollbackTxResponseHandler
         include Spi::ResponseHandler
+
+        def initialize(result_holder)
+          @result_holder = result_holder
+        end
+
         def on_success(_metadata)
+          @result_holder.succeed
         end
 
         def on_failure(error)
-          raise error
+          @result_holder.fail(error)
         end
 
         def on_record(fields)

data/ruby/neo4j/driver/internal/impersonation_util.rb

@@ -14,8 +14,8 @@ module Neo4j::Driver
       private
 
       def self.supports_impersonation?(connection)
-        connection.server_version.greater_than_or_equal(Util::ServerVersion::V4_4_0) &&
-        connection.protocol.version.compare_to( Messaging::V44::BoltProtocolV44::VERSION ) >= 0
+        connection.server_version >= Util::ServerVersion::V4_4_0 &&
+          connection.protocol.version >= Messaging::V44::BoltProtocolV44::VERSION
       end
     end
   end

data/ruby/neo4j/driver/internal/internal_bookmark.rb

@@ -2,13 +2,13 @@ module Neo4j::Driver
   module Internal
     class InternalBookmark
       include Bookmark
-      EMPTY = new
       attr :values
       delegate :hash, :empty?, to: :values
 
       private def initialize(*values)
         @values = values.to_set
       end
+      EMPTY = new.freeze
 
       def ==(other)
         equal?(other) || self.class == other.class && values == other.values

data/ruby/neo4j/driver/internal/internal_database_name.rb

@@ -1,10 +1,8 @@
 module Neo4j::Driver
   module Internal
-    class InternalDatabaseName < Struct.new(:database_name)
-      alias description database_name
-
-      def initialize(database_name)
-        super(Validator.require_non_nil!(database_name))
+    class InternalDatabaseName < Struct.new(:database_name, :description)
+      def initialize(database_name: nil, description: database_name)
+        super(database_name, description)
       end
     end
   end

data/ruby/neo4j/driver/internal/internal_result.rb

@@ -19,19 +19,19 @@ module Neo4j::Driver
       end
 
       def has_next?
-        @cursor.peek_async
+        @cursor.peek_async.result!
       end
 
       def next
-        @cursor.next_async || raise(Exceptions::NoSuchRecordException.no_more)
+        @cursor.next_async.result! || raise(Exceptions::NoSuchRecordException.no_more)
       end
 
       def single
-        @cursor.single_async
+        @cursor.single_async.result!
       end
 
       def peek
-        @cursor.peek_async or raise Exceptions::NoSuchRecordException.no_peek_past
+        @cursor.peek_async.result! or raise Exceptions::NoSuchRecordException.no_peek_past
       end
 
       def each
@@ -39,7 +39,7 @@ module Neo4j::Driver
       end
 
       def consume
-        @cursor.consume_async
+        @cursor.consume_async.result!
       end
 
       def remove

data/ruby/neo4j/driver/internal/internal_session.rb

@@ -17,7 +17,7 @@ module Neo4j::Driver
         Validator.require_hash_parameters!(parameters)
         cursor = @session.run_async(Query.new(query, **parameters), **TransactionConfig.new(**config.compact)) do
           terminate_connection_on_thread_interrupt('Thread interrupted while running query in session')
-        end
+        end.result!
 
         # query executed, it is safe to obtain a connection in a blocking way
         connection = @session.connection_async

data/ruby/neo4j/driver/internal/internal_transaction.rb

@@ -10,28 +10,28 @@ module Neo4j::Driver
       end
 
       def commit
-        @tx.commit_async
+        @tx.commit_async.result!
         # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.commit_async) do
         #   terminate_connection_on_thread_interrupt('Thread interrupted while committing the transaction')
         # end
       end
 
       def rollback
-        @tx.rollback_async
+        @tx.rollback_async.result!
         # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.rollback_async) do
         #   terminate_connection_on_thread_interrupt('Thread interrupted while rolling back the transaction')
         # end
       end
 
       def close
-        @tx.close_async
+        @tx.close_async.result!
         # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.close_async) do
         #     terminate_connection_on_thread_interrupt('Thread interrupted while closing the transaction')
         #   end
       end
 
       def run(query, **parameters)
-        cursor = @tx.run_async(Query.new(query, **parameters))
+        cursor = @tx.run_async(Query.new(query, **parameters)).result!
         # cursor = org.neo4j.driver.internal.util.Futures.blockingGet(@tx.run_async(to_statement(query, parameters))) do
         #   terminate_connection_on_thread_interrupt('Thread interrupted while running query in transaction')
         # end

data/ruby/neo4j/driver/internal/messaging/bolt_protocol_version.rb

@@ -2,10 +2,12 @@ module Neo4j::Driver
   module Internal
     module Messaging
       class BoltProtocolVersion < Struct.new(:major_version, :minor_version)
+        include Comparable
+
         def self.from_raw_bytes(raw_version)
           major = raw_version & 0x000000FF
           minor = (raw_version >> 8) & 0x000000FF
-          new(major,minor)
+          new(major, minor)
         end
 
         def to_int

data/ruby/neo4j/driver/internal/messaging/encode/route_message_encoder.rb

@@ -8,8 +8,14 @@ module Neo4j::Driver
             Util::Preconditions.check_argument(message, Request::RouteMessage)
             packer.pack_struct_header(3, message.signature)
             packer.pack(message.routing_context)
-            packer.pack(message.bookmark.present? ? Values.value(message.bookmark.values) : Values.value(java.util.Collections.empty_list))
-            packer.pack(message.database_name)
+            packer.pack(message.bookmark&.values || [])
+            packer.pack(option(message))
+          end
+
+          private
+
+          def option(message)
+            message.database_name
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/encode/route_v44_message_encoder.rb

@@ -3,22 +3,17 @@ module Neo4j::Driver
     module Messaging
       module Encode
         # Encodes the ROUTE message to the stream
-        class RouteV44MessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::RouteMessage)
-            packer.pack_struct_header(3, message.signature)
-            packer.pack(message.routing_context)
-            packer.pack(message.bookmark.present? ? Values.value(message.bookmark.values) : Values.value(java.util.Collections.empty_list))
+        class RouteV44MessageEncoder < RouteMessageEncoder
+          private
 
-            if !message.impersonated_user.nil? && message.database_name.nil?
-              params = java.util.Collections.singleton_map("imp_user", Values.value(message.impersonated_user))
-            elsif !message.database_name.nil?
-              params = java.util.Collections.singleton_map("db", Values.value(message.database_name))
+          def option(message)
+            if message.impersonated_user && !message.database_name
+              { imp_user: message.impersonated_user }
+            elsif message.database_name
+              { db: message.database_name }
             else
-              params = java.util.Collections.empty_map
+              {}
             end
-
-            packer.pack(params)
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/request/abstract_streaming_message.rb

@@ -4,7 +4,10 @@ module Neo4j::Driver
       module Request
         class AbstractStreamingMessage < Struct.new(:n, :qid)
           STREAM_LIMIT_UNLIMITED = -1
-          alias metadata to_h
+
+          def metadata
+            to_h.compact
+          end
 
           def to_s
             "#{name} #{metadata}"

data/ruby/neo4j/driver/internal/messaging/request/begin_message.rb

@@ -7,9 +7,8 @@ module Neo4j::Driver
 
           def initialize(bookmark, config, database_name, mode, impersonated_user)
             super(Request::TransactionMetadataBuilder.build_metadata(
-              tx_timeout: config[:timeout]&.then(&DurationNormalizer.method(:milliseconds)),
-              tx_metadata: config[:metadata], database_name: database_name, mode: mode, bookmark: bookmark,
-              impersonated_user: impersonated_user))
+              timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
+              bookmark: bookmark, impersonated_user: impersonated_user))
           end
 
           def signature

data/ruby/neo4j/driver/internal/messaging/request/multi_database_util.rb

@@ -10,12 +10,12 @@ module Neo4j::Driver
               end
             end
 
-            def supports_multi_database(connection)
+            def supports_multi_database?(connection)
               connection.server_version >= Util::ServerVersion::V4_0_0 &&
                 connection.protocol.version >= V4::BoltProtocolV4::VERSION
             end
 
-            def supports_route_message(connection)
+            def supports_route_message?(connection)
               connection.protocol.version >= V43::BoltProtocolV43::VERSION
             end
           end

data/ruby/neo4j/driver/internal/messaging/request/route_message.rb

@@ -6,19 +6,14 @@ module Neo4j::Driver
         # instance can provide the wanted service.
         # <p>
         # This message is used to fetch this routing information.
+        #
+        # @param routingContext   The routing context used to define the routing table. Multi-datacenter deployments is one of its use cases.
+        # @param bookmark         The bookmark used when getting the routing table.
+        # @param databaseName     The name of the database to get the routing table for.
+        # @param impersonatedUser The name of the impersonated user to get the routing table for, should be {@code null} for non-impersonated requests
         class RouteMessage < Struct.new(:routing_context, :bookmark, :database_name, :impersonated_user)
           SIGNATURE = 0x66
 
-          # Constructor
-
-          # @param routingContext   The routing context used to define the routing table. Multi-datacenter deployments is one of its use cases.
-          # @param bookmark         The bookmark used when getting the routing table.
-          # @param databaseName     The name of the database to get the routing table for.
-          # @param impersonatedUser The name of the impersonated user to get the routing table for, should be {@code null} for non-impersonated requests
-          def initialize(routing_context, bookmark, database_name, impersonated_user)
-            super(routing_context.freeze, bookmark, database_name, impersonated_user)
-          end
-
           def signature
             SIGNATURE
           end

data/ruby/neo4j/driver/internal/messaging/request/run_with_metadata_message.rb

@@ -9,7 +9,7 @@ module Neo4j::Driver
           class << self
             def auto_commit_tx_run_message(query, config, database_name, mode, bookmark, impersonated_user)
               metadata = Request::TransactionMetadataBuilder.build_metadata(
-                tx_timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
+                timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
                 bookmark: bookmark, impersonated_user: impersonated_user)
               new(query.text, query.parameters, metadata)
             end
@@ -29,10 +29,12 @@ module Neo4j::Driver
             SIGNATURE
           end
 
-          def eql?(other)
-            super && query.eql?(other.query) && parameters.eql?(other.parameters)
+          def ==(other)
+            super && query == other.query && parameters == other.parameters
           end
 
+          alias eql? ==
+
           def hash
             [query, parameters, metadata].hash
           end