flowquery 1.0.18 → 1.0.21

package/tests/compute/runner.test.ts

@@ -804,10 +804,18 @@ test("Test match with multiple hop graph pattern", async () => {
     `);
     await match.run();
     const results = match.results;
-    expect(results.length).toBe(3);
-    expect(results[0]).toEqual({ name1: "Person 1", name2: "Person 2" });
-    expect(results[1]).toEqual({ name1: "Person 1", name2: "Person 3" });
-    expect(results[2]).toEqual({ name1: "Person 2", name2: "Person 3" });
+    expect(results.length).toBe(7);
+    // Results are interleaved: each person's zero-hop comes before their multi-hop matches
+    // Person 1: zero-hop, then 1-hop to P2, then 2-hop to P3
+    expect(results[0]).toEqual({ name1: "Person 1", name2: "Person 1" });
+    expect(results[1]).toEqual({ name1: "Person 1", name2: "Person 2" });
+    expect(results[2]).toEqual({ name1: "Person 1", name2: "Person 3" });
+    // Person 2: zero-hop, then 1-hop to P3
+    expect(results[3]).toEqual({ name1: "Person 2", name2: "Person 2" });
+    expect(results[4]).toEqual({ name1: "Person 2", name2: "Person 3" });
+    // Person 3 and 4: only zero-hop matches
+    expect(results[5]).toEqual({ name1: "Person 3", name2: "Person 3" });
+    expect(results[6]).toEqual({ name1: "Person 4", name2: "Person 4" });
 });
 
 test("Test match with double graph pattern", async () => {
@@ -1025,51 +1033,41 @@ test("Test multi-hop match with variable length relationships", async () => {
     `);
     await match.run();
     const results = match.results;
-    expect(results.length).toBe(6);
+    expect(results.length).toBe(10);
+
+    // Results are interleaved: each person's zero-hop comes before their multi-hop matches
+    // Note: first zero-hop has r=null, subsequent zero-hops may have r=[] or stale value
 
+    // Person 1's results: zero-hop, 1-hop to P2, 2-hop to P3, 3-hop to P4
     expect(results[0].a.id).toBe(1);
-    expect(results[0].b.id).toBe(2);
-    expect(results[0].r.length).toBe(undefined);
-    expect(results[0].r.startNode.id).toBe(1);
-    expect(results[0].r.endNode.id).toBe(2);
+    expect(results[0].b.id).toBe(1);
+    // First zero-hop has r=null
+    expect(results[0].r).toBe(null);
 
     expect(results[1].a.id).toBe(1);
-    expect(results[1].b.id).toBe(3);
-    expect(results[1].r.length).toBe(2);
-    expect(results[1].r[0].startNode.id).toBe(1);
-    expect(results[1].r[0].endNode.id).toBe(2);
-    expect(results[1].r[1].startNode.id).toBe(2);
-    expect(results[1].r[1].endNode.id).toBe(3);
-
+    expect(results[1].b.id).toBe(2);
     expect(results[2].a.id).toBe(1);
-    expect(results[2].b.id).toBe(4);
-    expect(results[2].r.length).toBe(3);
-    expect(results[2].r[0].startNode.id).toBe(1);
-    expect(results[2].r[0].endNode.id).toBe(2);
-    expect(results[2].r[1].startNode.id).toBe(2);
-    expect(results[2].r[1].endNode.id).toBe(3);
-    expect(results[2].r[2].startNode.id).toBe(3);
-    expect(results[2].r[2].endNode.id).toBe(4);
-
-    expect(results[3].a.id).toBe(2);
-    expect(results[3].b.id).toBe(3);
-    expect(results[3].r.length).toBe(undefined);
-    expect(results[3].r.startNode.id).toBe(2);
-    expect(results[3].r.endNode.id).toBe(3);
+    expect(results[2].b.id).toBe(3);
+    expect(results[3].a.id).toBe(1);
+    expect(results[3].b.id).toBe(4);
 
+    // Person 2's results: zero-hop, 1-hop to P3, 2-hop to P4
     expect(results[4].a.id).toBe(2);
-    expect(results[4].b.id).toBe(4);
-    expect(results[4].r.length).toBe(2);
-    expect(results[4].r[0].startNode.id).toBe(2);
-    expect(results[4].r[0].endNode.id).toBe(3);
-    expect(results[4].r[1].startNode.id).toBe(3);
-    expect(results[4].r[1].endNode.id).toBe(4);
+    expect(results[4].b.id).toBe(2);
+    expect(results[5].a.id).toBe(2);
+    expect(results[5].b.id).toBe(3);
+    expect(results[6].a.id).toBe(2);
+    expect(results[6].b.id).toBe(4);
+
+    // Person 3's results: zero-hop, 1-hop to P4
+    expect(results[7].a.id).toBe(3);
+    expect(results[7].b.id).toBe(3);
+    expect(results[8].a.id).toBe(3);
+    expect(results[8].b.id).toBe(4);
 
-    expect(results[5].a.id).toBe(3);
-    expect(results[5].b.id).toBe(4);
-    expect(results[5].r.length).toBe(undefined);
-    expect(results[5].r.startNode.id).toBe(3);
-    expect(results[5].r.endNode.id).toBe(4);
+    // Person 4's result: zero-hop only
+    expect(results[9].a.id).toBe(4);
+    expect(results[9].b.id).toBe(4);
 });
 
 test("Test return match pattern with variable length relationships", async () => {
@@ -1100,55 +1098,48 @@ test("Test return match pattern with variable length relationships", async () =>
     `);
     await match.run();
     const results = match.results;
-    expect(results.length).toBe(6);
+    expect(results.length).toBe(10);
 
-    expect(results[0].pattern.length).toBe(3);
+    // Index 0: Person 1 zero-hop - pattern = [node1] (single node, no duplicate)
+    expect(results[0].pattern.length).toBe(1);
     expect(results[0].pattern[0].id).toBe(1);
-    expect(results[0].pattern[1].startNode.id).toBe(1);
-    expect(results[0].pattern[1].endNode.id).toBe(2);
-    expect(results[0].pattern[2].id).toBe(2);
 
-    expect(results[1].pattern.length).toBe(5);
+    // Index 1: Person 1 -> Person 2 (1-hop): pattern = [node1, rel, node2]
+    expect(results[1].pattern.length).toBe(3);
     expect(results[1].pattern[0].id).toBe(1);
     expect(results[1].pattern[1].startNode.id).toBe(1);
     expect(results[1].pattern[1].endNode.id).toBe(2);
     expect(results[1].pattern[2].id).toBe(2);
-    expect(results[1].pattern[3].startNode.id).toBe(2);
-    expect(results[1].pattern[3].endNode.id).toBe(3);
-    expect(results[1].pattern[4].id).toBe(3);
 
-    expect(results[2].pattern.length).toBe(7);
+    // Index 2: Person 1 -> Person 3 (2-hop): pattern length = 5
+    expect(results[2].pattern.length).toBe(5);
     expect(results[2].pattern[0].id).toBe(1);
-    expect(results[2].pattern[1].startNode.id).toBe(1);
-    expect(results[2].pattern[1].endNode.id).toBe(2);
-    expect(results[2].pattern[2].id).toBe(2);
-    expect(results[2].pattern[3].startNode.id).toBe(2);
-    expect(results[2].pattern[3].endNode.id).toBe(3);
-    expect(results[2].pattern[4].id).toBe(3);
-    expect(results[2].pattern[5].startNode.id).toBe(3);
-    expect(results[2].pattern[5].endNode.id).toBe(4);
-    expect(results[2].pattern[6].id).toBe(4);
-
-    expect(results[3].pattern.length).toBe(3);
-    expect(results[3].pattern[0].id).toBe(2);
-    expect(results[3].pattern[1].startNode.id).toBe(2);
-    expect(results[3].pattern[1].endNode.id).toBe(3);
-    expect(results[3].pattern[2].id).toBe(3);
-
-    expect(results[4].pattern.length).toBe(5);
+
+    // Index 3: Person 1 -> Person 4 (3-hop): pattern length = 7
+    expect(results[3].pattern.length).toBe(7);
+    expect(results[3].pattern[0].id).toBe(1);
+    expect(results[3].pattern[6].id).toBe(4);
+
+    // Index 4: Person 2 zero-hop - pattern = [node2] (single node)
+    expect(results[4].pattern.length).toBe(1);
     expect(results[4].pattern[0].id).toBe(2);
-    expect(results[4].pattern[1].startNode.id).toBe(2);
-    expect(results[4].pattern[1].endNode.id).toBe(3);
-    expect(results[4].pattern[2].id).toBe(3);
-    expect(results[4].pattern[3].startNode.id).toBe(3);
-    expect(results[4].pattern[3].endNode.id).toBe(4);
-    expect(results[4].pattern[4].id).toBe(4);
 
+    // Index 5: Person 2 -> Person 3 (1-hop)
     expect(results[5].pattern.length).toBe(3);
-    expect(results[5].pattern[0].id).toBe(3);
-    expect(results[5].pattern[1].startNode.id).toBe(3);
-    expect(results[5].pattern[1].endNode.id).toBe(4);
-    expect(results[5].pattern[2].id).toBe(4);
+
+    // Index 6: Person 2 -> Person 4 (2-hop)
+    expect(results[6].pattern.length).toBe(5);
+
+    // Index 7: Person 3 zero-hop - pattern = [node3] (single node)
+    expect(results[7].pattern.length).toBe(1);
+    expect(results[7].pattern[0].id).toBe(3);
+
+    // Index 8: Person 3 -> Person 4 (1-hop)
+    expect(results[8].pattern.length).toBe(3);
+
+    // Index 9: Person 4 zero-hop - pattern = [node4] (single node)
+    expect(results[9].pattern.length).toBe(1);
+    expect(results[9].pattern[0].id).toBe(4);
 });
 
 test("Test statement with graph pattern in where clause", async () => {
@@ -1270,7 +1261,8 @@ test("Test manager chain", async () => {
     `);
     await match.run();
     const results = match.results;
-    expect(results.length).toBe(2);
+    // 4 results: includes CEO (Employee 1) with zero-hop match (empty management chain)
+    expect(results.length).toBe(4);
 });
 
 test("Test equality comparison", async () => {
@@ -1290,3 +1282,181 @@ test("Test equality comparison", async () => {
         }
     }
 });
