cypher-dsl 0.1.0.alpha.1 → 0.1.0.alpha.3

data/lib/cypher_dsl/renderer/name_resolver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  class Renderer
+    # Resolves symbolic names, aliases and parameter names while rendering.
+    # The base strategy keeps the given names and invents `hint001`-style names
+    # for elements that were referenced without ever being named.
+    class NameResolver
+      def initialize
+        @context_names = {}.compare_by_identity
+      end
+
+      def resolve(symbolic_name, in_entity: false) # rubocop:disable Lint/UnusedMethodArgument
+        context_name(symbolic_name)
+      end
+
+      def resolve_alias(aliased, define: false, in_last_return: false) # rubocop:disable Lint/UnusedMethodArgument
+        context_name(aliased.alias_name)
+      end
+
+      def resolve_parameter(parameter) = parameter.name
+
+      def enter_scope(imports); end
+      def leave_scope(exports); end
+
+      private
+
+      def context_name(symbolic_name)
+        return symbolic_name.value if symbolic_name.resolved?
+
+        @context_names[symbolic_name] ||= "#{symbolic_name.hint}#{format('%03d', @context_names.size + 1)}"
+      end
+    end
+  end
+end

data/lib/cypher_dsl/renderer/visitor/conditions.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  class Renderer
+    class Visitor
+      # Rendering of comparisons and compound conditions.
+      module Conditions
+        private
+
+        def render_comparison(comparison)
+          left = render_operand(comparison.left)
+          return "#{left} #{comparison.operator}" if comparison.unary?
+
+          "#{left} #{comparison.operator} #{render_operand(comparison.right)}"
+        end
+
+        # A comparison nested inside another comparison is parenthesised: `(1 > 2) = true`.
+        def render_operand(expression)
+          rendered = render_expression(expression)
+          expression.is_a?(Comparison) ? "(#{rendered})" : rendered
+        end
+
+        # `exists(n.prop)` on Neo4j 4, `n.prop IS NOT NULL` afterwards.
+        def render_property_exists(condition, negated: false)
+          property = render_expression(condition.property)
+          return "exists(#{property})" if @configuration.legacy_functions?
+
+          "#{property} IS #{'NOT ' unless negated}NULL"
+        end
+
+        # Pretty printed, each further operand starts an indented line: `(a\n  AND b)`.
+        def render_compound_condition(condition)
+          if condition.negation?
+            negated = condition.conditions.first
+            if negated.is_a?(PropertyExistsCondition) && !@configuration.legacy_functions?
+              return render_property_exists(negated, negated: true)
+            end
+
+            rendered = render_expression(negated)
+            return negated.is_a?(RelationshipPatternCondition) ? "NOT #{rendered}" : "NOT (#{rendered})"
+          end
+
+          operands = nested { condition.conditions.map { |inner| render_compound_operand(inner) } }
+          "(#{operands.join("#{break_line(@level + 1)}#{condition.operator} ")})"
+        end
+
+        # A raw operand is parenthesised unless it already is one group, so that
+        # `Cypher.raw('a OR b').as_condition.and(c)` keeps its precedence. (Ruby addition; the
+        # Java renderer trusts raw text.)
+        def render_compound_operand(condition)
+          rendered = render_expression(condition)
+          raw_condition?(condition) && !parenthesised?(rendered) ? "(#{rendered})" : rendered
+        end
+
+        def raw_condition?(condition)
+          condition.is_a?(ExpressionCondition) && condition.expression.is_a?(RawExpression)
+        end
+
+        # True when the text is one parenthesised group: `(a OR b)` but not `(a) OR (b)`.
+        def parenthesised?(text)
+          return false unless text.start_with?('(') && text.end_with?(')')
+
+          depth = 0
+          text.each_char.with_index do |char, index|
+            depth += 1 if char == '('
+            depth -= 1 if char == ')'
+            return false if depth.zero? && index < text.size - 1
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/cypher_dsl/renderer/visitor/expressions.rb

@@ -17,7 +17,7 @@ module CypherDSL
           when Asterisk then '*'
           when AliasedExpression then render_aliased_reference(expression)
           when NamedPath then render_expression(expression.symbolic_name)
-          when RawExpression then expression.content
+          when RawExpression then render_raw(expression)
           when CollectExpression
             block('COLLECT {', '}') { render_subquery(expression.statement, expression.imports) }
           when CountExpression then render_count(expression)
@@ -60,6 +60,7 @@ module CypherDSL
           when LabelOperation then render_labels(expression.node, expression.labels)
           when Reduction then render_reduction(expression)
           when PatternExpression then render_pattern_expression(expression.pattern)
+          when VectorLiteral then expression.as_string
           else render_condition_or_operation(expression)
           end
         end
