df-script 1.4.0

package/dist/columnExpressions/ColumnExpr.d.ts

@@ -0,0 +1,368 @@
+import { ExprBase } from "./ExprBase";
+declare const ColumnExpr_base: {
+    new (...args: any[]): {
+        get list(): import("./mixins/ListExpr").ListExprNamespace;
+        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;
+    };
+} & {
+    new (...args: any[]): {
+        get dt(): import("./mixins/TemporalExpr").DateTimeExprNamespace;
+        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;
+    };
+} & {
+    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;
+    };
+} & {
+    new (...args: any[]): {
+        get str(): import("./mixins/StringExpr").StringExprNamespace;
+        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;
+    };
+} & {
+    new (...args: any[]): {
+        partitionBy: (string | import("..").IExpr)[] | null;
+        _rolling(windowSize: number, aggFn: (vals: any[]) => any): /*elided*/ any;
+        get isWindow(): boolean;
+        cum_count(reverse?: boolean): /*elided*/ any;
+        cum_max(reverse?: boolean): /*elided*/ any;
+        cum_min(reverse?: boolean): /*elided*/ any;
+        cum_prod(reverse?: boolean): /*elided*/ any;
+        cum_sum(reverse?: boolean): /*elided*/ any;
+        dense_rank(): /*elided*/ any;
+        lag(offset?: number, defaultVal?: any): /*elided*/ any;
+        lead(offset?: number, defaultVal?: any): /*elided*/ any;
+        over(columns: string | import("..").IExpr | (string | import("..").IExpr)[]): /*elided*/ any;
+        rank(): /*elided*/ any;
+        rolling_max(windowSize: number): /*elided*/ any;
+        rolling_mean(windowSize: number): /*elided*/ any;
+        rolling_median(windowSize: number): /*elided*/ any;
+        rolling_min(windowSize: number): /*elided*/ any;
+        rolling_quantile(quantile: number, windowSize: number): /*elided*/ any;
+        rolling_rank(windowSize: number): /*elided*/ any;
+        rolling_std(windowSize: number): /*elided*/ any;
+        rolling_sum(windowSize: number): /*elided*/ any;
+        row_number(): /*elided*/ any;
+        ops: import("..").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        aggFn?: import("..").AggFn<any> | null;
+        groupingOpsIndex?: number;
+        partitionOpsIndex?: number;
+        windowOp?: {
+            type: string;
+            [key: string]: any;
+        } | null;
+        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;
+    };
+} & {
+    new (...args: any[]): {
+        aggFn: import("..").AggFn<any> | null;
+        _deriveAgg(fn: import("..").AggFn<any>): /*elided*/ any;
+        all(): /*elided*/ any;
+        all_null(): /*elided*/ any;
+        any(): /*elided*/ any;
+        any_null(): /*elided*/ any;
+        avg(): /*elided*/ any;
+        count(options?: {
+            includeNulls?: boolean;
+        }): /*elided*/ any;
+        first(): /*elided*/ any;
+        last(): /*elided*/ any;
+        max(): /*elided*/ any;
+        mean(): /*elided*/ any;
+        median(): /*elided*/ any;
+        min(): /*elided*/ any;
+        mode(): /*elided*/ any;
+        n_unique(): /*elided*/ any;
+        quantile(q: number): /*elided*/ any;
+        std(): /*elided*/ any;
+        sum(): /*elided*/ any;
+        ops: import("..").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        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;
+    };
+} & {
+    new (...args: any[]): {
+        between(lower: any, upper: any, closed?: "both" | "left" | "right" | "none"): /*elided*/ any;
+        eq(val: any): /*elided*/ any;
+        eq_missing(val: any): /*elided*/ any;
+        ge(val: any): /*elided*/ any;
+        gt(val: any): /*elided*/ any;
+        has_nulls(): any;
+        is_close(other: any, options?: {
+            abs_tol?: number;
+            rel_tol?: number;
+            nans_equal?: boolean;
+        }): /*elided*/ any;
+        is_duplicated(): /*elided*/ any;
+        is_empty(options?: {
+            ignoreNulls?: boolean;
+        }): /*elided*/ any;
+        is_finite(): /*elided*/ any;
+        is_first_distinct(): /*elided*/ any;
+        is_in(values: any[] | any): /*elided*/ any;
+        is_infinite(): /*elided*/ any;
+        is_last_distinct(): /*elided*/ any;
+        is_n_distinct(n: number): any;
+        is_nan(): /*elided*/ any;
+        is_not_nan(): /*elided*/ any;
+        is_not_null(): /*elided*/ any;
+        is_null(): /*elided*/ any;
+        is_unique(): /*elided*/ any;
+        le(val: any): /*elided*/ any;
+        lt(val: any): /*elided*/ any;
+        ne(val: any): /*elided*/ any;
+        ne_missing(val: any): /*elided*/ any;
+        not_in(values: any[] | 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;
+    };
+} & {
+    new (...args: any[]): {
+        abs(): /*elided*/ any;
+        acos(): /*elided*/ any;
+        acosh(): /*elided*/ any;
+        add(val: number | import("..").IExpr | null): /*elided*/ any;
+        asin(): /*elided*/ any;
+        asinh(): /*elided*/ any;
+        atan(): /*elided*/ any;
+        atanh(): /*elided*/ any;
+        cbrt(): /*elided*/ any;
+        ceil(): /*elided*/ any;
+        clip(lower?: number | null, upper?: number | null): /*elided*/ any;
+        cos(): /*elided*/ any;
+        cosh(): /*elided*/ any;
+        degrees(): /*elided*/ any;
+        div(val: number | import("..").IExpr | null): /*elided*/ any;
+        exp(): /*elided*/ any;
+        expm1(): /*elided*/ any;
+        floor(): /*elided*/ any;
+        floordiv(val: number | import("..").IExpr | null): /*elided*/ any;
+        hypot(val: number | import("..").IExpr | null): /*elided*/ any;
+        log(base?: number): /*elided*/ any;
+        log1p(): /*elided*/ any;
+        mod(val: number | import("..").IExpr | null): /*elided*/ any;
+        mul(val: number | import("..").IExpr | null): /*elided*/ any;
+        negate(): /*elided*/ any;
+        pow(val: number | import("..").IExpr | null): /*elided*/ any;
+        radians(): /*elided*/ any;
+        rand(seed?: number, { min, max, integer }?: import("./types").RandomOptions): /*elided*/ any;
+        round(decimals?: number): /*elided*/ any;
+        sign(): /*elided*/ any;
+        sin(): /*elided*/ any;
+        sinh(): /*elided*/ any;
+        sqrt(): /*elided*/ any;
+        sub(val: number | import("..").IExpr | null): /*elided*/ any;
+        tan(): /*elided*/ any;
+        tanh(): /*elided*/ any;
+        trunc(): /*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;
+    };
+} & {
+    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;
+    };
+} & typeof ExprBase;
+export declare class ColumnExpr<T> extends ColumnExpr_base {
+    colName: string;
+    excludedCols: string[];
+    constructor(colName: keyof T | string);
+}
+export {};

package/dist/columnExpressions/ColumnExpr.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnExpr = void 0;
+const ExprBase_1 = require("./ExprBase");
+const ArithmeticExpr_1 = require("./mixins/ArithmeticExpr");
+const ComparisonExpr_1 = require("./mixins/ComparisonExpr");
+const AggregationExpr_1 = require("./mixins/AggregationExpr");
+const WindowExpr_1 = require("./mixins/WindowExpr");
+const StringExpr_1 = require("./mixins/StringExpr");
+const LogicalExpr_1 = require("./mixins/LogicalExpr");
+const TemporalExpr_1 = require("./mixins/TemporalExpr");
+const ListExpr_1 = require("./mixins/ListExpr");
+const ManipulationExpr_1 = require("./mixins/ManipulationExpr");
+class ColumnExpr extends (0, ListExpr_1.ListExpr)((0, TemporalExpr_1.TemporalExpr)((0, LogicalExpr_1.LogicalExpr)((0, StringExpr_1.StringExpr)((0, WindowExpr_1.WindowExpr)((0, AggregationExpr_1.AggregationExpr)((0, ComparisonExpr_1.ComparisonExpr)((0, ArithmeticExpr_1.ArithmeticExpr)((0, ManipulationExpr_1.ManipulationExpr)(ExprBase_1.ExprBase))))))))) {
+    colName;
+    excludedCols = [];
+    constructor(colName) {
+        super();
+        this.colName = String(colName);
+        this.outputName = this.colName;
+    }
+}
+exports.ColumnExpr = ColumnExpr;

package/dist/columnExpressions/ExprBase.d.ts

@@ -0,0 +1,24 @@
+import type { IExpr, OpFn, AggFn, ColumnData, ColumnDict } from "../types";
+import type { DataType } from "../datatypes";
+export declare const kleeneUnary: (fn: (v: any) => any) => (vArray: ColumnData) => any[];
+export declare const kleeneBinary: (expr: IExpr, other: any, fn: (v: any, r: any) => any) => (vArray: ColumnData, columns: ColumnDict) => any[];
+export declare const derive: <T extends IExpr>(instance: T, nextOp?: OpFn) => T;
+export declare class ExprBase implements IExpr {
+    ops: OpFn[];
+    outputName: string;
+    aggFn?: AggFn<any> | null;
+    groupingOpsIndex?: number;
+    partitionOpsIndex?: number;
+    partitionBy: (string | IExpr)[] | null;
+    _resolve(val: any, columns: ColumnDict, height: number): any;
+    alias(name: string): this;
+    cast(dataType: DataType): this;
+    debug(label?: string): this;
+    evaluate(columns: ColumnDict, height: number): ColumnData;
+    private _evaluatePre;
+    private _evaluatePost;
+    evaluatePrePartition(columns: ColumnDict, height: number): ColumnData;
+    evaluatePostPartition(aggregatedArray: any[], columns: ColumnDict): ColumnData;
+    evaluatePreGrouping(columns: ColumnDict, height: number): ColumnData;
+    evaluatePostGrouping(aggregatedArray: any[], columns: ColumnDict): ColumnData;
+}

package/dist/columnExpressions/ExprBase.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprBase = exports.derive = exports.kleeneBinary = exports.kleeneUnary = void 0;
+const utils_1 = require("../utils");
+const constants_1 = require("./constants");
+const kleeneUnary = (fn) => {
+    return (vArray) => {
+        const height = vArray.length;
+        const result = new Array(height);
+        for (let i = 0; i < height; i++) {
+            const v = vArray[i];
+            result[i] = v == null ? null : fn(v);
+        }
+        return result;
+    };
+};
+exports.kleeneUnary = kleeneUnary;
+const kleeneBinary = (expr, other, fn) => {
+    return (vArray, columns) => {
+        const height = vArray.length;
+        const rResolved = expr._resolve(other, columns, height);
+        const result = new Array(height);
+        if ((0, utils_1.isArrayOrTypedArray)(rResolved)) {
+            for (let i = 0; i < height; i++) {
+                const v = vArray[i];
+                const r = rResolved[i];
+                result[i] = (v == null || r == null) ? null : fn(v, r);
+            }
+        }
+        else {
+            for (let i = 0; i < height; i++) {
+                const v = vArray[i];
+                result[i] = (v == null || rResolved == null) ? null : fn(v, rResolved);
+            }
+        }
+        return result;
+    };
+};
+exports.kleeneBinary = kleeneBinary;
+const derive = (instance, nextOp) => {
+    const Constructor = instance.constructor;
+    const newInst = new Constructor(instance.colName || "");
+    Object.assign(newInst, instance);
+    newInst.ops = nextOp ? [...instance.ops, nextOp] : [...instance.ops];
+    return newInst;
+};
+exports.derive = derive;
+class ExprBase {
+    ops = [];
+    outputName = "";
+    aggFn = null;
+    groupingOpsIndex;
+    partitionOpsIndex;
+    partitionBy = null;
+    _resolve(val, columns, height) {
+        if (val && typeof val === "object" && "evaluate" in val) {
+            if (val.isLiteral && val.ops.length === 1) {
+                return val.literalValue;
+            }
+            return val.evaluate(columns, height);
+        }
+        return val;
+    }
+    alias(name) {
+        const Constructor = this.constructor;
+        const newInst = new Constructor(this.colName || "");
+        Object.assign(newInst, this);
+        newInst.outputName = name;
+        return newInst;
+    }
+    cast(dataType) {
+        return (0, exports.derive)(this, (vArray) => {
+            const height = vArray.length;
+            const result = new Array(height);
+            for (let i = 0; i < height; i++) {
+                result[i] = dataType.coerce(vArray[i]);
+            }
+            return result;
+        });
+    }
+    debug(label) {
+        return (0, exports.derive)(this, (vArray) => {
+            console.log(`[DEBUG] ${label ? label + ': ' : ''}`, vArray);
+            return vArray;
+        });
+    }
+    evaluate(columns, height) {
+        const name = this.colName;
+        let value = name && name !== constants_1.ALL_COLUMNS_MARKER
+            ? (columns[name] || new Array(height).fill(null))
+            : new Array(height).fill(null);
+        const ops = this.ops;
+        const len = ops.length;
+        for (let i = 0; i < len; i++) {
+            value = ops[i](value, columns);
+        }
+        return value;
+    }
+    _evaluatePre(opsIndex, columns, height) {
+        const name = this.colName;
+        let value = name && name !== constants_1.ALL_COLUMNS_MARKER
+            ? (columns[name] || new Array(height).fill(null))
+            : new Array(height).fill(null);
+        const ops = this.ops;
+        const idx = opsIndex !== undefined ? opsIndex : ops.length;
+        for (let i = 0; i < idx; i++) {
+            value = ops[i](value, columns);
+        }
+        return value;
+    }
+    _evaluatePost(opsIndex, aggregatedArray, columns) {
+        const ops = this.ops;
+        const idx = opsIndex !== undefined ? opsIndex : ops.length;
+        let value = aggregatedArray;
+        for (let i = idx; i < ops.length; i++) {
+            value = ops[i](value, columns);
+        }
+        return value;
+    }
+    evaluatePrePartition(columns, height) {
+        return this._evaluatePre(this.partitionOpsIndex, columns, height);
+    }
+    evaluatePostPartition(aggregatedArray, columns) {
+        return this._evaluatePost(this.partitionOpsIndex, aggregatedArray, columns);
+    }
+    evaluatePreGrouping(columns, height) {
+        return this._evaluatePre(this.groupingOpsIndex, columns, height);
+    }
+    evaluatePostGrouping(aggregatedArray, columns) {
+        return this._evaluatePost(this.groupingOpsIndex, aggregatedArray, columns);
+    }
+}
+exports.ExprBase = ExprBase;

package/dist/columnExpressions/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const ALL_COLUMNS_MARKER = "*";
+export declare const LITERAL_MARKER = "*literal*";

package/dist/columnExpressions/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LITERAL_MARKER = exports.ALL_COLUMNS_MARKER = void 0;
+exports.ALL_COLUMNS_MARKER = "*";
+exports.LITERAL_MARKER = "*literal*";

package/dist/columnExpressions/functions/all.d.ts

@@ -0,0 +1,5 @@
+import { ColumnExpr } from "../ColumnExpr";
+/**
+ * Creates an expression targeting all columns in the DataFrame.
+ */
+export declare function all(): ColumnExpr<any>;

package/dist/columnExpressions/functions/all.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.all = all;
+const ColumnExpr_1 = require("../ColumnExpr");
+const constants_1 = require("../constants");
+/**
+ * Creates an expression targeting all columns in the DataFrame.
+ */
+function all() {
+    return new ColumnExpr_1.ColumnExpr(constants_1.ALL_COLUMNS_MARKER);
+}

package/dist/columnExpressions/functions/coalesce.d.ts

@@ -0,0 +1,3 @@
+import { ColumnExpr } from "../ColumnExpr";
+import type { IExpr, Scalar } from "../../types";
+export declare function coalesce(...exprs: (IExpr | Scalar | (IExpr | Scalar)[])[]): ColumnExpr<any>;

package/dist/columnExpressions/functions/coalesce.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coalesce = coalesce;
+const ColumnExpr_1 = require("../ColumnExpr");
+const utils_1 = require("../../utils");
+function coalesce(...exprs) {
+    const rawArgs = (exprs.length === 1 && Array.isArray(exprs[0]))
+        ? exprs[0]
+        : exprs;
+    const expr = new ColumnExpr_1.ColumnExpr("*coalesce*");
+    expr.ops.push((_, columns) => {
+        const height = _.length;
+        const evaluateArg = (arg) => {
+            if (arg && typeof arg === "object" && "evaluate" in arg) {
+                return arg.evaluate(columns, height);
+            }
+            if (typeof arg === "string") {
+                return columns[arg] || new Array(height).fill(null);
+            }
+            return arg;
+        };
+        const evaluatedArrays = rawArgs.map(evaluateArg);
+        const result = new Array(height);
+        const exprCount = evaluatedArrays.length;
+        for (let i = 0; i < height; i++) {
+            let foundVal = null;
+            for (let j = 0; j < exprCount; j++) {
+                const arr = evaluatedArrays[j];
+                const val = (0, utils_1.isArrayOrTypedArray)(arr) ? arr[i] : arr;
+                if (val != null) {
+                    foundVal = val;
+                    break;
+                }
+            }
+            result[i] = foundVal;
+        }
+        return result;
+    });
+    return expr;
+}

package/dist/columnExpressions/functions/exclude.d.ts

@@ -0,0 +1,5 @@
+import { ColumnExpr } from "../ColumnExpr";
+/**
+ * Creates an expression targeting all columns except the specified ones.
+ */
+export declare function exclude(columns: string | string[]): ColumnExpr<any>;

package/dist/columnExpressions/functions/exclude.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exclude = exclude;
+const ColumnExpr_1 = require("../ColumnExpr");
+const constants_1 = require("../constants");
+/**
+ * Creates an expression targeting all columns except the specified ones.
+ */
+function exclude(columns) {
+    const expr = new ColumnExpr_1.ColumnExpr(constants_1.ALL_COLUMNS_MARKER);
+    expr.excludedCols = Array.isArray(columns) ? columns : [columns];
+    return expr;
+}

package/dist/columnExpressions/functions/lit.d.ts

@@ -0,0 +1,5 @@
+import { ColumnExpr } from "../ColumnExpr";
+/**
+ * Creates a literal column expression that repeats the given value for all rows.
+ */
+export declare function lit(value: any): ColumnExpr<any>;