neo4j-core 5.0.1 → 5.1.0

data/lib/neo4j-core/query_clauses.rb

@@ -11,12 +11,12 @@ module Neo4j
 
 
       class Clause
-        include CypherTranslator
         UNDERSCORE = '_'
         COMMA_SPACE = ', '
         AND = ' AND '
 
         attr_accessor :params, :arg
+        attr_reader :options
 
         def initialize(arg, options = {})
           @arg = arg
@@ -25,7 +25,7 @@ module Neo4j
         end
 
         def value
-          [String, Symbol, Integer, Hash].each do |arg_class|
+          [String, Symbol, Integer, Hash, NilClass].each do |arg_class|
             from_method = "from_#{arg_class.name.downcase}"
             return send(from_method, @arg) if @arg.is_a?(arg_class) && self.respond_to?(from_method)
           end
@@ -53,8 +53,10 @@ module Neo4j
         end
 
         def node_from_key_and_value(key, value, options = {})
-          var = var_from_key_and_value(key, value, options[:prefer] || :var)
-          label = label_from_key_and_value(key, value, options[:prefer] || :var)
+          prefer = options[:prefer] || :var
+          var = var_from_key_and_value(key, value, prefer)
+          label = label_from_key_and_value(key, value, prefer)
+
           attributes = attributes_from_key_and_value(key, value)
 
           prefix_value = value
@@ -131,30 +133,73 @@ module Neo4j
             new(arg, options) if !arg.respond_to?(:empty?) || !arg.empty?
           end
 
-          def to_cypher(clauses)
+          def to_cypher(clauses, options = {})
             @question_mark_param_index = 1
 
-            string = clause_string(clauses)
-            string.strip!
+            string = clause_string(clauses, options)
+
+            final_keyword = if options[:pretty]
+                              "#{clause_color}#{keyword}#{ANSI::CLEAR}"
+                            else
+                              keyword
+                            end
+
+            "#{final_keyword} #{string}" if string.size > 0
+          end
+
+          def clause_string(clauses, options = {})
+            join_string = clause_join + (options[:pretty] ? "\n  " : '')
+
+            strings = clause_strings(clauses)
+            string = ((options[:pretty] && strings.size > 1) ? "\n  " : '')
+            string + strings.join(join_string).strip
+          end
+
+          def clause_join
+            ''
+          end
 
-            "#{keyword} #{string}" if string.size > 0
+          def clause_color
+            ANSI::CYAN
           end
         end
 
+        def self.paramaterize_key!(key)
+          key.tr_s!('^a-zA-Z0-9', UNDERSCORE)
+          key.gsub!(/^_+|_+$/, '')
+        end
+
         private
 
         def key_value_string(key, value, previous_keys = [], is_set = false)
           param = (previous_keys << key).join(UNDERSCORE)
-          param.tr_s!('^a-zA-Z0-9', UNDERSCORE)
-          param.gsub!(/^_+|_+$/, '')
+          self.class.paramaterize_key!(param)
 
-          value = value.first if !is_set && value.is_a?(Array) && value.size == 1
-          @params[param.to_sym] = value
+          if value.is_a?(Range)
+            add_params("#{param}_range_min" => value.min, "#{param}_range_max" => value.max)
 
-          if !value.is_a?(Array) || is_set
-            "#{key} = {#{param}}"
+            "#{key} IN RANGE({#{param}_range_min}, {#{param}_range_max})"
           else
-            "#{key} IN {#{param}}"
+            value = value.first if array_value?(value, is_set) && value.size == 1
+            operator = array_value?(value, is_set) ? 'IN' : '='
+
+            add_param(param, value)
+
+            "#{key} #{operator} {#{param}}"
+          end
+        end
+
+        def array_value?(value, is_set)
+          value.is_a?(Array) && !is_set
+        end
+
+        def add_param(key, value)
+          @params[key.freeze.to_sym] = value
+        end
+
+        def add_params(params)
+          params.each do |key, value|
+            add_param(key, value)
           end
         end
 
@@ -180,7 +225,7 @@ module Neo4j
               "#{key}: #{value}"
             else
               param_key = "#{prefix}#{key}".gsub('::', '_')
