neo4j-core 5.1.7 → 6.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 270806b67718b4b05e99c73d1b1d2118fefe6dce
-  data.tar.gz: 878b8d073dd7a1fbce2139524a92f195286325f4
+  metadata.gz: d2e549ac9b629bd47019215c2457d66c6b355a2f
+  data.tar.gz: 717fb2cc5363c0a7a9726ae4d686e504634d7310
 SHA512:
-  metadata.gz: d4f9e836e2a5352c48621ef7bc0bfe40f6ec6cab15fcc7b32a003e719a11211d78e35c247ea2e51fc1c50926babe3215285a054541e511483ab9d72bfdae2707
-  data.tar.gz: fea94937e02b32ffdd8bf6a5bbf8bee6f9e7ac6b56b1cab031ec9c5c918a03bcca21df1b2e87e5edb4b5f7c837fbca30e99b088d6981dd82352f9fc2717411fd
+  metadata.gz: 14df3ab1fb20692a66036201039f66861b38fc340b3c63c7051d977b2a718c09a9daa3b5d717920ddaa5228089c899f8cf9f611c2e11e6cda992af6fc6d1838a
+  data.tar.gz: ece61afe7b0c8c21db72322bfe5143ccc9ab7ef84dc6b01f7b7416b7978b28a082b0edb7dbc5587ed390cc9aa2da3555f4aad1fa11e96fb28e76e5de9d90e7c4

data/lib/neo4j/core/cypher_session/adaptors/embedded.rb

@@ -0,0 +1,81 @@
+require 'neo4j/core/cypher_session/adaptors'
+require 'neo4j/core/cypher_session/responses/embedded'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Adaptors
+        class Embedded < Base
+          def initialize(path, options = {})
+            fail 'JRuby is required for embedded mode' if RUBY_PLATFORM != 'java'
+            fail ArgumentError, "Invalid path: #{path}" if !File.directory?(path)
+
+            @path = path
+            @options = options
+          end
+
+          def connect
+            factory    = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new
+            db_service = factory.newEmbeddedDatabaseBuilder(@path)
+            db_service.loadPropertiesFromFile(@options[:properties_file]) if @options[:properties_file]
+            db_service.setConfig(@options[:properties_map])               if @options[:properties_map]
+
+            @graph_db = db_service.newGraphDatabase
+          end
+
+          def query_set(queries)
+            # I think that this is the best way to do a batch in embedded...
+            # Should probably do within a transaction in case of errors...
+
+            transaction do
+              self.class.instrument_transaction do
+                self.class.instrument_queries(queries)
+
+                execution_results = queries.map do |query|
+                  engine.execute(query.cypher, HashWithIndifferentAccess.new(query.parameters))
+                end
+
+                Responses::Embedded.new(execution_results).results
+              end
+            end
+          end
+
+          def start_transaction
+            @transaction = @graph_db.begin_tx
+          end
+
+          def end_transaction
+            if @transaction.nil?
+              fail 'Cannot close transaction without starting one'
+            end
+
+            @transaction.success
+            @transaction.close
+          end
+
+          def version
+            if defined?(::Neo4j::Community)
+              ::Neo4j::Community::NEO_VERSION
+            elsif defined?(::Neo4j::Enterprise)
+              ::Neo4j::Enterprise::NEO_VERSION
+            else
+              fail 'Could not determine embedded version!'
+            end
+          end
+
+          instrument(:transaction, 'neo4j.core.embedded.transaction', []) do |_, start, finish, _id, _payload|
+            ms = (finish - start) * 1000
+
+            " #{ANSI::BLUE}EMBEDDED CYPHER TRANSACTION:#{ANSI::CLEAR} #{ANSI::YELLOW}#{ms.round}ms#{ANSI::CLEAR}"
+          end
+
+          private
+
+          def engine
+            @engine ||= Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/adaptors/http.rb

