neo4j-core 5.1.14 → 6.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a86ca1a3a458ea6ecb32b39dc5e3b3bf1dd4a0b0
-  data.tar.gz: 69150678225a39745ade9246252a02e39e7e1192
+  metadata.gz: d2e549ac9b629bd47019215c2457d66c6b355a2f
+  data.tar.gz: 717fb2cc5363c0a7a9726ae4d686e504634d7310
 SHA512:
-  metadata.gz: a250f017521e2ccdccc62eca1735eba6a46ac4f75194718129274c91ab2dfecd280c5cd3610382af8ca3e733459816158dd5e395742d87f691afe0c568255fd0
-  data.tar.gz: 569162a558aaa56a76cb922287e5be484238f0f6c94524331ef1a3852117bf45b125edbc07115ec10d43af69af40e411255c42e90f4ce51edd12f18e77a6a9cb
+  metadata.gz: 14df3ab1fb20692a66036201039f66861b38fc340b3c63c7051d977b2a718c09a9daa3b5d717920ddaa5228089c899f8cf9f611c2e11e6cda992af6fc6d1838a
+  data.tar.gz: ece61afe7b0c8c21db72322bfe5143ccc9ab7ef84dc6b01f7b7416b7978b28a082b0edb7dbc5587ed390cc9aa2da3555f4aad1fa11e96fb28e76e5de9d90e7c4

data/lib/neo4j-core.rb

@@ -26,7 +26,7 @@ require 'neo4j-server'
 require 'rake'
 require 'neo4j/rake_tasks'
 
-if RUBY_PLATFORM == 'java'
+if RUBY_PLATFORM == 'java' && !ENV['WITHOUT_NEO4J_EMBEDDED']
   require 'neo4j-embedded'
 else
   # just for the tests

data/lib/neo4j-core/helpers.rb

@@ -13,5 +13,11 @@ module Neo4j
         end
       end
     end
+
+    module Config
+      def self.using_new_session?
+        ENV.key?('NEW_NEO4J_SESSIONS')
+      end
+    end
   end
 end

data/lib/neo4j-core/query.rb

@@ -18,16 +18,61 @@ module Neo4j
 
       attr_accessor :clauses
 
+      class Parameters
+        def initialize(hash = nil)
+          @parameters = (hash || {})
+        end
+
+        def to_hash
+          @parameters
+        end
+
+        def copy
+          self.class.new(@parameters.dup)
+        end
+
+        def add_param(key, value)
+          free_param_key(key).tap do |k|
+            @parameters[k.freeze] = value
+          end
+        end
+
+        def remove_param(key)
+          @parameters.delete(key.to_sym)
+        end
+
+        def add_params(params)
+          params.map do |key, value|
+            add_param(key, value)
+          end
+        end
+
+        private
+
+        def free_param_key(key)
+          k = key.to_sym
+
+          return k if !@parameters.key?(k)
+
+          i = 2
+          i += 1 while @parameters.key?("#{key}#{i}".to_sym)
+
+          "#{key}#{i}".to_sym
+        end
+      end
+
       class << self
         attr_accessor :pretty_cypher
       end
 
       def initialize(options = {})
-        @session = options[:session] || Neo4j::Session.current
+        @session = options[:session]
+        @session = Neo4j::Session.current if !options.key?(:session)
 
         @options = options
         @clauses = []
         @_params = {}
+        @params = Parameters.new
       end
 
       def inspect
@@ -113,9 +158,7 @@ module Neo4j
       METHODS = %w(start match optional_match using where create create_unique merge set on_create_set on_match_set remove unwind delete with return order skip limit)
       BREAK_METHODS = %(with)
 
-      CLAUSIFY_CLAUSE = proc do |method|
-        const_get(method.to_s.split('_').map(&:capitalize).join + 'Clause')
-      end
+      CLAUSIFY_CLAUSE = proc { |method| const_get(method.to_s.split('_').map(&:capitalize).join + 'Clause') }
 
       CLAUSES = METHODS.map(&CLAUSIFY_CLAUSE)
 
@@ -171,9 +214,7 @@ module Neo4j
       #   Query.new.match('(q: Person {id: {id}})').params(id: 12)
       #
       def params(args)
-        @_params = @_params.merge(args)
-
-        self
+        copy.tap { |new_query| new_query.instance_variable_get('@params').add_params(args) }
       end
 
       def unwrapped
@@ -187,25 +228,19 @@ module Neo4j
 
       def response
         return @response if @response
