Method evaluateLiteral

src/binder/expression/expression_util.cpp:490–518

template<typename T>
T ExpressionUtil::evaluateLiteral(main::ClientContext* context,
    std::shared_ptr<Expression> expression, const common::LogicalType& type,
    validate_param_func<T> validateParamFunc) {
    if (!canEvaluateAsLiteral(*expression)) {
        std::string errMsg;
        switch (expression->expressionType) {
        case ExpressionType::PARAMETER: {
            errMsg = std::format(
                "The expression: '{}' is a parameter expression. Please assign it a value.",
                expression->toString());
        } break;
        default: {
            errMsg = std::format("The expression: '{}' must be a parameter/literal expression.",
                expression->toString());
            ;
        } break;
        }
        throw RuntimeException{errMsg};
    }
    if (expression->getDataType() != type) {
        binder::Binder binder{context};
        auto literalExpr = std::make_shared<LiteralExpression>(
            ExpressionUtil::evaluateAsLiteralValue(*expression), expression->getUniqueName());
        expression = binder.getExpressionBinder()->implicitCast(literalExpr, type.copy());
        expression = binder.getExpressionBinder()->foldExpression(expression);
    }
    auto value = evaluateAsLiteralValue(*expression);
    return getExpressionVal(*expression, value, type, validateParamFunc);
}

std::shared_ptr<Expression> ExpressionUtil::applyImplicitCastingIfNecessary(
    main::ClientContext* context, std::shared_ptr<Expression> expr,