flowquery 1.0.15 → 1.0.17

package/tests/graph/match.test.ts

@@ -0,0 +1,29 @@
+import Runner from "../../src/compute/runner";
+import PhysicalNode from "../../src/graph/physical_node";
+import CreateNode from "../../src/parsing/operations/create_node";
+import Parser from "../../src/parsing/parser";
+
+test("Test CreateNode and match operations", async () => {
+    const node = new PhysicalNode(null, "Person");
+    expect(node.label).toBe("Person");
+    expect(node.statement).toBeNull();
+    const parser = new Parser();
+    const statement = parser.parse(`
+        unwind [
+            {id: 1, name: 'Person 1'},
+            {id: 2, name: 'Person 2'}
+        ] as record
+        RETURN record.id as id, record.name as name
+    `);
+    const op = new CreateNode(node, statement);
+    await op.run();
+    const runner = new Runner("match (n:Person) RETURN n");
+    await runner.run();
+    expect(runner.results.length).toBe(2);
+    expect(runner.results[0].n).toBeDefined();
+    expect(runner.results[0].n.id).toBe(1);
+    expect(runner.results[0].n.name).toBe("Person 1");
+    expect(runner.results[1].n).toBeDefined();
+    expect(runner.results[1].n.id).toBe(2);
+    expect(runner.results[1].n.name).toBe("Person 2");
+});

package/tests/parsing/parser.test.ts

@@ -1,8 +1,11 @@
+import Node from "../../src/graph/node";
+import NodeReference from "../../src/graph/node_reference";
+import Relationship from "../../src/graph/relationship";
 import AsyncFunction from "../../src/parsing/functions/async_function";
-import {
-    FunctionDef,
-    getRegisteredFunctionFactory,
-} from "../../src/parsing/functions/function_metadata";
+import { FunctionDef } from "../../src/parsing/functions/function_metadata";
+import CreateNode from "../../src/parsing/operations/create_node";
+import CreateRelationship from "../../src/parsing/operations/create_relationship";
+import Match from "../../src/parsing/operations/match";
 import Parser from "../../src/parsing/parser";
 
 // Test class for CALL operation parsing test - defined at module level for Prettier compatibility
@@ -12,7 +15,7 @@ import Parser from "../../src/parsing/parser";
     parameters: [],
     output: { description: "Yields test values", type: "any" },
 })
-class CallParserTestFunction extends AsyncFunction {
+class Test extends AsyncFunction {
     constructor() {
         super();
         this._expectedParameterCount = 0;
@@ -427,7 +430,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, or a CALL statement"
+        "Last statement must be a RETURN, WHERE, CALL, or CREATE statement"
     );
 });
 