-              @params[param_key.to_sym] = value
+              add_param(param_key, value)
               "#{key}: {#{param_key}}"
             end
           end.join(Clause::COMMA_SPACE)
@@ -206,8 +251,12 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(Clause::COMMA_SPACE)
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
           end
         end
       end
@@ -219,16 +268,24 @@ module Neo4j
           case value
           when Hash then hash_key_value_string(key, value, previous_keys)
           when NilClass then "#{key} IS NULL"
-          when Regexp then regexp_key_value_string(key, value)
-          when Array then key_value_string(key, value, previous_keys)
+          when Regexp then regexp_key_value_string(key, value, previous_keys)
+          when Array, Range then key_value_string(key, value, previous_keys)
           else
             key_value_string(key, value, previous_keys)
           end
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).tap(&:flatten!).map! { |value| "(#{value})" }.join(Clause::AND)
+          def clause_strings(clauses)
+            clauses.flat_map do |clause|
+              Array(clause.value).map do |v|
+                (clause.options[:not] ? 'NOT' : '') + "(#{v})"
+              end
+            end
+          end
+
+          def clause_join
+            Clause::AND
           end
         end
 
@@ -245,9 +302,15 @@ module Neo4j
           end.join(AND)
         end
 
-        def regexp_key_value_string(key, value)
+        def regexp_key_value_string(key, value, previous_keys)
           pattern = (value.casefold? ? '(?i)' : '') + value.source
-          "#{key} =~ #{escape_value(pattern.gsub(/\\/, '\\\\\\'))}"
+
+          param = [previous_keys + [key]].join(UNDERSCORE)
+          self.class.paramaterize_key!(param)
+
+          add_params(param => pattern)
+
+          "#{key} =~ {#{param}}"
         end
 
         class << self
@@ -274,14 +337,18 @@ module Neo4j
           end
 
           def question_mark_params_param
-            result = "question_mark_param#{@question_mark_param_index}"
-            @question_mark_param_index += 1
-            result
+            "question_mark_param#{question_mark_param_index}"
+          end
+
+          def question_mark_param_index
+            @question_mark_param_index ||= 1
+            @question_mark_param_index.tap do
+              @question_mark_param_index += 1
+            end
           end
         end
       end
 
-
       class MatchClause < Clause
         KEYWORD = 'MATCH'
 
@@ -294,8 +361,12 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(Clause::COMMA_SPACE)
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
           end
         end
       end
@@ -316,8 +387,12 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(Clause::COMMA_SPACE)
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
           end
         end
       end
@@ -326,8 +401,12 @@ module Neo4j
         KEYWORD = 'USING'
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(" #{keyword} ")
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            " #{keyword} "
           end
         end
       end
@@ -358,8 +437,16 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(', ')
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            ', '
+          end
+
+          def clause_color
+            ANSI::GREEN
           end
         end
       end
@@ -370,6 +457,12 @@ module Neo4j
 
       class MergeClause < CreateClause
         KEYWORD = 'MERGE'
+
+        class << self
+          def clause_color
+            ANSI::MAGENTA
+          end
+        end
       end
 
       class DeleteClause < Clause
@@ -380,8 +473,16 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(Clause::COMMA_SPACE)
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+
+          def clause_color
+            ANSI::RED
           end
         end
       end
@@ -407,8 +508,12 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(Clause::COMMA_SPACE)
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
           end
         end
       end
@@ -418,19 +523,23 @@ module Neo4j
 
         def from_string(value)
           clause_id = "#{self.class.keyword_downcase}_#{value}"
-          @params[clause_id.to_sym] = value.to_i
+          add_param(clause_id, value.to_i)
           "{#{clause_id}}"
         end
 
         def from_integer(value)
           clause_id = "#{self.class.keyword_downcase}_#{value}"
-          @params[clause_id.to_sym] = value
+          add_param(clause_id, value)
           "{#{clause_id}}"
         end
 
+        def from_nilclass(value)
+          ''
+        end
+
         class << self
-          def clause_string(clauses)
-            clauses.last.value
+          def clause_strings(clauses)
+            [clauses.last.value]
           end
         end
       end