@@ -71,7 +72,7 @@ module CypherDSL
         end
 
         def render_labels(node, labels)
-          "#{render_expression(node)}#{labels.map { |label| ":#{escape_schema_name(label)}" }.join}"
+          "#{render_expression(node)}#{labels.map { |label| render_label(label) }.join}"
         end
 
         def render_condition_or_operation(expression)
@@ -81,6 +82,7 @@ module CypherDSL
           when ConstantCondition then expression.value.to_s
           when ExpressionCondition then render_expression(expression.expression)
           when ExistsCondition then render_exists(expression)
+          when PropertyExistsCondition then render_property_exists(expression)
           when RelationshipPatternCondition then render_pattern_expression(expression.pattern)
           when ListPredicate then render_list_predicate(expression)
           when HasLabelCondition then render_labels(expression.node, expression.labels)
@@ -109,18 +111,29 @@ module CypherDSL
           "exists(#{render_pattern_expression(body)})"
         end
 
+        # A pattern body renders bare; with imports it needs a MATCH after the WITH.
         def render_count(count)
           body = count.body
-          return block('COUNT {', '}') { render_subquery(body, count.imports) } if body.is_a?(Statement)
+          return block('COUNT {', '}') { render_subquery(body, count.imports) } unless pattern_body?(body)
 
-          "COUNT { #{render_in_own_scope { render_pattern_element(body) }} }"
+          rendered = render_in_own_scope do
+            imports = count.imports.map { |import| render_projection_item(import) }
+            parts = [("WITH #{imports.join(', ')} MATCH" unless imports.empty?), render_pattern_element(body)]
+            parts << "WHERE #{render_expression(count.where_condition)}" if count.where_condition
+            parts.compact.join(' ')
+          end
+          "COUNT { #{rendered} }"
         end
 
+        def pattern_body?(body) = !(body.is_a?(Statement) || body.is_a?(UnionQuery))
+
         # Renders with the current scope, discarding names introduced inside.
         def render_in_own_scope
           outer_scope = @visited_names.dup
+          @names.enter_scope(:all)
           yield
         ensure
+          @names.leave_scope([])
           @visited_names = outer_scope
         end
 
@@ -166,13 +179,13 @@ module CypherDSL
         # A pattern comprehension is its own scope: names it introduces do not
         # count as visited outside of it.
         def render_pattern_comprehension(comprehension)
