Function nativeCastWithDecimalScale

src/DataTypes/Native.cpp:220–362

}

llvm::Value * nativeCastWithDecimalScale(
    llvm::IRBuilderBase & b, const DataTypePtr & from_type, llvm::Value * value, const DataTypePtr & to_type)
{
    if (from_type->equals(*to_type))
        return value;

    if (from_type->isNullable() && to_type->isNullable())
    {
        auto * inner_value = b.CreateExtractValue(value, {0});
        auto * is_null = b.CreateExtractValue(value, {1});
        auto * inner = nativeCastWithDecimalScale(b, removeNullable(from_type), inner_value, removeNullable(to_type));
        auto * to_native_type = toNativeType(b, to_type);
        llvm::Value * result = llvm::Constant::getNullValue(to_native_type);
        result = b.CreateInsertValue(result, inner, {0});
        return b.CreateInsertValue(result, is_null, {1});
    }
    if (from_type->isNullable())
    {
        return nativeCastWithDecimalScale(b, removeNullable(from_type), b.CreateExtractValue(value, {0}), to_type);
    }
    if (to_type->isNullable())
    {
        auto * to_native_type = toNativeType(b, to_type);
        auto * inner = nativeCastWithDecimalScale(b, from_type, value, removeNullable(to_type));
        return b.CreateInsertValue(llvm::Constant::getNullValue(to_native_type), inner, {0});
    }

    WhichDataType from_w(*from_type);
    WhichDataType to_w(*to_type);

    /// Only intercept conversions involving `Decimal` here. Everything else
    /// — including `DateTime` / `DateTime64` / `Time` / `Time64` scale lifts —
    /// is already handled correctly by `nativeCast`.
    if (to_w.isDecimal() || from_w.isDecimal())
    {
        auto * from_native_type = toNativeType(b, from_type);
        auto * to_native_type = toNativeType(b, to_type);
        const UInt32 to_scale = to_w.isDecimal() ? getDecimalScale(*to_type) : 0;
        const UInt32 from_scale = from_w.isDecimal() ? getDecimalScale(*from_type) : 0;

        /// Build LLVM integer constant for `10^n` of the requested bit width.
        auto pow10_int_const = [&](unsigned bit_width, UInt32 n) -> llvm::ConstantInt *
        {
            llvm::APInt v(bit_width, 1);
            for (UInt32 i = 0; i < n; ++i)
                v *= 10;
            return llvm::cast<llvm::ConstantInt>(llvm::ConstantInt::get(b.getContext(), v));
        };

        /// Build LLVM floating-point constant for `10^n` from an `APInt` of the requested bit width.
        /// This goes through `APFloat::convertFromAPInt` rather than `APInt::getZExtValue` so that
        /// it stays correct when `10^n` does not fit in 64 bits (e.g. `Decimal128` with `scale = 38`,
        /// or `Decimal256` with even larger scales).
        auto pow10_fp_const = [&](unsigned bit_width, UInt32 n, llvm::Type * fp_type) -> llvm::Constant *
        {
            llvm::APInt v(bit_width, 1);
            for (UInt32 i = 0; i < n; ++i)
                v *= 10;