From c6b1da40ba563d49c3ff9bc1f27cbeaaf952c397 Mon Sep 17 00:00:00 2001
From: wyxxxcat <1520358997@qq.com>
Date: Sat, 10 Aug 2024 13:41:06 +0800
Subject: [PATCH 1/2] draft

---
 .../aggregate_function_regr_sxx.cpp           |  74 +++++
 .../aggregate_function_regr_sxx_.h            | 270 ++++++++++++++++++
 .../aggregate_function_simple_factory.cpp     |   2 +
 .../doris/catalog/AggregateFunction.java      |   1 +
 .../catalog/BuiltinAggregateFunctions.java    |   8 +-
 .../org/apache/doris/catalog/FunctionSet.java |  33 +++
 .../expressions/functions/agg/RegrSxx.java    | 103 +++++++
 .../expressions/functions/agg/RegrSxy.java    | 103 +++++++
 .../expressions/functions/agg/RegrSyy.java    | 103 +++++++
 .../visitor/AggregateFunctionVisitor.java     |  15 +
 .../agg_function/test_regr_sxx.out            |  22 ++
 .../agg_function/test_regr_sxy.out            |  25 ++
 .../agg_function/test_regr_syy.out            |  22 ++
 .../agg_function/test_regr_sxx.groovy         | 139 +++++++++
 .../agg_function/test_regr_sxy.groovy         | 132 +++++++++
 .../agg_function/test_regr_syy.groovy         | 128 +++++++++
 16 files changed, 1179 insertions(+), 1 deletion(-)
 create mode 100644 be/src/vec/aggregate_functions/aggregate_function_regr_sxx.cpp
 create mode 100644 be/src/vec/aggregate_functions/aggregate_function_regr_sxx_.h
 create mode 100644 fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxx.java
 create mode 100644 fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxy.java
 create mode 100644 fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSyy.java
 create mode 100644 regression-test/data/nereids_function_p0/agg_function/test_regr_sxx.out
 create mode 100644 regression-test/data/nereids_function_p0/agg_function/test_regr_sxy.out
 create mode 100644 regression-test/data/nereids_function_p0/agg_function/test_regr_syy.out
 create mode 100644 regression-test/suites/nereids_function_p0/agg_function/test_regr_sxx.groovy
 create mode 100644 regression-test/suites/nereids_function_p0/agg_function/test_regr_sxy.groovy
 create mode 100644 regression-test/suites/nereids_function_p0/agg_function/test_regr_syy.groovy

