neo4j-ruby-driver 0.1.1

data/ffi/neo4j/driver/internal/internal_statement_result.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class InternalStatementResult
+        include Enumerable
+
+        delegate :consume, :failure, :summary, :finalize, to: :@pull_all_handler
+
+        def initialize(run_handler, pull_all_handler)
+          @run_handler = run_handler
+          @pull_all_handler = pull_all_handler
+        end
+
+        def single
+          @pull_all_handler.next.tap do |record|
+            raise Exceptions::NoSuchRecordException.empty unless record
+            raise Exceptions::NoSuchRecordException.too_many if has_next?
+          end
+        end
+
+        def next
+          @pull_all_handler.next.tap do |record|
+            raise Exceptions::NoSuchRecordException.no_more unless record
+          end
+        end
+
+        def peek
+          @pull_all_handler.peek.tap do |record|
+            raise Exceptions::NoSuchRecordException.no_peek_past unless record
+          end
+        end
+
+        def has_next?
+          @pull_all_handler.peek
+        end
+
+        def each
+          yield @pull_all_handler.next while has_next?
+        end
+
+        def keys
+          @keys ||= begin
+            @pull_all_handler.peek
+            @pull_all_handler.statement_keys
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Messaging
+        module BoltProtocol
+          def self.for_version(version)
+            case version
+            when V1::BoltProtocolV1::VERSION
+              V1::BoltProtocolV1::INSTANCE
+            when V2::BoltProtocolV2::VERSION
+              V2::BoltProtocolV2::INSTANCE
+            when V3::BoltProtocolV3::VERSION
+              V3::BoltProtocolV3::INSTANCE
+            else
+              raise Exceptions::ClientException, "Unknown protocol version: #{version}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/messaging/v1/bolt_protocol_v1.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Messaging
+        module V1
+          class BoltProtocolV1
+            VERSION = 1
+            INSTANCE = new
+
+            METADATA_EXTRACTOR = Util::MetadataExtractor.new('result_available_after', 'result_consumed_after')
+
+            def run_in_auto_commit_transaction(connection, statement, bookmarks_holder, config)
+              # bookmarks are ignored for auto-commit transactions in this version of the protocol
+
+              self.class.tx_config_not_supported if config&.present?
+
+              self.class.run_statement(connection, statement, nil)
+            end
+
+            def run_in_explicit_transaction(connection, statement, tx)
+              self.class.run_statement(connection, statement, tx)
+            end
+
+            class << self
+              def run_statement(connection, statement, tx)
+                query = statement.text
+                params = statement.parameters
+
+                run_handler = Handlers::RunResponseHandler.new(METADATA_EXTRACTOR)
+                pull_all_handler = new_pull_all_handler(statement, run_handler, connection, tx)
+
+                connection.write_and_flush(query, params, run_handler, pull_all_handler)
+                InternalStatementResult.new(run_handler, pull_all_handler)
+              end
+
+              def new_pull_all_handler(statement, run_handler, connection, tx)
+                if tx
+                  Handlers::TransactionPullAllResponseHandler.new(statement, run_handler, connection, tx,
+                                                                  METADATA_EXTRACTOR)
+                else
+                  Handlers::SessionPullAllResponseHandler.new(statement, run_handler, connection,
+                                                              BookmarksHolder::NO_OP, METADATA_EXTRACTOR)
+                end
+              end
+
+              def tx_config_not_supported
+                raise ClientException,
+                      'Driver is connected to the database that does not support transaction configuration. ' \
+                      'Please upgrade to neo4j 3.5.0 or later in order to use this functionality'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/messaging/v2/bolt_protocol_v2.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Messaging
+        module V2
+          class BoltProtocolV2 < V1::BoltProtocolV1
+            VERSION = 2
+            INSTANCE = new
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/messaging/v3/bolt_protocol_v3.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Messaging
+        module V3
+          class BoltProtocolV3
+            VERSION = 3
+            INSTANCE = new
+            METADATA_EXTRACTOR = Util::MetadataExtractor.new('t_first', 't_last')
+
+            def run_in_auto_commit_transaction(connection, statement, bookmarks_holder, config)
+              self.class.run_statement(connection, statement, bookmarks_holder, nil, config)
+            end
+
+            def run_in_explicit_transaction(connection, statement, tx)
+              self.class.run_statement(connection, statement, BookmarksHolder::NO_OP, tx, nil)
+            end
+
+            def begin_transaction(connection, bookmarks, config)
+              begin_handler = Handlers::ResponseHandler.new(connection)
+              connection.begin(bookmarks, config, begin_handler)
+              connection.flush if bookmarks.present?
+              begin_handler
+            end
+
+            def commit_transaction(connection)
+              Handlers::ResponseHandler.new(connection).tap(&connection.method(:commit))
+            end
+
+            def rollback_transaction(connection)
+              Handlers::ResponseHandler.new(connection).tap(&connection.method(:rollback))
+            end
+
+            class << self
+              def run_statement(connection, statement, boomarks_holder, tx, config)
+                query = statement.text
+                params = statement.parameters
+
+                run_handler = Handlers::RunResponseHandler.new(connection, METADATA_EXTRACTOR)
+                pull_all_handler = new_pull_all_handler(statement, run_handler, connection, boomarks_holder, tx)
+
+                connection.write_and_flush(query, params, boomarks_holder, config, run_handler, pull_all_handler)
+                InternalStatementResult.new(run_handler, pull_all_handler)
+              end
+
+              def new_pull_all_handler(statement, run_handler, connection, bookmarks_holder, tx)
+                if tx
+                  Handlers::TransactionPullAllResponseHandler.new(statement, run_handler, connection, tx,
+                                                                  METADATA_EXTRACTOR)
+                else
+                  Handlers::SessionPullAllResponseHandler.new(statement, run_handler, connection, bookmarks_holder,
+                                                              METADATA_EXTRACTOR)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/network_session.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class NetworkSession
+        include BookmarksHolder
+        include ErrorHandling
+        extend AutoClosable
+
+        auto_closable :begin_transaction
+
+        def initialize(connection_provider, mode, retry_logic = nil, logging = nil)
+          super()
+          @open = Concurrent::AtomicBoolean.new(true)
+          @connection_provider = connection_provider
+          @mode = mode
+          # @retry_logic = retry_logic
+          @retry_logic = Class.new do
+            def retry
+              yield
+            end
+          end.new
+        end
+
+        def run(statement, parameters = {}, config = nil)
+          ensure_session_is_open
+          ensure_no_open_tx_before_running_query
+          acquire_connection(@mode)
+          @result = @connection.protocol.run_in_auto_commit_transaction(
+            @connection, Statement.new(statement, parameters), self, config
+          )
+        end
+
+        def read_transaction(&block)
+          transaction(Neo4j::Driver::AccessMode::READ, &block)
+        end
+
+        def write_transaction(&block)
+          transaction(Neo4j::Driver::AccessMode::WRITE, &block)
+        end
+
+        def close
+          return unless @open.make_false
+          begin
+            @result&.finalize
+            @result&.failure
+          ensure
+            close_transaction_and_release_connection
+          end
+        end
+
+        def release_connection
+          @connection&.release
+        end
+
+        def begin_transaction(mode = @mode, config = nil)
+          ensure_no_open_tx_before_starting_tx
+          acquire_connection(mode)
+          @transaction = ExplicitTransaction.new(@connection, self).begin(bookmarks, config)
+        end
+
+        def last_bookmark
+          bookmarks&.max
+        end
+
+        private
+
+        def transaction(mode, config = nil)
+          @retry_logic.retry do
+            tx = begin_transaction(mode, config)
+            result = yield tx
+            tx.success
+            result
+          rescue StandardError => e
+            tx&.failure
+            raise e
+          ensure
+            tx&.close
+          end
+        end
+
+        def acquire_connection(mode = @mode)
+          @result&.failure
+          raise Exceptions::IllegalStateException, 'Existing open connection detected' if @connection&.open?
+          @connection = @connection_provider.acquire_connection(@mode)
+          # old
+          # raise Exception, 'existing connection present' if @connection
+          #
+          # status = Bolt::Status.create
+          # @connection = Bolt::Connector.acquire(@connector, mode, status)
+          # check_status(status)
+        end
+
+        def close_transaction_and_release_connection
+          @transaction&.close
+        ensure
+          @transaction = nil
+          release_connection
+        end
+
+        def ensure_session_is_open
+          return if @open.true?
+          raise Exceptions::ClientException,
+                'No more interaction with this session are allowed as the current session is already closed.'
+        end
+
+        def ensure_no_open_tx_before_running_query
+          ensure_no_open_tx('Statements cannot be run directly on a session with an open transaction; ' \
+                            'either run from within the transaction or use a different session.')
+        end
+
+        def ensure_no_open_tx_before_starting_tx
+          ensure_no_open_tx('You cannot begin a transaction on a session with an open transaction; ' \
+                            'either run from within the transaction or use a different session.')
+        end
+
+        def ensure_no_open_tx(error_message)
+          raise Exceptions::ClientException, error_message if @transaction&.open?
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/session_factory_impl.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class SessionFactoryImpl
+        attr_reader :connection_provider
+        delegate :close, :verify_connectivity, to: :connection_provider
+
+        def initialize(connection_provider, retry_logic, config)
+          @connection_provider = connection_provider
+          @retry_logic = retry_logic
+          @config = config
+        end
+
+        def new_instance(mode, bookmarks)
+          create_session(connection_provider, @retry_logic, mode).tap { |session| session.bookmarks = bookmarks }
+        end
+
+        private
+
+        def create_session(connection_provider, retry_logic, mode, logging = nil)
+          NetworkSession.new(connection_provider, mode, retry_logic, logging)
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/summary/internal_result_summary.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Summary
+        class InternalResultSummary
+          attr_reader :server, :counters, :statement, :result_available_after, :result_consumed_after
+          delegate :notifications, :profile, to: :@metadata
+
+          def initialize(statement, result_available_after, bolt_connection)
+            @statement = statement
+            @result_available_after = result_available_after
+            @server = InternalServerInfo.new(bolt_connection)
+            @metadata = RecursiveOpenStruct.new(
+              underscore_keys(Value::ValueAdapter.to_ruby(Bolt::Connection.metadata(bolt_connection))),
+              recurse_over_arrays: true
+            )
+            @result_consumed_after = @metadata.result_consumed_after || @metadata.t_last
+            @counters = InternalSummaryCounters.new(@metadata.stats)
+          end
+
+          def notifications
+            @metadata.notifications || []
+          end
+
+          def plan
+            @metadata.plan || profile
+          end
+
+          alias has_plan? plan
+          alias has_profile? profile
+
+          def method_missing(method)
+            @metadata.send(method)
+          end
+
+          private
+
+          def underscore_keys(arg)
+            case arg
+            when Array
+              arg.map(&method(:underscore_keys))
+            when Hash
+              arg.map { |key, value| [translate_key(key), underscore_keys(value)] }.to_h
+            else
+              arg
+            end
+          end
+
+          def translate_key(key)
+            case key
+            when :type
+              :statement_type
+            when :args
+              :arguments
+            when :rows
+              :records
+            else
+              key.to_s.underscore.to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/summary/internal_server_info.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Summary
+        class InternalServerInfo
+          attr_reader :address, :version
+
+          def initialize(bolt_connection)
+            address = Bolt::Connection.remote_endpoint(bolt_connection)
+            @address = %i[host port].map { |method| Bolt::Address.send(method, address).first }.join(':')
+            @version = Bolt::Connection.server(bolt_connection).first
+          end
+        end
+      end
+    end
+  end
+end