merge

dbms/src/AggregateFunctions/AggregateFunctionAvg.h

@@ -89,10 +89,10 @@ class AggregateFunctionAvg final
         if constexpr (IsDecimal<T>)
             this->data(place).sum -= static_cast<const ColumnDecimal<T> &>(*columns[0]).getData()[row_num];
         else
-        {
             this->data(place).sum -= static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num];
-        }
+
         --this->data(place).count;
+        assert(this->data(place).count >= 0);
     }
 
     void reset(AggregateDataPtr __restrict place) const override { this->data(place).reset(); }

dbms/src/AggregateFunctions/AggregateFunctionGroupConcat.h

@@ -116,7 +116,6 @@ class AggregateFunctionGroupConcat final
 
     DataTypePtr getReturnType() const override { return result_is_nullable ? makeNullable(ret_type) : ret_type; }
 
-    /// reject nulls before add()/decrease() of nested agg
     template <bool is_add>
     void addOrDecrease(AggregateDataPtr __restrict place, const IColumn ** columns, size_t row_num, Arena * arena) const
     {

dbms/src/AggregateFunctions/AggregateFunctionMaxIntersections.h

@@ -109,12 +109,6 @@ class AggregateFunctionIntersectionsMax final
             this->data(place).value.push_back(std::make_pair(right, static_cast<Int64>(-1)), arena);
     }
 
-    // TODO move to helper
-    void decrease(AggregateDataPtr __restrict, const IColumn **, size_t, Arena *) const override
-    {
-        throw Exception("");
-    }
-
     void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena * arena) const override
     {
         auto & cur_elems = this->data(place);

dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h

@@ -33,7 +33,6 @@ namespace DB
 struct CommonImpl
 {
     static void decrease(const IColumn &, size_t) { throw Exception(" decrease is not implemented yet"); }
-    static bool allocatesMemoryInArena() { return false; }
 };
 
 /// For numeric values.
@@ -793,8 +792,6 @@ class AggregateFunctionsSingleValue final
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }
-
-    bool allocatesMemoryInArena() const override { return Data::allocatesMemoryInArena(); }
 };
 
 } // namespace DB

dbms/src/AggregateFunctions/AggregateFunctionMinMaxWindow.h

@@ -39,29 +39,33 @@ struct SingleValueDataFixedForWindow
 
     mutable std::multiset<T> saved_values;
 
-public:
-    void insertMaxResultInto(IColumn & to) const { insertMinOrMaxResultInto<false>(to); }
-
-    void insertMinResultInto(IColumn & to) const { insertMinOrMaxResultInto<true>(to); }
-
     template <bool is_min>
     void insertMinOrMaxResultInto(IColumn & to) const
     {
         if (!saved_values.empty())
         {
-            typename std::multiset<T>::iterator iter;
             if constexpr (is_min)
-                iter = saved_values.begin();
+            {
+                const auto & iter = saved_values.begin();
+                static_cast<ColumnType &>(to).getData().push_back(*iter);
+            }
             else
-                iter = --(saved_values.end());
-            static_cast<ColumnType &>(to).getData().push_back(*iter);
+            {
+                const auto & iter = saved_values.rbegin();
+                static_cast<ColumnType &>(to).getData().push_back(*iter);
+            }
         }
         else
         {
             static_cast<ColumnType &>(to).insertDefault();
         }
     }
 
+public:
+    void insertMaxResultInto(IColumn & to) const { insertMinOrMaxResultInto<false>(to); }
+
+    void insertMinResultInto(IColumn & to) const { insertMinOrMaxResultInto<true>(to); }
+
     void reset() { saved_values.clear(); }
 
     void decrease(const IColumn & column, size_t row_num)
@@ -72,13 +76,7 @@ struct SingleValueDataFixedForWindow
         saved_values.erase(iter);
     }
 
-    void changeIfLess(const IColumn & column, size_t row_num, Arena *)
-    {
-        auto to_value = static_cast<const ColumnType &>(column).getData()[row_num];
-        saved_values.insert(to_value);
-    }
-
-    void changeIfGreater(const IColumn & column, size_t row_num, Arena *)
+    void add(const IColumn & column, size_t row_num, Arena *)
     {
         auto to_value = static_cast<const ColumnType &>(column).getData()[row_num];
         saved_values.insert(to_value);
@@ -97,12 +95,11 @@ struct SingleValueDataStringForWindow
     struct StringWithCollator
     {
         StringWithCollator(const StringRef & value_, TiDB::TiDBCollatorPtr collator_)
-            : value(value_.toString())
+            : value(value_)
             , collator(collator_)
         {}
 
-        // TODO use std::string is inefficient
-        std::string value;
+        StringRef value;
         TiDB::TiDBCollatorPtr collator;
     };
 
@@ -112,8 +109,7 @@ struct SingleValueDataStringForWindow
         {
             if unlikely (left.collator == nullptr)
                 return left.value < right.value;
-            return left.collator
-                ->compareFastPath(left.value.data(), left.value.size(), right.value.data(), right.value.size());
+            return left.collator->compareFastPath(left.value.data, left.value.size, right.value.data, right.value.size);
         }
     };
 
