Remove even more code

src/AggregateFunctions/AggregateFunctionGroupArray.h

@@ -296,12 +296,7 @@ public:
         if (size)
         {
             typename ColumnVector<T>::Container & data_to = assert_cast<ColumnVector<T> &>(arr_to.getData()).getData();
-            if constexpr (is_big_int_v<T>)
+            data_to.insert(this->data(place).value.begin(), this->data(place).value.end());
-                // is data_to empty? we should probably use std::vector::insert then
-                for (auto it = this->data(place).value.begin(); it != this->data(place).value.end(); it++)
-                    data_to.push_back(*it);
-            else
-                data_to.insert(this->data(place).value.begin(), this->data(place).value.end());
         }
     }
 

src/Columns/ColumnVector.cpp

@@ -474,8 +474,6 @@ void ColumnVector<T>::gather(ColumnGathererStream & gatherer)
 template <typename T>
 void ColumnVector<T>::getExtremes(Field & min, Field & max) const
 {
-    using FastRefT = std::conditional_t<is_big_int_v<T>, const T &, const T>;
-
     size_t size = data.size();
 
     if (size == 0)
@@ -496,7 +494,7 @@ void ColumnVector<T>::getExtremes(Field & min, Field & max) const
     T cur_min = NaNOrZero<T>();
     T cur_max = NaNOrZero<T>();
 
-    for (FastRefT x : data)
+    for (const T & x : data)
     {
         if (isNaN(x))
             continue;

src/Common/HashTable/Hash.h

@@ -186,7 +186,7 @@ inline size_t DefaultHash64(std::enable_if_t<(sizeof(T) > sizeof(UInt64)), T> ke
     }
     if constexpr (std::is_same_v<T, DB::UInt128>)
     {
-        return intHash64(key.low ^ key.high);
+        return intHash64(key.low ^ key.high);   /// TODO This is classical antipattern.
     }
     else if constexpr (is_big_int_v<T> && sizeof(T) == 32)
     {

src/Functions/FunctionMathBinaryFloat64.h

@@ -76,18 +76,8 @@ private:
             if (rows_remaining != 0)
             {
                 RightType right_src_remaining[Impl::rows_per_iteration];
-                if constexpr (!is_big_int_v<RightType> && !std::is_same_v<RightType, Decimal256>)
+                memcpy(right_src_remaining, &right_src_data[rows_size], rows_remaining * sizeof(RightType));
-                {
+                memset(right_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(RightType));
-                    memcpy(right_src_remaining, &right_src_data[rows_size], rows_remaining * sizeof(RightType));
-                    memset(right_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(RightType));
-                }
-                else
-                {
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        right_src_remaining[i] = right_src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        right_src_remaining[i] = 0;
-                }
                 Float64 dst_remaining[Impl::rows_per_iteration];
 
                 Impl::execute(left_src_data, right_src_remaining, dst_remaining);
@@ -123,32 +113,13 @@ private:
             if (rows_remaining != 0)
             {
                 LeftType left_src_remaining[Impl::rows_per_iteration];
-                if constexpr (!is_big_int_v<LeftType> && !std::is_same_v<LeftType, Decimal256>)
+                memcpy(left_src_remaining, &left_src_data[rows_size], rows_remaining * sizeof(LeftType));
-                {
+                memset(left_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(LeftType));
-                    memcpy(left_src_remaining, &left_src_data[rows_size], rows_remaining * sizeof(LeftType));
-                    memset(left_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(LeftType));
-                }
-                else
-                {
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        left_src_remaining[i] = left_src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        left_src_remaining[i] = 0;
-                }
 
                 RightType right_src_remaining[Impl::rows_per_iteration];
-                if constexpr (!is_big_int_v<RightType> && !std::is_same_v<RightType, Decimal256>)
+                memcpy(right_src_remaining, &right_src_data[rows_size], rows_remaining * sizeof(RightType));
-                {
+                memset(right_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(RightType));
-                    memcpy(right_src_remaining, &right_src_data[rows_size], rows_remaining * sizeof(RightType));
+
-                    memset(right_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(RightType));
-                }
-                else
-                {
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        right_src_remaining[i] = right_src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        right_src_remaining[i] = 0;
-                }
                 Float64 dst_remaining[Impl::rows_per_iteration];
 
                 Impl::execute(left_src_remaining, right_src_remaining, dst_remaining);
@@ -178,18 +149,8 @@ private:
             if (rows_remaining != 0)
             {
                 LeftType left_src_remaining[Impl::rows_per_iteration];
-                if constexpr (!is_big_int_v<LeftType> && !std::is_same_v<LeftType, Decimal256>)
+                memcpy(left_src_remaining, &left_src_data[rows_size], rows_remaining * sizeof(LeftType));
-                {
+                memset(left_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(LeftType));
-                    memcpy(left_src_remaining, &left_src_data[rows_size], rows_remaining * sizeof(LeftType));
-                    memset(left_src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(LeftType));
-                }
-                else
-                {
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        left_src_remaining[i] = left_src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        left_src_remaining[i] = 0;
-                }
 
                 Float64 dst_remaining[Impl::rows_per_iteration];
 

src/Functions/FunctionMathUnary.h

@@ -87,18 +87,8 @@ private:
             if (rows_remaining != 0)
             {
                 T src_remaining[Impl::rows_per_iteration];
-                if constexpr (is_big_int_v<T> || std::is_same_v<T, Decimal256>)
+                memcpy(src_remaining, &src_data[rows_size], rows_remaining * sizeof(T));
-                {
+                memset(src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(T));
-                    for (size_t i = 0; i < rows_remaining; i++)
-                        src_remaining[i] = src_data[rows_size + i];
-                    for (size_t i = rows_remaining; i < Impl::rows_per_iteration; i++)
-                        src_remaining[i] = 0;
-                }
-                else
-                {
-                    memcpy(src_remaining, &src_data[rows_size], rows_remaining * sizeof(T));
-                    memset(src_remaining + rows_remaining, 0, (Impl::rows_per_iteration - rows_remaining) * sizeof(T));
-                }
                 ReturnType dst_remaining[Impl::rows_per_iteration];
 
                 Impl::execute(src_remaining, dst_remaining);

src/Functions/FunctionsRound.h

@@ -440,13 +440,7 @@ public:
         }
         else
         {
-            if constexpr (!is_big_int_v<NativeType>)
+            memcpy(out.data(), in.data(), in.size() * sizeof(T));
-                memcpy(out.data(), in.data(), in.size() * sizeof(T));
-            else
-            {
-                for (size_t i = 0; i < in.size(); i++)
-                    out[i] = in[i];
-            }
         }
     }
 };

src/IO/ReadHelpers.h

@@ -257,8 +257,7 @@ enum class ReadIntTextCheckOverflow
 template <typename T, typename ReturnType = void, ReadIntTextCheckOverflow check_overflow = ReadIntTextCheckOverflow::DO_NOT_CHECK_OVERFLOW>
 ReturnType readIntTextImpl(T & x, ReadBuffer & buf)
 {
-    /// TODO: disabled for big ints cause of 127 vs 128 bit conversion
+    using UnsignedT = make_unsigned_t<T>;
-    using UnsignedT = std::conditional_t<is_big_int_v<T>, T, make_unsigned_t<T>>;
 
     static constexpr bool throw_exception = std::is_same_v<ReturnType, void>;
 
@@ -318,12 +317,8 @@ ReturnType readIntTextImpl(T & x, ReadBuffer & buf)
                             || common::addOverflow<T>(signed_res, (*buf.position() - '0'), signed_res))
                             return ReturnType(false);
 
-                        /// Cannot assign signed to unsigned for big ints. Ignore fast path.
+                        res = signed_res;
-                        if constexpr (!is_big_int_v<T>)
+                        break;
-                        {
-                            res = signed_res;
-                            break;
-                        }
                     }
                 }
                 res *= 10;

src/IO/WriteHelpers.h

@@ -923,7 +923,7 @@ inline void writeBinary(const Int256 & x, WriteBuffer & buf) { writePODBinary(x,
 
 /// Methods for outputting the value in text form for a tab-separated format.
 template <typename T>
-inline std::enable_if_t<is_integer_v<T> && !is_big_int_v<T>, void>
+inline std::enable_if_t<is_integer_v<T>, void>
 writeText(const T & x, WriteBuffer & buf) { writeIntText(x, buf); }
 
 template <typename T>