@@ -0,0 +1,159 @@
+require 'neo4j/core/cypher_session/adaptors'
+require 'neo4j/core/cypher_session/responses/http'
+
+# TODO: Work with `Query` objects
+module Neo4j
+  module Core
+    class CypherSession
+      module Adaptors
+        class HTTP < Base
+          # @transaction_state valid states
+          # nil, :open_requested, :open, :close_requested
+
+          def initialize(url, _options = {})
+            @url = url
+            @url_components = url_components!(url)
+            @transaction_state = nil
+          end
+
+          def connect
+            @connection ||= connection
+          end
+
+          ROW_REST = %w(row REST)
+
+          def query_set(queries)
+            fail 'Query attempted without a connection' if @connection.nil?
+
+            statements_data = queries.map do |query|
+              {statement: query.cypher, parameters: query.parameters || {},
+               resultDataContents: ROW_REST}
+            end
+            request_data = {statements: statements_data}
+
+            # context option not implemented
+            self.class.instrument_queries(queries)
+
+            url = full_transaction_url
+            faraday_response = self.class.instrument_request(url, request_data) do
+              @connection.post(url, request_data)
+            end
+
+            store_transaction_id!(faraday_response)
+
+            Responses::HTTP.new(faraday_response, request_data).results
+          end
+
+          def start_transaction
+            case @transaction_state
+            when :open
+              return
+            when :close_requested
+              fail 'Cannot start transaction when a close has been requested'
+            end
+
+            @transaction_state = :open_requested
+          end
+
+          def end_transaction
+            if @transaction_state.nil?
+              fail 'Cannot close transaction without starting one'
+            end
+
+            # This needs thought through more...
+            @transaction_state = :close_requested
+            query_set([])
+            @transaction_state = nil
+
+            true
+          end
+
+          def version
+            @version ||= @connection.get(db_data_url).body[:neo4j_version]
+          end
+
+          instrument(:request, 'neo4j.core.http.request', %w(url body)) do |_, start, finish, _id, payload|
+            ms = (finish - start) * 1000
+
+            " #{ANSI::BLUE}HTTP REQUEST:#{ANSI::CLEAR} #{ANSI::YELLOW}#{ms.round}ms#{ANSI::CLEAR} #{payload[:url]}"
+          end
+
+          private
+
+          def store_transaction_id!(faraday_response)
+            location = faraday_response.env[:response_headers][:location]
+
+            return if !location
+
+            @transaction_id = location.split('/').last.to_i
+          end
+
+          def full_transaction_url
+            path = case @transaction_state
+                   when nil then '/commit'
+                   when :open_requested then ''
+                   when :open then "/#{@transaction_id}"
+                   when :close_requested then "/#{@transaction_id}/commit"
+                   end
+
+            db_data_url + 'transaction' + path
+          end
+
+          def db_data_url
+            url_base + 'db/data/'
+          end
+
+          def url_base
+            "#{scheme}://#{host}:#{port}/"
+          end
+
+          def connection
+            Faraday.new(@url) do |c|
+              c.request :basic_auth, user, password
+              c.request :multi_json
+
+              c.response :multi_json, symbolize_keys: true, content_type: 'application/json'
+              c.use Faraday::Adapter::NetHttpPersistent
+
+              c.headers['Content-Type'] = 'application/json'
+              c.headers['User-Agent'] = user_agent_string
+            end
+          end
+
+          def url_components!(url)
+            @uri = URI(url || 'http://localhost:7474')
+
+            if !@uri.is_a?(URI::HTTP)
+              fail ArgumentError, "Invalid URL: #{url.inspect}"
+            end
+
+            true
+          end
+
+          URI_DEFAULTS = {
+            scheme: 'http',
+            user: 'neo4j', password: 'neo4j',
+            host: 'localhost', port: 7474
+          }
+
+          URI_DEFAULTS.each do |method, value|
+            define_method(method) do
+              @uri.send(method) || value
+            end
+          end
+
+          def user_agent_string
+            gem, version = if defined?(::Neo4j::ActiveNode)
+                             ['neo4j', ::Neo4j::VERSION]
+                           else
+                             ['neo4j-core', ::Neo4j::Core::VERSION]
+                           end
+
+
+            "#{gem}-gem/#{version} (https://github.com/neo4jrb/#{gem})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/adaptors.rb

@@ -0,0 +1,108 @@
+require 'neo4j/core/instrumentable'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Adaptors
+        MAP = {}
+
+        class Base
+          include Neo4j::Core::Instrumentable
+
+          def connect(*_args)
+            fail '#connect not implemented!'
+          end
+
+          Query = Struct.new(:cypher, :parameters, :pretty_cypher, :context)
+
+          class QueryBuilder
+            attr_reader :queries
+
+            def initialize
+              @queries = []
+            end
+
+            def append(*args)
+              query = case args.map(&:class)
+                      when [String], [String, Hash]
+                        Query.new(args[0], args[1] || {})
+                      when [::Neo4j::Core::Query]
+                        args[0]
+                      else
+                        fail ArgumentError, "Could not determine query from arguments: #{args.inspect}"
+                      end
+
+              @queries << query
+            end
+
+            def query
+              # `nil` sessions are just a workaround until
+              # we phase out `Query` objects containing sessions
+              Neo4j::Core::Query.new(session: nil)
+            end
+          end
+
+          def query(cypher, parameters = {})
+            queries do
+              append(cypher, parameters)
+            end[0]
+          end
+
+          def queries(&block)
+            query_builder = QueryBuilder.new
+
+            query_builder.instance_eval(&block)
+
+            query_set(query_builder.queries)
+          end
+
+          def query_set(_queries)
+            fail '#queries not implemented!'
+          end
+
+          def start_transaction(*_args)
+            fail '#start_transaction not implemented!'
+          end
+
+          def end_transaction(*_args)
+            fail '#end_transaction not implemented!'
+          end
+
+          def version(*_args)
+            fail '#version not implemented!'
+          end
+
+          # Uses #start_transaction and #end_transaction to allow
+          # execution of queries within a block to be part of a
+          # full transaction
+          def transaction
+            start_transaction
+
+            yield
+          ensure
+            end_transaction
+          end
+
+          EMPTY = ''
+          NEWLINE_W_SPACES = "\n  "
+
+          instrument(:query, 'neo4j.core.cypher_query', %w(query)) do |_, _start, _finish, _id, payload|
+            query = payload[:query]
+            params_string = (query.parameters && query.parameters.size > 0 ? "| #{query.parameters.inspect}" : EMPTY)
+            cypher = query.pretty_cypher ? NEWLINE_W_SPACES + query.pretty_cypher.gsub(/\n/, NEWLINE_W_SPACES) : query.cypher
+
+            " #{ANSI::CYAN}#{query.context || 'CYPHER'}#{ANSI::CLEAR} #{cypher} #{params_string}"
+          end
+
+          class << self
+            def instrument_queries(queries)
+              queries.each do |query|
+                instrument_query(query) {}
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/responses/embedded.rb

