flowquery 1.0.38 → 1.0.40

package/tests/compute/runner.test.ts

@@ -1,6 +1,7 @@
 import Runner from "../../src/compute/runner";
 import Database from "../../src/graph/database";
 import Node from "../../src/graph/node";
+import Relationship from "../../src/graph/relationship";
 import AsyncFunction from "../../src/parsing/functions/async_function";
 import { FunctionDef } from "../../src/parsing/functions/function_metadata";
 
@@ -725,6 +726,38 @@ test("Test trim function with empty string", async () => {
     expect(results[0]).toEqual({ result: "" });
 });
 
+test("Test substring function with start and length", async () => {
+    const runner = new Runner('RETURN substring("hello", 1, 3) as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "ell" });
+});
+
+test("Test substring function with start only", async () => {
+    const runner = new Runner('RETURN substring("hello", 2) as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "llo" });
+});
+
+test("Test substring function with zero start", async () => {
+    const runner = new Runner('RETURN substring("hello", 0, 5) as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "hello" });
+});
+
+test("Test substring function with zero length", async () => {
+    const runner = new Runner('RETURN substring("hello", 1, 0) as result');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ result: "" });
+});
+
 test("Test associative array with key which is keyword", async () => {
     const runner = new Runner("RETURN {return: 1} as aa");
     await runner.run();
@@ -2548,6 +2581,54 @@ test("Test WHERE with IN combined with AND", async () => {
     expect(results.map((r: any) => r.n)).toEqual([10, 15, 20]);
 });
 
+test("Test WHERE with AND before IN", async () => {
+    const runner = new Runner(`
+        unwind ['expert', 'intermediate', 'beginner'] as proficiency
+        with proficiency where 1=1 and proficiency in ['expert']
+        return proficiency
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ proficiency: "expert" });
+});
+
+test("Test WHERE with AND before NOT IN", async () => {
+    const runner = new Runner(`
+        unwind ['expert', 'intermediate', 'beginner'] as proficiency
+        with proficiency where 1=1 and proficiency not in ['expert']
+        return proficiency
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results.map((r: any) => r.proficiency)).toEqual(["intermediate", "beginner"]);
+});
+
+test("Test WHERE with OR before IN", async () => {
+    const runner = new Runner(`
+        unwind range(1, 10) as n
+        with n where 1=0 or n in [3, 7]
+        return n
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results.map((r: any) => r.n)).toEqual([3, 7]);
+});
+
+test("Test IN as return expression with AND in WHERE", async () => {
+    const runner = new Runner(`
+        unwind ['expert', 'intermediate', 'beginner'] as proficiency
+        with proficiency where 1=1 and proficiency in ['expert']
+        return proficiency, proficiency in ['expert'] as isExpert
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ proficiency: "expert", isExpert: 1 });
+});
+
 test("Test WHERE with CONTAINS", async () => {
     const runner = new Runner(`
         unwind ['apple', 'banana', 'grape', 'pineapple'] as fruit
@@ -3759,3 +3840,213 @@ test("Test duration() with time only", async () => {
     expect(d.totalSeconds).toBe(9000);
     expect(d.formatted).toBe("PT2H30M");
 });
+
+// ORDER BY tests
+
+test("Test order by ascending", async () => {
+    const runner = new Runner("unwind [3, 1, 2] as x return x order by x");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ x: 1 });
+    expect(results[1]).toEqual({ x: 2 });
+    expect(results[2]).toEqual({ x: 3 });
+});
+
+test("Test order by descending", async () => {
+    const runner = new Runner("unwind [3, 1, 2] as x return x order by x desc");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ x: 3 });
+    expect(results[1]).toEqual({ x: 2 });
+    expect(results[2]).toEqual({ x: 1 });
+});
+
+test("Test order by ascending explicit", async () => {
+    const runner = new Runner("unwind [3, 1, 2] as x return x order by x asc");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ x: 1 });
+    expect(results[1]).toEqual({ x: 2 });
+    expect(results[2]).toEqual({ x: 3 });
+});
+
+test("Test order by with multiple fields", async () => {
+    const runner = new Runner(`
+        unwind [{name: 'Alice', age: 30}, {name: 'Bob', age: 25}, {name: 'Alice', age: 25}] as person
+        return person.name as name, person.age as age
+        order by name asc, age asc
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ name: "Alice", age: 25 });
+    expect(results[1]).toEqual({ name: "Alice", age: 30 });
+    expect(results[2]).toEqual({ name: "Bob", age: 25 });
+});
+
+test("Test order by with strings", async () => {
+    const runner = new Runner(
+        "unwind ['banana', 'apple', 'cherry'] as fruit return fruit order by fruit"
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ fruit: "apple" });
+    expect(results[1]).toEqual({ fruit: "banana" });
+    expect(results[2]).toEqual({ fruit: "cherry" });
+});
+
+test("Test order by with aggregated return", async () => {
+    const runner = new Runner(`
+        unwind [1, 1, 2, 2, 3, 3] as x
+        return x, count(x) as cnt
+        order by x desc
+    `);
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ x: 3, cnt: 2 });
+    expect(results[1]).toEqual({ x: 2, cnt: 2 });
+    expect(results[2]).toEqual({ x: 1, cnt: 2 });
+});
+
+test("Test order by with limit", async () => {
+    const runner = new Runner("unwind [3, 1, 4, 1, 5, 9, 2, 6] as x return x order by x limit 3");
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ x: 1 });
+    expect(results[1]).toEqual({ x: 1 });
+    expect(results[2]).toEqual({ x: 2 });
+});
+
+test("Test order by with where", async () => {
+    const runner = new Runner(
+        "unwind [3, 1, 4, 1, 5, 9, 2, 6] as x return x where x > 2 order by x desc"
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(5);
+    expect(results[0]).toEqual({ x: 9 });
+    expect(results[1]).toEqual({ x: 6 });
+    expect(results[2]).toEqual({ x: 5 });
+    expect(results[3]).toEqual({ x: 4 });
+    expect(results[4]).toEqual({ x: 3 });
+});
+
+test("Test delete virtual node operation", async () => {
+    const db = Database.getInstance();
+    // Create a virtual node first
+    const create = new Runner(`
+        CREATE VIRTUAL (:DeleteTestPerson) AS {
+            unwind [
+                {id: 1, name: 'Person 1'},
+                {id: 2, name: 'Person 2'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `);
+    await create.run();
+    expect(db.getNode(new Node(null, "DeleteTestPerson"))).not.toBeNull();
+
+    // Delete the virtual node
+    const del = new Runner("DELETE VIRTUAL (:DeleteTestPerson)");
+    await del.run();
+    expect(del.results.length).toBe(0);
+    expect(db.getNode(new Node(null, "DeleteTestPerson"))).toBeNull();
+});
+
+test("Test delete virtual node then match throws", async () => {
+    // Create a virtual node
+    const create = new Runner(`
+        CREATE VIRTUAL (:DeleteMatchPerson) AS {
+            unwind [{id: 1, name: 'Alice'}] as record
+            RETURN record.id as id, record.name as name
+        }
+    `);
+    await create.run();
+
+    // Verify it can be matched
+    const match1 = new Runner("MATCH (n:DeleteMatchPerson) RETURN n");
+    await match1.run();
+    expect(match1.results.length).toBe(1);
+
+    // Delete the virtual node
+    const del = new Runner("DELETE VIRTUAL (:DeleteMatchPerson)");
+    await del.run();
+
+    // Matching should now throw since the node is gone
+    const match2 = new Runner("MATCH (n:DeleteMatchPerson) RETURN n");
+    await expect(match2.run()).rejects.toThrow();
+});
+
+test("Test delete virtual relationship operation", async () => {
+    const db = Database.getInstance();
+    // Create virtual nodes and relationship
+    await new Runner(`
+        CREATE VIRTUAL (:DelRelUser) AS {
+            unwind [
+                {id: 1, name: 'Alice'},
+                {id: 2, name: 'Bob'}
+            ] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+
+    await new Runner(`
+        CREATE VIRTUAL (:DelRelUser)-[:DEL_KNOWS]-(:DelRelUser) AS {
+            unwind [
+                {left_id: 1, right_id: 2}
+            ] as record
+            RETURN record.left_id as left_id, record.right_id as right_id
+        }
+    `).run();
+
+    // Verify relationship exists
+    const rel = new Relationship();
+    rel.type = "DEL_KNOWS";
+    expect(db.getRelationship(rel)).not.toBeNull();
+
+    // Delete the virtual relationship
+    const del = new Runner("DELETE VIRTUAL (:DelRelUser)-[:DEL_KNOWS]-(:DelRelUser)");
+    await del.run();
+    expect(del.results.length).toBe(0);
+    expect(db.getRelationship(rel)).toBeNull();
+});
+
+test("Test delete virtual node leaves other nodes intact", async () => {
+    const db = Database.getInstance();
+    // Create two virtual node types
+    await new Runner(`
+        CREATE VIRTUAL (:KeepNode) AS {
+            unwind [{id: 1, name: 'Keep'}] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+
+    await new Runner(`
+        CREATE VIRTUAL (:RemoveNode) AS {
+            unwind [{id: 2, name: 'Remove'}] as record
+            RETURN record.id as id, record.name as name
+        }
+    `).run();
+
+    expect(db.getNode(new Node(null, "KeepNode"))).not.toBeNull();
+    expect(db.getNode(new Node(null, "RemoveNode"))).not.toBeNull();
+
+    // Delete only one
+    await new Runner("DELETE VIRTUAL (:RemoveNode)").run();
+
+    // The other should still exist
+    expect(db.getNode(new Node(null, "KeepNode"))).not.toBeNull();
+    expect(db.getNode(new Node(null, "RemoveNode"))).toBeNull();
+
+    // The remaining node can still be matched
+    const match = new Runner("MATCH (n:KeepNode) RETURN n");
+    await match.run();
+    expect(match.results.length).toBe(1);
+    expect(match.results[0].n.name).toBe("Keep");
+});

package/tests/parsing/parser.test.ts

@@ -521,7 +521,7 @@ test("Test non-well formed statements", () => {
         "Only one RETURN statement is allowed"
     );
     expect(() => new Parser().parse("return 1 with 1 as n")).toThrow(
-        "Last statement must be a RETURN, WHERE, CALL, or CREATE statement"
+        "Last statement must be a RETURN, WHERE, CALL, CREATE, or DELETE statement"
     );
 });