ClickHouse/dbms/include/DB/Columns/ColumnFixedString.h

261 lines
6.3 KiB
C
Raw Normal View History

2011-08-07 02:08:22 +00:00
#pragma once
#include <string.h> // memcpy
#include <DB/Common/PODArray.h>
#include <DB/Columns/IColumn.h>
2011-08-07 02:08:22 +00:00
namespace DB
{
/** Cтолбeц значений типа "строка фиксированной длины".
* Если вставить строку меньшей длины, то она будет дополнена нулевыми байтами.
*/
class ColumnFixedString final : public IColumn
2011-08-07 02:08:22 +00:00
{
public:
typedef PODArray<UInt8> Chars_t;
2011-08-07 02:08:22 +00:00
private:
/// Размер строк.
const size_t n;
/// Байты строк, уложенные подряд. Строки хранятся без завершающего нулевого байта.
Chars_t chars;
2011-08-07 02:08:22 +00:00
public:
/** Создать пустой столбец строк фиксированной длины n */
ColumnFixedString(size_t n_) : n(n_) {}
2011-08-07 02:08:22 +00:00
std::string getName() const override { return "ColumnFixedString"; }
2011-08-28 00:31:30 +00:00
ColumnPtr cloneEmpty() const override
2011-08-07 02:08:22 +00:00
{
return new ColumnFixedString(n);
}
size_t size() const override
{
return chars.size() / n;
}
size_t sizeOfField() const override
{
return n;
}
bool isFixed() const override
{
return true;
}
2014-08-20 04:57:03 +00:00
size_t byteSize() const override
{
return chars.size() + sizeof(n);
}
2014-08-20 04:57:03 +00:00
Field operator[](size_t index) const override
2011-08-07 02:08:22 +00:00
{
return String(reinterpret_cast<const char *>(&chars[n * index]), n);
2011-08-07 02:08:22 +00:00
}
void get(size_t index, Field & res) const override
{
res.assignString(reinterpret_cast<const char *>(&chars[n * index]), n);
}
StringRef getDataAt(size_t index) const override
{
return StringRef(&chars[n * index], n);
}
void insert(const Field & x) override
2011-08-07 02:08:22 +00:00
{
const String & s = DB::get<const String &>(x);
if (s.size() > n)
2012-11-25 21:16:37 +00:00
throw Exception("Too large string '" + s + "' for FixedString column", ErrorCodes::TOO_LARGE_STRING_SIZE);
2014-08-20 04:57:03 +00:00
size_t old_size = chars.size();
chars.resize_fill(old_size + n);
memcpy(&chars[old_size], s.data(), s.size());
2011-08-07 02:08:22 +00:00
}
void insertFrom(const IColumn & src_, size_t index) override
{
const ColumnFixedString & src = static_cast<const ColumnFixedString &>(src_);
if (n != src.getN())
throw Exception("Size of FixedString doesn't match", ErrorCodes::SIZE_OF_ARRAY_DOESNT_MATCH_SIZE_OF_FIXEDARRAY_COLUMN);
size_t old_size = chars.size();
chars.resize(old_size + n);
memcpy(&chars[old_size], &src.chars[n * index], n);
}
void insertData(const char * pos, size_t length) override
{
if (length > n)
throw Exception("Too large string for FixedString column", ErrorCodes::TOO_LARGE_STRING_SIZE);
size_t old_size = chars.size();
chars.resize_fill(old_size + n);
memcpy(&chars[old_size], pos, length);
}
void insertDefault() override
2011-08-07 02:08:22 +00:00
{
chars.resize_fill(chars.size() + n);
2011-08-07 02:08:22 +00:00
}
2011-09-04 00:22:19 +00:00
int compareAt(size_t p1, size_t p2, const IColumn & rhs_, int nan_direction_hint) const override
2011-09-04 00:22:19 +00:00
{
const ColumnFixedString & rhs = static_cast<const ColumnFixedString &>(rhs_);
return memcmp(&chars[p1 * n], &rhs.chars[p2 * n], n);
2011-09-04 00:22:19 +00:00
}
2011-09-26 11:05:38 +00:00
template <bool positive>
2011-09-26 11:05:38 +00:00
struct less
{
const ColumnFixedString & parent;
less(const ColumnFixedString & parent_) : parent(parent_) {}
bool operator()(size_t lhs, size_t rhs) const
{
/// TODO: memcmp тормозит.
int res = memcmp(&parent.chars[lhs * parent.n], &parent.chars[rhs * parent.n], parent.n);
return positive ? (res < 0) : (res > 0);
2011-09-26 11:05:38 +00:00
}
};
void getPermutation(bool reverse, size_t limit, Permutation & res) const override
2011-09-26 11:05:38 +00:00
{
size_t s = size();
res.resize(s);
2011-09-26 11:05:38 +00:00
for (size_t i = 0; i < s; ++i)
res[i] = i;
2014-05-23 01:32:32 +00:00
if (limit >= s)
limit = 0;
if (limit)
{
if (reverse)
std::partial_sort(res.begin(), res.begin() + limit, res.end(), less<false>(*this));
else
std::partial_sort(res.begin(), res.begin() + limit, res.end(), less<true>(*this));
}
else
{
if (reverse)
std::sort(res.begin(), res.end(), less<false>(*this));
else
std::sort(res.begin(), res.end(), less<true>(*this));
}
2011-09-26 11:05:38 +00:00
}
2012-08-27 05:13:14 +00:00
ColumnPtr cut(size_t start, size_t length) const override
{
ColumnFixedString * res_ = new ColumnFixedString(n);
ColumnPtr res = res_;
res_->chars.resize(n * length);
memcpy(&res_->chars[0], &chars[n * start], n * length);
return res;
}
ColumnPtr filter(const IColumn::Filter & filt) const override
{
size_t col_size = size();
if (col_size != filt.size())
throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
ColumnFixedString * res_ = new ColumnFixedString(n);
ColumnPtr res = res_;
res_->chars.reserve(chars.size());
size_t offset = 0;
for (size_t i = 0; i < col_size; ++i, offset += n)
{
if (filt[i])
{
res_->chars.resize(res_->chars.size() + n);
memcpy(&res_->chars[res_->chars.size() - n], &chars[offset], n);
}
}
return res;
}
ColumnPtr permute(const Permutation & perm, size_t limit) const override
{
size_t col_size = size();
if (limit == 0)
limit = col_size;
else
limit = std::min(col_size, limit);
if (perm.size() < limit)
throw Exception("Size of permutation is less than required.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
if (limit == 0)
return new ColumnFixedString(n);
ColumnFixedString * res_ = new ColumnFixedString(n);
ColumnPtr res = res_;
Chars_t & res_chars = res_->chars;
res_chars.resize(n * limit);
size_t offset = 0;
for (size_t i = 0; i < limit; ++i, offset += n)
memcpy(&res_chars[offset], &chars[perm[i] * n], n);
return res;
}
ColumnPtr replicate(const Offsets_t & offsets) const override
2012-08-27 05:13:14 +00:00
{
size_t col_size = size();
if (col_size != offsets.size())
throw Exception("Size of offsets doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
2013-05-03 05:23:14 +00:00
ColumnFixedString * res_ = new ColumnFixedString(n);
ColumnPtr res = res_;
2014-08-20 04:57:03 +00:00
if (0 == col_size)
return res;
Chars_t & res_chars = res_->chars;
2013-05-03 05:23:14 +00:00
res_chars.reserve(n * offsets.back());
2012-08-27 05:13:14 +00:00
Offset_t prev_offset = 0;
for (size_t i = 0; i < col_size; ++i)
{
size_t size_to_replicate = offsets[i] - prev_offset;
prev_offset = offsets[i];
for (size_t j = 0; j < size_to_replicate; ++j)
for (size_t k = 0; k < n; ++k)
res_chars.push_back(chars[i * n + k]);
2012-08-27 05:13:14 +00:00
}
2013-05-03 05:23:14 +00:00
return res;
2012-08-27 05:13:14 +00:00
}
void getExtremes(Field & min, Field & max) const override
{
min = String();
max = String();
}
Chars_t & getChars() { return chars; }
const Chars_t & getChars() const { return chars; }
size_t getN() const { return n; }
2011-08-07 02:08:22 +00:00
};
}