ClickHouse/dbms/include/DB/Common/HashTable/HashSet.h

97 lines
2.3 KiB
C
Raw Normal View History

2014-03-17 02:01:03 +00:00
#pragma once
#include <DB/Common/HashTable/Hash.h>
#include <DB/Common/HashTable/HashTable.h>
#include <DB/Common/HashTable/HashTableAllocator.h>
#include <DB/IO/WriteBuffer.h>
#include <DB/IO/WriteHelpers.h>
#include <DB/IO/ReadBuffer.h>
#include <DB/IO/ReadHelpers.h>
#include <DB/IO/VarInt.h>
template
<
typename Key,
typename TCell,
2014-03-17 02:01:03 +00:00
typename Hash = DefaultHash<Key>,
2014-05-03 16:03:49 +00:00
typename Grower = HashTableGrower<>,
2014-03-17 02:01:03 +00:00
typename Allocator = HashTableAllocator
>
class HashSetTable : public HashTable<Key, TCell, Hash, Grower, Allocator>
2014-03-17 02:01:03 +00:00
{
public:
typedef HashSetTable<Key, TCell, Hash, Grower, Allocator> Self;
typedef TCell Cell;
2014-03-17 02:01:03 +00:00
void merge(const Self & rhs)
{
if (!this->hasZero() && rhs.hasZero())
2014-03-17 02:01:03 +00:00
{
this->setHasZero();
2014-03-17 02:01:03 +00:00
++this->m_size;
}
for (size_t i = 0; i < rhs.grower.bufSize(); ++i)
if (!rhs.buf[i].isZero(*this))
this->insert(Cell::getKey(rhs.buf[i].getValue()));
2014-03-17 02:01:03 +00:00
}
void readAndMerge(DB::ReadBuffer & rb)
{
Cell::State::read(rb);
2014-03-17 02:01:03 +00:00
size_t new_size = 0;
DB::readVarUInt(new_size, rb);
this->resize(new_size);
for (size_t i = 0; i < new_size; ++i)
{
Cell x;
x.read(rb);
this->insert(Cell::getKey(x.getValue()));
2014-03-17 02:01:03 +00:00
}
}
};
template <typename Key, typename Hash, typename TState = HashTableNoState>
struct HashSetCellWithSavedHash : public HashTableCell<Key, Hash, TState>
{
typedef HashTableCell<Key, Hash, TState> Base;
size_t saved_hash;
HashSetCellWithSavedHash() : Base() {}
HashSetCellWithSavedHash(const Key & key_, const typename Base::State & state) : Base(key_, state) {}
bool keyEquals(const Key & key_) const { return this->key == key_; }
bool keyEquals(const HashSetCellWithSavedHash & other) const { return saved_hash == other.saved_hash && this->key == other.key; }
void setHash(size_t hash_value) { saved_hash = hash_value; }
size_t getHash(const Hash & hash) const { return saved_hash; }
};
template
<
typename Key,
typename Hash = DefaultHash<Key>,
typename Grower = HashTableGrower<>,
typename Allocator = HashTableAllocator
>
using HashSet = HashSetTable<Key, HashTableCell<Key, Hash>, Hash, Grower, Allocator>;
template
<
typename Key,
typename Hash = DefaultHash<Key>,
typename Grower = HashTableGrower<>,
typename Allocator = HashTableAllocator
>
using HashSetWithSavedHash = HashSetTable<Key, HashSetCellWithSavedHash<Key, Hash>, Hash, Grower, Allocator>;