mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-09-23 18:20:50 +00:00
632 lines
26 KiB
C++
632 lines
26 KiB
C++
#pragma once
|
||
|
||
#include <map>
|
||
#include <unordered_map>
|
||
|
||
#include <Poco/Mutex.h>
|
||
|
||
#include <Yandex/logger_useful.h>
|
||
|
||
#include <DB/Core/ColumnNumbers.h>
|
||
#include <DB/Core/Names.h>
|
||
#include <DB/Core/StringRef.h>
|
||
#include <DB/Common/Arena.h>
|
||
|
||
#include <DB/DataStreams/IBlockInputStream.h>
|
||
|
||
#include <DB/AggregateFunctions/IAggregateFunction.h>
|
||
|
||
#include <DB/Interpreters/AggregationCommon.h>
|
||
#include <DB/Interpreters/Limits.h>
|
||
|
||
#include <DB/Columns/ColumnString.h>
|
||
#include <DB/Columns/ColumnFixedString.h>
|
||
#include <DB/Columns/ColumnAggregateFunction.h>
|
||
#include <DB/Columns/ColumnVector.h>
|
||
|
||
|
||
|
||
namespace DB
|
||
{
|
||
|
||
|
||
struct AggregateDescription
|
||
{
|
||
AggregateFunctionPtr function;
|
||
Array parameters; /// Параметры (параметрической) агрегатной функции.
|
||
ColumnNumbers arguments;
|
||
Names argument_names; /// Используются, если arguments не заданы.
|
||
String column_name; /// Какое имя использовать для столбца со значениями агрегатной функции
|
||
};
|
||
|
||
typedef std::vector<AggregateDescription> AggregateDescriptions;
|
||
|
||
|
||
/** Разные структуры данных, которые могут использоваться для агрегации
|
||
* Для эффективности сами данные для агрегации кладутся в пул.
|
||
* Владение данными (состояний агрегатных функций) и пулом
|
||
* захватывается позднее - в функции convertToBlock, объектом ColumnAggregateFunction.
|
||
*/
|
||
typedef AggregateDataPtr AggregatedDataWithoutKey;
|
||
typedef HashMap<UInt64, AggregateDataPtr> AggregatedDataWithUInt64Key;
|
||
typedef HashMapWithSavedHash<StringRef, AggregateDataPtr> AggregatedDataWithStringKey;
|
||
typedef HashMap<UInt128, AggregateDataPtr, UInt128Hash> AggregatedDataWithKeys128;
|
||
typedef HashMap<UInt128, std::pair<StringRef*, AggregateDataPtr>, UInt128TrivialHash> AggregatedDataHashed;
|
||
|
||
|
||
/// Специализации для UInt8, UInt16.
|
||
struct TrivialHash
|
||
{
|
||
template <typename T>
|
||
size_t operator() (T key) const
|
||
{
|
||
return key;
|
||
}
|
||
};
|
||
|
||
/// Превращает хэш-таблицу в что-то типа lookup-таблицы. Остаётся неоптимальность - в ячейках хранятся ключи.
|
||
template <size_t key_bits>
|
||
struct HashTableFixedGrower
|
||
{
|
||
size_t bufSize() const { return 1 << key_bits; }
|
||
size_t place(size_t x) const { return x; }
|
||
/// Тут можно было бы написать __builtin_unreachable(), но компилятор не до конца всё оптимизирует, и получается менее эффективно.
|
||
size_t next(size_t pos) const { return pos + 1; }
|
||
bool overflow(size_t elems) const { return false; }
|
||
|
||
void increaseSize() { __builtin_unreachable(); }
|
||
void set(size_t num_elems) {}
|
||
void setBufSize(size_t buf_size_) {}
|
||
};
|
||
|
||
typedef HashMap<UInt64, AggregateDataPtr, TrivialHash, HashTableFixedGrower<8>> AggregatedDataWithUInt8Key;
|
||
typedef HashMap<UInt64, AggregateDataPtr, TrivialHash, HashTableFixedGrower<16>> AggregatedDataWithUInt16Key;
|
||
|
||
template <typename FieldType>
|
||
struct AggregatedDataWithUIntKey
|
||
{
|
||
using Type = AggregatedDataWithUInt64Key;
|
||
static constexpr bool never_overflows = false;
|
||
};
|
||
|
||
template <>
|
||
struct AggregatedDataWithUIntKey<UInt8>
|
||
{
|
||
using Type = AggregatedDataWithUInt8Key;
|
||
static constexpr bool never_overflows = true; /// Говорит о том, что в результате агрегации не может быть много записей.
|
||
};
|
||
|
||
template <>
|
||
struct AggregatedDataWithUIntKey<UInt16>
|
||
{
|
||
using Type = AggregatedDataWithUInt16Key;
|
||
static constexpr bool never_overflows = true;
|
||
};
|
||
|
||
|
||
/// Для случая, когда есть один числовой ключ.
|
||
template <typename FieldType> /// UInt8/16/32/64 для любых типов соответствующей битности.
|
||
struct AggregationMethodOneNumber
|
||
{
|
||
typedef typename AggregatedDataWithUIntKey<FieldType>::Type Data;
|
||
typedef typename Data::key_type Key;
|
||
typedef typename Data::mapped_type Mapped;
|
||
typedef typename Data::iterator iterator;
|
||
typedef typename Data::const_iterator const_iterator;
|
||
|
||
static constexpr bool never_overflows = AggregatedDataWithUIntKey<FieldType>::never_overflows;
|
||
|
||
Data data;
|
||
|
||
const ColumnVector<FieldType> * column;
|
||
|
||
/** Вызывается в начале обработки каждого блока.
|
||
* Устанавливает переменные, необходимые для остальных методов, вызываемых во внутренних циклах.
|
||
*/
|
||
void init(ConstColumnPlainPtrs & key_columns)
|
||
{
|
||
column = static_cast<const ColumnVector<FieldType> *>(key_columns[0]);
|
||
}
|
||
|
||
/// Достать из ключевых столбцов ключ для вставки в хэш-таблицу.
|
||
Key getKey(
|
||
const ConstColumnPlainPtrs & key_columns, /// Ключевые столбцы.
|
||
size_t keys_size, /// Количество ключевых столбцов.
|
||
size_t i, /// Из какой строки блока достать ключ.
|
||
const Sizes & key_sizes, /// Если ключи фиксированной длины - их длины. Не используется в методах агрегации по ключам переменной длины.
|
||
StringRefs & keys) const /// Сюда могут быть записаны ссылки на данные ключей в столбцах. Они могут быть использованы в дальнейшем.
|
||
{
|
||
return column->get64(i);
|
||
}
|
||
|
||
/// Из значения в хэш-таблице получить AggregateDataPtr.
|
||
static AggregateDataPtr & getAggregateData(Mapped & value) { return value; }
|
||
static const AggregateDataPtr & getAggregateData(const Mapped & value) { return value; }
|
||
|
||
/** Разместить дополнительные данные, если это необходимо, в случае, когда в хэш-таблицу был вставлен новый ключ.
|
||
*/
|
||
static void onNewKey(iterator & it, size_t keys_size, size_t i, StringRefs & keys, Arena & pool)
|
||
{
|
||
}
|
||
|
||
/** Вставить ключ из хэш-таблицы в столбцы.
|
||
*/
|
||
static void insertKeyIntoColumns(const_iterator & it, ColumnPlainPtrs & key_columns, size_t keys_size, const Sizes & key_sizes)
|
||
{
|
||
static_cast<ColumnVector<FieldType> *>(key_columns[0])->insertData(reinterpret_cast<const char *>(&it->first), sizeof(it->first));
|
||
}
|
||
};
|
||
|
||
|
||
/// Для случая, когда есть один строковый ключ.
|
||
struct AggregationMethodString
|
||
{
|
||
typedef AggregatedDataWithStringKey Data;
|
||
typedef Data::key_type Key;
|
||
typedef Data::mapped_type Mapped;
|
||
typedef Data::iterator iterator;
|
||
typedef Data::const_iterator const_iterator;
|
||
|
||
static constexpr bool never_overflows = false;
|
||
|
||
Data data;
|
||
|
||
const ColumnString::Offsets_t * offsets;
|
||
const ColumnString::Chars_t * chars;
|
||
|
||
void init(ConstColumnPlainPtrs & key_columns)
|
||
{
|
||
const IColumn & column = *key_columns[0];
|
||
const ColumnString & column_string = static_cast<const ColumnString &>(column);
|
||
offsets = &column_string.getOffsets();
|
||
chars = &column_string.getChars();
|
||
}
|
||
|
||
Key getKey(
|
||
const ConstColumnPlainPtrs & key_columns,
|
||
size_t keys_size,
|
||
size_t i,
|
||
const Sizes & key_sizes,
|
||
StringRefs & keys) const
|
||
{
|
||
return StringRef(&(*chars)[i == 0 ? 0 : (*offsets)[i - 1]], (i == 0 ? (*offsets)[i] : ((*offsets)[i] - (*offsets)[i - 1])) - 1);
|
||
}
|
||
|
||
static AggregateDataPtr & getAggregateData(Mapped & value) { return value; }
|
||
static const AggregateDataPtr & getAggregateData(const Mapped & value) { return value; }
|
||
|
||
static void onNewKey(iterator & it, size_t keys_size, size_t i, StringRefs & keys, Arena & pool)
|
||
{
|
||
it->first.data = pool.insert(it->first.data, it->first.size);
|
||
}
|
||
|
||
static void insertKeyIntoColumns(const_iterator & it, ColumnPlainPtrs & key_columns, size_t keys_size, const Sizes & key_sizes)
|
||
{
|
||
key_columns[0]->insertData(it->first.data, it->first.size);
|
||
}
|
||
};
|
||
|
||
|
||
/// Для случая, когда есть один строковый ключ фиксированной длины.
|
||
struct AggregationMethodFixedString
|
||
{
|
||
typedef AggregatedDataWithStringKey Data;
|
||
typedef Data::key_type Key;
|
||
typedef Data::mapped_type Mapped;
|
||
typedef Data::iterator iterator;
|
||
typedef Data::const_iterator const_iterator;
|
||
|
||
static constexpr bool never_overflows = false;
|
||
|
||
Data data;
|
||
|
||
size_t n;
|
||
const ColumnFixedString::Chars_t * chars;
|
||
|
||
void init(ConstColumnPlainPtrs & key_columns)
|
||
{
|
||
const IColumn & column = *key_columns[0];
|
||
const ColumnFixedString & column_string = static_cast<const ColumnFixedString &>(column);
|
||
n = column_string.getN();
|
||
chars = &column_string.getChars();
|
||
}
|
||
|
||
Key getKey(
|
||
const ConstColumnPlainPtrs & key_columns,
|
||
size_t keys_size,
|
||
size_t i,
|
||
const Sizes & key_sizes,
|
||
StringRefs & keys) const
|
||
{
|
||
return StringRef(&(*chars)[i * n], n);
|
||
}
|
||
|
||
static AggregateDataPtr & getAggregateData(Mapped & value) { return value; }
|
||
static const AggregateDataPtr & getAggregateData(const Mapped & value) { return value; }
|
||
|
||
static void onNewKey(iterator & it, size_t keys_size, size_t i, StringRefs & keys, Arena & pool)
|
||
{
|
||
it->first.data = pool.insert(it->first.data, it->first.size);
|
||
}
|
||
|
||
static void insertKeyIntoColumns(const_iterator & it, ColumnPlainPtrs & key_columns, size_t keys_size, const Sizes & key_sizes)
|
||
{
|
||
key_columns[0]->insertData(it->first.data, it->first.size);
|
||
}
|
||
};
|
||
|
||
|
||
/// Для случая, когда все ключи фиксированной длины, и они помещаются в 128 бит.
|
||
struct AggregationMethodKeys128
|
||
{
|
||
typedef AggregatedDataWithKeys128 Data;
|
||
typedef Data::key_type Key;
|
||
typedef Data::mapped_type Mapped;
|
||
typedef Data::iterator iterator;
|
||
typedef Data::const_iterator const_iterator;
|
||
|
||
static constexpr bool never_overflows = false;
|
||
|
||
Data data;
|
||
|
||
void init(ConstColumnPlainPtrs & key_columns)
|
||
{
|
||
}
|
||
|
||
Key getKey(
|
||
const ConstColumnPlainPtrs & key_columns,
|
||
size_t keys_size,
|
||
size_t i,
|
||
const Sizes & key_sizes,
|
||
StringRefs & keys) const
|
||
{
|
||
return pack128(i, keys_size, key_columns, key_sizes);
|
||
}
|
||
|
||
static AggregateDataPtr & getAggregateData(Mapped & value) { return value; }
|
||
static const AggregateDataPtr & getAggregateData(const Mapped & value) { return value; }
|
||
|
||
static void onNewKey(iterator & it, size_t keys_size, size_t i, StringRefs & keys, Arena & pool)
|
||
{
|
||
}
|
||
|
||
static void insertKeyIntoColumns(const_iterator & it, ColumnPlainPtrs & key_columns, size_t keys_size, const Sizes & key_sizes)
|
||
{
|
||
size_t offset = 0;
|
||
for (size_t i = 0; i < keys_size; ++i)
|
||
{
|
||
size_t size = key_sizes[i];
|
||
key_columns[i]->insertData(reinterpret_cast<const char *>(&it->first) + offset, size);
|
||
offset += size;
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
/// Для остальных случаев. Агрегирует по 128 битному хэшу от ключа. (При этом, строки, содержащие нули посередине, могут склеиться.)
|
||
struct AggregationMethodHashed
|
||
{
|
||
typedef AggregatedDataHashed Data;
|
||
typedef Data::key_type Key;
|
||
typedef Data::mapped_type Mapped;
|
||
typedef Data::iterator iterator;
|
||
typedef Data::const_iterator const_iterator;
|
||
|
||
static constexpr bool never_overflows = false;
|
||
|
||
Data data;
|
||
|
||
void init(ConstColumnPlainPtrs & key_columns)
|
||
{
|
||
}
|
||
|
||
Key getKey(
|
||
const ConstColumnPlainPtrs & key_columns,
|
||
size_t keys_size,
|
||
size_t i,
|
||
const Sizes & key_sizes,
|
||
StringRefs & keys) const
|
||
{
|
||
return hash128(i, keys_size, key_columns, keys);
|
||
}
|
||
|
||
static AggregateDataPtr & getAggregateData(Mapped & value) { return value.second; }
|
||
static const AggregateDataPtr & getAggregateData(const Mapped & value) { return value.second; }
|
||
|
||
static void onNewKey(iterator & it, size_t keys_size, size_t i, StringRefs & keys, Arena & pool)
|
||
{
|
||
it->second.first = placeKeysInPool(i, keys_size, keys, pool);
|
||
}
|
||
|
||
static void insertKeyIntoColumns(const_iterator & it, ColumnPlainPtrs & key_columns, size_t keys_size, const Sizes & key_sizes)
|
||
{
|
||
for (size_t i = 0; i < keys_size; ++i)
|
||
key_columns[i]->insertDataWithTerminatingZero(it->second.first[i].data, it->second.first[i].size);
|
||
}
|
||
};
|
||
|
||
|
||
class Aggregator;
|
||
|
||
struct AggregatedDataVariants : private boost::noncopyable
|
||
{
|
||
/** Работа с состояниями агрегатных функций в пуле устроена следующим (неудобным) образом:
|
||
* - при агрегации, состояния создаются в пуле с помощью функции IAggregateFunction::create (внутри - placement new произвольной структуры);
|
||
* - они должны быть затем уничтожены с помощью IAggregateFunction::destroy (внутри - вызов деструктора произвольной структуры);
|
||
* - если агрегация завершена, то, в функции Aggregator::convertToBlock, указатели на состояния агрегатных функций
|
||
* записываются в ColumnAggregateFunction; ColumnAggregateFunction "захватывает владение" ими, то есть - вызывает destroy в своём деструкторе.
|
||
* - если при агрегации, до вызова Aggregator::convertToBlock вылетело исключение, то состояния агрегатных функций всё-равно должны быть уничтожены,
|
||
* иначе для сложных состояний (наприемер, AggregateFunctionUniq), будут утечки памяти;
|
||
* - чтобы, в этом случае, уничтожить состояния, в деструкторе вызывается метод Aggregator::destroyAggregateStates,
|
||
* но только если переменная aggregator (см. ниже) не nullptr;
|
||
* - то есть, пока вы не передали владение состояниями агрегатных функций в ColumnAggregateFunction, установите переменную aggregator,
|
||
* чтобы при возникновении исключения, состояния были корректно уничтожены.
|
||
*
|
||
* PS. Это можно исправить, сделав пул, который знает о том, какие состояния агрегатных функций и в каком порядке в него уложены, и умеет сам их уничтожать.
|
||
* Но это вряд ли можно просто сделать, так как в этот же пул планируется класть строки переменной длины.
|
||
* В этом случае, пул не сможет знать, по каким смещениям хранятся объекты.
|
||
*/
|
||
Aggregator * aggregator = nullptr;
|
||
|
||
size_t keys_size; /// Количество ключей NOTE нужно ли это поле?
|
||
Sizes key_sizes; /// Размеры ключей, если ключи фиксированной длины
|
||
|
||
/// Пулы для состояний агрегатных функций. Владение потом будет передано в ColumnAggregateFunction.
|
||
Arenas aggregates_pools;
|
||
Arena * aggregates_pool; /// Пул, который сейчас используется для аллокации.
|
||
|
||
/** Специализация для случая, когда ключи отсутствуют, и для ключей, не попавших в max_rows_to_group_by.
|
||
*/
|
||
AggregatedDataWithoutKey without_key = nullptr;
|
||
|
||
std::unique_ptr<AggregationMethodOneNumber<UInt8>> key8;
|
||
std::unique_ptr<AggregationMethodOneNumber<UInt16>> key16;
|
||
std::unique_ptr<AggregationMethodOneNumber<UInt32>> key32;
|
||
std::unique_ptr<AggregationMethodOneNumber<UInt64>> key64;
|
||
std::unique_ptr<AggregationMethodString> key_string;
|
||
std::unique_ptr<AggregationMethodFixedString> key_fixed_string;
|
||
std::unique_ptr<AggregationMethodKeys128> keys128;
|
||
std::unique_ptr<AggregationMethodHashed> hashed;
|
||
|
||
enum Type
|
||
{
|
||
EMPTY = 0,
|
||
WITHOUT_KEY,
|
||
KEY_8,
|
||
KEY_16,
|
||
KEY_32,
|
||
KEY_64,
|
||
KEY_STRING,
|
||
KEY_FIXED_STRING,
|
||
KEYS_128,
|
||
HASHED,
|
||
};
|
||
Type type = EMPTY;
|
||
|
||
AggregatedDataVariants() : aggregates_pools(1, new Arena), aggregates_pool(&*aggregates_pools.back()) {}
|
||
bool empty() const { return type == EMPTY; }
|
||
|
||
~AggregatedDataVariants();
|
||
|
||
void init(Type type_)
|
||
{
|
||
type = type_;
|
||
|
||
switch (type)
|
||
{
|
||
case EMPTY: break;
|
||
case WITHOUT_KEY: break;
|
||
case KEY_8: key8 .reset(new decltype(key8)::element_type); break;
|
||
case KEY_16: key16 .reset(new decltype(key16)::element_type); break;
|
||
case KEY_32: key32 .reset(new decltype(key32)::element_type); break;
|
||
case KEY_64: key64 .reset(new decltype(key64)::element_type); break;
|
||
case KEY_STRING: key_string .reset(new decltype(key_string)::element_type); break;
|
||
case KEY_FIXED_STRING: key_fixed_string.reset(new decltype(key_fixed_string)::element_type); break;
|
||
case KEYS_128: keys128 .reset(new decltype(keys128)::element_type); break;
|
||
case HASHED: hashed .reset(new decltype(hashed)::element_type); break;
|
||
|
||
default:
|
||
throw Exception("Unknown aggregated data variant.", ErrorCodes::UNKNOWN_AGGREGATED_DATA_VARIANT);
|
||
}
|
||
}
|
||
|
||
size_t size() const
|
||
{
|
||
switch (type)
|
||
{
|
||
case EMPTY: return 0;
|
||
case WITHOUT_KEY: return 1;
|
||
case KEY_8: return key8->data.size() + (without_key != nullptr);
|
||
case KEY_16: return key16->data.size() + (without_key != nullptr);
|
||
case KEY_32: return key32->data.size() + (without_key != nullptr);
|
||
case KEY_64: return key64->data.size() + (without_key != nullptr);
|
||
case KEY_STRING: return key_string->data.size() + (without_key != nullptr);
|
||
case KEY_FIXED_STRING: return key_fixed_string->data.size() + (without_key != nullptr);
|
||
case KEYS_128: return keys128->data.size() + (without_key != nullptr);
|
||
case HASHED: return hashed->data.size() + (without_key != nullptr);
|
||
|
||
default:
|
||
throw Exception("Unknown aggregated data variant.", ErrorCodes::UNKNOWN_AGGREGATED_DATA_VARIANT);
|
||
}
|
||
}
|
||
|
||
const char * getMethodName() const
|
||
{
|
||
switch (type)
|
||
{
|
||
case EMPTY: return "EMPTY";
|
||
case WITHOUT_KEY: return "WITHOUT_KEY";
|
||
case KEY_8: return "KEY_8";
|
||
case KEY_16: return "KEY_16";
|
||
case KEY_32: return "KEY_32";
|
||
case KEY_64: return "KEY_64";
|
||
case KEY_STRING: return "KEY_STRING";
|
||
case KEY_FIXED_STRING: return "KEY_FIXED_STRING";
|
||
case KEYS_128: return "KEYS_128";
|
||
case HASHED: return "HASHED";
|
||
|
||
default:
|
||
throw Exception("Unknown aggregated data variant.", ErrorCodes::UNKNOWN_AGGREGATED_DATA_VARIANT);
|
||
}
|
||
}
|
||
};
|
||
|
||
typedef SharedPtr<AggregatedDataVariants> AggregatedDataVariantsPtr;
|
||
typedef std::vector<AggregatedDataVariantsPtr> ManyAggregatedDataVariants;
|
||
|
||
|
||
/** Агрегирует источник блоков.
|
||
*/
|
||
class Aggregator
|
||
{
|
||
public:
|
||
Aggregator(const ColumnNumbers & keys_, const AggregateDescriptions & aggregates_, bool overflow_row_,
|
||
size_t max_rows_to_group_by_ = 0, OverflowMode group_by_overflow_mode_ = OverflowMode::THROW)
|
||
: keys(keys_), aggregates(aggregates_), aggregates_size(aggregates.size()),
|
||
overflow_row(overflow_row_),
|
||
max_rows_to_group_by(max_rows_to_group_by_), group_by_overflow_mode(group_by_overflow_mode_),
|
||
log(&Logger::get("Aggregator"))
|
||
{
|
||
std::sort(keys.begin(), keys.end());
|
||
keys.erase(std::unique(keys.begin(), keys.end()), keys.end());
|
||
keys_size = keys.size();
|
||
}
|
||
|
||
Aggregator(const Names & key_names_, const AggregateDescriptions & aggregates_, bool overflow_row_,
|
||
size_t max_rows_to_group_by_ = 0, OverflowMode group_by_overflow_mode_ = OverflowMode::THROW)
|
||
: key_names(key_names_), aggregates(aggregates_), aggregates_size(aggregates.size()),
|
||
overflow_row(overflow_row_),
|
||
max_rows_to_group_by(max_rows_to_group_by_), group_by_overflow_mode(group_by_overflow_mode_),
|
||
log(&Logger::get("Aggregator"))
|
||
{
|
||
std::sort(key_names.begin(), key_names.end());
|
||
key_names.erase(std::unique(key_names.begin(), key_names.end()), key_names.end());
|
||
keys_size = key_names.size();
|
||
}
|
||
|
||
/// Агрегировать источник. Получить результат в виде одной из структур данных.
|
||
void execute(BlockInputStreamPtr stream, AggregatedDataVariants & result);
|
||
|
||
typedef std::vector<ConstColumnPlainPtrs> AggregateColumns;
|
||
typedef std::vector<ColumnAggregateFunction::Container_t *> AggregateColumnsData;
|
||
|
||
/// Обработать один блок. Вернуть false, если обработку следует прервать (при group_by_overflow_mode = 'break').
|
||
bool executeOnBlock(Block & block, AggregatedDataVariants & result,
|
||
ConstColumnPlainPtrs & key_columns, AggregateColumns & aggregate_columns, /// Передаются, чтобы не создавать их заново на каждый блок
|
||
Sizes & key_sizes, StringRefs & keys, /// - передайте соответствующие объекты, которые изначально пустые.
|
||
bool & no_more_keys);
|
||
|
||
/** Преобразовать структуру данных агрегации в блок.
|
||
* Если overflow_row = true, то агрегаты для строк, не попавших в max_rows_to_group_by, кладутся в первую строчку возвращаемого блока.
|
||
*
|
||
* Если final = false, то в качестве столбцов-агрегатов создаются ColumnAggregateFunction с состоянием вычислений,
|
||
* которые могут быть затем объединены с другими состояниями (для распределённой обработки запроса).
|
||
* Если final = true, то в качестве столбцов-агрегатов создаются столбцы с готовыми значениями.
|
||
*/
|
||
Block convertToBlock(AggregatedDataVariants & data_variants, bool final);
|
||
|
||
/** Объединить несколько структур данных агрегации в одну. (В первый непустой элемент массива.) Все варианты агрегации должны быть одинаковыми!
|
||
* После объединения, все стркутуры агрегации (а не только те, в которую они будут слиты) должны жить, пока не будет вызвана функция convertToBlock.
|
||
* Это нужно, так как в слитом результате могут остаться указатели на память в пуле, которым владеют другие структуры агрегации.
|
||
*/
|
||
AggregatedDataVariantsPtr merge(ManyAggregatedDataVariants & data_variants);
|
||
|
||
/** Объединить несколько агрегированных блоков в одну структуру данных.
|
||
* (Доагрегировать несколько блоков, которые представляют собой результат независимых агрегаций с удалённых серверов.)
|
||
* Если overflow_row = true, то предполагается, что агрегаты для строк, не попавших в max_rows_to_group_by, расположены в первой строке каждого блока.
|
||
*/
|
||
void merge(BlockInputStreamPtr stream, AggregatedDataVariants & result);
|
||
|
||
/// Для IBlockInputStream.
|
||
String getID() const;
|
||
|
||
protected:
|
||
friend struct AggregatedDataVariants;
|
||
|
||
ColumnNumbers keys;
|
||
Names key_names;
|
||
AggregateDescriptions aggregates;
|
||
std::vector<IAggregateFunction *> aggregate_functions;
|
||
size_t keys_size;
|
||
size_t aggregates_size;
|
||
/// Нужно ли класть в AggregatedDataVariants::without_key агрегаты для ключей, не попавших в max_rows_to_group_by.
|
||
bool overflow_row;
|
||
|
||
Sizes offsets_of_aggregate_states; /// Смещение до n-ой агрегатной функции в строке из агрегатных функций.
|
||
size_t total_size_of_aggregate_states = 0; /// Суммарный размер строки из агрегатных функций.
|
||
bool all_aggregates_has_trivial_destructor = false;
|
||
|
||
/// Для инициализации от первого блока при конкуррентном использовании.
|
||
bool initialized = false;
|
||
Poco::FastMutex mutex;
|
||
|
||
size_t max_rows_to_group_by;
|
||
OverflowMode group_by_overflow_mode;
|
||
|
||
Block sample;
|
||
|
||
Logger * log;
|
||
|
||
/** Если заданы только имена столбцов (key_names, а также aggregates[i].column_name), то вычислить номера столбцов.
|
||
* Сформировать блок - пример результата.
|
||
*/
|
||
void initialize(Block & block);
|
||
|
||
/** Выбрать способ агрегации на основе количества и типов ключей. */
|
||
AggregatedDataVariants::Type chooseAggregationMethod(const ConstColumnPlainPtrs & key_columns, Sizes & key_sizes);
|
||
|
||
/** Создать состояния агрегатных функций для одного ключа.
|
||
*/
|
||
void createAggregateStates(AggregateDataPtr & aggregate_data) const;
|
||
|
||
/** Вызвать методы destroy для состояний агрегатных функций.
|
||
* Используется в обработчике исключений при агрегации, так как RAII в данном случае не применим.
|
||
*/
|
||
void destroyAllAggregateStates(AggregatedDataVariants & result);
|
||
|
||
|
||
template <typename Method>
|
||
void executeImpl(
|
||
Method & method,
|
||
Arena * aggregates_pool,
|
||
size_t rows,
|
||
ConstColumnPlainPtrs & key_columns,
|
||
AggregateColumns & aggregate_columns,
|
||
const Sizes & key_sizes,
|
||
StringRefs & keys,
|
||
bool no_more_keys,
|
||
AggregateDataPtr overflow_row) const;
|
||
|
||
template <typename Method>
|
||
void convertToBlockImpl(
|
||
Method & method,
|
||
ColumnPlainPtrs & key_columns,
|
||
AggregateColumnsData & aggregate_columns,
|
||
ColumnPlainPtrs & final_aggregate_columns,
|
||
const Sizes & key_sizes,
|
||
size_t start_row, bool final) const;
|
||
|
||
template <typename Method>
|
||
void mergeDataImpl(
|
||
Method & method_dst,
|
||
Method & method_src) const;
|
||
|
||
template <typename Method>
|
||
void mergeStreamsImpl(
|
||
Method & method,
|
||
Arena * aggregates_pool,
|
||
size_t start_row,
|
||
size_t rows,
|
||
ConstColumnPlainPtrs & key_columns,
|
||
AggregateColumnsData & aggregate_columns,
|
||
const Sizes & key_sizes,
|
||
StringRefs & keys) const;
|
||
|
||
template <typename Method>
|
||
void destroyImpl(
|
||
Method & method) const;
|
||
};
|
||
|
||
|
||
}
|