Skip to content

[env](compiler) Reduce compile time of aggregate_function_reader_replace.cpp #62047

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
BiteTheDDDDt merged 2 commits into from
Apr 3, 2026
Merged

[env](compiler) Reduce compile time of aggregate_function_reader_replace.cpp #62047

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
99cd41e
upd
Mryange Apr 2, 2026
014d8ab
fix
Mryange Apr 2, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
304 changes: 1 addition & 303 deletions be/src/exprs/aggregate/aggregate_function_reader_first_last.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,17 +19,7 @@

#include <type_traits>

#include "core/column/column_array.h"
#include "core/column/column_map.h"
#include "core/column/column_nullable.h"
#include "core/column/column_struct.h"
#include "core/column/column_variant.h"
#include "core/column/column_vector.h"
#include "core/data_type/data_type_decimal.h"
#include "core/data_type/data_type_nullable.h"
#include "core/data_type/data_type_string.h"
#include "exprs/aggregate/aggregate_function.h"
#include "exprs/function/function.h"

namespace doris {
#include "common/compile_check_begin.h"
Expand Down Expand Up @@ -177,297 +167,5 @@ struct ReaderFirstAndLastData {
bool _has_value = false;
};

template <typename ColVecType, bool result_is_nullable, bool arg_is_nullable, bool is_copy>
struct ReaderFunctionFirstData
: ReaderFirstAndLastData<ColVecType, result_is_nullable, arg_is_nullable, is_copy> {
void add(int64_t row, const IColumn** columns) {
if (this->has_set_value()) {
return;
}
this->set_value(columns, row);
}
static const char* name() { return "first_value"; }
};

template <typename ColVecType, bool result_is_nullable, bool arg_is_nullable, bool is_copy>
struct ReaderFunctionFirstNonNullData
: ReaderFirstAndLastData<ColVecType, result_is_nullable, arg_is_nullable, is_copy> {
void add(int64_t row, const IColumn** columns) {
if (this->has_set_value()) {
return;
}
if constexpr (ReaderFirstAndLastData<ColVecType, result_is_nullable, arg_is_nullable,
is_copy>::nullable) {
const auto* nullable_column =
assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(columns[0]);
if (nullable_column->is_null_at(row)) {
return;
}
}
this->set_value(columns, row);
}
static const char* name() { return "first_non_null_value"; }
};

template <typename ColVecType, bool result_is_nullable, bool arg_is_nullable, bool is_copy>
struct ReaderFunctionLastData
: ReaderFirstAndLastData<ColVecType, result_is_nullable, arg_is_nullable, is_copy> {
void add(int64_t row, const IColumn** columns) { this->set_value(columns, row); }
static const char* name() { return "last_value"; }
};

template <typename ColVecType, bool result_is_nullable, bool arg_is_nullable, bool is_copy>
struct ReaderFunctionLastNonNullData
: ReaderFirstAndLastData<ColVecType, result_is_nullable, arg_is_nullable, is_copy> {
void add(int64_t row, const IColumn** columns) {
if constexpr (ReaderFirstAndLastData<ColVecType, result_is_nullable, arg_is_nullable,
is_copy>::nullable) {
const auto* nullable_column =
assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(columns[0]);
if (nullable_column->is_null_at(row)) {
return;
}
}
this->set_value(columns, row);
}

static const char* name() { return "last_non_null_value"; }
};

template <typename Data>
class ReaderFunctionData final
: public IAggregateFunctionDataHelper<Data, ReaderFunctionData<Data>> {
public:
ReaderFunctionData(const DataTypes& argument_types_)
: IAggregateFunctionDataHelper<Data, ReaderFunctionData<Data>>(argument_types_),
_argument_type(argument_types_[0]) {}

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

DataTypePtr get_return_type() const override {
if constexpr (Data::result_nullable) {
return make_nullable(_argument_type);
} else {
return _argument_type;
}
}

void insert_result_into(ConstAggregateDataPtr place, IColumn& to) const override {
this->data(place).insert_result_into(to);
}

void add(AggregateDataPtr place, const IColumn** columns, ssize_t row_num,
Arena&) const override {
this->data(place).add(row_num, columns);
}

void reset(AggregateDataPtr place) const override { this->data(place).reset(); }

void add_range_single_place(int64_t partition_start, int64_t partition_end, int64_t frame_start,
int64_t frame_end, AggregateDataPtr place, const IColumn** columns,
Arena& arena, UInt8*, UInt8*) const override {
throw doris::Exception(
Status::FatalError("ReaderFunctionData do not support add_range_single_place"));
}
void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena&) const override {
throw doris::Exception(Status::FatalError("ReaderFunctionData do not support merge"));
}
void serialize(ConstAggregateDataPtr place, BufferWritable& buf) const override {
throw doris::Exception(Status::FatalError("ReaderFunctionData do not support serialize"));
}
void deserialize(AggregateDataPtr place, BufferReadable& buf, Arena&) const override {
throw doris::Exception(Status::FatalError("ReaderFunctionData do not support deserialize"));
}

private:
DataTypePtr _argument_type;
};

