flowquery 1.0.30 → 1.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowquery",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "A declarative query language for data processing pipelines.",
   "main": "dist/index.node.js",
   "types": "dist/index.node.d.ts",

package/src/graph/node_reference.ts

@@ -1,8 +1,9 @@
+import ASTNode from "../parsing/ast_node";
 import Node from "./node";
 
 class NodeReference extends Node {
-    private _reference: Node | null = null;
-    constructor(base: Node, reference: Node) {
+    private _reference: ASTNode | null = null;
+    constructor(base: Node, reference: ASTNode) {
         super();
         this._identifier = base.identifier;
         this._label = base.label;
@@ -11,7 +12,7 @@ class NodeReference extends Node {
         this._incoming = base.incoming;
         this._reference = reference;
     }
-    public get reference(): Node | null {
+    public get reference(): ASTNode | null {
         return this._reference;
     }
     public async next(): Promise<void> {

package/src/graph/relationship.ts

@@ -71,8 +71,8 @@ class Relationship extends ASTNode {
     public get hops(): Hops | null {
         return this._hops;
     }
-    public setValue(relationship: Relationship): void {
-        const match: RelationshipMatchRecord = this._matches.push(relationship);
+    public setValue(relationship: Relationship, traversalId: string = ""): void {
+        const match: RelationshipMatchRecord = this._matches.push(relationship, traversalId);
         this._value = this._matches.value();
     }
     public set source(node: Node | null) {
@@ -108,10 +108,12 @@ class Relationship extends ASTNode {
     public setEndNode(node: Node): void {
         this._matches.endNode = node;
     }
+    public _left_id_or_right_id(): string {
+        return this._direction === "left" ? "left_id" : "right_id";
+    }
     public async find(left_id: string, hop: number = 0): Promise<void> {
         // Save original source node
         const original = this._source;
-        const isLeft = this._direction === "left";
         if (hop > 0) {
             // For hops greater than 0, the source becomes the target of the previous hop
             this._source = this._target;
@@ -127,28 +129,26 @@ class Relationship extends ASTNode {
                 await this._target.find(left_id, hop);
             }
         }
-        const findMatch = isLeft
-            ? (id: string, h: number) => this._data!.findReverse(id, h)
-            : (id: string, h: number) => this._data!.find(id, h);
-        const followId = isLeft ? "left_id" : "right_id";
-        while (findMatch(left_id, hop)) {
+        while (this._data!.find(left_id, hop, this._direction)) {
             const data: RelationshipRecord = this._data?.current(hop) as RelationshipRecord;
+            const id = data[this._left_id_or_right_id()];
             if (hop + 1 >= this.hops!.min) {
-                this.setValue(this);
+                this.setValue(this, left_id);
                 if (!this._matchesProperties(hop)) {
                     continue;
                 }
-                await this._target?.find(data[followId], hop);
-                if (this._matches.isCircular()) {
-                    throw new Error("Circular relationship detected");
-                }
+                await this._target?.find(id, hop);
                 if (hop + 1 < this.hops!.max) {
-                    await this.find(data[followId], hop + 1);
+                    if (this._matches.isCircular(id)) {
+                        this._matches.pop();
+                        continue;
+                    }
+                    await this.find(id, hop + 1);
                 }
                 this._matches.pop();
             } else {
                 // Below minimum hops: traverse the edge without yielding a match
-                await this.find(data[followId], hop + 1);
+                await this.find(id, hop + 1);
             }
         }
         // Restore original source node

package/src/graph/relationship_data.ts

@@ -8,11 +8,8 @@ class RelationshipData extends Data {
         super._buildIndex("left_id");
         super._buildIndex("right_id");
     }
-    public find(left_id: string, hop: number = 0): boolean {
-        return super._find(left_id, hop, "left_id");
-    }
-    public findReverse(right_id: string, hop: number = 0): boolean {
-        return super._find(right_id, hop, "right_id");
+    public find(id: string, hop: number = 0, direction: "left" | "right" = "right"): boolean {
+        return super._find(id, hop, direction === "left" ? "right_id" : "left_id");
     }
     /*
     ** Get the properties of the current relationship record

package/src/graph/relationship_match_collector.ts

@@ -11,7 +11,7 @@ class RelationshipMatchCollector {
     private _matches: RelationshipMatchRecord[] = [];
     private _nodeIds: Array<string> = [];
 
-    public push(relationship: Relationship): RelationshipMatchRecord {
+    public push(relationship: Relationship, traversalId: string): RelationshipMatchRecord {
         const match: RelationshipMatchRecord = {
             type: relationship.type!,
             startNode: relationship.source?.value() || {},
@@ -19,7 +19,7 @@ class RelationshipMatchCollector {
             properties: relationship.getData()?.properties() as Record<string, any>,
         };
         this._matches.push(match);
-        this._nodeIds.push(match.startNode.id);
+        this._nodeIds.push(traversalId);
         return match;
     }
     public set endNode(node: any) {
@@ -46,12 +46,11 @@ class RelationshipMatchCollector {
         return this._matches;
     }
     /*
-     ** Checks if the collected relationships form a circular pattern
-     ** meaning the same node id occur more than 2 times in the collected matches
+     ** Checks if traversing to the given node id would form a cycle
+     ** in the current traversal path
      */
-    public isCircular(): boolean {
-        const seen = new Set(this._nodeIds);
-        return seen.size < this._nodeIds.length;
+    public isCircular(nextId: string): boolean {
+        return this._nodeIds.includes(nextId);
     }
 }
 

package/src/parsing/operations/group_by.ts

@@ -50,10 +50,10 @@ class GroupBy extends Projection {
     }
     private map() {
         let node: Node = this.current;
-        for(const mapper of this.mappers) {
+        for (const mapper of this.mappers) {
             const value: any = mapper.value();
             let child: Node | undefined = node.children.get(value);
-            if(child === undefined) {
+            if (child === undefined) {
                 child = new Node(value);
                 node.children.set(value, child);
             }
@@ -62,8 +62,8 @@ class GroupBy extends Projection {
         this.current = node;
     }
     private reduce() {
-        if(this.current.elements === null) {
-            this.current.elements = this.reducers.map(reducer => reducer.element());
+        if (this.current.elements === null) {
+            this.current.elements = this.reducers.map((reducer) => reducer.element());
         }
         const elements: AggregationElement[] = this.current.elements;
         this.reducers.forEach((reducer, index) => {
@@ -71,29 +71,37 @@ class GroupBy extends Projection {
         });
     }
     private get mappers(): Expression[] {
-        if(this._mappers === null) {
+        if (this._mappers === null) {
             this._mappers = [...this._generate_mappers()];
         }
         return this._mappers;
     }
     private *_generate_mappers(): Generator<Expression> {
-        for(const [expression, _] of this.expressions()) {
-            if(expression.mappable()) {
+        for (const [expression, _] of this.expressions()) {
+            if (expression.mappable()) {
                 yield expression;
             }
         }
     }
     private get reducers(): AggregateFunction[] {
-        if(this._reducers === null) {
-            this._reducers = this.children.map((child) => {
-                return (child as Expression).reducers();
-            }).flat();
+        if (this._reducers === null) {
+            this._reducers = this.children
+                .map((child) => {
+                    return (child as Expression).reducers();
+                })
+                .flat();
         }
         return this._reducers;
     }
-    public *generate_results(mapperIndex: number = 0, node: Node = this.root): Generator<Record<string, any>> {
-        if(node.children.size > 0) {
-            for(const child of node.children.values()) {
+    public *generate_results(
+        mapperIndex: number = 0,
+        node: Node = this.root
+    ): Generator<Record<string, any>> {
+        if (mapperIndex === 0 && node.children.size === 0 && this.mappers.length > 0) {
+            return;
+        }
+        if (node.children.size > 0) {
+            for (const child of node.children.values()) {
                 this.mappers[mapperIndex].overridden = child.value;
                 yield* this.generate_results(mapperIndex + 1, child);
             }
@@ -102,10 +110,10 @@ class GroupBy extends Projection {
                 this.reducers[reducerIndex].overridden = element.value;
             });
             const record: Record<string, any> = {};
-            for(const [expression, alias] of this.expressions()) {
+            for (const [expression, alias] of this.expressions()) {
                 record[alias] = expression.value();
             }
-            if(this.where) {
+            if (this.where) {
                 yield record;
             }
         }
@@ -114,11 +122,11 @@ class GroupBy extends Projection {
         this._where = where;
     }
     public get where(): boolean {
-        if(this._where === null) {
+        if (this._where === null) {
             return true;
         }
         return this._where.value();
     }
-};
+}
 
-export default GroupBy;
+export default GroupBy;

package/src/parsing/parser.ts

@@ -467,7 +467,10 @@ class Parser extends BaseParser {
                     reference = inner;
                 }
             }
-            if (reference === undefined || !(reference instanceof Node)) {
+            if (
+                reference === undefined ||
+                (!(reference instanceof Node) && !(reference instanceof Unwind))
+            ) {
                 throw new Error(`Undefined node reference: ${identifier}`);
             }
             node = new NodeReference(node, reference);

package/tests/compute/runner.test.ts

@@ -334,6 +334,20 @@ test("Test aggregated with and return", async () => {
     expect(results[1]).toEqual({ i: 2, sum: 12 });
 });
 
+test("Test aggregated with on empty result set", async () => {
+    const runner = new Runner(
+        `
+        unwind [] as i
+        unwind [1, 2] as j
+        with i, count(j) as cnt
+        return i, cnt
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(0);
+});
+
 test("Test aggregated with using collect and return", async () => {
     const runner = new Runner(
         `
@@ -1138,7 +1152,7 @@ test("Test circular graph pattern", async () => {
     expect(results[0].pattern[4].id).toBe(1);
 });
 
-test("Test circular graph pattern with variable length should throw error", async () => {
+test("Test circular graph pattern with variable length should not revisit nodes", async () => {
     await new Runner(`
         CREATE VIRTUAL (:Person) AS {
             unwind [
@@ -1161,9 +1175,10 @@ test("Test circular graph pattern with variable length should throw error", asyn
         MATCH p=(:Person)-[:KNOWS*]-(:Person)
         RETURN p AS pattern
     `);
-    await expect(async () => {
-        await match.run();
-    }).rejects.toThrow("Circular relationship detected");
+    await match.run();
+    const results = match.results;
+    // Circular graph 1↔2: cycles are skipped, only acyclic paths are returned
+    expect(results.length).toBe(6);
 });
 
 test("Test multi-hop match with min hops constraint *1..", async () => {
@@ -2064,3 +2079,107 @@ test("Test WHERE with CONTAINS combined with AND", async () => {
     expect(results.length).toBe(1);
     expect(results[0].fruit).toBe("pineapple");
 });
+
+test("Test collected nodes and re-matching", 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();
+    const match = new Runner(`
+        MATCH (a:Person)-[:KNOWS*0..3]->(b:Person)
+        WITH collect(a) AS persons, b
+        UNWIND persons AS p
+        match (p)-[:KNOWS]->(:Person)
+        return p.name AS name
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(9);
+    const names = results.map((r: any) => r.name);
+    expect(names).toContain("Person 1");
+    expect(names).toContain("Person 2");
+    expect(names).toContain("Person 3");
+});
+
+test("Test collected patterns and unwind", 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();
+    const match = new Runner(`
+        MATCH p=(a:Person)-[:KNOWS*0..3]->(b:Person)
+        WITH collect(p) AS patterns
+        UNWIND patterns AS pattern
+        RETURN pattern
+    `);
+    await match.run();
+    const results = match.results;
+    expect(results.length).toBe(10);
+    // Index 0: Person 1 zero-hop - pattern = [node1] (single node)
+    expect(results[0].pattern.length).toBe(1);
+    expect(results[0].pattern[0].id).toBe(1);
+
+    // Index 1: Person 1 -> Person 2 (1-hop)
+    expect(results[1].pattern.length).toBe(3);
+
+    // Index 2: Person 1 -> Person 2 -> Person 3 (2-hop)
+    expect(results[2].pattern.length).toBe(5);
+
+    // Index 3: Person 1 -> Person 2 -> Person 3 -> Person 4 (3-hop)
+    expect(results[3].pattern.length).toBe(7);
+
+    // Index 4: Person 2 zero-hop - pattern = [node2]
+    expect(results[4].pattern.length).toBe(1);
+    expect(results[4].pattern[0].id).toBe(2);
+
+    // Index 5: Person 2 -> Person 3 (1-hop)
+    expect(results[5].pattern.length).toBe(3);
+
+    // Index 6: Person 2 -> Person 3 -> Person 4 (2-hop)
+    expect(results[6].pattern.length).toBe(5);
+
+    // Index 7: Person 3 zero-hop - pattern = [node3]
+    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]
+    expect(results[9].pattern.length).toBe(1);
+    expect(results[9].pattern[0].id).toBe(4);
+});

package/tests/parsing/parser.test.ts

@@ -839,7 +839,7 @@ test("Parse statement with graph pattern in where clause", () => {
     const source = pattern.chain[0] as NodeReference;
     const relationship = pattern.chain[1] as Relationship;
     const target = pattern.chain[2] as Node;
-    expect(source.reference?.identifier).toBe("a");
+    expect((source.reference as Node)?.identifier).toBe("a");
     expect(relationship.type).toBe("KNOWS");
     expect(target.label).toBe("Person");
 });
@@ -909,7 +909,7 @@ test("Test node reference with label creates NodeReference instead of new node",
     expect(firstNode.identifier).toBe("n");
     expect(firstNode.label).toBe("Person");
     expect(secondNode).toBeInstanceOf(NodeReference);
-    expect(secondNode.reference!.identifier).toBe("n");
+    expect((secondNode.reference! as Node).identifier).toBe("n");
     expect(secondNode.label).toBe("Person");
 });