mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-11-30 19:42:00 +00:00
125 lines
3.5 KiB
C++
125 lines
3.5 KiB
C++
#include <base/map.h>
|
|
#include <Common/StringUtils/StringUtils.h>
|
|
#include <Columns/ColumnMap.h>
|
|
#include <Core/Field.h>
|
|
#include <DataTypes/DataTypeMap.h>
|
|
#include <DataTypes/DataTypeArray.h>
|
|
#include <DataTypes/DataTypeTuple.h>
|
|
#include <DataTypes/DataTypeLowCardinality.h>
|
|
#include <DataTypes/DataTypeFactory.h>
|
|
#include <DataTypes/Serializations/SerializationMap.h>
|
|
#include <Parsers/IAST.h>
|
|
#include <IO/WriteBufferFromString.h>
|
|
#include <IO/Operators.h>
|
|
|
|
|
|
namespace DB
|
|
{
|
|
|
|
namespace ErrorCodes
|
|
{
|
|
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
|
|
extern const int BAD_ARGUMENTS;
|
|
}
|
|
|
|
|
|
DataTypeMap::DataTypeMap(const DataTypes & elems_)
|
|
{
|
|
assert(elems_.size() == 2);
|
|
key_type = elems_[0];
|
|
value_type = elems_[1];
|
|
|
|
assertKeyType();
|
|
|
|
nested = std::make_shared<DataTypeArray>(
|
|
std::make_shared<DataTypeTuple>(DataTypes{key_type, value_type}, Names{"keys", "values"}));
|
|
}
|
|
|
|
DataTypeMap::DataTypeMap(const DataTypePtr & key_type_, const DataTypePtr & value_type_)
|
|
: key_type(key_type_), value_type(value_type_)
|
|
, nested(std::make_shared<DataTypeArray>(
|
|
std::make_shared<DataTypeTuple>(DataTypes{key_type_, value_type_}, Names{"keys", "values"})))
|
|
{
|
|
assertKeyType();
|
|
}
|
|
|
|
void DataTypeMap::assertKeyType() const
|
|
{
|
|
bool type_error = false;
|
|
if (key_type->getTypeId() == TypeIndex::LowCardinality)
|
|
{
|
|
const auto & low_cardinality_data_type = assert_cast<const DataTypeLowCardinality &>(*key_type);
|
|
if (!isStringOrFixedString(*(low_cardinality_data_type.getDictionaryType())))
|
|
type_error = true;
|
|
}
|
|
else if (!key_type->isValueRepresentedByInteger()
|
|
&& !isStringOrFixedString(*key_type)
|
|
&& !WhichDataType(key_type).isNothing()
|
|
&& !WhichDataType(key_type).isUUID())
|
|
{
|
|
type_error = true;
|
|
}
|
|
|
|
if (type_error)
|
|
throw Exception(ErrorCodes::BAD_ARGUMENTS,
|
|
"Type of Map key must be a type, that can be represented by integer or String or FixedString (possibly LowCardinality) or UUID,"
|
|
" but {} given", key_type->getName());
|
|
}
|
|
|
|
|
|
std::string DataTypeMap::doGetName() const
|
|
{
|
|
WriteBufferFromOwnString s;
|
|
s << "Map(" << key_type->getName() << ", " << value_type->getName() << ")";
|
|
|
|
return s.str();
|
|
}
|
|
|
|
MutableColumnPtr DataTypeMap::createColumn() const
|
|
{
|
|
return ColumnMap::create(nested->createColumn());
|
|
}
|
|
|
|
Field DataTypeMap::getDefault() const
|
|
{
|
|
return Map();
|
|
}
|
|
|
|
SerializationPtr DataTypeMap::doGetDefaultSerialization() const
|
|
{
|
|
return std::make_shared<SerializationMap>(
|
|
key_type->getDefaultSerialization(),
|
|
value_type->getDefaultSerialization(),
|
|
nested->getDefaultSerialization());
|
|
}
|
|
|
|
bool DataTypeMap::equals(const IDataType & rhs) const
|
|
{
|
|
if (typeid(rhs) != typeid(*this))
|
|
return false;
|
|
|
|
const DataTypeMap & rhs_map = static_cast<const DataTypeMap &>(rhs);
|
|
return nested->equals(*rhs_map.nested);
|
|
}
|
|
|
|
static DataTypePtr create(const ASTPtr & arguments)
|
|
{
|
|
if (!arguments || arguments->children.size() != 2)
|
|
throw Exception("Map data type family must have two arguments: key and value types", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
|
|
|
|
DataTypes nested_types;
|
|
nested_types.reserve(arguments->children.size());
|
|
|
|
for (const ASTPtr & child : arguments->children)
|
|
nested_types.emplace_back(DataTypeFactory::instance().get(child));
|
|
|
|
return std::make_shared<DataTypeMap>(nested_types);
|
|
}
|
|
|
|
|
|
void registerDataTypeMap(DataTypeFactory & factory)
|
|
{
|
|
factory.registerDataType("Map", create);
|
|
}
|
|
}
|