template <template <typename, bool, bool, bool> class FunctionData, bool result_is_nullable,
bool arg_is_nullable, bool is_copy = false>
AggregateFunctionPtr create_function_single_value(const String& name,
const DataTypes& argument_types) {
switch (argument_types[0]->get_primitive_type()) {
case PrimitiveType::TYPE_BOOLEAN: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnUInt8, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_TINYINT: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnInt8, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_SMALLINT: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnInt16, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_INT: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnInt32, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_BIGINT: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnInt64, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_LARGEINT: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnInt128, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_FLOAT: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnFloat32, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DOUBLE: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnFloat64, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DECIMAL32: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnDecimal32, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DECIMAL64: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnDecimal64, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DECIMAL128I: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnDecimal128V3, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DECIMALV2: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnDecimal128V2, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DECIMAL256: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnDecimal256, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_STRING:
case PrimitiveType::TYPE_CHAR:
case PrimitiveType::TYPE_VARCHAR:
case PrimitiveType::TYPE_JSONB: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnString, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DATE: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnDate, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DATETIME: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnDateTime, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DATETIMEV2: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnDateTimeV2, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_TIMESTAMPTZ: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnTimeStampTz, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_DATEV2: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnDateV2, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_IPV4: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnIPv4, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_IPV6: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnIPv6, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_ARRAY: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnArray, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_MAP: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnMap, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_STRUCT: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnStruct, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_VARIANT: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnVariant, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_BITMAP: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnBitmap, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_HLL: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnHLL, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
case PrimitiveType::TYPE_QUANTILE_STATE: {
return std::make_shared<ReaderFunctionData<
FunctionData<ColumnQuantileState, result_is_nullable, arg_is_nullable, is_copy>>>(
argument_types);
}
default:
LOG(WARNING) << "with unknowed type, failed in create_aggregate_function_" << name
<< " and type is: " << argument_types[0]->get_name();
return nullptr;
}
}

#define CREATE_READER_FUNCTION_WITH_NAME_AND_DATA(CREATE_FUNCTION_NAME, FUNCTION_DATA) \
template <bool is_copy> \
AggregateFunctionPtr CREATE_FUNCTION_NAME( \
const std::string& name, const DataTypes& argument_types, \
const DataTypePtr& result_type, bool result_is_nullable, \
const AggregateFunctionAttr& attr) { \
const bool arg_is_nullable = argument_types[0]->is_nullable(); \
AggregateFunctionPtr res = nullptr; \
std::visit( \
[&](auto result_is_nullable, auto arg_is_nullable) { \
res = AggregateFunctionPtr( \
create_function_single_value<FUNCTION_DATA, result_is_nullable, \
arg_is_nullable, is_copy>( \
name, argument_types)); \
}, \
make_bool_variant(result_is_nullable), make_bool_variant(arg_is_nullable)); \
if (!res) { \
LOG(WARNING) << " failed in create_aggregate_function_" << name \
<< " and type is: " << argument_types[0]->get_name(); \
} \
return res; \
}

CREATE_READER_FUNCTION_WITH_NAME_AND_DATA(create_aggregate_function_first, ReaderFunctionFirstData);
CREATE_READER_FUNCTION_WITH_NAME_AND_DATA(create_aggregate_function_first_non_null_value,
ReaderFunctionFirstNonNullData);
CREATE_READER_FUNCTION_WITH_NAME_AND_DATA(create_aggregate_function_last, ReaderFunctionLastData);
CREATE_READER_FUNCTION_WITH_NAME_AND_DATA(create_aggregate_function_last_non_null_value,
ReaderFunctionLastNonNullData);
#undef CREATE_READER_FUNCTION_WITH_NAME_AND_DATA

} // namespace doris
#include "common/compile_check_end.h"
#include "common/compile_check_end.h"
Loading
Loading