neo4j-ruby-driver 5.7.0.alpha.4 → 6.0.3.alpha.0-java

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

@@ -1,74 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class InternalDriver
-      extend AutoClosable
-      extend Synchronizable
-      attr_reader :session_factory, :metrics_provider
-      # delegate :verify_connectivity, to: :session_factory
-      delegate :metrics, :metrics_enabled?, to: :metrics_provider
-      auto_closable :session
-      sync :close, :supports_multi_db?, :verify_connectivity, :session
-
-      def initialize(security_plan, session_factory, metrics_provider, logger)
-        @closed = Concurrent::AtomicBoolean.new(false)
-        @security_plan = security_plan
-        @session_factory = session_factory
-        @metrics_provider = metrics_provider
-        @log = logger
-      end
-
-      def session(**session_config)
-        InternalSession.new(new_session(**session_config))
-      end
-
-      def async_session(**session_config)
-        InternalAsyncSession.new(new_session(**session_config))
-      end
-
-      def encrypted?
-        assert_open!
-        @security_plan.requires_encryption?
-      end
-
-      def close
-        close_async
-      end
-
-      def close_async
-        return nil unless @closed.make_true
-        @log.info { "Closing driver instance #{object_id}" }
-        session_factory.close
-      end
-
-      def verify_connectivity_async
-        session_factory.verify_connectivity
-      end
-
-      def supports_multi_db?
-        supports_multi_db_async?
-      end
-
-      def supports_multi_db_async?
-        session_factory.supports_multi_db?
-      end
-
-      def verify_connectivity
-        verify_connectivity_async
-      end
-
-      def new_session(**config)
-        assert_open!
-        session_factory.new_instance(**config.compact)
-      ensure
-        # session does not immediately acquire connection, it is fine to just throw
-        assert_open!
-      end
-
-      private
-
-      def assert_open!
-        raise Exceptions::IllegalStateException, 'This driver instance has already been closed' if @closed.true?
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class InternalEntity
-      attr_reader :id, :element_id, :properties
-      delegate :hash, to: :id
-      delegate :[], :size, :key?, :keys, :values, :to_h, to: :properties
-
-      def initialize(id, element_id, **properties)
-        @id = id
-        @element_id = element_id || id.to_s
-        @properties = properties
-      end
-
-      def ==(other)
-        equal?(other) || self.class == other.class && id == other.id
-      end
-
-      alias eql? ==
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    # {@link Node} implementation that directly contains labels and properties.
-    class InternalNode < InternalEntity
-      attr_reader :labels
-
-      def initialize(id, element_id, *labels, **properties)
-        super(id, element_id, **properties)
-        @labels = labels
-      end
-
-      def label?(label)
-        labels.include?(label)
-      end
-
-      def to_s
-        "node<#{id}>"
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class InternalPair < Struct.new(:key, :value)
-      def self.of(key, value)
-        new(key, value)
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class InternalPath < Array
-      attr_reader :nodes, :relationships
-
-      class Segment < Struct.new(:start_node, :relationship, :end_node)
-        def to_s
-          sprintf(relationship.start_node_id == start_node.id ? '(%s)-[%s:%s]->(%s)' : '(%s)<-[%s:%s]-(%s)',
-                  start_node.id, relationship.id, relationship.type, end_node.id)
-        end
-      end
-
-      delegate :length, to: :relationships
-      delegate :include?, to: :entities
-
-      def initialize(nodes, relationships)
-        super()
-        @nodes = nodes
-        @relationships = relationships
-      end
-
-      def to_s
-        'path' + super
-      end
-
-      def start_node
-        @nodes.first
-      end
-
-      def end_node
-        @nodes.last
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class InternalPoint2D < Struct.new(:srid, :x, :y)
-      def z
-        Float::NAN
-      end
-    end
-  end
-end

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

