activegraph 11.3.1 → 11.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1ae9faa69f9792692e849f1d3de64c0a22b8e5623302cde0b1e707bfb443bba
-  data.tar.gz: 57cb8e74aae28b60346bd7c908ed4e793df433c0722b3ab2322320d5a9bab217
+  metadata.gz: f068da2126bbed4301cf9fb15c34a708ef7f7a152afbfe42af5482237a041f0d
+  data.tar.gz: 0c87c4c2082a2e999ac8e0ff165e0cdbffe875f7f2eae407ea31f3f119d46a5f
 SHA512:
-  metadata.gz: c5de6bb15067a8c93a14be2dd8949d70d0edcbc1bdabcab2c0880e11dda13f9bfcbdddc51c82438d7cd1642fafb841cbe6b03ca714d1633f3c8b09396531eb0c
-  data.tar.gz: 976b9fa40c5056de62e7dc9fc3437c107adf13b09f5d1b07b660b79f92f74c9434c18114e4bab1c16e845f529e145c4b337e461cf77b5a4f40d5255a9619103f
+  metadata.gz: 5c12b0fc53c6bb04d661ec6c1669843e3c59d2ce00a9c7ea909d49b87ba7ef7b4c58ba2196d2c880c70da4ed727d14851fa27a15cf948125e91ee7670a23ff9d
+  data.tar.gz: e0dda99c677170338a7a470d00660fa20528e272452ee81a58722d055af969f0951e3344e0961e3b5ec49b6e0e316527dc0deab5f0ce01fe3dda0c029310ee01

data/CHANGELOG.md

