ClickHouse/src/AggregateFunctions/AggregateFunctionFactory.h

107 lines
3.5 KiB
C++
Raw Normal View History

2011-09-19 03:40:05 +00:00
#pragma once
#include <AggregateFunctions/IAggregateFunction.h>
#include <Common/IFactoryWithAliases.h>
2016-12-29 23:17:05 +00:00
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include <optional>
2011-09-19 03:40:05 +00:00
namespace DB
{
class Context;
class IDataType;
using DataTypePtr = std::shared_ptr<const IDataType>;
using DataTypes = std::vector<DataTypePtr>;
/**
* The invoker has arguments: name of aggregate function, types of arguments, values of parameters.
* Parameters are for "parametric" aggregate functions.
* For example, in quantileWeighted(0.9)(x, weight), 0.9 is "parameter" and x, weight are "arguments".
*/
using AggregateFunctionCreator = std::function<AggregateFunctionPtr(const String &, const DataTypes &, const Array &)>;
2020-06-14 07:44:02 +00:00
struct AggregateFunctionWithProperties
{
AggregateFunctionCreator creator;
AggregateFunctionProperties properties;
AggregateFunctionWithProperties() = default;
AggregateFunctionWithProperties(const AggregateFunctionWithProperties &) = default;
2020-06-17 13:18:52 +00:00
AggregateFunctionWithProperties & operator = (const AggregateFunctionWithProperties &) = default;
2020-06-14 07:44:02 +00:00
template <typename Creator, std::enable_if_t<!std::is_same_v<Creator, AggregateFunctionWithProperties>> * = nullptr>
AggregateFunctionWithProperties(Creator creator_, AggregateFunctionProperties properties_ = {})
: creator(std::forward<Creator>(creator_)), properties(std::move(properties_))
{
}
};
2016-08-05 15:44:19 +00:00
/** Creates an aggregate function by name.
2011-09-19 03:40:05 +00:00
*/
2020-06-14 07:44:02 +00:00
class AggregateFunctionFactory final : private boost::noncopyable, public IFactoryWithAliases<AggregateFunctionWithProperties>
2011-09-19 03:40:05 +00:00
{
public:
static AggregateFunctionFactory & instance();
/// Register a function by its name.
/// No locking, you must register all functions before usage of get.
void registerFunction(
const String & name,
2020-06-14 07:44:02 +00:00
Value creator,
CaseSensitiveness case_sensitiveness = CaseSensitive);
/// Throws an exception if not found.
AggregateFunctionPtr
get(const String & name,
const DataTypes & argument_types,
2020-06-14 07:44:02 +00:00
const Array & parameters,
AggregateFunctionProperties & out_properties) const;
/// Returns nullptr if not found.
AggregateFunctionPtr tryGet(
const String & name,
const DataTypes & argument_types,
2020-06-14 07:44:02 +00:00
const Array & parameters,
AggregateFunctionProperties & out_properties) const;
/// Get properties if the aggregate function exists.
std::optional<AggregateFunctionProperties> tryGetProperties(const String & name) const;
bool isAggregateFunctionName(const String & name) const;
2011-09-19 03:40:05 +00:00
2015-09-24 12:40:36 +00:00
private:
AggregateFunctionPtr getImpl(
const String & name,
const DataTypes & argument_types,
const Array & parameters,
2020-06-14 07:44:02 +00:00
AggregateFunctionProperties & out_properties,
bool has_null_arguments) const;
std::optional<AggregateFunctionProperties> tryGetPropertiesImpl(const String & name) const;
2020-06-14 07:44:02 +00:00
using AggregateFunctions = std::unordered_map<String, Value>;
AggregateFunctions aggregate_functions;
/// Case insensitive aggregate functions will be additionally added here with lowercased name.
AggregateFunctions case_insensitive_aggregate_functions;
2020-06-14 07:44:02 +00:00
const AggregateFunctions & getMap() const override { return aggregate_functions; }
2020-06-14 07:44:02 +00:00
const AggregateFunctions & getCaseInsensitiveMap() const override { return case_insensitive_aggregate_functions; }
String getFactoryName() const override { return "AggregateFunctionFactory"; }
2015-09-24 12:40:36 +00:00
};
2011-09-19 03:40:05 +00:00
}