@milaboratories/ptabler-expression-js 1.1.23 → 1.1.24

package/dist/expressions.cjs

@@ -1,843 +1,760 @@
-'use strict';
 
+//#region src/expressions.ts
 /**
- * Base expressionImpl classes and interfaces for PTabler JavaScript implementation
- */
+* Base abstract class for all expressions
+*/
+var ExpressionImpl = class {
+	_alias;
+	/**
+	* Set an alias for this expression
+	*/
+	alias(name) {
+		const cloned = this.clone();
+		cloned._alias = name;
+		return cloned;
+	}
+	plus(other) {
+		return new ArithmeticExpressionImpl("plus", this, coerceToExpression(other));
+	}
+	minus(other) {
+		return new ArithmeticExpressionImpl("minus", this, coerceToExpression(other));
+	}
+	multiply(other) {
+		return new ArithmeticExpressionImpl("multiply", this, coerceToExpression(other));
+	}
+	truediv(other) {
+		return new ArithmeticExpressionImpl("truediv", this, coerceToExpression(other));
+	}
+	floordiv(other) {
+		return new ArithmeticExpressionImpl("floordiv", this, coerceToExpression(other));
+	}
+	gt(other) {
+		return new ComparisonExpressionImpl("gt", this, coerceToExpression(other));
+	}
+	ge(other) {
+		return new ComparisonExpressionImpl("ge", this, coerceToExpression(other));
+	}
+	eq(other) {
+		return new ComparisonExpressionImpl("eq", this, coerceToExpression(other));
+	}
+	lt(other) {
+		return new ComparisonExpressionImpl("lt", this, coerceToExpression(other));
+	}
+	le(other) {
+		return new ComparisonExpressionImpl("le", this, coerceToExpression(other));
+	}
+	neq(other) {
+		return new ComparisonExpressionImpl("neq", this, coerceToExpression(other));
+	}
+	and(...others) {
+		return new LogicalExpressionImpl("and", [this, ...others]);
+	}
+	or(...others) {
+		return new LogicalExpressionImpl("or", [this, ...others]);
+	}
+	not() {
+		return new LogicalExpressionImpl("not", [this]);
+	}
+	abs() {
+		return new UnaryArithmeticExpressionImpl("abs", this);
+	}
+	sqrt() {
+		return new UnaryArithmeticExpressionImpl("sqrt", this);
+	}
+	log() {
+		return new UnaryArithmeticExpressionImpl("log", this);
+	}
+	log10() {
+		return new UnaryArithmeticExpressionImpl("log10", this);
+	}
+	log2() {
+		return new UnaryArithmeticExpressionImpl("log2", this);
+	}
+	floor() {
+		return new UnaryArithmeticExpressionImpl("floor", this);
+	}
+	ceil() {
+		return new UnaryArithmeticExpressionImpl("ceil", this);
+	}
+	round() {
+		return new UnaryArithmeticExpressionImpl("round", this);
+	}
+	negate() {
+		return new UnaryArithmeticExpressionImpl("negate", this);
+	}
+	isNull() {
+		return new NullCheckExpressionImpl("is_na", this);
+	}
+	isNotNull() {
+		return new NullCheckExpressionImpl("is_not_na", this);
+	}
+	fillNull(value) {
+		return new FillNullExpressionImpl(this, coerceToExpression(value));
+	}
+	fillNaN(value) {
+		return new FillNaNExpressionImpl(this, coerceToExpression(value));
+	}
+	strConcat(...others) {
+		return new StringConcatExpressionImpl([this, ...others.map(coerceToExpression)]);
+	}
+	substring(start, length) {
+		return new SubstringExpressionImpl(this, start, length);
+	}
+	strReplace(pattern, value, options) {
+		return new StringReplaceExpressionImpl(this, pattern, value, options);
+	}
+	strContains(pattern, literal, strict) {
+		return new StringContainsExpressionImpl(this, coerceToExpression(pattern), literal, strict);
+	}
+	strToUpper() {
+		return new StringCaseExpressionImpl("to_upper", this);
+	}
+	strToLower() {
+		return new StringCaseExpressionImpl("to_lower", this);
+	}
+	strStartsWith(pattern) {
+		return new StringStartsWithExpressionImpl(this, coerceToExpression(pattern));
+	}
+	strEndsWith(pattern) {
+		return new StringEndsWithExpressionImpl(this, coerceToExpression(pattern));
+	}
+	sum() {
+		return new AggregationExpressionImpl("sum", this);
+	}
+	mean() {
+		return new AggregationExpressionImpl("mean", this);
+	}
+	count() {
+		return new AggregationExpressionImpl("count", this);
+	}
+	min() {
+		return new AggregationExpressionImpl("min", this);
+	}
+	max() {
+		return new AggregationExpressionImpl("max", this);
+	}
+	first() {
+		return new AggregationExpressionImpl("first", this);
+	}
+	last() {
+		return new AggregationExpressionImpl("last", this);
+	}
+	cumsum() {
+		return new CumsumExpressionImpl(this);
+	}
+	stringDistance(other, metric, returnSimilarity) {
+		return new StringDistanceExpressionImpl(this, coerceToExpression(other), metric, returnSimilarity);
+	}
+	fuzzyStringFilter(pattern, metric, bound) {
+		return new FuzzyStringFilterExpressionImpl(this, coerceToExpression(pattern), metric, bound);
+	}
+};
+var ColumnExpressionImpl = class ColumnExpressionImpl extends ExpressionImpl {
+	constructor(columnName) {
+		super();
+		this.columnName = columnName;
+	}
+	toJSON() {
+		return {
+			type: "col",
+			name: this.columnName
+		};
+	}
+	getAlias() {
+		return this._alias || this.columnName;
+	}
+	clone() {
+		const cloned = new ColumnExpressionImpl(this.columnName);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+	/**
+	* Get the column name
+	*/
+	getColumnName() {
+		return this.columnName;
+	}
+};
 /**
- * Base abstract class for all expressions
- */
-class ExpressionImpl {
-    _alias;
-    /**
-     * Set an alias for this expression
-     */
-    alias(name) {
-        const cloned = this.clone();
-        cloned._alias = name;
-        return cloned;
-    }
-    // Arithmetic operations
-    plus(other) {
-        return new ArithmeticExpressionImpl("plus", this, coerceToExpression(other));
-    }
-    minus(other) {
-        return new ArithmeticExpressionImpl("minus", this, coerceToExpression(other));
-    }
-    multiply(other) {
-        return new ArithmeticExpressionImpl("multiply", this, coerceToExpression(other));
-    }
-    truediv(other) {
-        return new ArithmeticExpressionImpl("truediv", this, coerceToExpression(other));
-    }
-    floordiv(other) {
-        return new ArithmeticExpressionImpl("floordiv", this, coerceToExpression(other));
-    }
-    // Comparison operations
-    gt(other) {
-        return new ComparisonExpressionImpl("gt", this, coerceToExpression(other));
-    }
-    ge(other) {
-        return new ComparisonExpressionImpl("ge", this, coerceToExpression(other));
-    }
-    eq(other) {
-        return new ComparisonExpressionImpl("eq", this, coerceToExpression(other));
-    }
-    lt(other) {
-        return new ComparisonExpressionImpl("lt", this, coerceToExpression(other));
-    }
-    le(other) {
-        return new ComparisonExpressionImpl("le", this, coerceToExpression(other));
-    }
-    neq(other) {
-        return new ComparisonExpressionImpl("neq", this, coerceToExpression(other));
-    }
-    // Logical operations
-    and(...others) {
-        return new LogicalExpressionImpl("and", [this, ...others]);
-    }
-    or(...others) {
-        return new LogicalExpressionImpl("or", [this, ...others]);
-    }
-    not() {
-        return new LogicalExpressionImpl("not", [this]);
-    }
-    // Unary arithmetic operations
-    abs() {
-        return new UnaryArithmeticExpressionImpl("abs", this);
-    }
-    sqrt() {
-        return new UnaryArithmeticExpressionImpl("sqrt", this);
-    }
-    log() {
-        return new UnaryArithmeticExpressionImpl("log", this);
-    }
-    log10() {
-        return new UnaryArithmeticExpressionImpl("log10", this);
-    }
-    log2() {
-        return new UnaryArithmeticExpressionImpl("log2", this);
-    }
-    floor() {
-        return new UnaryArithmeticExpressionImpl("floor", this);
-    }
-    ceil() {
-        return new UnaryArithmeticExpressionImpl("ceil", this);
-    }
-    round() {
-        return new UnaryArithmeticExpressionImpl("round", this);
-    }
-    negate() {
-        return new UnaryArithmeticExpressionImpl("negate", this);
-    }
-    // Null checks
-    isNull() {
-        return new NullCheckExpressionImpl("is_na", this);
-    }
-    isNotNull() {
-        return new NullCheckExpressionImpl("is_not_na", this);
-    }
-    // Fill null/NaN
-    fillNull(value) {
-        return new FillNullExpressionImpl(this, coerceToExpression(value));
-    }
-    fillNaN(value) {
-        return new FillNaNExpressionImpl(this, coerceToExpression(value));
-    }
-    // String operations
-    strConcat(...others) {
-        return new StringConcatExpressionImpl([this, ...others.map(coerceToExpression)]);
-    }
-    substring(start, length) {
-        return new SubstringExpressionImpl(this, start, length);
-    }
-    strReplace(pattern, value, options) {
-        return new StringReplaceExpressionImpl(this, pattern, value, options);
-    }
-    strContains(pattern, literal, strict) {
-        return new StringContainsExpressionImpl(this, coerceToExpression(pattern), literal, strict);
-    }
-    strToUpper() {
-        return new StringCaseExpressionImpl("to_upper", this);
-    }
-    strToLower() {
-        return new StringCaseExpressionImpl("to_lower", this);
-    }
-    strStartsWith(pattern) {
-        return new StringStartsWithExpressionImpl(this, coerceToExpression(pattern));
-    }
-    strEndsWith(pattern) {
-        return new StringEndsWithExpressionImpl(this, coerceToExpression(pattern));
-    }
-    // Aggregation operations
-    sum() {
-        return new AggregationExpressionImpl("sum", this);
-    }
-    mean() {
-        return new AggregationExpressionImpl("mean", this);
-    }
-    count() {
-        return new AggregationExpressionImpl("count", this);
-    }
-    min() {
-        return new AggregationExpressionImpl("min", this);
-    }
-    max() {
-        return new AggregationExpressionImpl("max", this);
-    }
-    first() {
-        return new AggregationExpressionImpl("first", this);
-    }
-    last() {
-        return new AggregationExpressionImpl("last", this);
-    }
-    cumsum() {
-        return new CumsumExpressionImpl(this);
-    }
-    // Fuzzy operations
-    stringDistance(other, metric, returnSimilarity) {
-        return new StringDistanceExpressionImpl(this, coerceToExpression(other), metric, returnSimilarity);
-    }
-    fuzzyStringFilter(pattern, metric, bound) {
-        return new FuzzyStringFilterExpressionImpl(this, coerceToExpression(pattern), metric, bound);
-    }
-}
-class ColumnExpressionImpl extends ExpressionImpl {
-    columnName;
-    constructor(columnName) {
-        super();
-        this.columnName = columnName;
-    }
-    toJSON() {
-        return {
-            type: "col",
-            name: this.columnName,
-        };
-    }
-    getAlias() {
-        return this._alias || this.columnName;
-    }
-    clone() {
-        const cloned = new ColumnExpressionImpl(this.columnName);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-    /**
-     * Get the column name
-     */
-    getColumnName() {
-        return this.columnName;
-    }
-}
-/**
- * Helper function to coerce values to expressions
- */
+* Helper function to coerce values to expressions
+*/
 function coerceToExpression(value) {
-    if (value instanceof ExpressionImpl) {
-        return value;
-    }
-    return new LiteralExpressionImpl(value);
-}
-class MinMaxExpressionImpl extends ExpressionImpl {
-    op;
-    ops;
-    constructor(op, ops) {
-        super();
-        this.op = op;
-        this.ops = ops;
-    }
-    toJSON() {
-        return {
-            type: this.op,
-            operands: this.ops.map((o) => o.toJSON()),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.op}_${this.ops.map((o) => o.getAlias()).join("_")}`;
-    }
-    clone() {
-        const cloned = new MinMaxExpressionImpl(this.op, this.ops);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-// Forward declarations for concrete expressionImpl classes
-// These will be imported from their respective modules
-class ArithmeticExpressionImpl extends ExpressionImpl {
-    operator;
-    lhs;
-    rhs;
-    constructor(operator, lhs, rhs) {
-        super();
-        this.operator = operator;
-        this.lhs = lhs;
-        this.rhs = rhs;
-    }
-    toJSON() {
-        return {
-            type: this.operator,
-            lhs: this.lhs.toJSON(),
-            rhs: this.rhs.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.lhs.getAlias()}_${this.operator}_${this.rhs.getAlias()}`;
-    }
-    clone() {
-        const cloned = new ArithmeticExpressionImpl(this.operator, this.lhs, this.rhs);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class ComparisonExpressionImpl extends ExpressionImpl {
-    operator;
-    lhs;
-    rhs;
-    constructor(operator, lhs, rhs) {
-        super();
-        this.operator = operator;
-        this.lhs = lhs;
-        this.rhs = rhs;
-    }
-    toJSON() {
-        return {
-            type: this.operator,
-            lhs: this.lhs.toJSON(),
-            rhs: this.rhs.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.lhs.getAlias()}_${this.operator}_${this.rhs.getAlias()}`;
-    }
-    clone() {
-        const cloned = new ComparisonExpressionImpl(this.operator, this.lhs, this.rhs);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class LogicalExpressionImpl extends ExpressionImpl {
-    operator;
-    operands;
-    constructor(operator, operands) {
-        super();
-        this.operator = operator;
-        this.operands = operands;
-    }
-    toJSON() {
-        if (this.operator === "not") {
-            return {
-                type: "not",
-                value: this.operands[0].toJSON(),
-            };
-        }
-        return {
-            type: this.operator,
-            operands: this.operands.map((op) => op.toJSON()),
-        };
-    }
-    getAlias() {
-        if (this._alias)
-            return this._alias;
-        if (this.operator === "not") {
-            return `not_${this.operands[0].getAlias()}`;
-        }
-        return this.operands.map((op) => op.getAlias()).join(`_${this.operator}_`);
-    }
-    clone() {
-        const cloned = new LogicalExpressionImpl(this.operator, this.operands);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class UnaryArithmeticExpressionImpl extends ExpressionImpl {
-    operator;
-    value;
-    constructor(operator, value) {
-        super();
-        this.operator = operator;
-        this.value = value;
-    }
-    toJSON() {
-        return {
-            type: this.operator,
-            value: this.value.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.operator}_${this.value.getAlias()}`;
-    }
-    clone() {
-        const cloned = new UnaryArithmeticExpressionImpl(this.operator, this.value);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class NullCheckExpressionImpl extends ExpressionImpl {
-    operator;
-    value;
-    constructor(operator, value) {
-        super();
-        this.operator = operator;
-        this.value = value;
-    }
-    toJSON() {
-        return {
-            type: this.operator,
-            value: this.value.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.value.getAlias()}_${this.operator}`;
-    }
-    clone() {
-        const cloned = new NullCheckExpressionImpl(this.operator, this.value);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class LiteralExpressionImpl extends ExpressionImpl {
-    value;
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-    toJSON() {
-        return {
-            type: "const",
-            value: this.value,
-        };
-    }
-    getAlias() {
-        return this._alias || this.generateDefaultAlias();
-    }
-    clone() {
-        const cloned = new LiteralExpressionImpl(this.value);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-    /**
-     * Get the literal value
-     */
-    getValue() {
-        return this.value;
-    }
-    /**
-     * Generate a default alias based on the value
-     */
-    generateDefaultAlias() {
-        if (this.value === null || this.value === undefined) {
-            return "null";
-        }
-        if (typeof this.value === "string") {
-            // For string values, truncate if too long and make safe for column names
-            const safe = this.value.replace(/[^a-zA-Z0-9_]/g, "_");
-            return safe.length > 20 ? safe.substring(0, 17) + "..." : safe;
-        }
-        if (typeof this.value === "boolean") {
-            return this.value ? "true" : "false";
-        }
-        if (typeof this.value === "number") {
-            return String(this.value);
-        }
-        if (Array.isArray(this.value)) {
-            return "array";
-        }
-        if (typeof this.value === "object") {
-            return "object";
-        }
-        return "literal";
-    }
-}
-class FillNullExpressionImpl extends ExpressionImpl {
-    expr;
-    fillValue;
-    constructor(expr, fillValue) {
-        super();
-        this.expr = expr;
-        this.fillValue = fillValue;
-    }
-    toJSON() {
-        return {
-            type: "fill_null",
-            input: this.expr.toJSON(),
-            fillValue: this.fillValue.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_fill_null`;
-    }
-    clone() {
-        const cloned = new FillNullExpressionImpl(this.expr, this.fillValue);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class FillNaNExpressionImpl extends ExpressionImpl {
-    expr;
-    fillValue;
-    constructor(expr, fillValue) {
-        super();
-        this.expr = expr;
-        this.fillValue = fillValue;
-    }
-    toJSON() {
-        return {
-            type: "fill_nan",
-            input: this.expr.toJSON(),
-            fillValue: this.fillValue.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_fill_nan`;
-    }
-    clone() {
-        const cloned = new FillNaNExpressionImpl(this.expr, this.fillValue);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class StringConcatExpressionImpl extends ExpressionImpl {
-    operands;
-    delimiter;
-    constructor(operands, delimiter = "") {
-        super();
-        this.operands = operands;
-        this.delimiter = delimiter;
-    }
-    toJSON() {
-        return {
-            type: "str_join",
-            operands: this.operands.map((o) => o.toJSON()),
-            delimiter: this.delimiter,
-        };
-    }
-    getAlias() {
-        return this._alias || this.operands.map((o) => o.getAlias()).join("_");
-    }
-    clone() {
-        const cloned = new StringConcatExpressionImpl(this.operands);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class SubstringExpressionImpl extends ExpressionImpl {
-    expr;
-    start;
-    length;
-    constructor(expr, start, length) {
-        super();
-        this.expr = expr;
-        this.start = start;
-        this.length = length;
-    }
-    toJSON() {
-        return {
-            type: "substring",
-            value: this.expr.toJSON(),
-            start: { type: "const", value: this.start },
-            length: this.length !== undefined ? { type: "const", value: this.length } : undefined,
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_substring`;
-    }
-    clone() {
-        const cloned = new SubstringExpressionImpl(this.expr, this.start, this.length);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class StringReplaceExpressionImpl extends ExpressionImpl {
-    expr;
-    pattern;
-    value;
-    options;
-    constructor(expr, pattern, value, options) {
-        super();
-        this.expr = expr;
-        this.pattern = pattern;
-        this.value = value;
-        this.options = options;
-    }
-    toJSON() {
-        return {
-            type: "str_replace",
-            value: this.expr.toJSON(),
-            pattern: this.pattern,
-            replacement: this.value,
-            replaceAll: this.options?.replaceAll || false,
-            literal: this.options?.literal || false,
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_replace`;
-    }
-    clone() {
-        const cloned = new StringReplaceExpressionImpl(this.expr, this.pattern, this.value, this.options);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class StringContainsExpressionImpl extends ExpressionImpl {
-    expr;
-    pattern;
-    literal;
-    strict;
-    constructor(expr, pattern, literal, strict) {
-        super();
-        this.expr = expr;
-        this.pattern = pattern;
-        this.literal = literal;
-        this.strict = strict;
-    }
-    toJSON() {
-        return {
-            type: "str_contains",
-            value: this.expr.toJSON(),
-            pattern: this.pattern.toJSON(),
-            literal: this.literal || false,
-            strict: this.strict !== undefined ? this.strict : true,
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_contains`;
-    }
-    clone() {
-        const cloned = new StringContainsExpressionImpl(this.expr, this.pattern, this.literal, this.strict);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class StringCaseExpressionImpl extends ExpressionImpl {
-    operation;
-    expr;
-    constructor(operation, expr) {
-        super();
-        this.operation = operation;
-        this.expr = expr;
-    }
-    toJSON() {
-        return {
-            type: this.operation,
-            value: this.expr.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_${this.operation}`;
-    }
-    clone() {
-        const cloned = new StringCaseExpressionImpl(this.operation, this.expr);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class StringStartsWithExpressionImpl extends ExpressionImpl {
-    expr;
-    pattern;
-    constructor(expr, pattern) {
-        super();
-        this.expr = expr;
-        this.pattern = pattern;
-    }
-    toJSON() {
-        return {
-            type: "str_starts_with",
-            value: this.expr.toJSON(),
-            prefix: this.pattern.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_starts_with`;
-    }
-    clone() {
-        const cloned = new StringStartsWithExpressionImpl(this.expr, this.pattern);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class StringEndsWithExpressionImpl extends ExpressionImpl {
-    expr;
-    pattern;
-    constructor(expr, pattern) {
-        super();
-        this.expr = expr;
-        this.pattern = pattern;
-    }
-    toJSON() {
-        return {
-            type: "str_ends_with",
-            value: this.expr.toJSON(),
-            suffix: this.pattern.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_ends_with`;
-    }
-    clone() {
-        const cloned = new StringEndsWithExpressionImpl(this.expr, this.pattern);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class CumsumExpressionImpl extends ExpressionImpl {
-    value;
-    additionalOrderBy;
-    partitionBy;
-    descending;
-    constructor(value, additionalOrderBy = [], partitionBy = [], descending) {
-        super();
-        this.value = value;
-        this.additionalOrderBy = additionalOrderBy;
-        this.partitionBy = partitionBy;
-        this.descending = descending;
-    }
-    toJSON() {
-        return {
-            type: "cumsum",
-            value: this.value.toJSON(),
-            additionalOrderBy: this.additionalOrderBy.map((expr) => expr.toJSON()),
-            partitionBy: this.partitionBy.map((expr) => expr.toJSON()),
-            descending: this.descending,
-        };
-    }
-    getAlias() {
-        return this._alias || `cumsum_${this.value.getAlias()}`;
-    }
-    clone() {
-        const cloned = new CumsumExpressionImpl(this.value, this.additionalOrderBy, this.partitionBy, this.descending);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class AggregationExpressionImpl extends ExpressionImpl {
-    operation;
-    expr;
-    constructor(operation, expr) {
-        super();
-        this.operation = operation;
-        this.expr = expr;
-    }
-    toJSON() {
-        return {
-            type: "aggregate",
-            aggregation: this.operation,
-            value: this.expr?.toJSON() || { type: "const", value: 1 },
-            partitionBy: [],
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.operation}${this.expr ? "_" + this.expr.getAlias() : ""}`;
-    }
-    clone() {
-        const cloned = new AggregationExpressionImpl(this.operation, this.expr);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class WindowExpressionImpl extends ExpressionImpl {
-    expr;
-    aggregation;
-    partitionBy;
-    constructor(expr, aggregation, partitionBy) {
-        super();
-        this.expr = expr;
-        this.aggregation = aggregation;
-        this.partitionBy = partitionBy;
-    }
-    toJSON() {
-        return {
-            type: "aggregate",
-            aggregation: this.aggregation,
-            value: this.expr.toJSON(),
-            partitionBy: this.partitionBy.map((expr) => expr.toJSON()),
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_window`;
-    }
-    clone() {
-        const cloned = new WindowExpressionImpl(this.expr, this.aggregation, this.partitionBy);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class StringDistanceExpressionImpl extends ExpressionImpl {
-    string1;
-    string2;
-    metric;
-    returnSimilarity;
-    constructor(string1, string2, metric, returnSimilarity) {
-        super();
-        this.string1 = string1;
-        this.string2 = string2;
-        this.metric = metric;
-        this.returnSimilarity = returnSimilarity;
-    }
-    toJSON() {
-        return {
-            type: "string_distance",
-            metric: this.metric,
-            string1: this.string1.toJSON(),
-            string2: this.string2.toJSON(),
-            returnSimilarity: this.returnSimilarity || false,
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.string1.getAlias()}_distance_${this.string2.getAlias()}`;
-    }
-    clone() {
-        const cloned = new StringDistanceExpressionImpl(this.string1, this.string2, this.metric, this.returnSimilarity);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class FuzzyStringFilterExpressionImpl extends ExpressionImpl {
-    expr;
-    pattern;
-    metric;
-    bound;
-    constructor(expr, pattern, metric, bound) {
-        super();
-        this.expr = expr;
-        this.pattern = pattern;
-        this.metric = metric;
-        this.bound = bound;
-    }
-    toJSON() {
-        return {
-            type: "fuzzy_string_filter",
-            metric: this.metric,
-            value: this.expr.toJSON(),
-            pattern: this.pattern.toJSON(),
-            bound: this.bound,
-        };
-    }
-    getAlias() {
-        return this._alias || `${this.expr.getAlias()}_fuzzy_filter`;
-    }
-    clone() {
-        const cloned = new FuzzyStringFilterExpressionImpl(this.expr, this.pattern, this.metric, this.bound);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class RankExpressionImpl extends ExpressionImpl {
-    orderBy;
-    partitionBy;
-    descending;
-    constructor(orderBy, partitionBy, descending) {
-        super();
-        this.orderBy = orderBy;
-        this.partitionBy = partitionBy;
-        this.descending = descending;
-    }
-    toJSON() {
-        return {
-            type: "rank",
-            orderBy: this.orderBy.map((e) => e.toJSON()),
-            partitionBy: this.partitionBy.map((e) => e.toJSON()),
-            descending: this.descending || undefined,
-        };
-    }
-    getAlias() {
-        const order = this.orderBy.map((e) => e.getAlias()).join("_");
-        const part = this.partitionBy.map((e) => e.getAlias()).join("_");
-        const dir = this.descending ? "desc" : "asc";
-        return this._alias || `rank_${order}${part ? `_over_${part}` : ""}_${dir}`;
-    }
-    clone() {
-        const cloned = new RankExpressionImpl(this.orderBy, this.partitionBy, this.descending);
-        cloned._alias = this._alias;
-        return cloned;
-    }
-}
-class WhenThenOtherwiseExpressionImpl extends ExpressionImpl {
-    conditions;
-    otherwiseValue;
-    constructor(conditions, otherwiseValue) {
-        super();
-        this.conditions = conditions;
-        this.otherwiseValue = otherwiseValue;
-    }
-    toJSON() {
-        return {
-            type: "when_then_otherwise",
-            conditions: this.conditions.map((clause) => ({
-                when: clause.when.toJSON(),
-                then: clause.then.toJSON(),
-            })),
-            otherwise: this.otherwiseValue.toJSON(),
-        };
-    }
-    getAlias() {
-        return this._alias || "conditional";
-    }
-    clone() {
-        const cloned = new WhenThenOtherwiseExpressionImpl(this.conditions, this.otherwiseValue);
-        cloned._alias = this._alias;
-        return cloned;
-    }
+	if (value instanceof ExpressionImpl) return value;
+	return new LiteralExpressionImpl(value);
 }
+var MinMaxExpressionImpl = class MinMaxExpressionImpl extends ExpressionImpl {
+	constructor(op, ops) {
+		super();
+		this.op = op;
+		this.ops = ops;
+	}
+	toJSON() {
+		return {
+			type: this.op,
+			operands: this.ops.map((o) => o.toJSON())
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.op}_${this.ops.map((o) => o.getAlias()).join("_")}`;
+	}
+	clone() {
+		const cloned = new MinMaxExpressionImpl(this.op, this.ops);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var ArithmeticExpressionImpl = class ArithmeticExpressionImpl extends ExpressionImpl {
+	constructor(operator, lhs, rhs) {
+		super();
+		this.operator = operator;
+		this.lhs = lhs;
+		this.rhs = rhs;
+	}
+	toJSON() {
+		return {
+			type: this.operator,
+			lhs: this.lhs.toJSON(),
+			rhs: this.rhs.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.lhs.getAlias()}_${this.operator}_${this.rhs.getAlias()}`;
+	}
+	clone() {
+		const cloned = new ArithmeticExpressionImpl(this.operator, this.lhs, this.rhs);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var ComparisonExpressionImpl = class ComparisonExpressionImpl extends ExpressionImpl {
+	constructor(operator, lhs, rhs) {
+		super();
+		this.operator = operator;
+		this.lhs = lhs;
+		this.rhs = rhs;
+	}
+	toJSON() {
+		return {
+			type: this.operator,
+			lhs: this.lhs.toJSON(),
+			rhs: this.rhs.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.lhs.getAlias()}_${this.operator}_${this.rhs.getAlias()}`;
+	}
+	clone() {
+		const cloned = new ComparisonExpressionImpl(this.operator, this.lhs, this.rhs);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var LogicalExpressionImpl = class LogicalExpressionImpl extends ExpressionImpl {
+	constructor(operator, operands) {
+		super();
+		this.operator = operator;
+		this.operands = operands;
+	}
+	toJSON() {
+		if (this.operator === "not") return {
+			type: "not",
+			value: this.operands[0].toJSON()
+		};
+		return {
+			type: this.operator,
+			operands: this.operands.map((op) => op.toJSON())
+		};
+	}
+	getAlias() {
+		if (this._alias) return this._alias;
+		if (this.operator === "not") return `not_${this.operands[0].getAlias()}`;
+		return this.operands.map((op) => op.getAlias()).join(`_${this.operator}_`);
+	}
+	clone() {
+		const cloned = new LogicalExpressionImpl(this.operator, this.operands);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var UnaryArithmeticExpressionImpl = class UnaryArithmeticExpressionImpl extends ExpressionImpl {
+	constructor(operator, value) {
+		super();
+		this.operator = operator;
+		this.value = value;
+	}
+	toJSON() {
+		return {
+			type: this.operator,
+			value: this.value.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.operator}_${this.value.getAlias()}`;
+	}
+	clone() {
+		const cloned = new UnaryArithmeticExpressionImpl(this.operator, this.value);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var NullCheckExpressionImpl = class NullCheckExpressionImpl extends ExpressionImpl {
+	constructor(operator, value) {
+		super();
+		this.operator = operator;
+		this.value = value;
+	}
+	toJSON() {
+		return {
+			type: this.operator,
+			value: this.value.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.value.getAlias()}_${this.operator}`;
+	}
+	clone() {
+		const cloned = new NullCheckExpressionImpl(this.operator, this.value);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var LiteralExpressionImpl = class LiteralExpressionImpl extends ExpressionImpl {
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	toJSON() {
+		return {
+			type: "const",
+			value: this.value
+		};
+	}
+	getAlias() {
+		return this._alias || this.generateDefaultAlias();
+	}
+	clone() {
+		const cloned = new LiteralExpressionImpl(this.value);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+	/**
+	* Get the literal value
+	*/
+	getValue() {
+		return this.value;
+	}
+	/**
+	* Generate a default alias based on the value
+	*/
+	generateDefaultAlias() {
+		if (this.value === null || this.value === void 0) return "null";
+		if (typeof this.value === "string") {
+			const safe = this.value.replace(/[^a-zA-Z0-9_]/g, "_");
+			return safe.length > 20 ? safe.substring(0, 17) + "..." : safe;
+		}
+		if (typeof this.value === "boolean") return this.value ? "true" : "false";
+		if (typeof this.value === "number") return String(this.value);
+		if (Array.isArray(this.value)) return "array";
+		if (typeof this.value === "object") return "object";
+		return "literal";
+	}
+};
+var FillNullExpressionImpl = class FillNullExpressionImpl extends ExpressionImpl {
+	constructor(expr, fillValue) {
+		super();
+		this.expr = expr;
+		this.fillValue = fillValue;
+	}
+	toJSON() {
+		return {
+			type: "fill_null",
+			input: this.expr.toJSON(),
+			fillValue: this.fillValue.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_fill_null`;
+	}
+	clone() {
+		const cloned = new FillNullExpressionImpl(this.expr, this.fillValue);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var FillNaNExpressionImpl = class FillNaNExpressionImpl extends ExpressionImpl {
+	constructor(expr, fillValue) {
+		super();
+		this.expr = expr;
+		this.fillValue = fillValue;
+	}
+	toJSON() {
+		return {
+			type: "fill_nan",
+			input: this.expr.toJSON(),
+			fillValue: this.fillValue.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_fill_nan`;
+	}
+	clone() {
+		const cloned = new FillNaNExpressionImpl(this.expr, this.fillValue);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var StringConcatExpressionImpl = class StringConcatExpressionImpl extends ExpressionImpl {
+	constructor(operands, delimiter = "") {
+		super();
+		this.operands = operands;
+		this.delimiter = delimiter;
+	}
+	toJSON() {
+		return {
+			type: "str_join",
+			operands: this.operands.map((o) => o.toJSON()),
+			delimiter: this.delimiter
+		};
+	}
+	getAlias() {
+		return this._alias || this.operands.map((o) => o.getAlias()).join("_");
+	}
+	clone() {
+		const cloned = new StringConcatExpressionImpl(this.operands);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var SubstringExpressionImpl = class SubstringExpressionImpl extends ExpressionImpl {
+	constructor(expr, start, length) {
+		super();
+		this.expr = expr;
+		this.start = start;
+		this.length = length;
+	}
+	toJSON() {
+		return {
+			type: "substring",
+			value: this.expr.toJSON(),
+			start: {
+				type: "const",
+				value: this.start
+			},
+			length: this.length !== void 0 ? {
+				type: "const",
+				value: this.length
+			} : void 0
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_substring`;
+	}
+	clone() {
+		const cloned = new SubstringExpressionImpl(this.expr, this.start, this.length);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var StringReplaceExpressionImpl = class StringReplaceExpressionImpl extends ExpressionImpl {
+	constructor(expr, pattern, value, options) {
+		super();
+		this.expr = expr;
+		this.pattern = pattern;
+		this.value = value;
+		this.options = options;
+	}
+	toJSON() {
+		return {
+			type: "str_replace",
+			value: this.expr.toJSON(),
+			pattern: this.pattern,
+			replacement: this.value,
+			replaceAll: this.options?.replaceAll || false,
+			literal: this.options?.literal || false
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_replace`;
+	}
+	clone() {
+		const cloned = new StringReplaceExpressionImpl(this.expr, this.pattern, this.value, this.options);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var StringContainsExpressionImpl = class StringContainsExpressionImpl extends ExpressionImpl {
+	constructor(expr, pattern, literal, strict) {
+		super();
+		this.expr = expr;
+		this.pattern = pattern;
+		this.literal = literal;
+		this.strict = strict;
+	}
+	toJSON() {
+		return {
+			type: "str_contains",
+			value: this.expr.toJSON(),
+			pattern: this.pattern.toJSON(),
+			literal: this.literal || false,
+			strict: this.strict !== void 0 ? this.strict : true
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_contains`;
+	}
+	clone() {
+		const cloned = new StringContainsExpressionImpl(this.expr, this.pattern, this.literal, this.strict);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var StringCaseExpressionImpl = class StringCaseExpressionImpl extends ExpressionImpl {
+	constructor(operation, expr) {
+		super();
+		this.operation = operation;
+		this.expr = expr;
+	}
+	toJSON() {
+		return {
+			type: this.operation,
+			value: this.expr.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_${this.operation}`;
+	}
+	clone() {
+		const cloned = new StringCaseExpressionImpl(this.operation, this.expr);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var StringStartsWithExpressionImpl = class StringStartsWithExpressionImpl extends ExpressionImpl {
+	constructor(expr, pattern) {
+		super();
+		this.expr = expr;
+		this.pattern = pattern;
+	}
+	toJSON() {
+		return {
+			type: "str_starts_with",
+			value: this.expr.toJSON(),
+			prefix: this.pattern.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_starts_with`;
+	}
+	clone() {
+		const cloned = new StringStartsWithExpressionImpl(this.expr, this.pattern);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var StringEndsWithExpressionImpl = class StringEndsWithExpressionImpl extends ExpressionImpl {
+	constructor(expr, pattern) {
+		super();
+		this.expr = expr;
+		this.pattern = pattern;
+	}
+	toJSON() {
+		return {
+			type: "str_ends_with",
+			value: this.expr.toJSON(),
+			suffix: this.pattern.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_ends_with`;
+	}
+	clone() {
+		const cloned = new StringEndsWithExpressionImpl(this.expr, this.pattern);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var CumsumExpressionImpl = class CumsumExpressionImpl extends ExpressionImpl {
+	constructor(value, additionalOrderBy = [], partitionBy = [], descending) {
+		super();
+		this.value = value;
+		this.additionalOrderBy = additionalOrderBy;
+		this.partitionBy = partitionBy;
+		this.descending = descending;
+	}
+	toJSON() {
+		return {
+			type: "cumsum",
+			value: this.value.toJSON(),
+			additionalOrderBy: this.additionalOrderBy.map((expr) => expr.toJSON()),
+			partitionBy: this.partitionBy.map((expr) => expr.toJSON()),
+			descending: this.descending
+		};
+	}
+	getAlias() {
+		return this._alias || `cumsum_${this.value.getAlias()}`;
+	}
+	clone() {
+		const cloned = new CumsumExpressionImpl(this.value, this.additionalOrderBy, this.partitionBy, this.descending);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var AggregationExpressionImpl = class AggregationExpressionImpl extends ExpressionImpl {
+	constructor(operation, expr) {
+		super();
+		this.operation = operation;
+		this.expr = expr;
+	}
+	toJSON() {
+		return {
+			type: "aggregate",
+			aggregation: this.operation,
+			value: this.expr?.toJSON() || {
+				type: "const",
+				value: 1
+			},
+			partitionBy: []
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.operation}${this.expr ? "_" + this.expr.getAlias() : ""}`;
+	}
+	clone() {
+		const cloned = new AggregationExpressionImpl(this.operation, this.expr);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var WindowExpressionImpl = class WindowExpressionImpl extends ExpressionImpl {
+	constructor(expr, aggregation, partitionBy) {
+		super();
+		this.expr = expr;
+		this.aggregation = aggregation;
+		this.partitionBy = partitionBy;
+	}
+	toJSON() {
+		return {
+			type: "aggregate",
+			aggregation: this.aggregation,
+			value: this.expr.toJSON(),
+			partitionBy: this.partitionBy.map((expr) => expr.toJSON())
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_window`;
+	}
+	clone() {
+		const cloned = new WindowExpressionImpl(this.expr, this.aggregation, this.partitionBy);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var StringDistanceExpressionImpl = class StringDistanceExpressionImpl extends ExpressionImpl {
+	constructor(string1, string2, metric, returnSimilarity) {
+		super();
+		this.string1 = string1;
+		this.string2 = string2;
+		this.metric = metric;
+		this.returnSimilarity = returnSimilarity;
+	}
+	toJSON() {
+		return {
+			type: "string_distance",
+			metric: this.metric,
+			string1: this.string1.toJSON(),
+			string2: this.string2.toJSON(),
+			returnSimilarity: this.returnSimilarity || false
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.string1.getAlias()}_distance_${this.string2.getAlias()}`;
+	}
+	clone() {
+		const cloned = new StringDistanceExpressionImpl(this.string1, this.string2, this.metric, this.returnSimilarity);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var FuzzyStringFilterExpressionImpl = class FuzzyStringFilterExpressionImpl extends ExpressionImpl {
+	constructor(expr, pattern, metric, bound) {
+		super();
+		this.expr = expr;
+		this.pattern = pattern;
+		this.metric = metric;
+		this.bound = bound;
+	}
+	toJSON() {
+		return {
+			type: "fuzzy_string_filter",
+			metric: this.metric,
+			value: this.expr.toJSON(),
+			pattern: this.pattern.toJSON(),
+			bound: this.bound
+		};
+	}
+	getAlias() {
+		return this._alias || `${this.expr.getAlias()}_fuzzy_filter`;
+	}
+	clone() {
+		const cloned = new FuzzyStringFilterExpressionImpl(this.expr, this.pattern, this.metric, this.bound);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var RankExpressionImpl = class RankExpressionImpl extends ExpressionImpl {
+	constructor(orderBy, partitionBy, descending) {
+		super();
+		this.orderBy = orderBy;
+		this.partitionBy = partitionBy;
+		this.descending = descending;
+	}
+	toJSON() {
+		return {
+			type: "rank",
+			orderBy: this.orderBy.map((e) => e.toJSON()),
+			partitionBy: this.partitionBy.map((e) => e.toJSON()),
+			descending: this.descending || void 0
+		};
+	}
+	getAlias() {
+		const order = this.orderBy.map((e) => e.getAlias()).join("_");
+		const part = this.partitionBy.map((e) => e.getAlias()).join("_");
+		const dir = this.descending ? "desc" : "asc";
+		return this._alias || `rank_${order}${part ? `_over_${part}` : ""}_${dir}`;
+	}
+	clone() {
+		const cloned = new RankExpressionImpl(this.orderBy, this.partitionBy, this.descending);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
+var WhenThenOtherwiseExpressionImpl = class WhenThenOtherwiseExpressionImpl extends ExpressionImpl {
+	constructor(conditions, otherwiseValue) {
+		super();
+		this.conditions = conditions;
+		this.otherwiseValue = otherwiseValue;
+	}
+	toJSON() {
+		return {
+			type: "when_then_otherwise",
+			conditions: this.conditions.map((clause) => ({
+				when: clause.when.toJSON(),
+				then: clause.then.toJSON()
+			})),
+			otherwise: this.otherwiseValue.toJSON()
+		};
+	}
+	getAlias() {
+		return this._alias || "conditional";
+	}
+	clone() {
+		const cloned = new WhenThenOtherwiseExpressionImpl(this.conditions, this.otherwiseValue);
+		cloned._alias = this._alias;
+		return cloned;
+	}
+};
 
+//#endregion
 exports.AggregationExpressionImpl = AggregationExpressionImpl;
 exports.ArithmeticExpressionImpl = ArithmeticExpressionImpl;
 exports.ColumnExpressionImpl = ColumnExpressionImpl;
@@ -864,4 +781,4 @@ exports.UnaryArithmeticExpressionImpl = UnaryArithmeticExpressionImpl;
 exports.WhenThenOtherwiseExpressionImpl = WhenThenOtherwiseExpressionImpl;
 exports.WindowExpressionImpl = WindowExpressionImpl;
 exports.coerceToExpression = coerceToExpression;
-//# sourceMappingURL=expressions.cjs.map
+//# sourceMappingURL=expressions.cjs.map