neo4j-core 4.0.7 → 5.0.0.rc.1

data/lib/neo4j-embedded/embedded_node.rb

@@ -6,6 +6,7 @@ module Neo4j
 
       def initialize(node, match)
         @node = node
+        ::Neo4j::Node.validate_match!(match)
         @match = match
       end
 
@@ -46,7 +47,7 @@ module Neo4j
       end
     end
 
-    class EmbeddedNode
+    class EmbeddedNode < Neo4j::Node
       class << self
         # This method is used to extend a Java Neo4j class so that it includes the same mixins as this class.
         Java::OrgNeo4jKernelImplCore::NodeProxy.class_eval do
@@ -149,41 +150,32 @@ module Neo4j
           tx_methods :rel
 
           def _rel(match = {})
-            dir = ToJava.dir_to_java(match[:dir] || :both)
-            rel_type = match[:type]
+            dir, rel_type, between_id = _parse_match(match)
 
             rel = if rel_type
-                    get_single_relationship(ToJava.type_to_java(rel_type), dir)
+                    get_single_relationship(rel_type, dir)
                   else
-                    iter = get_relationships(dir).iterator
-
-                    if iter.has_next
-                      first = iter.next
-                      fail "Expected to only find one relationship from node #{neo_id} matching #{match.inspect}" if iter.has_next
-                      first
-                    end
+                    _get_single_relationship_by_dir(dir)
                   end
 
-            between_id = match[:between] && match[:between].neo_id
+            rel if !(rel && between_id) || rel.other_node(self).neo_id == between_id
+          end
 
-            if rel && between_id
-              rel if rel.other_node(self).neo_id == between_id
-            else
-              rel
-            end
+          def _get_single_relationship_by_dir(dir)
+            iter = get_relationships(dir).iterator
+
+            return nil if not iter.has_next
+
+            first = iter.next
+            fail "Expected to only find one relationship from node #{neo_id} matching #{match.inspect}" if iter.has_next
+            first
           end
 
           def _rels(match = {})
-            dir = match[:dir] || :both
-            rel_type = match[:type]
+            dir, rel_type, between_id = _parse_match(match)
 
-            rels = if rel_type
-                     get_relationships(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir)).iterator
-                   else
-                     get_relationships(ToJava.dir_to_java(dir)).iterator
-                   end
-
-            between_id = match[:between] && match[:between].neo_id
+            args = rel_type ? [rel_type, dir] : [dir]
+            rels = get_relationships(*args).iterator
 
             if between_id
               rels.find_all { |r| r.end_node.neo_id == between_id || r.start_node.neo_id == between_id }
@@ -192,8 +184,14 @@ module Neo4j
             end
           end
 
-          def class
-            Neo4j::Node
+          def _parse_match(match)
+            ::Neo4j::Node.validate_match!(match)
+
+            [
+              ToJava.dir_to_java(match[:dir] || :both),
+              ToJava.type_to_java(match[:type]),
+              match[:between] && match[:between].neo_id
+            ]
           end
 
           include Neo4j::Node::Wrapper

data/lib/neo4j-embedded/embedded_session.rb

@@ -16,7 +16,6 @@ module Neo4j
       extend Neo4j::Core::TxMethods
       def_delegator :@graph_db, :begin_tx
 
-
       def initialize(db_location, config = {})
         @db_location     = db_location
         @auto_commit     = !!config[:auto_commit]
@@ -34,7 +33,7 @@ module Neo4j
 
       def version
         # Wow
-        version_string = graph_db.to_java(Java::OrgNeo4jKernel::GraphDatabaseAPI).getDependencyResolver.resolveDependency(Java::OrgNeo4jKernel::KernelData.java_class).version.to_s
+        version_string = @graph_db.to_java(Java::OrgNeo4jKernel::GraphDatabaseAPI).getDependencyResolver.resolveDependency(Java::OrgNeo4jKernel::KernelData.java_class).version.to_s
         version_string.split(' ')[-1]
       end
 
@@ -69,12 +68,14 @@ module Neo4j
       end
 
       def shutdown
-        graph_db && graph_db.shutdown
+        @graph_db && @graph_db.shutdown
+
+        Neo4j::Session.clear_listeners
         @graph_db = nil
       end
 
       def running?
-        !!graph_db
+        !!@graph_db
       end
 
       def create_label(name)
