be/src/exprs/aggregate/aggregate_function_stddev.h

Source
// 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 <cstdint>
#include <limits>
#include <memory>

#include "core/assert_cast.h"
#include "core/column/column.h"
#include "core/data_type/data_type_number.h"
#include "core/types.h"
#include "exprs/aggregate/aggregate_function.h"

namespace doris {
class Arena;
class BufferReadable;
class BufferWritable;
template <PrimitiveType T>
class ColumnVector;

template <PrimitiveType T, bool is_stddev>
struct BaseData {
    BaseData() = default;
    virtual ~BaseData() = default;

    void write(BufferWritable& buf) const {
        buf.write_binary(mean);
        buf.write_binary(m2);
        buf.write_binary(count);
    }

    void read(BufferReadable& buf) {
        buf.read_binary(mean);
        buf.read_binary(m2);
        buf.read_binary(count);
    }

    void reset() {
        mean = 0.0;
        m2 = 0.0;
        count = 0;
    }

    double get_result(double res) const {
        auto inf_to_nan = [](double val) {
            // This function performs squaring operations, and due to differences in computation order,
            // it might produce different values such as inf and nan.
            // In MySQL, this will directly result in an error due to exceeding the double range.
            // For performance reasons, we are uniformly changing it to nan
            if (std::isinf(val)) {
                return std::numeric_limits<double>::quiet_NaN();
            }
            return val;
        };
        if constexpr (is_stddev) {
            return inf_to_nan(std::sqrt(res));
        } else {
            return inf_to_nan(res);
        }
    }

    double get_pop_result() const {
        if (count == 1) {
            return 0.0;
        }
        double res = m2 / (double)count;
        return get_result(res);
    }

    double get_samp_result() const {
        double res = m2 / double(count - 1);
        return get_result(res);
    }

    void merge(const BaseData& rhs) {
        if (rhs.count == 0) {
            return;
        }
        double delta = mean - rhs.mean;
        double sum_count = double(count + rhs.count);
        mean = rhs.mean + delta * (double)count / sum_count;
        m2 = rhs.m2 + m2 + (delta * delta) * (double)rhs.count * (double)count / sum_count;
        count = int64_t(sum_count);
    }

    void add(const IColumn* column, size_t row_num) {
        const auto& sources = assert_cast<const typename PrimitiveTypeTraits<T>::ColumnType&,
                                          TypeCheckOnRelease::DISABLE>(*column);
        double source_data = (double)sources.get_data()[row_num];

        double delta = source_data - mean;
        double r = delta / double(1 + count);
        mean += r;
        m2 += (double)count * delta * r;
        count += 1;
    }

    double mean {};
    double m2 {};
    int64_t count {};
};

template <PrimitiveType T, typename Name, bool is_stddev>
struct PopData : BaseData<T, is_stddev>, Name {
    void insert_result_into(IColumn& to) const {
        auto& col = assert_cast<ColumnFloat64&>(to);
        col.get_data().push_back(this->get_pop_result());
    }

    static DataTypePtr get_return_type() { return std::make_shared<DataTypeFloat64>(); }
};

// For this series of functions, the Decimal type is not supported
// because the operations involve squaring,
// which can easily exceed the range of the Decimal type.

template <PrimitiveType T, typename Name, bool is_stddev>
struct SampData : BaseData<T, is_stddev>, Name {
    void insert_result_into(IColumn& to) const {
        auto& col = assert_cast<ColumnFloat64&>(to);
        if (this->count == 1 || this->count == 0) {
            col.get_data().push_back(std::numeric_limits<double>::quiet_NaN());
        } else {
            col.get_data().push_back(this->get_samp_result());
        }
    }

