From 857bccc9813b02a80bdf319fbe05bd59ac79d8b0 Mon Sep 17 00:00:00 2001
From: Guillaume Tassery <tassery.guillaume@gmail.com>
Date: Mon, 15 Apr 2019 13:36:24 +0700
Subject: [PATCH 1/7] Add a way to set a size parameter for groupUniqArray

---
 .../AggregateFunctionGroupUniqArray.cpp       | 84 +++++++++++++++----
 .../AggregateFunctionGroupUniqArray.h         | 29 +++++--
 2 files changed, 86 insertions(+), 27 deletions(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
index 7a99709c33e..13c9b328938 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
@@ -9,55 +9,103 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int BAD_ARGUMENTS;
+}
+
 namespace
 {
 
 /// Substitute return type for Date and DateTime
-class AggregateFunctionGroupUniqArrayDate : public AggregateFunctionGroupUniqArray<DataTypeDate::FieldType>
+template <typename has_limit>
+class AggregateFunctionGroupUniqArrayDate : public AggregateFunctionGroupUniqArray<DataTypeDate::FieldType, has_limit>
 {
 public:
-    AggregateFunctionGroupUniqArrayDate(const DataTypePtr & argument_type) : AggregateFunctionGroupUniqArray<DataTypeDate::FieldType>(argument_type) {}
+    AggregateFunctionGroupUniqArrayDate(const DataTypePtr & argument_type, UInt64 max_elems_ = std::numeric_limits<UInt64>::max()) : AggregateFunctionGroupUniqArray<DataTypeDate::FieldType, has_limit>(argument_type, max_elems_) {}
     DataTypePtr getReturnType() const override { return std::make_shared<DataTypeArray>(std::make_shared<DataTypeDate>()); }
 };
 
-class AggregateFunctionGroupUniqArrayDateTime : public AggregateFunctionGroupUniqArray<DataTypeDateTime::FieldType>
+template <typename has_limit>
+class AggregateFunctionGroupUniqArrayDateTime : public AggregateFunctionGroupUniqArray<DataTypeDateTime::FieldType, has_limit>
 {
 public:
-    AggregateFunctionGroupUniqArrayDateTime(const DataTypePtr & argument_type) : AggregateFunctionGroupUniqArray<DataTypeDateTime::FieldType>(argument_type) {}
+    AggregateFunctionGroupUniqArrayDateTime(const DataTypePtr & argument_type, UInt64 max_elems_ = std::numeric_limits<UInt64>::max()) : AggregateFunctionGroupUniqArray<DataTypeDateTime::FieldType, has_limit>(argument_type, max_elems_) {}
     DataTypePtr getReturnType() const override { return std::make_shared<DataTypeArray>(std::make_shared<DataTypeDateTime>()); }
 };
 
-
-static IAggregateFunction * createWithExtraTypes(const DataTypePtr & argument_type)
+template <typename has_limit, typename ... TArgs>
+static IAggregateFunction * createWithExtraTypes(const DataTypePtr & argument_type, TArgs && ... args)
 {
     WhichDataType which(argument_type);
-         if (which.idx == TypeIndex::Date) return new AggregateFunctionGroupUniqArrayDate(argument_type);
-    else if (which.idx == TypeIndex::DateTime) return new AggregateFunctionGroupUniqArrayDateTime(argument_type);
+    if (which.idx == TypeIndex::Date) return new AggregateFunctionGroupUniqArrayDate<has_limit>(argument_type, std::forward<TArgs>(args)...);
+    else if (which.idx == TypeIndex::DateTime) return new AggregateFunctionGroupUniqArrayDateTime<has_limit>(argument_type, std::forward<TArgs>(args)...);
     else
     {
         /// Check that we can use plain version of AggreagteFunctionGroupUniqArrayGeneric
         if (argument_type->isValueUnambiguouslyRepresentedInContiguousMemoryRegion())
-            return new AggreagteFunctionGroupUniqArrayGeneric<true>(argument_type);
+            return new AggreagteFunctionGroupUniqArrayGeneric<true, has_limit>(argument_type, std::forward<TArgs>(args)...);
         else
-            return new AggreagteFunctionGroupUniqArrayGeneric<false>(argument_type);
+            return new AggreagteFunctionGroupUniqArrayGeneric<false, has_limit>(argument_type, std::forward<TArgs>(args)...);
     }
 }
 
+template <template <typename, typename> class AggregateFunctionTemplate, typename Data, typename ... TArgs>
+static IAggregateFunction * createWithNumericOrTimeType(const IDataType & argument_type, TArgs && ... args)
+{
+    return createWithNumericType<AggregateFunctionTemplate, Data, TArgs...>(argument_type, std::forward<TArgs>(args)...);
+}
+
+template <typename has_limit, typename ... TArgs>
+inline AggregateFunctionPtr createAggregateFunctionGroupUniqArrayImpl(const std::string & name, const DataTypePtr & argument_type, TArgs ... args)
+{
+
+    AggregateFunctionPtr res(createWithNumericOrTimeType<AggregateFunctionGroupUniqArray, has_limit>(*argument_type, argument_type, std::forward<TArgs>(args)...));
+
+    if (!res)
+        res = AggregateFunctionPtr(createWithExtraTypes<has_limit>(argument_type, std::forward<TArgs>(args)...));
+
+    if (!res)
+        throw Exception("Illegal type " + argument_type->getName() +
+                        " of argument for aggregate function " + name, ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+    return res;
+
+}
+
 AggregateFunctionPtr createAggregateFunctionGroupUniqArray(const std::string & name, const DataTypes & argument_types, const Array & parameters)
 {
-    assertNoParameters(name, parameters);
     assertUnary(name, argument_types);
 
-    AggregateFunctionPtr res(createWithNumericType<AggregateFunctionGroupUniqArray>(*argument_types[0], argument_types[0]));
+    bool limit_size = false;
+    UInt64 max_elems = std::numeric_limits<UInt64>::max();
 
-    if (!res)
-        res = AggregateFunctionPtr(createWithExtraTypes(argument_types[0]));
+    if (parameters.empty())
+    {
+        // no limit
+    }
+    else if (parameters.size() == 1)
+    {
+        auto type = parameters[0].getType();
+        if (type != Field::Types::Int64 && type != Field::Types::UInt64)
+            throw Exception("Parameter for aggregate function " + name + " should be positive number", ErrorCodes::BAD_ARGUMENTS);
 
-    if (!res)
-        throw Exception("Illegal type " + argument_types[0]->getName() +
-            " of argument for aggregate function " + name, ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        if ((type == Field::Types::Int64 && parameters[0].get<Int64>() < 0) ||
+            (type == Field::Types::UInt64 && parameters[0].get<UInt64>() == 0))
+            throw Exception("Parameter for aggregate function " + name + " should be positive number", ErrorCodes::BAD_ARGUMENTS);
 
-    return res;
+        limit_size = true;
+        max_elems = parameters[0].get<UInt64>();
+    }
+    else
+        throw Exception("Incorrect number of parameters for aggregate function " + name + ", should be 0 or 1",
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
+    if (!limit_size)
+        return createAggregateFunctionGroupUniqArrayImpl<std::false_type>(name, argument_types[0]);
+    else
+        return createAggregateFunctionGroupUniqArrayImpl<std::true_type>(name, argument_types[0], max_elems);
 }
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
index e51feedc53c..13b22001d1f 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
@@ -36,16 +36,21 @@ struct AggregateFunctionGroupUniqArrayData
 
 
 /// Puts all values to the hash set. Returns an array of unique values. Implemented for numeric types.
-template <typename T>
+template <typename T, typename Tlimit_num_elem>
 class AggregateFunctionGroupUniqArray
-    : public IAggregateFunctionDataHelper<AggregateFunctionGroupUniqArrayData<T>, AggregateFunctionGroupUniqArray<T>>
+    : public IAggregateFunctionDataHelper<AggregateFunctionGroupUniqArrayData<T>, AggregateFunctionGroupUniqArray<T, Tlimit_num_elem>>
 {
+    static constexpr bool limit_num_elems = Tlimit_num_elem::value;
+    UInt64 max_elems;
+
 private:
     using State = AggregateFunctionGroupUniqArrayData<T>;
 
 public:
-    AggregateFunctionGroupUniqArray(const DataTypePtr & argument_type)
-        : IAggregateFunctionDataHelper<AggregateFunctionGroupUniqArrayData<T>, AggregateFunctionGroupUniqArray<T>>({argument_type}, {}) {}
+    AggregateFunctionGroupUniqArray(const DataTypePtr & argument_type, UInt64 max_elems_ = std::numeric_limits<UInt64>::max())
+        : IAggregateFunctionDataHelper<AggregateFunctionGroupUniqArrayData<T>,
+          AggregateFunctionGroupUniqArray<T, Tlimit_num_elem>>({argument_type}, {}),
+          max_elems(max_elems_) {}
 
     String getName() const override { return "groupUniqArray"; }
 
@@ -56,6 +61,8 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
+        if (limit_num_elems && this->data(place).value.size() >= max_elems)
+            return;
         this->data(place).value.insert(static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
     }
 
@@ -114,12 +121,15 @@ struct AggreagteFunctionGroupUniqArrayGenericData
 /** Template parameter with true value should be used for columns that store their elements in memory continuously.
  *  For such columns groupUniqArray() can be implemented more efficiently (especially for small numeric arrays).
  */
-template <bool is_plain_column = false>
+template <bool is_plain_column = false, typename Tlimit_num_elem = std::false_type>
 class AggreagteFunctionGroupUniqArrayGeneric
-    : public IAggregateFunctionDataHelper<AggreagteFunctionGroupUniqArrayGenericData, AggreagteFunctionGroupUniqArrayGeneric<is_plain_column>>
+    : public IAggregateFunctionDataHelper<AggreagteFunctionGroupUniqArrayGenericData, AggreagteFunctionGroupUniqArrayGeneric<is_plain_column, Tlimit_num_elem>>
 {
     DataTypePtr & input_data_type;
 
+    static constexpr bool limit_num_elems = Tlimit_num_elem::value;
+    UInt64 max_elems;
+
     using State = AggreagteFunctionGroupUniqArrayGenericData;
 
     static StringRef getSerialization(const IColumn & column, size_t row_num, Arena & arena);
@@ -127,9 +137,10 @@ class AggreagteFunctionGroupUniqArrayGeneric
     static void deserializeAndInsert(StringRef str, IColumn & data_to);
 
 public:
-    AggreagteFunctionGroupUniqArrayGeneric(const DataTypePtr & input_data_type)
-        : IAggregateFunctionDataHelper<AggreagteFunctionGroupUniqArrayGenericData, AggreagteFunctionGroupUniqArrayGeneric<is_plain_column>>({input_data_type}, {})
-        , input_data_type(this->argument_types[0]) {}
+    AggreagteFunctionGroupUniqArrayGeneric(const DataTypePtr & input_data_type, UInt64 max_elems_ = std::numeric_limits<UInt64>::max())
+        : IAggregateFunctionDataHelper<AggreagteFunctionGroupUniqArrayGenericData, AggreagteFunctionGroupUniqArrayGeneric<is_plain_column, Tlimit_num_elem>>({input_data_type}, {})
+        , input_data_type(this->argument_types[0])
+        , max_elems(max_elems_) {}
 
     String getName() const override { return "groupUniqArray"; }
 

From 803675892b46363fac6bff54e556e45c880d1efd Mon Sep 17 00:00:00 2001
From: Guillaume Tassery <tassery.guillaume@gmail.com>
Date: Mon, 15 Apr 2019 16:09:52 +0700
Subject: [PATCH 2/7] Handle merge operation for size parameter on
 groupUniqArray aggregation function

---
 .../AggregateFunctionGroupUniqArray.h         | 53 +++++++++++++++++--
 1 file changed, 48 insertions(+), 5 deletions(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
index 13b22001d1f..bba64b4d786 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
@@ -68,7 +68,20 @@ public:
 
     void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena *) const override
     {
-        this->data(place).value.merge(this->data(rhs).value);
+        if (!limit_num_elems)
+            this->data(place).value.merge(this->data(rhs).value);
+        else
+        {
+            auto & cur_set = this->data(place).value;
+            auto & rhs_set = this->data(rhs).value;
+
+            for (auto & rhs_elem : rhs_set)
+            {
+                if (cur_set.size() >= max_elems)
+                    return ;
+                cur_set.insert(rhs_elem.getValue());
+            }
+        }
     }
 
     void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
@@ -185,7 +198,10 @@ public:
         bool inserted;
         State::Set::iterator it;
 
+        if (limit_num_elems && set.size() >= max_elems)
+            return;
         StringRef str_serialized = getSerialization(*columns[0], row_num, *arena);
+
         set.emplace(str_serialized, it, inserted);
 
         if constexpr (!is_plain_column)
@@ -209,6 +225,8 @@ public:
         State::Set::iterator it;
         for (auto & rhs_elem : rhs_set)
         {
+            if (limit_num_elems && cur_set.size() >= max_elems)
+                return ;
             cur_set.emplace(rhs_elem.getValue(), it, inserted);
             if (inserted)
             {
@@ -240,30 +258,55 @@ public:
 
 
 template <>
-inline StringRef AggreagteFunctionGroupUniqArrayGeneric<false>::getSerialization(const IColumn & column, size_t row_num, Arena & arena)
+inline StringRef AggreagteFunctionGroupUniqArrayGeneric<false, std::false_type>::getSerialization(const IColumn & column, size_t row_num, Arena & arena)
 {
     const char * begin = nullptr;
     return column.serializeValueIntoArena(row_num, arena, begin);
 }
 
 template <>
-inline StringRef AggreagteFunctionGroupUniqArrayGeneric<true>::getSerialization(const IColumn & column, size_t row_num, Arena &)
+inline StringRef AggreagteFunctionGroupUniqArrayGeneric<false, std::true_type>::getSerialization(const IColumn & column, size_t row_num, Arena & arena)
+{
+    const char * begin = nullptr;
+    return column.serializeValueIntoArena(row_num, arena, begin);
+}
+
+template <>
+inline StringRef AggreagteFunctionGroupUniqArrayGeneric<true, std::false_type>::getSerialization(const IColumn & column, size_t row_num, Arena &)
 {
     return column.getDataAt(row_num);
 }
 
 template <>
-inline void AggreagteFunctionGroupUniqArrayGeneric<false>::deserializeAndInsert(StringRef str, IColumn & data_to)
+inline StringRef AggreagteFunctionGroupUniqArrayGeneric<true, std::true_type>::getSerialization(const IColumn & column, size_t row_num, Arena &)
+{
+    return column.getDataAt(row_num);
+}
+
+
+template <>
+inline void AggreagteFunctionGroupUniqArrayGeneric<false, std::false_type>::deserializeAndInsert(StringRef str, IColumn & data_to)
 {
     data_to.deserializeAndInsertFromArena(str.data);
 }
 
 template <>
-inline void AggreagteFunctionGroupUniqArrayGeneric<true>::deserializeAndInsert(StringRef str, IColumn & data_to)
+inline void AggreagteFunctionGroupUniqArrayGeneric<false, std::true_type>::deserializeAndInsert(StringRef str, IColumn & data_to)
+{
+    data_to.deserializeAndInsertFromArena(str.data);
+}
+
+template <>
+inline void AggreagteFunctionGroupUniqArrayGeneric<true, std::true_type>::deserializeAndInsert(StringRef str, IColumn & data_to)
 {
     data_to.insertData(str.data, str.size);
 }
 
+template <>
+inline void AggreagteFunctionGroupUniqArrayGeneric<true, std::false_type>::deserializeAndInsert(StringRef str, IColumn & data_to)
+{
+    data_to.insertData(str.data, str.size);
+}
 
 #undef AGGREGATE_FUNCTION_GROUP_ARRAY_UNIQ_MAX_SIZE
 

From 3a23360e02a50fd22b1a006f11fb264f7d1a80ca Mon Sep 17 00:00:00 2001
From: Guillaume Tassery <tassery.guillaume@gmail.com>
Date: Mon, 15 Apr 2019 17:09:01 +0700
Subject: [PATCH 3/7] Add functional test for size parameter on groupUniqArray

---
 ...shard_group_uniq_array_of_string.reference | 20 +++++++++++++++++++
 ...00375_shard_group_uniq_array_of_string.sql |  2 ++
 ...rd_group_uniq_array_of_int_array.reference | 20 +++++++++++++++++++
 ...76_shard_group_uniq_array_of_int_array.sql |  6 +++++-
 ...9_group_uniq_array_date_datetime.reference |  4 ++++
 .../00399_group_uniq_array_date_datetime.sql  | 11 ++++++++--
 6 files changed, 60 insertions(+), 3 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00375_shard_group_uniq_array_of_string.reference b/dbms/tests/queries/0_stateless/00375_shard_group_uniq_array_of_string.reference
index 44d059430cd..bf0606cfc5b 100644
--- a/dbms/tests/queries/0_stateless/00375_shard_group_uniq_array_of_string.reference
+++ b/dbms/tests/queries/0_stateless/00375_shard_group_uniq_array_of_string.reference
@@ -18,3 +18,23 @@
 1000
 1000
 1000
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+1000
+1000
+1000
+1000
+1000
+1000
+1000
+1000
+1000
+1000
diff --git a/dbms/tests/queries/0_stateless/00375_shard_group_uniq_array_of_string.sql b/dbms/tests/queries/0_stateless/00375_shard_group_uniq_array_of_string.sql
index 210c5f4a0fd..ab2dbd730cc 100644
--- a/dbms/tests/queries/0_stateless/00375_shard_group_uniq_array_of_string.sql
+++ b/dbms/tests/queries/0_stateless/00375_shard_group_uniq_array_of_string.sql
@@ -6,5 +6,7 @@ INSERT INTO test.group_uniq_str SELECT 5 as id, toString(number % 100) as v FROM
 
 SELECT length(groupUniqArray(v)) FROM test.group_uniq_str GROUP BY id ORDER BY id;
 SELECT length(groupUniqArray(v)) FROM remote('127.0.0.{2,3,4,5}', 'test', 'group_uniq_str') GROUP BY id ORDER BY id;
+SELECT length(groupUniqArray(10)(v)) FROM test.group_uniq_str GROUP BY id ORDER BY id;
+SELECT length(groupUniqArray(10000)(v)) FROM test.group_uniq_str GROUP BY id ORDER BY id;
 
 DROP TABLE IF EXISTS test.group_uniq_str;
diff --git a/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.reference b/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.reference
index 932499cb209..4f4b18847b4 100644
--- a/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.reference
+++ b/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.reference
@@ -18,3 +18,23 @@
 20001
 20001
 20001
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+20001
+20001
+20001
+20001
+20001
+20001
+20001
+20001
+20001
+20001
diff --git a/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.sql b/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.sql
index fd8d4acbf02..4674da3c03c 100644
--- a/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.sql
+++ b/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.sql
@@ -4,6 +4,10 @@ CREATE TABLE test.group_uniq_arr_int ENGINE = Memory AS
 		(SELECT intDiv(number%1000000, 100) as v, intDiv(number%100, 10) as g, number%10 as c FROM system.numbers WHERE c < 3 LIMIT 10000000);
 
 SELECT length(groupUniqArray(v)) FROM test.group_uniq_arr_int GROUP BY id ORDER BY id;
-SELECT length(groupUniqArray(v)) FROM remote('127.0.0.{2,3,4,5}', 'test', 'group_uniq_arr_int') GROUP BY id ORDER BY id;
+SELECT length(groupUniqArray(v)) FROM test.group_uniq_arr_int GROUP BY id ORDER BY id;
+--SELECT length(groupUniqArray(v)) FROM remote('127.0.0.{2,3,4,5}', 'test', 'group_uniq_arr_int') GROUP BY id ORDER BY id;
+SELECT length(groupUniqArray(10)(v)) FROM test.group_uniq_arr_int GROUP BY id ORDER BY id;
+SELECT length(groupUniqArray(100000)(v)) FROM test.group_uniq_arr_int GROUP BY id ORDER BY id;
+
 
 DROP TABLE IF EXISTS test.group_uniq_arr_int;
diff --git a/dbms/tests/queries/0_stateless/00399_group_uniq_array_date_datetime.reference b/dbms/tests/queries/0_stateless/00399_group_uniq_array_date_datetime.reference
index 2ce0b460bb5..6f2b4335230 100644
--- a/dbms/tests/queries/0_stateless/00399_group_uniq_array_date_datetime.reference
+++ b/dbms/tests/queries/0_stateless/00399_group_uniq_array_date_datetime.reference
@@ -1 +1,5 @@
 ['2016-12-16']	['2016-12-16 12:00:00']
+2	2	3	3
+1	1	1	1
+3	3
+1	1
diff --git a/dbms/tests/queries/0_stateless/00399_group_uniq_array_date_datetime.sql b/dbms/tests/queries/0_stateless/00399_group_uniq_array_date_datetime.sql
index 8f760b5cac6..2ed2db11d4c 100644
--- a/dbms/tests/queries/0_stateless/00399_group_uniq_array_date_datetime.sql
+++ b/dbms/tests/queries/0_stateless/00399_group_uniq_array_date_datetime.sql
@@ -1,5 +1,12 @@
 DROP TABLE IF EXISTS test.grop_uniq_array_date;
-CREATE TABLE test.grop_uniq_array_date (d Date, dt DateTime) ENGINE = Memory;
-INSERT INTO test.grop_uniq_array_date VALUES (toDate('2016-12-16'), toDateTime('2016-12-16 12:00:00')) (toDate('2016-12-16'), toDateTime('2016-12-16 12:00:00'));
+CREATE TABLE test.grop_uniq_array_date (d Date, dt DateTime, id Integer) ENGINE = Memory;
+
+INSERT INTO test.grop_uniq_array_date VALUES (toDate('2016-12-16'), toDateTime('2016-12-16 12:00:00'), 1) (toDate('2016-12-16'), toDateTime('2016-12-16 12:00:00'), 1);
 SELECT groupUniqArray(d), groupUniqArray(dt) FROM test.grop_uniq_array_date;
+
+INSERT INTO test.grop_uniq_array_date VALUES (toDate('2016-12-17'), toDateTime('2016-12-17 12:00:00'), 1), (toDate('2016-12-18'), toDateTime('2016-12-18 12:00:00'), 1), (toDate('2016-12-16'), toDateTime('2016-12-16 12:00:00'), 2);
+
+SELECT length(groupUniqArray(2)(d)), length(groupUniqArray(2)(dt)), length(groupUniqArray(d)), length(groupUniqArray(dt)) FROM test.grop_uniq_array_date GROUP BY id ORDER BY id;
+SELECT length(groupUniqArray(10000)(d)), length(groupUniqArray(10000)(dt)) FROM test.grop_uniq_array_date GROUP BY id ORDER BY id;
+
 DROP TABLE IF EXISTS test.grop_uniq_array_date;

From 2a6ff2f240d0ae17b28782d1f50b07bba3e47103 Mon Sep 17 00:00:00 2001
From: Guillaume Tassery <tassery.guillaume@gmail.com>
Date: Mon, 15 Apr 2019 18:10:56 +0700
Subject: [PATCH 4/7] Code refactoring for the new size parameter on the
 GroupUniqArray aggregation function

---
 .../AggregateFunctionGroupUniqArray.cpp       |  8 +--
 .../AggregateFunctionGroupUniqArray.h         | 50 +++++++------------
 ...76_shard_group_uniq_array_of_int_array.sql |  3 +-
 3 files changed, 20 insertions(+), 41 deletions(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
index 13c9b328938..49cfe0271d8 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
@@ -51,17 +51,11 @@ static IAggregateFunction * createWithExtraTypes(const DataTypePtr & argument_ty
     }
 }
 
-template <template <typename, typename> class AggregateFunctionTemplate, typename Data, typename ... TArgs>
-static IAggregateFunction * createWithNumericOrTimeType(const IDataType & argument_type, TArgs && ... args)
-{
-    return createWithNumericType<AggregateFunctionTemplate, Data, TArgs...>(argument_type, std::forward<TArgs>(args)...);
-}
-
 template <typename has_limit, typename ... TArgs>
 inline AggregateFunctionPtr createAggregateFunctionGroupUniqArrayImpl(const std::string & name, const DataTypePtr & argument_type, TArgs ... args)
 {
 
-    AggregateFunctionPtr res(createWithNumericOrTimeType<AggregateFunctionGroupUniqArray, has_limit>(*argument_type, argument_type, std::forward<TArgs>(args)...));
+    AggregateFunctionPtr res(createWithNumericType<AggregateFunctionGroupUniqArray, has_limit, const DataTypePtr &, TArgs...>(*argument_type, argument_type, std::forward<TArgs>(args)...));
 
     if (!res)
         res = AggregateFunctionPtr(createWithExtraTypes<has_limit>(argument_type, std::forward<TArgs>(args)...));
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
index bba64b4d786..22d85f5215e 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
@@ -131,6 +131,14 @@ struct AggreagteFunctionGroupUniqArrayGenericData
     Set value;
 };
 
+
+/// Helper function for deserialize and insert for the class AggreagteFunctionGroupUniqArrayGeneric
+template <bool is_plain_column>
+static StringRef getSerializationImpl(const IColumn & column, size_t row_num, Arena & arena);
+
+template <bool is_plain_column>
+static void deserializeAndInsertImpl(StringRef str, IColumn & data_to);
+
 /** Template parameter with true value should be used for columns that store their elements in memory continuously.
  *  For such columns groupUniqArray() can be implemented more efficiently (especially for small numeric arrays).
  */
@@ -145,9 +153,13 @@ class AggreagteFunctionGroupUniqArrayGeneric
 
     using State = AggreagteFunctionGroupUniqArrayGenericData;
 
-    static StringRef getSerialization(const IColumn & column, size_t row_num, Arena & arena);
+    static StringRef getSerialization(const IColumn & column, size_t row_num, Arena & arena) {
+        return getSerializationImpl<is_plain_column>(column, row_num, arena);
+    }
 
-    static void deserializeAndInsert(StringRef str, IColumn & data_to);
+    static void deserializeAndInsert(StringRef str, IColumn & data_to) {
+        return deserializeAndInsertImpl<is_plain_column>(str, data_to);
+    }
 
 public:
     AggreagteFunctionGroupUniqArrayGeneric(const DataTypePtr & input_data_type, UInt64 max_elems_ = std::numeric_limits<UInt64>::max())
@@ -258,52 +270,26 @@ public:
 
 
 template <>
-inline StringRef AggreagteFunctionGroupUniqArrayGeneric<false, std::false_type>::getSerialization(const IColumn & column, size_t row_num, Arena & arena)
+inline StringRef getSerializationImpl<false>(const IColumn & column, size_t row_num, Arena & arena)
 {
     const char * begin = nullptr;
     return column.serializeValueIntoArena(row_num, arena, begin);
 }
 
 template <>
-inline StringRef AggreagteFunctionGroupUniqArrayGeneric<false, std::true_type>::getSerialization(const IColumn & column, size_t row_num, Arena & arena)
-{
-    const char * begin = nullptr;
-    return column.serializeValueIntoArena(row_num, arena, begin);
-}
-
-template <>
-inline StringRef AggreagteFunctionGroupUniqArrayGeneric<true, std::false_type>::getSerialization(const IColumn & column, size_t row_num, Arena &)
+inline StringRef getSerializationImpl<true>(const IColumn & column, size_t row_num, Arena &)
 {
     return column.getDataAt(row_num);
 }
 
 template <>
-inline StringRef AggreagteFunctionGroupUniqArrayGeneric<true, std::true_type>::getSerialization(const IColumn & column, size_t row_num, Arena &)
-{
-    return column.getDataAt(row_num);
-}
-
-
-template <>
-inline void AggreagteFunctionGroupUniqArrayGeneric<false, std::false_type>::deserializeAndInsert(StringRef str, IColumn & data_to)
+inline void deserializeAndInsertImpl<false>(StringRef str, IColumn & data_to)
 {
     data_to.deserializeAndInsertFromArena(str.data);
 }
 
 template <>
-inline void AggreagteFunctionGroupUniqArrayGeneric<false, std::true_type>::deserializeAndInsert(StringRef str, IColumn & data_to)
-{
-    data_to.deserializeAndInsertFromArena(str.data);
-}
-
-template <>
-inline void AggreagteFunctionGroupUniqArrayGeneric<true, std::true_type>::deserializeAndInsert(StringRef str, IColumn & data_to)
-{
-    data_to.insertData(str.data, str.size);
-}
-
-template <>
-inline void AggreagteFunctionGroupUniqArrayGeneric<true, std::false_type>::deserializeAndInsert(StringRef str, IColumn & data_to)
+inline void deserializeAndInsertImpl<true>(StringRef str, IColumn & data_to)
 {
     data_to.insertData(str.data, str.size);
 }
diff --git a/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.sql b/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.sql
index 4674da3c03c..ef5dfc6c489 100644
--- a/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.sql
+++ b/dbms/tests/queries/0_stateless/00376_shard_group_uniq_array_of_int_array.sql
@@ -4,8 +4,7 @@ CREATE TABLE test.group_uniq_arr_int ENGINE = Memory AS
 		(SELECT intDiv(number%1000000, 100) as v, intDiv(number%100, 10) as g, number%10 as c FROM system.numbers WHERE c < 3 LIMIT 10000000);
 
 SELECT length(groupUniqArray(v)) FROM test.group_uniq_arr_int GROUP BY id ORDER BY id;
-SELECT length(groupUniqArray(v)) FROM test.group_uniq_arr_int GROUP BY id ORDER BY id;
---SELECT length(groupUniqArray(v)) FROM remote('127.0.0.{2,3,4,5}', 'test', 'group_uniq_arr_int') GROUP BY id ORDER BY id;
+SELECT length(groupUniqArray(v)) FROM remote('127.0.0.{2,3,4,5}', 'test', 'group_uniq_arr_int') GROUP BY id ORDER BY id;
 SELECT length(groupUniqArray(10)(v)) FROM test.group_uniq_arr_int GROUP BY id ORDER BY id;
 SELECT length(groupUniqArray(100000)(v)) FROM test.group_uniq_arr_int GROUP BY id ORDER BY id;
 

From 3816b4057901f8c0d3d64b2e16b31157a97b01c4 Mon Sep 17 00:00:00 2001
From: Guillaume Tassery <tassery.guillaume@gmail.com>
Date: Wed, 17 Apr 2019 14:15:59 +0700
Subject: [PATCH 5/7] Add documentation about the max_size argument for
 groupUniqArray

---
 docs/en/query_language/agg_functions/reference.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/docs/en/query_language/agg_functions/reference.md b/docs/en/query_language/agg_functions/reference.md
index 811d23c7b01..033cea705d3 100644
--- a/docs/en/query_language/agg_functions/reference.md
+++ b/docs/en/query_language/agg_functions/reference.md
@@ -369,10 +369,13 @@ Optional parameters:
 - The default value for substituting in empty positions.
 - The length of the resulting array. This allows you to receive arrays of the same size for all the aggregate keys. When using this parameter, the default value must be specified.
 
-## groupUniqArray(x)
+## groupUniqArray(x), groupUniqArray(max_size)(x)
 
 Creates an array from different argument values. Memory consumption is the same as for the `uniqExact` function.
 
+The second version (with the `max_size` parameter) limits the size of the resulting array to `max_size` elements.
+For example, `groupUniqArray (1) (x)` is equivalent to `[any (x)]`.
+
 ## quantile(level)(x)
 
 Approximates the `level` quantile. `level` is a constant, a floating-point number from 0 to 1.

From a96e3c470e4fce76d5b3720ddeaf07d9c711eefa Mon Sep 17 00:00:00 2001
From: Guillaume Tassery <tassery.guillaume@gmail.com>
Date: Wed, 17 Apr 2019 17:24:02 +0700
Subject: [PATCH 6/7] Reformate code for optional parameter for groupUniqArray

---
 .../AggregateFunctions/AggregateFunctionGroupUniqArray.h    | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
index 22d85f5215e..7bc462f7f3f 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
@@ -153,11 +153,13 @@ class AggreagteFunctionGroupUniqArrayGeneric
 
     using State = AggreagteFunctionGroupUniqArrayGenericData;
 
-    static StringRef getSerialization(const IColumn & column, size_t row_num, Arena & arena) {
+    static StringRef getSerialization(const IColumn & column, size_t row_num, Arena & arena)
+    {
         return getSerializationImpl<is_plain_column>(column, row_num, arena);
     }
 
-    static void deserializeAndInsert(StringRef str, IColumn & data_to) {
+    static void deserializeAndInsert(StringRef str, IColumn & data_to)
+    {
         return deserializeAndInsertImpl<is_plain_column>(str, data_to);
     }
 

From 3db650861d168a97310e09fd355996d3af77419f Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Wed, 24 Apr 2019 01:40:16 +0300
Subject: [PATCH 7/7] Update AggregateFunctionGroupUniqArray.h

---
 dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
index 7bc462f7f3f..f2b339d2729 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
@@ -78,7 +78,7 @@ public:
             for (auto & rhs_elem : rhs_set)
             {
                 if (cur_set.size() >= max_elems)
-                    return ;
+                    return;
                 cur_set.insert(rhs_elem.getValue());
             }
         }