@@ -468,12 +471,18 @@ test("Test limit", () => {
 test("Test return -2", () => {
     const parser = new Parser();
     const ast = parser.parse("return -2");
-    expect(ast.print()).toBe("ASTNode\n" + "- Return\n" + "-- Expression\n" + "--- Number (-2)");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- Return\n" +
+        "-- Expression\n" +
+        "--- Number (-2)"
+    );
 });
 
 test("Test call operation", () => {
     const parser = new Parser();
-    const ast = parser.parse("CALL callparsertestfunction() YIELD result RETURN result");
+    const ast = parser.parse("CALL test() YIELD result RETURN result");
     expect(ast.print()).toBe(
         "ASTNode\n" +
             "- Call\n" +
@@ -484,3 +493,262 @@ test("Test call operation", () => {
             "--- Reference (result)"
     );
 });
+
+test("Test f-string", () => {
+    const parser = new Parser();
+    const ast = parser.parse("with 1 as value RETURN f'Value is: {value}.'");
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+            "- With\n" +
+            "-- Expression (value)\n" +
+            "--- Number (1)\n" +
+            "- Return\n" +
+            "-- Expression\n" +
+            "--- FString\n" +
+            "---- String (Value is: )\n" +
+            "---- Expression\n" +
+            "----- Reference (value)\n" +
+            "---- String (.)"
+    );
+});
+
+test("Test create node operation", () => {
+    const parser = new Parser();
+    const ast = parser.parse(`
+        CREATE VIRTUAL (:Person) AS {
+            unwind range(1, 3) AS id
+            return id, f'Person {id}' AS name
+        }
+    `);
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- CreateNode"
+    );
+    const create: CreateNode = ast.firstChild() as CreateNode;
+    expect(create.node).not.toBeNull();
+    expect(create.node!.label).toBe("Person");
+    expect(create.statement!.print()).toBe(
+        "ASTNode\n" +
+            "- Unwind\n" +
+            "-- Expression (id)\n" +
+            "--- Function (range)\n" +
+            "---- Expression\n" +
+            "----- Number (1)\n" +
+            "---- Expression\n" +
+            "----- Number (3)\n" +
+            "- Return\n" +
+            "-- Expression (id)\n" +
+            "--- Reference (id)\n" +
+            "-- Expression (name)\n" +
+            "--- FString\n" +
+            "---- String (Person )\n" +
+            "---- Expression\n" +
+            "----- Reference (id)\n" +
+            "---- String ()"
+    );
+});
+
+test("Test match operation", () => {
+    const parser = new Parser();
+    const ast = parser.parse("MATCH (n:Person) RETURN n");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- Match\n" +
+        "- Return\n" +
+        "-- Expression (n)\n" +
+        "--- Reference (n)"
+    );
+    const match = ast.firstChild() as Match;
+    expect(match.patterns[0].startNode).not.toBeNull();
+    expect(match.patterns[0].startNode!.label).toBe("Person");
+    expect(match.patterns[0].startNode!.identifier).toBe("n");
+});
+
+test("Test create relationship operation", () => {
+    const parser = new Parser();
+    const ast = parser.parse(`
+        CREATE VIRTUAL (:Person)-[:KNOWS]-(:Person) AS {
+            unwind [
+                {from_id: 1, to_id: 2, since: '2020-01-01'},
+                {from_id: 2, to_id: 3, since: '2021-01-01'}
+            ] AS pair
+            return pair.from_id AS from, pair.to_id AS to, pair.since AS since
+        }
+    `);
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- CreateRelationship"
+    );
+    const create = ast.firstChild() as CreateRelationship;
+    expect(create.relationship).not.toBeNull();
+    expect(create.relationship!.type).toBe("KNOWS");
+    expect(create.statement!.print()).toBe(
+        "ASTNode\n" +
+            "- Unwind\n" +
+            "-- Expression (pair)\n" +
+            "--- JSONArray\n" +
+            "---- Expression\n" +
+            "----- AssociativeArray\n" +
+            "------ KeyValuePair\n" +
+            "------- String (from_id)\n" +
+            "------- Expression\n" +
+            "-------- Number (1)\n" +
+            "------ KeyValuePair\n" +
+            "------- String (to_id)\n" +
+            "------- Expression\n" +
+            "-------- Number (2)\n" +
+            "------ KeyValuePair\n" +
+            "------- String (since)\n" +
+            "------- Expression\n" +
+            "-------- String (2020-01-01)\n" +
+            "---- Expression\n" +
+            "----- AssociativeArray\n" +
+            "------ KeyValuePair\n" +
+            "------- String (from_id)\n" +
+            "------- Expression\n" +
+            "-------- Number (2)\n" +
+            "------ KeyValuePair\n" +
+            "------- String (to_id)\n" +
+            "------- Expression\n" +
+            "-------- Number (3)\n" +
+            "------ KeyValuePair\n" +
+            "------- String (since)\n" +
+            "------- Expression\n" +
+            "-------- String (2021-01-01)\n" +
+            "- Return\n" +
+            "-- Expression (from)\n" +
+            "--- Lookup\n" +
+            "---- Identifier (from_id)\n" +
+            "---- Reference (pair)\n" +
+            "-- Expression (to)\n" +
+            "--- Lookup\n" +
+            "---- Identifier (to_id)\n" +
+            "---- Reference (pair)\n" +
+            "-- Expression (since)\n" +
+            "--- Lookup\n" +
+            "---- Identifier (since)\n" +
+            "---- Reference (pair)"
+    );
+});
+
+test("Match with graph pattern including relationships", () => {
+    const parser = new Parser();
+    const ast = parser.parse("MATCH (a:Person)-[:KNOWS]-(b:Person) RETURN a, b");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+            "- Match\n" +
+            "- Return\n" +
+            "-- Expression (a)\n" +
+            "--- Reference (a)\n" +
+            "-- Expression (b)\n" +
+            "--- Reference (b)"
+    );
+    const match = ast.firstChild() as Match;
+    expect(match.patterns[0].chain.length).toBe(3);
+    const source = match.patterns[0].chain[0] as Node;
+    const relationship = match.patterns[0].chain[1] as Relationship;
+    const target = match.patterns[0].chain[2] as Node;
+    expect(source.identifier).toBe("a");
+    expect(source.label).toBe("Person");
+    expect(relationship.type).toBe("KNOWS");
+    expect(target.identifier).toBe("b");
+    expect(target.label).toBe("Person");
+});
+
+test("Test not equal operator", () => {
+    const parser = new Parser();
+    const ast = parser.parse("RETURN 1 <> 2");
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+            "- Return\n" +
+            "-- Expression\n" +
+            "--- NotEquals\n" +
+            "---- Number (1)\n" +
+            "---- Number (2)"
+    );
+});
+
+test("Test equal operator", () => {
+    const parser = new Parser();
+    const ast = parser.parse("RETURN 1 = 2");
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+            "- Return\n" +
+            "-- Expression\n" +
+            "--- Equals\n" +
+            "---- Number (1)\n" +
+            "---- Number (2)"
+    );
+});
+
+test("Test not operator", () => {
+    const parser = new Parser();
+    const ast = parser.parse("RETURN NOT true");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+        "- Return\n" +
+        "-- Expression\n" +
+        "--- Not\n" +
+        "---- Expression\n" +
+        "----- Boolean"
+    );
+});
+
+test("Parse relationship with hops", () => {
+    const parser = new Parser();
+    const ast = parser.parse("MATCH (a:Test)-[:KNOWS*1..3]->(b:Test) RETURN a, b");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+            "- Match\n" +
+            "- Return\n" +
+            "-- Expression (a)\n" +
+            "--- Reference (a)\n" +
+            "-- Expression (b)\n" +
+            "--- Reference (b)"
+    );
+    const match = ast.firstChild() as Match;
+    expect(match.patterns[0].chain.length).toBe(3);
+    const source = match.patterns[0].chain[0] as Node;
+    const relationship = match.patterns[0].chain[1] as Relationship;
+    const target = match.patterns[0].chain[2] as Node;
+    expect(source.identifier).toBe("a");
+    expect(relationship.type).toBe("KNOWS");
+    expect(relationship.hops).not.toBeNull();
+    expect(relationship.hops!.min).toBe(1);
+    expect(relationship.hops!.max).toBe(3);
+    expect(target.identifier).toBe("b");
+});
+
+test("Parse statement with graph pattern in where clause", () => {
+    const parser = new Parser();
+    const ast = parser.parse("MATCH (a:Person) WHERE (a)-[:KNOWS]->(:Person) RETURN a");
+    // prettier-ignore
+    expect(ast.print()).toBe(
+        "ASTNode\n" +
+            "- Match\n" +
+            "- Where\n" +
+            "-- Expression\n" +
+            "--- PatternExpression\n" +
+            "- Return\n" +
+            "-- Expression (a)\n" +
+            "--- Reference (a)"
+    );
+    const match = ast.firstChild() as Match;
+    expect(match.patterns[0].startNode).not.toBeNull();
+    expect(match.patterns[0].startNode!.identifier).toBe("a");
+    const where = match.next as any;
+    const pattern = where.firstChild().firstChild() as any;
+    expect(pattern.chain.length).toBe(3);
+    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(relationship.type).toBe("KNOWS");
+    expect(target.label).toBe("Person");
+});