@@ -440,19 +549,19 @@ module Neo4j
 
         def from_string(value)
           clause_id = "#{self.class.keyword_downcase}_#{value}"
-          @params[clause_id.to_sym] = value.to_i
+          add_param(clause_id, value.to_i)
           "{#{clause_id}}"
         end
 
         def from_integer(value)
           clause_id = "#{self.class.keyword_downcase}_#{value}"
-          @params[clause_id.to_sym] = value
+          add_param(clause_id, value)
           "{#{clause_id}}"
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.last.value
+          def clause_strings(clauses)
+            [clauses.last.value]
           end
         end
       end
@@ -465,7 +574,7 @@ module Neo4j
           when String, Symbol then "#{key}:`#{value}`"
           when Hash
             if @options[:set_props]
-              @params["#{key}_set_props".freeze.to_sym] = value
+              add_param("#{key}_set_props", value)
               "#{key} = {#{key}_set_props}"
             else
               value.map { |k, v| key_value_string("#{key}.`#{k}`", v, ['setter'], true) }
@@ -478,8 +587,16 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(Clause::COMMA_SPACE)
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
+          end
+
+          def clause_color
+            ANSI::YELLOW
           end
         end
       end
@@ -518,8 +635,12 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(Clause::COMMA_SPACE)
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
           end
         end
       end
@@ -539,8 +660,12 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(' UNWIND ')
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            ' UNWIND '
           end
         end
       end
@@ -570,8 +695,12 @@ module Neo4j
         end
 
         class << self
-          def clause_string(clauses)
-            clauses.map!(&:value).join(Clause::COMMA_SPACE)
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            Clause::COMMA_SPACE
           end
         end
       end

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = '5.0.1'
+    VERSION = '5.1.0'
   end
 end

data/lib/neo4j-core.rb

@@ -9,7 +9,6 @@ require 'neo4j/property_validator'
 require 'neo4j/property_container'
 require 'neo4j-core/active_entity'
 require 'neo4j-core/helpers'
-require 'neo4j-core/cypher_translator'
 require 'neo4j-core/query_find_in_batches'
 require 'neo4j-core/query'
 
@@ -17,6 +16,7 @@ require 'neo4j/entity_equality'
 require 'neo4j/node'
 require 'neo4j/label'
 require 'neo4j/session'
+require 'neo4j/ansi'
 
 require 'neo4j/relationship'
 require 'neo4j/transaction'

data/lib/neo4j-embedded/embedded_session.rb

@@ -4,7 +4,6 @@ Neo4j::Session.register_db(:embedded_db) do |*args|
   Neo4j::Embedded::EmbeddedSession.new(*args)
 end
 
-
 module Neo4j
   module Embedded
     class EmbeddedSession < Neo4j::Session
@@ -17,16 +16,22 @@ module Neo4j
       def_delegator :@graph_db, :begin_tx
 
       def initialize(db_location, config = {})
+        @config          = config
         @db_location     = db_location
-        @auto_commit     = !!config[:auto_commit]
-        @properties_file = config[:properties_file]
-        if config[:properties_map]
-          props = config[:properties_map].each_with_object({}) { |(k, v), m| m[k.to_s.to_java] = v.to_s.to_java }
-          @properties_map = java.util.HashMap.new(props)
-        end
+        @auto_commit     = !!@config[:auto_commit]
+        @properties_file = @config[:properties_file]
         Neo4j::Session.register(self)
       end
 
+      def properties_map
+        return @properties_map if @properties_map
+
+        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
+
       def db_type
         :embedded_db
       end
@@ -137,9 +142,12 @@ module Neo4j
       # Remember that you should close the resource iterator.
       # @param [String] q the cypher query as a String
       # @return (see #query)
-      def _query(q, params = {})
-        @engine ||= Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-        @engine.execute(q, Neo4j::Core::HashWithIndifferentAccess.new(params))
+      def _query(query, params = {}, options = {})
+        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, HashWithIndifferentAccess.new(params))
+        end
       rescue StandardError => e
         raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
       end

data/lib/neo4j-embedded.rb

