Allow multiplication of Decimal and Float

src/Core/DecimalFunctions.h

@@ -6,6 +6,7 @@
 #include <common/arithmeticOverflow.h>
 
 #include <limits>
+#include <type_traits>
 
 
 namespace DB

src/Functions/intDiv.cpp

@@ -88,6 +88,8 @@ struct DivideIntegralByConstantImpl
 
 }
 
+namespace impl_
+{
 template <> struct BinaryOperationImpl<UInt64, UInt8, DivideIntegralImpl<UInt64, UInt8>> : DivideIntegralByConstantImpl<UInt64, UInt8> {};
 template <> struct BinaryOperationImpl<UInt64, UInt16, DivideIntegralImpl<UInt64, UInt16>> : DivideIntegralByConstantImpl<UInt64, UInt16> {};
 template <> struct BinaryOperationImpl<UInt64, UInt32, DivideIntegralImpl<UInt64, UInt32>> : DivideIntegralByConstantImpl<UInt64, UInt32> {};
@@ -107,7 +109,7 @@ template <> struct BinaryOperationImpl<Int32, Int8, DivideIntegralImpl<Int32, In
 template <> struct BinaryOperationImpl<Int32, Int16, DivideIntegralImpl<Int32, Int16>> : DivideIntegralByConstantImpl<Int32, Int16> {};
 template <> struct BinaryOperationImpl<Int32, Int32, DivideIntegralImpl<Int32, Int32>> : DivideIntegralByConstantImpl<Int32, Int32> {};
 template <> struct BinaryOperationImpl<Int32, Int64, DivideIntegralImpl<Int32, Int64>> : DivideIntegralByConstantImpl<Int32, Int64> {};
-
+}
 
 struct NameIntDiv { static constexpr auto name = "intDiv"; };
 using FunctionIntDiv = BinaryArithmeticOverloadResolver<DivideIntegralImpl, NameIntDiv, false>;

src/Functions/modulo.cpp

@@ -79,6 +79,8 @@ struct ModuloByConstantImpl
   * Can be expanded to all possible combinations, but more code is needed.
   */
 
+namespace impl_
+{
 template <> struct BinaryOperationImpl<UInt64, UInt8, ModuloImpl<UInt64, UInt8>> : ModuloByConstantImpl<UInt64, UInt8> {};
 template <> struct BinaryOperationImpl<UInt64, UInt16, ModuloImpl<UInt64, UInt16>> : ModuloByConstantImpl<UInt64, UInt16> {};
 template <> struct BinaryOperationImpl<UInt64, UInt32, ModuloImpl<UInt64, UInt32>> : ModuloByConstantImpl<UInt64, UInt32> {};
@@ -98,7 +100,7 @@ template <> struct BinaryOperationImpl<Int32, Int8, ModuloImpl<Int32, Int8>> : M
 template <> struct BinaryOperationImpl<Int32, Int16, ModuloImpl<Int32, Int16>> : ModuloByConstantImpl<Int32, Int16> {};
 template <> struct BinaryOperationImpl<Int32, Int32, ModuloImpl<Int32, Int32>> : ModuloByConstantImpl<Int32, Int32> {};
 template <> struct BinaryOperationImpl<Int32, Int64, ModuloImpl<Int32, Int64>> : ModuloByConstantImpl<Int32, Int64> {};
-
+}
 
 struct NameModulo { static constexpr auto name = "modulo"; };
 using FunctionModulo = BinaryArithmeticOverloadResolver<ModuloImpl, NameModulo, false>;

src/Functions/multiply.cpp

@@ -1,3 +1,4 @@
+#include <type_traits>
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionBinaryArithmetic.h>
 #include <common/arithmeticOverflow.h>
@@ -25,11 +26,17 @@ struct MultiplyImpl
             return static_cast<Result>(a) * b;
     }
 
-    /// Apply operation and check overflow. It's used for Deciamal operations. @returns true if overflowed, false otherwise.
+    /// Apply operation and check overflow. It's used for Decimal operations. @returns true if overflowed, false otherwise.
     template <typename Result = ResultType>
     static inline bool apply(A a, B b, Result & c)
     {
-        return common::mulOverflow(static_cast<Result>(a), b, c);
+        if constexpr (std::is_same_v<Result, float> || std::is_same_v<Result, double>)
+        {
+            c = static_cast<Result>(a) * b;
+            return false;
+        }
+        else
+            return common::mulOverflow(static_cast<Result>(a), b, c);
     }
 
 #if USE_EMBEDDED_COMPILER

tests/queries/0_stateless/01603_decimal_mult_float.reference

@@ -0,0 +1,14 @@
+2.4
+10.165
+0.00012000000000000002
+150.16500000000002
+7.775900000000001
+56.62269
+598.8376688440277
+299.41883723437786
+0.7485470860550345
+2.245641373854596
+1.641386318314034
+1.641386318314034
+1.641386334333447
+1.641386334333447

tests/queries/0_stateless/01603_decimal_mult_float.sql

@@ -0,0 +1,27 @@
+SELECT toDecimal32(2, 2) * 1.2;
+SELECT toDecimal64(0.5, 2) * 20.33;
+SELECT 0.00001 * toDecimal32(12, 2);
+SELECT 30.033 * toDecimal32(5, 1);
+
+CREATE TABLE IF NOT EXISTS test01603 (
+    f64 Float64,
+    d Decimal64(3) DEFAULT toDecimal32(f64, 3),
+    f32 Float32 DEFAULT f64
+) ENGINE=MergeTree() ORDER BY f32;
+
+INSERT INTO test01603(f64) SELECT 1 / (number + 1) FROM system.numbers LIMIT 1000;
+
+SELECT sum(d * 1.1) FROM test01603;
+SELECT sum(8.01 * d) FROM test01603;
+
+SELECT sum(f64 * toDecimal64(80, 2)) FROM test01603;
+SELECT sum(toDecimal64(40, 2) * f32) FROM test01603;
+SELECT sum(f64 * toDecimal64(0.1, 2)) FROM test01603;
+SELECT sum(toDecimal64(0.3, 2) * f32) FROM test01603;
+
+SELECT sum(f64 * d) FROM test01603;
+SELECT sum(d * f64) FROM test01603;
+SELECT sum(f32 * d) FROM test01603;
+SELECT sum(d * f32) FROM test01603;
+
+DROP TABLE IF EXISTS test01603;