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

252 lines
6.9 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/Columns/IColumn.h>
#include <DB/Common/PODArray.h>
#include <DB/Common/Arena.h>
#include <DB/Common/SipHash.h>
#include <DB/Common/memcpySmall.h>
2010-03-12 18:25:35 +00:00
2016-11-20 12:43:20 +00:00
class Collator;
2010-03-12 18:25:35 +00:00
namespace DB
{
/** Column for String values.
2010-05-13 16:13:38 +00:00
*/
class ColumnString final : public IColumn
2010-05-13 16:13:38 +00:00
{
public:
using Chars_t = PaddedPODArray<UInt8>;
2010-05-20 19:29:04 +00:00
private:
/// Maps i'th position to offset to i+1'th element. Last offset maps to the end of all chars (is the size of all chars).
Offsets_t offsets;
2010-05-20 19:29:04 +00:00
/// Bytes of strings, placed contiguously.
/// For convenience, every string ends with terminating zero byte. Note that strings could contain zero bytes in the middle.
Chars_t chars;
size_t __attribute__((__always_inline__)) offsetAt(size_t i) const { return i == 0 ? 0 : offsets[i - 1]; }
/// Size of i-th element, including terminating zero.
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
2016-11-20 12:43:20 +00:00
template <bool positive>
struct less;
2016-11-20 12:43:20 +00:00
template <bool positive>
struct lessWithCollation;
public:
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
size_t allocatedSize() const override
{
return chars.allocated_size() + offsets.allocated_size() * sizeof(offsets[0]);
}
ColumnPtr cloneResized(size_t to_size) const override;
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);
const size_t old_size = chars.size();
const size_t size_to_append = s.size() + 1;
const size_t new_size = old_size + size_to_append;
2014-08-20 04:57:03 +00:00
chars.resize(new_size);
memcpy(&chars[old_size], s.c_str(), size_to_append);
offsets.push_back(new_size);
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_);
2014-08-20 04:57:03 +00:00
if (n != 0)
{
const size_t size_to_append = src.offsets[n] - src.offsets[n - 1];
if (size_to_append == 1)
{
/// shortcut for empty string
chars.push_back(0);
offsets.push_back(chars.size());
}
else
{
const size_t old_size = chars.size();
const size_t offset = src.offsets[n - 1];
const size_t new_size = old_size + size_to_append;
chars.resize(new_size);
memcpySmallAllowReadWriteOverflow15(&chars[old_size], &src.chars[offset], size_to_append);
offsets.push_back(new_size);
}
}
else
{
const size_t old_size = chars.size();
const size_t size_to_append = src.offsets[0];
const size_t new_size = old_size + size_to_append;
chars.resize(new_size);
memcpySmallAllowReadWriteOverflow15(&chars[old_size], &src.chars[0], size_to_append);
offsets.push_back(new_size);
}
}
void insertData(const char * pos, size_t length) override
{
const size_t old_size = chars.size();
const size_t new_size = old_size + length + 1;
chars.resize(new_size);
memcpy(&chars[old_size], pos, length);
chars[old_size + length] = 0;
offsets.push_back(new_size);
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
{
const size_t old_size = chars.size();
const size_t new_size = old_size + length;
2013-04-13 00:56:07 +00:00
chars.resize(new_size);
memcpy(&chars[old_size], pos, length);
offsets.push_back(new_size);
}
void popBack(size_t n) override
{
size_t nested_n = offsets.back() - offsetAt(offsets.size() - n);
chars.resize(chars.size() - nested_n);
offsets.resize_assume_reserved(offsets.size() - n);
}
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
{
const size_t string_size = *reinterpret_cast<const size_t *>(pos);
pos += sizeof(string_size);
const size_t old_size = chars.size();
const size_t new_size = old_size + string_size;
chars.resize(new_size);
memcpy(&chars[old_size], pos, string_size);
offsets.push_back(new_size);
return pos + string_size;
}
void updateHashWithValue(size_t n, SipHash & hash) const override
{
size_t string_size = sizeAt(n);
size_t offset = offsetAt(n);
hash.update(reinterpret_cast<const char *>(&string_size), sizeof(string_size));
hash.update(reinterpret_cast<const char *>(&chars[offset]), string_size);
}
void insertRangeFrom(const IColumn & src, size_t start, size_t length) override;
ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override;
2013-05-03 05:23:14 +00:00
ColumnPtr permute(const Permutation & perm, size_t limit) const override;
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_);
2017-03-09 04:26:17 +00:00
/** For performance, the strings are compared to the first zero byte.
* (if zero byte is in the middle of the line, then what is after it is ignored)
* Note that the terminating zero byte is always present.
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
/// Variant of compareAt for string comparison with respect of collation.
2016-11-20 12:43:20 +00:00
int compareAtWithCollation(size_t n, size_t m, const IColumn & rhs_, const Collator & collator) const;
2011-09-26 11:05:38 +00:00
void getPermutation(bool reverse, size_t limit, Permutation & res) const override;
/// Sorting with respect of collation.
2016-11-20 12:43:20 +00:00
void getPermutationWithCollation(const Collator & collator, bool reverse, size_t limit, Permutation & res) const;
2012-08-27 05:13:14 +00:00
ColumnPtr replicate(const Offsets_t & replicate_offsets) const override;
Columns scatter(ColumnIndex num_columns, const Selector & selector) const override
{
return scatterImpl<ColumnString>(num_columns, selector);
}
void reserve(size_t n) override;
void getExtremes(Field & min, Field & max) const override;
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
}