Merge branch 'main' of https://github.com/ArcadeData/arcadedb

Author: lvca

engine/src/main/java/com/arcadedb/query/opencypher/executor/CypherExecutionPlan.java

@@ -1551,10 +1551,14 @@ private AbstractExecutionStep buildMatchStep(final MatchClause matchClause, Abst
             directionOverride = null;
           }
 
-          // Track relationship and target variables for cross-MATCH uniqueness scoping
-          if (relVar != null)
+          // Track relationship and target variables for cross-MATCH uniqueness scoping.
+          // Only add variables that are NEW to this MATCH clause — already-bound variables
+          // (from previous MATCHes or WITH) should not be treated as new match variables,
+          // otherwise OPTIONAL MATCH will incorrectly classify them when setting NULLs.
+          if (relVar != null && !boundVariables.contains(relVar))
             matchVariables.add(relVar);
-          matchVariables.add(effectiveTargetVar);
+          if (!boundVariables.contains(effectiveTargetVar))
+            matchVariables.add(effectiveTargetVar);
 
           AbstractExecutionStep nextStep;
           if (relPattern.isVariableLength()) {
@@ -2790,16 +2794,18 @@ private AbstractExecutionStep tryOptimizeMatchCountReturn(
     if (returnClause.isDistinct())
       return null;
 
-    // Find the single non-optional MATCH clause
+    // Find the single non-optional MATCH clause.
+    // Bail out if any OPTIONAL MATCH exists — the RETURN may reference variables
+    // from the OPTIONAL MATCH, which this optimization does not evaluate.
     MatchClause matchClause = null;
     int matchCount = 0;
     for (final ClauseEntry entry : clausesInOrder) {
       if (entry.getType() == ClauseEntry.ClauseType.MATCH) {
         final MatchClause mc = entry.getTypedClause();
-        if (!mc.isOptional()) {
-          matchClause = mc;
-          matchCount++;
-        }
+        if (mc.isOptional())
+          return null;
+        matchClause = mc;
+        matchCount++;
       }
     }
     if (matchCount != 1 || matchClause == null)

engine/src/main/java/com/arcadedb/query/opencypher/planner/CypherExecutionPlanner.java

@@ -28,6 +28,7 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -40,6 +41,14 @@
  * @author Luca Garulli (l.garulli--(at)--arcadedata.com)
  */
 public class CypherExecutionPlanner {
+  private static final Set<ClauseEntry.ClauseType> MUTATING_CLAUSES = EnumSet.of(
+      ClauseEntry.ClauseType.DELETE,
+      ClauseEntry.ClauseType.SET,
+      ClauseEntry.ClauseType.REMOVE,
+      ClauseEntry.ClauseType.CREATE,
+      ClauseEntry.ClauseType.MERGE
+  );
+
   private final DatabaseInternal    database;
   private final CypherStatement     statement;
   private final Map<String, Object> parameters;
@@ -213,23 +222,48 @@ private boolean shouldUseOptimizer() {
       }
     }
 
-    // The optimizer path (buildExecutionStepsWithOptimizer) only supports a fixed clause
-    // ordering: MATCH(es) → WITH → RETURN. Write clauses (CREATE/SET/DELETE/MERGE) are also handled.
-    // Disable for queries with clauses that break this assumption.
+    // The optimizer path (buildExecutionStepsWithOptimizer) applies clauses in a fixed order
+    // (MATCH → CREATE → SET → DELETE → REMOVE → MERGE → UNWIND → WITH → RETURN).
+    // This breaks queries where clause ordering matters, e.g. WITH before DELETE or UNWIND before SET.
+    // Fall back to ordered execution when write/mutating clauses are interleaved with WITH/UNWIND,
+    // or when MATCH appears after WITH (MATCH-WITH-MATCH pattern).
     if (statement.getClausesInOrder() != null) {
       int createCount = 0;
       int mergeCount = 0;
       int deleteCount = 0;
+      boolean seenWith = false;
+      boolean seenUnwind = false;
       for (final ClauseEntry clause : statement.getClausesInOrder()) {
         final ClauseEntry.ClauseType type = clause.getType();
-        if (type == ClauseEntry.ClauseType.FOREACH || type == ClauseEntry.ClauseType.CALL)
+
+        // Validate ordering before updating state
+        if ((seenWith || seenUnwind) && MUTATING_CLAUSES.contains(type))
+          return false;
+        if (seenWith && type == ClauseEntry.ClauseType.MATCH)
           return false;
-        if (type == ClauseEntry.ClauseType.CREATE)
+
+        switch (type) {
+        case FOREACH:
+        case CALL:
+          return false;
+        case WITH:
+          seenWith = true;
+          break;
+        case UNWIND:
+          seenUnwind = true;
+          break;
+        case CREATE:
           createCount++;
-        else if (type == ClauseEntry.ClauseType.MERGE)
+          break;
+        case MERGE:
           mergeCount++;
-        else if (type == ClauseEntry.ClauseType.DELETE)
+          break;
+        case DELETE:
           deleteCount++;
+          break;
+        default:
+          break;
+        }
       }
       // Multiple CREATE/MERGE/DELETE clauses not handled by optimizer path
       if (createCount > 1 || mergeCount > 1 || (deleteCount > 0 && mergeCount > 0))