{

min,

max,

sum,

average,

product

{

static bool needBoolean() { return false; }

static bool needExpression() { return false; }

static bool needOneArray() { return false; }

static DataTypePtr getReturnType(const DataTypePtr & expression_return, const DataTypePtr & /*array_element*/)

{

if constexpr (aggregate_operation == AggregateOperation::max || aggregate_operation == AggregateOperation::min)

{

return expression_return;

}

DataTypePtr result;

auto call = [&](const auto & types)

{

using Types = std::decay_t<decltype(types)>;

using DataType = typename Types::LeftType;

if constexpr (!IsDataTypeDateOrDateTimeOrTime<DataType>)

{

if constexpr (aggregate_operation == AggregateOperation::average || aggregate_operation == AggregateOperation::product)

{

result = std::make_shared<DataTypeFloat64>();

return true;

}

else if constexpr (IsDataTypeNumber<DataType>)

{

using NumberReturnType = ArrayAggregateResult<typename DataType::FieldType, aggregate_operation>;

result = std::make_shared<DataTypeNumber<NumberReturnType>>();

return true;

}

else if constexpr (IsDataTypeDecimal<DataType>)

{

using DecimalReturnType = ArrayAggregateResult<typename DataType::FieldType, aggregate_operation>;

UInt32 scale = getDecimalScale(*expression_return);

result = std::make_shared<DataTypeDecimal<DecimalReturnType>>(DecimalUtils::max_precision<DecimalReturnType>, scale);

return true;

}

}

return false;

};

if (!callOnIndexAndDataType<void>(expression_return->getTypeId(), call))

{

throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "array aggregation function cannot be performed on type {}",

expression_return->getName());

}

return result;

}

/// Vectorized fast path for plain numeric arrays: reduce each array slice with findExtremeMin/Max

/// (branchless SIMD horizontal min/max) instead of a per-element compareAt.

/// The result is bitwise-identical to the generic path: the extreme value is unique up to representation,

/// and the only value classes with multiple representations (NaN payloads and 0.0/-0.0) are fixed up below

/// to return the first occurrence, which is what compareAt-based selection returns.

template <typename Element>

requires(has_find_extreme_implementation<Element>)

static bool executeMinOrMaxNumeric(const ColumnPtr & mapped, const ColumnArray::Offsets & offsets, ColumnPtr & res_ptr)

{

const ColumnVector<Element> * column = checkAndGetColumn<ColumnVector<Element>>(&*mapped);

if (!column)

return false;

const Element * data = column->getData().data();

auto res_column = ColumnVector<Element>::create(offsets.size());

typename ColumnVector<Element>::Container & res = res_column->getData();

size_t pos = 0;

for (size_t i = 0; i < offsets.size(); ++i)

{

const size_t end_of_array = offsets[i];

/// Array is empty

if (pos == end_of_array)

{

res[i] = Element{};

continue;

}

std::optional<Element> result;

if constexpr (aggregate_operation == AggregateOperation::min)

result = findExtremeMin(data, pos, end_of_array);

else

result = findExtremeMax(data, pos, end_of_array);

chassert(result.has_value());

if constexpr (is_floating_point<Element>)

{

/// findExtreme* returns NaN only if all elements are NaN; the generic path returns the first of them.

if (isNaN(*result))

result = data[pos];

/// A zero result may be either 0.0 or -0.0 depending on reduction order; take the first zero in the array.

else if (*result == Element{})

{

for (size_t j = pos; j < end_of_array; ++j)

{

if (data[j] == Element{})

{

result = data[j];

break;

}

}

}

}

res[i] = *result;

pos = end_of_array;

}

res_ptr = std::move(res_column);

return true;

}

template <AggregateOperation op = aggregate_operation>

requires(op == AggregateOperation::min || op == AggregateOperation::max)

static void executeMinOrMax(const ColumnPtr & mapped, const ColumnArray::Offsets & offsets, ColumnPtr & res_ptr)

{

const ColumnConst * const_column = checkAndGetColumn<ColumnConst>(&*mapped);

if (const_column)

{

MutableColumnPtr res_column = const_column->getDataColumn().cloneEmpty();

const Field field = const_column->getField();

UInt64 pos = 0;

size_t first_non_empty = 0;

for (size_t i = 0; i < offsets.size(); ++i)

{

const auto end_of_array = offsets[i];

if (pos == end_of_array)

{

if (first_non_empty < i)

res_column->insertMany(field, i - first_non_empty);

res_column->insertDefault();

first_non_empty = i + 1;

}

pos = end_of_array;

}

if (first_non_empty < offsets.size())

res_column->insertMany(field, offsets.size() - first_non_empty);

res_ptr = std::move(res_column);

return;

}

if (executeMinOrMaxNumeric<UInt8>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<UInt16>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<UInt32>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<UInt64>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<Int8>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<Int16>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<Int32>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<Int64>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<UInt128>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<UInt256>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<Int128>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<Int256>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<Float32>(mapped, offsets, res_ptr)

|| executeMinOrMaxNumeric<Float64>(mapped, offsets, res_ptr))

return;

MutableColumnPtr res_column = mapped->cloneEmpty();

static constexpr int nan_null_direction_hint = aggregate_operation == AggregateOperation::min ? 1 : -1;

/// TODO: Introduce row_begin and row_end to getPermutation or an equivalent function to use that instead

/// (same use case as SingleValueDataBase::getSmallestIndex)

UInt64 start_of_array = 0;

for (auto end_of_array : offsets)

{

/// Array is empty

if (start_of_array == end_of_array)

{

res_column->insertDefault();

continue;

}

UInt64 index = start_of_array;

for (UInt64 i = index + 1; i < end_of_array; i++)

{

if constexpr (aggregate_operation == AggregateOperation::min)

{

if ((mapped->compareAt(i, index, *mapped, nan_null_direction_hint) < 0))

index = i;

}

else

{

if ((mapped->compareAt(i, index, *mapped, nan_null_direction_hint) > 0))

index = i;

}

}

res_column->insertFrom(*mapped, index);

start_of_array = end_of_array;

}

chassert(res_column->size() == offsets.size());

res_ptr = std::move(res_column);

}

template <typename Element>

static NO_SANITIZE_UNDEFINED bool executeType(const ColumnPtr & mapped, const ColumnArray::Offsets & offsets, ColumnPtr & res_ptr)

{

/// Min and Max are implemented in a different function

static_assert(aggregate_operation != AggregateOperation::min && aggregate_operation != AggregateOperation::max);

using ResultType = ArrayAggregateResult<Element, aggregate_operation>;

using ColVecType = ColumnVectorOrDecimal<Element>;

using ColVecResultType = ColumnVectorOrDecimal<ResultType>;

/// For average and product of array we return Float64 as result, but we want to keep precision

/// so we convert to Float64 as last step, but intermediate value is represented as result of sum operation

static constexpr bool is_average_or_product_operation = aggregate_operation == AggregateOperation::average ||

aggregate_operation == AggregateOperation::product;

using SummAggregationType = ArrayAggregateResult<Element, AggregateOperation::sum>;

using AggregationType = std::conditional_t<is_average_or_product_operation, SummAggregationType, ResultType>;

const ColVecType * column = checkAndGetColumn<ColVecType>(&*mapped);

/// Constant case.

if (!column)

{

const ColumnConst * column_const = checkAndGetColumnConst<ColVecType>(&*mapped);

if (!column_const)

return false;

const AggregationType x = static_cast<AggregationType>(column_const->template getValue<Element>()); // NOLINT

const ColVecType * column_typed = checkAndGetColumn<ColVecType>(&column_const->getDataColumn());

typename ColVecResultType::MutablePtr res_column;

if constexpr (is_decimal<Element>)

res_column = ColVecResultType::create(offsets.size(), column_typed->getScale());

else

res_column = ColVecResultType::create(offsets.size());

auto & res = res_column->getData();

size_t pos = 0;

for (size_t i = 0; i < offsets.size(); ++i)

{

const size_t array_size = offsets[i] - pos;

if (array_size == 0)

{

res[i] = {};

continue;

}

if constexpr (aggregate_operation == AggregateOperation::sum)

{

/// Just multiply the value by array size.

res[i] = x * static_cast<ResultType>(array_size);

}

else if constexpr (aggregate_operation == AggregateOperation::average)

{

if constexpr (is_decimal<Element>)

{

res[i] = DecimalUtils::convertTo<ResultType>(x, column_typed->getScale());

}

else

{

res[i] = static_cast<ResultType>(x);

}

}

else if constexpr (aggregate_operation == AggregateOperation::product)

{

AggregationType product = x;

if constexpr (is_decimal<Element>)

{

using T = decltype(x.value);

T x_val = x.value;

for (size_t array_index = 1; array_index < array_size; ++array_index)

{

T product_val = product.value;

if (common::mulOverflow(x_val, product_val, product.value))

throw Exception(ErrorCodes::DECIMAL_OVERFLOW, "Decimal math overflow");

}

auto result_scale = column_typed->getScale() * array_size;

if (unlikely(result_scale > DecimalUtils::max_precision<AggregationType>))

throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Scale {} is out of bounds (max scale: {})",

result_scale, DecimalUtils::max_precision<AggregationType>);

res[i] = DecimalUtils::convertTo<ResultType>(product, static_cast<UInt32>(result_scale));

}

else

{

for (size_t array_index = 1; array_index < array_size; ++array_index)

product = product * x;

res[i] = static_cast<ResultType>(product);

}

}

pos = offsets[i];

}

res_ptr = std::move(res_column);

return true;

}

const auto & data = column->getData();

typename ColVecResultType::MutablePtr res_column;

if constexpr (is_decimal<Element>)

res_column = ColVecResultType::create(offsets.size(), column->getScale());

else

res_column = ColVecResultType::create(offsets.size());

typename ColVecResultType::Container & res = res_column->getData();

size_t pos = 0;

for (size_t i = 0; i < offsets.size(); ++i)

{

AggregationType aggregate_value{};

/// Array is empty

if (offsets[i] == pos)

{

if constexpr (is_decimal<AggregationType>)

res[i] = aggregate_value.value;

else

res[i] = static_cast<ResultType>(aggregate_value);

continue;

}

size_t count = 1;

aggregate_value = static_cast<AggregationType>(data[pos]); // NOLINT

++pos;

for (; pos < offsets[i]; ++pos)

{

auto element = data[pos];

if constexpr (aggregate_operation == AggregateOperation::sum ||

aggregate_operation == AggregateOperation::average)

{

aggregate_value += static_cast<AggregationType>(element);

}

else if constexpr (aggregate_operation == AggregateOperation::product)

{

if constexpr (is_decimal<Element>)

{

using AggregateValueDecimalUnderlyingValue = decltype(aggregate_value.value);

AggregateValueDecimalUnderlyingValue current_aggregate_value = aggregate_value.value;

AggregateValueDecimalUnderlyingValue element_value = static_cast<AggregateValueDecimalUnderlyingValue>(element.value);

if (common::mulOverflow(current_aggregate_value, element_value, aggregate_value.value))

throw Exception(ErrorCodes::DECIMAL_OVERFLOW, "Decimal math overflow");

}

else

{

aggregate_value *= static_cast<AggregationType>(element);

}

}

++count;

}

if constexpr (aggregate_operation == AggregateOperation::average)

{

if constexpr (is_decimal<Element>)

{

aggregate_value = aggregate_value / AggregationType(count);

res[i] = DecimalUtils::convertTo<ResultType>(aggregate_value, column->getScale());

}

else

{

res[i] = static_cast<ResultType>(aggregate_value) / static_cast<ResultType>(count);

}

}

else if constexpr (aggregate_operation == AggregateOperation::product && is_decimal<Element>)

{

auto result_scale = column->getScale() * count;

if (unlikely(result_scale > DecimalUtils::max_precision<AggregationType>))

throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Scale {} is out of bounds (max scale: {})",

result_scale, DecimalUtils::max_precision<AggregationType>);

res[i] = DecimalUtils::convertTo<ResultType>(aggregate_value, static_cast<UInt32>(result_scale));

}

else

{

res[i] = static_cast<ResultType>(aggregate_value);

}

}

