diff --git a/be/src/vec/aggregate_functions/aggregate_function_max_by.cpp b/be/src/vec/aggregate_functions/aggregate_function_max_by.cpp
deleted file mode 100644
index 50e611b11d8b3e..00000000000000
--- a/be/src/vec/aggregate_functions/aggregate_function_max_by.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include <memory>
-
-#include "vec/aggregate_functions/aggregate_function_min_max_by.h"
-#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
-
-namespace doris::vectorized {
-#include "common/compile_check_begin.h"
-
-void register_aggregate_function_max_by(AggregateFunctionSimpleFactory& factory) {
-    factory.register_function_both(
-            "max_by", create_aggregate_function_min_max_by<AggregateFunctionsMinMaxBy,
-                                                           AggregateFunctionMaxByData>);
-}
-
-} // namespace doris::vectorized
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_by.cpp b/be/src/vec/aggregate_functions/aggregate_function_min_by.cpp
deleted file mode 100644
index 0af34292bbb2eb..00000000000000
--- a/be/src/vec/aggregate_functions/aggregate_function_min_by.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include <memory>
-
-#include "vec/aggregate_functions/aggregate_function_min_max_by.h"
-#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
-
-namespace doris::vectorized {
-#include "common/compile_check_begin.h"
-
-void register_aggregate_function_min_by(AggregateFunctionSimpleFactory& factory) {
-    factory.register_function_both(
-            "min_by", create_aggregate_function_min_max_by<AggregateFunctionsMinMaxBy,
-                                                           AggregateFunctionMinByData>);
-}
-
-} // namespace doris::vectorized
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max.cpp b/be/src/vec/aggregate_functions/aggregate_function_min_max.cpp
index f894faa5119629..f127cbb4c51f14 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_min_max.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_min_max.cpp
@@ -134,35 +134,20 @@ AggregateFunctionPtr create_aggregate_function_single_value(const String& name,
         return creator_without_type::create_unary_arguments<
                 AggregateFunctionsSingleValue<Data<SingleValueDataDecimal<TYPE_DECIMAL256>>>>(
                 argument_types, result_is_nullable, attr);
-    default:
-        return nullptr;
-    }
-}
-
-// any_value
-template <template <typename> class Data>
-AggregateFunctionPtr create_aggregate_function_single_value_any_value_function(
-        const String& name, const DataTypes& argument_types, const DataTypePtr& result_type,
-        const bool result_is_nullable, const AggregateFunctionAttr& attr) {
-    AggregateFunctionPtr res = create_aggregate_function_single_value<Data>(
-            name, argument_types, result_type, result_is_nullable, attr);
-    if (res) {
-        return res;
-    }
-    const DataTypePtr& argument_type = remove_nullable(argument_types[0]);
-    if (argument_type->get_primitive_type() == PrimitiveType::TYPE_ARRAY ||
-        argument_type->get_primitive_type() == PrimitiveType::TYPE_MAP ||
-        argument_type->get_primitive_type() == PrimitiveType::TYPE_STRUCT ||
-        argument_type->get_primitive_type() == PrimitiveType::TYPE_AGG_STATE ||
-        argument_type->get_primitive_type() == PrimitiveType::TYPE_BITMAP ||
-        argument_type->get_primitive_type() == PrimitiveType::TYPE_HLL ||
-        argument_type->get_primitive_type() == PrimitiveType::TYPE_QUANTILE_STATE) {
+    // For Complex type. Currently, only type_array supports min and max.
+    case PrimitiveType::TYPE_ARRAY:
+    case PrimitiveType::TYPE_MAP:
+    case PrimitiveType::TYPE_STRUCT:
+    case PrimitiveType::TYPE_AGG_STATE:
+    case PrimitiveType::TYPE_BITMAP:
+    case PrimitiveType::TYPE_HLL:
+    case PrimitiveType::TYPE_QUANTILE_STATE:
         return creator_without_type::create_unary_arguments<
-                AggregateFunctionsSingleValue<SingleValueDataComplexType>>(
+                AggregateFunctionsSingleValue<Data<SingleValueDataComplexType>>>(
                 argument_types, result_is_nullable, attr);
+    default:
+        return nullptr;
     }
-
-    return nullptr;
 }
 
 void register_aggregate_function_minmax(AggregateFunctionSimpleFactory& factory) {
@@ -171,8 +156,7 @@ void register_aggregate_function_minmax(AggregateFunctionSimpleFactory& factory)
     factory.register_function_both(
             "min", create_aggregate_function_single_value<AggregateFunctionMinData>);
     factory.register_function_both(
-            "any",
-            create_aggregate_function_single_value_any_value_function<AggregateFunctionAnyData>);
+            "any", create_aggregate_function_single_value<AggregateFunctionAnyData>);
     factory.register_alias("any", "any_value");
 }
 
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max.h b/be/src/vec/aggregate_functions/aggregate_function_min_max.h
index a2a868ad64bcbe..835c2c0c44055e 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_min_max.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_min_max.h
@@ -36,6 +36,7 @@
 #include "runtime/type_limit.h"
 #include "vec/aggregate_functions/aggregate_function.h"
 #include "vec/columns/column.h"
+#include "vec/columns/column_array.h"
 #include "vec/columns/column_fixed_length_object.h"
 #include "vec/columns/column_string.h"
 #include "vec/common/assert_cast.h"