@@ -0,0 +1,77 @@
+require 'neo4j/core/cypher_session/responses'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Responses
+        class Embedded < Base
+          attr_reader :results, :request_data
+
+          def initialize(execution_results)
+            @results = execution_results.map do |execution_result|
+              result_from_execution_result(execution_result)
+            end
+          end
+
+          private
+
+          def result_from_execution_result(execution_result)
+            columns = execution_result.columns.to_a
+            rows = execution_result.map do |execution_result_row|
+              columns.map { |column| wrap_entity(execution_result_row[column]) }
+            end
+            Result.new(columns, rows)
+          end
+
+          def wrap_entity(entity)
+            if entity.is_a?(Array) ||
+               entity.is_a?(Java::ScalaCollectionConvert::Wrappers::SeqWrapper)
+              entity.to_a.map { |e| wrap_entity(e) }
+            elsif entity.is_a?(Java::OrgNeo4jKernelImplCore::NodeProxy)
+              wrap_node(entity)
+            elsif entity.is_a?(Java::OrgNeo4jKernelImplCore::RelationshipProxy)
+              wrap_relationship(entity)
+            elsif entity.respond_to?(:path_entities)
+              wrap_path(entity)
+            else
+              wrap_value(entity)
+            end
+          end
+
+          def wrap_node(entity)
+            ::Neo4j::Core::Node.new(entity.get_id,
+                                    entity.get_labels.map(&:to_s),
+                                    get_entity_properties(entity)).wrap
+          end
+
+          def wrap_relationship(entity)
+            ::Neo4j::Core::Relationship.new(entity.get_id,
+                                            entity.get_type.name,
+                                            get_entity_properties(entity)).wrap
+          end
+
+          def wrap_path(entity)
+            ::Neo4j::Core::Path.new(entity.nodes.map(&method(:wrap_node)),
+                                    entity.relationships.map(&method(:wrap_relationship)),
+                                    nil).wrap
+          end
+
+          def wrap_value(entity)
+            if entity.is_a?(Java::ScalaCollectionConvert::Wrappers::MapWrapper)
+              entity.each_with_object({}) { |(k, v), r| r[k.to_sym] = v }
+            else
+              # Convert from Java?
+              entity
+            end
+          end
+
+          def get_entity_properties(entity)
+            entity.get_property_keys.each_with_object({}) do |key, result|
+              result[key.to_sym] = entity.get_property(key)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/responses/http.rb

