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 {
#include "common/compile_check_begin.h"
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
        : 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

#include "common/compile_check_end.h"

Coverage Report

Created: 2026-03-12 17:15

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