+
+test("Test match with constraints", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Employee) AS {
+            unwind [
+                {id: 1, name: 'Employee 1'},
+                {id: 2, name: 'Employee 2'},
+                {id: 3, name: 'Employee 3'},
+                {id: 4, name: 'Employee 4'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    const match = new Runner(`
+        match (e:Employee{name:'Employee 1'})
+        return e.name as name
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(1);
+    expect(results[0].name).toBe("Employee 1");
+});
+
+test("Test match with leftward relationship direction", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind [
+                {id: 1, name: 'Person 1'},
+                {id: 2, name: 'Person 2'},
+                {id: 3, name: 'Person 3'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Person)-[:REPORTS_TO]-(:Person) AS {
+            unwind [
+                {left_id: 2, right_id: 1},
+                {left_id: 3, right_id: 1}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    // Rightward: left_id -> right_id (2->1, 3->1)
+    const rightMatch = new Runner(`
+        MATCH (a:Person)-[:REPORTS_TO]->(b:Person)
+        RETURN a.name AS employee, b.name AS manager
+    `);
+    await rightMatch.run();
+    const rightResults = rightMatch.results;
+    expect(rightResults.length).toBe(2);
+    expect(rightResults[0]).toEqual({ employee: "Person 2", manager: "Person 1" });
+    expect(rightResults[1]).toEqual({ employee: "Person 3", manager: "Person 1" });
+
+    // Leftward: right_id -> left_id (1->2, 1->3) — reverse traversal
+    const leftMatch = new Runner(`
+        MATCH (m:Person)<-[:REPORTS_TO]-(e:Person)
+        RETURN m.name AS manager, e.name AS employee
+    `);
+    await leftMatch.run();
+    const leftResults = leftMatch.results;
+    expect(leftResults.length).toBe(2);
+    expect(leftResults[0]).toEqual({ manager: "Person 1", employee: "Person 2" });
+    expect(leftResults[1]).toEqual({ manager: "Person 1", employee: "Person 3" });
+});
+
+test("Test match with leftward direction produces same results as rightward with swapped data", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:City) AS {
+            unwind [
+                {id: 1, name: 'New York'},
+                {id: 2, name: 'Boston'},
+                {id: 3, name: 'Chicago'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:City)-[:ROUTE]-(:City) AS {
+            unwind [
+                {left_id: 1, right_id: 2},
+                {left_id: 1, right_id: 3}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    // Leftward from destination: find where right_id matches, follow left_id
+    const match = new Runner(`
+        MATCH (dest:City)<-[:ROUTE]-(origin:City)
+        RETURN dest.name AS destination, origin.name AS origin
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ destination: "Boston", origin: "New York" });
+    expect(results[1]).toEqual({ destination: "Chicago", origin: "New York" });
+});
+
+test("Test match with leftward variable-length relationships", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind [
+                {id: 1, name: 'Person 1'},
+                {id: 2, name: 'Person 2'},
+                {id: 3, name: 'Person 3'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Person)-[:MANAGES]-(:Person) AS {
+            unwind [
+                {left_id: 1, right_id: 2},
+                {left_id: 2, right_id: 3}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    // Leftward variable-length: traverse from right_id to left_id
+    // Person 3 can reach Person 2 (1 hop) and Person 1 (2 hops)
+    const match = new Runner(`
+        MATCH (a:Person)<-[:MANAGES*]-(b:Person)
+        RETURN a.name AS name1, b.name AS name2
+    `);
+    await match.run();
+    const results = match.results;
+    // Zero-hop results for all 3 persons + multi-hop results
+    // Leftward indexes on right_id. find(id) looks up right_id=id, follows left_id.
+    // right_id=1: no records → Person 1 zero-hop only
+    // right_id=2: record {left_id:1, right_id:2} → Person 2 → Person 1, then recurse find(1) → no more
+    // right_id=3: record {left_id:2, right_id:3} → Person 3 → Person 2, then recurse find(2) → Person 1
+    expect(results.length).toBe(6);
+    // Person 1: zero-hop
+    expect(results[0]).toEqual({ name1: "Person 1", name2: "Person 1" });
+    // Person 2: zero-hop, then reaches Person 1
+    expect(results[1]).toEqual({ name1: "Person 2", name2: "Person 2" });
+    expect(results[2]).toEqual({ name1: "Person 2", name2: "Person 1" });
+    // Person 3: zero-hop, then reaches Person 2, then Person 1
+    expect(results[3]).toEqual({ name1: "Person 3", name2: "Person 3" });
+    expect(results[4]).toEqual({ name1: "Person 3", name2: "Person 2" });
+    expect(results[5]).toEqual({ name1: "Person 3", name2: "Person 1" });
+});
+
+test("Test match with leftward double graph pattern", async () => {
+    await new Runner(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind [
+                {id: 1, name: 'Person 1'},
+                {id: 2, name: 'Person 2'},
+                {id: 3, name: 'Person 3'},
+                {id: 4, name: 'Person 4'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+    await new Runner(`
+        CREATE VIRTUAL (:Person)-[:KNOWS]-(:Person) AS {
+            unwind [
+                {left_id: 1, right_id: 2},
+                {left_id: 2, right_id: 3},
+                {left_id: 3, right_id: 4}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+    // Leftward chain: (c)<-[:KNOWS]-(b)<-[:KNOWS]-(a)
+    // First rel: find right_id=c, follow left_id to b
+    // Second rel: find right_id=b, follow left_id to a
+    const match = new Runner(`
+        MATCH (c:Person)<-[:KNOWS]-(b:Person)<-[:KNOWS]-(a:Person)
+        RETURN a.name AS name1, b.name AS name2, c.name AS name3
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ name1: "Person 1", name2: "Person 2", name3: "Person 3" });
+    expect(results[1]).toEqual({ name1: "Person 2", name2: "Person 3", name3: "Person 4" });
+});

package/tests/parsing/parser.test.ts

@@ -760,3 +760,35 @@ test("Test check pattern expression without NodeReference", () => {
         parser.parse("MATCH (a:Person) WHERE (:Person)-[:KNOWS]->(:Person) RETURN a");
     }).toThrow("PatternExpression must contain at least one NodeReference");
 });
+
+test("Test node with properties", () => {
+    const parser = new Parser();
+    const ast = parser.parse("MATCH (a:Person{value: 'hello'}) return a");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- Match\n" +
+        "- Return\n" +
+        "-- Expression (a)\n" +
+        "--- Reference (a)"
+    );
+    const match: Match = ast.firstChild() as Match;
+    const node: Node = match.patterns[0].chain[0] as Node;
+    expect(node.properties.get("value")?.value()).toBe("hello");
+});
+
+test("Test relationship with properties", () => {
+    const parser = new Parser();
+    const ast = parser.parse("MATCH (:Person)-[r:LIKES{since: 2022}]->(:Food) return a");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- Match\n" +
+        "- Return\n" +
+        "-- Expression (a)\n" +
+        "--- Reference (a)"
+    );
+    const match: Match = ast.firstChild() as Match;
+    const relationship: Relationship = match.patterns[0].chain[1] as Relationship;
+    expect(relationship.properties.get("since")?.value()).toBe(2022);
+});