res_ptr = std::move(res_column);

return true;

}

static ColumnPtr execute(const ColumnArray & array, ColumnPtr mapped)

{

const IColumn::Offsets & offsets = array.getOffsets();

ColumnPtr res;

if constexpr (aggregate_operation == AggregateOperation::min || aggregate_operation == AggregateOperation::max)

{

executeMinOrMax(mapped, offsets, res);

return res;

}

else

{

if (executeType<UInt8>(mapped, offsets, res) ||

executeType<UInt16>(mapped, offsets, res) ||

executeType<UInt32>(mapped, offsets, res) ||

executeType<UInt64>(mapped, offsets, res) ||

executeType<UInt128>(mapped, offsets, res) ||

executeType<UInt256>(mapped, offsets, res) ||

executeType<Int8>(mapped, offsets, res) ||

executeType<Int16>(mapped, offsets, res) ||

executeType<Int32>(mapped, offsets, res) ||

executeType<Int64>(mapped, offsets, res) ||

executeType<Int128>(mapped, offsets, res) ||

executeType<Int256>(mapped, offsets, res) ||

executeType<BFloat16>(mapped, offsets, res) ||

executeType<Float32>(mapped, offsets, res) ||

executeType<Float64>(mapped, offsets, res) ||

executeType<Decimal32>(mapped, offsets, res) ||

executeType<Decimal64>(mapped, offsets, res) ||

executeType<Decimal128>(mapped, offsets, res) ||

executeType<Decimal256>(mapped, offsets, res) ||

executeType<DateTime64>(mapped, offsets, res))

{

return res;

}

}

throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Unexpected column for arraySum: {}", mapped->getName());

}

