Merge branch 'neo4j-cypher-query-parser' into feature/cql-query-parser

Author: gonzalotguerrero

client-java/controller/src/main/antlr4/org/evomaster/client/java/controller/neo4j/cypher25/Cypher25Lexer.g4

@@ -0,0 +1,45 @@
+package org.evomaster.client.java.controller.neo4j.conditions;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Represents a logical AND of multiple conditions.
+ */
+public class AndCondition implements CypherCondition {
+
+    private final List<CypherCondition> conditions;
+
+    public AndCondition(List<CypherCondition> conditions) {
+        this.conditions = conditions != null ? new ArrayList<>(conditions) : new ArrayList<>();
+    }
+
+    public List<CypherCondition> getConditions() {
+        return Collections.unmodifiableList(conditions);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("(");
+        for (int i = 0; i < conditions.size(); i++) {
+            if (i > 0) sb.append(" AND ");
+            sb.append(conditions.get(i));
+        }
+        sb.append(")");
+        return sb.toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        AndCondition that = (AndCondition) o;
+        return conditions.equals(that.conditions);
+    }
+
+    @Override
+    public int hashCode() {
+        return conditions.hashCode();
+    }
+}

client-java/controller/src/main/antlr4/org/evomaster/client/java/controller/neo4j/cypher25/Cypher25Parser.g4

@@ -0,0 +1,37 @@
+package org.evomaster.client.java.controller.neo4j.conditions;
+
+import java.util.Objects;
+
+/**
+ * The any-label wildcard % in a label expression, e.g. (n:%). Satisfied when the element
+ * bound to the variable has a non-empty label set.
+ */
+public class AnyLabelCondition implements CypherCondition {
+
+    private final String variableName;
+
+    public AnyLabelCondition(String variableName) {
+        this.variableName = variableName;
+    }
+
+    public String getVariableName() {
+        return variableName;
+    }
+
+    @Override
+    public String toString() {
+        return variableName + ":%";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        return Objects.equals(variableName, ((AnyLabelCondition) o).variableName);
+    }
+
+    @Override
+    public int hashCode() {
+        return variableName != null ? variableName.hashCode() : 0;
+    }
+}

client-java/controller/src/main/java/org/evomaster/client/java/controller/neo4j/conditions/AndCondition.java