    static DataTypePtr get_return_type() { return std::make_shared<DataTypeFloat64>(); }
};

struct StddevName {
    static const char* name() { return "stddev"; }
};
struct VarianceName {
    static const char* name() { return "variance"; }
};
struct VarianceSampName {
    static const char* name() { return "variance_samp"; }
};
struct StddevSampName {
    static const char* name() { return "stddev_samp"; }
};

template <typename Data>
class AggregateFunctionSampVariance final
        : public IAggregateFunctionDataHelper<Data, AggregateFunctionSampVariance<Data>>,
          UnaryExpression,
          NullableAggregateFunction {
public:
    AggregateFunctionSampVariance(const DataTypes& argument_types_)
            : IAggregateFunctionDataHelper<Data, AggregateFunctionSampVariance<Data>>(
                      argument_types_) {}

    String get_name() const override { return Data::name(); }

    DataTypePtr get_return_type() const override { return Data::get_return_type(); }

    void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,
             Arena&) const override {
        this->data(place).add(columns[0], 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

Coverage Report

Created: 2026-05-29 19:04

Line	Count	Source
1		// Licensed to the Apache Software Foundation (ASF) under one
2		// or more contributor license agreements. See the NOTICE file
3		// distributed with this work for additional information
4		// regarding copyright ownership. The ASF licenses this file
5		// to you under the Apache License, Version 2.0 (the
6		// "License"); you may not use this file except in compliance
7		// with the License. You may obtain a copy of the License at
8		//
9		// http://www.apache.org/licenses/LICENSE-2.0
10		//
11		// Unless required by applicable law or agreed to in writing,
12		// software distributed under the License is distributed on an
13		// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14		// KIND, either express or implied. See the License for the
15		// specific language governing permissions and limitations
16		// under the License.
17
18		#pragma once
19
20		#include <boost/iterator/iterator_facade.hpp>
21		#include <cmath>
22		#include <cstddef>
23		#include <cstdint>
24		#include <limits>
25		#include <memory>
26
27		#include "core/assert_cast.h"
28		#include "core/column/column.h"
29		#include "core/data_type/data_type_number.h"
30		#include "core/types.h"
31		#include "exprs/aggregate/aggregate_function.h"
32
33		namespace doris {
34		class Arena;
35		class BufferReadable;
36		class BufferWritable;
37		template <PrimitiveType T>
38		class ColumnVector;
39
40		template <PrimitiveType T, bool is_stddev>
41		struct BaseData {
42	0	BaseData() = default; Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EEC2Ev Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EEC2Ev
43	0	virtual ~BaseData() = default; Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EED2Ev Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EED2Ev
44
45	0	void write(BufferWritable& buf) const {
46	0	buf.write_binary(mean);
47	0	buf.write_binary(m2);
48	0	buf.write_binary(count);
49	0	} Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE5writeERNS_14BufferWritableE Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE5writeERNS_14BufferWritableE
50
51	0	void read(BufferReadable& buf) {
52	0	buf.read_binary(mean);
53	0	buf.read_binary(m2);
54	0	buf.read_binary(count);
55	0	} Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE4readERNS_14BufferReadableE Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE4readERNS_14BufferReadableE
56
57	0	void reset() {
58	0	mean = 0.0;
59	0	m2 = 0.0;
60	0	count = 0;
61	0	} Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE5resetEv Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE5resetEv
62
63	0	double get_result(double res) const {
64	0	auto inf_to_nan = [](double val) {
65		// This function performs squaring operations, and due to differences in computation order,
66		// it might produce different values such as inf and nan.
67		// In MySQL, this will directly result in an error due to exceeding the double range.
68		// For performance reasons, we are uniformly changing it to nan
69	0	if (std::isinf(val)) {
70	0	return std::numeric_limits<double>::quiet_NaN();
71	0	}
72	0	return val;
73	0	}; Unexecuted instantiation: _ZZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE10get_resultEdENKUldE_clEd Unexecuted instantiation: _ZZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE10get_resultEdENKUldE_clEd
74	0	if constexpr (is_stddev) {
75	0	return inf_to_nan(std::sqrt(res));
76	0	} else {
77	0	return inf_to_nan(res);
78	0	}
79	0	} Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE10get_resultEd Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE10get_resultEd
80
81	0	double get_pop_result() const {
82	0	if (count == 1) {
83	0	return 0.0;
84	0	}
85	0	double res = m2 / (double)count;
86	0	return get_result(res);
87	0	} Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE14get_pop_resultEv Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE14get_pop_resultEv
88
89	0	double get_samp_result() const {
90	0	double res = m2 / double(count - 1);
91	0	return get_result(res);
92	0	} Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE15get_samp_resultEv Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE15get_samp_resultEv
93
94	0	void merge(const BaseData& rhs) {
95	0	if (rhs.count == 0) {
96	0	return;
97	0	}
98	0	double delta = mean - rhs.mean;
99	0	double sum_count = double(count + rhs.count);
100	0	mean = rhs.mean + delta * (double)count / sum_count;
101	0	m2 = rhs.m2 + m2 + (delta * delta) * (double)rhs.count * (double)count / sum_count;
102	0	count = int64_t(sum_count);
103	0	} Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE5mergeERKS2_ Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE5mergeERKS2_
104
105	0	void add(const IColumn* column, size_t row_num) {
106	0	const auto& sources = assert_cast<const typename PrimitiveTypeTraits<T>::ColumnType&,
107	0	TypeCheckOnRelease::DISABLE>(*column);
108	0	double source_data = (double)sources.get_data()[row_num];
109
110	0	double delta = source_data - mean;
111	0	double r = delta / double(1 + count);
112	0	mean += r;
113	0	m2 += (double)count * delta * r;
114	0	count += 1;
115	0	} Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE3addEPKNS_7IColumnEm Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE3addEPKNS_7IColumnEm
116
117		double mean {};
118		double m2 {};
119		int64_t count {};
120		};
121
122		template <PrimitiveType T, typename Name, bool is_stddev>
123		struct PopData : BaseData<T, is_stddev>, Name {
124	0	void insert_result_into(IColumn& to) const {
125	0	auto& col = assert_cast<ColumnFloat64&>(to);
126	0	col.get_data().push_back(this->get_pop_result());
127	0	} Unexecuted instantiation: _ZNK5doris7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EE18insert_result_intoERNS_7IColumnE Unexecuted instantiation: _ZNK5doris7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EE18insert_result_intoERNS_7IColumnE
128
129	0	static DataTypePtr get_return_type() { return std::make_shared<DataTypeFloat64>(); } Unexecuted instantiation: _ZN5doris7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EE15get_return_typeEv Unexecuted instantiation: _ZN5doris7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EE15get_return_typeEv
130		};
131
132		// For this series of functions, the Decimal type is not supported
133		// because the operations involve squaring,
134		// which can easily exceed the range of the Decimal type.
135
136		template <PrimitiveType T, typename Name, bool is_stddev>
137		struct SampData : BaseData<T, is_stddev>, Name {
138	0	void insert_result_into(IColumn& to) const {
139	0	auto& col = assert_cast<ColumnFloat64&>(to);
140	0	if (this->count == 1 \|\| this->count == 0) {
141	0	col.get_data().push_back(std::numeric_limits<double>::quiet_NaN());
142	0	} else {
143	0	col.get_data().push_back(this->get_samp_result());
144	0	}
145	0	} Unexecuted instantiation: _ZNK5doris8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EE18insert_result_intoERNS_7IColumnE Unexecuted instantiation: _ZNK5doris8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EE18insert_result_intoERNS_7IColumnE
146
147	0	static DataTypePtr get_return_type() { return std::make_shared<DataTypeFloat64>(); } Unexecuted instantiation: _ZN5doris8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EE15get_return_typeEv Unexecuted instantiation: _ZN5doris8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EE15get_return_typeEv
148		};
149
150		struct StddevName {
151	0	static const char* name() { return "stddev"; }
152		};
153		struct VarianceName {
154	0	static const char* name() { return "variance"; }
155		};
156		struct VarianceSampName {
157	0	static const char* name() { return "variance_samp"; }
158		};
159		struct StddevSampName {
160	0	static const char* name() { return "stddev_samp"; }
161		};
162
163		template <typename Data>
164		class AggregateFunctionSampVariance final
165		: public IAggregateFunctionDataHelper<Data, AggregateFunctionSampVariance<Data>>,
166		UnaryExpression,
167		NullableAggregateFunction {
168		public:
169		AggregateFunctionSampVariance(const DataTypes& argument_types_)
170	0	: IAggregateFunctionDataHelper<Data, AggregateFunctionSampVariance<Data>>(
171	0	argument_types_) {} Unexecuted instantiation: _ZN5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EEEEC2ERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISA_EE Unexecuted instantiation: _ZN5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EEEEC2ERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISA_EE Unexecuted instantiation: _ZN5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EEEEC2ERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISA_EE Unexecuted instantiation: _ZN5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EEEEC2ERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaISA_EE
172
173	0	String get_name() const override { return Data::name(); } Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EEEE8get_nameB5cxx11Ev Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EEEE8get_nameB5cxx11Ev Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EEEE8get_nameB5cxx11Ev Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EEEE8get_nameB5cxx11Ev
174
175	0	DataTypePtr get_return_type() const override { return Data::get_return_type(); } Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EEEE15get_return_typeEv Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EEEE15get_return_typeEv Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EEEE15get_return_typeEv Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EEEE15get_return_typeEv
176
177		void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,
178	0	Arena&) const override {
179	0	this->data(place).add(columns[0], row_num);
180	0	} Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EEEE3addEPcPPKNS_7IColumnElRNS_5ArenaE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EEEE3addEPcPPKNS_7IColumnElRNS_5ArenaE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EEEE3addEPcPPKNS_7IColumnElRNS_5ArenaE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EEEE3addEPcPPKNS_7IColumnElRNS_5ArenaE
181
182	0	void reset(AggregateDataPtr __restrict place) const override { this->data(place).reset(); } Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EEEE5resetEPc Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EEEE5resetEPc Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EEEE5resetEPc Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EEEE5resetEPc
183
184		void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
185	0	Arena&) const override {
186	0	this->data(place).merge(this->data(rhs));
187	0	} Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EEEE5mergeEPcPKcRNS_5ArenaE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EEEE5mergeEPcPKcRNS_5ArenaE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EEEE5mergeEPcPKcRNS_5ArenaE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EEEE5mergeEPcPKcRNS_5ArenaE
188
189	0	void serialize(ConstAggregateDataPtr __restrict place, BufferWritable& buf) const override {
190	0	this->data(place).write(buf);
191	0	} Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EEEE9serializeEPKcRNS_14BufferWritableE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EEEE9serializeEPKcRNS_14BufferWritableE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EEEE9serializeEPKcRNS_14BufferWritableE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EEEE9serializeEPKcRNS_14BufferWritableE
192
193		void deserialize(AggregateDataPtr __restrict place, BufferReadable& buf,
194	0	Arena&) const override {
195	0	this->data(place).read(buf);
196	0	} Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EEEE11deserializeEPcRNS_14BufferReadableERNS_5ArenaE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EEEE11deserializeEPcRNS_14BufferReadableERNS_5ArenaE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EEEE11deserializeEPcRNS_14BufferReadableERNS_5ArenaE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EEEE11deserializeEPcRNS_14BufferReadableERNS_5ArenaE
197
198	0	void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
199	0	this->data(place).insert_result_into(to);
200	0	} Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EEEE18insert_result_intoEPKcRNS_7IColumnE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EEEE18insert_result_intoEPKcRNS_7IColumnE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EEEE18insert_result_intoEPKcRNS_7IColumnE Unexecuted instantiation: _ZNK5doris29AggregateFunctionSampVarianceINS_8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EEEE18insert_result_intoEPKcRNS_7IColumnE
201		};
202
203		} // namespace doris