df-script 1.4.0

package/dist/columnExpressions/mixins/ListExpr.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListExpr = exports.ListExprNamespace = void 0;
+const ExprBase_1 = require("../ExprBase");
+const utils_1 = require("../../utils");
+const exceptions_1 = require("../../exceptions");
+class ListExprNamespace {
+    expr;
+    constructor(expr) {
+        this.expr = expr;
+    }
+    _deriveList(fn) {
+        return (0, ExprBase_1.derive)(this.expr, (0, ExprBase_1.kleeneUnary)((v) => {
+            return (0, utils_1.isArrayOrTypedArray)(v) ? fn(v) : null;
+        }));
+    }
+    all() {
+        return this._deriveList((arr) => {
+            const list = Array.from(arr);
+            for (let i = 0; i < list.length; i++) {
+                if (!list[i])
+                    return false;
+            }
+            return true;
+        });
+    }
+    any() {
+        return this._deriveList((arr) => {
+            const list = Array.from(arr);
+            for (let i = 0; i < list.length; i++) {
+                if (list[i])
+                    return true;
+            }
+            return false;
+        });
+    }
+    contains(item) {
+        return this._deriveList((arr) => {
+            return Array.from(arr).includes(item);
+        });
+    }
+    contains_all(items) {
+        return this._deriveList((arr) => {
+            const list = Array.from(arr);
+            for (let i = 0; i < items.length; i++) {
+                if (!list.includes(items[i]))
+                    return false;
+            }
+            return true;
+        });
+    }
+    contains_any(items) {
+        return this._deriveList((arr) => {
+            const list = Array.from(arr);
+            for (let i = 0; i < items.length; i++) {
+                if (list.includes(items[i]))
+                    return true;
+            }
+            return false;
+        });
+    }
+    count_matches(item) {
+        return this._deriveList((arr) => {
+            const list = Array.from(arr);
+            let count = 0;
+            for (const val of list) {
+                if (val === item) {
+                    count++;
+                }
+            }
+            return count;
+        });
+    }
+    drop_nulls() {
+        return this._deriveList((arr) => {
+            const list = Array.from(arr);
+            const result = [];
+            for (let i = 0; i < list.length; i++) {
+                if (list[i] != null)
+                    result.push(list[i]);
+            }
+            return result;
+        });
+    }
+    first(null_on_oob = true) {
+        return this.get(0, null_on_oob);
+    }
+    gather(indices, null_on_oob = true) {
+        const idxs = Array.isArray(indices) ? indices : [indices];
+        return this._deriveList((arr) => {
+            const len = arr.length;
+            const res = new Array(idxs.length);
+            for (let i = 0; i < idxs.length; i++) {
+                const index = idxs[i];
+                const val = arr.at(index);
+                if (val === undefined && !null_on_oob) {
+                    throw new exceptions_1.ComputeError(`Index ${index} is out of bounds for list of length ${len}`);
+                }
+                res[i] = val ?? null;
+            }
+            return res;
+        });
+    }
+    gather_every(n, offset = 0) {
+        if (n <= 0) {
+            throw new exceptions_1.ComputeError("Step size n must be positive");
+        }
+        return this._deriveList((arr) => {
+            const len = arr.length;
+            const res = [];
+            for (let i = offset; i < len; i += n) {
+                res.push(arr[i]);
+            }
+            return res;
+        });
+    }
+    get(index, null_on_oob = true) {
+        return this._deriveList((arr) => {
+            const val = arr.at(index);
+            if (val === undefined && !null_on_oob) {
+                throw new exceptions_1.ComputeError(`Index ${index} is out of bounds for list of length ${arr.length}`);
+            }
+            return val ?? null;
+        });
+    }
+    join(separator, { ignoreNulls = false } = {}) {
+        return this._deriveList((arr) => {
+            const list = Array.from(arr);
+            const strList = [];
+            for (let i = 0; i < list.length; i++) {
+                const x = list[i];
+                if (x != null) {
+                    strList.push(String(x));
+                }
+                else if (!ignoreNulls) {
+                    strList.push("");
+                }
+            }
+            return strList.join(separator);
+        });
+    }
+    last(null_on_oob = true) {
+        return this.get(-1, null_on_oob);
+    }
+    len() {
+        return this.lengths();
+    }
+    lengths() {
+        return this._deriveList((arr) => arr.length);
+    }
+    max() {
+        return this._deriveList((arr) => (0, utils_1.getListStats)(arr).max);
+    }
+    mean() {
+        return this._deriveList((arr) => {
+            const { sum, count } = (0, utils_1.getListStats)(arr);
+            return sum !== null && count > 0 ? sum / count : null;
+        });
+    }
+    median() {
+        return this._deriveList((arr) => {
+            if (!(0, utils_1.isArrayOfType)(arr, "number", { allowNulls: true }))
+                return null;
+            const len = arr.length;
+            const nums = [];
+            for (let i = 0; i < len; i++) {
+                const val = arr[i];
+                if (val != null) {
+                    nums.push(val);
+                }
+            }
+            const numsLen = nums.length;
+            if (numsLen === 0)
+                return null;
+            nums.sort((a, b) => a - b);
+            const mid = Math.floor(numsLen / 2);
+            return numsLen % 2 !== 0
+                ? nums[mid]
+                : (nums[mid - 1] + nums[mid]) / 2;
+        });
+    }
+    min() {
+        return this._deriveList((arr) => (0, utils_1.getListStats)(arr).min);
+    }
+    mode() {
+        return this._deriveList((arr) => {
+            const len = arr.length;
+            const counts = new Map();
+            let maxCount = 0;
+            for (let i = 0; i < len; i++) {
+                const val = arr[i];
+                if (val == null)
+                    continue;
+                const c = (counts.get(val) ?? 0) + 1;
+                counts.set(val, c);
+                if (c > maxCount)
+                    maxCount = c;
+            }
+            if (maxCount === 0)
+                return [];
+            const modes = [];
+            for (const [val, c] of counts.entries()) {
+                if (c === maxCount) {
+                    modes.push(val);
+                }
+            }
+            return (0, utils_1.sortList)(modes);
+        });
+    }
+    n_unique() {
+        return this._deriveList((arr) => {
+            return new Set(Array.from(arr)).size;
+        });
+    }
+    reverse() {
+        return this._deriveList((arr) => {
+            return Array.from(arr).reverse();
+        });
+    }
+    slice(offset, length) {
+        return this._deriveList((arr) => {
+            const list = Array.from(arr);
+            const start = offset < 0 ? Math.max(0, list.length + offset) : offset;
+            const end = length !== undefined ? start + length : list.length;
+            return list.slice(start, end);
+        });
+    }
+    sort(descending = false) {
+        return this._deriveList((arr) => (0, utils_1.sortList)(arr, descending));
+    }
+    sum() {
+        return this._deriveList((arr) => (0, utils_1.getListStats)(arr).sum);
+    }
+    unique() {
+        return this._deriveList((arr) => {
+            return Array.from(new Set(arr));
+        });
+    }
+}
+exports.ListExprNamespace = ListExprNamespace;
+const ListExpr = (Base) => {
+    return class extends Base {
+        get list() {
+            return new ListExprNamespace(this);
+        }
+    };
+};
+exports.ListExpr = ListExpr;

