cypher-dsl 0.1.0.alpha.1

data/lib/cypher_dsl/cypher.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # The main entry point of the DSL. Mirrors the static factory methods of the
+  # Java `org.neo4j.cypherdsl.core.Cypher` class in snake_case.
+  module Cypher
+    extend Functions
+
+    module_function
+
+    # --- pattern elements ------------------------------------------------
+
+    # A node with one primary label and optional additional labels; a trailing
+    # map (`Cypher.node('Test', Cypher.map_of(…))`) sets its properties.
+    def node(primary_label, *additional_labels)
+      properties = additional_labels.pop if [MapExpression, Hash].any? { |type| additional_labels.last.is_a?(type) }
+      labels = [primary_label, *additional_labels].map { |label| label.is_a?(LabelExpression) ? label : label.to_s }
+      node = Node.new(labels:)
+      properties ? node.with_properties(properties) : node
+    end
+
+    # A node without labels, optionally named.
+    def any_node(name = nil)
+      node = Node.new(labels: [])
+      name ? node.named(name) : node
+    end
+
+    # --- names, properties, parameters -----------------------------------
+
+    def name(value) = SymbolicName.of(value)
+
+    # `Cypher.property(:n, :name)` → `n.name`; the container may also be an expression,
+    # and a name may be an expression for a dynamic lookup (`n[$prop]`).
+    def property(container, *names)
+      container = SymbolicName.of(container) unless container.is_a?(Expression)
+      Property.new(container, names.flatten)
+    end
+
+    # `$name`, optionally with its value; see {Parameter}.
+    def parameter(name, value = Parameter::NO_VALUE) = Parameter.new(name, value)
+
+    # A parameter named by the renderer (`$pcdsl01`, …), carrying its value.
+    def anon_parameter(value) = Parameter.anonymous(value)
+
+    # --- literals --------------------------------------------------------
+
+    # Wraps a Ruby value as a literal; expressions pass through unchanged.
+    def literal_of(value) = Literal.of(value)
+
+    def literal_true = Literal::TRUE
+    def literal_false = Literal::FALSE
+    def literal_null = Literal::NULL
+
+    def map_of(*keys_and_values) = MapExpression.of(*keys_and_values)
+    def list_of(*expressions) = ListExpression.of(*expressions)
+
+    def asterisk = Asterisk::INSTANCE
+
+    # --- conditions ------------------------------------------------------
+
+    def is_true = ConstantCondition::TRUE
+    def is_false = ConstantCondition::FALSE
+    def no_condition = NoCondition::INSTANCE
+    def not(condition_or_pattern) = Condition.coerce(condition_or_pattern).not
+    def includes_all(list_expression, list) = Expression.coerce(list_expression).includes_all(list)
+    def includes_any(list_expression, list) = Expression.coerce(list_expression).includes_any(list)
+
+    # `[pattern WHERE … | …]`; continue with `where` and `returning`.
+    def list_based_on(pattern) = PatternComprehension.new(pattern)
+
+    # `[variable IN list WHERE … | …]`; continue with `in`, `where` and `returning`.
+    def list_with(variable) = ListComprehension.new(variable)
+
+    # `Cypher.path(:p).defined_by(pattern)` for `MATCH p = pattern`; `.get` for the bare name.
+    def path(name) = NamedPath::Ongoing.new(SymbolicName.of(name))
+
+    # Path selectors, `Cypher.any_shortest.named(:p).defined_by(pattern)` → `p = ANY pattern`.
+    def any_shortest = NamedPath::Selector.new('ANY')
+    def all_shortest = NamedPath::Selector.new('ALL SHORTEST')
+    def shortest_k(count) = NamedPath::Selector.shortest_k(count)
+    def shortest_k_groups(count) = NamedPath::Selector.shortest_k(count, groups: true)
+
+    # `EXISTS { pattern }` / `EXISTS { pattern, pattern }` / `EXISTS { [WITH imports] statement }`.
+    # A property gives the condition `n.prop IS NOT NULL`, any other plain expression the
+    # legacy `exists(expr)` function.
+    def exists(body, *imports)
+      return body.is_not_null if body.is_a?(Property)
+      return function('exists', body) if body.is_a?(Expression) && !body.is_a?(Statement) && !pattern?(body)
+
+      ExistsCondition.new(body, imports.flatten.map { |import| Expression.coerce(import) })
+    end
+
+    PATTERN_TYPES = [Relationship, RelationshipChain, QuantifiedPathPattern, NamedPath].freeze
+    private_constant :PATTERN_TYPES
+
+    def pattern?(value) = PATTERN_TYPES.any? { |type| value.is_a?(type) }
+
+    # List predicates: `Cypher.all(:x).in(list).where(condition)`.
+    def all(variable) = ListPredicate::Ongoing.new('all', variable)
+    def any(variable) = ListPredicate::Ongoing.new('any', variable)
+    def none(variable) = ListPredicate::Ongoing.new('none', variable)
+    def single(variable) = ListPredicate::Ongoing.new('single', variable)
+
+    def sub_list_until(list, end_index) = ListOperator.sublist(Expression.coerce(list), nil, end_index)
+    def sub_list_from(list, start_index) = ListOperator.sublist(Expression.coerce(list), start_index, nil)
+    def sub_list(list, start_index = nil, end_index = nil) = sublist(list, start_index, end_index)
+
+    def range(start_value, end_value, step = nil) = function('range', *[start_value, end_value, step].compact)
+
+    # --- operations ------------------------------------------------------
+
+    def set(target, value) = Operation.new(target, '=', Expression.coerce(value))
+    def set_label(node, *labels) = LabelOperation.new(node, labels)
+    def remove_label(node, *labels) = LabelOperation.new(node, labels, remove: true)
+    def mutate(target, expression) = Operation.new(target, '+=', Expression.coerce(expression))
+    def minus(expression) = UnaryOperation.new('-', Expression.coerce(expression))
+    def plus(expression) = UnaryOperation.new('+', Expression.coerce(expression))
+    def value_at(list, index) = ListOperator.value_at(Expression.coerce(list), index)
+
+    def sublist(list, start_index = nil, end_index = nil)
+      ListOperator.sublist(Expression.coerce(list), start_index, end_index)
+    end
+
+    # `CASE … END`; `case_expression(subject)` for the simple form, no argument for the generic one.
+    def case_expression(subject = nil) = CaseExpression.new(subject: subject && Expression.coerce(subject))
+
+    # --- sorting and functions --------------------------------------------
+    # Plain functions live in {Functions}; these overloads also accept patterns and statements.
+
+    # `collect(expression)`, or `COLLECT { statement }` when given a statement.
+    def collect(expression_or_statement)
+      return CollectExpression.new(expression_or_statement) if expression_or_statement.is_a?(Statement)
+
+      function('collect', expression_or_statement)
+    end
+
+    # A map projection on a name: `Cypher.create_projection(:n, 'title')` → `n{.title}`.
+    def create_projection(name, *entries) = MapProjection.new(SymbolicName.of(name), entries.flatten)
+
+    def sort(expression) = SortItem.new(Expression.coerce(expression), nil)
+
+    # `size(list)` or `size(pattern)`.
+    def size(expression_or_pattern)
+      argument = pattern?(expression_or_pattern) ? PatternExpression.new(expression_or_pattern) : expression_or_pattern
+      function('size', argument)
+    end
+
+    # `count(expression)`, or `COUNT { pattern }` / `COUNT { statement }` for patterns and statements.
+    def count(expression_or_pattern)
+      subquery = pattern?(expression_or_pattern) || expression_or_pattern.is_a?(Statement)
+      return CountExpression.new(expression_or_pattern) if subquery
+
+      FunctionInvocation.new('count', [Expression.coerce(expression_or_pattern)])
+    end
+
+    # `Cypher.call('db.labels')` / `Cypher.call('db', 'labels')`: a procedure call (see {StandaloneCall});
+    # `Cypher.call(statement, imports…)`: a `CALL { subquery }`.
+    def call(*arguments)
+      return StatementBuilder.new.call(*arguments) if arguments.first.is_a?(Statement)
+
+      StandaloneCall.new(arguments)
+    end
+
+    # `Cypher.use('graph', statement)` / `Cypher.use(Cypher.graph_by_name(name), statement)`:
+    # the statement prefixed with `USE graph`.
+    def use(graph, statement)
+      graph = graph.to_s unless graph.is_a?(Expression)
+      Statement.new([Clauses::Use.new(graph:)] + statement.clauses)
+    end
+
+    # `Cypher.load_csv('file:///x.csv').as(:line)`.
+    def load_csv(uri, with_headers: false) = StatementBuilder.new.load_csv(uri, with_headers:)
+
+    # Imports for an EXISTS / COLLECT subquery: `Cypher.subquery_with(x).collect(statement)`.
+    def subquery_with(*imports) = SubqueryWith.new(imports)
+
+    # `CALL () { raw cypher }`; continues as a statement builder.
+    def call_raw_cypher(cypher)
+      clause = Clauses::CallSubquery.new(body: RawExpression.new(cypher), imports: [],
+                                         in_transactions: false, rows: nil)
+      StatementBuilder.new.send(:append, clause, nil)
+    end
+
+    # Verbatim Cypher, the escape hatch.
+    def raw(cypher) = RawExpression.new(cypher)
+
+    # Static comparison forms, `Cypher.gt(a, b)` etc.
+    def eq(left, right) = Expression.coerce(left).is_equal_to(right)
+    def ne(left, right) = Expression.coerce(left).is_not_equal_to(right)
+    def gt(left, right) = Expression.coerce(left).gt(right)
+    def gte(left, right) = Expression.coerce(left).gte(right)
+    def lt(left, right) = Expression.coerce(left).lt(right)
+    def lte(left, right) = Expression.coerce(left).lte(right)
+
+    # --- statement builders -----------------------------------------------
+
+    def match(*pattern_elements) = StatementBuilder.new.match(*pattern_elements)
+    def optional_match(*pattern_elements) = StatementBuilder.new.optional_match(*pattern_elements)
+    def create(*pattern_elements) = StatementBuilder.new.create(*pattern_elements)
+    def merge(*pattern_elements) = StatementBuilder.new.merge(*pattern_elements)
+    def with(*expressions) = StatementBuilder.new.with(*expressions)
+    def unwind(*expressions) = StatementBuilder.new.unwind(*expressions)
+    def returning(*expressions) = StatementBuilder.new.returning(*expressions)
+    def returning_distinct(*expressions) = StatementBuilder.new.returning_distinct(*expressions)
+    def returning_raw(*expressions) = StatementBuilder.new.returning_raw(*expressions)
+
+    def union(*statements) = UnionQuery.create(statements, all: false)
+    def union_all(*statements) = UnionQuery.create(statements, all: true)
+  end
+end