@@ -0,0 +1,104 @@
+require 'neo4j/core/cypher_session/responses'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Responses
+        class HTTP < Base
+          attr_reader :results, :request_data
+
+          def initialize(faraday_response, request_data)
+            @request_data = request_data
+
+            validate_faraday_response!(faraday_response)
+
+            @results = faraday_response.body[:results].map do |result_data|
+              result_from_data(result_data[:columns], result_data[:data])
+            end
+          end
+
+          def result_from_data(columns, entities_data)
+            rows = entities_data.map do |entity_data|
+              wrap_entity entity_data[:row], entity_data[:rest]
+            end
+
+            Result.new(columns, rows)
+          end
+
+          def wrap_entity(row_data, rest_data)
+            row_data.each_with_index.map do |row_datum, i|
+              rest_datum = rest_data[i]
+
+              if rest_datum.is_a?(Array)
+                wrap_entity(row_datum, rest_datum)
+              elsif (ident = identify_entity(rest_datum))
+                send("wrap_#{ident}", rest_datum, row_datum)
+              else
+                row_datum
+              end
+            end
+          end
+
+          private
+
+          def identify_entity(rest_datum)
+            self_string = rest_datum[:self]
+            if self_string
+              type = self_string.split('/')[-2]
+              if type == 'node'
+                :node
+              elsif type == 'relationship'
+                :relationship
+              end
+            elsif [:nodes, :relationships, :start, :end, :length].all? { |k| rest_datum.key?(k) }
+              :path
+            end
+          end
+
+          def wrap_node(rest_datum, _)
+            metadata_data = rest_datum[:metadata]
+            ::Neo4j::Core::Node.new(id_from_rest_datum(rest_datum),
+                                    metadata_data && metadata_data[:labels],
+                                    rest_datum[:data]).wrap
+          end
+
+          def wrap_relationship(rest_datum, _)
+            metadata_data = rest_datum[:metadata]
+            ::Neo4j::Core::Relationship.new(id_from_rest_datum(rest_datum),
+                                            metadata_data && metadata_data[:type],
+                                            rest_datum[:data]).wrap
+          end
+
+          def wrap_path(rest_datum, row_datum)
+            nodes = rest_datum[:nodes].each_with_index.map do |url, i|
+              Node.from_url(url, row_datum[2 * i])
+            end
+            relationships = rest_datum[:relationships].each_with_index.map do |url, i|
+              Relationship.from_url(url, row_datum[(2 * i) + 1])
+            end
+
+            ::Neo4j::Core::Path.new(nodes, relationships, rest_datum[:directions]).wrap
+          end
+
+          def id_from_rest_datum(rest_datum)
+            if rest_datum[:metadata]
+              rest_datum[:metadata][:id]
+            else
+              rest_datum[:self].split('/').last.to_i
+            end
+          end
+
+          def validate_faraday_response!(faraday_response)
+            if error = faraday_response.body[:errors][0]
+              fail CypherError, "#{ANSI::CYAN}#{error[:code]}#{ANSI::CLEAR}: #{error[:message]}"
+            end
+
+            return if (200..299).include?(status = faraday_response.status)
+
+            fail CypherError, "Expected 200-series response for #{faraday_response.env.url} (got #{status})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/responses.rb

@@ -0,0 +1,27 @@
+require 'neo4j/core/cypher_session/result'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Responses
+        MAP = {}
+
+        class Base
+          class CypherError < StandardError; end
+
+          include Enumerable
+
+          def each
+            results.each do |result|
+              yield result
+            end
+          end
+
+          def results
+            fail '#results not implemented!'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/result.rb

@@ -0,0 +1,39 @@
+require 'neo4j/core/node'
+require 'neo4j/core/relationship'
+require 'neo4j/core/path'
+
+module Neo4j
+  module Core
+    class CypherSession
+      class Result
+        attr_reader :columns, :rows
+
+        def initialize(columns, rows)
+          @columns = columns.map(&:to_sym)
+          @rows = rows
+          @struct_class = Struct.new(*@columns)
+        end
+
+        include Enumerable
+
+        def each
+          structs.each do |struct|
+            yield struct
+          end
+        end
+
+        def structs
+          @structs ||= rows.map do |row|
+            @struct_class.new(*row)
+          end
+        end
+
+        def hashes
+          @hashes ||= rows.map do |row|
+            Hash[@columns.zip(row)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session.rb

@@ -0,0 +1,28 @@
+require 'neo4j/core/cypher_session/adaptors/http'
+
+module Neo4j
+  module Core
+    class CypherSession
+      def initialize(adaptor)
+        fail ArgumentError, "Invalid adaptor: #{adaptor.inspect}" if !adaptor.is_a?(Adaptors::Base)
+
+        @adaptor = adaptor
+
+        @adaptor.connect
+      end
+
+      %w(
+        query
+        queries
+        start_transaction
+        end_transaction
+        version
+        transactions
+      ).each do |method|
+        define_method(method) do |*args|
+          @adaptor.send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/instrumentable.rb

@@ -0,0 +1,36 @@
+require 'active_support/notifications'
+
+module Neo4j
+  module Core
+    module Instrumentable
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.extend ClassMethods
+      end
+
+      module InstanceMethods
+      end
+
+      module ClassMethods
+        def instrument(name, label, arguments, &block)
+          # defining class methods
+          klass = class << self; self; end
+          klass.instance_eval do
+            define_method("subscribe_to_#{name}") do |&b|
+              ActiveSupport::Notifications.subscribe(label) do |a, start, finish, id, payload|
+                b.call block.call(a, start, finish, id, payload)
+              end
+            end
+
+            define_method("instrument_#{name}") do |*args, &b|
+              hash = arguments.each_with_index.each_with_object({}) do |(argument, i), result|
+                result[argument.to_sym] = args[i]
+              end
+              ActiveSupport::Notifications.instrument(label, hash) { b.call }
+            end
+          end
+        end
+      end
+    end
+  end
+end