Optimize overflow check when cast to decimal

dbms/CMakeLists.txt

@@ -264,6 +264,11 @@ if (ENABLE_TESTS)
         file(GLOB_RECURSE "${DST_VAR}" RELATIVE "${BASE_DIR}" "gtest*.cpp")
     endmacro()
 
+    macro(grep_bench_sources BASE_DIR DST_VAR)
+        # Cold match files that are not in tests/ directories
+        file(GLOB_RECURSE "${DST_VAR}" RELATIVE "${BASE_DIR}" "bench*.cpp")
+    endmacro()
+
     # attach all dbms gtest sources
     grep_gtest_sources(${ClickHouse_SOURCE_DIR}/dbms dbms_gtest_sources)
     add_executable(gtests_dbms EXCLUDE_FROM_ALL
@@ -280,6 +285,23 @@ if (ENABLE_TESTS)
 
     target_compile_options(gtests_dbms PRIVATE -Wno-unknown-pragmas -Wno-deprecated-copy)
     add_check(gtests_dbms)
+
+    grep_bench_sources(${ClickHouse_SOURCE_DIR}/dbms dbms_bench_sources)
+    add_executable(bench_dbms EXCLUDE_FROM_ALL
+        ${ClickHouse_SOURCE_DIR}/dbms/src/Functions/tests/bench_function_cast.cpp
+        ${ClickHouse_SOURCE_DIR}/dbms/src/Server/StorageConfigParser.cpp
+        ${ClickHouse_SOURCE_DIR}/dbms/src/Server/UserConfigParser.cpp
+        ${ClickHouse_SOURCE_DIR}/dbms/src/Server/RaftConfigParser.cpp
+        ${ClickHouse_SOURCE_DIR}/dbms/src/AggregateFunctions/AggregateFunctionSum.cpp
+        )
+    target_include_directories(bench_dbms BEFORE PRIVATE ${SPARCEHASH_INCLUDE_DIR})
+
+    target_link_libraries(bench_dbms gtest dbms test_utils benchmark clickhouse_functions)
+    if (ENABLE_TIFLASH_DTWORKLOAD)
+        target_link_libraries(bench_dbms dt-workload-lib)
+    endif ()
+
+    add_check(bench_dbms)
 endif ()
 
 if (TEST_COVERAGE AND CMAKE_BUILD_TYPE STREQUAL "Debug")

dbms/src/Common/Decimal.h

@@ -27,7 +27,7 @@ struct IntPrec
 template <>
 struct IntPrec<int8_t>
 {
-    static constexpr PrecType prec = 4;
+    static constexpr PrecType prec = 3;
 };
 template <>
 struct IntPrec<uint8_t>
@@ -37,7 +37,7 @@ struct IntPrec<uint8_t>
 template <>
 struct IntPrec<int16_t>
 {
-    static constexpr PrecType prec = 6;
+    static constexpr PrecType prec = 5;
 };
 template <>
 struct IntPrec<uint16_t>
@@ -47,7 +47,7 @@ struct IntPrec<uint16_t>
 template <>
 struct IntPrec<int32_t>
 {
-    static constexpr PrecType prec = 11;
+    static constexpr PrecType prec = 10;
 };
 template <>
 struct IntPrec<uint32_t>

dbms/src/Functions/FunctionsTiDBConversion.h

@@ -33,6 +33,7 @@
 #include <Functions/FunctionsDateTime.h>
 #include <Functions/FunctionsMiscellaneous.h>
 #include <Functions/IFunction.h>
+#include <Functions/castTypeToEither.h>
 #include <IO/Operators.h>
 #include <IO/ReadBufferFromMemory.h>
 #include <IO/WriteBufferFromVector.h>
@@ -810,23 +811,26 @@ struct TiDBConvertToFloat
 
 /// cast int/real/decimal/enum/string/time/string as decimal
 // todo TiKV does not check unsigned flag but TiDB checks, currently follow TiKV's code, maybe changed latter
-template <typename FromDataType, typename ToFieldType, bool return_nullable>
+template <typename FromDataType, typename ToFieldType, bool return_nullable, bool canSkipCheckOverflow>
 struct TiDBConvertToDecimal
 {
     using FromFieldType = typename FromDataType::FieldType;
 
     template <typename T, typename U>
-    static U toTiDBDecimalInternal(T value, PrecType prec, ScaleType scale, const Context & context)
+    static U toTiDBDecimalInternal(T value, PrecType prec [[maybe_unused]], ScaleType scale, const Context & context)
     {
         using UType = typename U::NativeType;
-        auto max_value = DecimalMaxValue::get(prec);
-        if (value > max_value || value < -max_value)
+        if constexpr (!canSkipCheckOverflow)
         {
-            context.getDAGContext()->handleOverflowError("cast to decimal", Errors::Types::Truncated);
-            if (value > 0)
-                return static_cast<UType>(max_value);
-            else
-                return static_cast<UType>(-max_value);
+            auto max_value = DecimalMaxValue::get(prec);
+            if (value > max_value || value < -max_value)
+            {
+                context.getDAGContext()->handleOverflowError("cast to decimal", Errors::Types::Truncated);
+                if (value > 0)
+                    return static_cast<UType>(max_value);
+                else
+                    return static_cast<UType>(-max_value);
+            }
         }
         UType scale_mul = getScaleMultiplier<U>(scale);
         U result = static_cast<UType>(value) * scale_mul;
@@ -1727,6 +1731,29 @@ class FunctionTiDBCast final : public IFunctionBase
         return monotonicity_for_range(type, left, right);
     }
 
+    template <typename FromDataType>
+    static bool canSkipCheckOverflowForDecimal(DataTypePtr from_type, PrecType to_decimal_prec, ScaleType to_decimal_scale)
+    {
+        using FromFieldType = typename FromDataType::FieldType;
+
+        // cast(int as decimal)
+        constexpr int isUnsignedInt = (std::is_same_v<FromFieldType, UInt8> || std::is_same_v<FromFieldType, UInt16> || std::is_same_v<FromFieldType, UInt32> || std::is_same_v<FromFieldType, UInt64>);
+        constexpr int isSignedInt = (std::is_same_v<FromFieldType, Int8> || std::is_same_v<FromFieldType, Int16> || std::is_same_v<FromFieldType, Int32> || std::is_same_v<FromFieldType, Int64>);
+        if constexpr (isUnsignedInt || isSignedInt)
+        {
+            PrecType from_prec = IntPrec<FromFieldType>::prec;
+            if (from_prec <= (to_decimal_prec - to_decimal_scale))
+            {
+                return true;
+            }
+        }
+
+        // cast(decimal as decimal)
+        return castTypeToEither<DataTypeDecimal32, DataTypeDecimal64, DataTypeDecimal128, DataTypeDecimal256>(from_type.get(), [to_decimal_prec, to_decimal_scale](const auto & from_type_ptr, bool) -> bool {
+            return (from_type_ptr.getPrec() <= to_decimal_prec) && (from_type_ptr.getScale() <= to_decimal_scale);
+        });
+    }
+
 private:
     const Context & context;
     const char * name;
@@ -1740,7 +1767,7 @@ class FunctionTiDBCast final : public IFunctionBase
 
     /// createWrapper creates lambda functions that do the real type conversion job
     template <typename FromDataType, bool return_nullable>
-    WrapperType createWrapper(const DataTypePtr & to_type) const
+    WrapperType createWrapper(const DataTypePtr & from_type, const DataTypePtr & to_type) const
     {
         /// cast as int
         if (checkDataType<DataTypeUInt64>(to_type.get()))
@@ -1765,53 +1792,141 @@ class FunctionTiDBCast final : public IFunctionBase
             };
         /// cast as decimal
         if (const auto * decimal_type = checkAndGetDataType<DataTypeDecimal32>(to_type.get()))
-            return [decimal_type](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
-                TiDBConvertToDecimal<FromDataType, DataTypeDecimal32::FieldType, return_nullable>::execute(
-                    block,
-                    arguments,
-                    result,
-                    decimal_type->getPrec(),
-                    decimal_type->getScale(),
-                    in_union_,
-                    tidb_tp_,
-                    context_);
-            };
+        {
+            PrecType prec = decimal_type->getPrec();
+            ScaleType scale = decimal_type->getScale();
+            bool canSkip = canSkipCheckOverflowForDecimal<FromDataType>(from_type, prec, scale);
+            if (canSkip)
+            {
+                return [prec, scale](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
+                    TiDBConvertToDecimal<FromDataType, DataTypeDecimal32::FieldType, return_nullable, true>::execute(
+                        block,
+                        arguments,
+                        result,
+                        prec,
+                        scale,
+                        in_union_,
+                        tidb_tp_,
+                        context_);
+                };
+            }
+            else
+            {
+                return [prec, scale](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
+                    TiDBConvertToDecimal<FromDataType, DataTypeDecimal32::FieldType, return_nullable, false>::execute(
+                        block,
+                        arguments,
+                        result,
+                        prec,
+                        scale,
+                        in_union_,
+                        tidb_tp_,
+                        context_);
+                };
+            }
+        }
         if (const auto * decimal_type = checkAndGetDataType<DataTypeDecimal64>(to_type.get()))
-            return [decimal_type](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
-                TiDBConvertToDecimal<FromDataType, DataTypeDecimal64::FieldType, return_nullable>::execute(
-                    block,
-                    arguments,
-                    result,
-                    decimal_type->getPrec(),
-                    decimal_type->getScale(),
-                    in_union_,
-                    tidb_tp_,
-                    context_);
-            };
+        {
+            PrecType prec = decimal_type->getPrec();
+            ScaleType scale = decimal_type->getScale();
+            bool canSkip = canSkipCheckOverflowForDecimal<FromDataType>(from_type, prec, scale);
+            if (canSkip)
+            {
+                return [prec, scale](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
+                    TiDBConvertToDecimal<FromDataType, DataTypeDecimal64::FieldType, return_nullable, true>::execute(
+                        block,
+                        arguments,
+                        result,
+                        prec,
+                        scale,
+                        in_union_,
+                        tidb_tp_,
+                        context_);
+                };
+            }
+            else
+            {
+                return [prec, scale](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
+                    TiDBConvertToDecimal<FromDataType, DataTypeDecimal64::FieldType, return_nullable, false>::execute(
+                        block,
+                        arguments,
+                        result,
+                        prec,
+                        scale,
+                        in_union_,
+                        tidb_tp_,
+                        context_);
+                };
+            }
+        }
         if (const auto * decimal_type = checkAndGetDataType<DataTypeDecimal128>(to_type.get()))
-            return [decimal_type](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
-                TiDBConvertToDecimal<FromDataType, DataTypeDecimal128::FieldType, return_nullable>::execute(
-                    block,
-                    arguments,
-                    result,
-                    decimal_type->getPrec(),
-                    decimal_type->getScale(),
-                    in_union_,
-                    tidb_tp_,
-                    context_);
-            };
+        {
+            PrecType prec = decimal_type->getPrec();
+            ScaleType scale = decimal_type->getScale();
+            bool canSkip = canSkipCheckOverflowForDecimal<FromDataType>(from_type, prec, scale);
+            if (canSkip)
+            {
+                return [prec, scale](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
+                    TiDBConvertToDecimal<FromDataType, DataTypeDecimal128::FieldType, return_nullable, true>::execute(
+                        block,
+                        arguments,
+                        result,
+                        prec,
+                        scale,
+                        in_union_,
+                        tidb_tp_,
+                        context_);
+                };
+            }
+            else
+            {
+                return [prec, scale](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
+                    TiDBConvertToDecimal<FromDataType, DataTypeDecimal128::FieldType, return_nullable, false>::execute(
+                        block,
+                        arguments,
+                        result,
+                        prec,
+                        scale,
+                        in_union_,
+                        tidb_tp_,
+                        context_);
+                };
+            }
+        }
         if (const auto * decimal_type = checkAndGetDataType<DataTypeDecimal256>(to_type.get()))
-            return [decimal_type](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
-                TiDBConvertToDecimal<FromDataType, DataTypeDecimal256::FieldType, return_nullable>::execute(
-                    block,
-                    arguments,
-                    result,
-                    decimal_type->getPrec(),
-                    decimal_type->getScale(),
-                    in_union_,
-                    tidb_tp_,
-                    context_);
-            };
+        {
+            PrecType prec = decimal_type->getPrec();
+            ScaleType scale = decimal_type->getScale();
+            bool canSkip = canSkipCheckOverflowForDecimal<FromDataType>(from_type, prec, scale);
+            if (canSkip)
+            {
+                return [prec, scale](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
+                    TiDBConvertToDecimal<FromDataType, DataTypeDecimal256::FieldType, return_nullable, true>::execute(
+                        block,
+                        arguments,
+                        result,
+                        prec,
+                        scale,
+                        in_union_,
+                        tidb_tp_,
+                        context_);
+                };
+            }
+            else
+            {
+                return [prec, scale](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
+                    TiDBConvertToDecimal<FromDataType, DataTypeDecimal256::FieldType, return_nullable, false>::execute(
+                        block,
+                        arguments,
+                        result,
+                        prec,
+                        scale,
+                        in_union_,
+                        tidb_tp_,
+                        context_);
+                };
+            }
+        }
         /// cast as real
         if (checkDataType<DataTypeFloat64>(to_type.get()))
             return [](Block & block, const ColumnNumbers & arguments, const size_t result, bool in_union_, const tipb::FieldType & tidb_tp_, const Context & context_) {
@@ -1892,45 +2007,45 @@ class FunctionTiDBCast final : public IFunctionBase
         if (isIdentityCast(from_type, to_type))
             return createIdentityWrapper(from_type);
         if (checkAndGetDataType<DataTypeUInt8>(from_type.get()))
-            return createWrapper<DataTypeUInt8, return_nullable>(to_type);
+            return createWrapper<DataTypeUInt8, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeUInt16>(from_type.get()))
-            return createWrapper<DataTypeUInt16, return_nullable>(to_type);
+            return createWrapper<DataTypeUInt16, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeUInt32>(from_type.get()))
-            return createWrapper<DataTypeUInt32, return_nullable>(to_type);
+            return createWrapper<DataTypeUInt32, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeUInt64>(from_type.get()))
-            return createWrapper<DataTypeUInt64, return_nullable>(to_type);
+            return createWrapper<DataTypeUInt64, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeInt8>(from_type.get()))
-            return createWrapper<DataTypeInt8, return_nullable>(to_type);
+            return createWrapper<DataTypeInt8, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeInt16>(from_type.get()))
-            return createWrapper<DataTypeInt16, return_nullable>(to_type);
+            return createWrapper<DataTypeInt16, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeInt32>(from_type.get()))
-            return createWrapper<DataTypeInt32, return_nullable>(to_type);
+            return createWrapper<DataTypeInt32, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeInt64>(from_type.get()))
-            return createWrapper<DataTypeInt64, return_nullable>(to_type);
+            return createWrapper<DataTypeInt64, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeFloat32>(from_type.get()))
-            return createWrapper<DataTypeFloat32, return_nullable>(to_type);
+            return createWrapper<DataTypeFloat32, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeFloat64>(from_type.get()))
-            return createWrapper<DataTypeFloat64, return_nullable>(to_type);
+            return createWrapper<DataTypeFloat64, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeDecimal32>(from_type.get()))
-            return createWrapper<DataTypeDecimal32, return_nullable>(to_type);
+            return createWrapper<DataTypeDecimal32, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeDecimal64>(from_type.get()))
-            return createWrapper<DataTypeDecimal64, return_nullable>(to_type);
+            return createWrapper<DataTypeDecimal64, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeDecimal128>(from_type.get()))
-            return createWrapper<DataTypeDecimal128, return_nullable>(to_type);
+            return createWrapper<DataTypeDecimal128, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeDecimal256>(from_type.get()))
-            return createWrapper<DataTypeDecimal256, return_nullable>(to_type);
+            return createWrapper<DataTypeDecimal256, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeMyDate>(from_type.get()))
-            return createWrapper<DataTypeMyDate, return_nullable>(to_type);
+            return createWrapper<DataTypeMyDate, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeMyDateTime>(from_type.get()))
-            return createWrapper<DataTypeMyDateTime, return_nullable>(to_type);
+            return createWrapper<DataTypeMyDateTime, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeString>(from_type.get()))
-            return createWrapper<DataTypeString, return_nullable>(to_type);
+            return createWrapper<DataTypeString, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeEnum8>(from_type.get()))
-            return createWrapper<DataTypeEnum8, return_nullable>(to_type);
+            return createWrapper<DataTypeEnum8, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeEnum16>(from_type.get()))
-            return createWrapper<DataTypeEnum16, return_nullable>(to_type);
+            return createWrapper<DataTypeEnum16, return_nullable>(from_type, to_type);
         if (checkAndGetDataType<DataTypeMyDuration>(from_type.get()))
-            return createWrapper<DataTypeMyDuration, return_nullable>(to_type);
+            return createWrapper<DataTypeMyDuration, return_nullable>(from_type, to_type);
 
         // todo support convert to duration/json type
         throw Exception{