data/lib/cypher_dsl/exists_condition.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # `EXISTS { pattern }` / `EXISTS { [WITH imports] statement }`.
+  class ExistsCondition < Condition
+    attr_reader :body, :imports
+
+    def initialize(body, imports = [])
+      super()
+      @body = body
+      @imports = imports.freeze
+      freeze
+    end
+  end
+end

data/lib/cypher_dsl/expression.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # Mixed into everything that can appear where Cypher expects an expression.
+  # Provides the fluent condition, alias and sort helpers of the Java API.
+  module Expression
+    # Coerces a plain Ruby value into an expression; expressions pass through.
+    def self.coerce(value)
+      value.is_a?(Expression) ? value : Literal.of(value)
+    end
+
+    def as(alias_name) = AliasedExpression.new(self, alias_name)
+
+    # A property of this expression's value, e.g. `$param.key` or `datetime().epochSeconds`.
+    def property(*names) = Property.new(self, names)
+
+    # This expression as a condition, e.g. a CASE expression in WHERE.
+    def as_condition = ExpressionCondition.new(self)
+
+    def ascending = SortItem.new(self, :asc)
+    def descending = SortItem.new(self, :desc)
+
+    def is_equal_to(other) = Comparison.new(self, '=', Expression.coerce(other))
+    def is_not_equal_to(other) = Comparison.new(self, '<>', Expression.coerce(other))
+    def lt(other) = Comparison.new(self, '<', Expression.coerce(other))
+    def lte(other) = Comparison.new(self, '<=', Expression.coerce(other))
+    def gt(other) = Comparison.new(self, '>', Expression.coerce(other))
+    def gte(other) = Comparison.new(self, '>=', Expression.coerce(other))
+    def matches(other) = Comparison.new(self, '=~', Expression.coerce(other))
+    def starts_with(other) = Comparison.new(self, 'STARTS WITH', Expression.coerce(other))
+    def ends_with(other) = Comparison.new(self, 'ENDS WITH', Expression.coerce(other))
+    def contains(other) = Comparison.new(self, 'CONTAINS', Expression.coerce(other))
+    def is_null = Comparison.new(self, 'IS NULL', nil)
+    def is_not_null = Comparison.new(self, 'IS NOT NULL', nil)
+    def is_true = Comparison.new(self, '=', Literal::TRUE)
+    def is_false = Comparison.new(self, '=', Literal::FALSE)
+    def in(haystack) = Comparison.new(self, 'IN', Expression.coerce(haystack))
+
+    # `size(self)`, `size(self) = n` and `size(self) = 0`.
+    def size = FunctionInvocation.new('size', [self])
+    def has_size(expected) = size.is_equal_to(expected)
+    def is_empty = size.is_equal_to(Literal.new(0))
+
+    # `all(x IN list WHERE x IN self)` / `any(…)`: does this list contain all / any of the elements?
+    def includes_all(list) = ListPredicate.new('all', :x, Expression.coerce(list), SymbolicName.of(:x).in(self))
+    def includes_any(list) = ListPredicate.new('any', :x, Expression.coerce(list), SymbolicName.of(:x).in(self))
+
+    # Arithmetic; rendered in parentheses, e.g. `(a + b)`.
+    def add(other) = Operation.new(self, '+', Expression.coerce(other))
+    def subtract(other) = Operation.new(self, '-', Expression.coerce(other))
+    def multiply(other) = Operation.new(self, '*', Expression.coerce(other))
+    def divide(other) = Operation.new(self, '/', Expression.coerce(other))
+    def remainder(other) = Operation.new(self, '%', Expression.coerce(other))
+    def pow(other) = Operation.new(self, '^', Expression.coerce(other))
+    def concat(other) = Operation.new(self, '+', Expression.coerce(other))
+
+    # Java short forms.
+    alias eq is_equal_to
+    alias ne is_not_equal_to
+
+    # Arel spellings, each mapping to exactly one of the above.
+    alias not_eq is_not_equal_to
+    alias gteq gte
+    alias lteq lte
+    alias asc ascending
+    alias desc descending
+    def not_in(haystack) = self.in(haystack).not
+  end
+end