+
         cypher = to_cypher
         pretty_cypher = to_cypher(pretty: true) if self.class.pretty_cypher
 
         @response = @session._query(cypher, merge_params, context: @options[:context], pretty_cypher: pretty_cypher)
 
-        if !response.respond_to?(:error?) || !response.error?
-          response
-        else
-          response.raise_cypher_error
-        end
+        (!response.respond_to?(:error?) || !response.error?) ? response : response.raise_cypher_error
       end
 
       def match_nodes(hash, optional_match = false)
         hash.inject(self) do |query, (variable, node_object)|
-          neo_id = if node_object.respond_to?(:neo_id)
-                     node_object.neo_id
-                   else
-                     node_object
-                   end
+          neo_id = (node_object.respond_to?(:neo_id) ? node_object.neo_id : node_object)
+
           match_method = optional_match ? :optional_match : :match
           query.send(match_method, variable).where(variable => {neo_id: neo_id})
         end
@@ -267,11 +302,7 @@ module Neo4j
           column = columns[0]
           query.map { |row| row[column] }
         else
-          query.map do |row|
-            columns.map do |column|
-              row[column]
-            end
-          end
+          query.map { |row| columns.map { |column| row[column] } }
         end
       end
 
@@ -290,20 +321,39 @@ module Neo4j
       EMPTY = ' '
       NEWLINE = "\n"
       def to_cypher(options = {})
-        cypher_string = PartitionedClauses.new(@clauses).map do |clauses|
+        join_string = options[:pretty] ? NEWLINE : EMPTY
+
+        cypher_string = partitioned_clauses.map do |clauses|
           clauses_by_class = clauses.group_by(&:class)
 
           cypher_parts = CLAUSES.map do |clause_class|
-            clause_class.to_cypher(clauses, options) if clauses = clauses_by_class[clause_class]
-          end
+            clause_class.to_cypher(clauses, options[:pretty]) if clauses = clauses_by_class[clause_class]
+          end.compact
 
-          cypher_parts.compact!
-          cypher_parts.join(options[:pretty] ? NEWLINE : EMPTY).tap(&:strip!)
-        end.join(options[:pretty] ? NEWLINE : EMPTY)
+          cypher_parts.join(join_string).tap(&:strip!)
+        end.join(join_string)
 
         cypher_string = "CYPHER #{@options[:parser]} #{cypher_string}" if @options[:parser]
         cypher_string.tap(&:strip!)
       end
+      alias_method :cypher, :to_cypher
+
+      def pretty_cypher
+        to_cypher(pretty: true)
+      end
+
+      def context
+        @options[:context]
+      end
+
+      def parameters
+        to_cypher
+        merge_params
+      end
+
+      def partitioned_clauses
+        @partitioned_clauses ||= PartitionedClauses.new(@clauses)
+      end
 
       def print_cypher
         puts to_cypher(pretty: true).gsub(/\e[^m]+m/, '')
@@ -332,20 +382,18 @@ module Neo4j
         end.params(other._params)
       end
 
-      MEMOIZED_INSTANCE_VARIABLES = [:response, :merge_params]
       def copy
         dup.tap do |query|
-          MEMOIZED_INSTANCE_VARIABLES.each do |var|
-            query.instance_variable_set("@#{var}", nil)
-          end
+          to_cypher
+          query.instance_variable_set('@params', @params.copy)
+          query.instance_variable_set('@partitioned_clauses', nil)
+          query.instance_variable_set('@response', nil)
         end
       end
 
       def clause?(method)
         clause_class = DEFINED_CLAUSES[method] || CLAUSIFY_CLAUSE.call(method)
-        clauses.any? do |clause|
-          clause.is_a?(clause_class)
-        end
+        clauses.any? { |clause| clause.is_a?(clause_class) }
       end
 
       protected
@@ -357,9 +405,7 @@ module Neo4j
       end
 
       def remove_clause_class(clause_class)
-        @clauses = @clauses.reject do |clause|
-          clause.is_a?(clause_class)
-        end
+        @clauses = @clauses.reject { |clause| clause.is_a?(clause_class) }
       end
 
       private
@@ -367,7 +413,7 @@ module Neo4j
       def build_deeper_query(clause_class, args = {}, options = {})
         copy.tap do |new_query|
           new_query.add_clauses [nil] if [nil, WithClause].include?(clause_class)
-          new_query.add_clauses clause_class.from_args(args, options) if clause_class
+          new_query.add_clauses clause_class.from_args(args, new_query.instance_variable_get('@params'), options) if clause_class
         end
       end
 
