fix: cypher traversing considering unidirectional edges

Fixed issue ArcadeData#3711

The OpenCypher optimizer's anchor selection picks the node with lowest cardinality as the starting point. For MATCH (p:Person)-[:WORKS_FOR]->(c:Company), if Company has fewer vertices, the optimizer picks Company as anchor and reverses the traversal direction to IN (incoming).

However, WORKS_FOR was created as UNIDIRECTIONAL, meaning edges are only stored on the source vertex's outgoing edge list (Person), not on the target's incoming list (Company). So traversing IN from Company finds nothing → 0 results.

OPTIONAL MATCH worked because it uses a different code path: it first scans all Person vertices (mandatory MATCH), then for each person expands outgoing WORKS_FOR edges (always in the correct OUT direction).

Author: lvca

engine/src/main/java/com/arcadedb/query/opencypher/optimizer/CypherOptimizer.java

@@ -40,6 +40,7 @@
 import com.arcadedb.query.opencypher.optimizer.rules.*;
 import com.arcadedb.query.opencypher.optimizer.statistics.CostModel;
 import com.arcadedb.query.opencypher.optimizer.statistics.StatisticsProvider;
+import com.arcadedb.schema.EdgeType;
 import com.arcadedb.query.sql.executor.CommandContext;
 import com.arcadedb.query.sql.executor.Result;
 
@@ -131,7 +132,14 @@ public PhysicalPlan optimize() {
     }
 
     // 3. Select anchor node (best starting point)
-    final AnchorSelection anchor = anchorSelector.selectAnchor(logicalPlan);
+    AnchorSelection anchor = anchorSelector.selectAnchor(logicalPlan);
+
+    // 3a. Validate anchor against UNIDIRECTIONAL edge constraints.
+    // UNIDIRECTIONAL edges only store outgoing links on the source vertex,
+    // so reverse traversal (incoming from target) finds nothing. If the selected
+    // anchor would force reverse traversal of a UNIDIRECTIONAL edge, re-select
+    // the source side as anchor instead.
+    anchor = validateAnchorForUnidirectionalEdges(anchor, logicalPlan);
 
     // 4. Create anchor operator (index seek or scan)
     final PhysicalOperator anchorOperator = createAnchorOperator(anchor);
@@ -244,6 +252,40 @@ private List<String> extractTypeNames(final LogicalPlan plan) {
     return typeNames;
   }
 