data/lib/cypher_dsl/expression_condition.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # Any expression used where a condition is expected, e.g. a CASE expression in WHERE.
+  class ExpressionCondition < Condition
+    attr_reader :expression
+
+    def initialize(expression)
+      super()
+      @expression = expression
+      freeze
+    end
+  end
+end

data/lib/cypher_dsl/function_invocation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # A function call such as `size((a)-->())` or `count(n)`.
+  class FunctionInvocation
+    include Expression
+
+    attr_reader :function_name, :arguments, :distinct
+
+    def initialize(function_name, arguments, distinct: false)
+      @function_name = function_name
+      @arguments = arguments.freeze
+      @distinct = distinct
+      freeze
+    end
+  end
+end

data/lib/cypher_dsl/functions.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # Factory methods for Cypher's built-in functions, mixed into {Cypher}
+  # (`Cypher.to_upper(name)`, `Cypher.date(year: …)`). Names follow the Java
+  # `Functions` class in snake_case; `*_distinct` variants render `DISTINCT`
+  # inside the call. Arguments are coerced, so plain strings and numbers become
+  # literals and `nil` becomes `NULL`.
+  module Functions
+    # A call of any function with the given arguments, coerced to expressions.
+    def function(name, *arguments) = FunctionInvocation.new(name, arguments.map { |a| Expression.coerce(a) })
+
+    # --- strings ---------------------------------------------------------
+
+    def left(expression, length) = string_side('left', expression, length)
+    def right(expression, length) = string_side('right', expression, length)
+    def ltrim(expression) = function('ltrim', expression)
+    def rtrim(expression) = function('rtrim', expression)
+    def trim(expression) = function('trim', expression)
+    def to_lower(expression) = function('toLower', expression)
+    def to_upper(expression) = function('toUpper', expression)
+    def reverse(expression) = function('reverse', expression)
+    def replace(original, search, replacement) = function('replace', original, search, replacement)
+    def split(expression, delimiter) = function('split', expression, delimiter)
+    def to_string_or_null(expression) = function('toStringOrNull', expression)
+
+    def substring(original, start, length = nil)
+      raise ArgumentError, 'start is required' if start.nil?
+
+      function('substring', original, start, *[length].compact)
+    end
+
+    # --- aggregates ------------------------------------------------------
+
+    def avg(expression) = function('avg', expression)
+    def avg_distinct(expression) = distinct_function('avg', expression)
+    def collect(expression) = function('collect', expression)
+    def collect_distinct(expression) = distinct_function('collect', expression)
+    def count(expression) = function('count', expression)
+    def count_distinct(expression) = distinct_function('count', expression)
+    def max(expression) = function('max', expression)
+    def max_distinct(expression) = distinct_function('max', expression)
+    def min(expression) = function('min', expression)
+    def min_distinct(expression) = distinct_function('min', expression)
+    def sum(expression) = function('sum', expression)
+    def sum_distinct(expression) = distinct_function('sum', expression)
+    def percentile_cont(expression, percentile) = function('percentileCont', expression, percentile)
+    def percentile_cont_distinct(expression, percentile) = distinct_function('percentileCont', expression, percentile)
+    def percentile_disc(expression, percentile) = function('percentileDisc', expression, percentile)
+    def percentile_disc_distinct(expression, percentile) = distinct_function('percentileDisc', expression, percentile)
+    def st_dev(expression) = function('stDev', expression)
+    def st_dev_distinct(expression) = distinct_function('stDev', expression)
+    def st_dev_p(expression) = function('stDevP', expression)
+    def st_dev_p_distinct(expression) = distinct_function('stDevP', expression)
+
+    # --- lists, paths and entities ---------------------------------------
+
+    def head(expression) = function('head', expression)
+    def last(expression) = function('last', expression)
+    def tail(expression) = function('tail', expression)
+    def keys(expression) = function('keys', expression)
+    def properties(expression) = function('properties', expression)
+    def coalesce(*expressions) = function('coalesce', *expressions)
+    def is_empty(expression) = function('isEmpty', expression)
+    def range(start_value, end_value, step = nil) = function('range', start_value, end_value, *[step].compact)
+    def nodes(path) = function('nodes', path.required_symbolic_name)
+    def relationships(path) = function('relationships', path.required_symbolic_name)
+    def length(path) = function('length', path.required_symbolic_name)
+    def labels(node) = function('labels', node.required_symbolic_name)
+    def type(relationship) = function('type', relationship.required_symbolic_name)
+    def start_node(relationship) = function('startNode', relationship.required_symbolic_name)
+    def end_node(relationship) = function('endNode', relationship.required_symbolic_name)
+    def element_id(element) = function('elementId', element.required_symbolic_name)
+
+    # `id(n)`; deprecated in Neo4j 5 in favour of {#element_id}, kept for parity.
+    def id(element) = function('id', element.required_symbolic_name)
+
+    # `reduce(acc = initial, x IN list | mapper)`, built as
+    # `reduce(:x).in(list).map(mapper).accumulate_on(acc).with_initial_value_of(0)`.
+    def reduce(variable) = Reduction.of(variable)
+
+    # --- scalars and conversions -----------------------------------------
+
+    def to_integer(expression) = function('toInteger', expression)
+    def to_float(expression) = function('toFloat', expression)
+    def to_string(expression) = function('toString', expression)
+    def to_boolean(expression) = function('toBoolean', expression)
+    def random_uuid = function('randomUUID')
+
+    # --- mathematical ----------------------------------------------------
+
+    def abs(expression) = function('abs', expression)
+    def ceil(expression) = function('ceil', expression)
+    def floor(expression) = function('floor', expression)
+    def sign(expression) = function('sign', expression)
+    def exp(expression) = function('exp', expression)
+    def log(expression) = function('log', expression)
+    def log10(expression) = function('log10', expression)
+    def sqrt(expression) = function('sqrt', expression)
+    def acos(expression) = function('acos', expression)
+    def asin(expression) = function('asin', expression)
+    def atan(expression) = function('atan', expression)
+    def atan2(y, x) = function('atan2', y, x)
+    def cos(expression) = function('cos', expression)
+    def cot(expression) = function('cot', expression)
+    def degrees(expression) = function('degrees', expression)
+    def haversin(expression) = function('haversin', expression)
+    def radians(expression) = function('radians', expression)
+    def sin(expression) = function('sin', expression)
+    def tan(expression) = function('tan', expression)
+    def e = function('e')
+    def pi = function('pi')
+    def rand = function('rand')
+
+    # `round(value)`, `round(value, precision)` or `round(value, precision, mode)`.
+    def round(value, *arguments)
+      raise ArgumentError, 'round() takes a value, an optional precision and an optional mode' if arguments.size > 2
+
+      function('round', value, *arguments)
+    end
+
+    # --- spatial ---------------------------------------------------------
+
+    def point(expression) = function('point', expression)
+    def cartesian(x, y) = point(MapExpression.of('x', x, 'y', y))
+    def coordinate(longitude, latitude) = point(MapExpression.of('longitude', longitude, 'latitude', latitude))
+    def within_bbox(point, lower_left, upper_right) = function('point.withinBBox', point, lower_left, upper_right)
+
+    # `distance(a, b)`; rendered as `point.distance(a, b)` on Neo4j 5.
+    def distance(point1, point2) = function('distance', point1, point2)
+
+    # --- temporal --------------------------------------------------------
+
+    # `date()`, `date('2020-09-15')`, `date({year: 2020})`, `date($p)` or `date(timezone: 'Europe/Berlin')`;
+    # the same for datetime, localdatetime, localtime and time.
+    def date(value = nil, timezone: nil) = temporal('date', value, timezone)
+    def datetime(value = nil, timezone: nil) = temporal('datetime', value, timezone)
+    def localdatetime(value = nil, timezone: nil) = temporal('localdatetime', value, timezone)
+    def localtime(value = nil, timezone: nil) = temporal('localtime', value, timezone)
+    def time(value = nil, timezone: nil) = temporal('time', value, timezone)
+    def duration(value) = function('duration', value)
+
+    def calendar_date(year, month = nil, day = nil) = date(date_components(year:, month:, day:))
+    def week_date(year, week = nil, day_of_week = nil) = date(date_components(year:, week:, dayOfWeek: day_of_week))
+    def ordinal_date(year, ordinal_day = nil) = date(date_components(year:, ordinalDay: ordinal_day))
+
+    def quarter_date(year, quarter = nil, day_of_quarter = nil)
+      date(date_components(year:, quarter:, dayOfQuarter: day_of_quarter))
+    end
+
+    # --- graphs (composite databases) ------------------------------------
+
+    def graph_names = function('graph.names')
+    def graph_properties_by_name(name) = function('graph.propertiesByName', name)
+    def graph_by_name(name) = function('graph.byName', name)
+
+    private
+
+    def distinct_function(name, *arguments)
+      FunctionInvocation.new(name, arguments.map { |a| Expression.coerce(a) }, distinct: true)
+    end
+
+    def string_side(name, expression, length)
+      raise ArgumentError, 'length might not be null when the expression is not null' if !expression.nil? && length.nil?
+
+      function(name, expression, length)
+    end
+
+    def temporal(name, value, timezone)
+      raise ArgumentError, "#{name}() takes either a value or a timezone, not both" if value && timezone
+      return function(name, MapExpression.of('timezone', timezone)) if timezone
+
+      value.nil? ? function(name) : function(name, value)
+    end
+
+    def date_components(**components)
+      raise ArgumentError, 'year is required' if components[:year].nil?
+
+      MapExpression.of(components.compact.transform_keys(&:to_s))
+    end
+  end
+end

