diff --git a/be/src/vec/aggregate_functions/aggregate_function_regr_union.cpp b/be/src/vec/aggregate_functions/aggregate_function_regr_union.cpp
new file mode 100644
index 00000000000000..738d777441c360
--- /dev/null
+++ b/be/src/vec/aggregate_functions/aggregate_function_regr_union.cpp
@@ -0,0 +1,93 @@
+// 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_regr_union.h"
+
+#include "common/status.h"
+#include "vec/aggregate_functions/aggregate_function.h"
+#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
+#include "vec/aggregate_functions/helpers.h"
+#include "vec/core/types.h"
+#include "vec/data_types/data_type.h"
+#include "vec/data_types/data_type_nullable.h"
+
+namespace doris::vectorized {
+
+template <typename T, template <typename> class StatFunctionTemplate>
+AggregateFunctionPtr type_dispatch_for_aggregate_function_regr(const DataTypes& argument_types,
+                                                               const bool& result_is_nullable,
+                                                               bool y_nullable_input,
+                                                               bool x_nullable_input) {
+    if (y_nullable_input) {
+        if (x_nullable_input) {
+            return creator_without_type::create_ignore_nullable<
+                    AggregateFunctionRegrSimple<StatFunctionTemplate<T>, true, true>>(
+                    argument_types, result_is_nullable);
+        } else {
+            return creator_without_type::create_ignore_nullable<
+                    AggregateFunctionRegrSimple<StatFunctionTemplate<T>, true, false>>(
+                    argument_types, result_is_nullable);
+        }
+    } else {
+        if (x_nullable_input) {
+            return creator_without_type::create_ignore_nullable<
+                    AggregateFunctionRegrSimple<StatFunctionTemplate<T>, false, true>>(
+                    argument_types, result_is_nullable);
+        } else {
+            return creator_without_type::create_ignore_nullable<
+                    AggregateFunctionRegrSimple<StatFunctionTemplate<T>, false, false>>(
+                    argument_types, result_is_nullable);
+        }
+    }
+}
+
+template <template <typename> class StatFunctionTemplate>
+AggregateFunctionPtr create_aggregate_function_regr(const std::string& name,
+                                                    const DataTypes& argument_types,
+                                                    const bool result_is_nullable) {
+    if (argument_types.size() != 2) {
+        LOG(WARNING) << "aggregate function " << name << " requires exactly 2 arguments";
+        return nullptr;
+    }
+    if (!result_is_nullable) {
+        LOG(WARNING) << "aggregate function " << name << " requires nullable result type";
+        return nullptr;
+    }
+
+    bool y_nullable_input = argument_types[0]->is_nullable();
+    bool x_nullable_input = argument_types[1]->is_nullable();
+    WhichDataType y_type(remove_nullable(argument_types[0]));
+    WhichDataType x_type(remove_nullable(argument_types[1]));
+
+#define DISPATCH(TYPE)                                                                \
+    if (x_type.idx == TypeIndex::TYPE && y_type.idx == TypeIndex::TYPE)               \
+        return type_dispatch_for_aggregate_function_regr<TYPE, StatFunctionTemplate>( \
+                argument_types, result_is_nullable, y_nullable_input, x_nullable_input);
+    FOR_NUMERIC_TYPES(DISPATCH)
+#undef DISPATCH
+
+    LOG(WARNING) << "unsupported input types " << argument_types[0]->get_name() << " and "
+                 << argument_types[1]->get_name() << " for aggregate function " << name;
+    return nullptr;
+}
+
+void register_aggregate_function_regr_union(AggregateFunctionSimpleFactory& factory) {
+    factory.register_function_both("regr_slope", create_aggregate_function_regr<RegrSlopeFunc>);
+    factory.register_function_both("regr_intercept",
+                                   create_aggregate_function_regr<RegrInterceptFunc>);
+}
+} // namespace doris::vectorized
\ No newline at end of file
diff --git a/be/src/vec/aggregate_functions/aggregate_function_regr_union.h b/be/src/vec/aggregate_functions/aggregate_function_regr_union.h
new file mode 100644
index 00000000000000..c631ae66f261bd
--- /dev/null
+++ b/be/src/vec/aggregate_functions/aggregate_function_regr_union.h
@@ -0,0 +1,217 @@
+// 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 <cmath>
+#include <cstdint>
+#include <string>
+#include <type_traits>
+
+#include "common/exception.h"
+#include "common/status.h"
+#include "vec/aggregate_functions/aggregate_function.h"
+#include "vec/columns/column_nullable.h"
+#include "vec/columns/column_vector.h"
+#include "vec/common/assert_cast.h"
+#include "vec/core/field.h"
+#include "vec/core/types.h"
+#include "vec/data_types/data_type.h"
+#include "vec/data_types/data_type_nullable.h"
+#include "vec/data_types/data_type_number.h"
+#include "vec/io/io_helper.h"
+
+namespace doris::vectorized {
+
+template <typename T>
+struct AggregateFunctionRegrData {
+    UInt64 count = 0;
+    Float64 sum_x {};
+    Float64 sum_y {};
+    Float64 sum_of_x_mul_y {};
+    Float64 sum_of_x_squared {};
+
+    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(sum_of_x_squared, 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(sum_of_x_squared, buf);
+        read_binary(count, buf);
+    }
+
+    void reset() {
+        sum_x = {};
+        sum_y = {};
+        sum_of_x_mul_y = {};
+        sum_of_x_squared = {};
+        count = 0;
+    }
+
+    void merge(const AggregateFunctionRegrData& 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;
+        sum_of_x_squared += rhs.sum_of_x_squared;
+        count += rhs.count;
+    }
+
+    void add(T value_y, T value_x) {
+        sum_x += value_x;
+        sum_y += value_y;
+        sum_of_x_mul_y += value_x * value_y;
+        sum_of_x_squared += value_x * value_x;
+        count += 1;
+    }
+};
+
+template <typename T>
+struct RegrSlopeFunc : AggregateFunctionRegrData<T> {
+    using Type = T;
+    static constexpr const char* name = "regr_slope";
+
+    Float64 get_result() const {
+        Float64 denominator = this->count * this->sum_of_x_squared - this->sum_x * this->sum_x;
+        if (this->count < 2 || denominator == 0.0) {
+            return std::numeric_limits<Float64>::quiet_NaN();
+        }
+        Float64 slope =
+                (this->count * this->sum_of_x_mul_y - this->sum_x * this->sum_y) / denominator;
+        return slope;
+    }
+};
+
+template <typename T>
+struct RegrInterceptFunc : AggregateFunctionRegrData<T> {
+    using Type = T;
+    static constexpr const char* name = "regr_intercept";
+
+    Float64 get_result() const {
+        Float64 denominator = this->count * this->sum_of_x_squared - this->sum_x * this->sum_x;
+        if (this->count < 2 || denominator == 0.0) {
+            return std::numeric_limits<Float64>::quiet_NaN();
+        }
+        Float64 slope =
+                (this->count * this->sum_of_x_mul_y - this->sum_x * this->sum_y) / denominator;
+        Float64 intercept = (this->sum_y - slope * this->sum_x) / this->count;
+        return intercept;
+    }
+};
+
+template <typename RegrFunc, bool y_nullable, bool x_nullable>
+class AggregateFunctionRegrSimple
+        : public IAggregateFunctionDataHelper<
+                  RegrFunc, AggregateFunctionRegrSimple<RegrFunc, y_nullable, x_nullable>> {
+public:
+    using Type = typename RegrFunc::Type;
+    using XInputCol = ColumnVector<Type>;
+    using YInputCol = ColumnVector<Type>;
+    using ResultCol = ColumnVector<Float64>;
+
+    explicit AggregateFunctionRegrSimple(const DataTypes& argument_types_)
+            : IAggregateFunctionDataHelper<
+                      RegrFunc, AggregateFunctionRegrSimple<RegrFunc, y_nullable, x_nullable>>(
+                      argument_types_) {
+        DCHECK(!argument_types_.empty());
+    }
+
+    String get_name() const override { return RegrFunc::name; }
+
+    DataTypePtr get_return_type() const override {
+        return make_nullable(std::make_shared<DataTypeFloat64>());
+    }
+
+    void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,
+             Arena*) const override {
+        bool y_null = false;
+        bool x_null = false;
+        const YInputCol* y_nested_column = nullptr;
+        const XInputCol* x_nested_column = nullptr;
+
+        if constexpr (y_nullable) {
+            const ColumnNullable& y_column_nullable =
+                    assert_cast<const ColumnNullable&, TypeCheckOnRelease::DISABLE>(*columns[0]);
+            y_null = y_column_nullable.is_null_at(row_num);
+            y_nested_column = assert_cast<const YInputCol*, TypeCheckOnRelease::DISABLE>(
+                    y_column_nullable.get_nested_column_ptr().get());
+        } else {
+            y_nested_column = assert_cast<const YInputCol*, TypeCheckOnRelease::DISABLE>(
+                    (*columns[0]).get_ptr().get());
+        }
+
+        if constexpr (x_nullable) {
+            const ColumnNullable& x_column_nullable =
+                    assert_cast<const ColumnNullable&, TypeCheckOnRelease::DISABLE>(*columns[1]);
+            x_null = x_column_nullable.is_null_at(row_num);
+            x_nested_column = assert_cast<const XInputCol*, TypeCheckOnRelease::DISABLE>(
+                    x_column_nullable.get_nested_column_ptr().get());
+        } else {
+            x_nested_column = assert_cast<const XInputCol*, TypeCheckOnRelease::DISABLE>(
+                    (*columns[1]).get_ptr().get());
+        }
+
+        if (x_null || y_null) {
+            return;
+        }
+
+        Type y_value = y_nested_column->get_data()[row_num];
+        Type x_value = x_nested_column->get_data()[row_num];
+
+        this->data(place).add(y_value, x_value);
+    }
+
+    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 {
+        const auto& data = this->data(place);
+        auto& dst_column_with_nullable = assert_cast<ColumnNullable&>(to);
+        auto& dst_column = assert_cast<ResultCol&>(dst_column_with_nullable.get_nested_column());
+        Float64 result = data.get_result();
+        if (std::isnan(result)) {
+            dst_column_with_nullable.get_null_map_data().push_back(1);
+            dst_column.insert_default();
+        } else {
+            dst_column_with_nullable.get_null_map_data().push_back(0);
+            dst_column.get_data().push_back(result);
+        }
+    }
+};
+} // namespace doris::vectorized
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..eb8639d5908986 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
@@ -56,6 +56,7 @@ void register_aggregate_function_percentile(AggregateFunctionSimpleFactory& fact
 void register_aggregate_function_percentile_old(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_window_funnel(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_window_funnel_old(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_regr_union(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_retention(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_percentile_approx(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_orthogonal_bitmap(AggregateFunctionSimpleFactory& factory);
@@ -100,6 +101,7 @@ AggregateFunctionSimpleFactory& AggregateFunctionSimpleFactory::instance() {
         register_aggregate_function_percentile_approx(instance);
         register_aggregate_function_window_funnel(instance);
         register_aggregate_function_window_funnel_old(instance);
+        register_aggregate_function_regr_union(instance);
         register_aggregate_function_retention(instance);
         register_aggregate_function_orthogonal_bitmap(instance);
         register_aggregate_function_collect_list(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..df9c792aec6c41 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
@@ -56,7 +56,7 @@ public class AggregateFunction extends Function {
             "ndv_no_finalize", "percentile_array", "histogram",
             FunctionSet.SEQUENCE_COUNT, FunctionSet.MAP_AGG, FunctionSet.BITMAP_AGG, FunctionSet.ARRAY_AGG,
             FunctionSet.COLLECT_LIST, FunctionSet.COLLECT_SET, FunctionSet.GROUP_ARRAY_INTERSECT,
-            FunctionSet.SUM0, FunctionSet.MULTI_DISTINCT_SUM0);
+            FunctionSet.SUM0, FunctionSet.MULTI_DISTINCT_SUM0, FunctionSet.REGR_INTERCEPT, FunctionSet.REGR_SLOPE);
 
     public static ImmutableSet<String> ALWAYS_NULLABLE_AGGREGATE_FUNCTION_NAME_SET =
             ImmutableSet.of("stddev_samp", "variance_samp", "var_samp", "percentile_approx", "first_value",
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..f517770400b5dd 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,8 @@
 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.RegrIntercept;
+import org.apache.doris.nereids.trees.expressions.functions.agg.RegrSlope;
 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;
@@ -127,13 +129,15 @@ public class BuiltinAggregateFunctions implements FunctionHelper {
             agg(Ndv.class, "approx_count_distinct", "ndv"),
             agg(OrthogonalBitmapIntersect.class, "orthogonal_bitmap_intersect"),
             agg(OrthogonalBitmapIntersectCount.class, "orthogonal_bitmap_intersect_count"),
-                    agg(OrthogonalBitmapUnionCount.class, "orthogonal_bitmap_union_count"),
-                    agg(Percentile.class, "percentile"),
-                    agg(PercentileApprox.class, "percentile_approx"),
-                    agg(PercentileApproxWeighted.class, "percentile_approx_weighted"),
-                    agg(PercentileArray.class, "percentile_array"),
-                    agg(QuantileUnion.class, "quantile_union"),
-                    agg(Retention.class, "retention"),
+            agg(OrthogonalBitmapUnionCount.class, "orthogonal_bitmap_union_count"),
+            agg(Percentile.class, "percentile"),
+            agg(PercentileApprox.class, "percentile_approx"),
+            agg(PercentileApproxWeighted.class, "percentile_approx_weighted"),
+            agg(PercentileArray.class, "percentile_array"),
+            agg(QuantileUnion.class, "quantile_union"),
+            agg(RegrIntercept.class, "regr_intercept"),
+            agg(RegrSlope.class, "regr_slope"),
+            agg(Retention.class, "retention"),
             agg(SequenceCount.class, "sequence_count"),
             agg(SequenceMatch.class, "sequence_match"),
             agg(Stddev.class, "stddev_pop", "stddev"),
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 4165f9362214ed..afb79d8a9e464c 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
@@ -631,6 +631,10 @@ public void addBuiltinBothScalaAndVectorized(Function fn) {
 
     public static final String RETENTION = "retention";
 
+    public static final String REGR_INTERCEPT = "regr_intercept";
+
+    public static final String REGR_SLOPE = "regr_slope";
+
     public static final String SEQUENCE_MATCH = "sequence_match";
 
     public static final String SEQUENCE_COUNT = "sequence_count";
@@ -664,6 +668,25 @@ private void initAggregateBuiltins() {
                 "",
                 null, false, true, true, true));
 
+        // regr_intercept
+        addBuiltin(AggregateFunction.createBuiltin(FunctionSet.REGR_INTERCEPT,
+                Lists.newArrayList(Type.DOUBLE, Type.DOUBLE), Type.DOUBLE, Type.DOUBLE,
+                "",
+                "",
+                "",
+                null, null,
+                "",
+                null, false, false, false, true));
+        // regr_slope
+        addBuiltin(AggregateFunction.createBuiltin(FunctionSet.REGR_SLOPE,
+                Lists.newArrayList(Type.DOUBLE, Type.DOUBLE), Type.DOUBLE, Type.DOUBLE,
+                "",
+                "",
+                "",
+                null, null,
+                "",
+                null, false, false, false, true));
+
         // count(array/map/struct)
         for (Type complexType : Lists.newArrayList(Type.ARRAY, Type.MAP, Type.GENERIC_STRUCT)) {
             addBuiltin(AggregateFunction.createBuiltin(FunctionSet.COUNT,
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrIntercept.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrIntercept.java
new file mode 100644
index 00000000000000..85487a2807c550
--- /dev/null
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrIntercept.java
@@ -0,0 +1,97 @@
+// 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.AlwaysNullable;
+import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
+import org.apache.doris.nereids.trees.expressions.shape.BinaryExpression;
+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.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 'regr_intercept'.
+ */
+public class RegrIntercept extends AggregateFunction
+        implements BinaryExpression, ExplicitlyCastableSignature, AlwaysNullable {
+
+    public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
+            FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE, DoubleType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(BigIntType.INSTANCE, BigIntType.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),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(FloatType.INSTANCE, FloatType.INSTANCE)
+    );
+
+    /**
+     * Constructor with 2 arguments.
+     */
+    public RegrIntercept(Expression arg1, Expression arg2) {
+        this(false, arg1, arg2);
+    }
+
+    /**
+     * Constructor with distinct flag and 2 arguments.
+     */
+    public RegrIntercept(boolean distinct, Expression arg1, Expression arg2) {
+        super("regr_intercept", distinct, arg1, arg2);
+    }
+
+    @Override
+    public void checkLegalityBeforeTypeCoercion() throws AnalysisException {
+        DataType arg0Type = left().getDataType();
+        DataType arg1Type = right().getDataType();
+        if ((!arg0Type.isNumericType() && !arg0Type.isNullType())
+                || arg0Type.isOnlyMetricType()) {
+            throw new AnalysisException("regr_intercept requires numeric for first parameter: " + toSql());
+        } else if ((!arg1Type.isNumericType() && !arg1Type.isNullType())
+                || arg1Type.isOnlyMetricType()) {
+            throw new AnalysisException("regr_intercept requires numeric for second parameter: " + toSql());
+        }
+    }
+
+    @Override
+    public RegrIntercept withDistinctAndChildren(boolean distinct, List<Expression> children) {
+        Preconditions.checkArgument(children.size() == 2);
+        return new RegrIntercept(distinct, children.get(0), children.get(1));
+    }
+
+    @Override
+    public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visitRegrIntercept(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/RegrSlope.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSlope.java
new file mode 100644
index 00000000000000..efce6e88076a7e
--- /dev/null
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/agg/RegrSlope.java
@@ -0,0 +1,97 @@
+// 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.AlwaysNullable;
+import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
+import org.apache.doris.nereids.trees.expressions.shape.BinaryExpression;
+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.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 'regr_slope'.
+ */
+public class RegrSlope extends AggregateFunction
+        implements BinaryExpression, ExplicitlyCastableSignature, AlwaysNullable {
+
+    public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
+            FunctionSignature.ret(DoubleType.INSTANCE).args(DoubleType.INSTANCE, DoubleType.INSTANCE),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(BigIntType.INSTANCE, BigIntType.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),
+            FunctionSignature.ret(DoubleType.INSTANCE).args(FloatType.INSTANCE, FloatType.INSTANCE)
+    );
+
+    /**
+     * Constructor with 2 arguments.
+     */
+    public RegrSlope(Expression arg1, Expression arg2) {
+        this(false, arg1, arg2);
+    }
+
+    /**
+     * Constructor with distinct flag and 2 arguments.
+     */
+    public RegrSlope(boolean distinct, Expression arg1, Expression arg2) {
+        super("regr_slope", distinct, arg1, arg2);
+    }
+
+    @Override
+    public void checkLegalityBeforeTypeCoercion() throws AnalysisException {
+        DataType arg0Type = left().getDataType();
+        DataType arg1Type = right().getDataType();
+        if ((!arg0Type.isNumericType() && !arg0Type.isNullType())
+                || arg0Type.isOnlyMetricType()) {
+            throw new AnalysisException("regr_slope requires numeric for first parameter: " + toSql());
+        } else if ((!arg1Type.isNumericType() && !arg1Type.isNullType())
+                || arg1Type.isOnlyMetricType()) {
+            throw new AnalysisException("regr_slope requires numeric for second parameter: " + toSql());
+        }
+    }
+
+    @Override
+    public RegrSlope withDistinctAndChildren(boolean distinct, List<Expression> children) {
+        Preconditions.checkArgument(children.size() == 2);
+        return new RegrSlope(distinct, children.get(0), children.get(1));
+    }
+
+    @Override
+    public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visitRegrSlope(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..3f8c157b376bd6 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,8 @@
 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.RegrIntercept;
+import org.apache.doris.nereids.trees.expressions.functions.agg.RegrSlope;
 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;
@@ -266,6 +268,14 @@ default R visitQuantileUnion(QuantileUnion quantileUnion, C context) {
         return visitAggregateFunction(quantileUnion, context);
     }
 
+    default R visitRegrIntercept(RegrIntercept regrIntercept, C context) {
+        return visitAggregateFunction(regrIntercept, context);
+    }
+
+    default R visitRegrSlope(RegrSlope regrSlope, C context) {
+        return visitAggregateFunction(regrSlope, context);
+    }
+
     default R visitRetention(Retention retention, C context) {
         return visitNullableAggregateFunction(retention, context);
     }
diff --git a/regression-test/data/query_p0/aggregate/test_regr_intercept.out b/regression-test/data/query_p0/aggregate/test_regr_intercept.out
new file mode 100644
index 00000000000000..ff8bb43897e314
--- /dev/null
+++ b/regression-test/data/query_p0/aggregate/test_regr_intercept.out
@@ -0,0 +1,114 @@
+-- This file is automatically generated. You should know what you did if you want to edit this
+-- !sql_empty_1 --
+\N
+
+-- !sql_empty_2 --
+
+-- !sql_int_1 --
+10.0
+
+-- !sql_int_2 --
+\N
+
+-- !sql_int_3 --
+5.512931034482759
+
+-- !sql_int_4 --
+5.512931034482759
+
+-- !sql_int_5 --
+5.512931034482759
+
+-- !sql_int_6 --
+10.0
+
+-- !sql_int_7 --
+\N
+
+-- !sql_int_8 --
+4.9208211143695015
+
+-- !sql_int_8 --
+\N
+\N
+-106.33333333333333
+\N
+\N
+
+-- !sql_int_9 --
+3.606299212598425
+
+-- !sql_int_9 --
+-106.33333333333333
+\N
+\N
+
+-- !sql_int_10 --
+3.606299212598425
+
+-- !sql_int_10 --
+-106.33333333333333
+\N
+\N
+
+-- !sql_double_1 --
+10.0
+
+-- !sql_double_2 --
+\N
+
+-- !sql_double_3 --
+5.4887751937424145
+
+-- !sql_double_3 --
+\N
+\N
+\N
+\N
+\N
+
+-- !sql_double_4 --
+5.4887751937424145
+
+-- !sql_double_4 --
+\N
+\N
+\N
+\N
+\N
+
+-- !sql_double_5 --
+5.4887751937424145
+
+-- !sql_double_6 --
+10.0
+
+-- !sql_double_7 --
+\N
+
+-- !sql_double_8 --
+4.9208211143695015
+
+-- !sql_double_8 --
+\N
+\N
+-106.33333333333333
+\N
+\N
+
+-- !sql_double_9 --
+3.606299212598425
+
+-- !sql_double_9 --
+-106.33333333333333
+\N
+\N
+
+-- !sql_double_10 --
+3.606299212598425
+
+-- !sql_double_10 --
+-106.33333333333333
+\N
+\N
+
diff --git a/regression-test/data/query_p0/aggregate/test_regr_slope.out b/regression-test/data/query_p0/aggregate/test_regr_slope.out
new file mode 100644
index 00000000000000..2c39290d95c935
--- /dev/null
+++ b/regression-test/data/query_p0/aggregate/test_regr_slope.out
@@ -0,0 +1,114 @@
+-- This file is automatically generated. You should know what you did if you want to edit this
+-- !sql_empty_1 --
+\N
+
+-- !sql_empty_2 --
+
+-- !sql_int_1 --
+0.0
+
+-- !sql_int_2 --
+\N
+
+-- !sql_int_3 --
+0.6853448275862069
+
+-- !sql_int_4 --
+0.6853448275862069
+
+-- !sql_int_5 --
+0.6853448275862069
+
+-- !sql_int_6 --
+0.0
+
+-- !sql_int_7 --
+\N
+
+-- !sql_int_8 --
+0.7390029325513197
+
+-- !sql_int_8 --
+\N
+\N
+9.0
+\N
+\N
+
+-- !sql_int_9 --
+0.7401574803149606
+
+-- !sql_int_9 --
+9.0
+\N
+\N
+
+-- !sql_int_10 --
+0.7401574803149606
+
+-- !sql_int_10 --
+9.0
+\N
+\N
+
+-- !sql_double_1 --
+0.0
+
+-- !sql_double_2 --
+\N
+
+-- !sql_double_3 --
+0.6987176230207431
+
+-- !sql_double_3 --
+\N
+\N
+\N
+\N
+\N
+
+-- !sql_double_4 --
+0.6987176230207446
+
+-- !sql_double_4 --
+\N
+\N
+\N
+\N
+\N
+
+-- !sql_double_5 --
+0.6987176230207446
+
+-- !sql_double_6 --
+0.0
+
+-- !sql_double_7 --
+\N
+
+-- !sql_double_8 --
+0.7390029325513197
+
+-- !sql_double_8 --
+\N
+\N
+9.0
+\N
+\N
+
+-- !sql_double_9 --
+0.7401574803149606
+
+-- !sql_double_9 --
+9.0
+\N
+\N
+
+-- !sql_double_10 --
+0.7401574803149606
+
+-- !sql_double_10 --
+9.0
+\N
+\N
+
diff --git a/regression-test/suites/query_p0/aggregate/test_regr_intercept.groovy b/regression-test/suites/query_p0/aggregate/test_regr_intercept.groovy
new file mode 100644
index 00000000000000..f7c44642427c3c
--- /dev/null
+++ b/regression-test/suites/query_p0/aggregate/test_regr_intercept.groovy
@@ -0,0 +1,217 @@
+// 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_intercept") {
+    sql """ DROP TABLE IF EXISTS test_regr_intercept_int """
+    sql """ DROP TABLE IF EXISTS test_regr_intercept_double """
+    sql """ DROP TABLE IF EXISTS test_regr_intercept_nullable_col """
+
+
+    sql """ SET enable_nereids_planner=true """
+    sql """ SET enable_fallback_to_original_planner=false """
+
+    sql """
+        CREATE TABLE test_regr_intercept_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_intercept_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"
+        );
+        """
+    
+    // no value
+    // agg function without group by should return null
+    qt_sql_empty_1 "select regr_intercept(y,x) from test_regr_intercept_int"
+    // agg function with group by should return empty set
+    qt_sql_empty_2 "select regr_intercept(y,x) from test_regr_intercept_int group by id"
+
+    sql """ TRUNCATE TABLE test_regr_intercept_int """
+
+    sql """
+        INSERT INTO test_regr_intercept_int VALUES
+        (1, 18, 13),
+        (2, 14, 27),
+        (3, 12, 2),
+        (4, 5, 6),
+        (5, 10, 20);
+        """
+
+    sql """
+        INSERT INTO test_regr_intercept_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);
+        """
+
+    // parameter is literal and columns
+    // _xxx can help use to distinguish the result
+    qt_sql_int_1 "select regr_intercept(10, x) from test_regr_intercept_int"
+
+    // column and literal
+    qt_sql_int_2 "select regr_intercept(x, 4) from test_regr_intercept_int"
+
+    // int value
+    qt_sql_int_3 "select regr_intercept(y,x) from test_regr_intercept_int"
+
+    // qt_sql_int_3 tests Nullable input column, qt_sql_int_4 test non-Nullable input column
+    qt_sql_int_4 "select regr_intercept(non_nullable(y), non_nullable(x)) from test_regr_intercept_int"
+    // qt_sql_int_4 tests mix nullable 
+    qt_sql_int_5 "select regr_intercept(y, non_nullable(x)) from test_regr_intercept_int"
+
+    sql """ TRUNCATE TABLE test_regr_intercept_int """
+
+    // Insert random null values
+    sql """
+      INSERT INTO test_regr_intercept_int VALUES
+        (1, 18, 13),
+        (1, NULL, 14),
+        (1, 19, NULL),
+        (2, 14, 27),
+        (2, NULL, NULL);
+    """
+
+    // Insert random value
+    // group of id = 3 shoud NOT be null
+    // group of id = 4 || 5 shoud be null since its size is 1
+    sql """
+      INSERT INTO test_regr_intercept_int VALUES
+        (3, 12, 2),
+        (3, 13, 10),
+        (3, 14, 20),
+        (4, 5, 6),
+        (5, 10, 20);
+    """
+
+    // parameter is literal and columns
+    // _xxx can help use to distinguish the result
+    qt_sql_int_6 "select regr_intercept(10, x) from test_regr_intercept_int"
+  
+    // column and literal
+    qt_sql_int_7 "select regr_intercept(x, 4) from test_regr_intercept_int"
+
+    // int value
+    qt_sql_int_8 "select regr_intercept(y,x) from test_regr_intercept_int"
+    qt_sql_int_8 "select regr_intercept(y,x) from test_regr_intercept_int group by id order by id"
+
+    // qt_sql_int_3 tests Nullable input column, qt_sql_int_4 test non-Nullable input column
+    qt_sql_int_9 "select regr_intercept(non_nullable(y), non_nullable(x)) from test_regr_intercept_int where id >= 3"
+    qt_sql_int_9 "select regr_intercept(non_nullable(y), non_nullable(x)) from test_regr_intercept_int where id >= 3 group by id order by id"
+    // qt_sql_int_4 tests mix nullable 
+    qt_sql_int_10 "select regr_intercept(y, non_nullable(x)) from test_regr_intercept_int where id >= 3"
+    qt_sql_int_10 "select regr_intercept(y, non_nullable(x)) from test_regr_intercept_int where id >= 3 group by id order by id"
+
+    //// Repeat same thing for double ////
+
+    // parameter is literal and columns
+    // _xxx can help use to distinguish the result
+    qt_sql_double_1 "select regr_intercept(10, x) from test_regr_intercept_double"
+
+    // column and literal
+    qt_sql_double_2 "select regr_intercept(x, 4) from test_regr_intercept_double"
+
+    // int value
+    qt_sql_double_3 "select regr_intercept(y,x) from test_regr_intercept_double"
+    qt_sql_double_3 "select regr_intercept(y,x) from test_regr_intercept_double group by id order by id"
+
+    // qt_sql_int_3 tests Nullable input column, qt_sql_int_4 test non-Nullable input column
+    qt_sql_double_4 "select regr_intercept(non_nullable(y), non_nullable(x)) from test_regr_intercept_double"
+    qt_sql_double_4 "select regr_intercept(non_nullable(y), non_nullable(x)) from test_regr_intercept_double group by id order by id"
+    // qt_sql_int_4 tests mix nullable 
+    qt_sql_double_5 "select regr_intercept(y, non_nullable(x)) from test_regr_intercept_double"
+
+    sql """ TRUNCATE TABLE test_regr_intercept_double """
+
+    // Insert random null values
+    sql """
+      INSERT INTO test_regr_intercept_double VALUES
+        (1, 18, 13),
+        (1, NULL, 14),
+        (1, 19, NULL),
+        (2, 14, 27),
+        (2, NULL, NULL);
+    """
+
+    // Insert random value
+    // group of id = 3 shoud NOT be null
+    // group of id = 4 || 5 shoud be null since its size is 1
+    sql """
+      INSERT INTO test_regr_intercept_double VALUES
+        (3, 12, 2),
+        (3, 13, 10),
+        (3, 14, 20),
+        (4, 5, 6),
+        (5, 10, 20);
+    """
+
+    // parameter is literal and columns
+    // _xxx can help use to distinguish the result
+    qt_sql_double_6 "select regr_intercept(10, x) from test_regr_intercept_double"
+
+    // column and literal
+    qt_sql_double_7 "select regr_intercept(x, 4) from test_regr_intercept_double"
+
+    // int value
+    qt_sql_double_8 "select regr_intercept(y,x) from test_regr_intercept_double"
+    qt_sql_double_8 "select regr_intercept(y,x) from test_regr_intercept_double group by id order by id"
+    
+    // qt_sql_int_3 tests Nullable input column, qt_sql_int_4 test non-Nullable input column
+    qt_sql_double_9 "select regr_intercept(non_nullable(y), non_nullable(x)) from test_regr_intercept_double where id >= 3"
+    qt_sql_double_9 "select regr_intercept(non_nullable(y), non_nullable(x)) from test_regr_intercept_double where id >= 3 group by id order by id"
+    // qt_sql_int_4 tests mix nullable 
+    qt_sql_double_10 "select regr_intercept(y, non_nullable(x)) from test_regr_intercept_double where id >= 3"
+    qt_sql_double_10 "select regr_intercept(y, non_nullable(x)) from test_regr_intercept_double where id >= 3 group by id order by id"
+
+    // exception test
+    test{
+        sql """select regr_intercept('range', 1);"""
+        exception "regr_intercept requires numeric for first parameter"
+    }
+
+    test{
+        sql """select regr_intercept(1, 'hello');"""
+        exception "regr_intercept requires numeric for second parameter"
+    }
+
+    test{
+        sql """select regr_intercept(y, 'hello') from test_regr_intercept_int;"""
+        exception "regr_intercept requires numeric for second parameter"
+    }
+
+    test{
+        sql """select regr_intercept(1, true);"""
+        exception "regr_intercept requires numeric for second parameter"
+    }
+
+}
diff --git a/regression-test/suites/query_p0/aggregate/test_regr_slope.groovy b/regression-test/suites/query_p0/aggregate/test_regr_slope.groovy
new file mode 100644
index 00000000000000..19397036234595
--- /dev/null
+++ b/regression-test/suites/query_p0/aggregate/test_regr_slope.groovy
@@ -0,0 +1,217 @@
+// 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_slope") {
+    sql """ DROP TABLE IF EXISTS test_regr_slope_int """
+    sql """ DROP TABLE IF EXISTS test_regr_slope_double """
+    sql """ DROP TABLE IF EXISTS test_regr_slope_nullable_col """
+
+
+    sql """ SET enable_nereids_planner=true """
+    sql """ SET enable_fallback_to_original_planner=false """
+
+    sql """
+        CREATE TABLE test_regr_slope_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_slope_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"
+        );
+        """
+    
+    // no value
+    // agg function without group by should return null
+    qt_sql_empty_1 "select regr_slope(y,x) from test_regr_slope_int"
+    // agg function with group by should return empty set
+    qt_sql_empty_2 "select regr_slope(y,x) from test_regr_slope_int group by id"
+
+    sql """ TRUNCATE TABLE test_regr_slope_int """
+
+    sql """
+        INSERT INTO test_regr_slope_int VALUES
+        (1, 18, 13),
+        (2, 14, 27),
+        (3, 12, 2),
+        (4, 5, 6),
+        (5, 10, 20);
+        """
+
+    sql """
+        INSERT INTO test_regr_slope_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);
+        """
+
+    // parameter is literal and columns
+    // _xxx can help use to distinguish the result
+    qt_sql_int_1 "select regr_slope(10, x) from test_regr_slope_int"
+
+    // column and literal
+    qt_sql_int_2 "select regr_slope(x, 4) from test_regr_slope_int"
+
+    // int value
+    qt_sql_int_3 "select regr_slope(y,x) from test_regr_slope_int"
+
+    // qt_sql_int_3 tests Nullable input column, qt_sql_int_4 test non-Nullable input column
+    qt_sql_int_4 "select regr_slope(non_nullable(y), non_nullable(x)) from test_regr_slope_int"
+    // qt_sql_int_4 tests mix nullable 
+    qt_sql_int_5 "select regr_slope(y, non_nullable(x)) from test_regr_slope_int"
+
+    sql """ TRUNCATE TABLE test_regr_slope_int """
+
+    // Insert random null values
+    sql """
+      INSERT INTO test_regr_slope_int VALUES
+        (1, 18, 13),
+        (1, NULL, 14),
+        (1, 19, NULL),
+        (2, 14, 27),
+        (2, NULL, NULL);
+    """
+
+    // Insert random value
+    // group of id = 3 shoud NOT be null
+    // group of id = 4 || 5 shoud be null since its size is 1
+    sql """
+      INSERT INTO test_regr_slope_int VALUES
+        (3, 12, 2),
+        (3, 13, 10),
+        (3, 14, 20),
+        (4, 5, 6),
+        (5, 10, 20);
+    """
+
+    // parameter is literal and columns
+    // _xxx can help use to distinguish the result
+    qt_sql_int_6 "select regr_slope(10, x) from test_regr_slope_int"
+  
+    // column and literal
+    qt_sql_int_7 "select regr_slope(x, 4) from test_regr_slope_int"
+
+    // int value
+    qt_sql_int_8 "select regr_slope(y,x) from test_regr_slope_int"
+    qt_sql_int_8 "select regr_slope(y,x) from test_regr_slope_int group by id order by id"
+
+    // qt_sql_int_3 tests Nullable input column, qt_sql_int_4 test non-Nullable input column
+    qt_sql_int_9 "select regr_slope(non_nullable(y), non_nullable(x)) from test_regr_slope_int where id >= 3"
+    qt_sql_int_9 "select regr_slope(non_nullable(y), non_nullable(x)) from test_regr_slope_int where id >= 3 group by id order by id"
+    // qt_sql_int_4 tests mix nullable 
+    qt_sql_int_10 "select regr_slope(y, non_nullable(x)) from test_regr_slope_int where id >= 3"
+    qt_sql_int_10 "select regr_slope(y, non_nullable(x)) from test_regr_slope_int where id >= 3 group by id order by id"
+
+    //// Repeat same thing for double ////
+
+    // parameter is literal and columns
+    // _xxx can help use to distinguish the result
+    qt_sql_double_1 "select regr_slope(10, x) from test_regr_slope_double"
+
+    // column and literal
+    qt_sql_double_2 "select regr_slope(x, 4) from test_regr_slope_double"
+
+    // int value
+    qt_sql_double_3 "select regr_slope(y,x) from test_regr_slope_double"
+    qt_sql_double_3 "select regr_slope(y,x) from test_regr_slope_double group by id order by id"
+
+    // qt_sql_int_3 tests Nullable input column, qt_sql_int_4 test non-Nullable input column
+    qt_sql_double_4 "select regr_slope(non_nullable(y), non_nullable(x)) from test_regr_slope_double"
+    qt_sql_double_4 "select regr_slope(non_nullable(y), non_nullable(x)) from test_regr_slope_double group by id order by id"
+    // qt_sql_int_4 tests mix nullable 
+    qt_sql_double_5 "select regr_slope(y, non_nullable(x)) from test_regr_slope_double"
+
+    sql """ TRUNCATE TABLE test_regr_slope_double """
+
+    // Insert random null values
+    sql """
+      INSERT INTO test_regr_slope_double VALUES
+        (1, 18, 13),
+        (1, NULL, 14),
+        (1, 19, NULL),
+        (2, 14, 27),
+        (2, NULL, NULL);
+    """
+
+    // Insert random value
+    // group of id = 3 shoud NOT be null
+    // group of id = 4 || 5 shoud be null since its size is 1
+    sql """
+      INSERT INTO test_regr_slope_double VALUES
+        (3, 12, 2),
+        (3, 13, 10),
+        (3, 14, 20),
+        (4, 5, 6),
+        (5, 10, 20);
+    """
+
+    // parameter is literal and columns
+    // _xxx can help use to distinguish the result
+    qt_sql_double_6 "select regr_slope(10, x) from test_regr_slope_double"
+
+    // column and literal
+    qt_sql_double_7 "select regr_slope(x, 4) from test_regr_slope_double"
+
+    // int value
+    qt_sql_double_8 "select regr_slope(y,x) from test_regr_slope_double"
+    qt_sql_double_8 "select regr_slope(y,x) from test_regr_slope_double group by id order by id"
+    
+    // qt_sql_int_3 tests Nullable input column, qt_sql_int_4 test non-Nullable input column
+    qt_sql_double_9 "select regr_slope(non_nullable(y), non_nullable(x)) from test_regr_slope_double where id >= 3"
+    qt_sql_double_9 "select regr_slope(non_nullable(y), non_nullable(x)) from test_regr_slope_double where id >= 3 group by id order by id"
+    // qt_sql_int_4 tests mix nullable 
+    qt_sql_double_10 "select regr_slope(y, non_nullable(x)) from test_regr_slope_double where id >= 3"
+    qt_sql_double_10 "select regr_slope(y, non_nullable(x)) from test_regr_slope_double where id >= 3 group by id order by id"
+
+    // exception test
+    test{
+        sql """select regr_slope('range', 1);"""
+        exception "regr_slope requires numeric for first parameter"
+    }
+
+    test{
+        sql """select regr_slope(1, 'hello');"""
+        exception "regr_slope requires numeric for second parameter"
+    }
+
+    test{
+        sql """select regr_slope(y, 'hello') from test_regr_slope_int;"""
+        exception "regr_slope requires numeric for second parameter"
+    }
+
+    test{
+        sql """select regr_slope(1, true);"""
+        exception "regr_slope requires numeric for second parameter"
+    }
+
+}