package/dist/columnExpressions/mixins/LogicalExpr.d.ts

@@ -0,0 +1,33 @@
+import type { ExprConstructor } from "../types";
+export declare const LogicalExpr: <TBase extends ExprConstructor>(Base: TBase) => {
+    new (...args: any[]): {
+        and(other: any): /*elided*/ any;
+        not(): /*elided*/ any;
+        or(other: any): /*elided*/ any;
+        xor(other: any): /*elided*/ any;
+        ops: import("../..").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        aggFn?: import("../..").AggFn<any> | null;
+        groupingOpsIndex?: number;
+        partitionOpsIndex?: number;
+        partitionBy?: (string | import("../..").IExpr)[] | null;
+        windowOp?: {
+            type: string;
+            [key: string]: any;
+        } | null;
+        isWindow?: boolean;
+        alias(name: string): /*elided*/ any;
+        cast(dataType: any): /*elided*/ any;
+        _resolve(val: any, columns: import("../..").ColumnDict, height: number): import("../..").ColumnData | any;
+        evaluate(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePreGrouping(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePostGrouping(aggregatedArray: any[], columns: import("../..").ColumnDict): import("../..").ColumnData;
+        evaluatePrePartition(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePostPartition(aggregatedArray: any[], columns: import("../..").ColumnDict): import("../..").ColumnData;
+        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
+        debug(label?: string): /*elided*/ any;
+    };
+} & TBase;

package/dist/columnExpressions/mixins/LogicalExpr.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicalExpr = void 0;
+const ExprBase_1 = require("../ExprBase");
+const utils_1 = require("../../utils");
+const LogicalExpr = (Base) => {
+    return class extends Base {
+        and(other) {
+            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+                const height = vArray.length;
+                const otherVal = this._resolve(other, columns, height);
+                const isOtherArray = (0, utils_1.isArrayOrTypedArray)(otherVal);
+                const result = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    const v = vArray[i];
+                    const w = isOtherArray ? otherVal[i] : otherVal;
+                    if (v === false || w === false)
+                        result[i] = false;
+                    else if (v == null || w == null)
+                        result[i] = null;
+                    else
+                        result[i] = true;
+                }
+                return result;
+            });
+        }
+        not() {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneUnary)((v) => !v));
+        }
+        or(other) {
+            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+                const height = vArray.length;
+                const otherVal = this._resolve(other, columns, height);
+                const isOtherArray = (0, utils_1.isArrayOrTypedArray)(otherVal);
+                const result = new Array(height);
+                for (let i = 0; i < height; i++) {
+                    const v = vArray[i];
+                    const w = isOtherArray ? otherVal[i] : otherVal;
+                    if (v === true || w === true)
+                        result[i] = true;
+                    else if (v == null || w == null)
+                        result[i] = null;
+                    else
+                        result[i] = false;
+                }
+                return result;
+            });
+        }
+        xor(other) {
+            return (0, ExprBase_1.derive)(this, (0, ExprBase_1.kleeneBinary)(this, other, (v, w) => !!v !== !!w));
+        }
+    };
+};
+exports.LogicalExpr = LogicalExpr;

