flowquery 1.0.28 → 1.0.29

package/package.json

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

package/src/parsing/expressions/operator.ts

@@ -1,5 +1,28 @@
 import ASTNode from "../ast_node";
 
+function deepEquals(a: any, b: any): boolean {
+    if (a === b) return true;
+    if (a === null || b === null || a === undefined || b === undefined) return false;
+    if (typeof a !== typeof b) return false;
+    if (typeof a !== "object") return false;
+    if (Array.isArray(a) !== Array.isArray(b)) return false;
+    if (Array.isArray(a)) {
+        if (a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEquals(a[i], b[i])) return false;
+        }
+        return true;
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+        if (!deepEquals(a[key], b[key])) return false;
+    }
+    return true;
+}
+
 abstract class Operator extends ASTNode {
     private _precedence: number = 0;
     private _leftAssociative: boolean = true;
@@ -88,7 +111,7 @@ class Equals extends Operator {
         super(0, true);
     }
     public value(): number {
-        return this.lhs.value() === this.rhs.value() ? 1 : 0;
+        return deepEquals(this.lhs.value(), this.rhs.value()) ? 1 : 0;
     }
 }
 
@@ -97,7 +120,7 @@ class NotEquals extends Operator {
         super(0, true);
     }
     public value(): number {
-        return this.lhs.value() !== this.rhs.value() ? 1 : 0;
+        return !deepEquals(this.lhs.value(), this.rhs.value()) ? 1 : 0;
     }
 }
 