@@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file.
 This file should follow the standards specified on [http://keepachangelog.com/]
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [11.4.0] 2023-02-12
+
+## Fixed
+
+- Added support for cypher UNION
+
 ## [11.3.1] 2023-02-12
 
 ## Fixed

data/lib/active_graph/core/query.rb

@@ -162,8 +162,8 @@ module ActiveGraph
       # DETACH DELETE clause
       # @return [Query]
 
-      METHODS = %w[start match optional_match call using where create create_unique merge set on_create_set on_match_set remove unwind delete detach_delete with with_distinct return order skip limit] # rubocop:disable Metrics/LineLength
-      BREAK_METHODS = %(with with_distinct call)
+      METHODS = %w[start match optional_match call using where create create_unique merge set on_create_set on_match_set remove unwind delete detach_delete with with_distinct return order skip limit union call_subquery_start call_subquery_end] # rubocop:disable Layout/LineLength
+      BREAK_METHODS = %w(with with_distinct call call_subquery_start call_subquery_end)
 
       CLAUSIFY_CLAUSE = proc { |method| const_get(method.to_s.split('_').map(&:capitalize).join + 'Clause') }
       CLAUSES = METHODS.map(&CLAUSIFY_CLAUSE)

data/lib/active_graph/core/query_clauses.rb

@@ -28,7 +28,7 @@ module ActiveGraph
         def value
           return @value if @value
 
-          [String, Symbol, Integer, Hash, NilClass].each do |arg_class|
+          [String, Symbol, Integer, Hash, NilClass, Array].each do |arg_class|
             from_method = "from_#{arg_class.name.downcase}"
             return @value = send(from_method, @arg) if @arg.is_a?(arg_class) && respond_to?(from_method)
           end
@@ -130,13 +130,15 @@ module ActiveGraph
           def to_cypher(clauses, pretty = false)
             string = clause_string(clauses, pretty)
 
-            final_keyword = if pretty
-                              "#{clause_color}#{keyword}#{ANSI::CLEAR}"
-                            else
-                              keyword
-                            end
+            "#{final_keyword(pretty)} #{string}" if !string.empty?
+          end
 
-            "#{final_keyword} #{string}" if !string.empty?
+          def final_keyword(pretty)
+            if pretty
+              "#{clause_color}#{keyword}#{ANSI::CLEAR}"
+            else
+              keyword
+            end
           end
 
           def clause_string(clauses, pretty)
@@ -256,6 +258,30 @@ module ActiveGraph
         end
       end
 
+      class UnionClause < Clause
+        KEYWORD = ''
+
+        def from_array(args)
+          "#{args[1]} RETURN #{args[0]} AS #{args.last}"
+        end
+
+        class << self
+          def from_args(args, params, options = {})
+            params.add_params(args[2])
+
+            [from_arg(args, params, options)]
+          end
+
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+
+          def clause_join
+            ' UNION '
+          end
+        end
+      end
+
       class WhereClause < Clause
         KEYWORD = 'WHERE'
 
@@ -349,6 +375,38 @@ module ActiveGraph
         end
       end
 
+      class CallSubqueryStartClause < Clause
+        KEYWORD = 'CALL {'
+
+        def from_nilclass(_value)
+          ' '
+        end
+
+        def from_string(value)
+          value
+        end
+
+        class << self
+          def to_cypher(clauses, pretty = false)
+            super || final_keyword(pretty)
+          end
+
+          def clause_strings(clauses)
+            clauses.map!(&:value)
+          end
+        end
+      end
+
+      class CallSubqueryEndClause < Clause
+        KEYWORD = '}'
+
+        class << self
+          def to_cypher(_clauses, pretty = false)
+            final_keyword(pretty)
+          end
+        end
+      end
+
       class MatchClause < Clause
         KEYWORD = 'MATCH'
 

data/lib/active_graph/node/query/query_proxy.rb

@@ -94,13 +94,25 @@ module ActiveGraph
         #
         #   student.lessons.query_as(:l).with('your cypher here...')
         def query_as(var, with_labels = true)
-          query_from_chain(chain, base_query(var, with_labels).params(@params), var)
-            .tap { |query| query.proxy_chain_level = _chain_level }
+          init_outer_query_var(var)
+          var_name = @outer_query_var || var
+          query_obj = if chain.first&.start_of_subquery? && !@association && !starting_query
+                        _query
+                      else
+                        base_query(var_name, with_labels).params(@params)
+                      end
+
+          query_from_chain(chain, query_obj, var_name).tap { |query| query.proxy_chain_level = _chain_level }
+        end
+
+        def init_outer_query_var(var)
+          chain.find(&:start_of_subquery?)&.tap { |link| @outer_query_var = link.subquery_var(var) }
         end
 
         def query_from_chain(chain, base_query, var)
           chain.inject(base_query) do |query, link|
             args = link.args(var, rel_var)
+            var = link.update_outer_query_var(var)
 
             args.is_a?(Array) ? query.send(link.clause, *args) : query.send(link.clause, args)
           end
@@ -143,11 +155,16 @@ module ActiveGraph
           @model.current_scope = previous
         end
 
-        METHODS = %w(where where_not rel_where rel_where_not rel_order order skip limit)
+        METHODS = %w(where where_not rel_where rel_where_not rel_order order skip limit union)
 
         METHODS.each do |method|
           define_method(method) { |*args| build_deeper_query_proxy(method.to_sym, args) }
         end
+
+        def union(*args)
+          hash_args = {proxy: self, subquery_parts: args, first_clause: @chain.blank?}
+          build_deeper_query_proxy(:union, hash_args)
+        end
         # Since there are rel_where and rel_order methods, it seems only natural for there to be node_where and node_order
         alias node_where where
         alias node_order order

data/lib/active_graph/node/query/query_proxy_link.rb

@@ -3,6 +3,7 @@ module ActiveGraph
     module Query
       class QueryProxy
         class Link
+          OUTER_SUBQUERY_PREFIX = 'outer_'.freeze
           attr_reader :clause
 
           def initialize(clause, arg, args = [])
@@ -19,6 +20,26 @@ module ActiveGraph
             end
           end
 
+          def start_of_subquery?
+            clause == :call_subquery_start
+          end
+
+          def end_of_subquery?
+            clause == :call_subquery_end
+          end
+
+          def subquery_var(original_var)
+            return unless start_of_subquery?
+
+            "#{OUTER_SUBQUERY_PREFIX}#{original_var}"
+          end
+
+          def update_outer_query_var(original_var)
+            return original_var unless end_of_subquery?
+
+            original_var.delete_prefix(OUTER_SUBQUERY_PREFIX)
+          end
+
           class << self
             def for_clause(clause, arg, model, *args)
               method_to_call = "for_#{clause}_clause"
@@ -27,6 +48,75 @@ module ActiveGraph
               send(method_to_call, arg, model, *args)
             end
 
+            def for_union_clause(arg, model, *args)
+              links = []
+              links << new(:call_subquery_start, nil, *args)
+              arg[:subquery_parts].each_with_index do |subquery_part, loop_index|
+                links << init_union_link(arg[:proxy], model, subquery_part, loop_index, args)
+              end
+              links << new(:call_subquery_end, nil, *args)
+              links << post_subquery_with_clause(arg[:first_clause], args)
+            end
+
+            def post_subquery_with_clause(first_clause, args)
+              clause_arg_lambda = lambda do |v, _|
+                if first_clause
+                  [v]
+                else
+                  [v, "#{OUTER_SUBQUERY_PREFIX}#{v}"]
+                end
+              end
+
+              new(:with, clause_arg_lambda, *args)
+            end
+
+            def init_union_link(proxy, model, subquery_part, loop_index, args)
+              union_proc = if subquery_proxy_part = subquery_part.call rescue nil # rubocop:disable Style/RescueModifier
+                             independent_union_subquery_proc(subquery_proxy_part, loop_index)
+                           else
+                             continuation_union_subquery_proc(proxy, model, subquery_part, loop_index)
+                           end
+              new(:union, union_proc, *args)
+            end
+
+            def independent_union_subquery_proc(proxy, loop_index)
+              proxy_params = proxy.query.parameters
+              proxy_cypher = proxy.to_cypher
+              subquery_identity = proxy.identity
+              uniq_param_generator = uniq_param_generator_lambda
+
+              lambda do |identity, _|
+                proxy_params = uniq_param_generator.call(proxy_params, proxy_cypher, identity, loop_index) if proxy_params.present?
+                [subquery_identity, proxy_cypher, proxy_params, identity.delete_prefix(OUTER_SUBQUERY_PREFIX)]
+              end
+            end
+
+            def continuation_union_subquery_proc(outer_proxy, model, subquery_part, loop_index) # rubocop:disable Metrics/AbcSize
+              lambda do |identity, _|
+                proxy = outer_proxy.as(identity)
+                proxy_with_clause = proxy.query.with(proxy.identity).with(proxy.identity).proxy_as(model, proxy.identity)
+                complete_query = proxy_with_clause.instance_exec(&subquery_part) || proxy_with_clause
+                subquery_cypher = complete_query.to_cypher
+                subquery_cypher = subquery_cypher.delete_prefix(proxy.to_cypher) if proxy.send(:chain).present? || proxy.starting_query
+                subquery_parameters = (complete_query.query.parameters.to_a - proxy.query.parameters.to_a).to_h
+
+                subquery_parameters = uniq_param_generator_lambda.call(subquery_parameters, subquery_cypher, identity, loop_index) if subquery_parameters.present?
+                [complete_query.identity, subquery_cypher, subquery_parameters] + [identity.delete_prefix(OUTER_SUBQUERY_PREFIX)]
+              end
+            end
+
+            def uniq_param_generator_lambda
+              lambda do |proxy_params, proxy_cypher, identity, counter|
+                prefix = "#{identity}_UNION#{counter}_"
+                proxy_params.each_with_object({}) do |(param_name, param_val), new_params|
+                  new_params_key = "#{prefix}#{param_name}".to_sym
+                  new_params[new_params_key] = param_val
+                  proxy_cypher.gsub!(/\$#{param_name}(?=([^`'"]|'(\\.|[^'])*'|"(\\.|[^"])*"|`(\\.|[^`])*`)*\z)/, "$#{new_params_key}")
+                  new_params
+                end
+              end
+            end
+
             def for_where_clause(arg, model, *args)
               node_num = 1
               result = []
@@ -104,6 +194,8 @@ module ActiveGraph
                 [for_arg(model, clause, args[0], *args[1..-1])]
               elsif [:rel_where, :rel_where_not].include?(clause)
                 args.map { |arg| for_arg(model, clause, arg, association) }
+              elsif clause == :union
+                [for_arg(model, clause, args)]
               else
                 args.map { |arg| for_arg(model, clause, arg) }
               end

data/lib/active_graph/version.rb

@@ -1,3 +1,3 @@
 module ActiveGraph
-  VERSION = '11.3.1'
+  VERSION = '11.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activegraph
 version: !ruby/object:Gem::Version
-  version: 11.3.1
+  version: 11.4.0
 platform: ruby
 authors:
 - Andreas Ronge, Brian Underwood, Chris Grigg, Heinrich Klobuczek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-13 00:00:00.000000000 Z
+date: 2023-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -444,7 +444,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A graph database for Ruby