-          outer_scope = @visited_names.dup
-          parts = [render_pattern_element(comprehension.pattern)]
-          parts << "WHERE #{render_expression(comprehension.where_condition)}" if comprehension.where_condition
-          projection = comprehension.projection.map { |expression| render_expression(expression) }
-          parts << "| #{projection.size == 1 ? projection.first : "[#{projection.join(', ')}]"}"
-          @visited_names = outer_scope
-          "[#{parts.join(' ')}]"
+          render_in_own_scope do
+            parts = [render_pattern_element(comprehension.pattern)]
+            parts << "WHERE #{render_expression(comprehension.where_condition)}" if comprehension.where_condition
+            projection = comprehension.projection.map { |expression| render_expression(expression) }
+            parts << "| #{projection.size == 1 ? projection.first : "[#{projection.join(', ')}]"}"
+            "[#{parts.join(' ')}]"
+          end
         end
 
         def render_list_comprehension(comprehension)
@@ -185,7 +198,8 @@ module CypherDSL
         # Records every use for the catalog; anonymous parameters get `pcdslNN`,
         # shared between anonymous parameters with equal values.
         def render_parameter(parameter)
-          name = parameter.anonymous? ? anonymous_parameter_name(parameter) : parameter.name
+          name = parameter.anonymous? ? anonymous_parameter_name(parameter) : @names.resolve_parameter(parameter)
+          @renamed_parameters[parameter.name] = name if !parameter.anonymous? && name != parameter.name
           (@parameter_uses[name] ||= []) << parameter.value
           "$#{Escaper.escape_parameter_name(name)}"
         end
@@ -206,11 +220,18 @@ module CypherDSL
           "#{render_expression(property.container)}#{lookups.join}"
         end
 
+        # Verbatim text with its embedded expressions rendered (and their parameters collected).
+        def render_raw(raw)
+          raw.parts.map { |part| part.is_a?(String) ? part : render_expression(part) }.join
+        end
+
         def render_literal(value)
           case value
-          when String then "'#{value.gsub('\\') { '\\\\' }.gsub("'") { "\\'" }}'"
+          when String then Literal.quote(value)
           when nil then 'NULL'
           when true, false, Numeric then value.to_s
+          when DateTime, Time then "datetime('#{value.iso8601}')"
+          when Date then "date('#{value.iso8601}')"
           else raise ArgumentError, "Cannot render literal #{value.inspect}"
           end
         end
@@ -229,35 +250,14 @@ module CypherDSL
           "#{opening}#{break_line(@level + 1)}#{entries.join(",#{break_line(@level + 1)}")}#{break_line}#{closing}"
         end
 
-        def render_comparison(comparison)
-          left = render_operand(comparison.left)
-          return "#{left} #{comparison.operator}" if comparison.unary?
-
-          "#{left} #{comparison.operator} #{render_operand(comparison.right)}"
-        end
-
-        # A comparison nested inside another comparison is parenthesised: `(1 > 2) = true`.
-        def render_operand(expression)
-          rendered = render_expression(expression)
-          expression.is_a?(Comparison) ? "(#{rendered})" : rendered
-        end
-
-        # Pretty printed, each further operand starts an indented line: `(a\n  AND b)`.
-        def render_compound_condition(condition)
-          if condition.negation?
-            negated = condition.conditions.first
-            rendered = render_expression(negated)
-            return negated.is_a?(RelationshipPatternCondition) ? "NOT #{rendered}" : "NOT (#{rendered})"
-          end
-
-          operands = nested { condition.conditions.map { |inner| render_expression(inner) } }
-          "(#{operands.join("#{break_line(@level + 1)}#{condition.operator} ")})"
-        end
-
         def render_function_invocation(invocation)
-          arguments = invocation.arguments.map { |argument| render_expression(argument) }
+          arguments = invocation.arguments.map do |argument|
+            rendered = render_expression(argument)
+            # Pretty printed, a map argument keeps a space after the parenthesis: `collect( {`.
+            pretty? && rendered.start_with?('{') ? " #{rendered}" : rendered
+          end
           name = invocation.function_name
-          legacy = @configuration.dialect == Dialect::NEO4J_4
+          legacy = @configuration.legacy_functions?
           # Neo4j 4 has no elementId(); the closest equivalent is the stringified internal id.
           return "toString(id(#{arguments.join(', ')}))" if name == 'elementId' && legacy
 

data/lib/cypher_dsl/renderer/visitor/label_rendering.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  class Renderer
+    class Visitor
+      # Rendering of node labels: plain names and {Labels} expressions, dynamic
+      # (`:$($labels)`) where the dialect allows it, static otherwise.
+      module LabelRendering
+        STATIC_MESSAGE = 'Cannot render the given Labels in a Cypher pre 5.26 compatible way'
+
+        private
+
+        # One label entry including its leading colon.
+        def render_label(label)
+          label.is_a?(Labels) ? render_labels_expression(label) : ":#{escape_schema_name(label)}"
+        end
+
+        def render_labels_expression(labels)
+          return render_static_labels(labels) if !@configuration.dynamic_labels? && static_renderable?(labels)
+          return '' if labels.empty?
+
+          ":#{render_labels_tree(labels, nil)}"
+        end
+
+        def static_renderable?(labels)
+          labels.lhs.nil? && labels.rhs.nil? && %i[leaf colon_conjunction].include?(labels.type)
+        end
+
+        # Pre-5.26: the label names are taken from literals and parameter values and rendered as `:A:B`.
+        def render_static_labels(labels)
+          names = labels.values.flat_map { |value| static_label_names(value.value) }
+          names.map { |name| ":#{escape_schema_name(name)}" }.join
+        end
+
+        def static_label_names(value)
+          case value
+          when String then [value]
+          when Parameter then value.value? ? static_label_names(value.value) : raise(ArgumentError, STATIC_MESSAGE)
+          when ListExpression then value.elements.flat_map { |element| static_label_names(element) }
+          when Literal then value.value.is_a?(String) ? [value.value] : raise(ArgumentError, STATIC_MESSAGE)
+          when Array then value.flat_map { |item| static_label_names(item) }
+          else raise ArgumentError, STATIC_MESSAGE
+          end
+        end
+
+        # Mirrors the Java renderer's bracketing rules for `&`, `|` and `!`.
+        def render_labels_tree(labels, parent)
+          current = labels.type
+          close = false
+          unless labels.leaf?
+            close = (!parent.nil? || labels.negated?) && current != parent
+            close = false if close && !labels.negated? && (current == :conjunction || parent == :disjunction)
+          end
+
+          parts = []
+          parts << '!' if labels.negated?
+          parts << '(' if close
+          parts << render_labels_tree(labels.lhs, current) if labels.lhs
+          parts << render_label_values(labels, current)
+          parts << render_labels_tree(labels.rhs, current) if labels.rhs
+          parts << ')' if close
+          parts.join
+        end
+
+        def render_label_values(labels, current)
+          return labels.values.map { |value| render_label_value(value) }.join if labels.leaf?
+          if %i[colon_conjunction colon_disjunction].include?(current) && labels.values.any?
+            return labels.values.map { |value| render_label_value(value) }.join(':')
+          end
+
+          labels.empty? ? '' : Labels::OPERATORS[current]
+        end
+
+        def render_label_value(value)
+          case value.modifier
+          when :static then escape_schema_name(value.value)
+          when :all then "$(#{render_expression(value.value)})"
+          when :any then "$any(#{render_expression(value.value)})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cypher_dsl/renderer/visitor/patterns.rb

@@ -15,13 +15,21 @@ module CypherDSL
           when RelationshipChain then render_chain(element)
           when NamedPath then render_named_path(element)
           when QuantifiedPathPattern then render_quantified_path_pattern(element)
+          when RawExpression then render_raw(element) # `Cypher.raw('(n)-->(m)')` as a pattern
           else raise ArgumentError, "Cannot render pattern element #{element.inspect}"
           end
         end
 
+        # `p = SHORTEST 1 pattern`, or `p = shortestPath(pattern)` on dialects before Neo4j 5.21.
         def render_named_path(path)
-          selector = path.selector && "#{path.selector.keyword} "
-          "#{render_expression(path.symbolic_name)} = #{selector}#{render_pattern_element(path.pattern)}"
+          name = render_expression(path.symbolic_name)
+          pattern = render_pattern_element(path.pattern)
+          selector = path.selector
+          if selector&.legacy_function && @configuration.legacy_path_selectors?
+            "#{name} = #{selector.legacy_function}(#{pattern})"
+          else
+            "#{name} = #{"#{selector.keyword} " if selector}#{pattern}"
+          end
         end
 
         def render_quantified_path_pattern(quantified)
@@ -41,35 +49,15 @@ module CypherDSL
         # Inside a pattern expression (a pattern used as a condition) no new
         # variables may be introduced, so an unknown name is left out.
         def render_node(node)
-          name = node.symbolic_name && resolve_name(node.symbolic_name)
-          return "(#{name})" if name && @visited_names.include?(name)
+          name = node.symbolic_name && resolve_name(node.symbolic_name, in_entity: true)
+          return "(#{Escaper.escape_if_necessary(name)})" if name && @visited_names.include?(name)
 
           @visited_names << name if name && !@in_pattern_expression
           name = nil if @in_pattern_expression
-          labels = node.labels.map { |label| ":#{render_label(label)}" }.join
+          labels = node.labels.map { |label| render_label(label) }.join
           properties = node.properties && " #{render_expression(node.properties)}"
           where = node.where_condition && " WHERE #{render_expression(node.where_condition)}"
-          "(#{name}#{labels}#{properties}#{where})"
-        end
-
-        def render_label(label)
-          label.is_a?(LabelExpression) ? render_label_expression(label) : escape_schema_name(label)
-        end
-
-        # `A|B`, `A&B`, `!A`; operands of another kind are parenthesised.
-        def render_label_expression(expression)
-          case expression.type
-          when :leaf then escape_schema_name(expression.value)
-          when :negation then "!#{render_label_operand(expression.operands.first, expression)}"
-          else
-            operator = expression.type == :conjunction ? '&' : '|'
-            expression.operands.map { |operand| render_label_operand(operand, expression) }.join(operator)
-          end
-        end
-
-        def render_label_operand(operand, parent)
-          rendered = render_label_expression(operand)
-          operand.leaf? || operand.type == parent.type || operand.type == :negation ? rendered : "(#{rendered})"
+          "(#{name && Escaper.escape_if_necessary(name)}#{labels}#{properties}#{where})"
         end
 
         # A pattern used as a condition: known names render bare, unknown ones are dropped.
@@ -83,9 +71,9 @@ module CypherDSL
         # Like nodes, a named relationship renders in full once and as `[name]` afterwards.
         def render_relationship_details(relationship)
           details = relationship.details
-          name = relationship.symbolic_name && resolve_name(relationship.symbolic_name)
+          name = relationship.symbolic_name && resolve_name(relationship.symbolic_name, in_entity: true)
           inner = if name && @visited_names.include?(name)
-                    "[#{name}]"
+                    "[#{Escaper.escape_if_necessary(name)}]"
                   else
                     @visited_names << name if name && !@in_pattern_expression
                     content = render_details_content(relationship)
@@ -103,7 +91,8 @@ module CypherDSL
         def render_details_content(relationship)
           details = relationship.details
           types = details.types.map { |type| escape_schema_name(type) }.join('|')
-          name = relationship.symbolic_name && !@in_pattern_expression ? resolve_name(relationship.symbolic_name) : nil
+          named = relationship.symbolic_name && !@in_pattern_expression
+          name = named ? Escaper.escape_if_necessary(resolve_name(relationship.symbolic_name, in_entity: true)) : nil
           [
             name,
             (":#{types}" unless types.empty?),