Function nativeCast

src/DataTypes/Native.cpp:130–213

}

llvm::Value * nativeCast(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 = nativeCast(b, removeNullable(from_type), b.CreateExtractValue(value, {0}), to_type);
        return b.CreateInsertValue(inner, b.CreateExtractValue(value, {1}), {1});
    }
    if (from_type->isNullable())
    {
        return nativeCast(b, removeNullable(from_type), b.CreateExtractValue(value, {0}), to_type);
    }
    if (to_type->isNullable())
    {
        auto * to_native_type = toNativeType(b, to_type);
        auto * inner = nativeCast(b, from_type, value, removeNullable(to_type));
        return b.CreateInsertValue(llvm::Constant::getNullValue(to_native_type), inner, {0});
    }
    auto * from_native_type = toNativeType(b, from_type);
    auto * to_native_type = toNativeType(b, to_type);

    /// Handle scale conversion for DateTime/DateTime64/Time/Time64 types.
    /// When converting between types with different scales (e.g., DateTime with implicit
    /// scale 0 to DateTime64 with scale 3), we need to multiply/divide by the appropriate
    /// power of 10, not just cast the integer value.
    /// Note: Decimal types are NOT handled here because JIT-compiled aggregate functions
    /// (e.g., avg) already manage Decimal scale conversion themselves.
    {
        auto get_effective_scale = [](const DataTypePtr & type) -> std::optional<UInt32>
        {
            WhichDataType which(type);
            if (which.isDateTime() || which.isTime())
                return 0u;
            if (which.isDateTime64())
                return typeid_cast<const DataTypeDateTime64 *>(type.get())->getScale();
            if (which.isTime64())
                return typeid_cast<const DataTypeTime64 *>(type.get())->getScale();
            return std::nullopt;
        };

        auto from_scale = get_effective_scale(from_type);
        auto to_scale = get_effective_scale(to_type);

        if (from_scale && to_scale && *from_scale != *to_scale)
        {
            /// First widen/narrow the integer type if needed.
            if (from_native_type != to_native_type)
                value = b.CreateIntCast(value, to_native_type, typeIsSigned(*from_type));

            UInt32 scale_diff = (*to_scale > *from_scale) ? (*to_scale - *from_scale) : (*from_scale - *to_scale);
            unsigned bit_width = to_native_type->getIntegerBitWidth();
            llvm::APInt scale_factor(bit_width, 1);
            for (UInt32 i = 0; i < scale_diff; ++i)
                scale_factor *= 10;
            auto * scale_constant = llvm::ConstantInt::get(b.getContext(), scale_factor);