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

425 lines
12 KiB
C
Raw Normal View History

2011-09-04 00:22:19 +00:00
#pragma once
2010-03-12 18:25:35 +00:00
2011-09-04 00:22:19 +00:00
#include <string.h>
2010-05-20 19:29:04 +00:00
#include <DB/Core/Defines.h>
#include <DB/Columns/IColumn.h>
#include <DB/Columns/ColumnsCommon.h>
2013-05-28 16:56:05 +00:00
#include <DB/Common/Collator.h>
#include <DB/Common/PODArray.h>
#include <DB/Common/Arena.h>
2010-03-12 18:25:35 +00:00
namespace DB
{
2010-05-13 16:13:38 +00:00
/** Cтолбeц значений типа "строка".
*/
class ColumnString final : public IColumn
2010-05-13 16:13:38 +00:00
{
public:
//typedef std::vector<UInt8> Chars_t;
typedef PODArray<UInt8> Chars_t;
2010-05-20 19:29:04 +00:00
private:
/// По индексу i находится смещение до начала i + 1 -го элемента.
Offsets_t offsets;
2010-05-20 19:29:04 +00:00
/// Байты строк, уложенные подряд. Строки хранятся с завершающим нулевым байтом.
Chars_t chars;
size_t __attribute__((__always_inline__)) offsetAt(size_t i) const { return i == 0 ? 0 : offsets[i - 1]; }
/// Размер, включая завершающий нулевой байт.
size_t __attribute__((__always_inline__)) sizeAt(size_t i) const { return i == 0 ? offsets[0] : (offsets[i] - offsets[i - 1]); }
2014-08-20 04:57:03 +00:00
public:
2013-05-03 05:23:14 +00:00
/** Создать пустой столбец строк */
ColumnString() {}
std::string getName() const override { return "ColumnString"; }
size_t size() const override
2010-05-13 16:13:38 +00:00
{
return offsets.size();
2010-05-13 16:13:38 +00:00
}
2010-05-21 19:52:50 +00:00
size_t byteSize() const override
{
return chars.size() + offsets.size() * sizeof(offsets[0]);
}
2011-08-28 00:31:30 +00:00
ColumnPtr cloneEmpty() const override
2010-05-21 19:52:50 +00:00
{
return new ColumnString;
}
Field operator[](size_t n) const override
2010-05-13 16:13:38 +00:00
{
return Field(&chars[offsetAt(n)], sizeAt(n) - 1);
2010-05-13 16:13:38 +00:00
}
2010-05-20 19:29:04 +00:00
void get(size_t n, Field & res) const override
{
res.assignString(&chars[offsetAt(n)], sizeAt(n) - 1);
}
StringRef getDataAt(size_t n) const override
2013-04-13 00:56:07 +00:00
{
return StringRef(&chars[offsetAt(n)], sizeAt(n) - 1);
2013-04-13 00:56:07 +00:00
}
StringRef getDataAtWithTerminatingZero(size_t n) const override
{
return StringRef(&chars[offsetAt(n)], sizeAt(n));
}
void insert(const Field & x) override
2010-05-20 19:29:04 +00:00
{
const String & s = DB::get<const String &>(x);
size_t old_size = chars.size();
2010-05-20 19:29:04 +00:00
size_t size_to_append = s.size() + 1;
2014-08-20 04:57:03 +00:00
chars.resize(old_size + size_to_append);
memcpy(&chars[old_size], s.c_str(), size_to_append);
offsets.push_back((offsets.size() == 0 ? 0 : offsets.back()) + size_to_append);
2010-05-20 19:29:04 +00:00
}
void insertFrom(const IColumn & src_, size_t n) override
{
const ColumnString & src = static_cast<const ColumnString &>(src_);
size_t old_size = chars.size();
size_t size_to_append = src.sizeAt(n);
size_t offset = src.offsetAt(n);
2014-08-20 04:57:03 +00:00
chars.resize(old_size + size_to_append);
memcpy(&chars[old_size], &src.chars[offset], size_to_append);
offsets.push_back((offsets.size() == 0 ? 0 : offsets.back()) + size_to_append);
}
void insertData(const char * pos, size_t length) override
{
size_t old_size = chars.size();
chars.resize(old_size + length + 1);
memcpy(&chars[old_size], pos, length);
chars[old_size + length] = 0;
offsets.push_back((offsets.size() == 0 ? 0 : offsets.back()) + length + 1);
2013-04-13 00:56:07 +00:00
}
void insertDataWithTerminatingZero(const char * pos, size_t length) override
2013-04-13 00:56:07 +00:00
{
size_t old_size = chars.size();
2013-04-13 00:56:07 +00:00
chars.resize(old_size + length);
memcpy(&chars[old_size], pos, length);
offsets.push_back((offsets.size() == 0 ? 0 : offsets.back()) + length);
}
StringRef serializeValueIntoArena(size_t n, Arena & arena, char const *& begin) const override
{
size_t string_size = sizeAt(n);
size_t offset = offsetAt(n);
StringRef res;
res.size = sizeof(string_size) + string_size;
char * pos = arena.allocContinue(res.size, begin);
memcpy(pos, &string_size, sizeof(string_size));
memcpy(pos + sizeof(string_size), &chars[offset], string_size);
res.data = pos;
return res;
}
const char * deserializeAndInsertFromArena(const char * pos) override
{
size_t string_size = *reinterpret_cast<const size_t *>(pos);
pos += sizeof(string_size);
size_t old_size = chars.size();
chars.resize(old_size + string_size);
memcpy(&chars[old_size], pos, string_size);
offsets.push_back((offsets.size() == 0 ? 0 : offsets.back()) + string_size);
return pos + string_size;
}
2015-11-29 17:06:30 +00:00
void insertRangeFrom(const IColumn & src, size_t start, size_t length) override
{
if (length == 0)
2015-11-29 17:06:30 +00:00
return;
2015-11-29 17:06:30 +00:00
const ColumnString & src_concrete = static_cast<const ColumnString &>(src);
2015-11-29 17:06:30 +00:00
if (start + length > src_concrete.offsets.size())
throw Exception("Parameter out of bound in IColumnString::insertRangeFrom method.",
ErrorCodes::PARAMETER_OUT_OF_BOUND);
2015-11-29 17:06:30 +00:00
size_t nested_offset = src_concrete.offsetAt(start);
size_t nested_length = src_concrete.offsets[start + length - 1] - nested_offset;
2014-08-20 04:57:03 +00:00
2015-11-29 17:06:30 +00:00
size_t old_chars_size = chars.size();
chars.resize(old_chars_size + nested_length);
memcpy(&chars[old_chars_size], &src_concrete.chars[nested_offset], nested_length);
2015-11-29 17:06:30 +00:00
if (start == 0 && offsets.empty())
{
2015-11-29 17:06:30 +00:00
offsets.assign(src_concrete.offsets.begin(), src_concrete.offsets.begin() + length);
}
else
{
2015-11-29 17:06:30 +00:00
size_t old_size = offsets.size();
size_t prev_max_offset = old_size ? offsets.back() : 0;
offsets.resize(old_size + length);
for (size_t i = 0; i < length; ++i)
2015-11-29 17:06:30 +00:00
offsets[old_size + i] = src_concrete.offsets[start + i] - nested_offset + prev_max_offset;
}
}
ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override
{
if (offsets.size() == 0)
2013-05-03 05:23:14 +00:00
return new ColumnString;
auto res = new ColumnString;
2014-08-28 07:49:27 +00:00
ColumnPtr res_{res};
2013-05-03 05:23:14 +00:00
Chars_t & res_chars = res->chars;
Offsets_t & res_offsets = res->offsets;
filterArraysImpl<UInt8>(chars, offsets, res_chars, res_offsets, filt, result_size_hint);
2014-08-28 07:49:27 +00:00
return res_;
}
ColumnPtr permute(const Permutation & perm, size_t limit) const override
{
size_t size = offsets.size();
if (limit == 0)
limit = size;
else
limit = std::min(size, limit);
if (perm.size() < limit)
throw Exception("Size of permutation is less than required.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
if (limit == 0)
2013-05-03 05:23:14 +00:00
return new ColumnString;
ColumnString * res_ = new ColumnString;
ColumnPtr res = res_;
Chars_t & res_chars = res_->chars;
Offsets_t & res_offsets = res_->offsets;
if (limit == size)
res_chars.resize(chars.size());
else
{
size_t new_chars_size = 0;
for (size_t i = 0; i < limit; ++i)
new_chars_size += sizeAt(perm[i]);
res_chars.resize(new_chars_size);
}
res_offsets.resize(limit);
Offset_t current_new_offset = 0;
for (size_t i = 0; i < limit; ++i)
{
size_t j = perm[i];
size_t string_offset = j == 0 ? 0 : offsets[j - 1];
size_t string_size = offsets[j] - string_offset;
memcpy(&res_chars[current_new_offset], &chars[string_offset], string_size);
current_new_offset += string_size;
2013-05-03 05:23:14 +00:00
res_offsets[i] = current_new_offset;
}
2013-05-03 05:23:14 +00:00
return res;
}
void insertDefault() override
2010-05-20 19:29:04 +00:00
{
chars.push_back(0);
offsets.push_back(offsets.size() == 0 ? 1 : (offsets.back() + 1));
2010-05-20 19:29:04 +00:00
}
2011-09-04 00:22:19 +00:00
int compareAt(size_t n, size_t m, const IColumn & rhs_, int nan_direction_hint) const override
2011-09-04 00:22:19 +00:00
{
const ColumnString & rhs = static_cast<const ColumnString &>(rhs_);
2011-09-26 11:05:38 +00:00
/** Для производительности, строки сравниваются до первого нулевого байта.
* (если нулевой байт в середине строки, то то, что после него - игнорируется)
* Замечу, что завершающий нулевой байт всегда есть.
*/
return strcmp(
reinterpret_cast<const char *>(&chars[offsetAt(n)]),
reinterpret_cast<const char *>(&rhs.chars[rhs.offsetAt(m)]));
2011-09-26 11:05:38 +00:00
}
2014-08-20 04:57:03 +00:00
2013-05-28 16:56:05 +00:00
/// Версия compareAt для locale-sensitive сравнения строк
int compareAtWithCollation(size_t n, size_t m, const IColumn & rhs_, const Collator & collator) const
2013-05-28 16:56:05 +00:00
{
const ColumnString & rhs = static_cast<const ColumnString &>(rhs_);
2014-08-20 04:57:03 +00:00
2013-05-28 16:56:05 +00:00
return collator.compare(
reinterpret_cast<const char *>(&chars[offsetAt(n)]), sizeAt(n),
reinterpret_cast<const char *>(&rhs.chars[rhs.offsetAt(m)]), rhs.sizeAt(m));
}
2011-09-26 11:05:38 +00:00
template <bool positive>
2011-09-26 11:05:38 +00:00
struct less
{
const ColumnString & parent;
less(const ColumnString & parent_) : parent(parent_) {}
bool operator()(size_t lhs, size_t rhs) const
{
int res = strcmp(
reinterpret_cast<const char *>(&parent.chars[parent.offsetAt(lhs)]),
reinterpret_cast<const char *>(&parent.chars[parent.offsetAt(rhs)]));
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 = offsets.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-04 00:22:19 +00:00
}
template <bool positive>
2013-05-28 16:56:05 +00:00
struct lessWithCollation
{
const ColumnString & parent;
const Collator & collator;
2014-08-20 04:57:03 +00:00
2013-05-28 16:56:05 +00:00
lessWithCollation(const ColumnString & parent_, const Collator & collator_) : parent(parent_), collator(collator_) {}
2014-08-20 04:57:03 +00:00
2013-05-28 16:56:05 +00:00
bool operator()(size_t lhs, size_t rhs) const
{
int res = collator.compare(
2013-05-28 16:56:05 +00:00
reinterpret_cast<const char *>(&parent.chars[parent.offsetAt(lhs)]), parent.sizeAt(lhs),
reinterpret_cast<const char *>(&parent.chars[parent.offsetAt(rhs)]), parent.sizeAt(rhs));
return positive ? (res < 0) : (res > 0);
2013-05-28 16:56:05 +00:00
}
};
/// Сортировка с учетом Collation
void getPermutationWithCollation(const Collator & collator, bool reverse, size_t limit, Permutation & res) const
2013-05-28 16:56:05 +00:00
{
size_t s = offsets.size();
res.resize(s);
2013-05-28 16:56:05 +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(), lessWithCollation<false>(*this, collator));
else
std::partial_sort(res.begin(), res.begin() + limit, res.end(), lessWithCollation<true>(*this, collator));
}
else
{
if (reverse)
std::sort(res.begin(), res.end(), lessWithCollation<false>(*this, collator));
else
std::sort(res.begin(), res.end(), lessWithCollation<true>(*this, collator));
}
2013-05-28 16:56:05 +00:00
}
2012-08-27 05:13:14 +00:00
ColumnPtr replicate(const Offsets_t & replicate_offsets) const override
2012-08-27 05:13:14 +00:00
{
size_t col_size = size();
if (col_size != replicate_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
ColumnString * res_ = new ColumnString;
ColumnPtr res = res_;
2014-08-20 04:57:03 +00:00
if (0 == col_size)
return res;
Chars_t & res_chars = res_->chars;
Offsets_t & res_offsets = res_->offsets;
res_chars.reserve(chars.size() / col_size * replicate_offsets.back());
2013-05-03 05:23:14 +00:00
res_offsets.reserve(replicate_offsets.back());
2012-08-27 05:13:14 +00:00
Offset_t prev_replicate_offset = 0;
Offset_t prev_string_offset = 0;
Offset_t current_new_offset = 0;
for (size_t i = 0; i < col_size; ++i)
{
size_t size_to_replicate = replicate_offsets[i] - prev_replicate_offset;
size_t string_size = offsets[i] - prev_string_offset;
2012-08-27 05:13:14 +00:00
for (size_t j = 0; j < size_to_replicate; ++j)
{
current_new_offset += string_size;
2013-05-03 05:23:14 +00:00
res_offsets.push_back(current_new_offset);
2012-09-19 18:45:01 +00:00
2013-05-03 05:23:14 +00:00
res_chars.resize(res_chars.size() + string_size);
memcpy(&res_chars[res_chars.size() - string_size], &chars[prev_string_offset], string_size);
2012-08-27 05:13:14 +00:00
}
prev_replicate_offset = replicate_offsets[i];
prev_string_offset = offsets[i];
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 reserve(size_t n) override
{
offsets.reserve(n);
chars.reserve(n * DBMS_APPROX_STRING_SIZE);
}
void getExtremes(Field & min, Field & max) const override
{
min = String();
max = String();
}
Chars_t & getChars() { return chars; }
const Chars_t & getChars() const { return chars; }
Offsets_t & getOffsets() { return offsets; }
const Offsets_t & getOffsets() const { return offsets; }
2010-05-13 16:13:38 +00:00
};
2010-03-12 18:25:35 +00:00
}