@@ -522,12 +523,152 @@ struct SingleValueDataString {
     }
 };
 
+struct SingleValueDataComplexType {
+private:
+    using Self = SingleValueDataComplexType;
+
+    DataTypePtr column_type;
+    bool has_value = false;
+    MutableColumnPtr column_data; // a column ptr only save a single value
+    int be_exec_version = -1;
+
+public:
+    SingleValueDataComplexType() = default;
+    SingleValueDataComplexType(const DataTypes& argument_types, int be_version) {
+        column_type = argument_types[0];
+        column_data = column_type->create_column();
+        be_exec_version = be_version;
+    }
+
+    bool has() const { return has_value; }
+
+    constexpr static bool IsFixedLength = false;
+
+    void insert_result_into(IColumn& to) const {
+        if (has()) {
+            to.insert_from(*column_data, 0);
+        } else {
+            to.insert_default();
+        }
+    }
+
+    void reset() {
+        has_value = false;
+        column_data->clear();
+    }
+
+    void write(BufferWritable& buf) const {
+        buf.write_binary(has_value);
+        if (!has()) {
+            return;
+        }
+        auto size_bytes =
+                column_type->get_uncompressed_serialized_bytes(*column_data, be_exec_version);
+        buf.write_binary(size_bytes);
+        buf.resize(size_bytes);
+        auto* p = column_type->serialize(*column_data, buf.data(), be_exec_version);
+        DCHECK_EQ(p, buf.data() + size_bytes);
+        buf.add_offset(size_bytes);
+    }
+
+    void read(BufferReadable& buf, Arena& arena) {
+        buf.read_binary(has_value);
+        if (!has()) {
+            return;
+        }
+        int64_t size;
+        buf.read_binary(size);
+        const auto* p = column_type->deserialize(buf.data(), &column_data, be_exec_version);
+        DCHECK_EQ(p, buf.data() + size);
+        buf.add_offset(size);
+    }
+
+    void change(const IColumn& column, size_t row_num, Arena&) {
+        has_value = true;
+        column_data->clear();
+        column_data->insert_from(column, row_num);
+    }
+
+    /// Assuming to.has()
+    void change(const Self& to, Arena&) {
+        has_value = true;
+        column_data->clear();
+        column_data->insert_from(*to.column_data, 0);
+    }
+
+    bool change_if_less(const IColumn& column, size_t row_num, Arena& arena) {
+        if (!has() || column_data->compare_at(0, row_num, column, -1) == 1) {
+            change(column, row_num, arena);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    bool change_if_less(const Self& to, Arena& arena) {
+        if (to.has() && (!has() || column_data->compare_at(0, 0, *to.column_data, -1) == 1)) {
+            change(to, arena);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    bool change_if_greater(const IColumn& column, size_t row_num, Arena& arena) {
+        if (!has() || column_data->compare_at(0, row_num, column, -1) == -1) {
+            change(column, row_num, arena);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    bool change_if_greater(const Self& to, Arena& arena) {
+        if (to.has() && (!has() || column_data->compare_at(0, 0, *to.column_data, -1) == -1)) {
+            change(to, arena);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    bool check_if_equal(const IColumn& column, size_t row_num) const {
+        if (!has()) {
+            return false;
+        }
+        auto type = column_type->get_primitive_type();
+        if (type == TYPE_BITMAP || type == TYPE_HLL || type == TYPE_QUANTILE_STATE ||
+            type == TYPE_AGG_STATE) {
+            return false;
+        } else {
+            return !column_data->compare_at(0, row_num, column, -1);
+        }
+    }
+
+    void change_first_time(const IColumn& column, size_t row_num, Arena& arena) {
+        if (UNLIKELY(!has())) {
+            change(column, row_num, arena);
+        }
+    }
+
+    void change_first_time(const Self& to, Arena& arena) {
+        if (UNLIKELY(!has() && to.has())) {
+            change(to, arena);
+        }
+    }
+};
+
 template <typename Data>
 struct AggregateFunctionMaxData : public Data {
     using Self = AggregateFunctionMaxData;
     using Data::IsFixedLength;
     constexpr static bool IS_ANY = false;
 
+    AggregateFunctionMaxData(const DataTypes& argument_types, int be_version)
+            : Data(argument_types, be_version) {
+        this->reset();
+    }
+
     AggregateFunctionMaxData() { reset(); }
 
     void change_if_better(const IColumn& column, size_t row_num, Arena& arena) {
@@ -556,6 +697,11 @@ struct AggregateFunctionMinData : Data {
     using Data::IsFixedLength;
     constexpr static bool IS_ANY = false;
 
+    AggregateFunctionMinData(const DataTypes& argument_types, int be_version)
+            : Data(argument_types, be_version) {
+        this->reset();
+    }
+
     AggregateFunctionMinData() { reset(); }
 
     void change_if_better(const IColumn& column, size_t row_num, Arena& arena) {
@@ -584,99 +730,17 @@ struct AggregateFunctionAnyData : Data {
     using Data::IsFixedLength;
     static const char* name() { return "any"; }
     constexpr static bool IS_ANY = true;
-    void change_if_better(const IColumn& column, size_t row_num, Arena& arena) {
-        this->change_first_time(column, row_num, arena);
-    }
-
-    void change_if_better(const Self& to, Arena& arena) { this->change_first_time(to, arena); }
-};
-
-// this is used for complex type about any_value function
-struct SingleValueDataComplexType {
-    static const char* name() { return "any"; }
-    constexpr static bool IS_ANY = true;
-    constexpr static bool IsFixedLength = false;
-    using Self = SingleValueDataComplexType;
-
-    SingleValueDataComplexType() = default;
-
-    SingleValueDataComplexType(const DataTypes& argument_types, int be_version) {
-        column_type = argument_types[0];
-        column_data = column_type->create_column();
-        be_exec_version = be_version;
-    }
-
-    bool has() const { return has_value; }
-
-    void change_first_time(const IColumn& column, size_t row_num, Arena&) {
-        if (UNLIKELY(!has())) {
-            change_impl(column, row_num);
-        }
-    }
-
-    void change_first_time(const Self& to, Arena&) {
-        if (UNLIKELY(!has() && to.has())) {
-            change_impl(*to.column_data, 0);
-        }
-    }
-
-    void change_impl(const IColumn& column, size_t row_num) {
-        DCHECK_EQ(column_data->size(), 0);
-        column_data->insert_from(column, row_num);
-        has_value = true;
-    }
-
-    void insert_result_into(IColumn& to) const {
-        if (has()) {
-            to.insert_from(*column_data, 0);
-        } else {
-            to.insert_default();
-        }
-    }
-
-    void reset() {
-        column_data->clear();
-        has_value = false;
-    }
 
-    void write(BufferWritable& buf) const {
-        buf.write_binary(has());
-        if (!has()) {
-            return;
-        }
-        auto size_bytes =
-                column_type->get_uncompressed_serialized_bytes(*column_data, be_exec_version);
-        std::string memory_buffer(size_bytes, '0');
-        auto* p = column_type->serialize(*column_data, memory_buffer.data(), be_exec_version);
-        buf.write_binary(memory_buffer);
-        DCHECK_EQ(p, memory_buffer.data() + size_bytes);
-    }
+    AggregateFunctionAnyData(const DataTypes& argument_types, int be_version)
+            : Data(argument_types, be_version) {};
 
-    void read(BufferReadable& buf, Arena& arena) {
-        buf.read_binary(has_value);
-        if (!has()) {
-            return;
-        }
-        std::string memory_buffer;
-        buf.read_binary(memory_buffer);
-        const auto* p =
-                column_type->deserialize(memory_buffer.data(), &column_data, be_exec_version);
-        DCHECK_EQ(p, memory_buffer.data() + memory_buffer.size());
-    }
+    AggregateFunctionAnyData() {};
 
     void change_if_better(const IColumn& column, size_t row_num, Arena& arena) {
         this->change_first_time(column, row_num, arena);
     }
 
     void change_if_better(const Self& to, Arena& arena) { this->change_first_time(to, arena); }
-
-    bool check_if_equal(const IColumn& column, size_t row_num) const { return false; }
-
-private:
-    bool has_value = false;
-    MutableColumnPtr column_data;
-    DataTypePtr column_type;
-    int be_exec_version = -1;
 };
 
 template <typename Data>
@@ -693,7 +757,9 @@ class AggregateFunctionsSingleValue final
               type(this->argument_types[0]) {}
 
     void create(AggregateDataPtr __restrict place) const override {
-        if constexpr (std::is_same_v<Data, SingleValueDataComplexType>) {
+        if constexpr (std::is_same_v<Data, AggregateFunctionMaxData<SingleValueDataComplexType>> ||
+                      std::is_same_v<Data, AggregateFunctionMinData<SingleValueDataComplexType>> ||
+                      std::is_same_v<Data, AggregateFunctionAnyData<SingleValueDataComplexType>>) {
             new (place) Data(argument_types, IAggregateFunction::version);
         } else {
             new (place) Data;
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp
index bc77a3275279d5..659a2181c26b98 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp
@@ -17,9 +17,11 @@
 
 #include "vec/aggregate_functions/aggregate_function_min_max_by.h"
 
+#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
+
 namespace doris::vectorized {
 #include "common/compile_check_begin.h"
-std::unique_ptr<MaxMinValueBase> create_max_min_value(const DataTypePtr& type) {
+std::unique_ptr<MaxMinValueBase> create_max_min_value(const DataTypePtr& type, int be_version) {
     switch (type->get_primitive_type()) {
     case PrimitiveType::TYPE_BOOLEAN:
         return std::make_unique<MaxMinValue<SingleValueDataFixed<TYPE_BOOLEAN>>>();
@@ -61,6 +63,11 @@ std::unique_ptr<MaxMinValueBase> create_max_min_value(const DataTypePtr& type) {
         return std::make_unique<MaxMinValue<SingleValueDataFixed<TYPE_DATETIMEV2>>>();
     case PrimitiveType::TYPE_BITMAP:
         return std::make_unique<MaxMinValue<BitmapValueData>>();
+    case PrimitiveType::TYPE_ARRAY:
+    case PrimitiveType::TYPE_MAP:
+    case PrimitiveType::TYPE_STRUCT:
+        return std::make_unique<MaxMinValue<SingleValueDataComplexType>>(DataTypes {type},
+                                                                         be_version);
     default:
         throw doris::Exception(ErrorCode::INTERNAL_ERROR,
                                "Illegal type {} of argument of aggregate function min/max_by",
@@ -69,6 +76,13 @@ std::unique_ptr<MaxMinValueBase> create_max_min_value(const DataTypePtr& type) {
     }
 }
 
+void register_aggregate_function_max_min_by(AggregateFunctionSimpleFactory& factory) {
+    factory.register_function_both(
+            "min_by", create_aggregate_function_min_max_by<AggregateFunctionMinByData>);
+    factory.register_function_both(
+            "max_by", create_aggregate_function_min_max_by<AggregateFunctionMaxByData>);
+}
+
 } // namespace doris::vectorized
 
 #include "common/compile_check_end.h"
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h
index 686505ad99afcc..d2397d0c2558f0 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h
@@ -47,6 +47,9 @@ struct MaxMinValue : public MaxMinValueBase {
 
     MaxMinValue() = default;
 
+    MaxMinValue(const DataTypes& argument_types, int be_version)
+            : value(argument_types, be_version) {}
+
     ~MaxMinValue() override = default;
 
     void write(BufferWritable& buf) const override { value.write(buf); }
@@ -67,7 +70,7 @@ struct MaxMinValue : public MaxMinValueBase {
     }
 };
 
-std::unique_ptr<MaxMinValueBase> create_max_min_value(const DataTypePtr& type);
+std::unique_ptr<MaxMinValueBase> create_max_min_value(const DataTypePtr& type, int be_version);
 
 /// For bitmap value
 struct BitmapValueData {
@@ -120,6 +123,25 @@ struct BitmapValueData {
     }
 };
 
+/**
+ * The template parameter KT is introduced here primarily for performance reasons.
+ *
+ * Without using a template parameter, the key type would have to be
+ * std::unique_ptr<MaxMinValueBase>. Since MaxMinValueBase is a polymorphic base
+ * class with virtual methods, comparing keys would inevitably involve virtual
+ * function calls, which can introduce significant runtime overhead.
+ *
+ * By making KT a template parameter, the concrete key type is known at compile
+ * time, allowing static dispatch and avoiding virtual function calls. This
+ * substantially reduces the cost of key comparisons.
+ *
+ * In contrast, the value type VT is intentionally not made a template parameter.
+ * On one hand, templating both key and value types would lead to an n × n
+ * explosion in template instantiations, increasing compile time and code size.
+ * On the other hand, value objects typically only invoke the change method; for
+ * random data, this method is called approximately log(x) times (where x is the
+ * data size), making the overhead acceptable.
+ */
 template <typename KT>
 struct AggregateFunctionMinMaxByBaseData {
 protected:
@@ -127,8 +149,18 @@ struct AggregateFunctionMinMaxByBaseData {
     KT key;
 
 public:
-    AggregateFunctionMinMaxByBaseData(const DataTypes argument_types) {
-        value = create_max_min_value(argument_types[0]);
+    AggregateFunctionMinMaxByBaseData() {}
+
+    AggregateFunctionMinMaxByBaseData(const DataTypes argument_types, int be_version)
+        requires(std::is_same_v<KT, SingleValueDataComplexType>)
+            : key(SingleValueDataComplexType(DataTypes {argument_types[1]}, be_version)) {
+        value = create_max_min_value(argument_types[0], be_version);
+    }
+
+    AggregateFunctionMinMaxByBaseData(const DataTypes argument_types, int be_version)
+        requires(!std::is_same_v<KT, SingleValueDataComplexType>)
+    {
+        value = create_max_min_value(argument_types[0], be_version);
     }
 
     void insert_result_into(IColumn& to) const { value->insert_result_into(to); }
@@ -152,8 +184,10 @@ template <typename KT>
 struct AggregateFunctionMaxByData : public AggregateFunctionMinMaxByBaseData<KT> {
     using Self = AggregateFunctionMaxByData;
 
-    AggregateFunctionMaxByData(const DataTypes argument_types)
-            : AggregateFunctionMinMaxByBaseData<KT>(argument_types) {}
+    AggregateFunctionMaxByData() {}
+
+    AggregateFunctionMaxByData(const DataTypes argument_types, int be_version)
+            : AggregateFunctionMinMaxByBaseData<KT>(argument_types, be_version) {}
 
     void change_if_better(const IColumn& value_column, const IColumn& key_column, size_t row_num,
                           Arena& arena) {
@@ -188,8 +222,11 @@ template <typename KT>
 struct AggregateFunctionMinByData : public AggregateFunctionMinMaxByBaseData<KT> {
     using Self = AggregateFunctionMinByData;
 
-    AggregateFunctionMinByData(const DataTypes argument_types)
-            : AggregateFunctionMinMaxByBaseData<KT>(argument_types) {}
+    AggregateFunctionMinByData() {}
+
+    AggregateFunctionMinByData(const DataTypes argument_types, int be_version)
+            : AggregateFunctionMinMaxByBaseData<KT>(argument_types, be_version) {}
+
     void change_if_better(const IColumn& value_column, const IColumn& key_column, size_t row_num,
                           Arena& arena) {
         if (this->key.change_if_less(key_column, row_num, arena)) {
@@ -221,7 +258,7 @@ struct AggregateFunctionMinByData : public AggregateFunctionMinMaxByBaseData<KT>
 
 template <typename Data>
 class AggregateFunctionsMinMaxBy final
-        : public IAggregateFunctionDataHelper<Data, AggregateFunctionsMinMaxBy<Data>, true>,
+        : public IAggregateFunctionDataHelper<Data, AggregateFunctionsMinMaxBy<Data>>,
           MultiExpression,
           NullableAggregateFunction {
 private:
@@ -230,11 +267,15 @@ class AggregateFunctionsMinMaxBy final
 
 public:
     AggregateFunctionsMinMaxBy(const DataTypes& arguments)
-            : IAggregateFunctionDataHelper<Data, AggregateFunctionsMinMaxBy<Data>, true>(
+            : IAggregateFunctionDataHelper<Data, AggregateFunctionsMinMaxBy<Data>>(
                       {arguments[0], arguments[1]}),
               value_type(this->argument_types[0]),
               key_type(this->argument_types[1]) {}
 
+    void create(AggregateDataPtr __restrict place) const override {
+        new (place) Data(IAggregateFunction::argument_types, IAggregateFunction::version);
+    }
+
     String get_name() const override { return Data::name(); }
 
     DataTypePtr get_return_type() const override { return value_type; }
@@ -270,7 +311,7 @@ class AggregateFunctionsMinMaxBy final
     }
 };
 
-template <template <typename> class AggregateFunctionTemplate, template <typename> class Data>
+template <template <typename> class Data>
 AggregateFunctionPtr create_aggregate_function_min_max_by(const String& name,
                                                           const DataTypes& argument_types,
                                                           const DataTypePtr& result_type,
@@ -283,77 +324,81 @@ AggregateFunctionPtr create_aggregate_function_min_max_by(const String& name,
     switch (argument_types[1]->get_primitive_type()) {
     case PrimitiveType::TYPE_BOOLEAN:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_BOOLEAN>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_BOOLEAN>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_TINYINT:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_TINYINT>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_TINYINT>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_SMALLINT:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_SMALLINT>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_SMALLINT>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_INT:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_INT>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_INT>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_BIGINT:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_BIGINT>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_BIGINT>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_LARGEINT:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_LARGEINT>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_LARGEINT>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_FLOAT:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_FLOAT>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_FLOAT>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_DOUBLE:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_DOUBLE>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_DOUBLE>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_DECIMAL32:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataDecimal<TYPE_DECIMAL32>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataDecimal<TYPE_DECIMAL32>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_DECIMAL64:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataDecimal<TYPE_DECIMAL64>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataDecimal<TYPE_DECIMAL64>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_DECIMAL128I:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataDecimal<TYPE_DECIMAL128I>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataDecimal<TYPE_DECIMAL128I>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_DECIMALV2:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataDecimal<TYPE_DECIMALV2>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataDecimal<TYPE_DECIMALV2>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_DECIMAL256:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataDecimal<TYPE_DECIMAL256>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataDecimal<TYPE_DECIMAL256>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_CHAR:
     case PrimitiveType::TYPE_VARCHAR:
     case PrimitiveType::TYPE_STRING:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataString>>>(argument_types,
-                                                                        result_is_nullable, attr);
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataString>>>(argument_types,
+                                                                         result_is_nullable, attr);
     case PrimitiveType::TYPE_DATE:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_DATE>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_DATE>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_DATETIME:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_DATETIME>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_DATETIME>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_DATEV2:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_DATEV2>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_DATEV2>>>>(
                 argument_types, result_is_nullable, attr);
     case PrimitiveType::TYPE_DATETIMEV2:
         return creator_without_type::create_multi_arguments<
-                AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE_DATETIMEV2>>>>(
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataFixed<TYPE_DATETIMEV2>>>>(
+                argument_types, result_is_nullable, attr);
+    case PrimitiveType::TYPE_ARRAY:
+        return creator_without_type::create_multi_arguments<
+                AggregateFunctionsMinMaxBy<Data<SingleValueDataComplexType>>>(
                 argument_types, result_is_nullable, attr);
     default:
         return nullptr;
diff --git a/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp b/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
index aa4410d347ed17..8ba0696b667535 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
@@ -33,8 +33,7 @@ void register_aggregate_function_combinator_foreachv2(AggregateFunctionSimpleFac
 
 void register_aggregate_function_sum(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_minmax(AggregateFunctionSimpleFactory& factory);
-void register_aggregate_function_min_by(AggregateFunctionSimpleFactory& factory);
-void register_aggregate_function_max_by(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_max_min_by(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_avg(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_count(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_count_by_enum(AggregateFunctionSimpleFactory& factory);
@@ -87,8 +86,7 @@ AggregateFunctionSimpleFactory& AggregateFunctionSimpleFactory::instance() {
     std::call_once(oc, [&]() {
         register_aggregate_function_sum(instance);
         register_aggregate_function_minmax(instance);
-        register_aggregate_function_min_by(instance);
-        register_aggregate_function_max_by(instance);
+        register_aggregate_function_max_min_by(instance);
         register_aggregate_function_avg(instance);
         register_aggregate_function_count(instance);
         register_aggregate_function_count_by_enum(instance);
diff --git a/be/src/vec/common/string_buffer.hpp b/be/src/vec/common/string_buffer.hpp
index 809bdffcd581f3..4d69e97cd3bc5c 100644
--- a/be/src/vec/common/string_buffer.hpp
+++ b/be/src/vec/common/string_buffer.hpp
@@ -53,6 +53,12 @@ class BufferWritable final {
         _now_offset = 0;
     }
 
+    char* data() { return reinterpret_cast<char*>(_data.data() + _now_offset + _offsets.back()); }
+
+    void add_offset(size_t len) { _now_offset += len; }
+
+    void resize(size_t size) { _data.resize(size + _now_offset + _offsets.back()); }
+
     template <typename T>
     void write_number(T data) {
         fmt::memory_buffer buffer;
@@ -236,6 +242,10 @@ class BufferReadable {
         _data += len;
     }
 
+    const char* data() { return _data; }
+
+    void add_offset(size_t len) { _data += len; }
+
     void read_var_uint(UInt64& x) {
         x = 0;
         // get length from first byte firstly
diff --git a/be/test/vec/aggregate_functions/agg_min_max_by_test.cpp b/be/test/vec/aggregate_functions/agg_min_max_by_test.cpp
index c50fb52d6996b3..9150738d26fd41 100644
--- a/be/test/vec/aggregate_functions/agg_min_max_by_test.cpp
+++ b/be/test/vec/aggregate_functions/agg_min_max_by_test.cpp
@@ -45,8 +45,7 @@ const int agg_test_batch_size = 4096;
 
 namespace doris::vectorized {
 // declare function
-void register_aggregate_function_min_by(AggregateFunctionSimpleFactory& factory);
-void register_aggregate_function_max_by(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_max_min_by(AggregateFunctionSimpleFactory& factory);
 
 class AggMinMaxByTest : public ::testing::TestWithParam<std::string> {};
 
@@ -76,8 +75,7 @@ TEST_P(AggMinMaxByTest, min_max_by_test) {
 
     // Prepare test function and parameters.
     AggregateFunctionSimpleFactory factory;
-    register_aggregate_function_min_by(factory);
-    register_aggregate_function_max_by(factory);
+    register_aggregate_function_max_min_by(factory);
 
     // Test on 2 kind of key types (int32, string).
     for (int i = 0; i < 2; i++) {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Max.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Max.java
index eae94f395cffa6..600ea1d939ac20 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Max.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Max.java
@@ -57,11 +57,16 @@ private Max(NullableAggregateFunctionParams functionParams) {
 
     @Override
     public void checkLegalityBeforeTypeCoercion() {
-        if (getArgumentType(0).isOnlyMetricType()) {
+        if (getArgumentType(0).isOnlyMetricType() && !getArgumentType(0).isArrayType()) {
             throw new AnalysisException(Type.OnlyMetricTypeErrorMsg);
         }
     }
 
+    @Override
+    public void checkLegalityAfterRewrite() {
+        checkLegalityBeforeTypeCoercion();
+    }
+
     @Override
     public FunctionSignature customSignature() {
         DataType dataType = getArgument(0).getDataType();
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/MaxBy.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/MaxBy.java
index cc0324bcf3937f..63ca76c4800165 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/MaxBy.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/MaxBy.java
@@ -66,11 +66,16 @@ private MaxBy(NullableAggregateFunctionParams functionParams) {
 
     @Override
     public void checkLegalityBeforeTypeCoercion() {
-        if (getArgumentType(1).isOnlyMetricType()) {
+        if (getArgumentType(1).isOnlyMetricType() && !getArgumentType(1).isArrayType()) {
             throw new AnalysisException(Type.OnlyMetricTypeErrorMsg);
         }
     }
 
+    @Override
+    public void checkLegalityAfterRewrite() {
+        checkLegalityBeforeTypeCoercion();
+    }
+
     /**
      * withDistinctAndChildren.
      */
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Min.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Min.java
index 78700e7ed1117f..515e2e7323ff99 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Min.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Min.java
@@ -58,11 +58,16 @@ private Min(NullableAggregateFunctionParams functionParams) {
 
     @Override
     public void checkLegalityBeforeTypeCoercion() {
-        if (getArgumentType(0).isOnlyMetricType()) {
+        if (getArgumentType(0).isOnlyMetricType() && !getArgumentType(0).isArrayType()) {
             throw new AnalysisException(Type.OnlyMetricTypeErrorMsg);
         }
     }
 
+    @Override
+    public void checkLegalityAfterRewrite() {
+        checkLegalityBeforeTypeCoercion();
+    }
+
     @Override
     public FunctionSignature customSignature() {
         DataType dataType = getArgument(0).getDataType();
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/MinBy.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/MinBy.java
index 632abea03225b9..ab3f7a68e74da8 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/MinBy.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/MinBy.java
@@ -66,11 +66,16 @@ private MinBy(NullableAggregateFunctionParams functionParams) {
 
     @Override
     public void checkLegalityBeforeTypeCoercion() {
-        if (getArgumentType(1).isOnlyMetricType()) {
+        if (getArgumentType(1).isOnlyMetricType() && !getArgumentType(1).isArrayType()) {
             throw new AnalysisException(Type.OnlyMetricTypeErrorMsg);
         }
     }
 
+    @Override
+    public void checkLegalityAfterRewrite() {
+        checkLegalityBeforeTypeCoercion();
+    }
+
     /**
      * withDistinctAndChildren.
      */
diff --git a/regression-test/data/query_p0/sql_functions/aggregate_functions/test_aggregate_all_functions2.out b/regression-test/data/query_p0/sql_functions/aggregate_functions/test_aggregate_all_functions2.out
index aad0d7f02867fd..41ca9183b9c002 100644
--- a/regression-test/data/query_p0/sql_functions/aggregate_functions/test_aggregate_all_functions2.out
+++ b/regression-test/data/query_p0/sql_functions/aggregate_functions/test_aggregate_all_functions2.out
@@ -372,3 +372,81 @@ true
 -- !select_histogram_k13_all_null --
 {"num_buckets":0,"buckets":[]}
 
+-- !maxmin_array_1 --
+\N	\N
+
+-- !maxminby_array_1 --
+\N	\N
+
+-- !maxminby_map_1 --
+\N	\N
+
+-- !maxminby_struct_1 --
+\N	\N
+
+-- !maxmin_array_2 --
+[7]	[1, 2, 3]
+[1, 2, 5]	[1, 2]
+[11, 22, 33, 44]	[3, 1]
+[10]	[]
+[11, null, null, 55]	[1, null, null, 4]
+
+-- !maxminby_array_2 --
+[1, 2, 5]	[11, 22, 33, 44]
+
+-- !maxminby_array_3 --
+{"A":10, "B":1}	{"x":50, "y":60}
+
+-- !maxminby_array_4 --
+{"a":10, "b":"tt"}	{"a":4, "b":"delta"}
+
+-- !maxminby_array_5 --
+1	[5, 6]	[7]
+2	[1, 2, 5]	[1, 2]
+3	[3, 1]	[11, 22, 33, 44]
+4	[3, 1]	[10]
+5	[1, null, 3, 4]	[1, 2, 3, 4]
+
+-- !maxminby_map_2 --
+{"foo":1, "bar":2}	{"A":10, "B":1}
+
+-- !maxminby_map_3 --
+1	{"k1":30, "k2":15}	{"x":100, "y":200}
+2	{"foo":1, "bar":2}	{"foo":2, "bar":1}
+3	{"key1":99, "key2":98}	{"A":10, "B":1}
+4	{"key1":99, "key2":98}	{"A":5, "B":10}
+5	{"A":null, "B":null}	{"A":null, "B":5}
+
+-- !maxminby_map_4 --
+1	{"x":100, "y":200}	{"k1":10, "k2":20}
+2	{"foo":1, "bar":2}	{"foo":2, "bar":1}
+3	{"A":10, "B":1}	{"key1":99, "key2":98}
+4	{"A":5, "B":10}	{"x":50, "y":60}
+5	{"A":10, "B":5}	{"A":null, "B":null}
+
+-- !maxminby_struct_2 --
+{"a":5, "b":"echo"}	{"a":10, "b":"tt"}
+
+-- !maxminby_struct_3 --
+1	{"a":2, "b":"beta"}	{"a":3, "b":"gamma"}
+2	{"a":5, "b":"echo"}	{"a":6, "b":"zulu"}
+3	{"a":8, "b":"eight"}	{"a":10, "b":"tt"}
+4	{"a":8, "b":"eight"}	{"a":9, "b":"nine"}
+5	{"a":null, "b":null}	{"a":null, "b":"ten"}
+
+-- !maxminby_struct_4 --
+1	{"a":3, "b":"gamma"}	{"a":1, "b":"alpha"}
+2	{"a":5, "b":"echo"}	{"a":6, "b":"zulu"}
+3	{"a":10, "b":"tt"}	{"a":8, "b":"eight"}
+4	{"a":9, "b":"nine"}	{"a":4, "b":"delta"}
+5	{"a":10, "b":"ten"}	{"a":null, "b":null}
+
+-- !maxmin_array_3 --
+[[3, 4], [3, 4]]	[[1, 2], [3, 4]]
+
+-- !maxminby_array_6 --
+3	1
+
+-- !maxminby_array_7 --
+[[3, 4], [3, 4]]	[[1, 2], [3, 4]]
+
diff --git a/regression-test/suites/query_p0/sql_functions/aggregate_functions/test_aggregate_all_functions2.groovy b/regression-test/suites/query_p0/sql_functions/aggregate_functions/test_aggregate_all_functions2.groovy
index 5da30a1ae04a4f..3d9258f656801f 100644
--- a/regression-test/suites/query_p0/sql_functions/aggregate_functions/test_aggregate_all_functions2.groovy
+++ b/regression-test/suites/query_p0/sql_functions/aggregate_functions/test_aggregate_all_functions2.groovy
@@ -271,4 +271,83 @@ suite("test_aggregate_all_functions2") {
     qt_select_histogram_k11_all_null """SELECT histogram(k11, 11) FROM baseall"""
     qt_select_histogram_k12_all_null """SELECT histogram(k12, 12) FROM baseall"""
     qt_select_histogram_k13_all_null """SELECT histogram(k13, 13) FROM baseall"""
+
+    sql "DROP TABLE IF EXISTS test_maxmin";
+
+    sql """
+        CREATE TABLE test_maxmin (
+            id INT,
+            arr ARRAY<INT>,
+            mp MAP<STRING, INT>,
+            st STRUCT<a: INT, b: STRING>,
+            weight INT
+        ) engine=olap
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        properties("replication_num" = "1","store_row_column" = "true");
+    """
+
+    qt_maxmin_array_1 """SELECT max(arr), min(arr) from test_maxmin"""
+    qt_maxminby_array_1 """SELECT max_by(arr, weight), min_by(arr, weight) from test_maxmin"""
+    qt_maxminby_map_1 """SELECT max_by(mp, weight), min_by(mp, weight) from test_maxmin"""
+    qt_maxminby_struct_1 """SELECT max_by(st, weight), min_by(st, weight) from test_maxmin"""
+
+    sql """
+        INSERT INTO test_maxmin (id, arr, mp, st, weight) VALUES
+        (1,  [1,2,3],            {"k1": 10, "k2": 20},         NAMED_STRUCT("a", 1, "b", "alpha"),   5),
+        (1,  [5,6],              {"k1": 30, "k2": 15},         NAMED_STRUCT("a", 2, "b", "beta"),    10),
+        (1,  [7],                {"x": 100, "y": 200},         NAMED_STRUCT("a", 3, "b", "gamma"),   3),
+        (2,  [1,2,5],            {"foo": 1, "bar": 2},         NAMED_STRUCT("a", 5, "b", "echo"),    15),
+        (2,  [1,2],              {"foo": 2, "bar": 1},         NAMED_STRUCT("a", 6, "b", "zulu"),    7),
+        (2,  [1,2,3,4],          {"key1": -1, "key2": -5},     NAMED_STRUCT("a", 7, "b", "seven"),   12),
+        (3,  [3,1],              {"key1": 99, "key2": 98},     NAMED_STRUCT("a", 8, "b", "eight"),   9),
+        (3,  [10],               {"A": 5, "B": 10},            NAMED_STRUCT("a", 9, "b", "nine"),    6),
+        (3,  [11,22,33,44],      {"A": 10, "B": 1},            NAMED_STRUCT("a", 10,"b", "tt"),    1),
+        (3,  null,               null,                         null,                                17),
+        (3,  null,               null,                         null,                                -1),
+        (4,  [3,1],              {"key1": 99, "key2": 98},     NAMED_STRUCT("a", 8, "b", "eight"),   9),
+        (4,  [10],               {"A": 5, "B": 10},            NAMED_STRUCT("a", 9, "b", "nine"),    6),
+        (4,  [],                 {"x": 50,  "y": 60},          NAMED_STRUCT("a", 4, "b", "delta"),   8),
+        (5, [1,2,3,4],           {"A": null, "B": 5},          NAMED_STRUCT("a", null,"b", "ten"),   2),
+        (5, [1,2,null,4],        {"A": 100, "B": null},        NAMED_STRUCT("a", 10,"b", null),      3),
+        (5, [1,null,null,4],     {"A": null, "B": null},       NAMED_STRUCT("a", null,"b", null),    4),
+        (5, [1,null,3,4],        {"A": null, "B": null},       NAMED_STRUCT("a", null,"b", null),    5),
+        (5, [11,null,null,55],   {"A": 10, "B": 5},            NAMED_STRUCT("a", 10,"b", "ten"),     null);
+    """
+
+    qt_maxmin_array_2 """SELECT max(arr), min(arr) from test_maxmin group by id order by id"""
+    qt_maxminby_array_2 """SELECT max_by(arr, weight), min_by(arr, weight) from test_maxmin"""
+    qt_maxminby_array_3 """SELECT max_by(mp, arr), min_by(mp, arr) from test_maxmin"""
+    qt_maxminby_array_4 """SELECT max_by(st, arr), min_by(st, arr) from test_maxmin"""
+
+    qt_maxminby_array_5 """SELECT id, max_by(arr, weight), min_by(arr, weight) from test_maxmin group by id order by id"""
+
+    qt_maxminby_map_2 """SELECT max_by(mp, weight), min_by(mp, weight) from test_maxmin"""
+    qt_maxminby_map_3 """SELECT id, max_by(mp, weight), min_by(mp, weight) from test_maxmin group by id order by id"""
+    qt_maxminby_map_4 """SELECT id, max_by(mp, arr), min_by(mp, arr) from test_maxmin group by id order by id"""
+
+    qt_maxminby_struct_2 """SELECT max_by(st, weight), min_by(st, weight) from test_maxmin"""
+    qt_maxminby_struct_3 """SELECT id, max_by(st, weight), min_by(st, weight) from test_maxmin group by id order by id"""
+    qt_maxminby_struct_4 """SELECT id, max_by(st, arr), min_by(st, arr) from test_maxmin group by id order by id"""
+
+    sql "DROP TABLE IF EXISTS test_nested_maxmin";
+    sql """
+        CREATE TABLE test_nested_maxmin (
+            id INT,
+            arr ARRAY<ARRAY<int>>,
+            weight INT
+        ) engine=olap
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        properties("replication_num" = "1","store_row_column" = "true");
+    """
+
+    sql """
+        INSERT INTO test_nested_maxmin (id, arr, weight) VALUES
+        (1, [[1, 2], [3, 4]], 1),
+        (2, [[1, 2], [5, 6]], 2),
+        (3, [[3, 4], [3, 4]], 3);
+    """
+
+    qt_maxmin_array_3 """SELECT max(arr), min(arr) from test_nested_maxmin"""
+    qt_maxminby_array_6 """SELECT max_by(weight, arr), min_by(weight, arr) from test_nested_maxmin"""
+    qt_maxminby_array_7 """SELECT max_by(arr, weight), min_by(arr, weight) from test_nested_maxmin"""
 }