@@ -430,9 +476,11 @@ module Neo4j
         end
       end
 
+      # SHOULD BE DEPRECATED
       def merge_params
         @clauses.compact!
-        @merge_params ||= @clauses.inject(@_params) { |params, clause| params.merge!(clause.params) }
+        @merge_params ||= @clauses.inject(@params.to_hash) { |params, clause| params.merge!(clause.params) }
+        @params.to_hash
       end
     end
   end

data/lib/neo4j-core/query_clauses.rb

@@ -9,25 +9,27 @@ module Neo4j
         end
       end
 
-
       class Clause
         UNDERSCORE = '_'
         COMMA_SPACE = ', '
         AND = ' AND '
 
         attr_accessor :params, :arg
-        attr_reader :options
+        attr_reader :options, :param_vars_added
 
-        def initialize(arg, options = {})
+        def initialize(arg, params, options = {})
           @arg = arg
           @options = options
-          @params = {}
+          @params = params
+          @param_vars_added = []
         end
 
         def value
+          return @value if @value
+
           [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)
+            return @value = send(from_method, @arg) if @arg.is_a?(arg_class) && self.respond_to?(from_method)
           end
 
           fail ArgError
@@ -124,21 +126,19 @@ module Neo4j
             keyword.downcase
           end
 
-          def from_args(args, options = {})
+          def from_args(args, params, options = {})
             args.flatten!
-            args.map { |arg| from_arg(arg, options) }.tap(&:compact!)
+            args.map { |arg| from_arg(arg, params, options) }.tap(&:compact!)
           end
 
-          def from_arg(arg, options = {})
-            new(arg, options) if !arg.respond_to?(:empty?) || !arg.empty?
+          def from_arg(arg, params, options = {})
+            new(arg, params, options) if !arg.respond_to?(:empty?) || !arg.empty?
           end
 
-          def to_cypher(clauses, options = {})
-            @question_mark_param_index = 1
-
-            string = clause_string(clauses, options)
+          def to_cypher(clauses, pretty = false)
+            string = clause_string(clauses, pretty)
 
-            final_keyword = if options[:pretty]
+            final_keyword = if pretty
                               "#{clause_color}#{keyword}#{ANSI::CLEAR}"
                             else
                               keyword
@@ -147,11 +147,11 @@ module Neo4j
             "#{final_keyword} #{string}" if string.size > 0
           end
 
-          def clause_string(clauses, options = {})
-            join_string = clause_join + (options[:pretty] ? "\n  " : '')
+          def clause_string(clauses, pretty)
+            join_string = clause_join + (pretty ? "\n  " : '')
 
             strings = clause_strings(clauses)
-            string = ((options[:pretty] && strings.size > 1) ? "\n  " : '')
+            string = ((pretty && strings.size > 1) ? "\n  " : '')
             string + strings.join(join_string).strip
           end
 
@@ -169,6 +169,16 @@ module Neo4j
           key.gsub!(/^_+|_+$/, '')
         end
 
+        def add_param(key, value)
+          @param_vars_added << key
+          @params.add_param(key, value)
+        end
+
+        def add_params(keys_and_values)
+          @param_vars_added += keys_and_values.keys
+          @params.add_params(keys_and_values)
+        end
+
         private
 
         def key_value_string(key, value, previous_keys = [], is_set = false)
@@ -176,14 +186,14 @@ module Neo4j
           self.class.paramaterize_key!(param)
 
           if value.is_a?(Range)
-            add_params("#{param}_range_min" => value.min, "#{param}_range_max" => value.max)
+            min_param, max_param = add_params("#{param}_range_min" => value.min, "#{param}_range_max" => value.max)
 
-            "#{key} IN RANGE({#{param}_range_min}, {#{param}_range_max})"
+            "#{key} IN RANGE({#{min_param}}, {#{max_param}})"
           else
             value = value.first if array_value?(value, is_set) && value.size == 1
             operator = array_value?(value, is_set) ? 'IN' : '='
 
-            add_param(param, value)
+            param = add_param(param, value)
 
             "#{key} #{operator} {#{param}}"
           end
@@ -193,16 +203,6 @@ module Neo4j
           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
-
         def format_label(label_arg)
           if label_arg.is_a?(Array)
             return label_arg.map { |arg| format_label(arg) }.join
@@ -225,7 +225,7 @@ module Neo4j
               "#{key}: #{value}"
             else
               param_key = "#{prefix}#{key}".gsub('::', '_')