@@ -1,6 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class InternalPoint3D < Struct.new(:srid, :x, :y, :z)
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class InternalRecord
-        attr_reader :keys, :values
-        delegate :first, :size,to: :values
-        delegate :key?, to: :keys
-
-        def initialize(keys, values)
-          @keys = keys
-          @values = values
-        end
-
-        def [](key)
-          field_index = key.is_a?(Integer) ? key : @keys.index(key.to_sym)
-          @values[field_index] if field_index
-        end
-
-        def to_h
-          keys.zip(values).to_h
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver
-  module Internal
-    class InternalRelationship < InternalEntity
-      attr_accessor :start_node_id, :end_node_id, :start_node_element_id, :end_node_element_id
-      attr_reader :type
-
-      def initialize(id, element_id, start_node_id, start_node_element_id, end_node_id, end_node_element_id, type, **properties)
-        super(id, element_id, **properties)
-        set_start_and_end_node_ids(start_node_id, start_node_element_id, end_node_id, end_node_element_id)
-        @type = type.to_sym
-      end
-
-      def set_start_and_end_node_ids(start_node_id, start_node_element_id, end_node_id, end_node_element_id)
-        @start_node_id = start_node_id
-        @start_node_element_id = start_node_element_id || start_node_id.to_s
-        @end_node_id = end_node_id
-        @end_node_element_id = end_node_element_id || end_node_id.to_s
-      end
-
-      def to_s
-        "relationship<#{id}>"
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class InternalResult
-      extend Synchronizable
-      include Enumerable
-      sync :keys, :has_next?, :next, :single, :peek, :consume
-      delegate :keys, to: :@cursor
-
-      def initialize(connection, cursor)
-        @connection = connection
-        @cursor = cursor
-      end
-
-      def has_next?
-        @cursor.peek_async.result!
-      end
-
-      def next
-        @cursor.next_async.result! || raise(Exceptions::NoSuchRecordException.no_more)
-      end
-
-      def single
-        @cursor.single_async.result!
-      end
-
-      def peek
-        @cursor.peek_async.result! or raise Exceptions::NoSuchRecordException.no_peek_past
-      end
-
-      def each
-        yield self.next while has_next?
-      end
-
-      def consume
-        @cursor.consume_async.result!
-      end
-
-      def remove
-        raise ClientException, 'Removing records from a result is not supported.'
-      end
-
-      private
-
-      def terminate_connection_on_thread_interrupt
-        @connection.terminate_and_release('Thread interrupted while waiting for result to arrive')
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class InternalSession
-      extend AutoClosable
-      extend Synchronizable
-      # include Ext::RunOverride
-      delegate :open?, :last_bookmark, to: :@session
-      auto_closable :begin_transaction
-      sync :close, :begin_transaction, :run, :transaction
-
-      def initialize(session)
-        @session = session
-      end
-
-      def run(query, parameters = {}, config = {})
-        parameters ||= {}
-        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.result!
-
-        # query executed, it is safe to obtain a connection in a blocking way
-        connection = @session.connection_async
-        InternalResult.new(connection, cursor)
-      end
-
-      def close
-        @session.close_async do
-          terminate_connection_on_thread_interrupt("Thread interrupted while closing the session")
-        end
-      end
-
-      def begin_transaction(**config)
-        tx = @session.begin_transaction_async(**config) do
-          terminate_connection_on_thread_interrupt("Thread interrupted while starting a transaction")
-        end
-        InternalTransaction.new(tx)
-      end
-
-      def read_transaction(**config, &block)
-        transaction(AccessMode::READ, **config, &block)
-      end
-
-      def write_transaction(**config, &block)
-        transaction(AccessMode::WRITE, **config, &block)
-      end
-
-      private
-
-      def transaction(mode, **config)
-        # use different code path compared to async so that work is executed in the caller thread
-        # caller thread will also be the one who sleeps between retries;
-        # it is unsafe to execute retries in the event loop threads because this can cause a deadlock
-        # event loop thread will bock and wait for itself to read some data
-        @session.retry_logic.retry do
-          tx = private_begin_transaction(mode, **config)
-          result = yield tx
-          tx.commit if tx.open? # if a user has not explicitly committed or rolled back the transaction
-          result
-        ensure
-          tx&.close
-        end
-      end
-
-      def private_begin_transaction(mode, **config)
-        tx = @session.begin_transaction_async(mode, **config) do
-          terminate_connection_on_thread_interrupt("Thread interrupted while starting a transaction")
-        end
-        InternalTransaction.new(tx)
-      end
-
-      def terminate_connection_on_thread_interrupt(reason)
-        connection = @session.connection_async
-      rescue
-        nil # ignore errors because handing interruptions is best effort
-      ensure
-        connection&.terminate_and_release(reason)
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class InternalTransaction
-      extend Synchronizable
-      sync :commit, :rollback, :close, :run
-      delegate :open?, to: :@tx
-
-      def initialize(tx)
-        @tx = tx
-      end
-
-      def commit
-        @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.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.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)).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
-        InternalResult.new(@tx.connection, cursor)
-      end
-
-      private
-
-      def terminate_connection_on_thread_interrupt(reason)
-        @tx.connection.terminate_and_release(reason)
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/logging/channel_activity_logger.rb

@@ -1,29 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Logging
-      class ChannelActivityLogger < ReformattedLogger
-        def initialize(channel, logger, owner)
-          super(logger)
-          @channel = channel
-          @local_channel_id = channel&.object_id&.to_s
-          @owner = owner
-        end
-
-        private
-
-        def format_message(severity, datetime, progname, msg)
-          super(severity, datetime, @owner || progname,
-                @channel && "[0x#{@local_channel_id}] [#{server_address}] [#{db_connection_id}] #{msg}" || msg)
-        end
-
-        def db_connection_id
-          @db_connection_id ||= Async::Connection::ChannelAttributes.connection_id(@channel)
-        end
-
-        def server_address
-          @server_address ||= Async::Connection::ChannelAttributes.server_address(@channel)&.to_s
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/logging/channel_error_logger.rb