@@ -296,6 +319,7 @@ class NotEndsWith extends Operator {
 }
 
 export {
+    deepEquals,
     Operator,
     Add,
     Subtract,

package/src/parsing/functions/count.ts

@@ -0,0 +1,54 @@
+import AggregateFunction from "./aggregate_function";
+import { FunctionDef } from "./function_metadata";
+import ReducerElement from "./reducer_element";
+
+class CountReducerElement extends ReducerElement {
+    private _value: number = 0;
+    public get value(): any {
+        return this._value;
+    }
+    public set value(value: any) {
+        this._value += 1;
+    }
+}
+
+class DistinctCountReducerElement extends ReducerElement {
+    private _seen: Set<string> = new Set();
+    public get value(): any {
+        return this._seen.size;
+    }
+    public set value(value: any) {
+        const key: string = JSON.stringify(value);
+        this._seen.add(key);
+    }
+}
+
+@FunctionDef({
+    description: "Counts the number of values across grouped rows",
+    category: "aggregate",
+    parameters: [{ name: "value", description: "Value to count", type: "any" }],
+    output: { description: "Number of values", type: "number", example: 3 },
+    examples: [
+        "WITH [1, 2, 3] AS nums UNWIND nums AS n RETURN count(n)",
+        "WITH [1, 2, 2, 3] AS nums UNWIND nums AS n RETURN count(distinct n)",
+    ],
+})
+class Count extends AggregateFunction {
+    private _distinct: boolean = false;
+    constructor() {
+        super("count");
+        this._expectedParameterCount = 1;
+        this._supports_distinct = true;
+    }
+    public reduce(element: CountReducerElement | DistinctCountReducerElement): void {
+        element.value = this.firstChild().value();
+    }
+    public element(): CountReducerElement | DistinctCountReducerElement {
+        return this._distinct ? new DistinctCountReducerElement() : new CountReducerElement();
+    }
+    public set distinct(distinct: boolean) {
+        this._distinct = distinct;
+    }
+}
+
+export default Count;

package/src/parsing/functions/function_factory.ts

@@ -1,6 +1,7 @@
 import AsyncFunction from "./async_function";
 import "./avg";
 import "./collect";
+import "./count";
 import Function from "./function";
 import {
     AsyncDataProvider,

package/src/parsing/parser.ts

@@ -171,11 +171,17 @@ class Parser extends BaseParser {
         }
         this.setNextToken();
         this.expectAndSkipWhitespaceAndComments();
+        let distinct = false;
+        if (this.token.isDistinct()) {
+            distinct = true;
+            this.setNextToken();
+            this.expectAndSkipWhitespaceAndComments();
+        }
         const expressions = Array.from(this.parseExpressions(AliasOption.REQUIRED));
         if (expressions.length === 0) {
             throw new Error("Expected expression");
         }
-        if (expressions.some((expression: Expression) => expression.has_reducers())) {
+        if (distinct || expressions.some((expression: Expression) => expression.has_reducers())) {
             return new AggregatedWith(expressions);
         }
         return new With(expressions);
@@ -220,11 +226,17 @@ class Parser extends BaseParser {
         }
         this.setNextToken();
         this.expectAndSkipWhitespaceAndComments();
+        let distinct = false;
+        if (this.token.isDistinct()) {
+            distinct = true;
+            this.setNextToken();
+            this.expectAndSkipWhitespaceAndComments();
+        }
         const expressions = Array.from(this.parseExpressions(AliasOption.OPTIONAL));
         if (expressions.length === 0) {
             throw new Error("Expected expression");
         }
-        if (expressions.some((expression: Expression) => expression.has_reducers())) {
+        if (distinct || expressions.some((expression: Expression) => expression.has_reducers())) {
             return new AggregatedReturn(expressions);
         }
         this._returns++;

package/tests/compute/runner.test.ts

@@ -140,6 +140,58 @@ test("Test aggregated return with multiple aggregates", async () => {
     expect(results[1]).toEqual({ i: 2, sum: 20, avg: 2.5 });
 });
 
+test("Test count", async () => {
+    const runner = new Runner(
+        "unwind [1, 1, 2, 2] as i unwind [1, 2, 3, 4] as j return i, count(j) as cnt"
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ i: 1, cnt: 8 });
+    expect(results[1]).toEqual({ i: 2, cnt: 8 });
+});
+
+test("Test count distinct", async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2] as i
+        unwind [1, 2, 1, 2] as j
+        return i, count(distinct j) as cnt
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({ i: 1, cnt: 2 });
+    expect(results[1]).toEqual({ i: 2, cnt: 2 });
+});
+
+test("Test count with strings", async () => {
+    const runner = new Runner(
+        `
+        unwind ["a", "b", "a", "c"] as s
+        return count(s) as cnt
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ cnt: 4 });
+});
+
+test("Test count distinct with strings", async () => {
+    const runner = new Runner(
+        `
+        unwind ["a", "b", "a", "c"] as s
+        return count(distinct s) as cnt
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ cnt: 3 });
+});
+
 test("Test avg with null", async () => {
     const runner = new Runner("return avg(null) as avg");
     await runner.run();
@@ -330,6 +382,83 @@ test("Test collect distinct with associative array", async () => {
     expect(results[1]).toEqual({ i: 2, collected: [{ j: 1 }, { j: 2 }, { j: 3 }] });
 });
 
+test("Test return distinct", async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2, 3, 3] as i
+        return distinct i
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ i: 1 });
+    expect(results[1]).toEqual({ i: 2 });
+    expect(results[2]).toEqual({ i: 3 });
+});
+
+test("Test return distinct with multiple expressions", async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2] as i
+        unwind [10, 10, 20, 20] as j
+        return distinct i, j
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(4);
+    expect(results[0]).toEqual({ i: 1, j: 10 });
+    expect(results[1]).toEqual({ i: 1, j: 20 });
+    expect(results[2]).toEqual({ i: 2, j: 10 });
+    expect(results[3]).toEqual({ i: 2, j: 20 });
+});
+
+test("Test with distinct", async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2, 3, 3] as i
+        with distinct i as i
+        return i
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ i: 1 });
+    expect(results[1]).toEqual({ i: 2 });
+    expect(results[2]).toEqual({ i: 3 });
+});
+
+test("Test with distinct and aggregation", async () => {
+    const runner = new Runner(
+        `
+        unwind [1, 1, 2, 2] as i
+        with distinct i as i
+        return sum(i) as total
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({ total: 3 });
+});
+
+test("Test return distinct with strings", async () => {
+    const runner = new Runner(
+        `
+        unwind ["a", "b", "a", "c", "b"] as x
+        return distinct x
+        `
+    );
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(3);
+    expect(results[0]).toEqual({ x: "a" });
+    expect(results[1]).toEqual({ x: "b" });
+    expect(results[2]).toEqual({ x: "c" });
+});
+
 test("Test join function", async () => {
     const runner = new Runner('RETURN join(["a", "b", "c"], ",") as join');
     await runner.run();

package/tests/parsing/expression.test.ts

@@ -1,3 +1,4 @@
+import ASTNode from "../../src/parsing/ast_node";
 import Null from "../../src/parsing/components/null";
 import Expression from "../../src/parsing/expressions/expression";
 import Number from "../../src/parsing/expressions/number";
@@ -6,19 +7,33 @@ import {
     And,
     Contains,
     EndsWith,
+    Equals,
     GreaterThan,
     Is,
     IsNot,
     Multiply,
     NotContains,
     NotEndsWith,
+    NotEquals,
     NotStartsWith,
     Power,
     StartsWith,
     Subtract,
+    deepEquals,
 } from "../../src/parsing/expressions/operator";
 import String from "../../src/parsing/expressions/string";
 
+class ObjectValue extends ASTNode {
+    private _value: any;
+    constructor(value: any) {
+        super();
+        this._value = value;
+    }
+    public value(): any {
+        return this._value;
+    }
+}
+
 test("Test Expression Shunting Yard algorithm", () => {
     const expression = new Expression();
     expression.addNode(new Number("2"));
@@ -172,3 +187,117 @@ test("Test NOT ENDS WITH", () => {
     expression.finish();
     expect(expression.value()).toBe(1);
 });
+
+// deepEquals unit tests
+
+test("deepEquals with identical primitives", () => {
+    expect(deepEquals(1, 1)).toBe(true);
+    expect(deepEquals("abc", "abc")).toBe(true);
+    expect(deepEquals(null, null)).toBe(true);
+});
+
+test("deepEquals with different primitives", () => {
+    expect(deepEquals(1, 2)).toBe(false);
+    expect(deepEquals("abc", "def")).toBe(false);
+    expect(deepEquals(null, 1)).toBe(false);
+    expect(deepEquals(1, "1")).toBe(false);
+});
+
+test("deepEquals with identical objects", () => {
+    const obj = { id: "1", name: "Alice" };
+    expect(deepEquals(obj, obj)).toBe(true);
+});
+
+test("deepEquals with structurally equal objects", () => {
+    expect(deepEquals({ id: "1", name: "Alice" }, { id: "1", name: "Alice" })).toBe(true);
+});
+
+test("deepEquals with different objects", () => {
+    expect(deepEquals({ id: "1", name: "Alice" }, { id: "2", name: "Bob" })).toBe(false);
+});
+
+test("deepEquals with nested objects", () => {
+    expect(
+        deepEquals({ id: "1", data: { x: 1, y: [2, 3] } }, { id: "1", data: { x: 1, y: [2, 3] } })
+    ).toBe(true);
+    expect(
+        deepEquals({ id: "1", data: { x: 1, y: [2, 3] } }, { id: "1", data: { x: 1, y: [2, 4] } })
+    ).toBe(false);
+});
+
+test("deepEquals with arrays", () => {
+    expect(deepEquals([1, 2, 3], [1, 2, 3])).toBe(true);
+    expect(deepEquals([1, 2, 3], [1, 2])).toBe(false);
+    expect(deepEquals([1, 2], [1, 2, 3])).toBe(false);
+});
+
+test("deepEquals with objects having different keys", () => {
+    expect(deepEquals({ a: 1 }, { b: 1 })).toBe(false);
+    expect(deepEquals({ a: 1 }, { a: 1, b: 2 })).toBe(false);
+});
+
+// Equals operator with objects
+
+test("Test Equals with equal numbers", () => {
+    const expression = new Expression();
+    expression.addNode(new Number("42"));
+    expression.addNode(new Equals());
+    expression.addNode(new Number("42"));
+    expression.finish();
+    expect(expression.value()).toBe(1);
+});
+
+test("Test Equals with different numbers", () => {
+    const expression = new Expression();
+    expression.addNode(new Number("42"));
+    expression.addNode(new Equals());
+    expression.addNode(new Number("99"));
+    expression.finish();
+    expect(expression.value()).toBe(0);
+});
+
+test("Test Equals with structurally equal objects", () => {
+    const expression = new Expression();
+    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
+    expression.addNode(new Equals());
+    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
+    expression.finish();
+    expect(expression.value()).toBe(1);
+});
+
+test("Test Equals with different objects", () => {
+    const expression = new Expression();
+    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
+    expression.addNode(new Equals());
+    expression.addNode(new ObjectValue({ id: "2", name: "Bob" }));
+    expression.finish();
+    expect(expression.value()).toBe(0);
+});
+
+test("Test NotEquals with structurally equal objects", () => {
+    const expression = new Expression();
+    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
+    expression.addNode(new NotEquals());
+    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
+    expression.finish();
+    expect(expression.value()).toBe(0);
+});
+
+test("Test NotEquals with different objects", () => {
+    const expression = new Expression();
+    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
+    expression.addNode(new NotEquals());
+    expression.addNode(new ObjectValue({ id: "2", name: "Bob" }));
+    expression.finish();
+    expect(expression.value()).toBe(1);
+});
+
+test("Test Equals with same reference object", () => {
+    const obj = { id: "1", name: "Alice" };
+    const expression = new Expression();
+    expression.addNode(new ObjectValue(obj));
+    expression.addNode(new Equals());
+    expression.addNode(new ObjectValue(obj));
+    expression.finish();
+    expect(expression.value()).toBe(1);
+});