@@ -13,4 +13,4 @@ require 'neo4j-embedded/embedded_transaction'
 require 'neo4j-embedded/cypher_response'
 
 # TODO: replace this with https://github.com/intridea/hashie gem
-require 'neo4j-core/hash_with_indifferent_access'
+require 'active_support/hash_with_indifferent_access'

data/lib/neo4j-server/cypher_node.rb

@@ -2,7 +2,6 @@ module Neo4j
   module Server
     class CypherNode < Neo4j::Node
       include Neo4j::Server::Resource
-      include Neo4j::Core::CypherTranslator
       include Neo4j::Core::ActiveEntity
 
       def initialize(session, value)
@@ -113,8 +112,6 @@ module Neo4j
       end
 
       def set_label(*label_names)
-        q = match_start_query
-
         labels_to_add = label_names.map(&:to_sym).uniq
         labels_to_remove = labels - label_names
 
@@ -122,10 +119,15 @@ module Neo4j
         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?
+        query = _set_label_query(labels_to_add, labels_to_remove)
+        @session._query_or_fail(query, false) unless (labels_to_add + labels_to_remove).empty?
+      end
 
-        @session._query_or_fail(q, false) unless (labels_to_add + labels_to_remove).empty?
+      def _set_label_query(labels_to_add, labels_to_remove)
+        query = match_start_query
+        query = query.remove(n: labels_to_remove) unless labels_to_remove.empty?
+        query = query.set(n: labels_to_add) unless labels_to_add.empty?
+        query
       end
 
       # (see Neo4j::Node#del)

data/lib/neo4j-server/cypher_relationship.rb

@@ -2,7 +2,6 @@ module Neo4j
   module Server
     class CypherRelationship < Neo4j::Relationship
       include Neo4j::Server::Resource
-      include Neo4j::Core::CypherTranslator
       include Neo4j::Core::ActiveEntity
 
       def initialize(session, value)
@@ -93,10 +92,17 @@ module Neo4j
       # (see Neo4j::Relationship#update_props)
       def update_props(properties)
         return if properties.empty?
-        q = "#{match_start} SET " + properties.keys.map do |k|
-          "n.`#{k}`= #{escape_value(properties[k])}"
+
+        params = {}
+        q = "#{match_start} SET " + properties.keys.each_with_index.map do |k, _i|
+          param = k.to_s.tr_s('^a-zA-Z0-9', '_').gsub(/^_+|_+$/, '')
+          params[param] = properties[k]
+
+          "n.`#{k}`= {#{param}}"
         end.join(',')
-        @session._query_or_fail(q, false, neo_id: neo_id)
+
+        @session._query_or_fail(q, false, params.merge(neo_id: neo_id))
+
         properties
       end
 
@@ -127,7 +133,7 @@ module Neo4j
       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
+        id_or_url.is_a?(Integer) ? id_or_url : id_or_url.split('/').last.to_i
       end
     end
   end

data/lib/neo4j-server/cypher_response.rb

@@ -13,6 +13,7 @@ module Neo4j
         end
       end
 
+      class ConstraintViolationError < ResponseError; end
 
       class HashEnumeration
         include Enumerable
@@ -201,9 +202,15 @@ module Neo4j
         self
       end
 
+      CONSTRAINT_ERROR = 'Neo.ClientError.Schema.ConstraintViolation'
       def raise_error
         fail 'Tried to raise error without an error' unless @error
-        fail ResponseError.new(@error_msg, @error_status, @error_code)
+        error_class = constraint_error? ? ConstraintViolationError : ResponseError
+        fail error_class.new(@error_msg, @error_status, @error_code)
+      end
+
+      def constraint_error?
+        @error_code == CONSTRAINT_ERROR || @error_msg.include?('already exists with')
       end
 
       def raise_cypher_error
@@ -228,11 +235,7 @@ module Neo4j
 
         new(response, true).tap do |cr|
           body = response.body
-          if body[:errors].empty?
-            cr.set_data(body[:results].first)
-          else
-            cr.set_error(body[:errors].first)
-          end
+          body[:errors].empty? ? cr.set_data(body[:results].first) : cr.set_error(body[:errors].first)
         end
       end