@@ -152,10 +153,10 @@ module Neo4j
 
       def create_node(properties = nil, labels = [])
         if labels.empty?
-          graph_db.create_node
+          @graph_db.create_node
         else
           labels = EmbeddedLabel.as_java(labels)
-          graph_db.create_node(labels)
+          @graph_db.create_node(labels)
         end.tap do |java_node|
           properties.each_pair { |k, v| java_node[k] = v } if properties
         end

data/lib/neo4j-embedded/embedded_transaction.rb

@@ -22,12 +22,12 @@ module Neo4j
         "EmbeddedTransaction [nested: #{@pushed_nested} failed?: #{failure?} active: #{Neo4j::Transaction.current == self}]"
       end
 
-      def _delete_tx
+      def delete
         @root_tx.failure
         @root_tx.close
       end
 
-      def _commit_tx
+      def commit
         @root_tx.success
         @root_tx.close
       end

data/lib/neo4j-embedded/label.rb

@@ -0,0 +1,65 @@
+module Neo4j
+  class Label
+    class << self
+      def indexes
+        schema_query(:get_indexes)
+      end
+
+      def constraints
+        schema_query(:get_constraints)
+      end
+
+      def index?(label, property)
+        schema_index_operation(label, property, :indexes)
+      end
+
+      def constraint?(label, property)
+        schema_index_operation(label, property, :constraints)
+      end
+
+      def drop_all_indexes
+        Neo4j::Transaction.run do
+          schema.get_indexes.to_a.each do |i|
+            begin
+              i.drop
+            rescue Java::JavaLang::IllegalStateException; end
+          end
+        end
+      end
+
+      def drop_all_constraints
+        Neo4j::Transaction.run do
+          schema.get_constraints.to_a.each(&:drop)
+        end
+      end
+
+      private
+
+      def schema_query(query_method)
+        [].tap do |index_array|
+          Neo4j::Transaction.run do
+            schema.send(query_method).to_a.each { |i| index_array << index_hash(i) }
+          end
+        end
+      end
+
+      def schema_index_operation(label, property, schema_method)
+        label = label.to_s
+        property = property.to_s
+        !send(schema_method).select { |i| matched_index(i, label, property) }.empty?
+      end
+
+      def index_hash(java_index)
+        {property_keys: java_index.get_property_keys.to_a, label: java_index.get_label.name}
+      end
+
+      def matched_index(java_index, label, property)
+        java_index[:property_keys].first == property && java_index[:label] == label
+      end
+
+      def schema
+        Neo4j::Session.current.graph_db.schema
+      end
+    end
+  end
+end

data/lib/neo4j-embedded/property.rb

@@ -75,15 +75,13 @@ module Neo4j
       end
 
       def to_java_property(k, v)
-        validate_property(v)
+        validate_property!(v)
 
         k = k.to_s
         case v
-        when nil
-          remove_property(k)
+        when nil then remove_property(k)
         when Array
-          type = java_type_from_value(v[0]) || fail("Not allowed to store array with value #{v[0]} type #{v[0].class}")
-          set_property(k, v.to_java(type))
+          set_property(k, v.to_java(java_type_from_value(v[0])))
         else
           set_property(k, v)
         end
@@ -99,6 +97,8 @@ module Neo4j
           :boolean
         when Fixnum
           :long
+        else
+          fail "Not allowed to store array with value #{value.inspect} type #{value.class}"
         end
       end
     end

data/lib/neo4j-embedded/to_java.rb

@@ -4,7 +4,7 @@ module Neo4j
     # @private
     module ToJava
       def type_to_java(type)
-        Java::OrgNeo4jGraphdb::DynamicRelationshipType.withName(type.to_s)
+        type && Java::OrgNeo4jGraphdb::DynamicRelationshipType.withName(type.to_s)
       end
 
       module_function :type_to_java
@@ -18,12 +18,9 @@ module Neo4j
 
       def dir_from_java(dir)
         case dir
-        when Java::OrgNeo4jGraphdb::Direction::OUTGOING then
-          :outgoing
-        when Java::OrgNeo4jGraphdb::Direction::BOTH then
-          :both
-        when Java::OrgNeo4jGraphdb::Direction::INCOMING then
-          :incoming
+        when Java::OrgNeo4jGraphdb::Direction::OUTGOING then :outgoing
+        when Java::OrgNeo4jGraphdb::Direction::BOTH then :both
+        when Java::OrgNeo4jGraphdb::Direction::INCOMING then :incoming
         else
           fail "unknown direction '#{dir} / #{dir.class}'"
         end