@@ -122,27 +118,35 @@ struct SingleValueDataStringForWindow
     mutable multiset saved_values;
     TiDB::TiDBCollatorPtr collator{};
 
-    void saveValue(StringRef value) { saved_values.insert(StringWithCollator(value, collator)); }
+    void saveValue(const StringRef & value) { saved_values.insert(StringWithCollator(value, collator)); }
 
     template <bool is_min>
     void insertMinOrMaxResultInto(IColumn & to) const
     {
         if (!saved_values.empty())
         {
-            multiset::iterator iter;
             if constexpr (is_min)
-                iter = saved_values.begin();
+            {
+                const auto & iter = saved_values.begin();
+                static_cast<ColumnString &>(to).insertDataWithTerminatingZero(iter->value.data, iter->value.size);
+            }
             else
-                iter = --(saved_values.end());
-
-            static_cast<ColumnString &>(to).insertDataWithTerminatingZero(iter->value.data(), iter->value.size());
+            {
+                const auto & iter = saved_values.rbegin();
+                static_cast<ColumnString &>(to).insertDataWithTerminatingZero(iter->value.data, iter->value.size);
+            }
         }
         else
         {
             static_cast<ColumnString &>(to).insertDefault();
         }
     }
 
+public:
+    void insertMaxResultInto(IColumn & to) const { insertMinOrMaxResultInto<false>(to); }
+
+    void insertMinResultInto(IColumn & to) const { insertMinOrMaxResultInto<true>(to); }
+
     void reset() { saved_values.clear(); }
 
     void decrease(const IColumn & column, size_t row_num)
@@ -153,12 +157,7 @@ struct SingleValueDataStringForWindow
         saved_values.erase(iter);
     }
 
-    void changeIfLess(const IColumn & column, size_t row_num, Arena *)
-    {
-        saveValue(static_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num));
-    }
-
-    void changeIfGreater(const IColumn & column, size_t row_num, Arena *)
+    void add(const IColumn & column, size_t row_num, Arena *)
     {
         saveValue(static_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num));
     }
@@ -179,29 +178,33 @@ struct SingleValueDataGenericForWindow
     using Self = SingleValueDataGenericForWindow;
     mutable std::multiset<Field> saved_values;
 
-public:
-    void insertMaxResultInto(IColumn & to) const { insertMinOrMaxResultInto<false>(to); }
-
-    void insertMinResultInto(IColumn & to) const { insertMinOrMaxResultInto<true>(to); }
-
     template <bool is_min>
     void insertMinOrMaxResultInto(IColumn & to) const
     {
         if (!saved_values.empty())
         {
-            std::multiset<Field>::iterator iter;
             if constexpr (is_min)
-                iter = saved_values.begin();
+            {
+                const auto & iter = saved_values.begin();
+                to.insert(*iter);
+            }
             else
-                iter = --(saved_values.end());
-            to.insert(*iter);
+            {
+                const auto & iter = saved_values.rbegin();
+                to.insert(*iter);
+            }
         }
         else
         {
             to.insertDefault();
         }
     }
 
+public:
+    void insertMaxResultInto(IColumn & to) const { insertMinOrMaxResultInto<false>(to); }
+
+    void insertMinResultInto(IColumn & to) const { insertMinOrMaxResultInto<true>(to); }
+
     void reset() { saved_values.clear(); }
 
     void decrease(const IColumn & column, size_t row_num)
@@ -213,14 +216,7 @@ struct SingleValueDataGenericForWindow
         saved_values.erase(iter);
     }
 