data/lib/cypher_dsl/has_label_condition.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # The label predicate `n:Label:Other`.
+  class HasLabelCondition < Condition
+    attr_reader :node, :labels
+
+    def initialize(node, labels)
+      super()
+      @node = node
+      @labels = labels.map(&:to_s).freeze
+      freeze
+    end
+  end
+end

data/lib/cypher_dsl/label_expression.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # A label expression as in `(n:A|B)`, `(n:A&!B)` or `(n:(A|B)&C)`; built from
+  # {Labels.exactly} and combined with {#or}, {#and} and {#negate}.
+  class LabelExpression
+    TYPES = %i[leaf conjunction disjunction negation].freeze
+
+    attr_reader :type, :value, :operands
+
+    def self.exactly(name) = new(:leaf, name.to_s, [])
+
+    def initialize(type, value, operands)
+      raise ArgumentError, "Unknown label expression type #{type.inspect}" unless TYPES.include?(type)
+
+      @type = type
+      @value = value
+      @operands = operands.freeze
+      freeze
+    end
+
+    def or(other) = LabelExpression.new(:disjunction, nil, [self, coerce(other)])
+    def and(other) = LabelExpression.new(:conjunction, nil, [self, coerce(other)])
+    def negate = LabelExpression.new(:negation, nil, [self])
+    alias not negate
+
+    def leaf? = type == :leaf
+
+    private
+
+    def coerce(other) = other.is_a?(LabelExpression) ? other : LabelExpression.exactly(other)
+  end
+
+  # Factory for label expressions: `Labels.exactly('A').or('B')`.
+  module Labels
+    module_function
+
+    def exactly(name) = LabelExpression.exactly(name)
+  end
+end

