@adaptabletools/adaptable 10.0.0-canary.0

package/src/Utilities/Defaults/DefaultSparklinesChartProperties.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSparklinesChartProperties = void 0;
+const ChartEnums_1 = require("../../PredefinedConfig/Common/ChartEnums");
+exports.DefaultSparklinesChartProperties = {
+    DisplayType: ChartEnums_1.SparklineTypeEnum.Line,
+    UseMaxStaticValue: false,
+    UseMinStaticValue: false,
+    // Brush -- want to use same colour as UI but cannot re-use the constants
+    Brush: '#006400',
+    NegativeBrush: '#8B0000',
+    // Marker Visibility
+    HighMarkerVisibility: 'Visible',
+    LowMarkerVisibility: 'Visible',
+    FirstMarkerVisibility: 'Visible',
+    LastMarkerVisibility: 'Visible',
+    NegativeMarkerVisibility: 'Visible',
+    MarkerVisibility: 'Collapsed',
+    // Marker Brush
+    FirstMarkerBrush: 'Gray',
+    LastMarkerBrush: 'Gray',
+    HighMarkerBrush: 'DarkBlue',
+    LowMarkerBrush: 'Purple',
+    NegativeMarkerBrush: 'Red',
+};

package/src/Utilities/Emitter.d.ts

@@ -0,0 +1,21 @@
+/** based on emittery npm package, which is MIT */
+export declare type EmitterCallback = (data?: any) => any;
+export declare type EmitterAnyCallback = (eventName: string, data?: any) => any;
+declare class Emittery {
+    static mixin(emitteryPropertyName: string, methodNames: string[]): (target: any) => any;
+    constructor();
+    on(eventName: string, listener: EmitterCallback): any;
+    off(eventName: string, listener: EmitterCallback): void;
+    once(eventName: string): Promise<unknown>;
+    onIncludeFiredOnce(eventName: string): Promise<any>;
+    onIncludeFired(eventName: string, listener: EmitterCallback): any;
+    emit(eventName: string, eventData?: any): Promise<any[]>;
+    emitSync(eventName: string, eventData?: any): any[];
+    emitSerial(eventName: string, eventData: any): Promise<void>;
+    onAny(listener: EmitterAnyCallback): any;
+    offAny(listener: EmitterCallback): void;
+    clearListeners(eventName?: string): void;
+    listenerCount(eventName: string): any;
+    bindMethods(target: any, methodNames: string[]): void;
+}
+export default Emittery;

package/src/Utilities/Emitter.js

