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 <memory>
#include <type_traits>

#include "core/assert_cast.h"
#include "core/column/column.h"
#include "core/column/column_nullable.h"
#include "core/data_type/data_type_decimal.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 ColumnDecimal;
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::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 {
    using ColVecResult = std::conditional_t<is_decimal(T), ColumnDecimal128V2, ColumnFloat64>;
    void insert_result_into(IColumn& to) const {
        auto& col = assert_cast<ColVecResult&>(to);
        if constexpr (is_decimal(T)) {
            col.get_data().push_back(this->get_pop_result().value());
        } else {
            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 {
    using ColVecResult = std::conditional_t<is_decimal(T), ColumnDecimal128V2, ColumnFloat64>;
    void insert_result_into(IColumn& to) const {
        auto& col = assert_cast<ColVecResult&>(to);
        if (this->count == 1 || this->count == 0) {
            col.insert_default();
        } else {
            if constexpr (is_decimal(T)) {
                col.get_data().push_back(this->get_samp_result().value());
            } 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-04-24 20:42

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 <memory>
25		#include <type_traits>
26
27		#include "core/assert_cast.h"
28		#include "core/column/column.h"
29		#include "core/column/column_nullable.h"
30		#include "core/data_type/data_type_decimal.h"
31		#include "core/data_type/data_type_number.h"
32		#include "core/types.h"
33		#include "exprs/aggregate/aggregate_function.h"
34
35		namespace doris {
36		class Arena;
37		class BufferReadable;
38		class BufferWritable;
39		template <PrimitiveType T>
40		class ColumnDecimal;
41		template <PrimitiveType T>
42		class ColumnVector;
43
44		template <PrimitiveType T, bool is_stddev>
45		struct BaseData {
46	0	BaseData() = default; Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EEC2Ev Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EEC2Ev
47	0	virtual ~BaseData() = default; Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EED2Ev Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EED2Ev
48
49	0	void write(BufferWritable& buf) const {
50	0	buf.write_binary(mean);
51	0	buf.write_binary(m2);
52	0	buf.write_binary(count);
53	0	} Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE5writeERNS_14BufferWritableE Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE5writeERNS_14BufferWritableE
54
55	0	void read(BufferReadable& buf) {
56	0	buf.read_binary(mean);
57	0	buf.read_binary(m2);
58	0	buf.read_binary(count);
59	0	} Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE4readERNS_14BufferReadableE Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE4readERNS_14BufferReadableE
60
61	0	void reset() {
62	0	mean = 0.0;
63	0	m2 = 0.0;
64	0	count = 0;
65	0	} Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE5resetEv Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE5resetEv
66
67	0	double get_result(double res) const {
68	0	auto inf_to_nan = [](double val) {
69		// This function performs squaring operations, and due to differences in computation order,
70		// it might produce different values such as inf and nan.
71		// In MySQL, this will directly result in an error due to exceeding the double range.
72		// For performance reasons, we are uniformly changing it to nan
73	0	if (std::isinf(val)) {
74	0	return std::nan("");
75	0	}
76	0	return val;
77	0	}; Unexecuted instantiation: _ZZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE10get_resultEdENKUldE_clEd Unexecuted instantiation: _ZZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE10get_resultEdENKUldE_clEd
78	0	if constexpr (is_stddev) {
79	0	return inf_to_nan(std::sqrt(res));
80	0	} else {
81	0	return inf_to_nan(res);
82	0	}
83	0	} Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE10get_resultEd Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE10get_resultEd
84
85	0	double get_pop_result() const {
86	0	if (count == 1) {
87	0	return 0.0;
88	0	}
89	0	double res = m2 / (double)count;
90	0	return get_result(res);
91	0	} Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE14get_pop_resultEv Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE14get_pop_resultEv
92
93	0	double get_samp_result() const {
94	0	double res = m2 / double(count - 1);
95	0	return get_result(res);
96	0	} Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE15get_samp_resultEv Unexecuted instantiation: _ZNK5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE15get_samp_resultEv
97
98	0	void merge(const BaseData& rhs) {
99	0	if (rhs.count == 0) {
100	0	return;
101	0	}
102	0	double delta = mean - rhs.mean;
103	0	double sum_count = double(count + rhs.count);
104	0	mean = rhs.mean + delta * (double)count / sum_count;
105	0	m2 = rhs.m2 + m2 + (delta * delta) * (double)rhs.count * (double)count / sum_count;
106	0	count = int64_t(sum_count);
107	0	} Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE5mergeERKS2_ Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE5mergeERKS2_
108
109	0	void add(const IColumn* column, size_t row_num) {
110	0	const auto& sources = assert_cast<const typename PrimitiveTypeTraits<T>::ColumnType&,
111	0	TypeCheckOnRelease::DISABLE>(*column);
112	0	double source_data = (double)sources.get_data()[row_num];
113
114	0	double delta = source_data - mean;
115	0	double r = delta / double(1 + count);
116	0	mean += r;
117	0	m2 += (double)count * delta * r;
118	0	count += 1;
119	0	} Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb0EE3addEPKNS_7IColumnEm Unexecuted instantiation: _ZN5doris8BaseDataILNS_13PrimitiveTypeE9ELb1EE3addEPKNS_7IColumnEm
120
121		double mean {};
122		double m2 {};
123		int64_t count {};
124		};
125
126		template <PrimitiveType T, typename Name, bool is_stddev>
127		struct PopData : BaseData<T, is_stddev>, Name {
128		using ColVecResult = std::conditional_t<is_decimal(T), ColumnDecimal128V2, ColumnFloat64>;
129	0	void insert_result_into(IColumn& to) const {
130	0	auto& col = assert_cast<ColVecResult&>(to);
131		if constexpr (is_decimal(T)) {
132		col.get_data().push_back(this->get_pop_result().value());
133	0	} else {
134	0	col.get_data().push_back(this->get_pop_result());
135	0	}
136	0	} Unexecuted instantiation: _ZNK5doris7PopDataILNS_13PrimitiveTypeE9ENS_12VarianceNameELb0EE18insert_result_intoERNS_7IColumnE Unexecuted instantiation: _ZNK5doris7PopDataILNS_13PrimitiveTypeE9ENS_10StddevNameELb1EE18insert_result_intoERNS_7IColumnE
137
138	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
139		};
140
141		// For this series of functions, the Decimal type is not supported
142		// because the operations involve squaring,
143		// which can easily exceed the range of the Decimal type.
144
145		template <PrimitiveType T, typename Name, bool is_stddev>
146		struct SampData : BaseData<T, is_stddev>, Name {
147		using ColVecResult = std::conditional_t<is_decimal(T), ColumnDecimal128V2, ColumnFloat64>;
148	0	void insert_result_into(IColumn& to) const {
149	0	auto& col = assert_cast<ColVecResult&>(to);
150	0	if (this->count == 1 \|\| this->count == 0) {
151	0	col.insert_default();
152	0	} else {
153		if constexpr (is_decimal(T)) {
154		col.get_data().push_back(this->get_samp_result().value());
155	0	} else {
156	0	col.get_data().push_back(this->get_samp_result());
157	0	}
158	0	}
159	0	} Unexecuted instantiation: _ZNK5doris8SampDataILNS_13PrimitiveTypeE9ENS_16VarianceSampNameELb0EE18insert_result_intoERNS_7IColumnE Unexecuted instantiation: _ZNK5doris8SampDataILNS_13PrimitiveTypeE9ENS_14StddevSampNameELb1EE18insert_result_intoERNS_7IColumnE
160
161	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
162		};
163
164		struct StddevName {
165	0	static const char* name() { return "stddev"; }
166		};
167		struct VarianceName {
168	0	static const char* name() { return "variance"; }
169		};
170		struct VarianceSampName {
171	0	static const char* name() { return "variance_samp"; }
172		};
173		struct StddevSampName {
174	0	static const char* name() { return "stddev_samp"; }
175		};
176
177		template <typename Data>
178		class AggregateFunctionSampVariance final
179		: public IAggregateFunctionDataHelper<Data, AggregateFunctionSampVariance<Data>>,
180		UnaryExpression,
181		NullableAggregateFunction {
182		public:
183		AggregateFunctionSampVariance(const DataTypes& argument_types_)
184	0	: IAggregateFunctionDataHelper<Data, AggregateFunctionSampVariance<Data>>(
185	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
186
187	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
188
189	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
190
191		void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,
192	0	Arena&) const override {
193	0	this->data(place).add(columns[0], row_num);
194	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
195
196	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
197
198		void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
199	0	Arena&) const override {
200	0	this->data(place).merge(this->data(rhs));
201	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
202
203	0	void serialize(ConstAggregateDataPtr __restrict place, BufferWritable& buf) const override {
204	0	this->data(place).write(buf);
205	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
206
207		void deserialize(AggregateDataPtr __restrict place, BufferReadable& buf,
208	0	Arena&) const override {
209	0	this->data(place).read(buf);
210	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
211
212	0	void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
213	0	this->data(place).insert_result_into(to);
214	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
215		};
216
217		} // namespace doris