@@ -33,12 +30,9 @@ module Neo4j
 
       def dir_to_java(dir)
         case dir
-        when :outgoing then
-          Java::OrgNeo4jGraphdb::Direction::OUTGOING
-        when :both then
-          Java::OrgNeo4jGraphdb::Direction::BOTH
-        when :incoming then
-          Java::OrgNeo4jGraphdb::Direction::INCOMING
+        when :outgoing then Java::OrgNeo4jGraphdb::Direction::OUTGOING
+        when :both then Java::OrgNeo4jGraphdb::Direction::BOTH
+        when :incoming then Java::OrgNeo4jGraphdb::Direction::INCOMING
         else
           fail "unknown direction '#{dir}', expects argument: outgoing, :incoming or :both"
         end

data/lib/neo4j-embedded.rb

@@ -8,6 +8,7 @@ require 'neo4j-embedded/embedded_label'
 require 'neo4j-embedded/embedded_node'
 require 'neo4j-embedded/embedded_relationship'
 require 'neo4j-embedded/embedded_label'
+require 'neo4j-embedded/label'
 require 'neo4j-embedded/embedded_transaction'
 require 'neo4j-embedded/cypher_response'
 

data/lib/neo4j-server/cypher_node.rb

@@ -9,10 +9,9 @@ module Neo4j
         @session = session
 
         @neo_id = if value.is_a?(Hash)
-                    hash = value['data']
-                    @props = Hash[hash.map { |k, v| [k.to_sym, v] }]
-                    @labels = value['metadata']['labels'].map!(&:to_sym) if value['metadata']
-                    value['id'] # value['self'].match(/\d+$/)[0].to_i
+                    @props = value[:data]
+                    @labels = value[:metadata][:labels].map!(&:to_sym) if value[:metadata]
+                    value[:id]
                   else
                     value
                   end
@@ -31,15 +30,12 @@ module Neo4j
 
       # (see Neo4j::Node#create_rel)
       def create_rel(type, other_node, props = nil)
-        ids_hash = {start_neo_id: neo_id, end_neo_id: other_node.neo_id}
-        props_with_ids = props.nil? ? ids_hash : cypher_prop_list(props).merge(ids_hash)
-        id = @session._query_or_fail(rel_string(type, other_node, props), true, props_with_ids)
-        data_hash = {'type' => type, 'data' => props, 'start' => neo_id, 'end' => other_node.neo_id, 'id' => id}
-        CypherRelationship.new(@session, data_hash)
-      end
+        q = @session.query.match(:a, :b).where(a: {neo_id: neo_id}, b: {neo_id: other_node.neo_id})
+            .create("(a)-[r:`#{type}`]->(b)").break.set(r: props).return(r: :neo_id)
+
+        id = @session._query_or_fail(q, true)
 
-      def rel_string(type, other_node, props)
-        "MATCH (a), (b) WHERE ID(a) = {start_neo_id} AND ID(b) = {end_neo_id} CREATE (a)-[r:`#{type}` #{prop_identifier(props)}]->(b) RETURN ID(r)"
+        CypherRelationship.new(@session, type: type, data: props, start: neo_id, end: other_node.neo_id, id: id)
       end
 
       # (see Neo4j::Node#props)
@@ -47,8 +43,8 @@ module Neo4j
         if @props
           @props
         else
-          hash = @session._query_entity_data("#{match_start} RETURN n", nil, neo_id: neo_id)
-          @props = Hash[hash['data'].map { |k, v| [k.to_sym, v] }]
+          hash = @session._query_entity_data(match_start_query.return(:n), nil)
+          @props = Hash[hash[:data].to_a]
         end
       end
 
@@ -59,29 +55,27 @@ module Neo4j
       # (see Neo4j::Node#remove_property)
       def remove_property(key)
         refresh
-        @session._query_or_fail("#{match_start} REMOVE n.`#{key}`", false,  neo_id: neo_id)
+        @session._query_or_fail(match_start_query.remove(n: key), false)
       end
 
       # (see Neo4j::Node#set_property)
       def set_property(key, value)
         refresh