package/dist/columnExpressions/mixins/ManipulationExpr.d.ts

@@ -0,0 +1,31 @@
+import type { ExprConstructor } from "../types";
+export declare const ManipulationExpr: <TBase extends ExprConstructor>(Base: TBase) => {
+    new (...args: any[]): {
+        fill_null(value: any): /*elided*/ any;
+        reverse(): /*elided*/ any;
+        ops: import("../..").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        aggFn?: import("../..").AggFn<any> | null;
+        groupingOpsIndex?: number;
+        partitionOpsIndex?: number;
+        partitionBy?: (string | import("../..").IExpr)[] | null;
+        windowOp?: {
+            type: string;
+            [key: string]: any;
+        } | null;
+        isWindow?: boolean;
+        alias(name: string): /*elided*/ any;
+        cast(dataType: any): /*elided*/ any;
+        _resolve(val: any, columns: import("../..").ColumnDict, height: number): import("../..").ColumnData | any;
+        evaluate(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePreGrouping(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePostGrouping(aggregatedArray: any[], columns: import("../..").ColumnDict): import("../..").ColumnData;
+        evaluatePrePartition(columns: import("../..").ColumnDict, height: number): import("../..").ColumnData;
+        evaluatePostPartition(aggregatedArray: any[], columns: import("../..").ColumnDict): import("../..").ColumnData;
+        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
+        debug(label?: string): /*elided*/ any;
+    };
+} & TBase;

package/dist/columnExpressions/mixins/ManipulationExpr.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManipulationExpr = void 0;
+const ExprBase_1 = require("../ExprBase");
+const utils_1 = require("../../utils");
+const ManipulationExpr = (Base) => {
+    return class extends Base {
+        fill_null(value) {
+            return (0, ExprBase_1.derive)(this, (vArray, columns) => {
+                const height = vArray.length;
+                const resolved = this._resolve(value, columns, height);
+                const result = new Array(height);
+                if ((0, utils_1.isArrayOrTypedArray)(resolved)) {
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        result[i] = v == null ? resolved[i] : v;
+                    }
+                }
+                else {
+                    for (let i = 0; i < height; i++) {
+                        const v = vArray[i];
+                        result[i] = v == null ? resolved : v;
+                    }
+                }
+                return result;
+            });
+        }
+        reverse() {
+            return (0, ExprBase_1.derive)(this, (vArray) => {
+                return vArray.slice().reverse();
+            });
+        }
+    };
+};
+exports.ManipulationExpr = ManipulationExpr;

package/dist/columnExpressions/mixins/StringExpr.d.ts

@@ -0,0 +1,79 @@
+import type { IExpr } from "../../types";
+import type { ExprConstructor } from "../types";
+import { StripCharsOptions } from "../../utils";
+export declare class StringExprNamespace {
+    expr: any;
+    constructor(expr: any);
+    _deriveString(fn: (v: string) => any): any;
+    concat(other: string | IExpr): any;
+    contains(pattern: string | RegExp): any;
+    count_matches(pattern: string | RegExp): any;
+    decode_uri_component(): any;
+    encode_uri_component(): any;
+    ends_with(suffix: string): any;
+    explode(): any;
+    extract(pattern: RegExp, group?: number): any;
+    len(): any;
+    len_bytes(): any;
+    len_chars(): any;
+    lower(): any;
+    lpad(width: number, fill?: string): any;
+    pad_end(width: number, fill?: string): any;
+    pad_start(width: number, fill?: string): any;
+    replace(pattern: string | RegExp, replacement: string): any;
+    replace_all(pattern: string | RegExp, replacement: string): any;
+    reverse(): any;
+    rpad(width: number, fill?: string): any;
+    slice(offset: number, length?: number): any;
+    slice_str(offset: number, length?: number): any;
+    split(delimiter: string): any;
+    starts_with(prefix: string): any;
+    strip_chars(characters?: string | RegExp, options?: StripCharsOptions): any;
+    strip_chars_end(characters?: string | RegExp, options?: StripCharsOptions): any;
+    strip_chars_start(characters?: string | RegExp, options?: StripCharsOptions): any;
+    strip_prefix(prefix: string): any;
+    strip_suffix(suffix: string): any;
+    strptime(format: string, strict?: boolean): any;
+    to_date(): any;
+    to_datetime(): any;
+    to_decimal(precision?: number, scale?: number): any;
+    to_integer(): any;
+    to_lowercase(): any;
+    to_time(): any;
+    to_titlecase(): any;
+    to_uppercase(): any;
+    trim(): any;
+    trim_end(): any;
+    trim_start(): any;
+    upper(): any;
+    zfill(width: number): any;
+}
+export declare const StringExpr: <TBase extends ExprConstructor>(Base: TBase) => {
+    new (...args: any[]): {
+        get str(): StringExprNamespace;
+        ops: import("../../types").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        aggFn?: import("../../types").AggFn<any> | null;
+        groupingOpsIndex?: number;
+        partitionOpsIndex?: number;
+        partitionBy?: (string | IExpr)[] | null;
+        windowOp?: {
+            type: string;
+            [key: string]: any;
+        } | null;
+        isWindow?: boolean;
+        alias(name: string): /*elided*/ any;
+        cast(dataType: any): /*elided*/ any;
+        _resolve(val: any, columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData | any;
+        evaluate(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
+        evaluatePreGrouping(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
+        evaluatePostGrouping(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
+        evaluatePrePartition(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
+        evaluatePostPartition(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
+        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
+        debug(label?: string): /*elided*/ any;
+    };
+} & TBase;