@@ -1,17 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Logging
-      class ChannelErrorLogger < ChannelActivityLogger
-        DEBUG_MESSAGE_FORMAT = "%s (%s)"
-
-        def initialize(channel, logger)
-          super(channel, logger, self.class)
-        end
-
-        def debug(message, error)
-          super(DEBUG_MESSAGE_FORMAT % [message, error.class])
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/logging/prefixed_logger.rb

@@ -1,19 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Logging
-      class PrefixedLogger < ReformattedLogger
-        def initialize(message_prefix = nil, delegate)
-          super(delegate)
-          @message_prefix = message_prefix
-        end
-
-        private
-
-        def format_message(severity, datetime, progname, msg)
-          return super unless @message_prefix
-          super(severity, datetime, progname, "#{@message_prefix} #{msg}")
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/logging/reformatted_logger.rb

@@ -1,17 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Logging
-      class ReformattedLogger
-        delegate_missing_to :@delegate
-
-        def initialize(delegate)
-          @delegate = Validator.require_non_nil!(delegate)
-        end
-
-        def trace(*arg)
-          debug(*arg)
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      class AbstractMessageWriter
-        def initialize(packer)
-          @packer = Internal::Validator.require_non_nil!(packer)
-          @encoders_by_message_signature = Internal::Validator.require_non_nil!(build_encoders).transform_values(&:new)
-        end
-
-        def write(msg)
-          signature = msg.class::SIGNATURE
-          encoder = @encoders_by_message_signature[signature]
-
-          if encoder.nil?
-            raise IOError, "No encoder found for message #{msg} with signature #{signature}"
-          end
-
-          encoder.encode(msg, @packer)
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module BoltProtocol
-        def self.for_channel(channel)
-          for_version(channel.attributes[:protocol_version])
-        end
-
-        def self.for_version(version)
-          case version
-          when V3::BoltProtocolV3::VERSION
-            V3::BoltProtocolV3::INSTANCE
-          when V4::BoltProtocolV4::VERSION
-            V4::BoltProtocolV4::INSTANCE
-          when V41::BoltProtocolV41::VERSION
-            V41::BoltProtocolV41::INSTANCE
-          when V42::BoltProtocolV42::VERSION
-            V42::BoltProtocolV42::INSTANCE
-          when V43::BoltProtocolV43::VERSION
-            V43::BoltProtocolV43::INSTANCE
-          when V44::BoltProtocolV44::VERSION
-            V44::BoltProtocolV44::INSTANCE
-          when V5::BoltProtocolV5::VERSION
-            V5::BoltProtocolV5::INSTANCE
-          else
-            raise Exceptions::ClientException, "Unknown protocol version: #{version}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-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)
-        end
-
-        def to_int
-          shifted_minor = minor_version << 8
-          shifted_minor | major_version
-        end
-
-        def to_int_range(min_version)
-          if major_version != min_version.major_version
-            raise ArgumentError, 'Versions should be from the same major version'
-          elsif minor_version < min_version.minor_version
-            raise ArgumentError, 'Max version should be newer than min version'
-          end
-
-          range = minor_version - min_version.minor_version
-          shifted_range = range << 16
-          shifted_range | to_int
-        end
-
-        # @return the version in format X.Y where X is the major version and Y is the minor version
-        def to_s
-          values.join('.')
-        end
-
-        def <=>(other)
-          result = major_version <=> other.major_version
-          result == 0 ? minor_version <=> other.minor_version : result
-        end
-
-        def self.http?(protocol_version)
-          # server would respond with `HTTP..` We read 4 bytes to figure out the version. The first two are not used
-          # and therefore parse the `P` (80) for major and `T` (84) for minor.
-          protocol_version.major_version == 80 && protocol_version.minor_version == 84
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/common/common_message_reader.rb

@@ -1,51 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Common
-        class CommonMessageReader
-          def initialize(input)
-            @unpacker = input
-          end
-
-          def read(handler)
-            @unpacker.unpack_struct_header
-            type = @unpacker.unpack_struct_signature
-
-            case type
-            when Response::SuccessMessage::SIGNATURE
-              unpack_success_message(handler)
-            when Response::FailureMessage::SIGNATURE
-              unpack_failure_message(handler)
-            when Response::IgnoredMessage::SIGNATURE
-              unpack_ignored_message(handler)
-            when Response::RecordMessage::SIGNATURE
-              unpack_record_message(handler)
-            else
-              raise IOError, "Unknown message type: #{type}"
-            end
-          end
-
-          private
-
-          def unpack_success_message(output)
-            map = @unpacker.unpack
-            output.handle_success_message(map)
-          end
-
-          def unpack_failure_message(output)
-            output.handle_failure_message(**@unpacker.unpack)
-          end
-
-          def unpack_ignored_message(output)
-            output.handle_ignored_message
-          end
-
-          def unpack_record_message(output)
-            fields = @unpacker.unpack
-            output.handle_record_message(fields)
-          end
-        end
-      end
-    end
-  end
-end