database/doris
2
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

[refactor] add some clang-tidy checks && some code style fix (#8752)

Browse Source
This commit is contained in:
Pxl
2022-03-31 13:53:41 +08:00
committed by GitHub
parent 09409e4f96
commit d24735e95a
23 changed files with 282 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
.clang-tidy
View File

@ -13,5 +13,13 @@ Checks: |
readability-non-const-parameter,
readability-static-accessed-through-instance,
readability-redundant-smartptr-get,
readability-redundant-string-init
readability-redundant-member-init,
readability-redundant-string-cstr,
readability-redundant-string-init,
readability-braces-around-statements,
portability-simd-intrinsics,
performance-type-promotion-in-math-fn,
performance-faster-string-find,
performance-inefficient-algorithm,
performance-move-const-arg
WarningsAsErrors: '*'

11
be/src/vec/aggregate_functions/aggregate_function.h
View File

@ -57,7 +57,7 @@ public:
/// Get the result type.
virtual DataTypePtr get_return_type() const = 0;
virtual ~IAggregateFunction() {}
virtual ~IAggregateFunction() = default;
/** Create empty data for aggregation with `placement new` at the specified location.
* You will have to destroy them using the `destroy` method.
@ -147,14 +147,16 @@ public:
void add_batch(size_t batch_size, AggregateDataPtr* places, size_t place_offset,
const IColumn** columns, Arena* arena) const override {
for (size_t i = 0; i < batch_size; ++i)
for (size_t i = 0; i < batch_size; ++i) {
static_cast<const Derived*>(this)->add(places[i] + place_offset, columns, i, arena);
}
}
void add_batch_single_place(size_t batch_size, AggregateDataPtr place, const IColumn** columns,
Arena* arena) const override {
for (size_t i = 0; i < batch_size; ++i)
for (size_t i = 0; i < batch_size; ++i) {
static_cast<const Derived*>(this)->add(place, columns, i, arena);
}
}
//now this is use for sum/count/avg/min/max win function, other win function should override this function in class
void add_range_single_place(int64_t partition_start, int64_t partition_end, int64_t frame_start,
@ -169,8 +171,9 @@ public:
void add_batch_range(size_t batch_begin, size_t batch_end, AggregateDataPtr place,
const IColumn** columns, Arena* arena, bool has_null) override {
for (size_t i = batch_begin; i <= batch_end; ++i)
for (size_t i = batch_begin; i <= batch_end; ++i) {
static_cast<const Derived*>(this)->add(place, columns, i, arena);
}
}
};

2
be/src/vec/aggregate_functions/aggregate_function_approx_count_distinct.cpp
View File

@ -31,7 +31,7 @@ AggregateFunctionPtr create_aggregate_function_approx_count_distinct(
: argument_types[0]);
res.reset(create_class_with_type<AggregateFunctionApproxCountDistinct>(*argument_types[0],
argument_types));
argument_types));
if (!res) {
LOG(WARNING) << fmt::format("Illegal type {} of argument for aggregate function {}",

5
be/src/vec/aggregate_functions/aggregate_function_avg.cpp
View File

@ -45,11 +45,12 @@ AggregateFunctionPtr create_aggregate_function_avg(const std::string& name,
AggregateFunctionPtr res;
DataTypePtr data_type = argument_types[0];
if (is_decimal(data_type))
if (is_decimal(data_type)) {
res.reset(
create_with_decimal_type<AggregateFuncAvg>(*data_type, *data_type, argument_types));
else
} else {
res.reset(create_with_numeric_type<AggregateFuncAvg>(*data_type, argument_types));
}
if (!res) {
LOG(WARNING) << fmt::format("Illegal type {} of argument for aggregate function {}",

11
be/src/vec/aggregate_functions/aggregate_function_avg.h
View File

@ -36,9 +36,11 @@ struct AggregateFunctionAvgData {
template <typename ResultT>
ResultT result() const {
if constexpr (std::is_floating_point_v<ResultT>)
if constexpr (std::numeric_limits<ResultT>::is_iec559)
if constexpr (std::is_floating_point_v<ResultT>) {
if constexpr (std::numeric_limits<ResultT>::is_iec559) {
return static_cast<ResultT>(sum) / count; /// allow division by zero
}
}
if (!count) {
// null is handled in AggregationNode::_get_without_key_result
@ -85,10 +87,11 @@ public:
String get_name() const override { return "avg"; }
DataTypePtr get_return_type() const override {
if constexpr (IsDecimalNumber<T>)
if constexpr (IsDecimalNumber<T>) {
return std::make_shared<ResultDataType>(ResultDataType::max_precision(), scale);
else
} else {
return std::make_shared<ResultDataType>();
}
}
void add(AggregateDataPtr __restrict place, const IColumn** columns, size_t row_num,

12
be/src/vec/aggregate_functions/aggregate_function_bitmap.cpp
View File

@ -28,14 +28,18 @@ static IAggregateFunction* createWithIntDataType(const DataTypes& argument_type)
type = assert_cast<const DataTypeNullable*>(type)->get_nested_type().get();
}
WhichDataType which(type);
if (which.idx == TypeIndex::Int8)
if (which.idx == TypeIndex::Int8) {
return new AggregateFunctionTemplate<nullable, ColumnVector<Int8>>(argument_type);
if (which.idx == TypeIndex::Int16)
}
if (which.idx == TypeIndex::Int16) {
return new AggregateFunctionTemplate<nullable, ColumnVector<Int16>>(argument_type);
if (which.idx == TypeIndex::Int32)
}
if (which.idx == TypeIndex::Int32) {
return new AggregateFunctionTemplate<nullable, ColumnVector<Int32>>(argument_type);
if (which.idx == TypeIndex::Int64)
}
if (which.idx == TypeIndex::Int64) {
return new AggregateFunctionTemplate<nullable, ColumnVector<Int64>>(argument_type);
}
return nullptr;
}

2
be/src/vec/aggregate_functions/aggregate_function_combinator.h
View File

@ -73,7 +73,7 @@ public:
const AggregateFunctionPtr& nested_function, const DataTypes& arguments,
const Array& params, const bool result_is_nullable) const = 0;
virtual ~IAggregateFunctionCombinator() {}
virtual ~IAggregateFunctionCombinator() = default;
};
} // namespace doris::vectorized

4
be/src/vec/aggregate_functions/aggregate_function_count.h
View File

@ -50,7 +50,9 @@ public:
++data(place).count;
}
void reset(AggregateDataPtr place) const override { this->data(place).count = 0; }
void reset(AggregateDataPtr place) const override {
AggregateFunctionCount::data(place).count = 0;
}
void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
Arena*) const override {

28
be/src/vec/aggregate_functions/aggregate_function_distinct.cpp
View File

@ -18,11 +18,12 @@
// https://github.com/ClickHouse/ClickHouse/blob/master/src/AggregateFunctions/AggregateFunctionDistinct.cpp
// and modified by Doris
#include "vec/aggregate_functions/aggregate_function_distinct.h"
#include <algorithm>
#include <boost/algorithm/string.hpp>
#include "vec/aggregate_functions/aggregate_function_combinator.h"
#include "vec/aggregate_functions/aggregate_function_distinct.h"
#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
#include "vec/aggregate_functions/helpers.h"
#include "vec/common/typeid_cast.h"
@ -42,29 +43,33 @@ public:
return arguments;
}
AggregateFunctionPtr transform_aggregate_function(const AggregateFunctionPtr& nested_function,
const DataTypes& arguments,
const Array& params,
const bool result_is_nullable) const override {
AggregateFunctionPtr transform_aggregate_function(
const AggregateFunctionPtr& nested_function, const DataTypes& arguments,
const Array& params, const bool result_is_nullable) const override {
DCHECK(nested_function != nullptr);
if (nested_function == nullptr) return nullptr;
if (nested_function == nullptr) {
return nullptr;
}
AggregateFunctionPtr res;
if (arguments.size() == 1) {
res.reset(create_with_numeric_type<AggregateFunctionDistinct,
AggregateFunctionDistinctSingleNumericData>(
*arguments[0], nested_function, arguments));
if (res) return res;
if (res) {
return res;
}
if (arguments[0]->is_value_unambiguously_represented_in_contiguous_memory_region())
if (arguments[0]->is_value_unambiguously_represented_in_contiguous_memory_region()) {
return std::make_shared<AggregateFunctionDistinct<
AggregateFunctionDistinctSingleGenericData<true>>>(nested_function,
arguments);
else
} else {
return std::make_shared<AggregateFunctionDistinct<
AggregateFunctionDistinctSingleGenericData<false>>>(nested_function,
arguments);
}
}
return std::make_shared<
@ -89,7 +94,8 @@ void register_aggregate_function_combinator_distinct(AggregateFunctionSimpleFact
}
auto nested_function_name = name.substr(DISTINCT_FUNCTION_PREFIX.size());
auto nested_function = factory.get(nested_function_name, transform_arguments, params);
return function_combinator->transform_aggregate_function(nested_function, types, params, result_is_nullable);
return function_combinator->transform_aggregate_function(nested_function, types, params,
result_is_nullable);
};
factory.register_distinct_function_combinator(creator, DISTINCT_FUNCTION_PREFIX);
}

24
be/src/vec/aggregate_functions/aggregate_function_distinct.h
View File

@ -53,7 +53,9 @@ struct AggregateFunctionDistinctSingleNumericData {
MutableColumns get_arguments(const DataTypes& argument_types) const {
MutableColumns argument_columns;
argument_columns.emplace_back(argument_types[0]->create_column());
for (const auto& elem : set) argument_columns[0]->insert(elem.get_value());
for (const auto& elem : set) {
argument_columns[0]->insert(elem.get_value());
}
return argument_columns;
}
@ -68,13 +70,16 @@ struct AggregateFunctionDistinctGenericData {
void merge(const Self& rhs, Arena* arena) {
Set::LookupResult it;
bool inserted;
for (const auto& elem : rhs.set)
for (const auto& elem : rhs.set) {
set.emplace(ArenaKeyHolder {elem.get_value(), *arena}, it, inserted);
}
}
void serialize(BufferWritable& buf) const {
write_var_uint(set.size(), buf);
for (const auto& elem : set) write_string_binary(elem.get_value(), buf);
for (const auto& elem : set) {
write_string_binary(elem.get_value(), buf);
}
}
void deserialize(BufferReadable& buf, Arena* arena) {
@ -101,8 +106,9 @@ struct AggregateFunctionDistinctSingleGenericData : public AggregateFunctionDist
MutableColumns get_arguments(const DataTypes& argument_types) const {
MutableColumns argument_columns;
argument_columns.emplace_back(argument_types[0]->create_column());
for (const auto& elem : set)
for (const auto& elem : set) {
deserialize_and_insert<is_plain_column>(elem.get_value(), *argument_columns[0]);
}
return argument_columns;
}
@ -126,13 +132,15 @@ struct AggregateFunctionDistinctMultipleGenericData : public AggregateFunctionDi
MutableColumns get_arguments(const DataTypes& argument_types) const {
MutableColumns argument_columns(argument_types.size());
for (size_t i = 0; i < argument_types.size(); ++i)
for (size_t i = 0; i < argument_types.size(); ++i) {
argument_columns[i] = argument_types[i]->create_column();
}
for (const auto& elem : set) {
const char* begin = elem.get_value().data;
for (auto& column : argument_columns)
for (auto& column : argument_columns) {
begin = column->deserialize_and_insert_from_arena(begin);
}
}
return argument_columns;
@ -189,7 +197,9 @@ public:
auto place = const_cast<AggregateDataPtr>(targetplace);
auto arguments = this->data(place).get_arguments(this->argument_types);
ColumnRawPtrs arguments_raw(arguments.size());
for (size_t i = 0; i < arguments.size(); ++i) arguments_raw[i] = arguments[i].get();
for (size_t i = 0; i < arguments.size(); ++i) {
arguments_raw[i] = arguments[i].get();
}
assert(!arguments.empty());
// nested_func->add_batch_single_place(arguments[0]->size(), get_nested_place(place), arguments_raw.data(), arena);

73
be/src/vec/aggregate_functions/aggregate_function_min_max.h
View File

@ -43,10 +43,11 @@ public:
bool has() const { return has_value; }
void insert_result_into(IColumn& to) const {
if (has())
if (has()) {
assert_cast<ColumnVector<T>&>(to).get_data().push_back(value);
else
} else {
assert_cast<ColumnVector<T>&>(to).insert_default();
}
}
void reset() {
@ -57,12 +58,16 @@ public:
void write(BufferWritable& buf) const {
write_binary(has(), buf);
if (has()) write_binary(value, buf);
if (has()) {
write_binary(value, buf);
}
}
void read(BufferReadable& buf) {
read_binary(has_value, buf);
if (has()) read_binary(value, buf);
if (has()) {
read_binary(value, buf);
}
}
void change(const IColumn& column, size_t row_num, Arena*) {
@ -80,32 +85,36 @@ public:
if (!has() || assert_cast<const ColumnVector<T>&>(column).get_data()[row_num] < value) {
change(column, row_num, arena);
return true;
} else
} else {
return false;
}
}
bool change_if_less(const Self& to, Arena* arena) {
if (to.has() && (!has() || to.value < value)) {
change(to, arena);
return true;
} else
} else {
return false;
}
}
bool change_if_greater(const IColumn& column, size_t row_num, Arena* arena) {
if (!has() || assert_cast<const ColumnVector<T>&>(column).get_data()[row_num] > value) {
change(column, row_num, arena);
return true;
} else
} else {
return false;
}
}
bool change_if_greater(const Self& to, Arena* arena) {
if (to.has() && (!has() || to.value > value)) {
change(to, arena);
return true;
} else
} else {
return false;
}
}
bool is_equal_to(const Self& to) const { return has() && to.value == value; }
@ -132,8 +141,9 @@ public:
if (has()) {
DecimalV2Value decimal(value);
assert_cast<ColumnDecimal<Decimal128>&>(to).insert_data((const char*)&decimal, 0);
} else
} else {
assert_cast<ColumnDecimal<Decimal128>&>(to).insert_default();
}
}
void reset() {
@ -144,12 +154,16 @@ public:
void write(BufferWritable& buf) const {
write_binary(has(), buf);
if (has()) write_binary(value, buf);
if (has()) {
write_binary(value, buf);
}
}
void read(BufferReadable& buf) {
read_binary(has_value, buf);
if (has()) read_binary(value, buf);
if (has()) {
read_binary(value, buf);
}
}
void change(const IColumn& column, size_t row_num, Arena*) {
@ -168,16 +182,18 @@ public:
assert_cast<const ColumnDecimal<Decimal128>&>(column).get_data()[row_num] < value) {
change(column, row_num, arena);
return true;
} else
} else {
return false;
}
}
bool change_if_less(const Self& to, Arena* arena) {
if (to.has() && (!has() || to.value < value)) {
change(to, arena);
return true;
} else
} else {
return false;
}
}
bool change_if_greater(const IColumn& column, size_t row_num, Arena* arena) {
@ -185,16 +201,18 @@ public:
assert_cast<const ColumnDecimal<Decimal128>&>(column).get_data()[row_num] > value) {
change(column, row_num, arena);
return true;
} else
} else {
return false;
}
}
bool change_if_greater(const Self& to, Arena* arena) {
if (to.has() && (!has() || to.value > value)) {
change(to, arena);
return true;
} else
} else {
return false;
}
}
bool is_equal_to(const Self& to) const { return has() && to.value == value; }
@ -232,10 +250,11 @@ public:
const char* get_data() const { return size <= MAX_SMALL_STRING_SIZE ? small_data : large_data; }
void insert_result_into(IColumn& to) const {
if (has())
if (has()) {
assert_cast<ColumnString&>(to).insert_data(get_data(), size);
else
} else {
assert_cast<ColumnString&>(to).insert_default();
}
}
void reset() {
@ -249,7 +268,9 @@ public:
void write(BufferWritable& buf) const {
write_binary(size, buf);
if (has()) buf.write(get_data(), size);
if (has()) {
buf.write(get_data(), size);
}
}
void read(BufferReadable& buf) {
@ -262,7 +283,9 @@ public:
size = rhs_size;
if (size > 0) buf.read(small_data, size);
if (size > 0) {
buf.read(small_data, size);
}
} else {
if (capacity < rhs_size) {
capacity = static_cast<UInt32>(round_up_to_power_of_two_or_zero(rhs_size));
@ -316,8 +339,9 @@ public:
assert_cast<const ColumnString&>(column).get_data_at(row_num) < get_string_ref()) {
change(column, row_num, arena);
return true;
} else
} else {
return false;
}
}
bool change_if_greater(const IColumn& column, size_t row_num, Arena* arena) {
@ -325,24 +349,27 @@ public:
assert_cast<const ColumnString&>(column).get_data_at(row_num) > get_string_ref()) {
change(column, row_num, arena);
return true;
} else
} else {
return false;
}
}
bool change_if_less(const Self& to, Arena* arena) {
if (to.has() && (!has() || to.get_string_ref() < get_string_ref())) {
change(to, arena);
return true;
} else
} else {
return false;
}
}
bool change_if_greater(const Self& to, Arena* arena) {
if (to.has() && (!has() || to.get_string_ref() > get_string_ref())) {
change(to, arena);
return true;
} else
} else {
return false;
}
}
bool is_equal_to(const Self& to) const {

32
be/src/vec/aggregate_functions/aggregate_function_null.cpp
View File

@ -39,15 +39,18 @@ public:
DataTypes transform_arguments(const DataTypes& arguments) const override {
size_t size = arguments.size();
DataTypes res(size);
for (size_t i = 0; i < size; ++i) res[i] = remove_nullable(arguments[i]);
for (size_t i = 0; i < size; ++i) {
res[i] = remove_nullable(arguments[i]);
}
return res;
}
AggregateFunctionPtr transform_aggregate_function(const AggregateFunctionPtr& nested_function,
const DataTypes& arguments,
const Array& params,
const bool result_is_nullable) const override {
if (nested_function == nullptr) return nullptr;
AggregateFunctionPtr transform_aggregate_function(
const AggregateFunctionPtr& nested_function, const DataTypes& arguments,
const Array& params, const bool result_is_nullable) const override {
if (nested_function == nullptr) {
return nullptr;
}
bool has_null_types = false;
for (const auto& arg_type : arguments) {
@ -57,22 +60,26 @@ public:
}
}
if (has_null_types) return std::make_shared<AggregateFunctionNothing>(arguments, params);
if (has_null_types) {
return std::make_shared<AggregateFunctionNothing>(arguments, params);
}
if (arguments.size() == 1) {
if (result_is_nullable)
if (result_is_nullable) {
return std::make_shared<AggregateFunctionNullUnary<true>>(nested_function,
arguments, params);
else
} else {
return std::make_shared<AggregateFunctionNullUnary<false>>(nested_function,
arguments, params);
}
} else {
if (result_is_nullable)
if (result_is_nullable) {
return std::make_shared<AggregateFunctionNullVariadic<true>>(nested_function,
arguments, params);
else
} else {
return std::make_shared<AggregateFunctionNullVariadic<false>>(nested_function,
arguments, params);
}
}
}
};
@ -84,7 +91,8 @@ void register_aggregate_function_combinator_null(AggregateFunctionSimpleFactory&
auto function_combinator = std::make_shared<AggregateFunctionCombinatorNull>();
auto transform_arguments = function_combinator->transform_arguments(types);
auto nested_function = factory.get(name, transform_arguments, params);
return function_combinator->transform_aggregate_function(nested_function, types, params, result_is_nullable);
return function_combinator->transform_aggregate_function(nested_function, types, params,
result_is_nullable);
};
factory.register_nullable_function_combinator(creator);
}

33
be/src/vec/aggregate_functions/aggregate_function_null.h
View File

@ -62,15 +62,19 @@ protected:
}
static void init_flag(AggregateDataPtr __restrict place) noexcept {
if constexpr (result_is_nullable) place[0] = 0;
if constexpr (result_is_nullable) {
place[0] = false;
}
}
static void set_flag(AggregateDataPtr __restrict place) noexcept {
if constexpr (result_is_nullable) place[0] = 1;
if constexpr (result_is_nullable) {
place[0] = true;
}
}
static bool get_flag(ConstAggregateDataPtr __restrict place) noexcept {
return result_is_nullable ? place[0] : 1;
return result_is_nullable ? place[0] : true;
}
public:
@ -78,10 +82,11 @@ public:
const Array& params)
: IAggregateFunctionHelper<Derived>(arguments, params),
nested_function {nested_function_} {
if (result_is_nullable)
if (result_is_nullable) {
prefix_size = nested_function->align_of_data();
else
} else {
prefix_size = 0;
}
}
String get_name() const override {
@ -117,14 +122,18 @@ public:
void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
Arena* arena) const override {
if (result_is_nullable && get_flag(rhs)) set_flag(place);
if (result_is_nullable && get_flag(rhs)) {
set_flag(place);
}
nested_function->merge(nested_place(place), nested_place(rhs), arena);
}
void serialize(ConstAggregateDataPtr __restrict place, BufferWritable& buf) const override {
bool flag = get_flag(place);
if (result_is_nullable) write_binary(flag, buf);
if (result_is_nullable) {
write_binary(flag, buf);
}
if (flag) {
nested_function->serialize(nested_place(place), buf);
}
@ -133,7 +142,9 @@ public:
void deserialize(AggregateDataPtr __restrict place, BufferReadable& buf,
Arena* arena) const override {
bool flag = true;
if (result_is_nullable) read_binary(flag, buf);
if (result_is_nullable) {
read_binary(flag, buf);
}
if (flag) {
set_flag(place);
nested_function->deserialize(nested_place(place), buf, arena);
@ -248,8 +259,9 @@ public:
size_t(MAX_ARGS));
}
for (size_t i = 0; i < number_of_arguments; ++i)
for (size_t i = 0; i < number_of_arguments; ++i) {
is_nullable[i] = arguments[i]->is_nullable();
}
}
void add(AggregateDataPtr __restrict place, const IColumn** columns, size_t row_num,
@ -267,8 +279,9 @@ public:
return;
}
nested_columns[i] = &nullable_col.get_nested_column();
} else
} else {
nested_columns[i] = columns[i];
}
}
this->set_flag(place);

28
be/src/vec/aggregate_functions/aggregate_function_percentile_approx.h
View File

@ -124,25 +124,28 @@ public:
return make_nullable(std::make_shared<DataTypeFloat64>());
}
void reset(AggregateDataPtr __restrict place) const override { this->data(place).reset(); }
void reset(AggregateDataPtr __restrict place) const override {
AggregateFunctionPercentileApprox::data(place).reset();
}
void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
Arena*) const override {
this->data(place).merge(this->data(rhs));
AggregateFunctionPercentileApprox::data(place).merge(
AggregateFunctionPercentileApprox::data(rhs));
}
void serialize(ConstAggregateDataPtr __restrict place, BufferWritable& buf) const override {
this->data(place).write(buf);
AggregateFunctionPercentileApprox::data(place).write(buf);
}
void deserialize(AggregateDataPtr __restrict place, BufferReadable& buf,
Arena*) const override {
this->data(place).read(buf);
AggregateFunctionPercentileApprox::data(place).read(buf);
}
void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
ColumnNullable& nullable_column = assert_cast<ColumnNullable&>(to);
double result = this->data(place).get();
double result = AggregateFunctionPercentileApprox::data(place).get();
if (std::isnan(result)) {
nullable_column.insert_default();
@ -305,28 +308,31 @@ public:
const auto& sources = static_cast<const ColumnVector<Int64>&>(*columns[0]);
const auto& quantile = static_cast<const ColumnVector<Float64>&>(*columns[1]);
this->data(place).add(sources.get_int(row_num), quantile.get_float64(row_num));
AggregateFunctionPercentile::data(place).add(sources.get_int(row_num),
quantile.get_float64(row_num));
}
void reset(AggregateDataPtr __restrict place) const override { this->data(place).reset(); }
void reset(AggregateDataPtr __restrict place) const override {
AggregateFunctionPercentile::data(place).reset();
}
void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
Arena*) const override {
this->data(place).merge(this->data(rhs));
AggregateFunctionPercentile::data(place).merge(AggregateFunctionPercentile::data(rhs));
}
void serialize(ConstAggregateDataPtr __restrict place, BufferWritable& buf) const override {
this->data(place).write(buf);
AggregateFunctionPercentile::data(place).write(buf);
}
void deserialize(AggregateDataPtr __restrict place, BufferReadable& buf,
Arena*) const override {
this->data(place).read(buf);
AggregateFunctionPercentile::data(place).read(buf);
}
void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
auto& col = assert_cast<ColumnVector<Float64>&>(to);
col.insert_value(this->data(place).get());
col.insert_value(AggregateFunctionPercentile::data(place).get());
}
};

14
be/src/vec/aggregate_functions/aggregate_function_stddev.h
View File

@ -28,7 +28,7 @@ namespace doris::vectorized {
template <typename T, bool is_stddev>
struct BaseData {
BaseData() : mean(0.0), m2(0.0), count(0) {}
virtual ~BaseData() {}
virtual ~BaseData() = default;
void write(BufferWritable& buf) const {
write_binary(mean, buf);
@ -99,7 +99,7 @@ struct BaseData {
template <bool is_stddev>
struct BaseDatadecimal {
BaseDatadecimal() : mean(0), m2(0), count(0) {}
virtual ~BaseDatadecimal() {}
virtual ~BaseDatadecimal() = default;
void write(BufferWritable& buf) const {
write_binary(mean, buf);
@ -236,10 +236,12 @@ struct SampData : Data {
template <bool is_pop, typename Data, bool is_nullable>
class AggregateFunctionSampVariance
: public IAggregateFunctionDataHelper<Data, AggregateFunctionSampVariance<is_pop, Data, is_nullable>> {
: public IAggregateFunctionDataHelper<
Data, AggregateFunctionSampVariance<is_pop, Data, is_nullable>> {
public:
AggregateFunctionSampVariance(const DataTypes& argument_types_)
: IAggregateFunctionDataHelper<Data, AggregateFunctionSampVariance<is_pop, Data, is_nullable>>(
: IAggregateFunctionDataHelper<
Data, AggregateFunctionSampVariance<is_pop, Data, is_nullable>>(
argument_types_, {}) {}
String get_name() const override { return Data::name(); }
@ -292,7 +294,7 @@ public:
//samp function it's always nullables, it's need to handle nullable column
//so return type and add function should processing null values
template <typename Data, bool is_nullable>
class AggregateFunctionSamp final: public AggregateFunctionSampVariance<false, Data, is_nullable> {
class AggregateFunctionSamp final : public AggregateFunctionSampVariance<false, Data, is_nullable> {
public:
AggregateFunctionSamp(const DataTypes& argument_types_)
: AggregateFunctionSampVariance<false, Data, is_nullable>(argument_types_) {}
@ -300,7 +302,7 @@ public:
//pop function have use AggregateFunctionNullBase function, so needn't processing null values
template <typename Data, bool is_nullable>
class AggregateFunctionPop final: public AggregateFunctionSampVariance<true, Data, is_nullable> {
class AggregateFunctionPop final : public AggregateFunctionSampVariance<true, Data, is_nullable> {
public:
AggregateFunctionPop(const DataTypes& argument_types_)
: AggregateFunctionSampVariance<true, Data, is_nullable>(argument_types_) {}

5
be/src/vec/aggregate_functions/aggregate_function_sum.cpp
View File

@ -50,10 +50,11 @@ AggregateFunctionPtr create_aggregate_function_sum(const std::string& name,
AggregateFunctionPtr res;
DataTypePtr data_type = argument_types[0];
if (is_decimal(data_type))
if (is_decimal(data_type)) {
res.reset(create_with_decimal_type<Function>(*data_type, *data_type, argument_types));
else
} else {
res.reset(create_with_numeric_type<Function>(*data_type, argument_types));
}
if (!res) {
LOG(WARNING) << fmt::format("Illegal type {} of argument for aggregate function {}",

5
be/src/vec/aggregate_functions/aggregate_function_sum.h
View File

@ -67,10 +67,11 @@ public:
scale(get_decimal_scale(data_type)) {}
DataTypePtr get_return_type() const override {
if constexpr (IsDecimalNumber<T>)
if constexpr (IsDecimalNumber<T>) {
return std::make_shared<ResultDataType>(ResultDataType::max_precision(), scale);
else
} else {
return std::make_shared<ResultDataType>();
}
}
void add(AggregateDataPtr __restrict place, const IColumn** columns, size_t row_num,

10
be/src/vec/aggregate_functions/aggregate_function_uniq.cpp
View File

@ -48,12 +48,14 @@ AggregateFunctionPtr create_aggregate_function_uniq(const std::string& name,
WhichDataType which(argument_type);
// TODO: DateType
if (res)
if (res) {
return res;
else if (which.is_decimal())
return std::make_shared<AggregateFunctionUniq<Decimal128, Data<Int128>>>(argument_types);
else if (which.is_string_or_fixed_string())
} else if (which.is_decimal()) {
return std::make_shared<AggregateFunctionUniq<Decimal128, Data<Int128>>>(
argument_types);
} else if (which.is_string_or_fixed_string()) {
return std::make_shared<AggregateFunctionUniq<String, Data<String>>>(argument_types);
}
}
return nullptr;

3
be/src/vec/aggregate_functions/aggregate_function_window.cpp
View File

@ -83,9 +83,10 @@ static IAggregateFunction* create_function_single_value(const String& name,
return new AggregateFunctionTemplate<
Data<LeadAndLagData<Int64, is_nullable, false, StoreType>>>(argument_types);
}
if (which.is_string_or_fixed_string())
if (which.is_string_or_fixed_string()) {
return new AggregateFunctionTemplate<
Data<LeadAndLagData<StringRef, is_nullable, true, StoreType>>>(argument_types);
}
DCHECK(false) << "with unknowed type, failed in create_aggregate_function_leadlag";
return nullptr;
}

32
be/src/vec/aggregate_functions/aggregate_function_window.h
View File

@ -53,7 +53,9 @@ public:
++data(place).count;
}
void reset(AggregateDataPtr place) const override { this->data(place).count = 0; }
void reset(AggregateDataPtr place) const override {
WindowFunctionRowNumber::data(place).count = 0;
}
void insert_result_into(ConstAggregateDataPtr place, IColumn& to) const override {
assert_cast<ColumnInt64&>(to).get_data().push_back(data(place).count);
@ -87,17 +89,17 @@ public:
int64_t frame_end, AggregateDataPtr place, const IColumn** columns,
Arena* arena) const override {
int64_t peer_group_count = frame_end - frame_start;
if (this->data(place).peer_group_start != frame_start) {
this->data(place).peer_group_start = frame_start;
this->data(place).rank += this->data(place).count;
if (WindowFunctionRank::data(place).peer_group_start != frame_start) {
WindowFunctionRank::data(place).peer_group_start = frame_start;
WindowFunctionRank::data(place).rank += WindowFunctionRank::data(place).count;
}
this->data(place).count = peer_group_count;
WindowFunctionRank::data(place).count = peer_group_count;
}
void reset(AggregateDataPtr place) const override {
this->data(place).rank = 0;
this->data(place).count = 1;
this->data(place).peer_group_start = -1;
WindowFunctionRank::data(place).rank = 0;
WindowFunctionRank::data(place).count = 1;
WindowFunctionRank::data(place).peer_group_start = -1;
}
void insert_result_into(ConstAggregateDataPtr place, IColumn& to) const override {
@ -130,15 +132,15 @@ public:
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) const override {
if (this->data(place).peer_group_start != frame_start) {
this->data(place).peer_group_start = frame_start;
this->data(place).rank++;
if (WindowFunctionDenseRank::data(place).peer_group_start != frame_start) {
WindowFunctionDenseRank::data(place).peer_group_start = frame_start;
WindowFunctionDenseRank::data(place).rank++;
}
}
void reset(AggregateDataPtr place) const override {
this->data(place).rank = 0;
this->data(place).peer_group_start = -1;
WindowFunctionDenseRank::data(place).rank = 0;
WindowFunctionDenseRank::data(place).peer_group_start = -1;
}
void insert_result_into(ConstAggregateDataPtr place, IColumn& to) const override {
@ -357,9 +359,7 @@ struct WindowFunctionLastData : Data {
frame_end = std::min<int64_t>(frame_end, partition_end);
this->set_value(columns, frame_end - 1);
}
void add(int64_t row, const IColumn** columns) {
this->set_value(columns, row);
}
void add(int64_t row, const IColumn** columns) { this->set_value(columns, row); }
static const char* name() { return "last_value"; }
};

4
be/src/vec/aggregate_functions/factory_helpers.h
View File

@ -42,7 +42,9 @@ inline void assert_binary(const std::string& name, const DataTypes& argument_typ
template <std::size_t maximal_arity>
inline void assert_arity_at_most(const std::string& name, const DataTypes& argument_types) {
if (argument_types.size() <= maximal_arity) return;
if (argument_types.size() <= maximal_arity) {
return;
}
if constexpr (maximal_arity == 0) {
LOG(FATAL) << fmt::format("Aggregate function {} cannot have arguments", name);

79
be/src/vec/aggregate_functions/helpers.h
View File

@ -49,10 +49,12 @@ static IAggregateFunction* create_with_numeric_type(const IDataType& argument_ty
return new AggregateFunctionTemplate<TYPE>(std::forward<TArgs>(args)...);
FOR_NUMERIC_TYPES(DISPATCH)
#undef DISPATCH
if (which.idx == TypeIndex::Enum8)
if (which.idx == TypeIndex::Enum8) {
return new AggregateFunctionTemplate<Int8>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Enum16)
}
if (which.idx == TypeIndex::Enum16) {
return new AggregateFunctionTemplate<Int16>(std::forward<TArgs>(args)...);
}
return nullptr;
}
@ -66,10 +68,12 @@ static IAggregateFunction* create_with_numeric_type(const IDataType& argument_ty
return new AggregateFunctionTemplate<TYPE, bool_param>(std::forward<TArgs>(args)...);
FOR_NUMERIC_TYPES(DISPATCH)
#undef DISPATCH
if (which.idx == TypeIndex::Enum8)
if (which.idx == TypeIndex::Enum8) {
return new AggregateFunctionTemplate<Int8, bool_param>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Enum16)
}
if (which.idx == TypeIndex::Enum16) {
return new AggregateFunctionTemplate<Int16, bool_param>(std::forward<TArgs>(args)...);
}
return nullptr;
}
@ -83,10 +87,12 @@ static IAggregateFunction* create_with_numeric_type(const IDataType& argument_ty
return new AggregateFunctionTemplate<TYPE, Data>(std::forward<TArgs>(args)...);
FOR_NUMERIC_TYPES(DISPATCH)
#undef DISPATCH
if (which.idx == TypeIndex::Enum8)
if (which.idx == TypeIndex::Enum8) {
return new AggregateFunctionTemplate<Int8, Data>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Enum16)
}
if (which.idx == TypeIndex::Enum16) {
return new AggregateFunctionTemplate<Int16, Data>(std::forward<TArgs>(args)...);
}
return nullptr;
}
@ -100,10 +106,12 @@ static IAggregateFunction* create_with_numeric_type(const IDataType& argument_ty
return new AggregateFunctionTemplate<TYPE, Data<TYPE>>(std::forward<TArgs>(args)...);
FOR_NUMERIC_TYPES(DISPATCH)
#undef DISPATCH
if (which.idx == TypeIndex::Enum8)
if (which.idx == TypeIndex::Enum8) {
return new AggregateFunctionTemplate<Int8, Data<Int8>>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Enum16)
}
if (which.idx == TypeIndex::Enum16) {
return new AggregateFunctionTemplate<Int16, Data<Int16>>(std::forward<TArgs>(args)...);
}
return nullptr;
}
@ -127,14 +135,18 @@ template <template <typename, typename> class AggregateFunctionTemplate,
static IAggregateFunction* create_with_unsigned_integer_type(const IDataType& argument_type,
TArgs&&... args) {
WhichDataType which(argument_type);
if (which.idx == TypeIndex::UInt8)
if (which.idx == TypeIndex::UInt8) {
return new AggregateFunctionTemplate<UInt8, Data<UInt8>>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::UInt16)
}
if (which.idx == TypeIndex::UInt16) {
return new AggregateFunctionTemplate<UInt16, Data<UInt16>>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::UInt32)
}
if (which.idx == TypeIndex::UInt32) {
return new AggregateFunctionTemplate<UInt32, Data<UInt32>>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::UInt64)
}
if (which.idx == TypeIndex::UInt64) {
return new AggregateFunctionTemplate<UInt64, Data<UInt64>>(std::forward<TArgs>(args)...);
}
return nullptr;
}
@ -143,16 +155,21 @@ static IAggregateFunction* create_with_numeric_based_type(const IDataType& argum
TArgs&&... args) {
IAggregateFunction* f = create_with_numeric_type<AggregateFunctionTemplate>(
argument_type, std::forward<TArgs>(args)...);
if (f) return f;
if (f) {
return f;
}
/// expects that DataTypeDate based on UInt16, DataTypeDateTime based on UInt32 and UUID based on UInt128
WhichDataType which(argument_type);
if (which.idx == TypeIndex::Date)
if (which.idx == TypeIndex::Date) {
return new AggregateFunctionTemplate<UInt16>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::DateTime)
}
if (which.idx == TypeIndex::DateTime) {
return new AggregateFunctionTemplate<UInt32>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::UUID)
}
if (which.idx == TypeIndex::UUID) {
return new AggregateFunctionTemplate<UInt128>(std::forward<TArgs>(args)...);
}
return nullptr;
}
@ -160,12 +177,15 @@ template <template <typename> class AggregateFunctionTemplate, typename... TArgs
static IAggregateFunction* create_with_decimal_type(const IDataType& argument_type,
TArgs&&... args) {
WhichDataType which(argument_type);
if (which.idx == TypeIndex::Decimal32)
if (which.idx == TypeIndex::Decimal32) {
return new AggregateFunctionTemplate<Decimal32>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Decimal64)
}
if (which.idx == TypeIndex::Decimal64) {
return new AggregateFunctionTemplate<Decimal64>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Decimal128)
}
if (which.idx == TypeIndex::Decimal128) {
return new AggregateFunctionTemplate<Decimal128>(std::forward<TArgs>(args)...);
}
return nullptr;
}
@ -174,12 +194,15 @@ template <template <typename, typename> class AggregateFunctionTemplate, typenam
static IAggregateFunction* create_with_decimal_type(const IDataType& argument_type,
TArgs&&... args) {
WhichDataType which(argument_type);
if (which.idx == TypeIndex::Decimal32)
if (which.idx == TypeIndex::Decimal32) {
return new AggregateFunctionTemplate<Decimal32, Data>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Decimal64)
}
if (which.idx == TypeIndex::Decimal64) {
return new AggregateFunctionTemplate<Decimal64, Data>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Decimal128)
}
if (which.idx == TypeIndex::Decimal128) {
return new AggregateFunctionTemplate<Decimal128, Data>(std::forward<TArgs>(args)...);
}
return nullptr;
}
@ -195,10 +218,12 @@ static IAggregateFunction* create_with_two_numeric_types_second(const IDataType&
return new AggregateFunctionTemplate<FirstType, TYPE>(std::forward<TArgs>(args)...);
FOR_NUMERIC_TYPES(DISPATCH)
#undef DISPATCH
if (which.idx == TypeIndex::Enum8)
if (which.idx == TypeIndex::Enum8) {
return new AggregateFunctionTemplate<FirstType, Int8>(std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Enum16)
}
if (which.idx == TypeIndex::Enum16) {
return new AggregateFunctionTemplate<FirstType, Int16>(std::forward<TArgs>(args)...);
}
return nullptr;
}
@ -213,12 +238,14 @@ static IAggregateFunction* create_with_two_numeric_types(const IDataType& first_
second_type, std::forward<TArgs>(args)...);
FOR_NUMERIC_TYPES(DISPATCH)
#undef DISPATCH
if (which.idx == TypeIndex::Enum8)
if (which.idx == TypeIndex::Enum8) {
return create_with_two_numeric_types_second<Int8, AggregateFunctionTemplate>(
second_type, std::forward<TArgs>(args)...);
if (which.idx == TypeIndex::Enum16)
}
if (which.idx == TypeIndex::Enum16) {
return create_with_two_numeric_types_second<Int16, AggregateFunctionTemplate>(
second_type, std::forward<TArgs>(args)...);
}
return nullptr;
}

9
be/src/vec/aggregate_functions/key_holder_helpers.h
View File

@ -28,21 +28,22 @@ namespace doris::vectorized {
template <bool is_plain_column = false>
static auto get_key_holder(const IColumn& column, size_t row_num, Arena& arena) {
if constexpr (is_plain_column) {
return ArenaKeyHolder{column.get_data_at(row_num), arena};
return ArenaKeyHolder {column.get_data_at(row_num), arena};
} else {
const char* begin = nullptr;
StringRef serialized = column.serialize_value_into_arena(row_num, arena, begin);
assert(serialized.data != nullptr);
return SerializedKeyHolder{serialized, arena};
return SerializedKeyHolder {serialized, arena};
}
}
template <bool is_plain_column>
static void deserialize_and_insert(StringRef str, IColumn& data_to) {
if constexpr (is_plain_column)
if constexpr (is_plain_column) {
data_to.insert_data(str.data, str.size);
else
} else {
data_to.deserialize_and_insert_from_arena(str.data);
}
}
} // namespace doris::vectorized