@qrvey/formula-lang/dist/module/functions/isNull.js

QFormula support for qrvey projects

import { AST_PRIMITIVES, AST_TYPES } from '../constants';
import { ERROR_DICTIONARY, ERROR_LIST } from '../errors/dictionary';
import { isAColumn } from '../utils/isAColumn';
import { isALiteral } from '../utils/isALiteral';
import { inferPrimitive, isSinglePrimitive } from '../utils/primitiveFunctions';
/**
 * `ISNULL` Returns the replacement if the value is a null
 */
export const ISNULL = {
    identifier: 'ISNULL',
    parameters: [
        {
            identifier: 'VALUE',
            optional: false,
            validator: [samePrimitiveTypeCol],
        },
        {
            identifier: 'REPLACEMENT',
            optional: false,
            generic: true,
            validator: [samePrimitiveTypeNonCol],
        },
    ],
    transpiler: {
        elasticsearch,
        snowflake,
        redshift,
        postgresql,
    },
    primitiveResult(args) {
        return inferPrimitive(...args.map((arg) => arg.primitive));
    },
};
function samePrimitiveTypeCol(param, dataType, context) {
    const isColumn = isAColumn(context);
    const baseResult = samePrimitiveType(param, dataType, context);
    const valid = isColumn && baseResult.valid;
    const primitive = baseResult.mismatchData.primitive;
    return Object.assign(Object.assign(Object.assign(Object.assign({}, baseResult), { mismatchData: {
            type: AST_TYPES.column,
            primitive,
        } }), (!isColumn && Object.assign({}, ERROR_DICTIONARY[ERROR_LIST.missingColumnExpression]))), { valid });
}
function samePrimitiveTypeNonCol(param, dataType, context) {
    const isLiteral = isALiteral(context);
    const baseResult = samePrimitiveType(param, dataType, context);
    const valid = isLiteral && baseResult.valid;
    const primitive = baseResult.mismatchData.primitive;
    return Object.assign(Object.assign(Object.assign(Object.assign({}, baseResult), { mismatchData: {
            type: AST_TYPES.literal,
            primitive,
        } }), (!isLiteral && Object.assign({}, ERROR_DICTIONARY[ERROR_LIST.noColumnExpression]))), { valid });
}
function samePrimitiveType(_param, _dataType, context) {
    const firstPrimitive = primitiveArgIndex(context, 0);
    const secondPrimitive = primitiveArgIndex(context, 1);
    const ifPrimitive = calculateIsNullPrimitive(firstPrimitive, secondPrimitive);
    const valid = firstPrimitive === secondPrimitive;
    const baseResult = {
        valid,
        mismatchData: {
            primitive: ifPrimitive,
        },
    };
    if (!valid)
        return Object.assign(Object.assign({}, baseResult), ERROR_DICTIONARY[ERROR_LIST.inferredPrimitive]);
    return baseResult;
}
function primitiveArgIndex(context, index) {
    var _a;
    const basePrimitive = (_a = context.fnNode.arguments[index]) === null || _a === void 0 ? void 0 : _a.primitive;
    return isSinglePrimitive(basePrimitive)
        ? basePrimitive
        : AST_PRIMITIVES.UNKNOWN;
}
function calculateIsNullPrimitive(firstPrimitive, secondPrimitive) {
    if (firstPrimitive && firstPrimitive !== AST_PRIMITIVES.UNKNOWN)
        return firstPrimitive;
    return secondPrimitive !== null && secondPrimitive !== void 0 ? secondPrimitive : AST_PRIMITIVES.UNKNOWN;
}
function elasticsearch(value, replacement) {
    return `IS_NULL_SCRIPT(${value}, ${replacement})`;
}
function sql(value, replacement) {
    return `COALESCE(${value}, ${replacement})`;
}
function snowflake(value, replacement) {
    return sql(value, replacement);
}
function redshift(value, replacement) {
    return sql(value, replacement);
}
function postgresql(value, replacement) {
    return sql(value, replacement);
}
//# sourceMappingURL=isNull.js.map