package/tests/tokenization/tokenizer.test.ts

@@ -1,62 +1,69 @@
-import Tokenizer from '../../src/tokenization/tokenizer';
+import Tokenizer from "../../src/tokenization/tokenizer";
 
-test('Tokenizer.tokenize() should return an array of tokens', () => {
-    const tokenizer = new Tokenizer('MATCH (n:Person) RETURN n');
+test("Tokenizer.tokenize() should return an array of tokens", () => {
+    const tokenizer = new Tokenizer("MATCH (n:Person) RETURN n");
     const tokens = tokenizer.tokenize();
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
 });
 
-test('Tokenizer.tokenize() should handle escaped quotes', () => {
+test("Tokenizer.tokenize() should handle escaped quotes", () => {
     const tokenizer = new Tokenizer('return "hello \\"world"');
     const tokens = tokenizer.tokenize();
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
 });
 
-test('Test predicate function', () => {
-    const tokenizer = new Tokenizer('RETURN sum(n in [1, 2, 3] | n where n > 1)');
+test("Test predicate function", () => {
+    const tokenizer = new Tokenizer("RETURN sum(n in [1, 2, 3] | n where n > 1)");
     const tokens = tokenizer.tokenize();
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
 });
 
-test('Test f-string', () => {
+test("Test f-string", () => {
     const tokenizer = new Tokenizer('RETURN f"hello {world}"');
     const tokens = tokenizer.tokenize();
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
 });
 
-test('Test', () => {
-    const tokenizer = new Tokenizer('WITH 1 AS n RETURN n');
+test("Test another f-string", () => {
+    const tokenizer = new Tokenizer("RETURN f`Value is: {value}`");
     const tokens = tokenizer.tokenize();
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
 });
 
-test('Test associative array with backtick string', () => {
-    const tokenizer = new Tokenizer('RETURN {`key`: `value`}');
+test("Test", () => {
+    const tokenizer = new Tokenizer("WITH 1 AS n RETURN n");
     const tokens = tokenizer.tokenize();
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
 });
 
-test('Test limit', () => {
-    const tokenizer = new Tokenizer('unwind range(1, 10) as n limit 5 return n');
+test("Test associative array with backtick string", () => {
+    const tokenizer = new Tokenizer("RETURN {`key`: `value`}");
     const tokens = tokenizer.tokenize();
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
 });
 
-test('Test return -2', () => {
-    const tokenizer = new Tokenizer('return [:-2], -2');
+test("Test limit", () => {
+    const tokenizer = new Tokenizer("unwind range(1, 10) as n limit 5 return n");
     const tokens = tokenizer.tokenize();
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
 });
 
-test('Test range with function', () => {
+test("Test return -2", () => {
+    const tokenizer = new Tokenizer("return [:-2], -2");
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Test range with function", () => {
     const tokenizer = new Tokenizer(`
         with range(1,10) as data
         return range(0, size(data)-1) as indices
@@ -64,4 +71,87 @@ test('Test range with function', () => {
     const tokens = tokenizer.tokenize();
     expect(tokens).toBeDefined();
     expect(tokens.length).toBeGreaterThan(0);
-});
+});
+
+test("Test create virtual node", () => {
+    const tokenizer = new Tokenizer(`
+        CREATE VIRTUAL (:Person) AS {
+            call users() YIELD id, name
+        }
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Test create virtual relationship", () => {
+    const tokenizer = new Tokenizer(`
+        CREATE VIRTUAL (:Person)-[:KNOWS]->(:Person) AS {
+            call friendships() YIELD user1_id, user2_id
+        }
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Match based on virtual node", () => {
+    const tokenizer = new Tokenizer(`
+        MATCH (a:Person)
+        RETURN a.name
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Match based on virtual nodes and relationships", () => {
+    const tokenizer = new Tokenizer(`
+        MATCH (a:Person)-[r:KNOWS]->(b:Person)
+        RETURN a.name, b.name
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Test not equal operator", () => {
+    const tokenizer = new Tokenizer(`
+        MATCH (n:Person)
+        WHERE n.age <> 30
+        RETURN n.name AS name, n.age AS age
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Test equal operator", () => {
+    const tokenizer = new Tokenizer(`
+        MATCH (n:Person)
+        WHERE n.age = 30
+        RETURN n.name AS name, n.age AS age
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Test boolean operators", () => {
+    const tokenizer = new Tokenizer(`
+        return true AND false OR true NOT false
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});
+
+test("Test relationship with hops", () => {
+    const tokenizer = new Tokenizer(`
+        MATCH (a:Person)-[r:KNOWS*1..3]->(b:Person)
+        RETURN a.name, b.name
+    `);
+    const tokens = tokenizer.tokenize();
+    expect(tokens).toBeDefined();
+    expect(tokens.length).toBeGreaterThan(0);
+});