mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-12-16 03:12:43 +00:00
70d1adfe4b
* save format string for NetException * format exceptions * format exceptions 2 * format exceptions 3 * format exceptions 4 * format exceptions 5 * format exceptions 6 * fix * format exceptions 7 * format exceptions 8 * Update MergeTreeIndexGin.cpp * Update AggregateFunctionMap.cpp * Update AggregateFunctionMap.cpp * fix
176 lines
6.7 KiB
C++
176 lines
6.7 KiB
C++
#pragma once
|
|
|
|
#include "config.h"
|
|
|
|
#if USE_DATASKETCHES
|
|
|
|
#include <AggregateFunctions/AggregateFunctionFactory.h>
|
|
#include <Columns/ColumnAggregateFunction.h>
|
|
#include <Columns/ColumnArray.h>
|
|
#include <Columns/ColumnConst.h>
|
|
#include <Columns/ColumnString.h>
|
|
#include <Columns/ColumnVector.h>
|
|
#include <Columns/ColumnsNumber.h>
|
|
#include <DataTypes/DataTypeAggregateFunction.h>
|
|
#include <DataTypes/DataTypeArray.h>
|
|
#include <DataTypes/DataTypeString.h>
|
|
#include <DataTypes/DataTypesNumber.h>
|
|
#include <Functions/FunctionHelpers.h>
|
|
#include <Functions/IFunction.h>
|
|
#include <Interpreters/castColumn.h>
|
|
#include <Common/assert_cast.h>
|
|
#include <Common/typeid_cast.h>
|
|
|
|
#include <AggregateFunctions/AggregateFunctionUniq.h>
|
|
|
|
namespace DB
|
|
{
|
|
|
|
|
|
namespace ErrorCodes
|
|
{
|
|
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
|
|
}
|
|
|
|
struct UniqThetaIntersectImpl
|
|
{
|
|
static void apply(AggregateFunctionUniqThetaData & sketch_data_1, const AggregateFunctionUniqThetaData & sketch_data_2)
|
|
{
|
|
sketch_data_1.set.intersect(sketch_data_2.set);
|
|
}
|
|
};
|
|
|
|
struct UniqThetaUnionImpl
|
|
{
|
|
static void apply(AggregateFunctionUniqThetaData & sketch_data_1, const AggregateFunctionUniqThetaData & sketch_data_2)
|
|
{
|
|
sketch_data_1.set.merge(sketch_data_2.set);
|
|
}
|
|
};
|
|
|
|
struct UniqThetaNotImpl
|
|
{
|
|
static void apply(AggregateFunctionUniqThetaData & sketch_data_1, const AggregateFunctionUniqThetaData & sketch_data_2)
|
|
{
|
|
sketch_data_1.set.aNotB(sketch_data_2.set);
|
|
}
|
|
};
|
|
|
|
template <typename Impl, typename Name>
|
|
class FunctionUniqTheta : public IFunction
|
|
{
|
|
public:
|
|
static constexpr auto name = Name::name;
|
|
|
|
static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionUniqTheta>(); }
|
|
|
|
String getName() const override { return name; }
|
|
|
|
bool isVariadic() const override { return false; }
|
|
|
|
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; }
|
|
|
|
size_t getNumberOfArguments() const override { return 2; }
|
|
|
|
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
|
|
{
|
|
const auto * sketch_type0 = typeid_cast<const DataTypeAggregateFunction *>(arguments[0].get());
|
|
if (!(sketch_type0 && sketch_type0->getFunctionName() == "uniqTheta"))
|
|
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
|
|
"First argument for function {} must be a uniqTheta but it has type {}",
|
|
getName(), arguments[0]->getName());
|
|
|
|
const auto * sketch_type1 = typeid_cast<const DataTypeAggregateFunction *>(arguments[1].get());
|
|
if (!(sketch_type1 && sketch_type1->getFunctionName() == "uniqTheta"))
|
|
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
|
|
"Second argument for function {} must be a uniqTheta but it has type {}",
|
|
getName(), arguments[1]->getName());
|
|
|
|
const DataTypes & arg_data_types0 = sketch_type0->getArgumentsDataTypes();
|
|
const DataTypes & arg_data_types1 = sketch_type1->getArgumentsDataTypes();
|
|
|
|
if (arg_data_types0.size() != arg_data_types1.size())
|
|
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
|
|
"The nested type in uniqThetas must be the same length, "
|
|
"but one is {}, and the other is {}", arg_data_types0.size(), arg_data_types1.size());
|
|
|
|
size_t types_size = arg_data_types0.size();
|
|
for (size_t i = 0; i < types_size; ++i)
|
|
{
|
|
if (!arg_data_types0[i]->equals(*arg_data_types1[i]))
|
|
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
|
|
"The {}th nested type in uniqThetas must be the same, "
|
|
"but one is {}, and the other is {}",
|
|
i, arg_data_types0[i]->getName(), arg_data_types1[i]->getName());
|
|
}
|
|
|
|
|
|
return arguments[0];
|
|
}
|
|
|
|
bool useDefaultImplementationForConstants() const override { return true; }
|
|
|
|
ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
|
|
{
|
|
const ColumnAggregateFunction * column_ptrs[2];
|
|
bool is_column_const[2];
|
|
for (size_t i = 0; i < 2; ++i)
|
|
{
|
|
if (const auto * argument_column_const = typeid_cast<const ColumnConst *>(arguments[i].column.get()))
|
|
{
|
|
column_ptrs[i] = typeid_cast<const ColumnAggregateFunction *>(argument_column_const->getDataColumnPtr().get());
|
|
is_column_const[i] = true;
|
|
}
|
|
else
|
|
{
|
|
column_ptrs[i] = typeid_cast<const ColumnAggregateFunction *>(arguments[i].column.get());
|
|
is_column_const[i] = false;
|
|
}
|
|
}
|
|
|
|
auto col_to = ColumnAggregateFunction::create(column_ptrs[0]->getAggregateFunction());
|
|
|
|
col_to->reserve(input_rows_count);
|
|
|
|
const PaddedPODArray<AggregateDataPtr> & container0 = column_ptrs[0]->getData();
|
|
const PaddedPODArray<AggregateDataPtr> & container1 = column_ptrs[1]->getData();
|
|
|
|
for (size_t i = 0; i < input_rows_count; ++i)
|
|
{
|
|
const AggregateDataPtr data_ptr_0 = is_column_const[0] ? container0[0] : container0[i];
|
|
const AggregateDataPtr data_ptr_1 = is_column_const[1] ? container1[0] : container1[i];
|
|
|
|
col_to->insertFrom(data_ptr_0);
|
|
AggregateFunctionUniqThetaData & sketch_data_1 = *reinterpret_cast<AggregateFunctionUniqThetaData *>(col_to->getData()[i]);
|
|
const AggregateFunctionUniqThetaData & sketch_data_2
|
|
= *reinterpret_cast<const AggregateFunctionUniqThetaData *>(data_ptr_1);
|
|
Impl::apply(sketch_data_1, sketch_data_2);
|
|
}
|
|
return col_to;
|
|
}
|
|
};
|
|
|
|
struct NameUniqThetaIntersect
|
|
{
|
|
static constexpr auto name = "uniqThetaIntersect";
|
|
};
|
|
|
|
struct NameUniqThetaUnion
|
|
{
|
|
static constexpr auto name = "uniqThetaUnion";
|
|
};
|
|
|
|
struct NameUniqThetaNot
|
|
{
|
|
static constexpr auto name = "uniqThetaNot";
|
|
};
|
|
|
|
using FunctionUniqThetaIntersect = FunctionUniqTheta<UniqThetaIntersectImpl, NameUniqThetaIntersect>;
|
|
using FunctionUniqThetaUnion = FunctionUniqTheta<UniqThetaUnionImpl, NameUniqThetaUnion>;
|
|
using FunctionUniqThetaNot = FunctionUniqTheta<UniqThetaNotImpl, NameUniqThetaNot>;
|
|
|
|
}
|
|
|
|
|
|
#endif
|