thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-11-21 23:21:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

dbms: JOINs: development [#METR-11370].

Browse Source
This commit is contained in:
Alexey Milovidov 2014-06-19 00:08:31 +04:00
parent 2a25c8a4c0
commit efbd0de1ee
3 changed files with 251 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
dbms/include/DB/Interpreters/Join.h
View File

@ -84,10 +84,37 @@ public:
/** Разные структуры данных, которые могут использоваться для соединения.
*/
typedef HashMap<UInt64, RowRef> MapUInt64;
typedef HashMapWithSavedHash<StringRef, RowRef> MapString;
typedef HashMap<UInt128, RowRef, UInt128Hash> MapHashed;
struct MapsAny
{
/// Специализация для случая, когда есть один числовой ключ.
typedef HashMap<UInt64, RowRef> MapUInt64;
/// Специализация для случая, когда есть один строковый ключ.
typedef HashMapWithSavedHash<StringRef, RowRef> MapString;
/** Сравнивает 128 битные хэши.
* Если все ключи фиксированной длины, влезающие целиком в 128 бит, то укладывает их без изменений в 128 бит.
* Иначе - вычисляет SipHash от набора из всех ключей.
* (При этом, строки, содержащие нули посередине, могут склеиться.)
*/
typedef HashMap<UInt128, RowRef, UInt128Hash> MapHashed;
std::unique_ptr<MapUInt64> key64;
std::unique_ptr<MapString> key_string;
std::unique_ptr<MapHashed> hashed;
};
struct MapsAll
{
typedef HashMap<UInt64, RowRefList> MapUInt64;
typedef HashMapWithSavedHash<StringRef, RowRefList> MapString;
typedef HashMap<UInt128, RowRefList, UInt128Hash> MapHashed;
std::unique_ptr<MapUInt64> key64;
std::unique_ptr<MapString> key_string;
std::unique_ptr<MapHashed> hashed;
};
private:
ASTJoin::Kind kind;
ASTJoin::Strictness strictness;
@ -114,18 +141,8 @@ private:
size_t rows_in_external_table;
bool only_external;
/// Специализация для случая, когда есть один числовой ключ.
std::unique_ptr<MapUInt64> key64;
/// Специализация для случая, когда есть один строковый ключ.
std::unique_ptr<MapString> key_string;
/** Сравнивает 128 битные хэши.
* Если все ключи фиксированной длины, влезающие целиком в 128 бит, то укладывает их без изменений в 128 бит.
* Иначе - вычисляет SipHash от набора из всех ключей.
* (При этом, строки, содержащие нули посередине, могут склеиться.)
*/
std::unique_ptr<MapHashed> hashed;
MapsAny maps_any;
MapsAll maps_all;
/// Дополнительные данные - строки, а также продолжения односвязных списков строк.
Arena pool;
@ -142,21 +159,10 @@ private:
size_t max_bytes;
OverflowMode overflow_mode;
void init(Set::Type type_)
{
type = type_;
void init(Set::Type type_);
switch (type)
{
case Set::EMPTY: break;
case Set::KEY_64: key64 .reset(new MapUInt64); break;
case Set::KEY_STRING: key_string .reset(new MapString); break;
case Set::HASHED: hashed .reset(new MapHashed); break;
default:
throw Exception("Unknown JOIN keys variant.", ErrorCodes::UNKNOWN_AGGREGATED_DATA_VARIANT);
}
}
template <ASTJoin::Strictness STRICTNESS, typename Maps>
void insertFromBlockImpl(Maps & maps, size_t rows, const ConstColumnPlainPtrs & key_columns, size_t keys_size, Block * stored_block);
template <ASTJoin::Kind KIND>
void anyJoinBlock(Block & block);

23
dbms/include/DB/Interpreters/Set.h
View File

@ -30,8 +30,6 @@ namespace DB
*/
class Set
{
friend class Join;
public:
Set(const Limits & limits)
: max_bytes_to_transfer(limits.max_bytes_to_transfer),
@ -95,7 +93,17 @@ public:
/// проверяет есть ли в Set элементы для заданного диапазона индекса
BoolMask mayBeTrueInRange(const Range & range);
enum Type
{
EMPTY = 0,
KEY_64 = 1,
KEY_STRING = 2,
HASHED = 3,
};
static Type chooseMethod(const ConstColumnPlainPtrs & key_columns, bool & keys_fit_128_bits, Sizes & key_sizes);
private:
/** Разные структуры данных, которые могут использоваться для проверки принадлежности
* одного или нескольких столбцов значений множеству.
@ -129,13 +137,6 @@ private:
*/
std::unique_ptr<SetHashed> hashed;
enum Type
{
EMPTY = 0,
KEY_64 = 1,
KEY_STRING = 2,
HASHED = 3,
};
Type type = EMPTY;
bool keys_fit_128_bits;
@ -153,8 +154,6 @@ private:
size_t max_bytes;
OverflowMode overflow_mode;
static Type chooseMethod(const ConstColumnPlainPtrs & key_columns, bool & keys_fit_128_bits, Sizes & key_sizes);
void init(Type type_)
{
type = type_;

294
dbms/src/Interpreters/Join.cpp
View File

@ -8,30 +8,77 @@
namespace DB
{
size_t Join::getTotalRowCount() const
template <typename Maps>
static void initImpl(Maps & maps, Set::Type type)
{
switch (type)
{
case Set::EMPTY: break;
case Set::KEY_64: maps.key64 .reset(new typename Maps::MapUInt64); break;
case Set::KEY_STRING: maps.key_string .reset(new typename Maps::MapString); break;
case Set::HASHED: maps.hashed .reset(new typename Maps::MapHashed); break;
default:
throw Exception("Unknown JOIN keys variant.", ErrorCodes::UNKNOWN_AGGREGATED_DATA_VARIANT);
}
}
template <typename Maps>
static size_t getTotalRowCountImpl(const Maps & maps)
{
size_t rows = 0;
if (key64)
rows += key64->size();
if (key_string)
rows += key_string->size();
if (hashed)
rows += hashed->size();
if (maps.key64)
rows += maps.key64->size();
if (maps.key_string)
rows += maps.key_string->size();
if (maps.hashed)
rows += maps.hashed->size();
return rows;
}
template <typename Maps>
static size_t getTotalByteCountImpl(const Maps & maps)
{
size_t bytes = 0;
if (maps.key64)
bytes += maps.key64->getBufferSizeInBytes();
if (maps.key_string)
bytes += maps.key_string->getBufferSizeInBytes();
if (maps.hashed)
bytes += maps.hashed->getBufferSizeInBytes();
return bytes;
}
void Join::init(Set::Type type_)
{
type = type_;
if (strictness == ASTJoin::Any)
initImpl(maps_any, type);
else
initImpl(maps_all, type);
}
size_t Join::getTotalRowCount() const
{
if (strictness == ASTJoin::Any)
return getTotalRowCountImpl(maps_any);
else
return getTotalRowCountImpl(maps_all);
}
size_t Join::getTotalByteCount() const
{
size_t bytes = 0;
if (key64)
bytes += key64->getBufferSizeInBytes();
if (key_string)
bytes += key_string->getBufferSizeInBytes();
if (hashed)
bytes += hashed->getBufferSizeInBytes();
bytes += pool.size();
return bytes;
size_t bytes;
if (strictness == ASTJoin::Any)
bytes = getTotalByteCountImpl(maps_any);
else
bytes = getTotalByteCountImpl(maps_all);
return bytes + pool.size();
}
@ -55,6 +102,7 @@ bool Join::checkExternalSizeLimits() const
}
/// Вставка элемента в хэш-таблицу вида ключ -> ссылка на строку, которая затем будет использоваться при JOIN-е.
template <ASTJoin::Strictness STRICTNESS, typename Map>
struct Inserter
{
@ -75,12 +123,13 @@ struct Inserter<ASTJoin::Any, Map>
}
};
/// Для строковых ключей отличается тем, что саму строчку надо разместить в пуле.
template <>
struct Inserter<ASTJoin::Any, Join::MapString>
struct Inserter<ASTJoin::Any, Join::MapsAny::MapString>
{
static void insert(Join::MapString & map, const Join::MapString::key_type & key, Block * stored_block, size_t i, Arena & pool)
static void insert(Join::MapsAny::MapString & map, const Join::MapsAny::MapString::key_type & key, Block * stored_block, size_t i, Arena & pool)
{
Join::MapString::iterator it;
Join::MapsAny::MapString::iterator it;
bool inserted;
map.emplace(key, it, inserted);
@ -92,6 +141,133 @@ struct Inserter<ASTJoin::Any, Join::MapString>
}
};
template <typename Map>
struct Inserter<ASTJoin::All, Map>
{
static void insert(Map & map, const typename Map::key_type & key, Block * stored_block, size_t i, Arena & pool)
{
typename Map::iterator it;
bool inserted;
map.emplace(key, it, inserted);
if (inserted)
{
new (&it->second) Join::RowRefList(stored_block, i);
}
else
{
/** Первый элемент списка хранится в значении хэш-таблицы, остальные - в pool-е.
* Мы будем вставлять каждый раз элемент на место второго.
* То есть, бывший второй элемент, если он был, станет третьим, и т. п.
*/
Join::RowRefList * elem = reinterpret_cast<Join::RowRefList *>(pool.alloc(sizeof(Join::RowRefList)));
it->second.next = elem;
elem->next = it->second.next;
elem->block = stored_block;
elem->row_num = i;
}
}
};
template <>
struct Inserter<ASTJoin::All, Join::MapsAll::MapString>
{
static void insert(Join::MapsAll::MapString & map, const Join::MapsAll::MapString::key_type & key, Block * stored_block, size_t i, Arena & pool)
{
typename Join::MapsAll::MapString::iterator it;
bool inserted;
map.emplace(key, it, inserted);
if (inserted)
{
it->first.data = pool.insert(key.data, key.size);
new (&it->second) Join::RowRefList(stored_block, i);
}
else
{
Join::RowRefList * elem = reinterpret_cast<Join::RowRefList *>(pool.alloc(sizeof(Join::RowRefList)));
it->second.next = elem;
elem->next = it->second.next;
elem->block = stored_block;
elem->row_num = i;
}
}
};
template <ASTJoin::Strictness STRICTNESS, typename Maps>
void Join::insertFromBlockImpl(Maps & maps, size_t rows, const ConstColumnPlainPtrs & key_columns, size_t keys_size, Block * stored_block)
{
if (type == Set::KEY_64)
{
typedef typename Maps::MapUInt64 Map;
Map & res = *maps.key64;
const IColumn & column = *key_columns[0];
/// Для всех строчек
for (size_t i = 0; i < rows; ++i)
{
/// Строим ключ
UInt64 key = column.get64(i);
Inserter<STRICTNESS, Map>::insert(res, key, stored_block, i, pool);
}
}
else if (type == Set::KEY_STRING)
{
typedef typename Maps::MapString Map;
Map & res = *maps.key_string;
const IColumn & column = *key_columns[0];
if (const ColumnString * column_string = dynamic_cast<const ColumnString *>(&column))
{
const ColumnString::Offsets_t & offsets = column_string->getOffsets();
const ColumnString::Chars_t & data = column_string->getChars();
/// Для всех строчек
for (size_t i = 0; i < rows; ++i)
{
/// Строим ключ
StringRef key(&data[i == 0 ? 0 : offsets[i - 1]], (i == 0 ? offsets[i] : (offsets[i] - offsets[i - 1])) - 1);
Inserter<STRICTNESS, Map>::insert(res, key, stored_block, i, pool);
}
}
else if (const ColumnFixedString * column_string = dynamic_cast<const ColumnFixedString *>(&column))
{
size_t n = column_string->getN();
const ColumnFixedString::Chars_t & data = column_string->getChars();
/// Для всех строчек
for (size_t i = 0; i < rows; ++i)
{
/// Строим ключ
StringRef key(&data[i * n], n);
Inserter<STRICTNESS, Map>::insert(res, key, stored_block, i, pool);
}
}
else
throw Exception("Illegal type of column when creating set with string key: " + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
}
else if (type == Set::HASHED)
{
typedef typename Maps::MapHashed Map;
Map & res = *maps.hashed;
/// Для всех строчек
for (size_t i = 0; i < rows; ++i)
{
UInt128 key = keys_fit_128_bits
? pack128(i, keys_size, key_columns, key_sizes)
: hash128(i, keys_size, key_columns);
Inserter<STRICTNESS, Map>::insert(res, key, stored_block, i, pool);
}
}
else
throw Exception("Unknown JOIN variant.", ErrorCodes::UNKNOWN_SET_DATA_VARIANT);
}
bool Join::insertFromBlock(const Block & block)
{
@ -149,72 +325,10 @@ bool Join::insertFromBlock(const Block & block)
for (const auto & name : key_names)
stored_block->erase(stored_block->getPositionByName(name));
if (type == Set::KEY_64)
{
typedef MapUInt64 Map;
Map & res = *key64;
const IColumn & column = *key_columns[0];
/// Для всех строчек
for (size_t i = 0; i < rows; ++i)
{
/// Строим ключ
UInt64 key = column.get64(i);
Inserter<ASTJoin::Any, Map>::insert(res, key, stored_block, i, pool);
}
}
else if (type == Set::KEY_STRING)
{
typedef MapString Map;
Map & res = *key_string;
const IColumn & column = *key_columns[0];
if (const ColumnString * column_string = dynamic_cast<const ColumnString *>(&column))
{
const ColumnString::Offsets_t & offsets = column_string->getOffsets();
const ColumnString::Chars_t & data = column_string->getChars();
/// Для всех строчек
for (size_t i = 0; i < rows; ++i)
{
/// Строим ключ
StringRef key(&data[i == 0 ? 0 : offsets[i - 1]], (i == 0 ? offsets[i] : (offsets[i] - offsets[i - 1])) - 1);
Inserter<ASTJoin::Any, Map>::insert(res, key, stored_block, i, pool);
}
}
else if (const ColumnFixedString * column_string = dynamic_cast<const ColumnFixedString *>(&column))
{
size_t n = column_string->getN();
const ColumnFixedString::Chars_t & data = column_string->getChars();
/// Для всех строчек
for (size_t i = 0; i < rows; ++i)
{
/// Строим ключ
StringRef key(&data[i * n], n);
Inserter<ASTJoin::Any, Map>::insert(res, key, stored_block, i, pool);
}
}
else
throw Exception("Illegal type of column when creating set with string key: " + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
}
else if (type == Set::HASHED)
{
typedef MapHashed Map;
Map & res = *hashed;
/// Для всех строчек
for (size_t i = 0; i < rows; ++i)
{
UInt128 key = keys_fit_128_bits
? pack128(i, keys_size, key_columns, key_sizes)
: hash128(i, keys_size, key_columns);
Inserter<ASTJoin::Any, Map>::insert(res, key, stored_block, i, pool);
}
}
if (strictness == ASTJoin::Any)
insertFromBlockImpl<ASTJoin::Any, MapsAny>(maps_any, rows, key_columns, keys_size, stored_block);
else
throw Exception("Unknown JOIN variant.", ErrorCodes::UNKNOWN_SET_DATA_VARIANT);
insertFromBlockImpl<ASTJoin::All, MapsAll>(maps_all, rows, key_columns, keys_size, stored_block);
if (!checkSizeLimits())
{
@ -339,8 +453,8 @@ void Join::anyJoinBlock(Block & block)
if (type == Set::KEY_64)
{
typedef MapUInt64 Map;
const Map & map = *key64;
typedef MapsAny::MapUInt64 Map;
const Map & map = *maps_any.key64;
const IColumn & column = *key_columns[0];
/// Для всех строчек
@ -353,8 +467,8 @@ void Join::anyJoinBlock(Block & block)
}
else if (type == Set::KEY_STRING)
{
typedef MapString Map;
const Map & map = *key_string;
typedef MapsAny::MapString Map;
const Map & map = *maps_any.key_string;
const IColumn & column = *key_columns[0];
if (const ColumnString * column_string = dynamic_cast<const ColumnString *>(&column))
@ -388,8 +502,8 @@ void Join::anyJoinBlock(Block & block)
}
else if (type == Set::HASHED)
{
typedef MapHashed Map;
Map & map = *hashed;
typedef MapsAny::MapHashed Map;
Map & map = *maps_any.hashed;
/// Для всех строчек
for (size_t i = 0; i < rows; ++i)