@@ -0,0 +1,78 @@
+package org.evomaster.client.java.controller.neo4j.conditions;
+
+import java.util.Objects;
+
+/**
+ * An operand that is an arithmetic expression over other operands, e.g. {@code p.age + 5} or
+ * {@code -n.weight}. Keeps the structure (operator + sub-operands) instead of the original text,
+ * so the inner {@link PropertyOperand}s stay resolvable per mapping and the heuristics calculator
+ * can valuate {@code v(x op y) = apply(op, v(left), v(right))}.
+ *
+ * <p>Fully-literal subtrees are folded to a {@link LiteralOperand} at parse time, so this class only
+ * ever holds an expression that still depends on the graph (at least one property reference).
+ *
+ * <p>For {@link ArithmeticOperator#NEGATE} (unary minus) the operand is {@link #getLeft()} and
+ * {@link #getRight()} is {@code null}.
+ */
+public final class ArithmeticOperand implements Operand {
+
+    private final ArithmeticOperator operator;
+    private final Operand left;
+    private final Operand right;
+
+    public ArithmeticOperand(ArithmeticOperator operator, Operand left, Operand right) {
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+
+    public ArithmeticOperator getOperator() {
+        return operator;
+    }
+
+    public Operand getLeft() {
+        return left;
+    }
+
+    public Operand getRight() {
+        return right;
+    }
+
+    @Override
+    public String toString() {
+        if (operator == ArithmeticOperator.NEGATE) {
+            return "-" + left;
+        }
+        return "(" + left + " " + symbol() + " " + right + ")";
+    }
+
+    private String symbol() {
+        switch (operator) {
+            case PLUS: return "+";
+            case MINUS: return "-";
+            case TIMES: return "*";
+            case DIVIDE: return "/";
+            case MODULO: return "%";
+            case POWER: return "^";
+            default: return "?";
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ArithmeticOperand that = (ArithmeticOperand) o;
+        return operator == that.operator
+                && Objects.equals(left, that.left)
+                && Objects.equals(right, that.right);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = operator != null ? operator.hashCode() : 0;
+        result = 31 * result + (left != null ? left.hashCode() : 0);
+        result = 31 * result + (right != null ? right.hashCode() : 0);
+        return result;
+    }
+}

client-java/controller/src/main/java/org/evomaster/client/java/controller/neo4j/conditions/AnyLabelCondition.java

@@ -0,0 +1,15 @@
+package org.evomaster.client.java.controller.neo4j.conditions;
+
+/**
+ * The arithmetic connectives an {@link ArithmeticOperand} can carry. Binary operators map to the
+ * Cypher tokens {@code + - * / % ^}; {@link #NEGATE} is unary minus (its operand is the left side).
+ */
+public enum ArithmeticOperator {
+    PLUS,
+    MINUS,
+    TIMES,
+    DIVIDE,
+    MODULO,
+    POWER,
+    NEGATE
+}

client-java/controller/src/main/java/org/evomaster/client/java/controller/neo4j/conditions/ArithmeticOperand.java

@@ -0,0 +1,59 @@
+package org.evomaster.client.java.controller.neo4j.conditions;
+
+import java.util.Objects;
+
+/**
+ * A comparison from a WHERE clause: left OP right.
+ * Both sides are typed {@link Operand}s so each can be valuated against the graph
+ * independently. The right operand is null for the unary IS NULL / IS NOT NULL operators.
+ */
+public class ComparisonCondition implements CypherCondition {
+
+    private final Operand left;
+    private final ComparisonOperator operator;
+    private final Operand right;
+
+    public ComparisonCondition(Operand left, ComparisonOperator operator, Operand right) {
+        this.left = left;
+        this.operator = operator;
+        this.right = right;
+    }
+
+    public Operand getLeft() {
+        return left;
+    }
+
+    public ComparisonOperator getOperator() {
+        return operator;
+    }
+
+    public Operand getRight() {
+        return right;
+    }
+
+    @Override
+    public String toString() {
+        if (right == null) {
+            return left + " " + operator.getSymbol();
+        }
+        return left + " " + operator.getSymbol() + " " + right;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ComparisonCondition that = (ComparisonCondition) o;
+        return operator == that.operator
+                && Objects.equals(left, that.left)
+                && Objects.equals(right, that.right);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = left != null ? left.hashCode() : 0;
+        result = 31 * result + (operator != null ? operator.hashCode() : 0);
+        result = 31 * result + (right != null ? right.hashCode() : 0);
+        return result;
+    }
+}

client-java/controller/src/main/java/org/evomaster/client/java/controller/neo4j/conditions/ArithmeticOperator.java

@@ -0,0 +1,38 @@
+package org.evomaster.client.java.controller.neo4j.conditions;
+
+/**
+ * Comparison operators used in Cypher WHERE clauses.
+ */
+public enum ComparisonOperator {
+    EQUALS("="),
+    NOT_EQUALS("<>"),
+    LESS_THAN("<"),
+    LESS_THAN_OR_EQUALS("<="),
+    GREATER_THAN(">"),
+    GREATER_THAN_OR_EQUALS(">="),
+    STARTS_WITH("STARTS WITH"),
+    ENDS_WITH("ENDS WITH"),
+    CONTAINS("CONTAINS"),
+    IN("IN"),
+    IS_NULL("IS NULL"),
+    IS_NOT_NULL("IS NOT NULL");
+
+    private final String symbol;
+
+    ComparisonOperator(String symbol) {
+        this.symbol = symbol;
+    }
+
+    public String getSymbol() {
+        return symbol;
+    }
+
+    public static ComparisonOperator fromSymbol(String symbol) {
+        for (ComparisonOperator op : values()) {
+            if (op.symbol.equalsIgnoreCase(symbol)) {
+                return op;
+            }
+        }
+        return null;
+    }
+}

client-java/controller/src/main/java/org/evomaster/client/java/controller/neo4j/conditions/ComparisonCondition.java

@@ -0,0 +1,14 @@
+package org.evomaster.client.java.controller.neo4j.conditions;
+
+/**
+ * Represents a condition extracted from a Cypher query.
+ * Conditions can come from:
+ * - Node labels: (n:Person) → LabelCondition
+ * - Node properties: (n {name: "Alice"}) → PropertyCondition
+ * - Edge types: -[:KNOWS]-> → TypeCondition
+ * - Edge properties: -[:KNOWS {since: 2020}]-> → PropertyCondition
+ * - WHERE clause: WHERE n.age > 25 → ComparisonCondition
+ * - Logical operators: AND, OR, NOT
+ */
+public interface CypherCondition {
+}

client-java/controller/src/main/java/org/evomaster/client/java/controller/neo4j/conditions/ComparisonOperator.java

@@ -0,0 +1,47 @@
+package org.evomaster.client.java.controller.neo4j.conditions;
+
+import java.util.Objects;
+
+/**
+ * Represents a label condition: n:Label
+ * Extracted from patterns like (n:Person) or (n:Person:Employee)
+ */
+public class LabelCondition implements CypherCondition {
+
+    private final String variableName;
+    private final String label;
+
+    public LabelCondition(String variableName, String label) {
+        this.variableName = variableName;
+        this.label = label;
+    }
+
+    public String getVariableName() {
+        return variableName;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    @Override
+    public String toString() {
+        return variableName + ":" + label;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LabelCondition that = (LabelCondition) o;
+        if (!Objects.equals(variableName, that.variableName)) return false;
+        return Objects.equals(label, that.label);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = variableName != null ? variableName.hashCode() : 0;
+        result = 31 * result + (label != null ? label.hashCode() : 0);
+        return result;
+    }
+}