+  /**
+   * Validates the selected anchor against UNIDIRECTIONAL edge constraints.
+   * If the anchor is on the target side of a directed UNIDIRECTIONAL edge,
+   * the expand operator would need to traverse incoming edges which don't exist.
+   * In that case, force the source side as the anchor instead.
+   */
+  private AnchorSelection validateAnchorForUnidirectionalEdges(final AnchorSelection anchor,
+      final LogicalPlan logicalPlan) {
+    final String anchorVar = anchor.getVariable();
+    final var schema = database.getSchema();
+
+    for (final LogicalRelationship rel : logicalPlan.getRelationships()) {
+      // Check if the anchor is the target of an OUT relationship (would need IN traversal)
+      // or the source of an IN relationship (would need OUT traversal from the other side)
+      final boolean anchorIsTarget = anchorVar.equals(rel.getTargetVariable()) && rel.getDirection() == Direction.OUT;
+      final boolean anchorIsSource = anchorVar.equals(rel.getSourceVariable()) && rel.getDirection() == Direction.IN;
+
+      if (anchorIsTarget || anchorIsSource) {
+        // Check if any edge type in this relationship is UNIDIRECTIONAL
+        for (final String edgeTypeName : rel.getTypes()) {
+          if (schema.existsType(edgeTypeName) && schema.getType(edgeTypeName) instanceof EdgeType et && !et.isBidirectional()) {
+            // Force the other side as the anchor
+            final String correctAnchorVar = anchorIsTarget ? rel.getSourceVariable() : rel.getTargetVariable();
+            final LogicalNode correctNode = logicalPlan.getNodes().get(correctAnchorVar);
+            if (correctNode != null)
+              return anchorSelector.evaluateNodeDirect(correctNode, logicalPlan);
+            break;
+          }
+        }
+      }
+    }
+    return anchor;
+  }
+
   /**
    * Creates the appropriate physical operator for the anchor node.
    *

engine/src/test/java/com/arcadedb/query/opencypher/OpenCypherMandatoryMatchRelationshipTest.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright © 2021-present Arcade Data Ltd (info@arcadedata.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-FileCopyrightText: 2021-present Arcade Data Ltd (info@arcadedata.com)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.query.opencypher;
+
+import com.arcadedb.TestHelper;
+import com.arcadedb.query.sql.executor.Result;
+import com.arcadedb.query.sql.executor.ResultSet;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Regression test for GitHub issue #3711:
+ * Mandatory MATCH over existing relationship returns 0 rows,
+ * while OPTIONAL MATCH and SQL can see the same edges.
+ *
+ * @author Luca Garulli (l.garulli@arcadedata.com)
+ */
+class OpenCypherMandatoryMatchRelationshipTest extends TestHelper {
+
+  @Override
+  protected void beginTest() {
+    database.command("sql", "CREATE VERTEX TYPE Person");
+    database.command("sql", "CREATE VERTEX TYPE Company");
+    database.command("sql", "CREATE EDGE TYPE KNOWS UNIDIRECTIONAL");
+    database.command("sql", "CREATE EDGE TYPE WORKS_FOR UNIDIRECTIONAL");
+
+    database.transaction(() -> {
+      database.command("opencypher",
+          "CREATE (a:Person {name: 'Alice', age: 30})" +
+              "-[:KNOWS {since: 2020}]->" +
+              "(b:Person {name: 'Bob', age: 35})" +
+              "-[:KNOWS {since: 2021}]->" +
+              "(c:Person {name: 'Charlie', age: 25})" +
+              "-[:KNOWS {since: 2022}]->" +
+              "(d:Person {name: 'David', age: 28})");
+
+      database.command("opencypher", "CREATE (:Company {name: 'Acme'})");
+
+      database.command("opencypher",
+          "MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'}), (c:Company {name: 'Acme'}) " +
+              "CREATE (a)-[:WORKS_FOR]->(c), (b)-[:WORKS_FOR]->(c)");
+    });
+  }
+
+  @Test
+  void mandatoryMatchRelationshipShouldReturnResults() {
+    // Issue #3711: mandatory MATCH with relationship should return results when edges exist
+    try (final ResultSet rs = database.query("opencypher",
+        "MATCH (p:Person)-[:WORKS_FOR]->(c:Company) " +
+            "RETURN p.name as person, c.name as company ORDER BY person")) {
+      final List<Result> results = new ArrayList<>();
+      while (rs.hasNext())
+        results.add(rs.next());
+
+      assertThat(results).hasSize(2);
+      assertThat(results.get(0).<String>getProperty("person")).isEqualTo("Alice");
+      assertThat(results.get(0).<String>getProperty("company")).isEqualTo("Acme");
+      assertThat(results.get(1).<String>getProperty("person")).isEqualTo("Bob");
+      assertThat(results.get(1).<String>getProperty("company")).isEqualTo("Acme");
+    }
+  }
+
+  @Test
+  void sqlCanSeeEdges() {
+    // Verify SQL can see the WORKS_FOR edges
+    try (final ResultSet rs = database.query("sql", "SELECT count(*) as c FROM WORKS_FOR")) {
+      assertThat(rs.hasNext()).isTrue();
+      assertThat(((Number) rs.next().getProperty("c")).intValue()).isEqualTo(2);
+    }
+  }
+
+  @Test
+  void optionalMatchCanSeeEdges() {
+    // Verify OPTIONAL MATCH can see the WORKS_FOR edges
+    try (final ResultSet rs = database.query("opencypher",
+        "MATCH (p:Person) " +
+            "OPTIONAL MATCH (p)-[:WORKS_FOR]->(c:Company) " +
+            "RETURN p.name as name, c.name as company ORDER BY name")) {
+      final List<Result> results = new ArrayList<>();
+      while (rs.hasNext())
+        results.add(rs.next());
+
+      assertThat(results).hasSize(4);
+      // Alice -> Acme
+      assertThat(results.get(0).<String>getProperty("name")).isEqualTo("Alice");
+      assertThat(results.get(0).<String>getProperty("company")).isEqualTo("Acme");
+      // Bob -> Acme
+      assertThat(results.get(1).<String>getProperty("name")).isEqualTo("Bob");
+      assertThat(results.get(1).<String>getProperty("company")).isEqualTo("Acme");
+      // Charlie -> null
+      assertThat(results.get(2).<String>getProperty("name")).isEqualTo("Charlie");
+      assertThat((Object) results.get(2).getProperty("company")).isNull();
+      // David -> null
+      assertThat(results.get(3).<String>getProperty("name")).isEqualTo("David");
+      assertThat((Object) results.get(3).getProperty("company")).isNull();
+    }
+  }
+}