-        @session._query_or_fail("#{match_start} SET n.`#{key}` = { value }", false,  value: value, neo_id: neo_id)
-        value
+        @session._query_or_fail(match_start_query.set(n: {key => value}), false)
       end
 
       # (see Neo4j::Node#props=)
       def props=(properties)
         refresh
-        @session._query_or_fail("#{match_start} SET n = { props }", false,  props: properties, neo_id: neo_id)
+        @session._query_or_fail(match_start_query.set_props(n: properties), false)
         properties
       end
 
       def remove_properties(properties)
+        return if properties.empty?
+
         refresh
-        q = "#{match_start} REMOVE " + properties.map do |k|
-          "n.`#{k}`"
-        end.join(', ')
-        @session._query_or_fail(q, false, neo_id: neo_id)
+        @session._query_or_fail(match_start_query.remove(n: properties), false, neo_id: neo_id)
       end
 
       # (see Neo4j::Node#update_props)
@@ -89,23 +83,19 @@ module Neo4j
         refresh
         return if properties.empty?
 
-        removed_keys = properties.keys.select { |k| properties[k].nil? }
-        remove_properties(removed_keys) unless removed_keys.empty?
-        properties_to_set = properties.keys - removed_keys
-        return if properties_to_set.empty?
-        props_list = cypher_prop_list(properties)[:props].merge(neo_id: neo_id)
-        @session._query_or_fail("#{match_start} SET #{cypher_properties(properties_to_set)}", false, props_list)
+        @session._query_or_fail(match_start_query.set(n: properties), false)
+
         properties
       end
 
       # (see Neo4j::Node#get_property)
       def get_property(key)
-        @props ? @props[key.to_sym] : @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true, neo_id: neo_id)
+        @props ? @props[key.to_sym] : @session._query_or_fail(match_start_query.return(n: key), true)
       end
 
       # (see Neo4j::Node#labels)
       def labels
-        @labels ||= @session._query_or_fail("#{match_start} RETURN labels(n) as labels", true, neo_id: neo_id).map!(&:to_sym)
+        @labels ||= @session._query_or_fail(match_start_query.return('labels(n) AS labels'), true).map(&:to_sym)
       end
 
       def _cypher_label_list(labels_list)
@@ -113,18 +103,29 @@ module Neo4j
       end
 
       def add_label(*new_labels)
-        @session._query_or_fail("#{match_start} SET n #{_cypher_label_list(new_labels)}", false, neo_id: neo_id)
+        @session._query_or_fail(match_start_query.set(n: new_labels), false)
         new_labels.each { |label| labels << label }
       end
 
       def remove_label(*target_labels)
-        @session._query_or_fail("#{match_start} REMOVE n #{_cypher_label_list(target_labels)}", false, neo_id: neo_id)
+        @session._query_or_fail(match_start_query.remove(n: target_labels), false)
         target_labels.each { |label| labels.delete(label) } unless labels.nil?
       end
 
       def set_label(*label_names)
-        q = "#{match_start} #{remove_labels_if_needed} #{set_labels_if_needed(label_names)}"
-        @session._query_or_fail(q, false, neo_id: neo_id)
+        q = match_start_query
+
+        labels_to_add = label_names.map(&:to_sym).uniq
+        labels_to_remove = labels - label_names
+
+        common_labels = labels & labels_to_add
+        labels_to_add -= common_labels
+        labels_to_remove -= common_labels
+
+        q = q.remove(n: labels_to_remove) unless labels_to_remove.empty?
+        q = q.set(n: labels_to_add) unless labels_to_add.empty?
+
+        @session._query_or_fail(q, false) unless (labels_to_add + labels_to_remove).empty?
       end
 
       # (see Neo4j::Node#del)
@@ -138,7 +139,7 @@ module Neo4j
 
       # (see Neo4j::Node#exist?)
       def exist?
-        @session._query("#{match_start} RETURN ID(n)", neo_id: neo_id).data.empty? ? false : true
+        !@session._query(match_start_query.return(n: :neo_id)).data.empty?
       end
 
       # (see Neo4j::Node#node)
@@ -169,55 +170,44 @@ module Neo4j
 
       # @private
       def match(clazz, returns, match = {})
