From d70776af55cf873fffe0a98b126fc4f18f395d81 Mon Sep 17 00:00:00 2001
From: vhwzIs <33090503+vhwzIs@users.noreply.github.com>
Date: Sun, 18 Feb 2024 11:14:33 +0800
Subject: [PATCH] [feature](agg-func) support covar and covar_samp function
 (#30983)

---
 .../aggregate_function_covar.cpp              |  89 +++++
 .../aggregate_function_covar.h                | 331 ++++++++++++++++++
 .../aggregate_function_simple_factory.cpp     |   4 +
 .../aggregate-functions/covar-samp.md         |  48 +++
 .../aggregate-functions/covar.md              |  48 +++
 .../aggregate-functions/covar-samp.md         |  49 +++
 .../aggregate-functions/covar.md              |  49 +++
 .../catalog/BuiltinAggregateFunctions.java    |   4 +
 .../org/apache/doris/catalog/FunctionSet.java |  77 ++++
 .../expressions/functions/agg/Covar.java      |  85 +++++
 .../expressions/functions/agg/CovarSamp.java  |  85 +++++
 .../visitor/AggregateFunctionVisitor.java     |  10 +
 .../agg_function/test_covar.out               |  12 +
 .../agg_function/test_covar_samp.out          |  15 +
 .../agg_function/test_covar.groovy            |  82 +++++
 .../agg_function/test_covar_samp.groovy       |  90 +++++
 16 files changed, 1078 insertions(+)
 create mode 100644 be/src/vec/aggregate_functions/aggregate_function_covar.cpp
 create mode 100644 be/src/vec/aggregate_functions/aggregate_function_covar.h
 create mode 100644 docs/en/docs/sql-manual/sql-functions/aggregate-functions/covar-samp.md
 create mode 100644 docs/en/docs/sql-manual/sql-functions/aggregate-functions/covar.md
 create mode 100644 docs/zh-CN/docs/sql-manual/sql-functions/aggregate-functions/covar-samp.md
 create mode 100644 docs/zh-CN/docs/sql-manual/sql-functions/aggregate-functions/covar.md
 create mode 100644 fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Covar.java
 create mode 100644 fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/CovarSamp.java
 create mode 100644 regression-test/data/nereids_function_p0/agg_function/test_covar.out
 create mode 100644 regression-test/data/nereids_function_p0/agg_function/test_covar_samp.out
 create mode 100644 regression-test/suites/nereids_function_p0/agg_function/test_covar.groovy
 create mode 100644 regression-test/suites/nereids_function_p0/agg_function/test_covar_samp.groovy

diff --git a/be/src/vec/aggregate_functions/aggregate_function_covar.cpp b/be/src/vec/aggregate_functions/aggregate_function_covar.cpp
new file mode 100644
index 0000000000..aa5bd511d9
--- /dev/null
+++ b/be/src/vec/aggregate_functions/aggregate_function_covar.cpp
@@ -0,0 +1,89 @@
+// 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 "vec/aggregate_functions/aggregate_function_covar.h"
+
+#include <fmt/format.h>
+
+#include <string>
+
+#include "common/logging.h"
+#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
+#include "vec/aggregate_functions/helpers.h"
+#include "vec/data_types/data_type.h"
+#include "vec/data_types/data_type_nullable.h"
+
+namespace doris::vectorized {
+
+template <template <typename, bool> class AggregateFunctionTemplate,
+          template <typename> class NameData, template <typename, typename> class Data,
+          bool is_nullable = false>
+AggregateFunctionPtr create_function_single_value(const String& name,
+                                                  const DataTypes& argument_types,
+                                                  const bool result_is_nullable,
+                                                  bool custom_nullable) {
+    WhichDataType which(remove_nullable(argument_types[0]));
+#define DISPATCH(TYPE)                                                                         \
+    if (which.idx == TypeIndex::TYPE)                                                          \
+        return creator_without_type::create<                                                   \
+                AggregateFunctionTemplate<NameData<Data<TYPE, BaseData<TYPE>>>, is_nullable>>( \
+                custom_nullable ? remove_nullable(argument_types) : argument_types,            \
+                result_is_nullable);
+    FOR_NUMERIC_TYPES(DISPATCH)
+#undef DISPATCH
+
+#define DISPATCH(TYPE)                                                              \
+    if (which.idx == TypeIndex::TYPE)                                               \
+        return creator_without_type::create<AggregateFunctionTemplate<              \
+                NameData<Data<TYPE, BaseDatadecimal<TYPE>>>, is_nullable>>(         \
+                custom_nullable ? remove_nullable(argument_types) : argument_types, \
+                result_is_nullable);
+    FOR_DECIMAL_TYPES(DISPATCH)
+#undef DISPATCH
+
+    LOG(WARNING) << fmt::format("create_function_single_value with unknowed type {}",
+                                argument_types[0]->get_name());
+    return nullptr;
+}
+
+template <bool is_nullable>
+AggregateFunctionPtr create_aggregate_function_covariance_samp(const std::string& name,
+                                                               const DataTypes& argument_types,
+                                                               const bool result_is_nullable) {
+    return create_function_single_value<AggregateFunctionSamp, CovarSampName, SampData,
+                                        is_nullable>(name, argument_types, result_is_nullable,
+                                                     NULLABLE);
+}
+
+AggregateFunctionPtr create_aggregate_function_covariance_pop(const std::string& name,
+                                                              const DataTypes& argument_types,
+                                                              const bool result_is_nullable) {
+    return create_function_single_value<AggregateFunctionPop, CovarName, PopData>(
+            name, argument_types, result_is_nullable, NOTNULLABLE);
+}
+
+void register_aggregate_function_covar_pop(AggregateFunctionSimpleFactory& factory) {
+    factory.register_function_both("covar", create_aggregate_function_covariance_pop);
+    factory.register_alias("covar", "covar_pop");
+}
+
+void register_aggregate_function_covar_samp(AggregateFunctionSimpleFactory& factory) {
+    factory.register_function("covar_samp", create_aggregate_function_covariance_samp<NOTNULLABLE>);
+    factory.register_function("covar_samp", create_aggregate_function_covariance_samp<NULLABLE>,
+                              NULLABLE);
+}
+} // namespace doris::vectorized
diff --git a/be/src/vec/aggregate_functions/aggregate_function_covar.h b/be/src/vec/aggregate_functions/aggregate_function_covar.h
new file mode 100644
index 0000000000..0c5dfd3f03
--- /dev/null
+++ b/be/src/vec/aggregate_functions/aggregate_function_covar.h
@@ -0,0 +1,331 @@
+// 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.
+
+#pragma once
+
+#define POP true
+#define NOTPOP false
+#define NULLABLE true
+#define NOTNULLABLE false
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <boost/iterator/iterator_facade.hpp>
+#include <cmath>
+#include <memory>
+#include <type_traits>
+
+#include "olap/olap_common.h"
+#include "runtime/decimalv2_value.h"
+#include "vec/aggregate_functions/aggregate_function.h"
+#include "vec/columns/column.h"
+#include "vec/columns/column_nullable.h"
+#include "vec/common/assert_cast.h"
+#include "vec/core/field.h"
+#include "vec/core/types.h"
+#include "vec/data_types/data_type_decimal.h"
+#include "vec/data_types/data_type_number.h"
+#include "vec/io/io_helper.h"
+
+namespace doris {
+namespace vectorized {
+class Arena;
+class BufferReadable;
+class BufferWritable;
+template <typename T>
+class ColumnDecimal;
+template <typename>
+class ColumnVector;
+} // namespace vectorized
+} // namespace doris
+
+namespace doris::vectorized {
+
+template <typename T>
+struct BaseData {
+    BaseData() : sum_x(0.0), sum_y(0.0), sum_xy(0.0), count(0) {}
+    virtual ~BaseData() = default;
+
+    void write(BufferWritable& buf) const {
+        write_binary(sum_x, buf);
+        write_binary(sum_y, buf);
+        write_binary(sum_xy, buf);
+        write_binary(count, buf);
+    }
+
+    void read(BufferReadable& buf) {
+        read_binary(sum_x, buf);
+        read_binary(sum_y, buf);
+        read_binary(sum_xy, buf);
+        read_binary(count, buf);
+    }
+
+    void reset() {
+        sum_x = 0.0;
+        sum_y = 0.0;
+        sum_xy = 0.0;
+        count = 0;
+    }
+
+    // Cov(X, Y) = E(XY) - E(X)E(Y)
+    double get_pop_result() const {
+        if (count == 1) {
+            return 0.0;
+        }
+        return sum_xy / count - sum_x * sum_y / (count * count);
+    }
+
+    double get_samp_result() const {
+        return sum_xy / (count - 1) - sum_x * sum_y / (count * (count - 1));
+    }
+
+    void merge(const BaseData& rhs) {
+        if (rhs.count == 0) {
+            return;
+        }
+        sum_x += rhs.sum_x;
+        sum_y += rhs.sum_y;
+        sum_xy += rhs.sum_xy;
+        count += rhs.count;
+    }
+
+    void add(const IColumn* column_x, const IColumn* column_y, size_t row_num) {
+        const auto& sources_x = assert_cast<const ColumnVector<T>&>(*column_x);
+        double source_data_x = sources_x.get_data()[row_num];
+        const auto& sources_y = assert_cast<const ColumnVector<T>&>(*column_y);
+        double source_data_y = sources_y.get_data()[row_num];
+
+        sum_x += source_data_x;
+        sum_y += source_data_y;
+        sum_xy += source_data_x * source_data_y;
+        count += 1;
+    }
+
+    static DataTypePtr get_return_type() { return std::make_shared<DataTypeNumber<Float64>>(); }
+
+    double sum_x;
+    double sum_y;
+    double sum_xy;
+    int64_t count;
+};
+
+template <typename T>
+struct BaseDatadecimal {
+    BaseDatadecimal() : sum_x(0), sum_y(0), sum_xy(0), count(0) {}
+    virtual ~BaseDatadecimal() = default;
+
+    void write(BufferWritable& buf) const {
+        write_binary(sum_x, buf);
+        write_binary(sum_y, buf);
+        write_binary(sum_xy, buf);
+        write_binary(count, buf);
+    }
+
+    void read(BufferReadable& buf) {
+        read_binary(sum_x, buf);
+        read_binary(sum_y, buf);
+        read_binary(sum_xy, buf);
+        read_binary(count, buf);
+    }
+
+    void reset() {
+        sum_x = DecimalV2Value();
+        sum_y = DecimalV2Value();
+        sum_xy = DecimalV2Value();
+        count = {};
+    }
+
+    DecimalV2Value get_pop_result() const {
+        if (count == 1) {
+            return DecimalV2Value();
+        }
+        DecimalV2Value count_dec = DecimalV2Value(static_cast<int128_t>(count));
+        return sum_xy / count_dec - sum_x * sum_y / (count_dec * count_dec);
+    }
+
+    DecimalV2Value get_samp_result() const {
+        DecimalV2Value count_dec = DecimalV2Value(static_cast<int128_t>(count));
+        DecimalV2Value one = DecimalV2Value(static_cast<int128_t>(1));
+        return sum_xy / (count_dec - one) - sum_x * sum_y / (count_dec * (count_dec - one));
+    }
+
+    void merge(const BaseDatadecimal& rhs) {
+        if (rhs.count == 0) {
+            return;
+        }
+        sum_x += rhs.sum_x;
+        sum_y += rhs.sum_y;
+        sum_xy += rhs.sum_xy;
+        count += rhs.count;
+    }
+
+    void add(const IColumn* column_x, const IColumn* column_y, size_t row_num) {
+        auto source_data_x = get_source_data(column_x, row_num);
+        auto source_data_y = get_source_data(column_y, row_num);
+        sum_x += source_data_x;
+        sum_y += source_data_y;
+        sum_xy += source_data_x * source_data_y;
+        count += 1;
+    }
+
+    DecimalV2Value get_source_data(const IColumn* column, size_t row_num) {
+        const auto& sources = assert_cast<const ColumnDecimal<T>&>(*column);
+        Field field = sources[row_num];
+        auto decimal_field = field.template get<DecimalField<T>>();
+        int128_t value;
+        if (decimal_field.get_scale() > DecimalV2Value::SCALE) {
+            value = static_cast<int128_t>(decimal_field.get_value()) /
+                    (decimal_field.get_scale_multiplier() / DecimalV2Value::ONE_BILLION);
+        } else {
+            value = static_cast<int128_t>(decimal_field.get_value()) *
+                    (DecimalV2Value::ONE_BILLION / decimal_field.get_scale_multiplier());
+        }
+        return DecimalV2Value(value);
+    }
+
+    static DataTypePtr get_return_type() {
+        return std::make_shared<DataTypeDecimal<Decimal128V2>>(27, 9);
+    }
+
+    DecimalV2Value sum_x;
+    DecimalV2Value sum_y;
+    DecimalV2Value sum_xy;
+    int64_t count;
+};
+
+template <typename T, typename Data>
+struct PopData : Data {
+    using ColVecResult = std::conditional_t<IsDecimalNumber<T>, ColumnDecimal<Decimal128V2>,
+                                            ColumnVector<Float64>>;
+    void insert_result_into(IColumn& to) const {
+        auto& col = assert_cast<ColVecResult&>(to);
+        if constexpr (IsDecimalNumber<T>) {
+            col.get_data().push_back(this->get_pop_result().value());
+        } else {
+            col.get_data().push_back(this->get_pop_result());
+        }
+    }
+};
+
+template <typename T, typename Data>
+struct SampData : Data {
+    using ColVecResult = std::conditional_t<IsDecimalNumber<T>, ColumnDecimal<Decimal128V2>,
+                                            ColumnVector<Float64>>;
+    void insert_result_into(IColumn& to) const {
+        ColumnNullable& nullable_column = assert_cast<ColumnNullable&>(to);
+        if (this->count == 1 || this->count == 0) {
+            nullable_column.insert_default();
+        } else {
+            auto& col = assert_cast<ColVecResult&>(nullable_column.get_nested_column());
+            if constexpr (IsDecimalNumber<T>) {
+                col.get_data().push_back(this->get_samp_result().value());
+            } else {
+                col.get_data().push_back(this->get_samp_result());
+            }
+            nullable_column.get_null_map_data().push_back(0);
+        }
+    }
+};
+
+template <typename Data>
+struct CovarName : Data {
+    static const char* name() { return "covar"; }
+};
+
+template <typename Data>
+struct CovarSampName : Data {
+    static const char* name() { return "covar_samp"; }
+};
+
+template <bool is_pop, typename Data, bool is_nullable>
+class AggregateFunctionSampCovariance
+        : public IAggregateFunctionDataHelper<
+                  Data, AggregateFunctionSampCovariance<is_pop, Data, is_nullable>> {
+public:
+    AggregateFunctionSampCovariance(const DataTypes& argument_types_)
+            : IAggregateFunctionDataHelper<
+                      Data, AggregateFunctionSampCovariance<is_pop, Data, is_nullable>>(
+                      argument_types_) {}
+
+    String get_name() const override { return Data::name(); }
+
+    DataTypePtr get_return_type() const override {
+        if constexpr (is_pop) {
+            return Data::get_return_type();
+        } else {
+            return make_nullable(Data::get_return_type());
+        }
+    }
+
+    void add(AggregateDataPtr __restrict place, const IColumn** columns, size_t row_num,
+             Arena*) const override {
+        if constexpr (is_pop) {
+            this->data(place).add(columns[0], columns[1], row_num);
+        } else {
+            if constexpr (is_nullable) {
+                const auto* nullable_column_x = check_and_get_column<ColumnNullable>(columns[0]);
+                const auto* nullable_column_y = check_and_get_column<ColumnNullable>(columns[1]);
+                if (!nullable_column_x->is_null_at(row_num) &&
+                    !nullable_column_y->is_null_at(row_num)) {
+                    this->data(place).add(&nullable_column_x->get_nested_column(),
+                                          &nullable_column_y->get_nested_column(), row_num);
+                }
+            } else {
+                this->data(place).add(columns[0], columns[1], row_num);
+            }
+        }
+    }
+
+    void reset(AggregateDataPtr __restrict place) const override { this->data(place).reset(); }
+
+    void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
+               Arena*) const override {
+        this->data(place).merge(this->data(rhs));
+    }
+
+    void serialize(ConstAggregateDataPtr __restrict place, BufferWritable& buf) const override {
+        this->data(place).write(buf);
+    }
+
+    void deserialize(AggregateDataPtr __restrict place, BufferReadable& buf,
+                     Arena*) const override {
+        this->data(place).read(buf);
+    }
+
+    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
+        this->data(place).insert_result_into(to);
+    }
+};
+
+template <typename Data, bool is_nullable>
+class AggregateFunctionSamp final
+        : public AggregateFunctionSampCovariance<NOTPOP, Data, is_nullable> {
+public:
+    AggregateFunctionSamp(const DataTypes& argument_types_)
+            : AggregateFunctionSampCovariance<NOTPOP, Data, is_nullable>(argument_types_) {}
+};
+
+template <typename Data, bool is_nullable>
+class AggregateFunctionPop final : public AggregateFunctionSampCovariance<POP, Data, is_nullable> {
+public:
+    AggregateFunctionPop(const DataTypes& argument_types_)
+            : AggregateFunctionSampCovariance<POP, Data, is_nullable>(argument_types_) {}
+};
+
+} // namespace doris::vectorized
\ No newline at end of file
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 9f99a64f2b..abb8449198 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
@@ -61,6 +61,8 @@ void register_aggregate_function_histogram(AggregateFunctionSimpleFactory& facto
 void register_aggregate_function_map_agg(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_bitmap_agg(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_functions_corr(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_covar_pop(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_covar_samp(AggregateFunctionSimpleFactory& factory);
 
 AggregateFunctionSimpleFactory& AggregateFunctionSimpleFactory::instance() {
     static std::once_flag oc;
@@ -103,6 +105,8 @@ AggregateFunctionSimpleFactory& AggregateFunctionSimpleFactory::instance() {
         register_aggregate_function_HLL_union_agg(instance);
 
         register_aggregate_functions_corr(instance);
+        register_aggregate_function_covar_pop(instance);
+        register_aggregate_function_covar_samp(instance);
     });
     return instance;
 }
diff --git a/docs/en/docs/sql-manual/sql-functions/aggregate-functions/covar-samp.md b/docs/en/docs/sql-manual/sql-functions/aggregate-functions/covar-samp.md
new file mode 100644
index 0000000000..0ce8558807
--- /dev/null
+++ b/docs/en/docs/sql-manual/sql-functions/aggregate-functions/covar-samp.md
@@ -0,0 +1,48 @@
+---
+{
+    "title": "COVAR_SAMP",
+    "language": "en"
+}
+---
+
+<!-- 
+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.
+-->
+
+## COVAR_SAMP
+### Description
+#### Syntax
+
+` double covar_samp(x, y)`
+
+Calculate the sample covariance between x and y.
+
+### example
+
+```
+mysql> select covar_samp(x,y) from baseall;
++---------------------+
+| covar_samp(x, y)    |
++---------------------+
+| 0.89442719099991586 |
++---------------------+
+1 row in set (0.21 sec)
+
+```
+### keywords
+COVAR_SAMP
diff --git a/docs/en/docs/sql-manual/sql-functions/aggregate-functions/covar.md b/docs/en/docs/sql-manual/sql-functions/aggregate-functions/covar.md
new file mode 100644
index 0000000000..dfc5ca4f0f
--- /dev/null
+++ b/docs/en/docs/sql-manual/sql-functions/aggregate-functions/covar.md
@@ -0,0 +1,48 @@
+---
+{
+    "title": "COVAR,COVAR_POP",
+    "language": "en"
+}
+---
+
+<!-- 
+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.
+-->
+
+## COVAR,COVAR_POP
+### Description
+#### Syntax
+
+` double covar(x, y)`
+
+Calculate the covariance between x and y.
+
+### example
+
+```
+mysql> select covar(x,y) from baseall;
++---------------------+
+| covar(x, y)         |
++---------------------+
+| 0.89442719099991586 |
++---------------------+
+1 row in set (0.21 sec)
+
+```
+### keywords
+COVAR, COVAR_POP
diff --git a/docs/zh-CN/docs/sql-manual/sql-functions/aggregate-functions/covar-samp.md b/docs/zh-CN/docs/sql-manual/sql-functions/aggregate-functions/covar-samp.md
new file mode 100644
index 0000000000..c3e41b0b5b
--- /dev/null
+++ b/docs/zh-CN/docs/sql-manual/sql-functions/aggregate-functions/covar-samp.md
@@ -0,0 +1,49 @@
+---
+{
+    "title": "COVAR_SAMP",
+    "language": "zh-CN"
+}
+---
+
+<!-- 
+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.
+-->
+
+## COVAR_SAMP
+### Description
+#### Syntax
+
+` double covar_samp(x, y)`
+
+计算x和y的样本协方差。
+
+
+### example
+
+```
+mysql> select covar_samp(x,y) from baseall;
++---------------------+
+| covar_samp(x, y)    |
++---------------------+
+| 0.89442719099991586 |
++---------------------+
+1 row in set (0.21 sec)
+
+```
+### keywords
+COVAR_SAMP
diff --git a/docs/zh-CN/docs/sql-manual/sql-functions/aggregate-functions/covar.md b/docs/zh-CN/docs/sql-manual/sql-functions/aggregate-functions/covar.md
new file mode 100644
index 0000000000..d932f3fabf
--- /dev/null
+++ b/docs/zh-CN/docs/sql-manual/sql-functions/aggregate-functions/covar.md
@@ -0,0 +1,49 @@
+---
+{
+    "title": "COVAR",
+    "language": "zh-CN"
+}
+---
+
+<!-- 
+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.
+-->
+
+## COVAR
+### Description
+#### Syntax
+
+` double covar(x, y)`
+
+计算协方差, 即返回结果为: x和y的协方差。
+
+
+### example
+
+```
+mysql> select covar(x,y) from baseall;
++---------------------+
+| covar(x, y)          |
++---------------------+
+| 0.89442719099991586 |
++---------------------+
+1 row in set (0.21 sec)
+
+```
+### keywords
+COVAR
diff --git a/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinAggregateFunctions.java b/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinAggregateFunctions.java
index a8fc246d23..e6134cfc31 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinAggregateFunctions.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinAggregateFunctions.java
@@ -31,6 +31,8 @@ import org.apache.doris.nereids.trees.expressions.functions.agg.CollectSet;
 import org.apache.doris.nereids.trees.expressions.functions.agg.Corr;
 import org.apache.doris.nereids.trees.expressions.functions.agg.Count;
 import org.apache.doris.nereids.trees.expressions.functions.agg.CountByEnum;
+import org.apache.doris.nereids.trees.expressions.functions.agg.Covar;
+import org.apache.doris.nereids.trees.expressions.functions.agg.CovarSamp;
 import org.apache.doris.nereids.trees.expressions.functions.agg.GroupBitAnd;
 import org.apache.doris.nereids.trees.expressions.functions.agg.GroupBitOr;
 import org.apache.doris.nereids.trees.expressions.functions.agg.GroupBitXor;
@@ -97,6 +99,8 @@ public class BuiltinAggregateFunctions implements FunctionHelper {
             agg(Corr.class, "corr"),
             agg(Count.class, "count"),
             agg(CountByEnum.class, "count_by_enum"),
+            agg(Covar.class, "covar", "covar_pop"),
+            agg(CovarSamp.class, "covar_samp"),
             agg(GroupBitAnd.class, "group_bit_and"),
             agg(GroupBitOr.class, "group_bit_or"),
             agg(GroupBitXor.class, "group_bit_xor"),
diff --git a/fe/fe-core/src/main/java/org/apache/doris/catalog/FunctionSet.java b/fe/fe-core/src/main/java/org/apache/doris/catalog/FunctionSet.java
index e2dd59d680..c95f04a5f7 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/catalog/FunctionSet.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/catalog/FunctionSet.java
@@ -1759,6 +1759,83 @@ public class FunctionSet<T> {
                 Lists.<Type>newArrayList(Type.DOUBLE, Type.DOUBLE), Type.DOUBLE, Type.DOUBLE,
                 "", "", "", "", "", "", "",
                 false, false, false, true));
+
+        // covar
+        addBuiltin(AggregateFunction.createBuiltin("covar",
+                Lists.<Type>newArrayList(Type.TINYINT, Type.TINYINT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar",
+                Lists.<Type>newArrayList(Type.SMALLINT, Type.SMALLINT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar",
+                Lists.<Type>newArrayList(Type.INT, Type.INT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar",
+                Lists.<Type>newArrayList(Type.BIGINT, Type.BIGINT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar",
+                Lists.<Type>newArrayList(Type.FLOAT, Type.FLOAT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar",
+                Lists.<Type>newArrayList(Type.DOUBLE, Type.DOUBLE), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+
+        addBuiltin(AggregateFunction.createBuiltin("covar_pop",
+                Lists.<Type>newArrayList(Type.TINYINT, Type.TINYINT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_pop",
+                Lists.<Type>newArrayList(Type.SMALLINT, Type.SMALLINT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_pop",
+                Lists.<Type>newArrayList(Type.INT, Type.INT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_pop",
+                Lists.<Type>newArrayList(Type.BIGINT, Type.BIGINT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_pop",
+                Lists.<Type>newArrayList(Type.FLOAT, Type.FLOAT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_pop",
+                Lists.<Type>newArrayList(Type.DOUBLE, Type.DOUBLE), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+
+        // covar_samp
+        addBuiltin(AggregateFunction.createBuiltin("covar_samp",
+                Lists.<Type>newArrayList(Type.TINYINT, Type.TINYINT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_samp",
+                Lists.<Type>newArrayList(Type.SMALLINT, Type.SMALLINT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_samp",
+                Lists.<Type>newArrayList(Type.INT, Type.INT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_samp",
+                Lists.<Type>newArrayList(Type.BIGINT, Type.BIGINT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_samp",
+                Lists.<Type>newArrayList(Type.FLOAT, Type.FLOAT), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
+        addBuiltin(AggregateFunction.createBuiltin("covar_samp",
+                Lists.<Type>newArrayList(Type.DOUBLE, Type.DOUBLE), Type.DOUBLE, Type.DOUBLE,
+                "", "", "", "", "", "", "",
+                false, false, false, true));
     }
 
     public Map<String, List<Function>> getVectorizedFunctions() {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Covar.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Covar.java
new file mode 100644
index 0000000000..12096f547c
--- /dev/null
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/Covar.java
@@ -0,0 +1,85 @@
+// 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.
+
+package org.apache.doris.nereids.trees.expressions.functions.agg;
+
+import org.apache.doris.catalog.FunctionSignature;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.functions.AlwaysNullable;
+import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
+import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression;
+import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
+import org.apache.doris.nereids.types.BigIntType;
+import org.apache.doris.nereids.types.DoubleType;
+import org.apache.doris.nereids.types.FloatType;
+import org.apache.doris.nereids.types.IntegerType;
+import org.apache.doris.nereids.types.SmallIntType;
+import org.apache.doris.nereids.types.TinyIntType;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
+
+/**
+ * AggregateFunction 'covar'. This class is generated by GenerateFunction.
+ */
+public class Covar extends AggregateFunction
+        implements UnaryExpression, ExplicitlyCastableSignature, AlwaysNullable {
+
+    public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
+            FunctionSignature.ret(DoubleType.INSTANCE).args(TinyIntType.INSTANCE, TinyIntType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(SmallIntType.INSTANCE, SmallIntType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(IntegerType.INSTANCE, IntegerType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(BigIntType.INSTANCE, BigIntType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(FloatType.INSTANCE, FloatType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE, DoubleType.INSTANCE)
+    );
+
+    /**
+     * constructor with 2 argument.
+     */
+    public Covar(Expression arg1, Expression arg2) {
+        super("covar", arg1, arg2);
+    }
+
+    /**
+     * constructor with 3 arguments.
+     */
+    public Covar(boolean distinct, Expression arg1, Expression arg2) {
+        super("covar", distinct, arg1, arg2);
+    }
+
+    /**
+     * withDistinctAndChildren.
+     */
+    @Override
+    public Covar withDistinctAndChildren(boolean distinct, List<Expression> children) {
+        Preconditions.checkArgument(children.size() == 2);
+        return new Covar(distinct, children.get(0), children.get(1));
+    }
+
+    @Override
+    public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visitCovar(this, context);
+    }
+
+    @Override
+    public List<FunctionSignature> getSignatures() {
+        return SIGNATURES;
+    }
+}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/CovarSamp.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/CovarSamp.java
new file mode 100644
index 0000000000..310ce2ca21
--- /dev/null
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/CovarSamp.java
@@ -0,0 +1,85 @@
+// 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.
+
+package org.apache.doris.nereids.trees.expressions.functions.agg;
+
+import org.apache.doris.catalog.FunctionSignature;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.functions.AlwaysNullable;
+import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
+import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression;
+import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
+import org.apache.doris.nereids.types.BigIntType;
+import org.apache.doris.nereids.types.DoubleType;
+import org.apache.doris.nereids.types.FloatType;
+import org.apache.doris.nereids.types.IntegerType;
+import org.apache.doris.nereids.types.SmallIntType;
+import org.apache.doris.nereids.types.TinyIntType;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
+
+/**
+ * AggregateFunction 'covar_samp'. This class is generated by GenerateFunction.
+ */
+public class CovarSamp extends AggregateFunction
+        implements UnaryExpression, ExplicitlyCastableSignature, AlwaysNullable {
+
+    public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
+            FunctionSignature.ret(DoubleType.INSTANCE).args(TinyIntType.INSTANCE, TinyIntType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(SmallIntType.INSTANCE, SmallIntType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(IntegerType.INSTANCE, IntegerType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(BigIntType.INSTANCE, BigIntType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(FloatType.INSTANCE, FloatType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE, DoubleType.INSTANCE)
+    );
+
+    /**
+     * constructor with 2 argument.
+     */
+    public CovarSamp(Expression arg1, Expression arg2) {
+        super("covar_samp", arg1, arg2);
+    }
+
+    /**
+     * constructor with 3 arguments.
+     */
+    public CovarSamp(boolean distinct, Expression arg1, Expression arg2) {
+        super("covar_samp", distinct, arg1, arg2);
+    }
+
+    /**
+     * withDistinctAndChildren.
+     */
+    @Override
+    public CovarSamp withDistinctAndChildren(boolean distinct, List<Expression> children) {
+        Preconditions.checkArgument(children.size() == 2);
+        return new CovarSamp(distinct, children.get(0), children.get(1));
+    }
+
+    @Override
+    public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visitCovarSamp(this, context);
+    }
+
+    @Override
+    public List<FunctionSignature> getSignatures() {
+        return SIGNATURES;
+    }
+}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/AggregateFunctionVisitor.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/AggregateFunctionVisitor.java
index 73dd6a838b..4a1830341b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/AggregateFunctionVisitor.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/AggregateFunctionVisitor.java
@@ -32,6 +32,8 @@ import org.apache.doris.nereids.trees.expressions.functions.agg.CollectSet;
 import org.apache.doris.nereids.trees.expressions.functions.agg.Corr;
 import org.apache.doris.nereids.trees.expressions.functions.agg.Count;
 import org.apache.doris.nereids.trees.expressions.functions.agg.CountByEnum;
+import org.apache.doris.nereids.trees.expressions.functions.agg.Covar;
+import org.apache.doris.nereids.trees.expressions.functions.agg.CovarSamp;
 import org.apache.doris.nereids.trees.expressions.functions.agg.GroupBitAnd;
 import org.apache.doris.nereids.trees.expressions.functions.agg.GroupBitOr;
 import org.apache.doris.nereids.trees.expressions.functions.agg.GroupBitXor;
@@ -139,6 +141,14 @@ public interface AggregateFunctionVisitor<R, C> {
         return visitAggregateFunction(count, context);
     }
 
+    default R visitCovar(Covar covar, C context) {
+        return visitAggregateFunction(covar, context);
+    }
+
+    default R visitCovarSamp(CovarSamp covarSamp, C context) {
+        return visitAggregateFunction(covarSamp, context);
+    }
+
     default R visitMultiDistinctCount(MultiDistinctCount multiDistinctCount, C context) {
         return visitAggregateFunction(multiDistinctCount, context);
     }
diff --git a/regression-test/data/nereids_function_p0/agg_function/test_covar.out b/regression-test/data/nereids_function_p0/agg_function/test_covar.out
new file mode 100644
index 0000000000..770e620ef7
--- /dev/null
+++ b/regression-test/data/nereids_function_p0/agg_function/test_covar.out
@@ -0,0 +1,12 @@
+-- This file is automatically generated. You should know what you did if you want to edit this
+-- !sql --
+0.25
+
+-- !sql --
+-0.25
+
+-- !sql --
+0.0
+
+-- !sql --
+3.5
diff --git a/regression-test/data/nereids_function_p0/agg_function/test_covar_samp.out b/regression-test/data/nereids_function_p0/agg_function/test_covar_samp.out
new file mode 100644
index 0000000000..728beed6cc
--- /dev/null
+++ b/regression-test/data/nereids_function_p0/agg_function/test_covar_samp.out
@@ -0,0 +1,15 @@
+-- This file is automatically generated. You should know what you did if you want to edit this
+-- !sql --
+1
+
+-- !sql --
+-1.5
+
+-- !sql --
+0.0
+
+-- !sql --
+4.5
+
+-- !sql --
+1.666667
\ No newline at end of file
diff --git a/regression-test/suites/nereids_function_p0/agg_function/test_covar.groovy b/regression-test/suites/nereids_function_p0/agg_function/test_covar.groovy
new file mode 100644
index 0000000000..2416b88fa5
--- /dev/null
+++ b/regression-test/suites/nereids_function_p0/agg_function/test_covar.groovy
@@ -0,0 +1,82 @@
+// 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.
+
+suite("test_covar") {
+    sql """ DROP TABLE IF EXISTS test_covar """
+
+    sql """ SET enable_nereids_planner=true """
+    sql """ SET enable_fallback_to_original_planner=false """
+
+    sql """
+        CREATE TABLE test_covar (
+          `id` int,
+          `x` int,
+          `y` int,
+        ) ENGINE=OLAP
+        Duplicate KEY (`id`)
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        PROPERTIES (
+        "replication_allocation" = "tag.location.default: 1"
+        );
+        """
+    
+    // Equal to variance   
+    sql """
+        insert into test_covar values
+        (1, 1, 1),
+        (2, 1, 1),
+        (3, 2, 2),
+        (4, 2, 2)
+        """
+    qt_sql "select covar(x,y) from test_covar"
+    sql """ truncate table test_covar """
+    
+    // Equal to -variance   
+    sql """
+    insert into test_covar values
+    (1, 1, 2),
+    (2, 1, 2),
+    (3, 2, 1),
+    (4, 2, 1)
+    """
+    qt_sql "select covar(x,y) from test_covar"
+    sql """ truncate table test_covar """
+    
+    // Zero covar
+    sql """
+    insert into test_covar values
+    (1, 1, 1),
+    (2, 1, 2),
+    (3, 1, 3),
+    (4, 1, 4),
+    (5, 1, 5)
+    """
+    qt_sql "select covar(x,y) from test_covar"
+    sql """ truncate table test_covar """
+    
+    // Partial linear 
+    sql """
+    insert into test_covar values
+    (1, 1, 1),
+    (2, 2, 2),
+    (3, 3, 3),
+    (4, 4, 10)
+    """
+    qt_sql "select covar(x,y) from test_covar"
+    
+    sql """ DROP TABLE IF EXISTS test_covar """
+}
diff --git a/regression-test/suites/nereids_function_p0/agg_function/test_covar_samp.groovy b/regression-test/suites/nereids_function_p0/agg_function/test_covar_samp.groovy
new file mode 100644
index 0000000000..a75a933e74
--- /dev/null
+++ b/regression-test/suites/nereids_function_p0/agg_function/test_covar_samp.groovy
@@ -0,0 +1,90 @@
+// 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.
+
+suite("test_covar_samp") {
+    sql """ DROP TABLE IF EXISTS test_covar_samp """
+
+    sql """ SET enable_nereids_planner=true """
+    sql """ SET enable_fallback_to_original_planner=false """
+
+    sql """
+        CREATE TABLE test_covar_samp (
+          `id` int,
+          `x` int,
+          `y` int,
+        ) ENGINE=OLAP
+        Duplicate KEY (`id`)
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        PROPERTIES (
+        "replication_allocation" = "tag.location.default: 1"
+        );
+        """
+    
+    sql """
+        insert into test_covar_samp values
+        (1, 1, 1),
+        (2, 2, 1),
+        (3, 3, 1),
+        (4, 4, 3)
+        """
+    qt_sql "select covar_samp(x,y) from test_covar_samp"
+    sql """ truncate table test_covar_samp """
+    
+    sql """
+    insert into test_covar_samp values
+    (1, 1, 4),
+    (2, 2, 1),
+    (3, 3, 1),
+    (4, 4, 1)
+    """
+    qt_sql "select covar_samp(x,y) from test_covar_samp"
+    sql """ truncate table test_covar_samp """
+    
+    // Zero covar
+    sql """
+    insert into test_covar_samp values
+    (1, 1, 1),
+    (2, 1, 2),
+    (3, 1, 3),
+    (4, 1, 4),
+    (5, 1, 5)
+    """
+    qt_sql "select covar_samp(x,y) from test_covar_samp"
+    sql """ truncate table test_covar_samp """
+    
+    // Partial linear 
+    sql """
+    insert into test_covar_samp values
+    (1, 1, 1),
+    (2, 2, 1),
+    (3, 3, 1),
+    (4, 4, 10)
+    """
+    qt_sql "select covar_samp(x,y) from test_covar_samp"
+    sql """ truncate table test_covar_samp """
+
+    sql """
+    insert into test_covar_samp values
+    (1, 1, 1),
+    (2, 2, 2),
+    (3, 3, 3),
+    (4, 4, 4)
+    """
+    qt_sql "select covar_samp(x,y) from test_covar_samp"
+    
+    sql """ DROP TABLE IF EXISTS test_covar_samp """
+}