neo4j-core 5.1.14 → 6.0.0.alpha.1

data/lib/neo4j-embedded/embedded_session.rb

@@ -26,13 +26,9 @@ module Neo4j
       def properties_map
         return @properties_map if @properties_map
 
-        props = if @config[:properties_map].is_a?(Hash)
-                  @config[:properties_map].each_with_object({}) do |(k, v), m|
-                    m[k.to_s.to_java] = v.to_s.to_java
-                  end
-                else
-                  {}
-                end
+        props = @config[:properties_map].each_with_object({}) do |(k, v), m|
+          m[k.to_s.to_java] = v.to_s.to_java
+        end
         @properties_map = java.util.HashMap.new(props)
       end
 
@@ -46,6 +42,7 @@ module Neo4j
 
       def version
         # Wow
+        # Yeah, agreed...
         version_string = @graph_db.to_java(Java::OrgNeo4jKernel::GraphDatabaseAPI).getDependencyResolver.resolveDependency(Java::OrgNeo4jKernel::KernelData.java_class).version.to_s
         version_string.split(' ')[-1]
       end
@@ -150,18 +147,12 @@ module Neo4j
         ActiveSupport::Notifications.instrument('neo4j.cypher_query', params: params, context: options[:context],
                                                                       cypher: query, pretty_cypher: options[:pretty_cypher], params: params) do
           @engine ||= Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-          @engine.execute(query, indifferent_params(params))
+          @engine.execute(query, HashWithIndifferentAccess.new(params))
         end
       rescue StandardError => e
         raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
       end
 
-      def indifferent_params(params)
-        return {} unless params
-        params.each { |k, v| params[k] = HashWithIndifferentAccess.new(params[k]) if v.is_a?(Hash) && !v.respond_to?(:nested_under_indifferent_access) }
-        HashWithIndifferentAccess.new(params)
-      end
-
       def query_default_return(as)
         " RETURN #{as}"
       end

data/lib/neo4j-embedded/label.rb

@@ -22,7 +22,8 @@ module Neo4j
           schema.get_indexes.to_a.each do |i|
             begin
               i.drop
-            rescue Java::JavaLang::IllegalStateException; end
+            rescue Java::JavaLang::IllegalStateException
+            end
           end
         end
       end

data/lib/neo4j-server/cypher_label.rb

@@ -10,16 +10,17 @@ module Neo4j
         @session = session
       end
 
-      def create_index(*properties)
-        response = @session._query("CREATE INDEX ON :`#{@name}`(#{properties.join(',')})")
+      def create_index(property, options = {}, session = Neo4j::Session.current)
+        validate_index_options!(options)
+        properties = property.is_a?(Array) ? property.join(',') : property
+        response = session._query("CREATE INDEX ON :`#{@name}`(#{properties})")
         response.raise_error if response.error?
       end
 
-      def drop_index(*properties)
-        properties.each do |property|
-          response = @session._query("DROP INDEX ON :`#{@name}`(#{property})")
-          response.raise_error if response.error? && !response.error_msg.match(/No such INDEX ON/)
-        end
+      def drop_index(property, options = {}, session = Neo4j::Session.current)
+        validate_index_options!(options)
+        response = session._query("DROP INDEX ON :`#{@name}`(#{property})")
+        response.raise_error if response.error? && !response.error_msg.match(/No such INDEX ON/)
       end
 
       def indexes

data/lib/neo4j-server/cypher_relationship.rb

@@ -85,7 +85,7 @@ module Neo4j
 
       # (see Neo4j::Relationship#props=)
       def props=(properties)
-        @session._query_or_fail("#{match_start} SET n = { props }", false,  props: properties, neo_id: neo_id)
+        @session._query_or_fail("#{match_start} SET n = { props }", false, props: properties, neo_id: neo_id)
         properties
       end
 

data/lib/neo4j-server/cypher_response.rb

@@ -101,9 +101,10 @@ module Neo4j
       def identify_entity(data)
         self_string = data[:self]
         if self_string
-          if self_string.include?('node')
+          type = self_string.split('/')[-2]
+          if type == 'node'
             :node
-          elsif self_string.include?('relationship')
+          elsif type == 'relationship'
             :relationship
           end
         elsif [:nodes, :relationships, :start, :end, :length].all? { |k| data.key?(k) }

data/lib/neo4j-server/cypher_transaction.rb

@@ -73,17 +73,12 @@ module Neo4j
             cypher_response.set_data(first_result)
           else
             first_error = response.body[:errors].first
-            tx_cleanup!(first_error)
+            mark_expired if first_error[:message].match(/Unrecognized transaction id/)
             cypher_response.set_error(first_error)
           end
         end
       end
 
-      def tx_cleanup!(first_error)
-        autoclosed!
-        mark_expired if first_error[:message].match(/Unrecognized transaction id/)
-      end
-
       def empty_response
         OpenStruct.new(status: 200, body: '')
       end

data/lib/neo4j-server/resource.rb

@@ -47,7 +47,7 @@ module Neo4j
       end
 
       def resource_url_id(url = resource_url)
-        url.match(/\/(\d+)$/)[1].to_i
+        url.match(%r{/(\d+)$})[1].to_i
       end
 
       def convert_from_json_value(value)

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/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/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