-        to_dir = {outgoing: ->(rel) { "-#{rel}->" },
-                  incoming: ->(rel) { "<-#{rel}-" },
-                  both:     ->(rel) { "-#{rel}-" }}
-
-        cypher_rel = match[:type] ? "[r:`#{match[:type]}`]" : '[r]'
-        between_id = match[:between] ? "MATCH (p) WHERE ID(p) = #{match[:between].neo_id}" : ''
-        dir_func = to_dir[match[:dir] || :both]
-        cypher = "#{match_start} #{between_id} MATCH (n)#{dir_func.call(cypher_rel)}(p) RETURN #{returns}"
-        r = @session._query(cypher, neo_id: neo_id)
+        ::Neo4j::Node.validate_match!(match)
+
+        query = self.query
+
+        query = query.match(:p).where(p: {neo_id: match[:between].neo_id}) if match[:between]
+
+        r = query.match("(n)#{relationship_arrow(match)}(p)").return(returns).response
+
         r.raise_error if r.error?
-        _map_result(r)
-      end
 
-      def _map_result(r)
         r.to_node_enumeration.map(&:result)
       end
 
-      private
-
-      def cypher_properties(properties_to_set)
-        properties_to_set.map! { |k| "n.`#{k}` = {`#{k}`}" }.join(',')
+      def query(identifier = :n)
+        @session.query.match(identifier).where(identifier => {neo_id: neo_id})
       end
 
-      def remove_labels_if_needed
-        if labels.empty?
-          ''
-        else
-          " REMOVE n #{_cypher_label_list(labels)}"
-        end
-      end
+      private
+
+      def relationship_arrow(match)
+        rel_spec = match[:type] ? "[r:`#{match[:type]}`]" : '[r]'
 
-      def set_labels_if_needed(label_names)
-        if label_names.empty?
-          ''
+        case match[:dir] || :both
+        when :outgoing then "-#{rel_spec}->"
+        when :incoming then "<-#{rel_spec}-"
+        when :both then "-#{rel_spec}-"
         else
-          " SET n #{_cypher_label_list(label_names.map(&:to_sym).uniq)}"
+          fail "Invalid value for relationship_arrow direction: #{match[:dir].inspect}"
         end
       end
 
-      def ensure_single_relationship(&block)
+      def ensure_single_relationship
+        fail 'Expected a block' unless block_given?
         result = yield
         fail "Expected to only find one relationship from node #{neo_id} matching #{match.inspect} but found #{result.count}" if result.count > 1
         result.first
       end
 
-      def match_start(identifier = 'n')
-        "MATCH (#{identifier}) WHERE ID(#{identifier}) = {neo_id}"
-      end
-
       def match_start_query(identifier = :n)
         @session.query.match(identifier).where(identifier => {neo_id: neo_id}).with(identifier)
       end

data/lib/neo4j-server/cypher_node_uncommited.rb

@@ -7,7 +7,7 @@ module Neo4j
       end
 
       def [](key)
-        @data[key.to_s]
+        @data[key]
       end
     end
   end

data/lib/neo4j-server/cypher_relationship.rb

@@ -8,11 +8,11 @@ module Neo4j
       def initialize(session, value)
         @session = session
         @response_hash = value
-        @rel_type = @response_hash['type']
-        @props = @response_hash['data']
-        @start_node_neo_id = @response_hash['start'].is_a?(Integer) ? @response_hash['start'] : @response_hash['start'].match(/\d+$/)[0].to_i
-        @end_node_neo_id = @response_hash['end'].is_a?(Integer) ? @response_hash['end'] : @response_hash['end'].match(/\d+$/)[0].to_i
-        @id = @response_hash['id']
+        @rel_type = @response_hash[:type]
+        @props = @response_hash[:data]
+        @start_node_neo_id = neo_id_integer(@response_hash[:start])
+        @end_node_neo_id = neo_id_integer(@response_hash[:end])
+        @id = @response_hash[:id]
       end
 
       def ==(other)
@@ -80,7 +80,7 @@ module Neo4j
           @props
         else
           hash = @session._query_entity_data("#{match_start} RETURN n", nil, neo_id: neo_id)
-          @props = Hash[hash['data'].map { |k, v| [k.to_sym, v] }]
+          @props = Hash[hash[:data].map { |k, v| [k, v] }]
         end
       end
 
@@ -125,6 +125,10 @@ module Neo4j
       def resource_data_present?
         !resource_data.nil? && !resource_data.empty?
       end
+
+      def neo_id_integer(id_or_url)
+        id_or_url.is_a?(Integer) ? id_or_url : id_or_url.match(/\d+$/)[0].to_i
+      end
     end
   end
 end