diff --git a/be/src/vec/aggregate_functions/aggregate_function_regr_sxx.cpp b/be/src/vec/aggregate_functions/aggregate_function_regr_sxx.cpp
new file mode 100644
index 00000000000000..8d9abd2721e0ca
--- /dev/null
+++ b/be/src/vec/aggregate_functions/aggregate_function_regr_sxx.cpp
@@ -0,0 +1,74 @@
+// 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 <fmt/format.h>
+
+#include <string>
+
+#include "common/logging.h"
+#include "vec/aggregate_functions/aggregate_function_regr_sxx_.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> class NameData, template <typename, typename> class Data,
+          template <typename> class AggregateFunctionRegrData>
+AggregateFunctionPtr create_function_regr(const String& name, const DataTypes& argument_types,
+                                          const bool result_is_nullable) {
+    WhichDataType which(remove_nullable(argument_types[0]));
+#define DISPATCH(TYPE)                                                                        \
+    if (which.idx == TypeIndex::TYPE)                                                         \
+        return creator_without_type::create<AggregateFunctionRegrFunc<                        \
+                TYPE, NameData<Data<TYPE, AggregateFunctionRegrData<TYPE>>>>>(argument_types, \
+                                                                              result_is_nullable);
+    FOR_NUMERIC_TYPES(DISPATCH)
+#undef DISPATCH
+
+    LOG(WARNING) << fmt::format("function {} with unknowed type {}", name,
+                                argument_types[0]->get_name());
+    return nullptr;
+}
+
+AggregateFunctionPtr create_aggregate_function_regr_sxx(const std::string& name,
+                                                        const DataTypes& argument_types,
+                                                        const bool result_is_nullable) {
+    return create_function_regr<RegrSxxName, RegrSxxData, AggregateFunctionRegrSxxData>(
+            name, argument_types, result_is_nullable);
+}
+
+AggregateFunctionPtr create_aggregate_function_regr_sxy(const std::string& name,
+                                                        const DataTypes& argument_types,
+                                                        const bool result_is_nullable) {
+    return create_function_regr<RegrSxyName, RegrSxyData, AggregateFunctionRegrSxyData>(
+            name, argument_types, result_is_nullable);
+}
+
+AggregateFunctionPtr create_aggregate_function_regr_syy(const std::string& name,
+                                                        const DataTypes& argument_types,
+                                                        const bool result_is_nullable) {
+    return create_function_regr<RegrSyyName, RegrSyyData, AggregateFunctionRegrSyyData>(
+            name, argument_types, result_is_nullable);
+}
+
+void register_aggregate_function_regr_mixed(AggregateFunctionSimpleFactory& factory) {
+    factory.register_function_both("regr_sxx", create_aggregate_function_regr_sxx);
+    factory.register_function_both("regr_sxy", create_aggregate_function_regr_sxy);
+    factory.register_function_both("regr_syy", create_aggregate_function_regr_syy);
+}
+} // namespace doris::vectorized
diff --git a/be/src/vec/aggregate_functions/aggregate_function_regr_sxx_.h b/be/src/vec/aggregate_functions/aggregate_function_regr_sxx_.h
new file mode 100644
index 00000000000000..9006c317372ad8
--- /dev/null
+++ b/be/src/vec/aggregate_functions/aggregate_function_regr_sxx_.h
@@ -0,0 +1,270 @@
+// 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
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <cmath>
+#include <cstddef>
+#include <memory>
+
+#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 AggregateFunctionRegrSxxData {
+    UInt64 count = 0;
+    double square_of_sum_x {};
+    double sum_x {};
+    void write(BufferWritable& buf) const {
+        write_binary(square_of_sum_x, buf);
+        write_binary(sum_x, buf);
+        write_binary(count, buf);
+    }
+
+    void read(BufferReadable& buf) {
+        read_binary(square_of_sum_x, buf);
+        read_binary(sum_x, buf);
+        read_binary(count, buf);
+    }
+
+    void reset() {
+        square_of_sum_x = {};
+        sum_x = {};
+        count = 0;
+    }
+
+    double get_regr_sxx_result() const { return square_of_sum_x - (sum_x * sum_x) / count; }
+
+    void merge(const AggregateFunctionRegrSxxData& rhs) {
+        if (rhs.count == 0) {
+            return;
+        }
+        square_of_sum_x += rhs.square_of_sum_x;
+        sum_x += rhs.sum_x;
+        count += rhs.count;
+    }
+
+    void add(const IColumn* column_y, const IColumn* column_x, size_t row_num) {
+#ifdef __clang__
+#pragma clang fp reassociate(on)
+#endif
+        const auto& sources_x = assert_cast<const ColumnVector<T>&>(*column_x);
+        const auto& value = sources_x.get_data()[row_num];
+        sum_x += value;
+        square_of_sum_x += value * value;
+        count += 1;
+    }
+};
+template <typename T>
+struct AggregateFunctionRegrSxyData {
+    using ResultType = T;
+    UInt64 count = 0;
+    double sum_x {};
+    double sum_y {};
+    double sum_of_x_mul_y {};
+    void write(BufferWritable& buf) const {
+        write_binary(sum_x, buf);
+        write_binary(sum_y, buf);
+        write_binary(sum_of_x_mul_y, buf);
+        write_binary(count, buf);
+    }
+
+    void read(BufferReadable& buf) {
+        read_binary(sum_x, buf);
+        read_binary(sum_y, buf);
+        read_binary(sum_of_x_mul_y, buf);
+        read_binary(count, buf);
+    }
+
+    void reset() {
+        count = 0;
+        sum_x = {};
+        sum_y = {};
+        sum_of_x_mul_y = {};
+    }
+
+    double get_regr_sxy_result() const { return sum_of_x_mul_y - (sum_x * sum_y) / count; }
+
+    void merge(const AggregateFunctionRegrSxyData& rhs) {
+        if (rhs.count == 0) {
+            return;
+        }
+        sum_x += rhs.sum_x;
+        sum_y += rhs.sum_y;
+        sum_of_x_mul_y += rhs.sum_of_x_mul_y;
+        count += rhs.count;
+    }
+
+    void add(const IColumn* column_y, const IColumn* column_x, size_t row_num) {
+#ifdef __clang__
+#pragma clang fp reassociate(on)
+#endif
+        const auto& sources_x = assert_cast<const ColumnVector<T>&>(*column_x);
+        const auto& sources_y = assert_cast<const ColumnVector<T>&>(*column_y);
+        const auto& value_x = sources_x.get_data()[row_num];
+        const auto& value_y = sources_y.get_data()[row_num];
+        sum_x += value_x;
+        sum_y += value_y;
+        sum_of_x_mul_y += value_x * value_y;
+        count += 1;
+    }
+};
+template <typename T>
+struct AggregateFunctionRegrSyyData {
+    using ResultType = T;
+    UInt64 count = 0;
+    double square_of_sum_y {};
+    double sum_y {};
+    void write(BufferWritable& buf) const {
+        write_binary(square_of_sum_y, buf);
+        write_binary(sum_y, buf);
+        write_binary(count, buf);
+    }
+
+    void read(BufferReadable& buf) {
+        read_binary(square_of_sum_y, buf);
+        read_binary(sum_y, buf);
+        read_binary(count, buf);
+    }
+
+    void reset() {
+        square_of_sum_y = {};
+        sum_y = {};
+        count = 0;
+    }
+    double get_regr_syy_result() const { return square_of_sum_y - (sum_y * sum_y) / count; }
+    void merge(const AggregateFunctionRegrSyyData& rhs) {
+        if (rhs.count == 0) {
+            return;
+        }
+        square_of_sum_y += rhs.square_of_sum_y;
+        sum_y += rhs.sum_y;
+        count += rhs.count;
+    }
+
+    void add(const IColumn* column_y, const IColumn* column_x, size_t row_num) {
+#ifdef __clang__
+#pragma clang fp reassociate(on)
+#endif
+        const auto& sources_y = assert_cast<const ColumnVector<T>&>(*column_y);
+        const auto& value = sources_y.get_data()[row_num];
+        square_of_sum_y += value * value;
+        sum_y += value;
+        count += 1;
+    }
+};
+
+template <typename T, typename Data>
+struct RegrSxxData : AggregateFunctionRegrSxxData<T> {
+    void insert_result_into(IColumn& to) const {
+        auto& col = assert_cast<ColumnFloat64&>(to);
+        col.get_data().push_back(this->get_regr_sxx_result());
+    }
+};
+
+template <typename T, typename Data>
+struct RegrSxyData : AggregateFunctionRegrSxyData<T> {
+    void insert_result_into(IColumn& to) const {
+        auto& col = assert_cast<ColumnFloat64&>(to);
+        col.get_data().push_back(this->get_regr_sxy_result());
+    }
+};
+template <typename T, typename Data>
+struct RegrSyyData : AggregateFunctionRegrSyyData<T> {
+    void insert_result_into(IColumn& to) const {
+        auto& col = assert_cast<ColumnFloat64&>(to);
+        col.get_data().push_back(this->get_regr_syy_result());
+    }
+};
+template <typename Data>
+struct RegrSxxName : Data {
+    static const char* name() { return "regr_sxx"; }
+};
+
+template <typename Data>
+struct RegrSxyName : Data {
+    static const char* name() { return "regr_sxy"; }
+};
+
+template <typename Data>
+struct RegrSyyName : Data {
+    static const char* name() { return "regr_syy"; }
+};
+
+template <typename T, typename Data>
+class AggregateFunctionRegrFunc
+        : public IAggregateFunctionDataHelper<Data, AggregateFunctionRegrFunc<T, Data>> {
+public:
+    AggregateFunctionRegrFunc(const DataTypes& argument_types_)
+            : IAggregateFunctionDataHelper<Data, AggregateFunctionRegrFunc<T, Data>>(
+                      argument_types_) {}
+
+    String get_name() const override { return Data::name(); }
+
+    DataTypePtr get_return_type() const override {
+        return std::make_shared<DataTypeNumber<Float64>>();
+    }
+
+    void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,
+             Arena*) const override {
+        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);
+    }
+};
+} // 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 436691c6ef2aad..d531e206ab4b1e 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
@@ -57,6 +57,7 @@ void register_aggregate_function_percentile_old(AggregateFunctionSimpleFactory&
 void register_aggregate_function_window_funnel(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_window_funnel_old(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_retention(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_regr_mixed(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_percentile_approx(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_orthogonal_bitmap(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_collect_list(AggregateFunctionSimpleFactory& factory);
@@ -92,6 +93,7 @@ AggregateFunctionSimpleFactory& AggregateFunctionSimpleFactory::instance() {
         register_aggregate_function_reader_load(
                 instance); // register aggregate function for agg reader
         register_aggregate_function_window_rank(instance);
+        register_aggregate_function_regr_mixed(instance);
         register_aggregate_function_stddev_variance_pop(instance);
         register_aggregate_function_topn(instance);
         register_aggregate_function_approx_count_distinct(instance);
diff --git a/fe/fe-core/src/main/java/org/apache/doris/catalog/AggregateFunction.java b/fe/fe-core/src/main/java/org/apache/doris/catalog/AggregateFunction.java
index 2786dc6470e39d..185280d18c791d 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/catalog/AggregateFunction.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/catalog/AggregateFunction.java
@@ -55,6 +55,7 @@ public class AggregateFunction extends Function {
             "approx_count_distinct", "ndv", FunctionSet.BITMAP_UNION_INT, FunctionSet.BITMAP_UNION_COUNT,
             "ndv_no_finalize", "percentile_array", "histogram",
             FunctionSet.SEQUENCE_COUNT, FunctionSet.MAP_AGG, FunctionSet.BITMAP_AGG, FunctionSet.ARRAY_AGG,
+            FunctionSet.REGR_SXX, FunctionSet.REGR_SYY, FunctionSet.REGR_SXY,
             FunctionSet.COLLECT_LIST, FunctionSet.COLLECT_SET, FunctionSet.GROUP_ARRAY_INTERSECT,
             FunctionSet.SUM0, FunctionSet.MULTI_DISTINCT_SUM0);
 
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 28b1352eaf4551..4bd727fb0139b5 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
@@ -61,6 +61,9 @@
 import org.apache.doris.nereids.trees.expressions.functions.agg.PercentileApproxWeighted;
 import org.apache.doris.nereids.trees.expressions.functions.agg.PercentileArray;
 import org.apache.doris.nereids.trees.expressions.functions.agg.QuantileUnion;
+import org.apache.doris.nereids.trees.expressions.functions.agg.RegrSxx;
+import org.apache.doris.nereids.trees.expressions.functions.agg.RegrSxy;
+import org.apache.doris.nereids.trees.expressions.functions.agg.RegrSyy;
 import org.apache.doris.nereids.trees.expressions.functions.agg.Retention;
 import org.apache.doris.nereids.trees.expressions.functions.agg.SequenceCount;
 import org.apache.doris.nereids.trees.expressions.functions.agg.SequenceMatch;
@@ -134,7 +137,10 @@ public class BuiltinAggregateFunctions implements FunctionHelper {
                     agg(PercentileArray.class, "percentile_array"),
                     agg(QuantileUnion.class, "quantile_union"),
                     agg(Retention.class, "retention"),
-            agg(SequenceCount.class, "sequence_count"),
+                    agg(RegrSxx.class, "regr_sxx"),
+                    agg(RegrSxy.class, "regr_sxy"),
+                    agg(RegrSyy.class, "regr_syy"),
+                                            agg(SequenceCount.class, "sequence_count"),
             agg(SequenceMatch.class, "sequence_match"),
             agg(Stddev.class, "stddev_pop", "stddev"),
             agg(StddevSamp.class, "stddev_samp"),
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 74b2778373eacd..2ddfe0084fe22d 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
@@ -605,6 +605,12 @@ public void addBuiltinBothScalaAndVectorized(Function fn) {
 
     public static final String RETENTION = "retention";
 
+    public static final String REGR_SXX = "regr_sxx";
+
+    public static final String REGR_SXY = "regr_sxy";
+
+    public static final String REGR_SYY = "regr_syy";
+
     public static final String SEQUENCE_MATCH = "sequence_match";
 
     public static final String SEQUENCE_COUNT = "sequence_count";
@@ -659,6 +665,33 @@ private void initAggregateBuiltins() {
                     null, false, true, true, true));
         }
 
+        addBuiltin(AggregateFunction.createBuiltin(FunctionSet.REGR_SXX,
+                        new ArrayList<Type>(), Type.DOUBLE, Type.DOUBLE,
+                        "",
+                        "",
+                        "",
+                        null, null,
+                        "",
+                        null, false, true, true, true));
+
+        addBuiltin(AggregateFunction.createBuiltin(FunctionSet.REGR_SXY,
+                        new ArrayList<Type>(), Type.DOUBLE, Type.DOUBLE,
+                        "",
+                        "",
+                        "",
+                        null, null,
+                        "",
+                        null, false, true, true, true));
+
+        addBuiltin(AggregateFunction.createBuiltin(FunctionSet.REGR_SYY,
+                        new ArrayList<Type>(), Type.DOUBLE, Type.DOUBLE,
+                        "",
+                        "",
+                        "",
+                        null, null,
+                        "",
+                        null, false, true, true, true));
+
         // Vectorization does not need symbol any more, we should clean it in the future.
         addBuiltin(AggregateFunction.createBuiltin(FunctionSet.WINDOW_FUNNEL,
                 Lists.newArrayList(Type.BIGINT, Type.STRING, Type.DATETIME, Type.BOOLEAN),
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxx.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxx.java
new file mode 100644
index 00000000000000..93d64293a57cb2
--- /dev/null
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxx.java
@@ -0,0 +1,103 @@
+// 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.exceptions.AnalysisException;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.functions.AlwaysNotNullable;
+import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
+import org.apache.doris.nereids.trees.expressions.functions.window.SupportWindowAnalytic;
+import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
+import org.apache.doris.nereids.types.BigIntType;
+import org.apache.doris.nereids.types.DataType;
+import org.apache.doris.nereids.types.DoubleType;
+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;
+
+/** regr_sxx agg function. */
+public class RegrSxx extends NullableAggregateFunction
+        implements ExplicitlyCastableSignature, SupportWindowAnalytic {
+
+    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(DoubleType.INSTANCE, DoubleType.INSTANCE));
+
+    public RegrSxx(Expression arg0, Expression arg1) {
+        this(false, false, arg0, arg1);
+    }
+
+    public RegrSxx(boolean distinct, Expression arg0, Expression arg1) {
+        this(distinct, false, arg0, arg1);
+    }
+
+    public RegrSxx(boolean distinct, boolean alwaysNullable, Expression arg0, Expression arg1) {
+        super("regr_sxx", distinct, alwaysNullable, arg0, arg1);
+    }
+
+    @Override
+    public void checkLegalityBeforeTypeCoercion() {
+        DataType regrSxxTypeFirst = child(0).getDataType();
+        DataType regrSxxTypeSecond = child(1).getDataType();
+        if ((!regrSxxTypeFirst.isNumericType() && !regrSxxTypeFirst.isNullType())
+                || regrSxxTypeFirst.isOnlyMetricType()) {
+            throw new AnalysisException("regr_sxx requires numeric for first parameter");
+        } else if ((!regrSxxTypeSecond.isNumericType() && !regrSxxTypeSecond.isNullType())
+                || regrSxxTypeSecond.isOnlyMetricType()) {
+            throw new AnalysisException("regr_sxx requires numeric for second parameter");
+
+        }
+    }
+
+    @Override
+    public void checkLegalityAfterRewrite() {
+        if (arity() != 2) {
+            throw new AnalysisException("regr_sxx must contain two arguments");
+        }
+    }
+
+    @Override
+    public RegrSxx withDistinctAndChildren(boolean distinct, List<Expression> children) {
+        Preconditions.checkArgument(children.size() == 2);
+        return new RegrSxx(distinct, alwaysNullable, children.get(0), children.get(1));
+    }
+
+    @Override
+    public NullableAggregateFunction withAlwaysNullable(boolean alwaysNullable) {
+        return new RegrSxx(distinct, alwaysNullable, children.get(0), children.get(1));
+    }
+
+    @Override
+    public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visitRegrSxx(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/RegrSxy.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxy.java
new file mode 100644
index 00000000000000..057523fa68ab74
--- /dev/null
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxy.java
@@ -0,0 +1,103 @@
+// 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.exceptions.AnalysisException;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.functions.AlwaysNotNullable;
+import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
+import org.apache.doris.nereids.trees.expressions.functions.window.SupportWindowAnalytic;
+import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
+import org.apache.doris.nereids.types.BigIntType;
+import org.apache.doris.nereids.types.DataType;
+import org.apache.doris.nereids.types.DoubleType;
+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;
+
+/** regr_sxy agg function. */
+public class RegrSxy extends NullableAggregateFunction
+        implements ExplicitlyCastableSignature, SupportWindowAnalytic {
+
+    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(DoubleType.INSTANCE, DoubleType.INSTANCE));
+
+    public RegrSxy(Expression arg0, Expression arg1) {
+        this(false, false, arg0, arg1);
+    }
+
+    public RegrSxy(boolean distinct, Expression arg0, Expression arg1) {
+        this(distinct, false, arg0, arg1);
+    }
+
+    public RegrSxy(boolean distinct, boolean alwaysNullable, Expression arg0, Expression arg1) {
+        super("regr_sxy", distinct, alwaysNullable, arg0, arg1);
+    }
+
+    @Override
+    public void checkLegalityBeforeTypeCoercion() {
+        DataType regrSxyTypeFirst = child(0).getDataType();
+        DataType regrSxyTypeSecond = child(1).getDataType();
+        if ((!regrSxyTypeFirst.isNumericType() && !regrSxyTypeFirst.isNullType())
+                || regrSxyTypeFirst.isOnlyMetricType()) {
+            throw new AnalysisException("regr_sxy requires numeric for first parameter");
+        } else if ((!regrSxyTypeSecond.isNumericType() && !regrSxyTypeSecond.isNullType())
+                || regrSxyTypeSecond.isOnlyMetricType()) {
+            throw new AnalysisException("regr_sxy requires numeric for second parameter");
+
+        }
+    }
+
+    @Override
+    public void checkLegalityAfterRewrite() {
+        if (arity() != 2) {
+            throw new AnalysisException("regr_sxy must contain two arguments");
+        }
+    }
+
+    @Override
+    public RegrSxy withDistinctAndChildren(boolean distinct, List<Expression> children) {
+        Preconditions.checkArgument(children.size() == 2);
+        return new RegrSxy(distinct, alwaysNullable, children.get(0), children.get(1));
+    }
+
+    @Override
+    public NullableAggregateFunction withAlwaysNullable(boolean alwaysNullable) {
+        return new RegrSxy(distinct, alwaysNullable, children.get(0), children.get(1));
+    }
+
+    @Override
+    public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visitRegrSxy(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/RegrSyy.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSyy.java
new file mode 100644
index 00000000000000..4f33e7917e5185
--- /dev/null
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSyy.java
@@ -0,0 +1,103 @@
+// 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.exceptions.AnalysisException;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.functions.AlwaysNotNullable;
+import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
+import org.apache.doris.nereids.trees.expressions.functions.window.SupportWindowAnalytic;
+import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
+import org.apache.doris.nereids.types.BigIntType;
+import org.apache.doris.nereids.types.DataType;
+import org.apache.doris.nereids.types.DoubleType;
+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;
+
+/** regr_syy agg function. */
+public class RegrSyy extends NullableAggregateFunction
+        implements ExplicitlyCastableSignature, SupportWindowAnalytic {
+
+    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(DoubleType.INSTANCE, DoubleType.INSTANCE));
+
+    public RegrSyy(Expression arg0, Expression arg1) {
+        this(false, false, arg0, arg1);
+    }
+
+    public RegrSyy(boolean distinct, Expression arg0, Expression arg1) {
+        this(distinct, false, arg0, arg1);
+    }
+
+    public RegrSyy(boolean distinct, boolean alwaysNullable, Expression arg0, Expression arg1) {
+        super("regr_syy", distinct, alwaysNullable, arg0, arg1);
+    }
+
+    @Override
+    public void checkLegalityBeforeTypeCoercion() {
+        DataType regrSyyTypeFirst = child(0).getDataType();
+        DataType regrSyyTypeSecond = child(1).getDataType();
+        if ((!regrSyyTypeFirst.isNumericType() && !regrSyyTypeFirst.isNullType())
+                || regrSyyTypeFirst.isOnlyMetricType()) {
+            throw new AnalysisException("regr_syy requires numeric for first parameter");
+        } else if ((!regrSyyTypeSecond.isNumericType() && !regrSyyTypeSecond.isNullType())
+                || regrSyyTypeSecond.isOnlyMetricType()) {
+            throw new AnalysisException("regr_syy requires numeric for second parameter");
+
+        }
+    }
+
+    @Override
+    public void checkLegalityAfterRewrite() {
+        if (arity() != 2) {
+            throw new AnalysisException("regr_syy must contain two arguments");
+        }
+    }
+
+    @Override
+    public RegrSyy withDistinctAndChildren(boolean distinct, List<Expression> children) {
+        Preconditions.checkArgument(children.size() == 2);
+        return new RegrSyy(distinct, alwaysNullable, children.get(0), children.get(1));
+    }
+
+    @Override
+    public NullableAggregateFunction withAlwaysNullable(boolean alwaysNullable) {
+        return new RegrSyy(distinct, alwaysNullable, children.get(0), children.get(1));
+    }
+
+    @Override
+    public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visitRegrSyy(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 abe8044c28c342..26537ae2fe2efd 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
@@ -63,6 +63,9 @@
 import org.apache.doris.nereids.trees.expressions.functions.agg.PercentileApproxWeighted;
 import org.apache.doris.nereids.trees.expressions.functions.agg.PercentileArray;
 import org.apache.doris.nereids.trees.expressions.functions.agg.QuantileUnion;
+import org.apache.doris.nereids.trees.expressions.functions.agg.RegrSxx;
+import org.apache.doris.nereids.trees.expressions.functions.agg.RegrSxy;
+import org.apache.doris.nereids.trees.expressions.functions.agg.RegrSyy;
 import org.apache.doris.nereids.trees.expressions.functions.agg.Retention;
 import org.apache.doris.nereids.trees.expressions.functions.agg.SequenceCount;
 import org.apache.doris.nereids.trees.expressions.functions.agg.SequenceMatch;
@@ -270,6 +273,18 @@ default R visitRetention(Retention retention, C context) {
         return visitNullableAggregateFunction(retention, context);
     }
 
+    default R visitRegrSxx(RegrSxx regrSxx, C context) {
+        return visitAggregateFunction(regrSxx, context);
+    }
+
+    default R visitRegrSxy(RegrSxy regrSxy, C context) {
+        return visitAggregateFunction(regrSxy, context);
+    }
+
+    default R visitRegrSyy(RegrSyy regrSyy, C context) {
+        return visitAggregateFunction(regrSyy, context);
+    }
+
     default R visitSequenceCount(SequenceCount sequenceCount, C context) {
         return visitAggregateFunction(sequenceCount, context);
     }
diff --git a/regression-test/data/nereids_function_p0/agg_function/test_regr_sxx.out b/regression-test/data/nereids_function_p0/agg_function/test_regr_sxx.out
new file mode 100644
index 00000000000000..84e30b51724cab
--- /dev/null
+++ b/regression-test/data/nereids_function_p0/agg_function/test_regr_sxx.out
@@ -0,0 +1,22 @@
+-- This file is automatically generated. You should know what you did if you want to edit this
+-- !sql --
+\N
+
+-- !sql --
+92.79999999999995
+
+-- !sql --
+\N
+
+-- !sql --
+86.93426485321584
+
+-- !sql --
+92.75
+
+-- !sql --
+92.75
+
+-- !sql --
+92.75
+
diff --git a/regression-test/data/nereids_function_p0/agg_function/test_regr_sxy.out b/regression-test/data/nereids_function_p0/agg_function/test_regr_sxy.out
new file mode 100644
index 00000000000000..5202b9e69f69c4
--- /dev/null
+++ b/regression-test/data/nereids_function_p0/agg_function/test_regr_sxy.out
@@ -0,0 +1,25 @@
+-- This file is automatically generated. You should know what you did if you want to edit this
+-- !sql --
+\N
+
+-- !sql --
+0.0
+
+-- !sql --
+\N
+
+-- !sql --
+\N
+
+-- !sql --
+60.742502897294685
+
+-- !sql --
+59.75
+
+-- !sql --
+59.75
+
+-- !sql --
+59.75
+
diff --git a/regression-test/data/nereids_function_p0/agg_function/test_regr_syy.out b/regression-test/data/nereids_function_p0/agg_function/test_regr_syy.out
new file mode 100644
index 00000000000000..ef69596e79125c
--- /dev/null
+++ b/regression-test/data/nereids_function_p0/agg_function/test_regr_syy.out
@@ -0,0 +1,22 @@
+-- This file is automatically generated. You should know what you did if you want to edit this
+-- !sql --
+\N
+
+-- !sql --
+413.20000000000005
+
+-- !sql --
+\N
+
+-- !sql --
+413.35074075257376
+
+-- !sql --
+224.75
+
+-- !sql --
+224.75
+
+-- !sql --
+224.75
+
diff --git a/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxx.groovy b/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxx.groovy
new file mode 100644
index 00000000000000..c5b1bdd7c6e020
--- /dev/null
+++ b/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxx.groovy
@@ -0,0 +1,139 @@
+// 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_regr_sxx") {
+    sql """ DROP TABLE IF EXISTS test_regr_sxx_int """
+    sql """ DROP TABLE IF EXISTS test_regr_sxx_double """
+    sql """ DROP TABLE IF EXISTS test_regr_sxx_nullalble_col """
+
+
+    sql """ SET enable_nereids_planner=true """
+    sql """ SET enable_fallback_to_original_planner=false """
+
+    sql """
+        CREATE TABLE test_regr_sxx_int (
+          `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 """
+        CREATE TABLE test_regr_sxx_double (
+          `id` int,
+          `x` double,
+          `y` double,
+        ) ENGINE=OLAP
+        Duplicate KEY (`id`)
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        PROPERTIES (
+        "replication_allocation" = "tag.location.default: 1"
+        );
+        """
+    sql """
+        CREATE TABLE test_regr_sxx_nullalble_col (
+          `id` int,
+          `x` int,
+          `y` int,
+        ) ENGINE=OLAP
+        Duplicate KEY (`id`)
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        PROPERTIES (
+        "replication_allocation" = "tag.location.default: 1"
+        );
+        """
+    // no value
+    qt_sql "select regr_sxx(y,x) from test_regr_sxx_int"
+    sql """ truncate table test_regr_sxx_int """
+    
+    sql """
+        insert into test_regr_sxx_int values
+        (1, 18, 13),
+        (2, 14, 27),
+        (3, 12, 2),
+        (4, 5, 6),
+        (5, 10, 20);
+        """
+
+    sql """
+        insert into test_regr_sxx_double values
+        (1, 18.27123456, 13.27123456),
+        (2, 14.65890846, 27.65890846),
+        (3, 12.25345846, 2.253458468),
+        (4, 5.890846835, 6.890846835),
+        (5, 10.14345678, 20.14345678);
+        """
+
+    sql """
+        insert into test_regr_sxx_nullalble_col values
+        (1, 18, 13),
+        (2, 14, 27),
+        (3, 5, 7),
+        (4, 10, 20);
+        """
+
+    // value is null
+    sql """select regr_sxx(NULL, NULL);"""
+
+    // parameter is literal and columns
+    qt_sql "select regr_sxx(10,x) from test_regr_sxx_int"
+    sql """ truncate table test_regr_sxx_int """
+
+    // int value
+    qt_sql "select regr_sxx(y,x) from test_regr_sxx_int"
+    sql """ truncate table test_regr_sxx_int """
+
+    // double value
+    qt_sql "select regr_sxx(y,x) from test_regr_sxx_double"
+    sql """ truncate table test_regr_sxx_double """
+
+    // nullable and non_nullable
+    qt_sql "select regr_sxx(y,non_nullable(x)) from test_regr_sxx_nullalble_col"
+
+    // non_nullable and nullable
+    qt_sql "select regr_sxx(non_nullable(y),x) from test_regr_sxx_nullalble_col"
+    
+    // non_nullable and non_nullable
+    qt_sql "select regr_sxx(non_nullable(y),non_nullable(x)) from test_regr_sxx_nullalble_col"
+    sql """ truncate table test_regr_sxx_nullalble_col """
+
+    // exception test
+	test{
+		sql """select regr_sxx('range', 1);"""
+		exception "regr_sxx requires numeric for first parameter"
+	}
+
+    test{
+		sql """select regr_sxx(1, 'hello');"""
+		exception "regr_sxx requires numeric for second parameter"
+	}
+    
+    test{
+		sql """select regr_sxx(y, 'hello') from test_regr_sxx_int;"""
+		exception "regr_sxx requires numeric for second parameter"
+	}
+
+    test{
+		sql """select regr_sxx(1, true);"""
+		exception "regr_sxx requires numeric for second parameter"
+	}
+
+}
diff --git a/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxy.groovy b/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxy.groovy
new file mode 100644
index 00000000000000..54b656e55e4c68
--- /dev/null
+++ b/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxy.groovy
@@ -0,0 +1,132 @@
+// 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_regr_sxy") {
+    sql """ DROP TABLE IF EXISTS test_regr_sxy_int """
+    sql """ DROP TABLE IF EXISTS test_regr_sxy_double """
+    sql """ DROP TABLE IF EXISTS test_regr_sxy_nullalble_col """
+
+
+    sql """ SET enable_nereids_planner=true """
+    sql """ SET enable_fallback_to_original_planner=false """
+
+    sql """
+        CREATE TABLE test_regr_sxy_int (
+          `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 """
+        CREATE TABLE test_regr_sxy_double (
+          `id` int,
+          `x` double,
+          `y` double,
+        ) ENGINE=OLAP
+        Duplicate KEY (`id`)
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        PROPERTIES (
+        "replication_allocation" = "tag.location.default: 1"
+        );
+        """
+    sql """
+        CREATE TABLE test_regr_sxy_nullalble_col (
+          `id` int,
+          `x` int,
+          `y` int,
+        ) ENGINE=OLAP
+        Duplicate KEY (`id`)
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        PROPERTIES (
+        "replication_allocation" = "tag.location.default: 1"
+        );
+        """
+    // no value
+    qt_sql "select regr_sxy(y,x) from test_regr_sxy_int"
+    sql """ truncate table test_regr_sxy_int """
+    
+    sql """
+        insert into test_regr_sxy_int values
+        (1, 18, 13),
+        (2, 14, 27),
+        (3, 12, 2),
+        (4, 5, 6),
+        (5, 10, 20)
+        """
+
+    sql """
+        insert into test_regr_sxy_double values
+        (1, 18.27123456, 13.27123456),
+        (2, 14.65890846, 27.65890846),
+        (3, 12.25345846, 2.253458468),
+        (4, 5.890846835, 6.890846835),
+        (5, 10.14345678, 20.14345678)
+        """
+
+    sql """
+        insert into test_regr_sxy_nullalble_col values
+        (1, 18, 13),
+        (2, 14, 27),
+        (3, 5, 7),
+        (4, 10, 20);
+        """
+
+    // value is null
+    sql """select regr_sxy(NULL, NULL);"""
+
+    // value is literal and columns
+    qt_sql "select regr_sxy(y,20) from test_regr_sxy_int"
+    sql """ truncate table test_regr_sxy_int """
+
+    // value is literal and columns
+    qt_sql "select regr_sxy(10,x) from test_regr_sxy_int"
+    sql """ truncate table test_regr_sxy_int """
+
+    // int value
+    qt_sql "select regr_sxy(y,x) from test_regr_sxy_int"
+    sql """ truncate table test_regr_sxy_int """
+
+    // double value
+    qt_sql "select regr_sxy(y,x) from test_regr_sxy_double"
+    sql """ truncate table test_regr_sxy_double """
+
+    // nullable and non_nullable
+    qt_sql "select regr_sxy(y,non_nullable(x)) from test_regr_sxy_nullalble_col"
+
+    // non_nullable and nullable
+    qt_sql "select regr_sxy(non_nullable(y),x) from test_regr_sxy_nullalble_col"
+    
+    // non_nullable and non_nullable
+    qt_sql "select regr_sxy(non_nullable(y),non_nullable(x)) from test_regr_sxy_nullalble_col"
+    sql """ truncate table test_regr_sxy_nullalble_col """
+
+    // exception test
+	test{
+		sql """select regr_sxy('range', 1);"""
+		exception "regr_sxy requires numeric for first parameter"
+	}
+    test{
+		sql """select regr_sxy(1, 'hello');"""
+		exception "regr_sxy requires numeric for second parameter"
+	}
+
+}
diff --git a/regression-test/suites/nereids_function_p0/agg_function/test_regr_syy.groovy b/regression-test/suites/nereids_function_p0/agg_function/test_regr_syy.groovy
new file mode 100644
index 00000000000000..9ed9f55a4d679f
--- /dev/null
+++ b/regression-test/suites/nereids_function_p0/agg_function/test_regr_syy.groovy
@@ -0,0 +1,128 @@
+// 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_regr_syy") {
+    sql """ DROP TABLE IF EXISTS test_regr_syy_int """
+    sql """ DROP TABLE IF EXISTS test_regr_syy_double """
+    sql """ DROP TABLE IF EXISTS test_regr_syy_nullalble_col """
+
+
+    sql """ SET enable_nereids_planner=true """
+    sql """ SET enable_fallback_to_original_planner=false """
+
+    sql """
+        CREATE TABLE test_regr_syy_int (
+          `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 """
+        CREATE TABLE test_regr_syy_double (
+          `id` int,
+          `x` double,
+          `y` double,
+        ) ENGINE=OLAP
+        Duplicate KEY (`id`)
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        PROPERTIES (
+        "replication_allocation" = "tag.location.default: 1"
+        );
+        """
+    sql """
+        CREATE TABLE test_regr_syy_nullalble_col (
+          `id` int NULL,
+          `x` int NULL,
+          `y` int NULL,
+        ) ENGINE=OLAP
+        Duplicate KEY (`id`)
+        DISTRIBUTED BY HASH(`id`) BUCKETS 4
+        PROPERTIES (
+        "replication_allocation" = "tag.location.default: 1"
+        );
+        """
+    // no value
+    qt_sql "select regr_syy(y,x) from test_regr_syy_int"
+    sql """ truncate table test_regr_syy_int """
+    
+    sql """
+        insert into test_regr_syy_int values
+        (1, 18, 13),
+        (2, 14, 27),
+        (3, 12, 2),
+        (4, 5, 6),
+        (5, 10, 20)
+        """
+
+    sql """
+        insert into test_regr_syy_double values
+        (1, 18.27123456, 13.27123456),
+        (2, 14.65890846, 27.65890846),
+        (3, 12.25345846, 2.253458468),
+        (4, 5.890846835, 6.890846835),
+        (5, 10.14345678, 20.14345678)
+        """
+
+    sql """
+        insert into test_regr_syy_nullalble_col values
+        (1, 18, 13),
+        (2, 14, 27),
+        (3, 5, 7),
+        (4, 10, 20);
+        """
+
+    // value is null
+    sql """select regr_syy(NULL, NULL);"""
+
+    // value is literal and columns
+    qt_sql "select regr_syy(y,20) from test_regr_syy_int"
+    sql """ truncate table test_regr_syy_int """
+
+    // int value
+    qt_sql "select regr_syy(y,x) from test_regr_syy_int"
+    sql """ truncate table test_regr_syy_int """
+
+    // double value
+    qt_sql "select regr_syy(y,x) from test_regr_syy_double"
+    sql """ truncate table test_regr_syy_double """
+
+    // nullable and non_nullable
+    qt_sql "select regr_syy(y,non_nullable(x)) from test_regr_syy_nullalble_col"
+
+    // non_nullable and nullable
+    qt_sql "select regr_syy(non_nullable(y),x) from test_regr_syy_nullalble_col"
+    
+    // non_nullable and non_nullable
+    qt_sql "select regr_syy(non_nullable(y),non_nullable(x)) from test_regr_syy_nullalble_col"
+    sql """ truncate table test_regr_syy_nullalble_col """
+
+    // exception test
+	test{
+		sql """select regr_syy('range', 1);"""
+		exception "regr_syy requires numeric for first parameter"
+	}
+    test{
+		sql """select regr_syy(1, 'hello');"""
+		exception "regr_syy requires numeric for second parameter"
+	}
+
+}

From 53ad25d8ee0127001c16289665811008f8c2026b Mon Sep 17 00:00:00 2001
From: wyxxxcat <1520358997@qq.com>
Date: Wed, 14 Aug 2024 17:26:18 +0800
Subject: [PATCH 2/2] 1

---
 ..._sxx_.h => aggregate_function_regr_math.h} | 18 ++++---
 .../aggregate_function_regr_sxx.cpp           |  2 +-
 .../catalog/BuiltinAggregateFunctions.java    |  4 +-
 .../expressions/functions/agg/RegrSxx.java    | 16 ++----
 .../expressions/functions/agg/RegrSxy.java    | 16 ++----
 .../expressions/functions/agg/RegrSyy.java    | 16 ++----
 .../functions/scalar/AutoPartitionName.java   |  4 +-
 .../visitor/AggregateFunctionVisitor.java     |  8 +--
 .../agg_function/test_regr_sxx.out            |  6 ++-
 .../agg_function/test_regr_sxy.out            |  7 ++-
 .../agg_function/test_regr_syy.out            |  4 +-
 .../agg_function/test_regr_sxx.groovy         | 54 ++++++++++---------
 .../agg_function/test_regr_sxy.groovy         | 19 ++++---
 .../agg_function/test_regr_syy.groovy         | 17 +++---
 14 files changed, 96 insertions(+), 95 deletions(-)
 rename be/src/vec/aggregate_functions/{aggregate_function_regr_sxx_.h => aggregate_function_regr_math.h} (91%)

diff --git a/be/src/vec/aggregate_functions/aggregate_function_regr_sxx_.h b/be/src/vec/aggregate_functions/aggregate_function_regr_math.h
similarity index 91%
rename from be/src/vec/aggregate_functions/aggregate_function_regr_sxx_.h
rename to be/src/vec/aggregate_functions/aggregate_function_regr_math.h
index 9006c317372ad8..139637a5079308 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_regr_sxx_.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_regr_math.h
@@ -85,7 +85,8 @@ struct AggregateFunctionRegrSxxData {
 #ifdef __clang__
 #pragma clang fp reassociate(on)
 #endif
-        const auto& sources_x = assert_cast<const ColumnVector<T>&>(*column_x);
+        const auto& sources_x =
+                assert_cast<const ColumnVector<T>&, TypeCheckOnRelease::DISABLE>(*column_x);
         const auto& value = sources_x.get_data()[row_num];
         sum_x += value;
         square_of_sum_x += value * value;
@@ -136,8 +137,10 @@ struct AggregateFunctionRegrSxyData {
 #ifdef __clang__
 #pragma clang fp reassociate(on)
 #endif
-        const auto& sources_x = assert_cast<const ColumnVector<T>&>(*column_x);
-        const auto& sources_y = assert_cast<const ColumnVector<T>&>(*column_y);
+        const auto& sources_x =
+                assert_cast<const ColumnVector<T>&, TypeCheckOnRelease::DISABLE>(*column_x);
+        const auto& sources_y =
+                assert_cast<const ColumnVector<T>&, TypeCheckOnRelease::DISABLE>(*column_y);
         const auto& value_x = sources_x.get_data()[row_num];
         const auto& value_y = sources_y.get_data()[row_num];
         sum_x += value_x;
@@ -183,7 +186,8 @@ struct AggregateFunctionRegrSyyData {
 #ifdef __clang__
 #pragma clang fp reassociate(on)
 #endif
-        const auto& sources_y = assert_cast<const ColumnVector<T>&>(*column_y);
+        const auto& sources_y =
+                assert_cast<const ColumnVector<T>&, TypeCheckOnRelease::DISABLE>(*column_y);
         const auto& value = sources_y.get_data()[row_num];
         square_of_sum_y += value * value;
         sum_y += value;
@@ -194,7 +198,7 @@ struct AggregateFunctionRegrSyyData {
 template <typename T, typename Data>
 struct RegrSxxData : AggregateFunctionRegrSxxData<T> {
     void insert_result_into(IColumn& to) const {
-        auto& col = assert_cast<ColumnFloat64&>(to);
+        auto& col = assert_cast<ColumnFloat64&, TypeCheckOnRelease::DISABLE>(to);
         col.get_data().push_back(this->get_regr_sxx_result());
     }
 };
@@ -202,14 +206,14 @@ struct RegrSxxData : AggregateFunctionRegrSxxData<T> {
 template <typename T, typename Data>
 struct RegrSxyData : AggregateFunctionRegrSxyData<T> {
     void insert_result_into(IColumn& to) const {
-        auto& col = assert_cast<ColumnFloat64&>(to);
+        auto& col = assert_cast<ColumnFloat64&, TypeCheckOnRelease::DISABLE>(to);
         col.get_data().push_back(this->get_regr_sxy_result());
     }
 };
 template <typename T, typename Data>
 struct RegrSyyData : AggregateFunctionRegrSyyData<T> {
     void insert_result_into(IColumn& to) const {
-        auto& col = assert_cast<ColumnFloat64&>(to);
+        auto& col = assert_cast<ColumnFloat64&, TypeCheckOnRelease::DISABLE>(to);
         col.get_data().push_back(this->get_regr_syy_result());
     }
 };
diff --git a/be/src/vec/aggregate_functions/aggregate_function_regr_sxx.cpp b/be/src/vec/aggregate_functions/aggregate_function_regr_sxx.cpp
index 8d9abd2721e0ca..3f29701d19d18d 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_regr_sxx.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_regr_sxx.cpp
@@ -20,7 +20,7 @@
 #include <string>
 
 #include "common/logging.h"
-#include "vec/aggregate_functions/aggregate_function_regr_sxx_.h"
+#include "vec/aggregate_functions/aggregate_function_regr_math.h"
 #include "vec/aggregate_functions/aggregate_function_simple_factory.h"
 #include "vec/aggregate_functions/helpers.h"
 #include "vec/data_types/data_type.h"
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 4bd727fb0139b5..81b3170796f68a 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
@@ -136,11 +136,11 @@ public class BuiltinAggregateFunctions implements FunctionHelper {
                     agg(PercentileApproxWeighted.class, "percentile_approx_weighted"),
                     agg(PercentileArray.class, "percentile_array"),
                     agg(QuantileUnion.class, "quantile_union"),
-                    agg(Retention.class, "retention"),
                     agg(RegrSxx.class, "regr_sxx"),
                     agg(RegrSxy.class, "regr_sxy"),
                     agg(RegrSyy.class, "regr_syy"),
-                                            agg(SequenceCount.class, "sequence_count"),
+                    agg(Retention.class, "retention"),
+            agg(SequenceCount.class, "sequence_count"),
             agg(SequenceMatch.class, "sequence_match"),
             agg(Stddev.class, "stddev_pop", "stddev"),
             agg(StddevSamp.class, "stddev_samp"),
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxx.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxx.java
index 93d64293a57cb2..17b1e35e00401b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxx.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxx.java
@@ -20,7 +20,6 @@
 import org.apache.doris.catalog.FunctionSignature;
 import org.apache.doris.nereids.exceptions.AnalysisException;
 import org.apache.doris.nereids.trees.expressions.Expression;
-import org.apache.doris.nereids.trees.expressions.functions.AlwaysNotNullable;
 import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
 import org.apache.doris.nereids.trees.expressions.functions.window.SupportWindowAnalytic;
 import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
@@ -41,11 +40,11 @@ public class RegrSxx extends NullableAggregateFunction
         implements ExplicitlyCastableSignature, SupportWindowAnalytic {
 
     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(DoubleType.INSTANCE, DoubleType.INSTANCE),
             FunctionSignature.ret(DoubleType.INSTANCE).args(BigIntType.INSTANCE, BigIntType.INSTANCE),
-            FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE, DoubleType.INSTANCE));
+            FunctionSignature.ret(DoubleType.INSTANCE).args(IntegerType.INSTANCE, IntegerType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(SmallIntType.INSTANCE, SmallIntType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(TinyIntType.INSTANCE, TinyIntType.INSTANCE));
 
     public RegrSxx(Expression arg0, Expression arg1) {
         this(false, false, arg0, arg1);
@@ -73,13 +72,6 @@ public void checkLegalityBeforeTypeCoercion() {
         }
     }
 
-    @Override
-    public void checkLegalityAfterRewrite() {
-        if (arity() != 2) {
-            throw new AnalysisException("regr_sxx must contain two arguments");
-        }
-    }
-
     @Override
     public RegrSxx withDistinctAndChildren(boolean distinct, List<Expression> children) {
         Preconditions.checkArgument(children.size() == 2);
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxy.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxy.java
index 057523fa68ab74..3c0f8f16b155fd 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxy.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSxy.java
@@ -20,7 +20,6 @@
 import org.apache.doris.catalog.FunctionSignature;
 import org.apache.doris.nereids.exceptions.AnalysisException;
 import org.apache.doris.nereids.trees.expressions.Expression;
-import org.apache.doris.nereids.trees.expressions.functions.AlwaysNotNullable;
 import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
 import org.apache.doris.nereids.trees.expressions.functions.window.SupportWindowAnalytic;
 import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
@@ -41,11 +40,11 @@ public class RegrSxy extends NullableAggregateFunction
         implements ExplicitlyCastableSignature, SupportWindowAnalytic {
 
     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(DoubleType.INSTANCE, DoubleType.INSTANCE),
             FunctionSignature.ret(DoubleType.INSTANCE).args(BigIntType.INSTANCE, BigIntType.INSTANCE),
-            FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE, DoubleType.INSTANCE));
+            FunctionSignature.ret(DoubleType.INSTANCE).args(IntegerType.INSTANCE, IntegerType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(SmallIntType.INSTANCE, SmallIntType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(TinyIntType.INSTANCE, TinyIntType.INSTANCE));
 
     public RegrSxy(Expression arg0, Expression arg1) {
         this(false, false, arg0, arg1);
@@ -73,13 +72,6 @@ public void checkLegalityBeforeTypeCoercion() {
         }
     }
 
-    @Override
-    public void checkLegalityAfterRewrite() {
-        if (arity() != 2) {
-            throw new AnalysisException("regr_sxy must contain two arguments");
-        }
-    }
-
     @Override
     public RegrSxy withDistinctAndChildren(boolean distinct, List<Expression> children) {
         Preconditions.checkArgument(children.size() == 2);
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSyy.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSyy.java
index 4f33e7917e5185..1ca7e86439c9cd 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSyy.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSyy.java
@@ -20,7 +20,6 @@
 import org.apache.doris.catalog.FunctionSignature;
 import org.apache.doris.nereids.exceptions.AnalysisException;
 import org.apache.doris.nereids.trees.expressions.Expression;
-import org.apache.doris.nereids.trees.expressions.functions.AlwaysNotNullable;
 import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
 import org.apache.doris.nereids.trees.expressions.functions.window.SupportWindowAnalytic;
 import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
@@ -41,11 +40,11 @@ public class RegrSyy extends NullableAggregateFunction
         implements ExplicitlyCastableSignature, SupportWindowAnalytic {
 
     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(DoubleType.INSTANCE, DoubleType.INSTANCE),
             FunctionSignature.ret(DoubleType.INSTANCE).args(BigIntType.INSTANCE, BigIntType.INSTANCE),
-            FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE, DoubleType.INSTANCE));
+            FunctionSignature.ret(DoubleType.INSTANCE).args(IntegerType.INSTANCE, IntegerType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(SmallIntType.INSTANCE, SmallIntType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(TinyIntType.INSTANCE, TinyIntType.INSTANCE));
 
     public RegrSyy(Expression arg0, Expression arg1) {
         this(false, false, arg0, arg1);
@@ -73,13 +72,6 @@ public void checkLegalityBeforeTypeCoercion() {
         }
     }
 
-    @Override
-    public void checkLegalityAfterRewrite() {
-        if (arity() != 2) {
-            throw new AnalysisException("regr_syy must contain two arguments");
-        }
-    }
-
     @Override
     public RegrSyy withDistinctAndChildren(boolean distinct, List<Expression> children) {
         Preconditions.checkArgument(children.size() == 2);
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/AutoPartitionName.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/AutoPartitionName.java
index 716cb0a6ee5127..5fc820b9dd0739 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/AutoPartitionName.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/AutoPartitionName.java
@@ -20,8 +20,8 @@
 import org.apache.doris.catalog.FunctionSignature;
 import org.apache.doris.nereids.exceptions.AnalysisException;
 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.functions.PropagateNullable;
 import org.apache.doris.nereids.trees.expressions.literal.VarcharLiteral;
 import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression;
 import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
@@ -40,7 +40,7 @@
  * GenerateFunction.
  */
 public class AutoPartitionName extends ScalarFunction
-        implements UnaryExpression, ExplicitlyCastableSignature, PropagateNullable {
+        implements UnaryExpression, ExplicitlyCastableSignature, AlwaysNullable {
 
     public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
             FunctionSignature.ret(VarcharType.SYSTEM_DEFAULT).varArgs(VarcharType.SYSTEM_DEFAULT),
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 26537ae2fe2efd..437f8eeb55ad9d 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
@@ -269,10 +269,6 @@ default R visitQuantileUnion(QuantileUnion quantileUnion, C context) {
         return visitAggregateFunction(quantileUnion, context);
     }
 
-    default R visitRetention(Retention retention, C context) {
-        return visitNullableAggregateFunction(retention, context);
-    }
-
     default R visitRegrSxx(RegrSxx regrSxx, C context) {
         return visitAggregateFunction(regrSxx, context);
     }
@@ -285,6 +281,10 @@ default R visitRegrSyy(RegrSyy regrSyy, C context) {
         return visitAggregateFunction(regrSyy, context);
     }
 
+    default R visitRetention(Retention retention, C context) {
+        return visitNullableAggregateFunction(retention, context);
+    }
+
     default R visitSequenceCount(SequenceCount sequenceCount, C context) {
         return visitAggregateFunction(sequenceCount, context);
     }
diff --git a/regression-test/data/nereids_function_p0/agg_function/test_regr_sxx.out b/regression-test/data/nereids_function_p0/agg_function/test_regr_sxx.out
index 84e30b51724cab..0f4b68c6f1b1c8 100644
--- a/regression-test/data/nereids_function_p0/agg_function/test_regr_sxx.out
+++ b/regression-test/data/nereids_function_p0/agg_function/test_regr_sxx.out
@@ -1,4 +1,3 @@
--- This file is automatically generated. You should know what you did if you want to edit this
 -- !sql --
 \N
 
@@ -6,7 +5,10 @@
 92.79999999999995
 
 -- !sql --
-\N
+92.79999999999995
+
+-- !sql --
+92.79999999999995
 
 -- !sql --
 86.93426485321584
diff --git a/regression-test/data/nereids_function_p0/agg_function/test_regr_sxy.out b/regression-test/data/nereids_function_p0/agg_function/test_regr_sxy.out
index 5202b9e69f69c4..6b33d373bbd15b 100644
--- a/regression-test/data/nereids_function_p0/agg_function/test_regr_sxy.out
+++ b/regression-test/data/nereids_function_p0/agg_function/test_regr_sxy.out
@@ -1,10 +1,15 @@
--- This file is automatically generated. You should know what you did if you want to edit this
 -- !sql --
 \N
 
 -- !sql --
 0.0
 
+-- !sql --
+0.0
+
+-- !sql --
+0.0
+
 -- !sql --
 \N
 
diff --git a/regression-test/data/nereids_function_p0/agg_function/test_regr_syy.out b/regression-test/data/nereids_function_p0/agg_function/test_regr_syy.out
index ef69596e79125c..cecaa04286a3b8 100644
--- a/regression-test/data/nereids_function_p0/agg_function/test_regr_syy.out
+++ b/regression-test/data/nereids_function_p0/agg_function/test_regr_syy.out
@@ -1,10 +1,12 @@
--- This file is automatically generated. You should know what you did if you want to edit this
 -- !sql --
 \N
 
 -- !sql --
 413.20000000000005
 
+-- !sql --
+413.20000000000005
+
 -- !sql --
 \N
 
diff --git a/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxx.groovy b/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxx.groovy
index c5b1bdd7c6e020..6881c1d3931780 100644
--- a/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxx.groovy
+++ b/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxx.groovy
@@ -18,7 +18,7 @@
 suite("test_regr_sxx") {
     sql """ DROP TABLE IF EXISTS test_regr_sxx_int """
     sql """ DROP TABLE IF EXISTS test_regr_sxx_double """
-    sql """ DROP TABLE IF EXISTS test_regr_sxx_nullalble_col """
+    sql """ DROP TABLE IF EXISTS test_regr_sxx_nullable_col """
 
 
     sql """ SET enable_nereids_planner=true """
@@ -49,7 +49,7 @@ suite("test_regr_sxx") {
         );
         """
     sql """
-        CREATE TABLE test_regr_sxx_nullalble_col (
+        CREATE TABLE test_regr_sxx_nullable_col (
           `id` int,
           `x` int,
           `y` int,
@@ -83,7 +83,7 @@ suite("test_regr_sxx") {
         """
 
     sql """
-        insert into test_regr_sxx_nullalble_col values
+        insert into test_regr_sxx_nullable_col values
         (1, 18, 13),
         (2, 14, 27),
         (3, 5, 7),
@@ -95,7 +95,9 @@ suite("test_regr_sxx") {
 
     // parameter is literal and columns
     qt_sql "select regr_sxx(10,x) from test_regr_sxx_int"
-    sql """ truncate table test_regr_sxx_int """
+
+    // literal and column
+    qt_sql "select regr_sxx(4,x) from test_regr_sxx_int"
 
     // int value
     qt_sql "select regr_sxx(y,x) from test_regr_sxx_int"
@@ -106,34 +108,36 @@ suite("test_regr_sxx") {
     sql """ truncate table test_regr_sxx_double """
 
     // nullable and non_nullable
-    qt_sql "select regr_sxx(y,non_nullable(x)) from test_regr_sxx_nullalble_col"
+    qt_sql "select regr_sxx(y,non_nullable(x)) from test_regr_sxx_nullable_col"
 
     // non_nullable and nullable
-    qt_sql "select regr_sxx(non_nullable(y),x) from test_regr_sxx_nullalble_col"
+    qt_sql "select regr_sxx(non_nullable(y),x) from test_regr_sxx_nullable_col"
     
     // non_nullable and non_nullable
-    qt_sql "select regr_sxx(non_nullable(y),non_nullable(x)) from test_regr_sxx_nullalble_col"
-    sql """ truncate table test_regr_sxx_nullalble_col """
+    qt_sql "select regr_sxx(non_nullable(y),non_nullable(x)) from test_regr_sxx_nullable_col"
+    sql """ truncate table test_regr_sxx_nullable_col """
 
-    // exception test
-	test{
-		sql """select regr_sxx('range', 1);"""
-		exception "regr_sxx requires numeric for first parameter"
-	}
 
-    test{
-		sql """select regr_sxx(1, 'hello');"""
-		exception "regr_sxx requires numeric for second parameter"
-	}
-    
-    test{
-		sql """select regr_sxx(y, 'hello') from test_regr_sxx_int;"""
-		exception "regr_sxx requires numeric for second parameter"
-	}
 
+    // exception test
     test{
-		sql """select regr_sxx(1, true);"""
-		exception "regr_sxx requires numeric for second parameter"
-	}
+      sql """select regr_sxx('range', 1);"""
+      exception "regr_sxx requires numeric for first parameter"
+    }
+
+      test{
+      sql """select regr_sxx(1, 'hello');"""
+      exception "regr_sxx requires numeric for second parameter"
+    }
+      
+      test{
+      sql """select regr_sxx(y, 'hello') from test_regr_sxx_int;"""
+      exception "regr_sxx requires numeric for second parameter"
+    }
+
+      test{
+      sql """select regr_sxx(1, true);"""
+      exception "regr_sxx requires numeric for second parameter"
+    }
 
 }
diff --git a/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxy.groovy b/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxy.groovy
index 54b656e55e4c68..5d5b5274572f43 100644
--- a/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxy.groovy
+++ b/regression-test/suites/nereids_function_p0/agg_function/test_regr_sxy.groovy
@@ -18,7 +18,7 @@
 suite("test_regr_sxy") {
     sql """ DROP TABLE IF EXISTS test_regr_sxy_int """
     sql """ DROP TABLE IF EXISTS test_regr_sxy_double """
-    sql """ DROP TABLE IF EXISTS test_regr_sxy_nullalble_col """
+    sql """ DROP TABLE IF EXISTS test_regr_sxy_nullable_col """
 
 
     sql """ SET enable_nereids_planner=true """
@@ -49,7 +49,7 @@ suite("test_regr_sxy") {
         );
         """
     sql """
-        CREATE TABLE test_regr_sxy_nullalble_col (
+        CREATE TABLE test_regr_sxy_nullable_col (
           `id` int,
           `x` int,
           `y` int,
@@ -83,7 +83,7 @@ suite("test_regr_sxy") {
         """
 
     sql """
-        insert into test_regr_sxy_nullalble_col values
+        insert into test_regr_sxy_nullable_col values
         (1, 18, 13),
         (2, 14, 27),
         (3, 5, 7),
@@ -93,6 +93,11 @@ suite("test_regr_sxy") {
     // value is null
     sql """select regr_sxy(NULL, NULL);"""
 
+    // literal and column
+    qt_sql "select regr_sxy(4,x) from test_regr_sxy_int"
+
+    qt_sql "select regr_sxy(y,10) from test_regr_sxy_int"
+
     // value is literal and columns
     qt_sql "select regr_sxy(y,20) from test_regr_sxy_int"
     sql """ truncate table test_regr_sxy_int """
@@ -110,14 +115,14 @@ suite("test_regr_sxy") {
     sql """ truncate table test_regr_sxy_double """
 
     // nullable and non_nullable
-    qt_sql "select regr_sxy(y,non_nullable(x)) from test_regr_sxy_nullalble_col"
+    qt_sql "select regr_sxy(y,non_nullable(x)) from test_regr_sxy_nullable_col"
 
     // non_nullable and nullable
-    qt_sql "select regr_sxy(non_nullable(y),x) from test_regr_sxy_nullalble_col"
+    qt_sql "select regr_sxy(non_nullable(y),x) from test_regr_sxy_nullable_col"
     
     // non_nullable and non_nullable
-    qt_sql "select regr_sxy(non_nullable(y),non_nullable(x)) from test_regr_sxy_nullalble_col"
-    sql """ truncate table test_regr_sxy_nullalble_col """
+    qt_sql "select regr_sxy(non_nullable(y),non_nullable(x)) from test_regr_sxy_nullable_col"
+    sql """ truncate table test_regr_sxy_nullable_col """
 
     // exception test
 	test{
diff --git a/regression-test/suites/nereids_function_p0/agg_function/test_regr_syy.groovy b/regression-test/suites/nereids_function_p0/agg_function/test_regr_syy.groovy
index 9ed9f55a4d679f..cc3cf934c108bd 100644
--- a/regression-test/suites/nereids_function_p0/agg_function/test_regr_syy.groovy
+++ b/regression-test/suites/nereids_function_p0/agg_function/test_regr_syy.groovy
@@ -18,7 +18,7 @@
 suite("test_regr_syy") {
     sql """ DROP TABLE IF EXISTS test_regr_syy_int """
     sql """ DROP TABLE IF EXISTS test_regr_syy_double """
-    sql """ DROP TABLE IF EXISTS test_regr_syy_nullalble_col """
+    sql """ DROP TABLE IF EXISTS test_regr_syy_nullable_col """
 
 
     sql """ SET enable_nereids_planner=true """
@@ -49,7 +49,7 @@ suite("test_regr_syy") {
         );
         """
     sql """
-        CREATE TABLE test_regr_syy_nullalble_col (
+        CREATE TABLE test_regr_syy_nullable_col (
           `id` int NULL,
           `x` int NULL,
           `y` int NULL,
@@ -83,7 +83,7 @@ suite("test_regr_syy") {
         """
 
     sql """
-        insert into test_regr_syy_nullalble_col values
+        insert into test_regr_syy_nullable_col values
         (1, 18, 13),
         (2, 14, 27),
         (3, 5, 7),
@@ -93,6 +93,9 @@ suite("test_regr_syy") {
     // value is null
     sql """select regr_syy(NULL, NULL);"""
 
+    // literal and column
+    qt_sql "select regr_syy(y,4) from test_regr_syy_int"
+
     // value is literal and columns
     qt_sql "select regr_syy(y,20) from test_regr_syy_int"
     sql """ truncate table test_regr_syy_int """
@@ -106,14 +109,14 @@ suite("test_regr_syy") {
     sql """ truncate table test_regr_syy_double """
 
     // nullable and non_nullable
-    qt_sql "select regr_syy(y,non_nullable(x)) from test_regr_syy_nullalble_col"
+    qt_sql "select regr_syy(y,non_nullable(x)) from test_regr_syy_nullable_col"
 
     // non_nullable and nullable
-    qt_sql "select regr_syy(non_nullable(y),x) from test_regr_syy_nullalble_col"
+    qt_sql "select regr_syy(non_nullable(y),x) from test_regr_syy_nullable_col"
     
     // non_nullable and non_nullable
-    qt_sql "select regr_syy(non_nullable(y),non_nullable(x)) from test_regr_syy_nullalble_col"
-    sql """ truncate table test_regr_syy_nullalble_col """
+    qt_sql "select regr_syy(non_nullable(y),non_nullable(x)) from test_regr_syy_nullable_col"
+    sql """ truncate table test_regr_syy_nullable_col """
 
     // exception test
 	test{