flowquery 1.0.38 → 1.0.40

package/package.json

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

package/src/graph/database.ts

@@ -25,6 +25,12 @@ class Database {
         physical.statement = statement;
         Database.nodes.set(node.label, physical);
     }
+    public removeNode(node: Node): void {
+        if (node.label === null) {
+            throw new Error("Node label is null");
+        }
+        Database.nodes.delete(node.label);
+    }
     public getNode(node: Node): PhysicalNode | null {
         return Database.nodes.get(node.label!) || null;
     }
@@ -38,6 +44,12 @@ class Database {
         physical.target = relationship.target;
         Database.relationships.set(relationship.type, physical);
     }
+    public removeRelationship(relationship: Relationship): void {
+        if (relationship.type === null) {
+            throw new Error("Relationship type is null");
+        }
+        Database.relationships.delete(relationship.type);
+    }
     public getRelationship(relationship: Relationship): PhysicalRelationship | null {
         return Database.relationships.get(relationship.type!) || null;
     }

package/src/parsing/expressions/operator.ts

@@ -197,7 +197,7 @@ class Not extends Operator {
 
 class Is extends Operator {
     constructor() {
-        super(-1, true);
+        super(0, true);
     }
     public value(): number {
         return this.lhs.value() == this.rhs.value() ? 1 : 0;
@@ -206,7 +206,7 @@ class Is extends Operator {
 
 class IsNot extends Operator {
     constructor() {
-        super(-1, true);
+        super(0, true);
     }
     public value(): number {
         return this.lhs.value() != this.rhs.value() ? 1 : 0;
@@ -215,7 +215,7 @@ class IsNot extends Operator {
 
 class In extends Operator {
     constructor() {
-        super(-1, true);
+        super(0, true);
     }
     public value(): number {
         const list = this.rhs.value();
@@ -228,7 +228,7 @@ class In extends Operator {
 
 class NotIn extends Operator {
     constructor() {
-        super(-1, true);
+        super(0, true);
     }
     public value(): number {
         const list = this.rhs.value();

package/src/parsing/functions/function_factory.ts

@@ -39,6 +39,7 @@ import "./size";
 import "./split";
 import "./string_distance";
 import "./stringify";
+import "./substring";
 // Import built-in functions to ensure their @FunctionDef decorators run
 import "./sum";
 import "./tail";

package/src/parsing/functions/substring.ts

@@ -0,0 +1,65 @@
+import ASTNode from "../ast_node";
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description:
+        "Returns a substring of a string, starting at a 0-based index with an optional length",
+    category: "scalar",
+    parameters: [
+        { name: "original", description: "The original string", type: "string" },
+        { name: "start", description: "The 0-based start index", type: "integer" },
+        {
+            name: "length",
+            description: "The length of the substring (optional, defaults to remainder of string)",
+            type: "integer",
+        },
+    ],
+    output: { description: "The substring", type: "string", example: "llo" },
+    examples: ["RETURN substring('hello', 1, 3)", "RETURN substring('hello', 2)"],
+})
+class Substring extends Function {
+    constructor() {
+        super("substring");
+    }
+
+    public set parameters(nodes: ASTNode[]) {
+        if (nodes.length < 2 || nodes.length > 3) {
+            throw new Error(
+                `Function substring expected 2 or 3 parameters, but got ${nodes.length}`
+            );
+        }
+        this.children = nodes;
+    }
+
+    public value(): any {
+        const children = this.getChildren();
+        const original = children[0].value();
+        const start = children[1].value();
+
+        if (typeof original !== "string") {
+            throw new Error(
+                "Invalid argument for substring function: expected a string as the first argument"
+            );
+        }
+        if (typeof start !== "number" || !Number.isInteger(start)) {
+            throw new Error(
+                "Invalid argument for substring function: expected an integer as the second argument"
+            );
+        }
+
+        if (children.length === 3) {
+            const length = children[2].value();
+            if (typeof length !== "number" || !Number.isInteger(length)) {
+                throw new Error(
+                    "Invalid argument for substring function: expected an integer as the third argument"
+                );
+            }
+            return original.substring(start, start + length);
+        }
+
+        return original.substring(start);
+    }
+}
+
+export default Substring;

package/src/parsing/operations/aggregated_return.ts

@@ -1,6 +1,6 @@
-import Return from "./return";
-import GroupBy from "./group_by";
 import Expression from "../expressions/expression";
+import GroupBy from "./group_by";
+import Return from "./return";
 
 class AggregatedReturn extends Return {
     private _group_by: GroupBy = new GroupBy(this.children as Expression[]);
@@ -8,11 +8,15 @@ class AggregatedReturn extends Return {
         await this._group_by.run();
     }
     public get results(): Record<string, any>[] {
-        if(this._where !== null) {
+        if (this._where !== null) {
             this._group_by.where = this._where;
         }
-        return Array.from(this._group_by.generate_results());
+        const results = Array.from(this._group_by.generate_results());
+        if (this._orderBy !== null) {
+            return this._orderBy.sort(results);
+        }
+        return results;
     }
 }
 
-export default AggregatedReturn;
+export default AggregatedReturn;

package/src/parsing/operations/delete_node.ts

@@ -0,0 +1,33 @@
+import Database from "../../graph/database";
+import Node from "../../graph/node";
+import Operation from "./operation";
+
+class DeleteNode extends Operation {
+    private _node: Node | null = null;
+    constructor(node: Node) {
+        super();
+        this._node = node;
+    }
+    public get node(): Node | null {
+        return this._node;
+    }
+    public run(): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (this._node === null) {
+                    throw new Error("Node is null");
+                }
+                const db: Database = Database.getInstance();
+                db.removeNode(this._node);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+    public get results(): Record<string, any>[] {
+        return [];
+    }
+}
+
+export default DeleteNode;

package/src/parsing/operations/delete_relationship.ts

@@ -0,0 +1,32 @@
+import Database from "../../graph/database";
+import Relationship from "../../graph/relationship";
+import Operation from "./operation";
+
+class DeleteRelationship extends Operation {
+    private _relationship: Relationship | null = null;
+    constructor(relationship: Relationship) {
+        super();
+        this._relationship = relationship;
+    }
+    public get relationship(): Relationship | null {
+        return this._relationship;
+    }
+    public run(): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (this._relationship === null) {
+                    throw new Error("Relationship is null");
+                }
+                const db = Database.getInstance();
+                db.removeRelationship(this._relationship);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+    public get results(): Record<string, any>[] {
+        return [];
+    }
+}
+export default DeleteRelationship;

package/src/parsing/operations/limit.ts

@@ -10,6 +10,9 @@ class Limit extends Operation {
     public get isLimitReached(): boolean {
         return this.count >= this.limit;
     }
+    public get limitValue(): number {
+        return this.limit;
+    }
     public increment(): void {
         this.count++;
     }

package/src/parsing/operations/order_by.ts

@@ -0,0 +1,75 @@
+import Operation from "./operation";
+
+export interface SortField {
+    field: string;
+    direction: "asc" | "desc";
+}
+
+/**
+ * Represents an ORDER BY operation that sorts results.
+ *
+ * Can be attached to a RETURN operation (sorting its results),
+ * or used as a standalone accumulating operation after a non-aggregate WITH.
+ *
+ * @example
+ * ```
+ * RETURN x ORDER BY x DESC
+ * ```
+ */
+class OrderBy extends Operation {
+    private _fields: SortField[];
+    private _results: Record<string, any>[] = [];
+
+    constructor(fields: SortField[]) {
+        super();
+        this._fields = fields;
+    }
+
+    public get fields(): SortField[] {
+        return this._fields;
+    }
+
+    /**
+     * Sorts an array of records according to the sort fields.
+     */
+    public sort(records: Record<string, any>[]): Record<string, any>[] {
+        return records.sort((a, b) => {
+            for (const { field, direction } of this._fields) {
+                const aVal = a[field];
+                const bVal = b[field];
+                let cmp = 0;
+                if (aVal == null && bVal == null) cmp = 0;
+                else if (aVal == null) cmp = -1;
+                else if (bVal == null) cmp = 1;
+                else if (aVal < bVal) cmp = -1;
+                else if (aVal > bVal) cmp = 1;
+                if (cmp !== 0) {
+                    return direction === "desc" ? -cmp : cmp;
+                }
+            }
+            return 0;
+        });
+    }
+
+    /**
+     * When used as a standalone operation (after non-aggregate WITH),
+     * accumulates records to sort later.
+     */
+    public async run(): Promise<void> {
+        const record: Record<string, any> = {};
+        // Collect current variable values from the context
+        // This gets called per-row, and then finish() sorts and emits
+        await this.next?.run();
+    }
+
+    public async initialize(): Promise<void> {
+        this._results = [];
+        await this.next?.initialize();
+    }
+
+    public get results(): Record<string, any>[] {
+        return this._results;
+    }
+}
+
+export default OrderBy;

package/src/parsing/operations/return.ts

@@ -1,4 +1,5 @@
 import Limit from "./limit";
+import OrderBy from "./order_by";
 import Projection from "./projection";
 import Where from "./where";
 
@@ -17,6 +18,7 @@ class Return extends Projection {
     protected _where: Where | null = null;
     protected _results: Record<string, any>[] = [];
     private _limit: Limit | null = null;
+    protected _orderBy: OrderBy | null = null;
     public set where(where: Where) {
         this._where = where;
     }
@@ -29,11 +31,16 @@ class Return extends Projection {
     public set limit(limit: Limit) {
         this._limit = limit;
     }
+    public set orderBy(orderBy: OrderBy) {
+        this._orderBy = orderBy;
+    }
     public async run(): Promise<void> {
         if (!this.where) {
             return;
         }
-        if (this._limit !== null && this._limit.isLimitReached) {
+        // When ORDER BY is present, skip limit during accumulation;
+        // limit will be applied after sorting in get results()
+        if (this._orderBy === null && this._limit !== null && this._limit.isLimitReached) {
             return;
         }
         const record: Map<string, any> = new Map();
@@ -43,7 +50,7 @@ class Return extends Projection {
             record.set(alias, value);
         }
         this._results.push(Object.fromEntries(record));
-        if (this._limit !== null) {
+        if (this._orderBy === null && this._limit !== null) {
             this._limit.increment();
         }
     }
@@ -51,7 +58,14 @@ class Return extends Projection {
         this._results = [];
     }
     public get results(): Record<string, any>[] {
-        return this._results;
+        let results = this._results;
+        if (this._orderBy !== null) {
+            results = this._orderBy.sort(results);
+        }
+        if (this._orderBy !== null && this._limit !== null) {
+            results = results.slice(0, this._limit.limitValue);
+        }
+        return results;
     }
 }
 

package/src/parsing/parser.ts

@@ -53,10 +53,13 @@ import AggregatedWith from "./operations/aggregated_with";
 import Call from "./operations/call";
 import CreateNode from "./operations/create_node";
 import CreateRelationship from "./operations/create_relationship";
+import DeleteNode from "./operations/delete_node";
+import DeleteRelationship from "./operations/delete_relationship";
 import Limit from "./operations/limit";
 import Load from "./operations/load";
 import Match from "./operations/match";
 import Operation from "./operations/operation";
+import OrderBy, { SortField } from "./operations/order_by";
 import Return from "./operations/return";
 import Union from "./operations/union";
 import UnionAll from "./operations/union_all";
@@ -143,6 +146,15 @@ class Parser extends BaseParser {
                     operation = where;
                 }
             }
+            const orderBy = this.parseOrderBy();
+            if (orderBy !== null) {
+                if (operation instanceof Return) {
+                    (operation as Return).orderBy = orderBy;
+                } else {
+                    operation!.addSibling(orderBy);
+                    operation = orderBy;
+                }
+            }
             const limit = this.parseLimit();
             if (limit !== null) {
                 if (operation instanceof Return) {
@@ -176,9 +188,13 @@ class Parser extends BaseParser {
             !(operation instanceof Return) &&
             !(operation instanceof Call) &&
             !(operation instanceof CreateNode) &&
-            !(operation instanceof CreateRelationship)
+            !(operation instanceof CreateRelationship) &&
+            !(operation instanceof DeleteNode) &&
+            !(operation instanceof DeleteRelationship)
         ) {
-            throw new Error("Last statement must be a RETURN, WHERE, CALL, or CREATE statement");
+            throw new Error(
+                "Last statement must be a RETURN, WHERE, CALL, CREATE, or DELETE statement"
+            );
         }
         return root;
     }
@@ -191,6 +207,7 @@ class Parser extends BaseParser {
             this.parseLoad() ||
             this.parseCall() ||
             this.parseCreate() ||
+            this.parseDelete() ||
             this.parseMatch()
         );
     }
@@ -449,6 +466,60 @@ class Parser extends BaseParser {
         return create;
     }
 
+    private parseDelete(): DeleteNode | DeleteRelationship | null {
+        if (!this.token.isDelete()) {
+            return null;
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        if (!this.token.isVirtual()) {
+            throw new Error("Expected VIRTUAL");
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        const node: Node | null = this.parseNode();
+        if (node === null) {
+            throw new Error("Expected node definition");
+        }
+        let relationship: Relationship | null = null;
+        if (this.token.isSubtract() && this.peek()?.isOpeningBracket()) {
+            this.setNextToken();
+            this.setNextToken();
+            if (!this.token.isColon()) {
+                throw new Error("Expected ':' for relationship type");
+            }
+            this.setNextToken();
+            if (!this.token.isIdentifierOrKeyword()) {
+                throw new Error("Expected relationship type identifier");
+            }
+            const type: string = this.token.value || "";
+            this.setNextToken();
+            if (!this.token.isClosingBracket()) {
+                throw new Error("Expected closing bracket for relationship definition");
+            }
+            this.setNextToken();
+            if (!this.token.isSubtract()) {
+                throw new Error("Expected '-' for relationship definition");
+            }
+            this.setNextToken();
+            const target: Node | null = this.parseNode();
+            if (target === null) {
+                throw new Error("Expected target node definition");
+            }
+            relationship = new Relationship();
+            relationship.type = type;
+            relationship.source = node;
+            relationship.target = target;
+        }
+        let result: DeleteNode | DeleteRelationship;
+        if (relationship !== null) {
+            result = new DeleteRelationship(relationship);
+        } else {
+            result = new DeleteNode(node);
+        }
+        return result;
+    }
+
     private parseMatch(): Match | null {
         let optional = false;
         if (this.token.isOptional()) {
@@ -790,6 +861,48 @@ class Parser extends BaseParser {
         return limit;
     }
 
+    private parseOrderBy(): OrderBy | null {
+        this.skipWhitespaceAndComments();
+        if (!this.token.isOrder()) {
+            return null;
+        }
+        this.expectPreviousTokenToBeWhitespaceOrComment();
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        if (!this.token.isByKeyword()) {
+            throw new Error("Expected BY after ORDER");
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        const fields: SortField[] = [];
+        while (true) {
+            if (!this.token.isIdentifierOrKeyword()) {
+                throw new Error("Expected field name in ORDER BY");
+            }
+            const field = this.token.value!;
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            let direction: "asc" | "desc" = "asc";
+            if (this.token.isAsc()) {
+                direction = "asc";
+                this.setNextToken();
+                this.skipWhitespaceAndComments();
+            } else if (this.token.isDesc()) {
+                direction = "desc";
+                this.setNextToken();
+                this.skipWhitespaceAndComments();
+            }
+            fields.push({ field, direction });
+            if (this.token.isComma()) {
+                this.setNextToken();
+                this.skipWhitespaceAndComments();
+            } else {
+                break;
+            }
+        }
+        return new OrderBy(fields);
+    }
+
     private *parseExpressions(
         alias_option: AliasOption = AliasOption.NOT_ALLOWED
     ): IterableIterator<Expression> {

package/src/tokenization/token.ts

@@ -675,6 +675,38 @@ class Token {
         return this._type === TokenType.KEYWORD && this._value === Keyword.DISTINCT;
     }
 
+    public static get ORDER(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.ORDER);
+    }
+
+    public isOrder(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.ORDER;
+    }
+
+    public static get BY(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.BY);
+    }
+
+    public isByKeyword(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.BY;
+    }
+
+    public static get ASC(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.ASC);
+    }
+
+    public isAsc(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.ASC;
+    }
+
+    public static get DESC(): Token {
+        return new Token(TokenType.KEYWORD, Keyword.DESC);
+    }
+
+    public isDesc(): boolean {
+        return this._type === TokenType.KEYWORD && this._value === Keyword.DESC;
+    }
+
     public static get LIMIT(): Token {
         return new Token(TokenType.KEYWORD, Keyword.LIMIT);
     }