-              add_param(param_key, value)
+              param_key = add_param(param_key, value)
               "#{key}: {#{param_key}}"
             end
           end.join(Clause::COMMA_SPACE)
@@ -310,7 +310,7 @@ module Neo4j
           param = [previous_keys + [key]].join(UNDERSCORE)
           self.class.paramaterize_key!(param)
 
-          add_params(param => pattern)
+          param = add_param(param, pattern)
 
           "#{key} =~ {#{param}}"
         end
@@ -318,36 +318,22 @@ module Neo4j
         class << self
           ARG_HAS_QUESTION_MARK_REGEX = /(^|\(|\s)\?(\s|\)|$)/
 
-          def from_args(args, options = {})
-            query_string, params = args
-
-            if query_string.is_a?(String) && (query_string.match(ARG_HAS_QUESTION_MARK_REGEX) || params.is_a?(Hash))
-              if !params.is_a?(Hash)
-                question_mark_params_param = self.question_mark_params_param
-                query_string = query_string.gsub(ARG_HAS_QUESTION_MARK_REGEX, "\\1{#{question_mark_params_param}}\\2")
-                params = {question_mark_params_param.to_sym => params}
-              end
+          def from_args(args, params, options = {})
+            query_string, params_arg = args
 
-              clause = from_arg(query_string, options).tap do |clause|
-                clause.params.merge!(params)
+            if query_string.is_a?(String) && (query_string.match(ARG_HAS_QUESTION_MARK_REGEX) || params_arg.is_a?(Hash))
+              if params_arg.is_a?(Hash)
+                params.add_params(params_arg)
+              else
+                param_var = params.add_params(question_mark_param: params_arg)[0]
+                query_string = query_string.gsub(ARG_HAS_QUESTION_MARK_REGEX, "\\1{#{param_var}}\\2")
               end
 
-              [clause]
+              [from_arg(query_string, params, options)]
             else
               super
             end
           end
-
-          def question_mark_params_param
-            "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
 
@@ -464,6 +450,10 @@ module Neo4j
           def clause_color
             ANSI::MAGENTA
           end
+
+          def clause_join
+            ' MERGE '
+          end
         end
       end
 
@@ -524,15 +514,13 @@ module Neo4j
         KEYWORD = 'LIMIT'
 
         def from_string(value)
-          clause_id = "#{self.class.keyword_downcase}_#{value}"
-          add_param(clause_id, value.to_i)
-          "{#{clause_id}}"
+          param_var = "#{self.class.keyword_downcase}_#{value}"
+          param_var = add_param(param_var, value.to_i)
+          "{#{param_var}}"
         end
 
         def from_integer(value)
-          clause_id = "#{self.class.keyword_downcase}_#{value}"
-          add_param(clause_id, value)
-          "{#{clause_id}}"
+          from_string(value)
         end
 
         def from_nilclass(value)
@@ -541,7 +529,13 @@ module Neo4j
 
         class << self
           def clause_strings(clauses)
-            [clauses.last.value]
+            result_clause = clauses.last
+
+            clauses[0..-2].map(&:param_vars_added).flatten.grep(/^limit_\d+$/).each do |var|
+              result_clause.params.remove_param(var)
+            end
+
+            [result_clause.value]
           end
         end
       end
@@ -551,19 +545,25 @@ module Neo4j
 
         def from_string(value)
           clause_id = "#{self.class.keyword_downcase}_#{value}"
-          add_param(clause_id, value.to_i)
+          clause_id = add_param(clause_id, value.to_i)
           "{#{clause_id}}"
         end
 
         def from_integer(value)
           clause_id = "#{self.class.keyword_downcase}_#{value}"
-          add_param(clause_id, value)
+          clause_id = add_param(clause_id, value)
           "{#{clause_id}}"
         end
 
         class << self
           def clause_strings(clauses)
-            [clauses.last.value]
+            result_clause = clauses.last
+
+            clauses[0..-2].map(&:param_vars_added).flatten.grep(/^skip_\d+$/).each do |var|
+              result_clause.params.remove_param(var)
+            end
+
+            [result_clause.value]
           end
         end
       end
@@ -576,8 +576,8 @@ module Neo4j
           when String, Symbol then "#{key}:`#{value}`"
           when Hash
             if @options[:set_props]
-              add_param("#{key}_set_props", value)
-              "#{key} = {#{key}_set_props}"
+              param = add_param("#{key}_set_props", value)
+              "#{key} = {#{param}}"
             else
               value.map { |k, v| key_value_string("#{key}.`#{k}`", v, ['setter'], true) }
             end