data/lib/cypher_dsl/label_operation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # `n:Label:Other` as the target of SET or REMOVE; `remove` marks an operation
+  # built for REMOVE, which a SET clause rejects.
+  class LabelOperation
+    attr_reader :node, :labels, :remove
+
+    def initialize(node, labels, remove: false)
+      @node = node
+      @labels = labels.map(&:to_s).freeze
+      @remove = remove
+      freeze
+    end
+
+    def remove? = remove
+  end
+end

data/lib/cypher_dsl/list_comprehension.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # `[variable IN list WHERE condition | expression]`. Built with
+  # `Cypher.list_with(name).in(list)`, refined with `where`, completed with `returning`.
+  class ListComprehension
+    include Expression
+
+    attr_reader :variable, :list, :where_condition, :projection
+
+    def initialize(variable, list: nil, where_condition: nil, projection: nil)
+      @variable = SymbolicName.of(variable)
+      @list = list
+      @where_condition = where_condition
+      @projection = projection
+      freeze
+    end
+
+    def in(list) = with(list: Expression.coerce(list))
+
+    def where(condition) = with(where_condition: Condition.coerce(condition))
+
+    # Without an argument the comprehension yields the variable itself; several
+    # expressions yield a list.
+    def returning(*expressions)
+      projection = case expressions.size
+                   when 0 then nil
+                   when 1 then Expression.coerce(expressions.first)
+                   else ListExpression.of(expressions)
+                   end
+      with(projection:)
+    end
+
+    private
+
+    def with(**changes)
+      ListComprehension.new(variable, list:, where_condition:, projection:, **changes)
+    end
+  end
+end

data/lib/cypher_dsl/list_expression.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # A list literal `[a, b, c]` of expressions.
+  class ListExpression
+    include Expression
+
+    attr_reader :elements
+
+    def self.of(*elements) = new(elements.flatten.map { |element| Expression.coerce(element) })
+
+    def initialize(elements)
+      @elements = elements.freeze
+      freeze
+    end
+  end
+end

data/lib/cypher_dsl/list_operator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CypherDSL
+  # Index and slice access on lists: `list[0]`, `list[1..3]`, `list[..2]`.
+  class ListOperator
+    include Expression
+
+    attr_reader :list, :start_index, :end_index, :slice
+
+    def self.value_at(list, index) = new(list, Expression.coerce(index), nil, false)
+
+    def self.sublist(list, start_index = nil, end_index = nil)
+      new(list, start_index && Expression.coerce(start_index), end_index && Expression.coerce(end_index), true)
+    end
+
+    def initialize(list, start_index, end_index, slice)
+      @list = list
+      @start_index = start_index
+      @end_index = end_index
+      @slice = slice
+      freeze
+    end
+  end
+end