@milaboratories/ptabler-expression-js 1.1.0

package/dist/expressions.cjs

@@ -0,0 +1,867 @@
+'use strict';
+
+/**
+ * Base expressionImpl classes and interfaces for PTabler JavaScript implementation
+ */
+/**
+ * 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
+ */
+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;
+    }
+}
+
+exports.AggregationExpressionImpl = AggregationExpressionImpl;
+exports.ArithmeticExpressionImpl = ArithmeticExpressionImpl;
+exports.ColumnExpressionImpl = ColumnExpressionImpl;
+exports.ComparisonExpressionImpl = ComparisonExpressionImpl;
+exports.CumsumExpressionImpl = CumsumExpressionImpl;
+exports.ExpressionImpl = ExpressionImpl;
+exports.FillNaNExpressionImpl = FillNaNExpressionImpl;
+exports.FillNullExpressionImpl = FillNullExpressionImpl;
+exports.FuzzyStringFilterExpressionImpl = FuzzyStringFilterExpressionImpl;
+exports.LiteralExpressionImpl = LiteralExpressionImpl;
+exports.LogicalExpressionImpl = LogicalExpressionImpl;
+exports.MinMaxExpressionImpl = MinMaxExpressionImpl;
+exports.NullCheckExpressionImpl = NullCheckExpressionImpl;
+exports.RankExpressionImpl = RankExpressionImpl;
+exports.StringCaseExpressionImpl = StringCaseExpressionImpl;
+exports.StringConcatExpressionImpl = StringConcatExpressionImpl;
+exports.StringContainsExpressionImpl = StringContainsExpressionImpl;
+exports.StringDistanceExpressionImpl = StringDistanceExpressionImpl;
+exports.StringEndsWithExpressionImpl = StringEndsWithExpressionImpl;
+exports.StringReplaceExpressionImpl = StringReplaceExpressionImpl;
+exports.StringStartsWithExpressionImpl = StringStartsWithExpressionImpl;
+exports.SubstringExpressionImpl = SubstringExpressionImpl;
+exports.UnaryArithmeticExpressionImpl = UnaryArithmeticExpressionImpl;
+exports.WhenThenOtherwiseExpressionImpl = WhenThenOtherwiseExpressionImpl;
+exports.WindowExpressionImpl = WindowExpressionImpl;
+exports.coerceToExpression = coerceToExpression;
+//# sourceMappingURL=expressions.cjs.map