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

245 lines
8.2 KiB
C
Raw Normal View History

2011-08-21 03:41:37 +00:00
#pragma once
2010-03-12 18:25:35 +00:00
#include <Poco/SharedPtr.h>
2011-08-12 18:28:48 +00:00
#include <DB/Core/Field.h>
2010-05-20 19:29:04 +00:00
#include <DB/Core/Exception.h>
#include <DB/Core/ErrorCodes.h>
2011-11-06 06:22:52 +00:00
#include <DB/Columns/ColumnVector.h>
2010-03-12 18:25:35 +00:00
#include <DB/Columns/IColumn.h>
#include <DB/DataTypes/IDataType.h>
2010-03-12 18:25:35 +00:00
namespace DB
{
using Poco::SharedPtr;
2011-11-06 06:22:52 +00:00
class IColumnConst : public IColumn
{
public:
bool isConst() const override { return true; }
2011-11-06 06:22:52 +00:00
virtual ColumnPtr convertToFullColumn() const = 0;
};
2010-03-12 18:25:35 +00:00
/** шаблон для столбцов-констант (столбцов одинаковых значений).
*/
template <typename T>
class ColumnConst final : public IColumnConst
2010-03-12 18:25:35 +00:00
{
public:
2011-08-12 20:39:42 +00:00
typedef T Type;
typedef typename NearestFieldType<T>::Type FieldType;
2013-03-27 10:07:23 +00:00
/// Для ColumnConst<Array> data_type_ должен быть ненулевым.
/// Для ColumnConst<String> data_type_ должен быть ненулевым, если тип данных FixedString.
ColumnConst(size_t s_, const T & data_, DataTypePtr data_type_ = DataTypePtr()) : s(s_), data(data_), data_type(data_type_) {}
std::string getName() const override { return "ColumnConst<" + TypeName<T>::get() + ">"; }
bool isNumeric() const override { return IsNumber<T>::value; }
bool isFixed() const override { return IsNumber<T>::value; }
size_t sizeOfField() const override { return sizeof(T); }
ColumnPtr cloneResized(size_t s_) const override { return new ColumnConst(s_, data); }
size_t size() const override { return s; }
Field operator[](size_t n) const override { return FieldType(data); }
void get(size_t n, Field & res) const override { res = FieldType(data); }
2013-05-03 05:23:14 +00:00
ColumnPtr cut(size_t start, size_t length) const override
2013-05-03 05:23:14 +00:00
{
return new ColumnConst<T>(length, data, data_type);
}
void insert(const Field & x) override
2010-05-20 19:29:04 +00:00
{
if (x.get<FieldType>() != FieldType(data))
throw Exception("Cannot insert different element into constant column " + getName(),
ErrorCodes::CANNOT_INSERT_ELEMENT_INTO_CONSTANT_COLUMN);
++s;
2010-05-20 19:29:04 +00:00
}
void insertData(const char * pos, size_t length) override
{
throw Exception("Cannot insert element into constant column " + getName(), ErrorCodes::NOT_IMPLEMENTED);
}
void insertFrom(const IColumn & src, size_t n) override
{
if (data != static_cast<const ColumnConst<T> &>(src).data)
throw Exception("Cannot insert different element into constant column " + getName(),
ErrorCodes::CANNOT_INSERT_ELEMENT_INTO_CONSTANT_COLUMN);
++s;
}
void insertDefault() override { ++s; }
2011-08-28 05:13:24 +00:00
ColumnPtr filter(const Filter & filt) const override
2011-08-28 05:13:24 +00:00
{
2012-08-27 05:13:14 +00:00
if (s != filt.size())
throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
return new ColumnConst<T>(countBytesInFilter(filt), data, data_type);
2011-08-28 05:13:24 +00:00
}
2010-03-12 18:25:35 +00:00
ColumnPtr replicate(const Offsets_t & offsets) const override
2012-08-27 05:13:14 +00:00
{
if (s != offsets.size())
throw Exception("Size of offsets doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
2014-08-20 04:57:03 +00:00
size_t replicated_size = 0 == s ? 0 : offsets.back();
return new ColumnConst<T>(replicated_size, data, data_type);
2012-08-27 05:13:14 +00:00
}
size_t byteSize() const override { return sizeof(data) + sizeof(s); }
2011-08-27 22:43:31 +00:00
ColumnPtr permute(const Permutation & perm, size_t limit) const override
2011-09-04 00:22:19 +00:00
{
if (limit == 0)
limit = s;
else
limit = std::min(s, limit);
2013-05-03 05:23:14 +00:00
if (perm.size() < limit)
throw Exception("Size of permutation is less than required.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
return new ColumnConst<T>(limit, data, data_type);
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 ColumnConst<T> & rhs = static_cast<const ColumnConst<T> &>(rhs_);
return data < rhs.data /// TODO: правильное сравнение NaN-ов в константных столбцах.
2011-09-04 00:22:19 +00:00
? -1
: (data == rhs.data
? 0
: 1);
}
void getPermutation(bool reverse, size_t limit, Permutation & res) const override
2011-09-26 11:05:38 +00:00
{
res.resize(s);
2011-09-26 11:05:38 +00:00
for (size_t i = 0; i < s; ++i)
res[i] = i;
}
StringRef getDataAt(size_t n) const override;
StringRef getDataAtWithTerminatingZero(size_t n) const override;
UInt64 get64(size_t n) const override;
2010-03-12 18:25:35 +00:00
/** Более эффективные методы манипуляции */
T & getData() { return data; }
const T & getData() const { return data; }
/** Преобразование из константы в полноценный столбец */
ColumnPtr convertToFullColumn() const override;
2010-03-12 18:25:35 +00:00
void getExtremes(Field & min, Field & max) const override
{
min = FieldType(data);
max = FieldType(data);
}
DataTypePtr & getDataType() { return data_type; }
const DataTypePtr & getDataType() const { return data_type; }
2010-03-12 18:25:35 +00:00
private:
2010-05-13 16:13:38 +00:00
size_t s;
2010-03-12 18:25:35 +00:00
T data;
2013-03-27 10:07:23 +00:00
DataTypePtr data_type;
2010-03-12 18:25:35 +00:00
};
2011-08-21 03:41:37 +00:00
typedef ColumnConst<String> ColumnConstString;
2012-08-26 06:48:39 +00:00
typedef ColumnConst<Array> ColumnConstArray;
2010-03-12 18:25:35 +00:00
2011-11-06 06:22:52 +00:00
template <typename T> ColumnPtr ColumnConst<T>::convertToFullColumn() const
{
ColumnVector<T> * res = new ColumnVector<T>;
res->getData().assign(s, data);
return res;
}
2012-05-09 13:12:38 +00:00
template <> ColumnPtr ColumnConst<String>::convertToFullColumn() const;
2012-08-26 06:48:39 +00:00
template <> ColumnPtr ColumnConst<Array>::convertToFullColumn() const;
template <typename T> StringRef ColumnConst<T>::getDataAt(size_t n) const
{
throw Exception("Method getDataAt is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
}
template <> inline StringRef ColumnConst<String>::getDataAt(size_t n) const
{
return StringRef(data);
}
template <typename T> UInt64 ColumnConst<T>::get64(size_t n) const
{
throw Exception("Method get64 is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
}
/// Для элементарных типов.
template <typename T> StringRef getDataAtImpl(const T & data)
{
return StringRef(reinterpret_cast<const char *>(&data), sizeof(data));
}
2014-10-06 22:46:18 +00:00
template <typename T> UInt64 get64IntImpl(const T & data)
{
return data;
}
template <typename T> UInt64 get64FloatImpl(const T & data)
{
union
{
T src;
UInt64 res;
};
res = 0;
src = data;
return res;
}
template <> inline StringRef ColumnConst<UInt8 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
template <> inline StringRef ColumnConst<UInt16 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
template <> inline StringRef ColumnConst<UInt32 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
template <> inline StringRef ColumnConst<UInt64 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
template <> inline StringRef ColumnConst<Int8 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
template <> inline StringRef ColumnConst<Int16 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
template <> inline StringRef ColumnConst<Int32 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
template <> inline StringRef ColumnConst<Int64 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
template <> inline StringRef ColumnConst<Float32 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
template <> inline StringRef ColumnConst<Float64 >::getDataAt(size_t n) const { return getDataAtImpl(data); }
2014-10-06 22:46:18 +00:00
template <> inline UInt64 ColumnConst<UInt8 >::get64(size_t n) const { return get64IntImpl(data); }
template <> inline UInt64 ColumnConst<UInt16 >::get64(size_t n) const { return get64IntImpl(data); }
template <> inline UInt64 ColumnConst<UInt32 >::get64(size_t n) const { return get64IntImpl(data); }
template <> inline UInt64 ColumnConst<UInt64 >::get64(size_t n) const { return get64IntImpl(data); }
template <> inline UInt64 ColumnConst<Int8 >::get64(size_t n) const { return get64IntImpl(data); }
template <> inline UInt64 ColumnConst<Int16 >::get64(size_t n) const { return get64IntImpl(data); }
template <> inline UInt64 ColumnConst<Int32 >::get64(size_t n) const { return get64IntImpl(data); }
template <> inline UInt64 ColumnConst<Int64 >::get64(size_t n) const { return get64IntImpl(data); }
template <> inline UInt64 ColumnConst<Float32 >::get64(size_t n) const { return get64FloatImpl(data); }
template <> inline UInt64 ColumnConst<Float64 >::get64(size_t n) const { return get64FloatImpl(data); }
2012-05-09 13:12:38 +00:00
2013-04-13 00:56:07 +00:00
template <typename T> StringRef ColumnConst<T>::getDataAtWithTerminatingZero(size_t n) const
{
return getDataAt(n);
}
template <> inline StringRef ColumnConst<String>::getDataAtWithTerminatingZero(size_t n) const
{
return StringRef(data.data(), data.size() + 1);
}
2011-08-21 03:41:37 +00:00
}