{

FunctionDocumentation::Description description_min = R"(

)";

FunctionDocumentation::Syntax syntax_min = "arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";

FunctionDocumentation::Arguments arguments_min = {

{"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`).", {"Lambda function"}},

{"source_arr", "The source array to process.", {"Array(T)"}},

{"cond1_arr, ...", "Optional. N condition arrays providing additional arguments to the lambda function.", {"Array(T)"}}

};

FunctionDocumentation::ReturnedValue returned_value_min = {"Returns the minimum element in the source array, or the minimum element of the lambda results if provided."};

FunctionDocumentation::Examples examples_min = {

{"Basic example", "SELECT arrayMin([5, 3, 2, 7]);", "2"},

{"Usage with lambda function", "SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);", "4"},

};

FunctionDocumentation::IntroducedIn introduced_in_min = {21, 1};

FunctionDocumentation::Category category_min = FunctionDocumentation::Category::Array;

FunctionDocumentation documentation_min = {description_min, syntax_min, arguments_min, {}, returned_value_min, examples_min, introduced_in_min, category_min};

factory.registerFunction<FunctionArrayMin>(documentation_min);

FunctionDocumentation::Description description_max = R"(

)";

FunctionDocumentation::Syntax syntax_max = "arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";

FunctionDocumentation::Arguments arguments_max = {

{"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`).", {"Lambda function"}},

{"source_arr", "The source array to process.", {"Array(T)"}},

{"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function.", {"Array(T)"}}

};