-    void changeIfLess(const IColumn & column, size_t row_num, Arena *)
-    {
-        Field value;
-        column.get(row_num, value);
-        saved_values.insert(value);
-    }
-
-    void changeIfGreater(const IColumn & column, size_t row_num, Arena *)
+    void add(const IColumn & column, size_t row_num, Arena *)
     {
         Field value;
         column.get(row_num, value);
@@ -239,8 +235,9 @@ struct AggregateFunctionMinDataForWindow : Data
 
     void changeIfBetter(const IColumn & column, size_t row_num, Arena * arena)
     {
-        return this->changeIfLess(column, row_num, arena);
+        return this->add(column, row_num, arena);
     }
+
     void changeIfBetter(const Self &, Arena *) { throw Exception("Not implemented yet"); }
 
     void insertResultInto(IColumn & to) const { Data::insertMinResultInto(to); }
@@ -253,15 +250,15 @@ struct AggregateFunctionMaxDataForWindow : Data
 {
     using Self = AggregateFunctionMaxDataForWindow<Data>;
 
-    void insertResultInto(IColumn & to) const { Data::insertMaxResultInto(to); }
-
     void changeIfBetter(const IColumn & column, size_t row_num, Arena * arena)
     {
-        return this->changeIfGreater(column, row_num, arena);
+        return this->add(column, row_num, arena);
     }
 
     void changeIfBetter(const Self &, Arena *) { throw Exception("Not implemented yet"); }
 
+    void insertResultInto(IColumn & to) const { Data::insertMaxResultInto(to); }
+
     static const char * name() { return "max_for_window"; }
 };
 

dbms/src/AggregateFunctions/AggregateFunctionNull.cpp

@@ -188,20 +188,10 @@ class AggregateFunctionCombinatorNullForWindow final : public IAggregateFunction
         if (has_null_types)
             return std::make_shared<AggregateFunctionNothing>();
 
-        if (nested_function->getReturnType()->canBeInsideNullable())
-        {
-            if (has_nullable_types)
-                return std::make_shared<AggregateFunctionNullUnaryForWindow<true>>(nested_function);
-            else
-                return std::make_shared<AggregateFunctionNullUnaryForWindow<false>>(nested_function);
-        }
+        if (has_nullable_types)
+            return std::make_shared<AggregateFunctionNullUnaryForWindow<true>>(nested_function);
         else
-        {
-            if (has_nullable_types)
-                return std::make_shared<AggregateFunctionNullUnaryForWindow<true>>(nested_function);
-            else
-                return std::make_shared<AggregateFunctionNullUnaryForWindow<false>>(nested_function);
-        }
+            return std::make_shared<AggregateFunctionNullUnaryForWindow<false>>(nested_function);
     }
 };
 

dbms/src/AggregateFunctions/AggregateFunctionNull.h

@@ -515,6 +515,23 @@ class AggregateFunctionNullVariadic final
     std::array<char, MAX_ARGS> is_nullable; /// Plain array is better than std::vector due to one indirection less.
 };
 
+// Make the prefix_size >= sizeof(UInt64) and could fit the align size
+inline size_t enlargePrefixSize(size_t prefix_size) noexcept
+{
+    assert(prefix_size != 0);
+    static_assert(sizeof(UInt64) == 8);
+    static_assert((sizeof(prefix_size_look_up_table) / sizeof(UInt64)) == 7);
+
+    // align_size is equal to prefix_size at the beginning
+    [[maybe_unused]] const auto align_size = prefix_size;
+
+    if (prefix_size < 8)
+        prefix_size = prefix_size_look_up_table[prefix_size - 1];
+
+    assert(prefix_size >= sizeof(UInt64) && (prefix_size % align_size == 0));
+    return prefix_size;
+}
+
 template <bool input_is_nullable>
 class AggregateFunctionNullUnaryForWindow
     : public IAggregateFunctionHelper<AggregateFunctionNullUnaryForWindow<input_is_nullable>>
@@ -533,18 +550,8 @@ class AggregateFunctionNullUnaryForWindow
 public:
     explicit AggregateFunctionNullUnaryForWindow(AggregateFunctionPtr nested_function_)
         : nested_function(nested_function_)
-    {
-        prefix_size = nested_function->alignOfData();
-        if (prefix_size < sizeof(Int64))
-        {
-            auto tmp = prefix_size;
-            prefix_size += sizeof(Int64);
-            if ((prefix_size % tmp) != 0)
-                prefix_size += tmp - (prefix_size % tmp);
-            assert((prefix_size % tmp) == 0);
-            assert(prefix_size >= (tmp + sizeof(Int64)));
-        }
-    }
+        , prefix_size(enlargePrefixSize(nested_function->alignOfData()))
+    {}
 
     String getName() const override
     {

dbms/src/AggregateFunctions/AggregateFunctionSequenceMatch.h

@@ -16,6 +16,7 @@
 
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnsNumber.h>
+#include <Common/Exception.h>
 #include <Common/PODArray.h>
 #include <Common/typeid_cast.h>
 #include <DataTypes/DataTypeDateTime.h>
@@ -27,9 +28,6 @@
 #include <ext/range.h>
 #include <stack>
 
-#include "Common/Exception.h"
-
-
 namespace DB
 {
 namespace ErrorCodes