neo4j-core 4.0.7 → 5.0.0.rc.1

data/lib/neo4j-core/query.rb

@@ -14,6 +14,9 @@ module Neo4j
     class Query
       include Neo4j::Core::QueryClauses
       include Neo4j::Core::QueryFindInBatches
+      DEFINED_CLAUSES = {}
+
+      attr_accessor :clauses
 
       def initialize(options = {})
         @session = options[:session] || Neo4j::Session.current
@@ -99,17 +102,24 @@ module Neo4j
       # DELETE clause
       # @return [Query]
 
-      METHODS = %w(with start match optional_match using where set create create_unique merge on_create_set on_match_set remove unwind delete return order skip limit)
+      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
 
-      CLAUSES = METHODS.map { |method| const_get(method.split('_').map(&:capitalize).join + 'Clause') }
+      CLAUSES = METHODS.map(&CLAUSIFY_CLAUSE)
 
       METHODS.each_with_index do |clause, i|
         clause_class = CLAUSES[i]
 
-        module_eval(%{
-          def #{clause}(*args)
-            build_deeper_query(#{clause_class}, args)
-          end}, __FILE__, __LINE__)
+        DEFINED_CLAUSES[clause.to_sym] = clause_class
+        define_method(clause) do |*args|
+          build_deeper_query(clause_class, args).ergo do |result|
+            BREAK_METHODS.include?(clause) ? result.break : result
+          end
+        end
       end
 
       alias_method :offset, :skip
@@ -152,6 +162,15 @@ module Neo4j
         self
       end
 
+      def unwrapped
+        @_unwrapped_obj = true
+        self
+      end
+
+      def unwrapped?
+        !!@_unwrapped_obj
+      end
+
       def response
         return @response if @response
         cypher = to_cypher
@@ -167,12 +186,18 @@ module Neo4j
 
       include Enumerable
 
+      def count(var = nil)
+        v = var.nil? ? '*' : var
+        pluck("count(#{v})").first
+      end
+
       def each
         response = self.response
         if response.is_a?(Neo4j::Server::CypherResponse)
+          response.unwrapped! if unwrapped?
           response.to_node_enumeration
         else
-          Neo4j::Embedded::ResultWrapper.new(response, to_cypher)
+          Neo4j::Embedded::ResultWrapper.new(response, to_cypher, unwrapped?)
         end.each { |object| yield object }
       end
 
@@ -201,12 +226,12 @@ module Neo4j
       #    Query.new.match(n: :Person).return(p: :name}.pluck('p, DISTINCT p.name') # => Array of [node, name] pairs
       #
       def pluck(*columns)
+        fail ArgumentError, 'No columns specified for Query#pluck' if columns.size.zero?
+
         query = return_query(columns)
         columns = query.response.columns
 
         case columns.size
-        when 0
-          fail ArgumentError, 'No columns specified for Query#pluck'
         when 1
           column = columns[0]
           query.map { |row| row[column] }
@@ -223,15 +248,7 @@ module Neo4j
         query = copy
         query.remove_clause_class(ReturnClause)
 
-        columns = columns.map do |column_definition|
-          if column_definition.is_a?(Hash)
-            column_definition.map { |k, v| "#{k}.#{v}" }
-          else
-            column_definition
-          end
-        end.flatten.map(&:to_sym)
-
-        query.return(columns)
+        query.return(*columns)
       end
 
       # Returns a CYPHER query string from the object query representation
@@ -239,22 +256,21 @@ module Neo4j
       #    Query.new.match(p: :Person).where(p: {age: 30})  # => "MATCH (p:Person) WHERE p.age = 30
       #
       # @return [String] Resulting cypher query string
+      EMPTY = ' '
       def to_cypher
-        cypher_string = partitioned_clauses.map do |clauses|
+        cypher_string = PartitionedClauses.new(@clauses).map do |clauses|
           clauses_by_class = clauses.group_by(&:class)
 
           cypher_parts = CLAUSES.map do |clause_class|
-            clauses = clauses_by_class[clause_class]
-
-            clause_class.to_cypher(clauses) if clauses
+            clause_class.to_cypher(clauses) if clauses = clauses_by_class[clause_class]
           end
 
-          cypher_string = cypher_parts.compact.join(' ')
-          cypher_string.strip
-        end.join ' '
+          cypher_parts.compact!
+          cypher_parts.join(EMPTY).tap(&:strip!)
+        end.join EMPTY
 
         cypher_string = "CYPHER #{@options[:parser]} #{cypher_string}" if @options[:parser]
-        cypher_string.strip
+        cypher_string.tap(&:strip!)
       end
 
       # Returns a CYPHER query specifying the union of the callee object's query and the argument's query
@@ -289,9 +305,16 @@ module Neo4j
         end
       end
 
+      def clause?(method)
+        clause_class = DEFINED_CLAUSES[method] || CLAUSIFY_CLAUSE.call(method)
+        clauses.any? do |clause|
+          clause.is_a?(clause_class)
+        end
+      end
+
       protected
 
-      attr_accessor :session, :options, :clauses, :_params
+      attr_accessor :session, :options, :_params
 
       def add_clauses(clauses)
         @clauses += clauses
@@ -312,35 +335,68 @@ module Neo4j
         end
       end
 
-      def break_deeper_query
-        copy.tap do |new_query|
-          new_query.add_clauses [nil]
+      class PartitionedClauses
+        def initialize(clauses)
+          @clauses = clauses
+          @partitioning = [[]]
         end
-      end
 
-      def partitioned_clauses
-        partitioning = [[]]
+        include Enumerable
+
+        def each
+          generate_partitioning!
+
+          @partitioning.each { |partition| yield partition }
+        end
 
-        @clauses.each do |clause|
-          if clause.nil? && partitioning.last != []
-            partitioning << []
-          else
-            partitioning.last << clause
+        def generate_partitioning!
+          @partitioning = [[]]
+
+          @clauses.each do |clause|
+            if clause.nil? && !fresh_partition?
+              @partitioning << []
+            elsif clause_is_order_or_limit_directly_following_with_or_order?(clause)
+              second_to_last << clause
+            elsif clause_is_with_following_order_or_limit?(clause)
+              second_to_last << clause
+              second_to_last.sort_by! { |c| c.is_a?(::Neo4j::Core::QueryClauses::OrderClause) ? 1 : 0 }
+            else
+              @partitioning.last << clause
+            end
           end
         end
 
-        partitioning
-      end
+        private
 
-      def merge_params
-        @merge_params ||= @clauses.compact.inject(@_params) { |params, clause| params.merge(clause.params) }
-      end
+        def fresh_partition?
+          @partitioning.last == []
+        end
 
-      def sanitize_params(params)
-        passthrough_classes = [String, Numeric, Array, Regexp]
-        params.each do |key, value|
-          params[key] = value.to_s if not passthrough_classes.any? { |klass| value.is_a?(klass) }
+        def second_to_last
+          @partitioning[-2]
         end
+
+        def clause_is_order_or_limit_directly_following_with_or_order?(clause)
+          self.class.clause_is_order_or_limit?(clause) &&
+            @partitioning[-2] &&
+            (@partitioning[-2].last.is_a?(::Neo4j::Core::QueryClauses::WithClause) ||
+              @partitioning[-2].last.is_a?(::Neo4j::Core::QueryClauses::OrderClause))
+        end
+
+        def clause_is_with_following_order_or_limit?(clause)
+          clause.is_a?(::Neo4j::Core::QueryClauses::WithClause) &&
+            @partitioning[-2] && @partitioning[-2].any? { |c| self.class.clause_is_order_or_limit?(c) }
+        end
+
+        def self.clause_is_order_or_limit?(clause)
+          clause.is_a?(::Neo4j::Core::QueryClauses::OrderClause) ||
+            clause.is_a?(::Neo4j::Core::QueryClauses::LimitClause)
+        end
+      end
+
+      def merge_params
+        @clauses.compact!
+        @merge_params ||= @clauses.inject(@_params) { |params, clause| params.merge!(clause.params) }
       end
     end
   end