FunctionDocumentation::ReturnedValue returned_value_max = {"Returns the maximum element in the source array, or the maximum element of the lambda results if provided."};

FunctionDocumentation::Examples examples_max = {

{"Basic example", "SELECT arrayMax([5, 3, 2, 7]);", "7"},

{"Usage with lambda function", "SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);", "12"},

};

FunctionDocumentation::IntroducedIn introduced_in_max = {21, 1};

FunctionDocumentation::Category category_max = FunctionDocumentation::Category::Array;

FunctionDocumentation documentation_max = {description_max, syntax_max, arguments_max, {}, returned_value_max, examples_max, introduced_in_max, category_max};

factory.registerFunction<FunctionArrayMax>(documentation_max);

FunctionDocumentation::Description description_sum = R"(

)";

FunctionDocumentation::Syntax syntax_sum = "arraySum([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";

FunctionDocumentation::Arguments arguments_sum = {

{"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`).", {"Lambda function"}},

{"source_arr", "The source array to process.", {"Array(T)"}},

{", cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function.", {"Array(T)"}}

};

FunctionDocumentation::ReturnedValue returned_value_sum = {"Returns the sum of elements in the source array, or the sum of elements of the lambda results if provided."};

FunctionDocumentation::Examples examples_sum = {

{"Basic example", "SELECT arraySum([1, 2, 3, 4]);", "10"},

{"Usage with lambda function", "SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);", "8"},

};

