2016-07-05 16:23:37 +00:00
|
|
|
#include <DB/DataTypes/DataTypeNullable.h>
|
2016-07-14 12:58:30 +00:00
|
|
|
#include <DB/DataTypes/NullSymbol.h>
|
2016-07-05 16:23:37 +00:00
|
|
|
#include <DB/Columns/ColumnNullable.h>
|
|
|
|
#include <DB/Common/typeid_cast.h>
|
2016-07-14 12:58:30 +00:00
|
|
|
#include <DB/IO/ReadBuffer.h>
|
|
|
|
#include <DB/IO/ReadHelpers.h>
|
|
|
|
#include <DB/IO/WriteBuffer.h>
|
|
|
|
#include <DB/IO/WriteHelpers.h>
|
2016-07-05 16:23:37 +00:00
|
|
|
|
|
|
|
namespace DB
|
|
|
|
{
|
|
|
|
|
2016-07-11 16:41:57 +00:00
|
|
|
namespace
|
|
|
|
{
|
|
|
|
|
2016-07-14 12:58:30 +00:00
|
|
|
template <typename Null>
|
|
|
|
struct Deserializer
|
|
|
|
{
|
|
|
|
static bool execute(IColumn & column, ReadBuffer & istr, NullValuesByteMap * null_map)
|
|
|
|
{
|
|
|
|
if (null_map != nullptr)
|
|
|
|
{
|
|
|
|
if (!istr.eof())
|
|
|
|
{
|
|
|
|
if (*istr.position() == Null::prefix)
|
|
|
|
{
|
|
|
|
++istr.position();
|
|
|
|
if (Null::length > 1)
|
|
|
|
assertString(Null::suffix, istr);
|
|
|
|
null_map->push_back(1);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
null_map->push_back(0);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-07-12 13:02:52 +00:00
|
|
|
inline bool isNullValue(const NullValuesByteMap * null_map, size_t row_num)
|
2016-07-11 16:41:57 +00:00
|
|
|
{
|
|
|
|
return (null_map != nullptr) && ((*null_map)[row_num] == 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-07-07 10:33:12 +00:00
|
|
|
DataTypeNullable::DataTypeNullable(DataTypePtr nested_data_type_)
|
|
|
|
: nested_data_type{nested_data_type_}
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string DataTypeNullable::getName() const
|
|
|
|
{
|
2016-08-15 11:14:29 +00:00
|
|
|
return "Nullable(" + nested_data_type->getName() + ")";
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool DataTypeNullable::isNullable() const
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
DataTypePtr DataTypeNullable::clone() const
|
|
|
|
{
|
2016-08-15 11:14:29 +00:00
|
|
|
return std::make_shared<DataTypeNullable>(nested_data_type->clone());
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DataTypeNullable::serializeBinary(const IColumn & column, WriteBuffer & ostr, size_t offset, size_t limit) const
|
|
|
|
{
|
|
|
|
const ColumnNullable * col = typeid_cast<const ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->serializeBinary(*col->getNestedColumn(), ostr, offset, limit);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DataTypeNullable::deserializeBinary(IColumn & column, ReadBuffer & istr, size_t limit, double avg_value_size_hint) const
|
|
|
|
{
|
|
|
|
ColumnNullable * col = typeid_cast<ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->deserializeBinary(*col->getNestedColumn(), istr, limit, avg_value_size_hint);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DataTypeNullable::serializeBinary(const Field & field, WriteBuffer & ostr) const
|
|
|
|
{
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->serializeBinary(field, ostr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DataTypeNullable::deserializeBinary(Field & field, ReadBuffer & istr) const
|
|
|
|
{
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->deserializeBinary(field, istr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DataTypeNullable::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
|
|
|
|
{
|
|
|
|
const ColumnNullable * col = typeid_cast<const ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->serializeBinary(*col->getNestedColumn(), row_num, ostr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DataTypeNullable::deserializeBinary(IColumn & column, ReadBuffer & istr) const
|
|
|
|
{
|
|
|
|
ColumnNullable * col = typeid_cast<ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->deserializeBinary(*col->getNestedColumn(), istr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 14:54:46 +00:00
|
|
|
void DataTypeNullable::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
const ColumnNullable * col = typeid_cast<const ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
const ColumnUInt8 & content = static_cast<const ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 14:54:46 +00:00
|
|
|
const auto & null_map = content.getData();
|
|
|
|
|
|
|
|
if (isNullValue(&null_map, row_num))
|
2016-08-04 15:06:27 +00:00
|
|
|
writeCString(NullSymbol::Escaped::name, ostr);
|
2016-07-11 14:54:46 +00:00
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->serializeTextEscaped(*col->getNestedColumn(), row_num, ostr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 14:54:46 +00:00
|
|
|
void DataTypeNullable::deserializeTextEscaped(IColumn & column, ReadBuffer & istr) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
ColumnNullable * col = typeid_cast<ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
ColumnUInt8 & content = static_cast<ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 14:54:46 +00:00
|
|
|
auto & null_map = content.getData();
|
|
|
|
|
2016-07-14 12:58:30 +00:00
|
|
|
if (Deserializer<NullSymbol::Escaped>::execute(column, istr, &null_map))
|
2016-07-13 14:23:08 +00:00
|
|
|
{
|
|
|
|
ColumnPtr & nested_col = col->getNestedColumn();
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_col->insertDefault();
|
2016-07-13 14:23:08 +00:00
|
|
|
}
|
2016-07-11 14:54:46 +00:00
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->deserializeTextEscaped(*col->getNestedColumn(), istr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 14:54:46 +00:00
|
|
|
void DataTypeNullable::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
const ColumnNullable * col = typeid_cast<const ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
const ColumnUInt8 & content = static_cast<const ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 14:54:46 +00:00
|
|
|
const auto & null_map = content.getData();
|
|
|
|
|
|
|
|
if (isNullValue(&null_map, row_num))
|
|
|
|
writeCString(NullSymbol::Quoted::name, ostr);
|
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->serializeTextQuoted(*col->getNestedColumn(), row_num, ostr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 14:54:46 +00:00
|
|
|
void DataTypeNullable::deserializeTextQuoted(IColumn & column, ReadBuffer & istr) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
ColumnNullable * col = typeid_cast<ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
ColumnUInt8 & content = static_cast<ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 14:54:46 +00:00
|
|
|
auto & null_map = content.getData();
|
|
|
|
|
2016-07-14 12:58:30 +00:00
|
|
|
if (Deserializer<NullSymbol::Quoted>::execute(column, istr, &null_map))
|
2016-07-13 14:23:08 +00:00
|
|
|
{
|
|
|
|
ColumnPtr & nested_col = col->getNestedColumn();
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_col->insertDefault();
|
2016-07-13 14:23:08 +00:00
|
|
|
}
|
2016-07-11 14:54:46 +00:00
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->deserializeTextQuoted(*col->getNestedColumn(), istr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 16:37:44 +00:00
|
|
|
void DataTypeNullable::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
const ColumnNullable * col = typeid_cast<const ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
const ColumnUInt8 & content = static_cast<const ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 16:37:44 +00:00
|
|
|
const auto & null_map = content.getData();
|
|
|
|
|
|
|
|
if (isNullValue(&null_map, row_num))
|
|
|
|
writeCString(NullSymbol::Quoted::name, ostr);
|
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->serializeTextCSV(*col->getNestedColumn(), row_num, ostr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 16:37:44 +00:00
|
|
|
void DataTypeNullable::deserializeTextCSV(IColumn & column, ReadBuffer & istr, const char delimiter) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
ColumnNullable * col = typeid_cast<ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
ColumnUInt8 & content = static_cast<ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 16:37:44 +00:00
|
|
|
auto & null_map = content.getData();
|
|
|
|
|
2016-07-14 12:58:30 +00:00
|
|
|
if (Deserializer<NullSymbol::Quoted>::execute(column, istr, &null_map))
|
2016-07-13 14:23:08 +00:00
|
|
|
{
|
|
|
|
ColumnPtr & nested_col = col->getNestedColumn();
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_col->insertDefault();
|
2016-07-13 14:23:08 +00:00
|
|
|
}
|
2016-07-11 16:37:44 +00:00
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->deserializeTextCSV(*col->getNestedColumn(), istr, delimiter);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 14:54:46 +00:00
|
|
|
void DataTypeNullable::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
const ColumnNullable * col = typeid_cast<const ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
const ColumnUInt8 & content = static_cast<const ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 14:54:46 +00:00
|
|
|
const auto & null_map = content.getData();
|
|
|
|
|
|
|
|
if (isNullValue(&null_map, row_num))
|
|
|
|
writeCString(NullSymbol::Plain::name, ostr);
|
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->serializeText(*col->getNestedColumn(), row_num, ostr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 16:37:44 +00:00
|
|
|
void DataTypeNullable::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
const ColumnNullable * col = typeid_cast<const ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
const ColumnUInt8 & content = static_cast<const ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 16:37:44 +00:00
|
|
|
const auto & null_map = content.getData();
|
|
|
|
|
|
|
|
if (isNullValue(&null_map, row_num))
|
|
|
|
writeCString(NullSymbol::JSON::name, ostr);
|
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->serializeTextJSON(*col->getNestedColumn(), row_num, ostr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 16:37:44 +00:00
|
|
|
void DataTypeNullable::deserializeTextJSON(IColumn & column, ReadBuffer & istr) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
ColumnNullable * col = typeid_cast<ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
ColumnUInt8 & content = static_cast<ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 16:37:44 +00:00
|
|
|
auto & null_map = content.getData();
|
|
|
|
|
2016-07-14 12:58:30 +00:00
|
|
|
if (Deserializer<NullSymbol::JSON>::execute(column, istr, &null_map))
|
2016-07-13 14:23:08 +00:00
|
|
|
{
|
|
|
|
ColumnPtr & nested_col = col->getNestedColumn();
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_col->insertDefault();
|
2016-07-13 14:23:08 +00:00
|
|
|
}
|
2016-07-11 16:37:44 +00:00
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->deserializeTextJSON(*col->getNestedColumn(), istr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-11 14:54:46 +00:00
|
|
|
void DataTypeNullable::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
|
2016-07-05 16:23:37 +00:00
|
|
|
{
|
|
|
|
const ColumnNullable * col = typeid_cast<const ColumnNullable *>(&column);
|
|
|
|
if (col == nullptr)
|
|
|
|
throw Exception{"Discrepancy between data type and column type", ErrorCodes::LOGICAL_ERROR};
|
|
|
|
|
2016-08-10 19:12:29 +00:00
|
|
|
const ColumnUInt8 & content = static_cast<const ColumnUInt8 &>(*col->getNullValuesByteMap());
|
2016-07-11 14:54:46 +00:00
|
|
|
auto & null_map = content.getData();
|
|
|
|
|
|
|
|
if (isNullValue(&null_map, row_num))
|
|
|
|
writeCString(NullSymbol::XML::name, ostr);
|
|
|
|
else
|
2016-08-15 11:14:29 +00:00
|
|
|
nested_data_type->serializeTextXML(*col->getNestedColumn(), row_num, ostr);
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ColumnPtr DataTypeNullable::createColumn() const
|
|
|
|
{
|
2016-08-15 11:14:29 +00:00
|
|
|
ColumnPtr new_col_holder = std::make_shared<ColumnNullable>(nested_data_type->createColumn());
|
2016-08-10 19:12:29 +00:00
|
|
|
ColumnNullable & nullable_col = static_cast<ColumnNullable &>(*new_col_holder);
|
|
|
|
nullable_col.getNullValuesByteMap() = std::make_shared<ColumnUInt8>();
|
|
|
|
return new_col_holder;
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ColumnPtr DataTypeNullable::createConstColumn(size_t size, const Field & field) const
|
|
|
|
{
|
2016-08-15 11:14:29 +00:00
|
|
|
ColumnPtr new_col_holder = std::make_shared<ColumnNullable>(nested_data_type->createConstColumn(size, field));
|
2016-08-10 19:12:29 +00:00
|
|
|
ColumnNullable & nullable_col = static_cast<ColumnNullable &>(*new_col_holder);
|
|
|
|
nullable_col.getNullValuesByteMap() = std::make_shared<ColumnUInt8>(size);
|
|
|
|
return new_col_holder;
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Field DataTypeNullable::getDefault() const
|
|
|
|
{
|
2016-08-15 11:14:29 +00:00
|
|
|
return nested_data_type->getDefault();
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t DataTypeNullable::getSizeOfField() const
|
|
|
|
{
|
2016-08-15 11:14:29 +00:00
|
|
|
return nested_data_type->getSizeOfField();
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
DataTypePtr & DataTypeNullable::getNestedType()
|
|
|
|
{
|
2016-07-07 10:33:12 +00:00
|
|
|
return nested_data_type;
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const DataTypePtr & DataTypeNullable::getNestedType() const
|
|
|
|
{
|
2016-07-07 10:33:12 +00:00
|
|
|
return nested_data_type;
|
2016-07-05 16:23:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|