Function convertCompileImpl

src/Functions/FunctionsConversion.cpp:2811–2895

}

llvm::Value * convertCompileImpl(llvm::IRBuilderBase & builder, const ValuesWithType & arguments, const DataTypePtr & result_type)
{
    llvm::Value * result = nullptr;
    castBothTypes(
        arguments[0].type.get(),
        result_type.get(),
        [&](const auto & left, const auto & right)
        {
            using LeftDataType = std::decay_t<decltype(left)>;
            using RightDataType = std::decay_t<decltype(right)>;
            if constexpr (IsDataTypeDecimalOrNumber<LeftDataType> && IsDataTypeDecimalOrNumber<RightDataType>)
            {
                using LeftFieldType = typename LeftDataType::FieldType;
                using RightFieldType = typename RightDataType::FieldType;

                if (isBool(right.getPtr()))
                {
                    /// nativeBoolCast returns i1, but Bool (UInt8) needs i8
                    auto * bool_value = nativeBoolCast(builder, arguments[0]);
                    result = builder.CreateZExt(bool_value, builder.getInt8Ty());
                    return true;
                }

                if constexpr (IsDataTypeNumber<LeftDataType> && IsDataTypeNumber<RightDataType>)
                {
                    result = nativeCast(builder, arguments[0], right.getPtr());
                    return true;
                }
                else if constexpr (IsDataTypeNumber<LeftDataType> && IsDataTypeDecimal<RightDataType>)
                {
                    auto scale = right.getScale();
                    auto multiplier = DecimalUtils::scaleMultiplier<NativeType<RightFieldType>>(scale);
                    if constexpr (std::is_floating_point_v<LeftFieldType>)
                    {
                        /// left type is float and right type is decimal
                        auto * from_type = arguments[0].value->getType();
                        auto * from_value = arguments[0].value;
                        result = builder.CreateFMul(from_value, llvm::ConstantFP::get(from_type, static_cast<double>(multiplier)));
                        result = nativeCast(builder, left.getPtr(), result, right.getPtr());
                    }
                    else
                    {
                        /// left type is integer and right type is decimal
                        auto * from_value = nativeCast(builder, arguments[0], right.getPtr());
                        auto * multiplier_value = getNativeValue(builder, right.getPtr(), RightFieldType(multiplier));
                        result = builder.CreateMul(from_value, multiplier_value);
                    }
                    return true;
                }
                else if constexpr (IsDataTypeDecimal<LeftDataType> && IsDataTypeNumber<RightDataType>)
                {
                    auto scale = left.getScale();
                    auto divider = DecimalUtils::scaleMultiplier<NativeType<LeftFieldType>>(scale);
                    if constexpr (std::is_floating_point_v<RightFieldType>)
                    {
                        DataTypePtr double_type = std::make_shared<DataTypeFloat64>();
                        auto * from_value = nativeCast(builder, arguments[0], double_type);
                        auto * d = llvm::ConstantFP::get(builder.getDoubleTy(), static_cast<double>(divider));