FunctionDocumentation::IntroducedIn introduced_in_sum = {21, 1};

FunctionDocumentation::Category category_sum = FunctionDocumentation::Category::Array;

FunctionDocumentation documentation_sum = {description_sum, syntax_sum, arguments_sum, {}, returned_value_sum, examples_sum, introduced_in_sum, category_sum};

factory.registerFunction<FunctionArraySum>(documentation_sum);

FunctionDocumentation::Description description_avg = R"(

)";

FunctionDocumentation::Syntax syntax_avg = "arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";

FunctionDocumentation::Arguments arguments_avg = {

{"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`).", {"Lambda function"}},

{"source_arr", "The source array to process.", {"Array(T)"}},

{"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function.", {"Array(T)"}}

};

FunctionDocumentation::ReturnedValue returned_value_avg = {"Returns the average of elements in the source array, or the average of elements of the lambda results if provided.", {"Float64"}};

FunctionDocumentation::Examples examples_avg = {

{"Basic example", "SELECT arrayAvg([1, 2, 3, 4]);", "2.5"},

{"Usage with lambda function", "SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;", "6.5"},

};

FunctionDocumentation::IntroducedIn introduced_in_avg = {21, 1};

FunctionDocumentation::Category category_avg = FunctionDocumentation::Category::Array;

FunctionDocumentation documentation_avg = {description_avg, syntax_avg, arguments_avg, {}, returned_value_avg, examples_avg, introduced_in_avg, category_avg};

factory.registerFunction<FunctionArrayAverage>(documentation_avg);

FunctionDocumentation::Description description_prod = R"(

)";

FunctionDocumentation::Syntax syntax_prod = "arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])";

FunctionDocumentation::Arguments arguments_prod = {

{"func(x[, y1, ..., yN])", "Optional. A lambda function which operates on elements of the source array (`x`) and condition arrays (`y`).", {"Lambda function"}},

{"source_arr", "The source array to process.", {"Array(T)"}},

{"[, cond1_arr, ... , condN_arr]", "Optional. N condition arrays providing additional arguments to the lambda function.", {"Array(T)"}}

};

FunctionDocumentation::ReturnedValue returned_value_prod = {"Returns the product of elements in the source array, or the product of elements of the lambda results if provided.", {"Float64"}};

FunctionDocumentation::Examples examples_prod = {

{"Basic example", "SELECT arrayProduct([1, 2, 3, 4]);", "24"},

{"Usage with lambda function", "SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;", "16"},

};

FunctionDocumentation::IntroducedIn introduced_in_prod = {21, 1};

FunctionDocumentation::Category category_prod = FunctionDocumentation::Category::Array;

FunctionDocumentation documentation_prod = {description_prod, syntax_prod, arguments_prod, {}, returned_value_prod, examples_prod, introduced_in_prod, category_prod};

factory.registerFunction<FunctionArrayProduct>(documentation_prod);