@@ -0,0 +1,232 @@
+"use strict";
+/** based on emittery npm package, which is MIT */
+Object.defineProperty(exports, "__esModule", { value: true });
+const anyMap = new WeakMap();
+const eventsMap = new WeakMap();
+const triggeredMap = new WeakMap();
+const resolvedPromise = Promise.resolve();
+//type EmitterCallback = (data?: any) => any;
+function assertEventName(eventName) {
+    if (typeof eventName !== 'string') {
+        throw new TypeError('eventName must be a string');
+    }
+}
+function assertListener(listener) {
+    if (typeof listener !== 'function') {
+        throw new TypeError('listener must be a function');
+    }
+}
+function getListeners(instance, eventName) {
+    const events = eventsMap.get(instance);
+    if (!events.has(eventName)) {
+        events.set(eventName, new Set());
+    }
+    return events.get(eventName);
+}
+function defaultMethodNamesOrAssert(methodNames) {
+    if (methodNames === undefined) {
+        return allEmitteryMethods;
+    }
+    if (!Array.isArray(methodNames)) {
+        throw new TypeError('`methodNames` must be an array of strings');
+    }
+    for (const methodName of methodNames) {
+        if (!allEmitteryMethods.includes(methodName)) {
+            if (typeof methodName !== 'string') {
+                throw new TypeError('`methodNames` element must be a string');
+            }
+            throw new Error(`${methodName} is not Emittery method`);
+        }
+    }
+    return methodNames;
+}
+class Emittery {
+    static mixin(emitteryPropertyName, methodNames) {
+        methodNames = defaultMethodNamesOrAssert(methodNames);
+        return (target) => {
+            if (typeof target !== 'function') {
+                throw new TypeError('`target` must be function');
+            }
+            for (const methodName of methodNames) {
+                if (target.prototype[methodName] !== undefined) {
+                    throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+                }
+            }
+            function getEmitteryProperty() {
+                Object.defineProperty(this, emitteryPropertyName, {
+                    enumerable: false,
+                    value: new Emittery(),
+                });
+                return this[emitteryPropertyName];
+            }
+            Object.defineProperty(target.prototype, emitteryPropertyName, {
+                enumerable: false,
+                get: getEmitteryProperty,
+            });
+            const emitteryMethodCaller = (methodName) => function (...args) {
+                return this[emitteryPropertyName][methodName](...args);
+            };
+            for (const methodName of methodNames) {
+                Object.defineProperty(target.prototype, methodName, {
+                    enumerable: false,
+                    value: emitteryMethodCaller(methodName),
+                });
+            }
+            return target;
+        };
+    }
+    constructor() {
+        anyMap.set(this, new Set());
+        eventsMap.set(this, new Map());
+        triggeredMap.set(this, new Map());
+    }
+    on(eventName, listener) {
+        assertEventName(eventName);
+        assertListener(listener);
+        getListeners(this, eventName).add(listener);
+        return this.off.bind(this, eventName, listener);
+    }
+    off(eventName, listener) {
+        assertEventName(eventName);
+        assertListener(listener);
+        getListeners(this, eventName).delete(listener);
+    }
+    once(eventName) {
+        return new Promise((resolve) => {
+            assertEventName(eventName);
+            const off = this.on(eventName, (data) => {
+                off();
+                resolve(data);
+            });
+        });
+    }
+    onIncludeFiredOnce(eventName) {
+        const triggeredEventsMap = triggeredMap.get(this);
+        const eventInfo = triggeredEventsMap.get(eventName);
+        if (eventInfo) {
+            return Promise.resolve(eventInfo.data);
+        }
+        return this.once(eventName);
+    }
+    onIncludeFired(eventName, listener) {
+        const triggeredEventsMap = triggeredMap.get(this);
+        const eventInfo = triggeredEventsMap.get(eventName);
+        if (eventInfo) {
+            listener(eventInfo.data);
+        }
+        return this.on(eventName, listener);
+    }
+    async emit(eventName, eventData) {
+        assertEventName(eventName);
+        const listeners = getListeners(this, eventName);
+        const triggeredEventsMap = triggeredMap.get(this);
+        const anyListeners = anyMap.get(this);
+        const staticListeners = [...listeners];
+        const staticAnyListeners = [...anyListeners];
+        triggeredEventsMap.set(eventName, { data: eventData });
+        await resolvedPromise;
+        return Promise.all([
+            ...staticListeners.map(async (listener) => {
+                if (listeners.has(listener)) {
+                    return listener(eventData);
+                }
+            }),
+            ...staticAnyListeners.map(async (listener) => {
+                if (anyListeners.has(listener)) {
+                    return listener(eventName, eventData);
+                }
+            }),
+        ]);
+    }
+    emitSync(eventName, eventData) {
+        assertEventName(eventName);
+        const listeners = getListeners(this, eventName);
+        const triggeredEventsMap = triggeredMap.get(this);
+        const anyListeners = anyMap.get(this);
+        const staticListeners = [...listeners];
+        const staticAnyListeners = [...anyListeners];
+        triggeredEventsMap.set(eventName, { data: eventData });
+        return [
+            ...staticListeners.map((listener) => {
+                if (listeners.has(listener)) {
+                    return listener(eventData);
+                }
+            }),
+            ...staticAnyListeners.map((listener) => {
+                if (anyListeners.has(listener)) {
+                    return listener(eventName, eventData);
+                }
+            }),
+        ];
+    }
+    async emitSerial(eventName, eventData) {
+        assertEventName(eventName);
+        const listeners = getListeners(this, eventName);
+        const anyListeners = anyMap.get(this);
+        const staticListeners = [...listeners];
+        const staticAnyListeners = [...anyListeners];
+        await resolvedPromise;
+        /* eslint-disable no-await-in-loop */
+        for (const listener of staticListeners) {
+            if (listeners.has(listener)) {
+                await listener(eventData);
+            }
+        }
+        for (const listener of staticAnyListeners) {
+            if (anyListeners.has(listener)) {
+                await listener(eventName, eventData);
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+    }
+    onAny(listener) {
+        assertListener(listener);
+        anyMap.get(this).add(listener);
+        return this.offAny.bind(this, listener);
+    }
+    offAny(listener) {
+        assertListener(listener);
+        anyMap.get(this).delete(listener);
+    }
+    clearListeners(eventName) {
+        if (typeof eventName === 'string') {
+            getListeners(this, eventName).clear();
+        }
+        else {
+            anyMap.get(this).clear();
+            for (const listeners of eventsMap.get(this).values()) {
+                listeners.clear();
+            }
+        }
+    }
+    listenerCount(eventName) {
+        if (typeof eventName === 'string') {
+            return anyMap.get(this).size + getListeners(this, eventName).size;
+        }
+        if (typeof eventName !== 'undefined') {
+            assertEventName(eventName);
+        }
+        let count = anyMap.get(this).size;
+        for (const value of eventsMap.get(this).values()) {
+            count += value.size;
+        }
+        return count;
+    }
+    bindMethods(target, methodNames) {
+        if (typeof target !== 'object' || target === null) {
+            throw new TypeError('`target` must be an object');
+        }
+        methodNames = defaultMethodNamesOrAssert(methodNames);
+        for (const methodName of methodNames) {
+            if (target[methodName] !== undefined) {
+                throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+            }
+            Object.defineProperty(target, methodName, {
+                enumerable: false,
+                value: this[methodName].bind(this),
+            });
+        }
+    }
+}
+const allEmitteryMethods = Object.getOwnPropertyNames(Emittery.prototype).filter((v) => v !== 'constructor');
+exports.default = Emittery;

package/src/Utilities/ExpressionFunctions/ExpressionEvaluationError.d.ts

@@ -0,0 +1,4 @@
+export declare class ExpressionEvaluationError extends Error {
+    readonly expressionFnName: string;
+    constructor(expressionFnName: string, message: string);
+}

package/src/Utilities/ExpressionFunctions/ExpressionEvaluationError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionEvaluationError = void 0;
+class ExpressionEvaluationError extends Error {
+    constructor(expressionFnName, message) {
+        super(message);
+        this.expressionFnName = expressionFnName;
+        this.name = 'ExpressionEvaluationError';
+    }
+}
+exports.ExpressionEvaluationError = ExpressionEvaluationError;

package/src/Utilities/ExpressionFunctions/aggregationExpressionFunctions.d.ts

@@ -0,0 +1,6 @@
+import { ExpressionFunction } from '../../parser/src/types';
+declare type AggregationFunctionName = 'WHERE' | 'COL' | AggregationFunction | ComparisonFunction;
+declare type AggregationFunction = 'SUM';
+declare type ComparisonFunction = 'EQ' | 'NEQ' | 'LT' | 'GT' | 'LTE' | 'GTE';
+export declare const aggregationExpressionFunctions: Record<AggregationFunctionName, ExpressionFunction>;
+export {};

package/src/Utilities/ExpressionFunctions/aggregationExpressionFunctions.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregationExpressionFunctions = void 0;
+const tslib_1 = require("tslib");
+const rxjs_1 = require("rxjs");
+const parseInt_1 = tslib_1.__importDefault(require("lodash-es/parseInt"));
+const ExpressionEvaluationError_1 = require("./ExpressionEvaluationError");
+const operators_1 = require("rxjs/operators");
+const reactiveExpressionFunctionUtils_1 = require("./reactiveExpressionFunctionUtils");
+const aggregationScalarOperandMap = {
+    SUM: ['string', 'number'],
+};
+// 0. optional non-capturing block of empty spaces
+// 1. block containing a numeric value (any digits) (required)
+// 2. block containing a single 'K', 'M' or 'B' letter (optional) (case insensitive)
+const CRITERIA_REGEX = /^(?:\s*)(\d+)(K|M|B)?$/i;
+exports.aggregationExpressionFunctions = {
+    WHERE: {
+        handler(args, context) {
+            return reactiveExpressionFunctionUtils_1.handleWhereFunction(args, context, exports.aggregationExpressionFunctions);
+        },
+        isHiddenFromMenu: true,
+        description: 'Splits 2 composed queries, allowing for a main query(lhs) to have a where clause query(rhs) defined',
+        signatures: ['<main_query> WHERE <boolean_query>'],
+        examples: ['<main_query> WHERE <boolean_query>', '<main_query> WHERE QUERY("abc")'],
+        hasEagerEvaluation: true,
+    },
+    SUM: {
+        handler(args, context) {
+            const columnParameter = reactiveExpressionFunctionUtils_1.extractColumnParameter('SUM', args);
+            reactiveExpressionFunctionUtils_1.validateColumnType(columnParameter.value, ['Number'], 'SUM', context.api);
+            const sumAggregationFn = (dataSource$) => getSumAggregation$(dataSource$, getColumnValueSum(columnParameter.value, context));
+            const result = {
+                type: 'aggregation',
+                name: 'SUM',
+                column: columnParameter.value,
+                aggregationFn: sumAggregationFn,
+            };
+            return result;
+        },
+        description: 'Aggregates a column over multiple rows by summing up the column values',
+        signatures: ['SUM( [colName] )', 'SUM( COL(name: string) )'],
+        examples: ['SUM( [colA] )', "SUM( COL('col1') )"],
+    },
+    COL: {
+        handler(args, context) {
+            return reactiveExpressionFunctionUtils_1.handleColumnFunction(args, context);
+        },
+        description: 'References a grid column by name',
+        signatures: ['[colName]', 'COL(name: string)'],
+        examples: ['[col1]', "COL('col1')"],
+    },
+    EQ: {
+        handler(args, context) {
+            return handleAggregationCondition(args, context, '=', (aggregatedValue, conditionValue) => aggregatedValue === conditionValue);
+        },
+        isHiddenFromMenu: true,
+        description: 'Evaluates if the aggregation result is equals a numerical value defined either as a number or a string abbreviation for thousands(K), millions(M) or billions(B)',
+        signatures: [
+            'SUM() = number',
+            `SUM() = '%number%(K|M|B)'`,
+            'EQ(a: SUM(), b: number)',
+            `EQ(a: SUM(), b: '%number%(K|M|B)')`,
+        ],
+        examples: [`SUM([col1]) = '5M'`, 'EQ( SUM([col1]), 250000)'],
+    },
+    NEQ: {
+        handler(args, context) {
+            return handleAggregationCondition(args, context, '!=', (aggregatedValue, conditionValue) => aggregatedValue !== conditionValue);
+        },
+        isHiddenFromMenu: true,
+        description: 'Evaluates if the aggregation result is NOT equal with a numerical value defined either as a number or a string abbreviation for thousands(K), millions(M) or billions(B)',
+        signatures: [
+            'SUM() != number',
+            `SUM() != '%number%(K|M|B)'`,
+            'NEQ(a: SUM(), b: number)',
+            `NEQ(a: SUM(), b: '%number%(K|M|B)')`,
+        ],
+        examples: [`SUM([col1]) != '5M'`, 'NEQ( SUM([col1]), 250000)'],
+    },
+    LT: {
+        handler(args, context) {
+            return handleAggregationCondition(args, context, '<', (aggregatedValue, conditionValue) => aggregatedValue < conditionValue);
+        },
+        isHiddenFromMenu: true,
+        description: 'Evaluates if the aggregation result is less than a numerical value defined either as a number or a string abbreviation for thousands(K), millions(M) or billions(B)',
+        signatures: [
+            'SUM() < number',
+            `SUM() < '%number%(K|M|B)'`,
+            'LT(a: SUM(), b: number)',
+            `LT(a: SUM(), b: '%number%(K|M|B)')`,
+        ],
+        examples: [`SUM([col1]) < '5M'`, 'LT( SUM([col1]), 250000)'],
+    },
+    LTE: {
+        handler(args, context) {
+            return handleAggregationCondition(args, context, '<=', (aggregatedValue, conditionValue) => aggregatedValue <= conditionValue);
+        },
+        isHiddenFromMenu: true,
+        description: 'Evaluates if the aggregation result is less than or equals a numerical value defined either as a number or a string abbreviation for thousands(K), millions(M) or billions(B)',
+        signatures: [
+            'SUM() <= number',
+            `SUM() <= '%number%(K|M|B)'`,
+            'LTE(a: SUM(), b: number)',
+            `LTE(a: SUM(), b: '%number%(K|M|B)')`,
+        ],
+        examples: [`SUM([col1]) <= '5M'`, 'LTE( SUM([col1]), 250000)'],
+    },
+    GT: {
+        handler(args, context) {
+            return handleAggregationCondition(args, context, '>', (aggregatedValue, conditionValue) => aggregatedValue > conditionValue);
+        },
+        isHiddenFromMenu: true,
+        description: 'Evaluates if the aggregation result is greater than a numerical value defined either as a number or a string abbreviation for thousands(K), millions(M) or billions(B)',
+        signatures: [
+            'SUM() > number',
+            `SUM() > '%number%(K|M|B)'`,
+            'GT(a: SUM(), b: number)',
+            `GT(a: SUM(), b: '%number%(K|M|B)')`,
+        ],
+        examples: [`SUM([col1]) > '5M'`, 'GT( SUM([col1]), 250000)'],
+    },
+    GTE: {
+        handler(args, context) {
+            return handleAggregationCondition(args, context, '>=', (aggregatedValue, conditionValue) => aggregatedValue >= conditionValue);
+        },
+        isHiddenFromMenu: true,
+        description: 'Evaluates if the aggregation result is greater than or equals a numerical value defined either as a number or a string abbreviation for thousands(K), millions(M) or billions(B)',
+        signatures: [
+            'SUM() >= number',
+            `SUM() >= '%number%(K|M|B)'`,
+            'GTE(a: SUM(), b: number)',
+            `GTE(a: SUM(), b: '%number%(K|M|B)')`,
+        ],
+        examples: [`SUM([col1]) >= '5M'`, 'GTE( SUM([col1]), 250000)'],
+    },
+};
+const handleAggregationCondition = (args, context, comparisonOperator, conditionFn) => {
+    // LHS
+    const aggregationOperand = extractAggregationOperand(comparisonOperator, ['SUM'], args[0]);
+    // RHS
+    const scalarOperand = extractScalarOperand(comparisonOperator, args[1], aggregationScalarOperandMap[aggregationOperand.name]);
+    let dataChangeLog$ = reactiveExpressionFunctionUtils_1.getDataChangeLog$(context, aggregationOperand.column);
+    const aggregatedValue$ = aggregationOperand.aggregationFn(dataChangeLog$);
+    return dataChangeLog$.pipe(operators_1.withLatestFrom(aggregatedValue$), operators_1.filter(([_, currentAggregationValue]) => {
+        // check if new aggregated value satisfies the criteria
+        return conditionFn(currentAggregationValue, scalarOperand);
+    }), operators_1.map(([source]) => source));
+};
+const extractAggregationOperand = (consumingFunctionName, allowedAggregations, argument) => {
+    const result = argument;
+    if (argument == undefined ||
+        argument.type !== 'aggregation' ||
+        !allowedAggregations.includes(argument.name)) {
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `comparison operator expects as a left-hand operand an aggregation function of type '${allowedAggregations.join(' | ')}'`);
+    }
+    return result;
+};
+const extractScalarOperand = (consumingFunctionName, value, allowedTypes) => {
+    var _a;
+    if (value == undefined || !allowedTypes.find((allowedType) => typeof value === allowedType)) {
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `comparison operator expects as a right-hand operand a scalar value of type '${allowedTypes.join(' | ')}'`);
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    // assertion is safe, we checked in the IF above
+    const stringValue = value;
+    const matchingResult = stringValue.match(CRITERIA_REGEX);
+    const numericString = matchingResult === null || matchingResult === void 0 ? void 0 : matchingResult[1];
+    const largeNumberUnit = (_a = matchingResult === null || matchingResult === void 0 ? void 0 : matchingResult[2]) !== null && _a !== void 0 ? _a : 'number';
+    if (!numericString) {
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError('Numeric abbreviation', `"${stringValue}" is invalid, expecting a number with a suffix for thousands(K), millions(M) or billions(B)"`);
+    }
+    // unit -> number
+    const numberUnitRatios = {
+        number: 1,
+        k: 1000,
+        m: 1000000,
+        b: 1000000000,
+    };
+    // numeric value
+    return parseInt_1.default(numericString) * numberUnitRatios[largeNumberUnit.toLowerCase()];
+};
+const getSumAggregation$ = (source$, initialSum) => {
+    return rxjs_1.defer(() => {
+        let sumValue = initialSum;
+        const updateSum = (dataChangeLog) => {
+            const oldValue = reactiveExpressionFunctionUtils_1.getNumericValue(dataChangeLog.oldValue);
+            const newValue = reactiveExpressionFunctionUtils_1.getNumericValue(dataChangeLog.newValue);
+            sumValue = sumValue - oldValue + newValue;
+        };
+        return source$.pipe(operators_1.tap((dataChangeLog) => updateSum(dataChangeLog)), operators_1.map(() => sumValue));
+    });
+};
+const getColumnValueSum = (column, context) => {
+    let sum = 0;
+    context.api.internalApi.getAdaptableInstance().forAllRowNodesDo((rowNode) => {
+        var _a;
+        // if there is a WHERE clause defined, check if the current rowNode satisfies the condition
+        if (context.filterFn && !context.filterFn(rowNode)) {
+            return;
+        }
+        const cellValue = (_a = rowNode.data) === null || _a === void 0 ? void 0 : _a[column];
+        // cell value may not always be defined (ex. group nodes)
+        if (cellValue != undefined) {
+            sum = sum + reactiveExpressionFunctionUtils_1.getNumericValue(rowNode.data[column]);
+        }
+    });
+    return sum;
+};

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.d.ts

@@ -0,0 +1,53 @@
+import { ExpressionFunction } from '../../parser/src/types';
+export declare const defaultFunctions: {
+    ADD: ExpressionFunction;
+    SUB: ExpressionFunction;
+    MUL: ExpressionFunction;
+    DIV: ExpressionFunction;
+    MOD: ExpressionFunction;
+    POW: ExpressionFunction;
+    OR: ExpressionFunction;
+    AND: ExpressionFunction;
+    NOT: ExpressionFunction;
+    IF: ExpressionFunction;
+    EQ: ExpressionFunction;
+    NEQ: ExpressionFunction;
+    LT: ExpressionFunction;
+    LTE: ExpressionFunction;
+    GT: ExpressionFunction;
+    GTE: ExpressionFunction;
+    COL: ExpressionFunction;
+    MIN: ExpressionFunction;
+    MAX: ExpressionFunction;
+    AVG: ExpressionFunction;
+    BETWEEN: ExpressionFunction;
+    IN: ExpressionFunction;
+    DATE: ExpressionFunction;
+    NOW: ExpressionFunction;
+    TODAY: ExpressionFunction;
+    DAY: ExpressionFunction;
+    WEEK: ExpressionFunction;
+    MONTH: ExpressionFunction;
+    YEAR: ExpressionFunction;
+    ADD_DAYS: ExpressionFunction;
+    ADD_WEEKS: ExpressionFunction;
+    ADD_MONTHS: ExpressionFunction;
+    ADD_YEARS: ExpressionFunction;
+    DIFF_DAYS: ExpressionFunction;
+    DIFF_WEEKS: ExpressionFunction;
+    DIFF_MONTHS: ExpressionFunction;
+    DIFF_YEARS: ExpressionFunction;
+    IS_BLANK: ExpressionFunction;
+    CONTAINS: ExpressionFunction;
+    STARTS_WITH: ExpressionFunction;
+    ENDS_WITH: ExpressionFunction;
+    SUB_STRING: ExpressionFunction;
+    LEN: ExpressionFunction;
+    UPPER: ExpressionFunction;
+    LOWER: ExpressionFunction;
+    REPLACE: ExpressionFunction;
+    COALESCE: ExpressionFunction;
+    CONCAT: ExpressionFunction;
+    ANY_CONTAINS: ExpressionFunction;
+    QUERY: ExpressionFunction;
+};