rawsql-ts/dist/utils/ValueComponentRewriter.js

High-performance SQL parser and AST analyzer written in TypeScript. Provides fast parsing and advanced transformation capabilities.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.rewriteValueComponentWithColumnResolver = rewriteValueComponentWithColumnResolver;
const ValueComponent_1 = require("../models/ValueComponent");
const Clause_1 = require("../models/Clause");
function rewriteValueComponentWithColumnResolver(value, resolver) {
    if (value instanceof ValueComponent_1.ColumnReference) {
        return resolver(value);
    }
    if (value instanceof ValueComponent_1.FunctionCall) {
        const rewrittenArgument = value.argument
            ? rewriteValueComponentWithColumnResolver(value.argument, resolver)
            : null;
        const rewrittenOver = value.over ? rewriteOverExpression(value.over, resolver) : null;
        const rewrittenWithinGroup = value.withinGroup
            ? rewriteOrderByClause(value.withinGroup, resolver)
            : null;
        const rewrittenInternalOrderBy = value.internalOrderBy
            ? rewriteOrderByClause(value.internalOrderBy, resolver)
            : null;
        // Preserve FILTER predicates so aggregate behaviour remains intact.
        const rewrittenFilterCondition = value.filterCondition
            ? rewriteValueComponentWithColumnResolver(value.filterCondition, resolver)
            : null;
        return new ValueComponent_1.FunctionCall(value.qualifiedName.namespaces, value.qualifiedName.name, rewrittenArgument, rewrittenOver, rewrittenWithinGroup, value.withOrdinality, rewrittenInternalOrderBy, rewrittenFilterCondition);
    }
    if (value instanceof ValueComponent_1.UnaryExpression) {
        const rewrittenExpression = rewriteValueComponentWithColumnResolver(value.expression, resolver);
        return new ValueComponent_1.UnaryExpression(value.operator.value, rewrittenExpression);
    }
    if (value instanceof ValueComponent_1.BinaryExpression) {
        const left = rewriteValueComponentWithColumnResolver(value.left, resolver);
        const right = rewriteValueComponentWithColumnResolver(value.right, resolver);
        return new ValueComponent_1.BinaryExpression(left, value.operator.value, right);
    }
    if (value instanceof ValueComponent_1.JsonPredicateExpression) {
        const expression = rewriteValueComponentWithColumnResolver(value.expression, resolver);
        return new ValueComponent_1.JsonPredicateExpression(expression, value.negated, value.jsonType, value.uniqueKeys);
    }
    if (value instanceof ValueComponent_1.CaseExpression) {
        const condition = value.condition
            ? rewriteValueComponentWithColumnResolver(value.condition, resolver)
            : null;
        const switchCase = rewriteSwitchCaseArgument(value.switchCase, resolver);
        return new ValueComponent_1.CaseExpression(condition, switchCase);
    }
    if (value instanceof ValueComponent_1.SwitchCaseArgument) {
        return rewriteSwitchCaseArgument(value, resolver);
    }
    if (value instanceof ValueComponent_1.CaseKeyValuePair) {
        return rewriteCaseKeyValuePair(value, resolver);
    }
    if (value instanceof ValueComponent_1.BetweenExpression) {
        const expression = rewriteValueComponentWithColumnResolver(value.expression, resolver);
        const lower = rewriteValueComponentWithColumnResolver(value.lower, resolver);
        const upper = rewriteValueComponentWithColumnResolver(value.upper, resolver);
        return new ValueComponent_1.BetweenExpression(expression, lower, upper, value.negated);
    }
    if (value instanceof ValueComponent_1.CastExpression) {
        const input = rewriteValueComponentWithColumnResolver(value.input, resolver);
        const castType = rewriteTypeValue(value.castType, resolver);
        return new ValueComponent_1.CastExpression(input, castType);
    }
    if (value instanceof ValueComponent_1.ParenExpression) {
        const expression = rewriteValueComponentWithColumnResolver(value.expression, resolver);
        return new ValueComponent_1.ParenExpression(expression);
    }
    if (value instanceof ValueComponent_1.TupleExpression) {
        const rewrittenValues = value.values.map((item) => rewriteValueComponentWithColumnResolver(item, resolver));
        return new ValueComponent_1.TupleExpression(rewrittenValues);
    }
    if (value instanceof ValueComponent_1.ArrayExpression) {
        const expression = rewriteValueComponentWithColumnResolver(value.expression, resolver);
        return new ValueComponent_1.ArrayExpression(expression);
    }
    if (value instanceof ValueComponent_1.ArraySliceExpression) {
        const array = rewriteValueComponentWithColumnResolver(value.array, resolver);
        const startIndex = value.startIndex
            ? rewriteValueComponentWithColumnResolver(value.startIndex, resolver)
            : null;
        const endIndex = value.endIndex
            ? rewriteValueComponentWithColumnResolver(value.endIndex, resolver)
            : null;
        return new ValueComponent_1.ArraySliceExpression(array, startIndex, endIndex);
    }
    if (value instanceof ValueComponent_1.ArrayIndexExpression) {
        const array = rewriteValueComponentWithColumnResolver(value.array, resolver);
        const index = rewriteValueComponentWithColumnResolver(value.index, resolver);
        return new ValueComponent_1.ArrayIndexExpression(array, index);
    }
    if (value instanceof ValueComponent_1.ArrayQueryExpression) {
        return value;
    }
    if (value instanceof ValueComponent_1.ValueList) {
        const rewrittenList = value.values.map((item) => rewriteValueComponentWithColumnResolver(item, resolver));
        return new ValueComponent_1.ValueList(rewrittenList);
    }
    if (value instanceof ValueComponent_1.InlineQuery) {
        return value;
    }
    if (value instanceof ValueComponent_1.WindowFrameExpression) {
        return rewriteWindowFrameExpression(value, resolver);
    }
    if (value instanceof ValueComponent_1.WindowFrameSpec) {
        return rewriteWindowFrameSpec(value, resolver);
    }
    if (value instanceof ValueComponent_1.WindowFrameBoundaryValue) {
        const rewrittenValue = rewriteValueComponentWithColumnResolver(value.value, resolver);
        return new ValueComponent_1.WindowFrameBoundaryValue(rewrittenValue, value.isFollowing);
    }
    if (value instanceof ValueComponent_1.WindowFrameBoundStatic) {
        return value;
    }
    if (value instanceof ValueComponent_1.TypeValue) {
        return rewriteTypeValue(value, resolver);
    }
    if (value instanceof ValueComponent_1.StringSpecifierExpression) {
        return value;
    }
    if (value instanceof ValueComponent_1.LiteralValue || value instanceof ValueComponent_1.RawString || value instanceof ValueComponent_1.IdentifierString) {
        return value;
    }
    if (value instanceof ValueComponent_1.ParameterExpression) {
        return value;
    }
    return value;
}
function rewriteSwitchCaseArgument(argument, resolver) {
    const rewrittenCases = argument.cases.map((pair) => rewriteCaseKeyValuePair(pair, resolver));
    const elseValue = argument.elseValue
        ? rewriteValueComponentWithColumnResolver(argument.elseValue, resolver)
        : null;
    return new ValueComponent_1.SwitchCaseArgument(rewrittenCases, elseValue);
}
function rewriteCaseKeyValuePair(pair, resolver) {
    const key = rewriteValueComponentWithColumnResolver(pair.key, resolver);
    const value = rewriteValueComponentWithColumnResolver(pair.value, resolver);
    return new ValueComponent_1.CaseKeyValuePair(key, value);
}
function rewriteOrderByClause(clause, resolver) {
    const rewrittenOrder = clause.order.map((component) => rewriteOrderByComponent(component, resolver));
    return new Clause_1.OrderByClause(rewrittenOrder);
}
function rewriteOrderByComponent(component, resolver) {
    if (component instanceof Clause_1.OrderByItem) {
        const rewrittenValue = rewriteValueComponentWithColumnResolver(component.value, resolver);
        return new Clause_1.OrderByItem(rewrittenValue, component.sortDirection, component.nullsPosition);
    }
    return rewriteValueComponentWithColumnResolver(component, resolver);
}
function rewriteOverExpression(over, resolver) {
    if (over instanceof ValueComponent_1.WindowFrameExpression) {
        return rewriteWindowFrameExpression(over, resolver);
    }
    return over;
}
function rewriteWindowFrameExpression(expression, resolver) {
    const partition = expression.partition
        ? rewritePartitionByClause(expression.partition, resolver)
        : null;
    const order = expression.order ? rewriteOrderByClause(expression.order, resolver) : null;
    const frameSpec = expression.frameSpec
        ? rewriteWindowFrameSpec(expression.frameSpec, resolver)
        : null;
    return new ValueComponent_1.WindowFrameExpression(partition, order, frameSpec);
}
function rewritePartitionByClause(clause, resolver) {
    const value = rewriteValueComponentWithColumnResolver(clause.value, resolver);
    return new Clause_1.PartitionByClause(value);
}
function rewriteWindowFrameSpec(spec, resolver) {
    const startBound = rewriteFrameBoundaryComponent(spec.startBound, resolver);
    const endBound = spec.endBound
        ? rewriteFrameBoundaryComponent(spec.endBound, resolver)
        : null;
    return new ValueComponent_1.WindowFrameSpec(spec.frameType, startBound, endBound);
}
function rewriteFrameBoundaryComponent(bound, resolver) {
    if (bound instanceof ValueComponent_1.WindowFrameBoundaryValue) {
        const value = rewriteValueComponentWithColumnResolver(bound.value, resolver);
        return new ValueComponent_1.WindowFrameBoundaryValue(value, bound.isFollowing);
    }
    return bound;
}
function rewriteTypeValue(value, resolver) {
    const argument = value.argument
        ? rewriteValueComponentWithColumnResolver(value.argument, resolver)
        : null;
    return new ValueComponent_1.TypeValue(value.namespaces, value.qualifiedName.name, argument);
}
//# sourceMappingURL=ValueComponentRewriter.js.map