neo4j-ruby-driver 1.7.6 → 4.4.0.alpha.1

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

@@ -0,0 +1,101 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Common
+        module CommonValuePacker
+          include CommonValue
+
+          def pack(value)
+            case value
+            when ActiveSupport::Duration
+              pack_duration(value)
+            when Types::Point
+              pack_point(value)
+            when Types::OffsetTime
+              pack_time(value)
+            when Types::LocalTime
+              pack_local_time(value)
+            when Types::LocalDateTime
+              pack_local_date_time(value)
+            when ActiveSupport::TimeWithZone
+              pack_date_time_with_zone_id(value)
+            when Time, DateTime
+              pack_date_time_with_zone_offset(value)
+            when Date
+              pack_date(value)
+            else
+              super
+            end
+          end
+
+          private
+
+          def pack_date(local_date)
+            pack_struct_header(DATE_STRUCT_SIZE, DATE)
+            pack_integer((local_date - EPOCH).to_i)
+          end
+
+          def pack_time(offset_time)
+            pack_struct_header(TIME_STRUCT_SIZE, TIME)
+            pack_nano_of_day(offset_time)
+            pack_utc_offset(offset_time)
+          end
+
+          def pack_utc_offset(time)
+            pack_integer(time.utc_offset)
+          end
+
+          def pack_nano_of_day(local_time)
+            pack_integer(((local_time.hour * 60 + local_time.min) * 60 + local_time.sec) * NANO_FACTOR + local_time.nsec)
+          end
+
+          def pack_local_time(local_time)
+            pack_struct_header(LOCAL_TIME_STRUCT_SIZE, LOCAL_TIME)
+            pack_nano_of_day(local_time)
+          end
+
+          def pack_local_date_time(local_date_time)
+            pack_struct_header(LOCAL_DATE_TIME_STRUCT_SIZE, LOCAL_DATE_TIME)
+            pack_integer(local_date_time.to_i)
+            pack_integer(local_date_time.nsec)
+          end
+
+          def pack_date_time_with_zone_id(time)
+            pack_struct_header(DATE_TIME_STRUCT_SIZE, DATE_TIME_WITH_ZONE_ID)
+            pack_date_time(time)
+            pack_string(time.time_zone.tzinfo.identifier)
+          end
+
+          def pack_date_time(time)
+            pack_integer(time.to_i + time.utc_offset)
+            pack_integer(time.nsec)
+          end
+
+          def pack_date_time_with_zone_offset(time)
+            pack_struct_header(DATE_TIME_STRUCT_SIZE, DATE_TIME_WITH_ZONE_OFFSET)
+            pack_date_time(time)
+            pack_utc_offset(time)
+          end
+
+          def pack_duration(duration)
+            pack_struct_header(DURATION_TIME_STRUCT_SIZE, DURATION)
+            DurationNormalizer.normalize(duration).each(&method(:pack_integer))
+          end
+
+          def pack_point(point)
+            case point.coordinates.size
+            when 2
+              pack_struct_header(POINT_2D_STRUCT_SIZE, POINT_2D_STRUCT_TYPE)
+            when 3
+              pack_struct_header(POINT_3D_STRUCT_SIZE, POINT_3D_STRUCT_TYPE)
+            else
+              raise IOError, "Unknown type: type: #{point.class}, value: #{point.to_s}"
+            end
+            pack_integer(point.srid.to_i)
+            point.coordinates.each(&method(:pack_float))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Common
+        module CommonValueUnpacker
+          include CommonValue
+          NODE = 'N'
+          RELATIONSHIP = 'R'
+          UNBOUND_RELATIONSHIP = 'r'
+          PATH = 'P'
+          NODE_FIELDS = 3
+
+          def unpack_map(size)
+            size.times.to_h { [unpack.to_sym, unpack] }
+          end
+
+          def unpack_array(size)
+            size.times.map { unpack }
+          end
+
+          def unpack
+            marker_byte = read_byte
+            marker_high_nibble = marker_byte & 0xF0
+            marker_low_nibble = marker_byte & 0x0F
+
+            case marker_high_nibble
+            when TINY_STRING
+              return unpack_string(marker_low_nibble)
+            when TINY_LIST
+              return unpack_array(marker_low_nibble)
+            when TINY_MAP
+              return unpack_map(marker_low_nibble)
+            when TINY_STRUCT
+              return unpack_struct(marker_low_nibble, read_char)
+            end
+
+            case marker_byte & 0xFF # we read a signed byte but markers are unsigned
+            when NULL
+              nil
+            when TRUE
+              true
+            when FALSE
+              false
+            when FLOAT_64
+              unpack_double
+            when BYTES_8
+              unpack_bytes(read_ubyte)
+            when BYTES_16
+              unpack_bytes(read_ushort)
+            when BYTES_32
+              unpack_bytes(read_uint)
+            when STRING_8
+              unpack_string(read_ubyte)
+            when STRING_16
+              unpack_string(read_ushort)
+            when STRING_32
+              unpack_string(read_uint)
+            when LIST_8
+              unpack_array(read_ubyte)
+            when LIST_16
+              unpack_array(read_ushort)
+            when LIST_32
+              unpack_array(read_uint)
+            when MAP_8
+              unpack_map(read_ubyte)
+            when MAP_16
+              unpack_map(read_ushort)
+            when STRUCT_8
+              unpack_struct(read_ubyte, read_char)
+            when STRUCT_16
+              unpack_struct(read_ushort, read_char)
+            else
+              unpack_long(marker_byte)
+            end
+          end
+
+          def unpack_struct(size, type)
+            case type
+            when DATE
+              ensure_correct_struct_size(:DATE, DATE_STRUCT_SIZE, size)
+              unpack_date
+            when TIME
+              ensure_correct_struct_size(:TIME, TIME_STRUCT_SIZE, size)
+              unpack_time
+            when LOCAL_TIME
+              ensure_correct_struct_size(:LOCAL_TIME, LOCAL_TIME_STRUCT_SIZE, size)
+              unpack_local_time
+            when LOCAL_DATE_TIME
+              ensure_correct_struct_size(:LOCAL_DATE_TIME, LOCAL_DATE_TIME_STRUCT_SIZE, size)
+              unpack_local_date_time
+            when DATE_TIME_WITH_ZONE_OFFSET
+              ensure_correct_struct_size(:DATE_TIME_WITH_ZONE_OFFSET, DATE_TIME_STRUCT_SIZE, size)
+              unpack_date_time_with_zone_offset
+            when DATE_TIME_WITH_ZONE_ID
+              ensure_correct_struct_size(:DATE_TIME_WITH_ZONE_ID, DATE_TIME_STRUCT_SIZE, size)
+              unpack_date_time_with_zone_id
+            when DURATION
+              ensure_correct_struct_size(:DURATION, DURATION_TIME_STRUCT_SIZE, size)
+              unpack_duration
+            when POINT_2D_STRUCT_TYPE
+              ensure_correct_struct_size(:POINT, POINT_2D_STRUCT_SIZE, size)
+              unpack_point2_d
+            when POINT_3D_STRUCT_TYPE
+              ensure_correct_struct_size(:POINT, POINT_3D_STRUCT_SIZE, size)
+              unpack_point3_d
+            when NODE
+              ensure_correct_struct_size(:NODE, NODE_FIELDS, size)
+              adapted = unpack_node
+            when RELATIONSHIP
+              ensure_correct_struct_size(:RELATIONSHIP, 5, size)
+              unpack_relationship
+            when UNBOUND_RELATIONSHIP
+              ensure_correct_struct_size(:RELATIONSHIP, 3, size)
+              unpack_unbound_relationship
+            when PATH
+              ensure_correct_struct_size(:PATH, 3, size)
+              unpack_path
+            else
+              raise IOError, "Unknown struct type: #{type}"
+            end
+          end
+
+          private
+
+          def unpack_relationship
+            InternalRelationship.new(*4.times.map { unpack }, **unpack)
+          end
+
+          def unpack_unbound_relationship
+            InternalRelationship.new(unpack, nil, nil, unpack, **unpack)
+          end
+
+          def unpack_node
+            InternalNode.new(unpack, *unpack.map(&:to_sym), **unpack)
+          end
+
+          def unpack_path
+            uniq_nodes = unpack
+            uniq_rels = unpack
+            sequence = unpack
+            prev_node = uniq_nodes.first
+            nodes = [prev_node] # Start node is always 0, and isn't encoded in the sequence
+            rels = []
+            path = Types::Path.new(nodes, rels)
+            sequence.in_groups_of(2) do |rel_idx, node_idx|
+              node = uniq_nodes[node_idx]
+              nodes << node
+              rel = uniq_rels[rel_idx.abs - 1] # -1 because rel idx are 1-indexed
+              update(rel, prev_node, node, rel_idx.negative?)
+              rels << rel
+              path << Types::Path::Segment.new(prev_node, rel, node)
+              prev_node = node
+            end
+            path
+          end
+
+          def update(rel, prev_node, node, inversed)
+            # Negative rel index means this rel was traversed "inversed" from its direction
+            prev_node, node = node, prev_node if inversed
+            rel.start_node_id = prev_node.id
+            rel.end_node_id = node.id
+          end
+
+          def ensure_correct_struct_size(type_constructor, expected, actual)
+            if expected != actual
+              struct_name = type_constructor.to_s
+              raise Neo4j::Driver::Exceptions::ClientException, "Invalid message received, serialized #{struct_name} structures should have #{expected} fields, received #{struct_name} structure has #{actual} fields."
+            end
+          end
+
+          private
+
+          def ensure_correct_struct_signature(struct_name, expected, actual)
+            if expected != actual
+              struct_name = type_constructor.to_s
+              raise Neo4j::Driver::Exceptions::ClientException, "Invalid message received, expected a `#{struct_name}`, signature 0x#{expected.to_i.to_s(16)}. Received signature was 0x#{actual.to_i.to_s(16)}."
+            end
+          end
+
+          def unpack_date
+            EPOCH + unpack
+          end
+
+          def time(nano_of_day_local, offset_seconds = nil)
+            min, sec = Rational(nano_of_day_local, NANO_FACTOR).divmod(60)
+            Time.new(0, 1, 1, *min.divmod(60), sec, offset_seconds)
+          end
+
+          def unpack_time
+            Types::OffsetTime.new(time(unpack, unpack))
+          end
+
+          def unpack_local_time
+            Types::LocalTime.new(time(unpack))
+          end
+
+          def unpack_local_date_time
+            Types::LocalDateTime.new(Time.at(unpack, unpack, :nsec).utc)
+          end
+
+          def unpack_date_time_with_zone_offset
+            # Time.at(unpack, unpack, :nsec, in: unpack)
+            sec = unpack
+            nsec = unpack
+            offset = unpack
+            time = Time.at(sec, nsec, :nsec).utc
+            Time.new(time.year, time.month, time.mday, time.hour, time.min, time.sec + Rational(nsec, 1_000_000_000),
+                     offset)
+          end
+
+          def unpack_date_time_with_zone_id
+            time = Time.at(unpack, unpack, :nsec).in_time_zone(TZInfo::Timezone.get(unpack))
+            time - time.utc_offset
+          end
+
+          def unpack_duration
+            ActiveSupport::Duration.months(unpack) +
+              ActiveSupport::Duration.days(unpack) +
+              ActiveSupport::Duration.seconds(unpack) +
+              ActiveSupport::Duration.seconds(unpack * BigDecimal('1e-9'))
+          end
+
+          def unpack_point2_d
+            Types::Point.new(srid: unpack, x: unpack, y: unpack)
+          end
+
+          def unpack_point3_d
+            Types::Point.new(srid: unpack, x: unpack, y: unpack, z: unpack)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class BeginMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::BeginMessage)
+            packer.pack_struct_header(1, message.signature)
+            packer.pack(message.metadata)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class CommitMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::CommitMessage)
+            packer.pack_struct_header(0, Request::CommitMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class DiscardAllMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::DiscardAllMessage)
+            packer.pack_struct_header(0, Request::DiscardAllMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class DiscardMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::DiscardMessage)
+            packer.pack_struct_header(1, Request::DiscardMessage::SIGNATURE)
+            packer.pack(message.metadata)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class GoodbyeMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::GoodbyeMessage)
+            packer.pack_struct_header(0, Request::GoodbyeMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class HelloMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::HelloMessage)
+            packer.pack_struct_header(1, message.class::SIGNATURE)
+            packer.pack(message.metadata)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class InitMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::InitMessage)
+            packer.pack_struct_header(2, message.signature)
+            packer.pack(message.user_agent)
+            packer.pack(message.auth_token)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class PullAllMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::PullAllMessage)
+            packer.pack_struct_header(0, Request::PullAllMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class PullMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::PullMessage)
+            packer.pack_struct_header(1, Request::PullMessage::SIGNATURE)
+            packer.pack(message.metadata)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class ResetMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::ResetMessage)
+            packer.pack_struct_header(0, Request::ResetMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class RollbackMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::RollbackMessage)
+            packer.pack_struct_header(0, Request::RollbackMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        # Encodes the ROUTE message to the stream
+        class RouteMessageEncoder
+          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))
+            packer.pack(message.database_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Neo4j::Driver
+  module Internal
+    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))
+
+            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))
+            else
+              params = java.util.Collections.empty_map
+            end
+
+            packer.pack(params)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class RunMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::RunMessage)
+            packer.pack_struct_header(2, message.signature)
+            packer.pack(message.query)
+            packer.pack(message.parameters)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class RunWithMetadataMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::RunWithMetadataMessage)
+            packer.pack_struct_header(3, message.signature)
+            packer.pack(message.query)
+            packer.pack(message.parameters)
+            packer.pack(message.metadata)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class AbstractStreamingMessage < Struct.new(:n, :qid)
+          STREAM_LIMIT_UNLIMITED = -1
+          alias metadata to_h
+
+          def to_s
+            "#{name} #{metadata}"
+          end
+
+          protected
+
+          def name
+            raise 'Abstract method called'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class BeginMessage < MessageWithMetadata
+          SIGNATURE = 0x11
+
+          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))
+          end
+
+          def signature
+            SIGNATURE
+          end
+
+          def to_s
+            "BEGIN #{metadata}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class CommitMessage
+          SIGNATURE = 0x12
+          COMMIT = new
+
+          def signature
+            SIGNATURE
+          end
+
+          def to_s
+            "COMMIT"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class DiscardAllMessage
+          SIGNATURE = 0x2F
+          DISCARD_ALL = new
+
+          def signature
+            SIGNATURE
+          end
+
+          def to_s
+            "DISCARD_ALL"
+          end
+        end
+      end
+    end
+  end
+end