thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-09-21 17:20:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change Uuid to UUID datatype and make UInt128 a generic type

Browse Source
This commit is contained in:
Guillaume Tassery 2017-07-04 12:42:53 +02:00
parent d6ab06437a
commit cba9815981
22 changed files with 124 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dbms/src/Columns/ColumnVector.cpp
View File

@ -313,5 +313,5 @@ template class ColumnVector<Int32>;
template class ColumnVector<Int64>;
template class ColumnVector<Float32>;
template class ColumnVector<Float64>;
template class ColumnVector<Uuid>;
template class ColumnVector<UUID>;
}

4
dbms/src/Columns/ColumnsNumber.h
View File

@ -14,7 +14,7 @@ using ColumnUInt8 = ColumnVector<UInt8>;
using ColumnUInt16 = ColumnVector<UInt16>;
using ColumnUInt32 = ColumnVector<UInt32>;
using ColumnUInt64 = ColumnVector<UInt64>;
using ColumnUuid = ColumnVector<Uuid>;
using ColumnUInt128 = ColumnVector<UInt128>;
using ColumnInt8 = ColumnVector<Int8>;
using ColumnInt16 = ColumnVector<Int16>;
@ -29,7 +29,7 @@ using ColumnConstUInt8 = ColumnConst<UInt8>;
using ColumnConstUInt16 = ColumnConst<UInt16>;
using ColumnConstUInt32 = ColumnConst<UInt32>;
using ColumnConstUInt64 = ColumnConst<UInt64>;
using ColumnConstUuid = ColumnConst<Uuid>;
using ColumnConstUInt128 = ColumnConst<UInt128>;
using ColumnConstInt8 = ColumnConst<Int8>;
using ColumnConstInt16 = ColumnConst<Int16>;

2
dbms/src/Core/AccurateComparison.h
View File

@ -112,7 +112,7 @@ inline bool_if_gt_int_vs_uint<TInt, TUInt> equalsOpTmpl(TUInt a, TInt b)
// Case 3a. Comparison via conversion to double.
template <typename TAInt, typename TAFloat>
using bool_if_double_can_be_used = std::enable_if_t<
std::is_integral<TAInt>::value && (sizeof(TAInt) <= 4 || sizeof(DB::Uuid) == sizeof(TAInt)) && std::is_floating_point<TAFloat>::value,
std::is_integral<TAInt>::value && (sizeof(TAInt) <= 4 || sizeof(DB::UInt128) == sizeof(TAInt)) && std::is_floating_point<TAFloat>::value,
bool>;
template <typename TAInt, typename TAFloat>

48
dbms/src/Core/Field.cpp
View File

@ -34,6 +34,13 @@ namespace DB
x.push_back(value);
break;
}
case Field::Types::UInt128:
{
UInt128 value;
DB::readBinary(value, buf);
x.push_back(value);
break;
}
case Field::Types::Int64:
{
Int64 value;
@ -69,13 +76,6 @@ namespace DB
x.push_back(value);
break;
}
case Field::Types::Uuid:
{
Uuid value;
DB::readBinary(value, buf);
x.push_back(value);
break;
}
};
}
}
@ -99,6 +99,11 @@ namespace DB
DB::writeVarUInt(get<UInt64>(*it), buf);
break;
}
case Field::Types::UInt128:
{
DB::writeBinary(get<UInt128>(*it), buf);
break;
}
case Field::Types::Int64:
{
DB::writeVarInt(get<Int64>(*it), buf);
@ -124,11 +129,6 @@ namespace DB
DB::writeBinary(get<Tuple>(*it), buf);
break;
}
case Field::Types::Uuid:
{
DB::writeBinary(get<Uuid>(*it), buf);
break;
}
};
}
}
@ -168,6 +168,13 @@ namespace DB
x.push_back(value);
break;
}
case Field::Types::UInt128:
{
UInt128 value;
DB::readBinary(value, buf);
x.push_back(value);
break;
}
case Field::Types::Int64:
{
Int64 value;
@ -203,13 +210,6 @@ namespace DB
x.push_back(value);
break;
}
case Field::Types::Uuid:
{
Uuid value;
DB::readBinary(value, buf);
x.push_back(value);
break;
}
};
}
}
@ -233,6 +233,11 @@ namespace DB
DB::writeVarUInt(get<UInt64>(*it), buf);
break;
}
case Field::Types::UInt128:
{
DB::writeBinary(get<UInt128>(*it), buf);
break;
}
case Field::Types::Int64:
{
DB::writeVarInt(get<Int64>(*it), buf);
@ -258,11 +263,6 @@ namespace DB
DB::writeBinary(get<Tuple>(*it), buf);
break;
}
case Field::Types::Uuid:
{
DB::writeBinary(get<Uuid>(*it), buf);
break;
}
};
}
}

33
dbms/src/Core/Field.h
View File

@ -6,8 +6,8 @@
#include <functional>
#include <Common/Exception.h>
#include <Common/UInt128.h>
#include <Core/Types.h>
#include <Core/Uuid.h>
#include <common/strong_typedef.h>
@ -52,7 +52,7 @@ public:
UInt64 = 1,
Int64 = 2,
Float64 = 3,
Uuid = 4,
UInt128 = 4,
/// Non-POD types.
@ -74,7 +74,7 @@ public:
case String: return "String";
case Array: return "Array";
case Tuple: return "Tuple";
case Uuid: return "Uuid";
case UInt128: return "UInt128";
default:
throw Exception("Bad type of Field", ErrorCodes::BAD_TYPE_OF_FIELD);
@ -241,7 +241,7 @@ public:
case Types::String: return get<String>() < rhs.get<String>();
case Types::Array: return get<Array>() < rhs.get<Array>();
case Types::Tuple: return get<Tuple>() < rhs.get<Tuple>();
case Types::Uuid: return get<Uuid>() < rhs.get<Uuid>();
case Types::UInt128: return get<UInt128>() < rhs.get<UInt128>();
default:
throw Exception("Bad type of Field", ErrorCodes::BAD_TYPE_OF_FIELD);
@ -269,7 +269,7 @@ public:
case Types::String: return get<String>() <= rhs.get<String>();
case Types::Array: return get<Array>() <= rhs.get<Array>();
case Types::Tuple: return get<Tuple>() <= rhs.get<Tuple>();
case Types::Uuid: return get<Uuid>() <= rhs.get<Uuid>();
case Types::UInt128: return get<UInt128>() <= rhs.get<UInt128>();
default:
throw Exception("Bad type of Field", ErrorCodes::BAD_TYPE_OF_FIELD);
@ -291,11 +291,11 @@ public:
case Types::Null: return true;
case Types::UInt64:
case Types::Int64:
case Types::Float64: return get<UInt64>() == rhs.get<UInt64>();
case Types::String: return get<String>() == rhs.get<String>();
case Types::Array: return get<Array>() == rhs.get<Array>();
case Types::Tuple: return get<Tuple>() == rhs.get<Tuple>();
case Types::Uuid: return get<Uuid>() == rhs.get<Uuid>();
case Types::Float64: return get<UInt64>() == rhs.get<UInt64>();
case Types::String: return get<String>() == rhs.get<String>();
case Types::Array: return get<Array>() == rhs.get<Array>();
case Types::Tuple: return get<Tuple>() == rhs.get<Tuple>();
case Types::UInt128: return get<UInt128>() == rhs.get<UInt128>();
default:
throw Exception("Bad type of Field", ErrorCodes::BAD_TYPE_OF_FIELD);
@ -310,7 +310,7 @@ public:
private:
static const size_t storage_size = std::max({
DBMS_MIN_FIELD_SIZE - sizeof(Types::Which),
sizeof(Null), sizeof(UInt64), sizeof(Int64), sizeof(Float64), sizeof(String), sizeof(Array), sizeof(Tuple), sizeof(Uuid)});
sizeof(Null), sizeof(UInt64), sizeof(UInt128), sizeof(Int64), sizeof(Float64), sizeof(String), sizeof(Array), sizeof(Tuple)});
char storage[storage_size] __attribute__((aligned(8)));
Types::Which which;
@ -348,7 +348,7 @@ private:
case Types::String: f(field.template get<String>()); return;
case Types::Array: f(field.template get<Array>()); return;
case Types::Tuple: f(field.template get<Tuple>()); return;
case Types::Uuid: f(field.template get<Uuid>()); return;
case Types::UInt128: f(field.template get<UInt128>()); return;
default:
throw Exception("Bad type of Field", ErrorCodes::BAD_TYPE_OF_FIELD);
@ -405,9 +405,6 @@ private:
case Types::Tuple:
destroy<Tuple>();
break;
case Types::Uuid:
destroy<Uuid>();
break;
default:
break;
@ -434,7 +431,7 @@ template <> struct Field::TypeToEnum<Float64> { static const Types::Which value
template <> struct Field::TypeToEnum<String> { static const Types::Which value = Types::String; };
template <> struct Field::TypeToEnum<Array> { static const Types::Which value = Types::Array; };
template <> struct Field::TypeToEnum<Tuple> { static const Types::Which value = Types::Tuple; };
template <> struct Field::TypeToEnum<Uuid> { static const Types::Which value = Types::Uuid; };
template <> struct Field::TypeToEnum<UInt128> { static const Types::Which value = Types::UInt128; };
template <> struct Field::EnumToType<Field::Types::Null> { using Type = Null; };
template <> struct Field::EnumToType<Field::Types::UInt64> { using Type = UInt64; };
@ -443,7 +440,7 @@ template <> struct Field::EnumToType<Field::Types::Float64> { using Type = Float
template <> struct Field::EnumToType<Field::Types::String> { using Type = String; };
template <> struct Field::EnumToType<Field::Types::Array> { using Type = Array; };
template <> struct Field::EnumToType<Field::Types::Tuple> { using Type = Tuple; };
template <> struct Field::EnumToType<Field::Types::Uuid> { using Type = Uuid; };
template <> struct Field::EnumToType<Field::Types::UInt128> { using Type = UInt128; };
template <typename T>
@ -481,6 +478,7 @@ template <> struct NearestFieldType<UInt8> { using Type = UInt64; };
template <> struct NearestFieldType<UInt16> { using Type = UInt64; };
template <> struct NearestFieldType<UInt32> { using Type = UInt64; };
template <> struct NearestFieldType<UInt64> { using Type = UInt64; };
template <> struct NearestFieldType<UInt128> { using Type = UInt128; };
template <> struct NearestFieldType<Int8> { using Type = Int64; };
template <> struct NearestFieldType<Int16> { using Type = Int64; };
template <> struct NearestFieldType<Int32> { using Type = Int64; };
@ -492,7 +490,6 @@ template <> struct NearestFieldType<Array> { using Type = Array; };
template <> struct NearestFieldType<Tuple> { using Type = Tuple; };
template <> struct NearestFieldType<bool> { using Type = UInt64; };
template <> struct NearestFieldType<Null> { using Type = Null; };
template <> struct NearestFieldType<Uuid> { using Type = Uuid; };
template <typename T>

13
dbms/src/Core/UUID.h Normal file
View File

@ -0,0 +1,13 @@
#pragma once
#include <Common/UInt128.h>
namespace DB
{
using UUID = DB::UInt128;
template <> struct IsNumber<UUID> { static constexpr bool value = true; };
template <> struct TypeName<UUID> { static std::string get() { return "UUID"; } };
}

13
dbms/src/Core/Uuid.h
View File

@ -1,13 +0,0 @@
#pragma once
#include <Common/UInt128.h>
namespace DB
{
using Uuid = DB::UInt128;
template <> struct IsNumber<Uuid> { static constexpr bool value = true; };
template <> struct TypeName<Uuid> { static std::string get() { return "Uuid"; } };
}

4
dbms/src/DataTypes/DataTypeFactory.cpp
View File

@ -1,7 +1,7 @@
#include <IO/ReadHelpers.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeUuid.h>
#include <DataTypes/DataTypeUUID.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeString.h>
@ -60,7 +60,7 @@ DataTypeFactory::DataTypeFactory()
{"Float64", std::make_shared<DataTypeFloat64>()},
{"Date", std::make_shared<DataTypeDate>()},
{"DateTime", std::make_shared<DataTypeDateTime>()},
{"Uuid", std::make_shared<DataTypeUuid>()},
{"UUID", std::make_shared<DataTypeUUID>()},
{"String", std::make_shared<DataTypeString>()},
{"Null", std::make_shared<DataTypeNull>()}
}

2
dbms/src/DataTypes/DataTypeNumberBase.cpp
View File

@ -221,11 +221,11 @@ template class DataTypeNumberBase<UInt8>;
template class DataTypeNumberBase<UInt16>;
template class DataTypeNumberBase<UInt32>;
template class DataTypeNumberBase<UInt64>;
template class DataTypeNumberBase<UInt128>;
template class DataTypeNumberBase<Int8>;
template class DataTypeNumberBase<Int16>;
template class DataTypeNumberBase<Int32>;
template class DataTypeNumberBase<Int64>;
template class DataTypeNumberBase<Float32>;
template class DataTypeNumberBase<Float64>;
template class DataTypeNumberBase<Uuid>;
}

38
dbms/src/DataTypes/DataTypeUuid.cpp → dbms/src/DataTypes/DataTypeUUID.cpp
View File

@ -1,72 +1,72 @@
#include <DataTypes/DataTypeUuid.h>
#include <DataTypes/DataTypeUUID.h>
namespace DB
{
void DataTypeUuid::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
void DataTypeUUID::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
{
writeText(Uuid(static_cast<const ColumnUuid &>(column).getData()[row_num]), ostr);
writeText(UUID(static_cast<const ColumnUInt128 &>(column).getData()[row_num]), ostr);
}
static void deserializeText(IColumn & column, ReadBuffer & istr)
{
Uuid x;
UUID x;
readText(x, istr);
static_cast<ColumnUuid &>(column).getData().push_back(x);
static_cast<ColumnUInt128 &>(column).getData().push_back(x);
}
void DataTypeUuid::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
void DataTypeUUID::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
{
serializeText(column, row_num, ostr);
}
void DataTypeUuid::deserializeTextEscaped(IColumn & column, ReadBuffer & istr) const
void DataTypeUUID::deserializeTextEscaped(IColumn & column, ReadBuffer & istr) const
{
deserializeText(column, istr);
}
void DataTypeUuid::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
void DataTypeUUID::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
{
writeChar('\'', ostr);
serializeText(column, row_num, ostr);
writeChar('\'', ostr);
}
void DataTypeUuid::deserializeTextQuoted(IColumn & column, ReadBuffer & istr) const
void DataTypeUUID::deserializeTextQuoted(IColumn & column, ReadBuffer & istr) const
{
Uuid x;
UUID x;
assertChar('\'', istr);
readText(x, istr);
assertChar('\'', istr);
static_cast<ColumnUuid &>(column).getData().push_back(x); /// It's important to do this at the end - for exception safety.
static_cast<ColumnUInt128 &>(column).getData().push_back(x); /// It's important to do this at the end - for exception safety.
}
void DataTypeUuid::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, bool) const
void DataTypeUUID::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, bool) const
{
writeChar('"', ostr);
serializeText(column, row_num, ostr);
writeChar('"', ostr);
}
void DataTypeUuid::deserializeTextJSON(IColumn & column, ReadBuffer & istr) const
void DataTypeUUID::deserializeTextJSON(IColumn & column, ReadBuffer & istr) const
{
Uuid x;
UUID x;
assertChar('"', istr);
readText(x, istr);
assertChar('"', istr);
static_cast<ColumnUuid &>(column).getData().push_back(x);
static_cast<ColumnUInt128 &>(column).getData().push_back(x);
}
void DataTypeUuid::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
void DataTypeUUID::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
{
writeChar('"', ostr);
serializeText(column, row_num, ostr);
writeChar('"', ostr);
}
void DataTypeUuid::deserializeTextCSV(IColumn & column, ReadBuffer & istr, const char delimiter) const
void DataTypeUUID::deserializeTextCSV(IColumn & column, ReadBuffer & istr, const char delimiter) const
{
Uuid value;
UUID value;
readCSV(value, istr);
static_cast<ColumnUuid &>(column).getData().push_back(value);
static_cast<ColumnUInt128 &>(column).getData().push_back(value);
}
}

4
dbms/src/DataTypes/DataTypeUuid.h → dbms/src/DataTypes/DataTypeUUID.h
View File

@ -9,13 +9,13 @@
namespace DB
{
class DataTypeUuid final : public DataTypeNumberBase<Uuid>
class DataTypeUUID final : public DataTypeNumberBase<UInt128>
{
public:
bool behavesAsNumber() const override { return false; }
DataTypePtr clone() const override { return std::make_shared<DataTypeUuid>(); }
DataTypePtr clone() const override { return std::make_shared<DataTypeUUID>(); }
void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr) const override;
void serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr) const override;

18
dbms/src/DataTypes/FieldToDataType.cpp
View File

@ -6,7 +6,7 @@
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeUuid.h>
#include <DataTypes/DataTypeUUID.h>
#include <DataTypes/DataTypeNull.h>
#include <Common/Exception.h>
#include <ext/size.h>
@ -84,7 +84,7 @@ DataTypePtr FieldToDataType::operator() (Array & x) const
bool has_float = false;
bool has_tuple = false;
bool has_null = false;
bool has_uuid = false;
bool has_uint128 = false;
int max_bits = 0;
int max_signed_bits = 0;
int max_unsigned_bits = 0;
@ -129,6 +129,11 @@ DataTypePtr FieldToDataType::operator() (Array & x) const
max_bits = std::max(max_signed_bits, max_bits);
break;
}
case Field::Types::UInt128:
{
has_uint128 = true;
break;
}
case Field::Types::Float64:
{
has_float = true;
@ -154,11 +159,6 @@ DataTypePtr FieldToDataType::operator() (Array & x) const
has_null = true;
break;
}
case Field::Types::Uuid:
{
has_uuid = true;
break;
}
}
}
@ -174,8 +174,8 @@ DataTypePtr FieldToDataType::operator() (Array & x) const
if (has_string)
return wrap_into_array(std::make_shared<DataTypeString>());
if (has_uuid)
return wrap_into_array(std::make_shared<DataTypeUuid>());
if (has_uint128)
return wrap_into_array(std::make_shared<DataTypeUUID>());
if (has_float && max_bits == 64)
throw Exception("Incompatible types Float64 and UInt64/Int64 of elements of array", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);

16
dbms/src/Functions/FunctionsComparison.h
View File

@ -11,7 +11,7 @@
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeUuid.h>
#include <DataTypes/DataTypeUUID.h>
#include <DataTypes/DataTypeFixedString.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeEnum.h>
@ -773,7 +773,7 @@ private:
const auto legal_types = (is_date = typeid_cast<const DataTypeDate *>(number_type))
|| (is_date_time = typeid_cast<const DataTypeDateTime *>(number_type))
|| (is_uuid = typeid_cast<const DataTypeUuid *>(number_type))
|| (is_uuid = typeid_cast<const DataTypeUUID *>(number_type))
|| (is_enum8 = typeid_cast<const DataTypeEnum8 *>(number_type))
|| (is_enum16 = typeid_cast<const DataTypeEnum16 *>(number_type));
@ -813,14 +813,14 @@ private:
}
else if (is_uuid)
{
Uuid uuid;
UUID uuid;
ReadBufferFromString in(column_string->getData());
readText(uuid, in);
if (!in.eof())
throw Exception("String is too long for Uuid: " + column_string->getData());
throw Exception("String is too long for UUID: " + column_string->getData());
ColumnConst<DataTypeUuid::FieldType> parsed_const_uuid(block.rows(), uuid);
executeNumLeftType<DataTypeUuid::FieldType>(block, result,
ColumnConst<DataTypeUUID::FieldType> parsed_const_uuid(block.rows(), uuid);
executeNumLeftType<DataTypeUUID::FieldType>(block, result,
left_is_num ? col_left_untyped : &parsed_const_uuid,
left_is_num ? &parsed_const_uuid : col_right_untyped);
}
@ -1020,7 +1020,7 @@ public:
|| (left_is_date = typeid_cast<const DataTypeDate *>(arguments[0].get()))
|| (left_is_date_time = typeid_cast<const DataTypeDateTime *>(arguments[0].get()))
|| (left_is_enum8 = typeid_cast<const DataTypeEnum8 *>(arguments[0].get()))
|| (left_is_uuid = typeid_cast<const DataTypeUuid *>(arguments[0].get()))
|| (left_is_uuid = typeid_cast<const DataTypeUUID *>(arguments[0].get()))
|| (left_is_enum16 = typeid_cast<const DataTypeEnum16 *>(arguments[0].get()))
|| (left_is_string = typeid_cast<const DataTypeString *>(arguments[0].get()))
|| (left_is_fixed_string = typeid_cast<const DataTypeFixedString *>(arguments[0].get()))
@ -1040,7 +1040,7 @@ public:
false
|| (right_is_date = typeid_cast<const DataTypeDate *>(arguments[1].get()))
|| (right_is_date_time = typeid_cast<const DataTypeDateTime *>(arguments[1].get()))
|| (right_is_uuid = typeid_cast<const DataTypeUuid *>(arguments[1].get()))
|| (right_is_uuid = typeid_cast<const DataTypeUUID *>(arguments[1].get()))
|| (right_is_enum8 = typeid_cast<const DataTypeEnum8 *>(arguments[1].get()))
|| (right_is_enum16 = typeid_cast<const DataTypeEnum16 *>(arguments[1].get()))
|| (right_is_string = typeid_cast<const DataTypeString *>(arguments[1].get()))

2
dbms/src/Functions/FunctionsConversion.cpp
View File

@ -62,7 +62,7 @@ void registerFunctionsConversion(FunctionFactory & factory)
factory.registerFunction<FunctionToFloat64>();
factory.registerFunction<FunctionToDate>();
factory.registerFunction<FunctionToDateTime>();
factory.registerFunction<FunctionToUuid>();
factory.registerFunction<FunctionToUUID>();
factory.registerFunction<FunctionToString>();
factory.registerFunction<FunctionToFixedString>();
factory.registerFunction<FunctionToUnixTimestamp>();

10
dbms/src/Functions/FunctionsConversion.h
View File

@ -19,7 +19,7 @@
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeTuple.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeUuid.h>
#include <DataTypes/DataTypeUUID.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnConst.h>
@ -740,7 +740,7 @@ private:
else if (typeid_cast<const DataTypeFloat64 * >(from_type)) ConvertImpl<DataTypeFloat64, ToDataType, Name>::execute(block, arguments, result);
else if (typeid_cast<const DataTypeDate * >(from_type)) ConvertImpl<DataTypeDate, ToDataType, Name>::execute(block, arguments, result);
else if (typeid_cast<const DataTypeDateTime * >(from_type)) ConvertImpl<DataTypeDateTime, ToDataType, Name>::execute(block, arguments, result);
else if (typeid_cast<const DataTypeUuid * >(from_type)) ConvertImpl<DataTypeUuid, ToDataType, Name>::execute(block, arguments, result);
else if (typeid_cast<const DataTypeUUID * >(from_type)) ConvertImpl<DataTypeUUID, ToDataType, Name>::execute(block, arguments, result);
else if (typeid_cast<const DataTypeString * >(from_type)) ConvertImpl<DataTypeString, ToDataType, Name>::execute(block, arguments, result);
else if (typeid_cast<const DataTypeFixedString *>(from_type)) ConvertImpl<DataTypeFixedString, ToDataType, Name>::execute(block, arguments, result);
else if (typeid_cast<const DataTypeEnum8 *>(from_type)) ConvertImpl<DataTypeEnum8, ToDataType, Name>::execute(block, arguments, result);
@ -1145,7 +1145,7 @@ struct NameToInt64 { static constexpr auto name = "toInt64"; };
struct NameToFloat32 { static constexpr auto name = "toFloat32"; };
struct NameToFloat64 { static constexpr auto name = "toFloat64"; };
struct NameToDateTime { static constexpr auto name = "toDateTime"; };
struct NameToUuid { static constexpr auto name = "toUuid"; };
struct NameToUUID { static constexpr auto name = "toUUID"; };
using FunctionToUInt8 = FunctionConvert<DataTypeUInt8, NameToUInt8, ToIntMonotonicity<UInt8>>;
using FunctionToUInt16 = FunctionConvert<DataTypeUInt16, NameToUInt16, ToIntMonotonicity<UInt16>>;
@ -1159,7 +1159,7 @@ using FunctionToFloat32 = FunctionConvert<DataTypeFloat32, NameToFloat32,
using FunctionToFloat64 = FunctionConvert<DataTypeFloat64, NameToFloat64, PositiveMonotonicity>;
using FunctionToDate = FunctionConvert<DataTypeDate, NameToDate, ToIntMonotonicity<UInt16>>;
using FunctionToDateTime = FunctionConvert<DataTypeDateTime, NameToDateTime, ToIntMonotonicity<UInt32>>;
using FunctionToUuid = FunctionConvert<DataTypeUuid, NameToUuid, ToIntMonotonicity<UInt128>>;
using FunctionToUUID = FunctionConvert<DataTypeUUID, NameToUUID, ToIntMonotonicity<UInt128>>;
using FunctionToString = FunctionConvert<DataTypeString, NameToString, ToStringMonotonicity>;
using FunctionToUnixTimestamp = FunctionConvert<DataTypeUInt32, NameToUnixTimestamp, ToIntMonotonicity<UInt32>>;
@ -1176,7 +1176,7 @@ template <> struct FunctionTo<DataTypeFloat32> { using Type = FunctionToFloat32;
template <> struct FunctionTo<DataTypeFloat64> { using Type = FunctionToFloat64; };
template <> struct FunctionTo<DataTypeDate> { using Type = FunctionToDate; };
template <> struct FunctionTo<DataTypeDateTime> { using Type = FunctionToDateTime; };
template <> struct FunctionTo<DataTypeUuid> { using Type = FunctionToUuid; };
template <> struct FunctionTo<DataTypeUUID> { using Type = FunctionToUUID; };
template <> struct FunctionTo<DataTypeString> { using Type = FunctionToString; };
template <> struct FunctionTo<DataTypeFixedString> { using Type = FunctionToFixedString; };
template <typename FieldType> struct FunctionTo<DataTypeEnum<FieldType>>

2
dbms/src/IO/ReadHelpers.cpp
View File

@ -41,7 +41,7 @@ void parseUUID(const UInt8 * src36, UInt8 * dst16)
parseHex(&src36[24], &dst16[10], 6);
}
void parseUUID(const UInt8 * src36, Uuid & uuid)
void parseUUID(const UInt8 * src36, UUID & uuid)
{
char s[16 + 1];

10
dbms/src/IO/ReadHelpers.h
View File

@ -14,7 +14,7 @@
#include <common/exp10.h>
#include <Core/Types.h>
#include <Core/Uuid.h>
#include <Core/UUID.h>
#include <common/StringRef.h>
#include <Common/Exception.h>
#include <Common/StringUtils.h>
@ -558,7 +558,7 @@ struct NullSink
};
void parseUUID(const UInt8 * src36, UInt8 * dst16);
void parseUUID(const UInt8 * src36, Uuid & uuid);
void parseUUID(const UInt8 * src36, UUID & uuid);
void formatHex(const UInt8 * __restrict src, UInt8 * __restrict dst, const size_t num_bytes);
/// In YYYY-MM-DD format
@ -594,7 +594,7 @@ inline void readDateText(LocalDate & date, ReadBuffer & buf)
date.day((s[8] - '0') * 10 + (s[9] - '0'));
}
inline void readUuidText(Uuid & uuid, ReadBuffer & buf)
inline void readUUIDText(UUID & uuid, ReadBuffer & buf)
{
char s[36];
size_t size = buf.read(s, 36);
@ -700,7 +700,7 @@ inline void readText(bool & x, ReadBuffer & buf) { readBoolText(x, buf); }
inline void readText(String & x, ReadBuffer & buf) { readEscapedString(x, buf); }
inline void readText(LocalDate & x, ReadBuffer & buf) { readDateText(x, buf); }
inline void readText(LocalDateTime & x, ReadBuffer & buf) { readDateTimeText(x, buf); }
inline void readText(Uuid & x, ReadBuffer & buf) { readUuidText(x, buf); }
inline void readText(UUID & x, ReadBuffer & buf) { readUUIDText(x, buf); }
/// Generic methods to read value in text format,
@ -773,7 +773,7 @@ readCSV(T & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
inline void readCSV(String & x, ReadBuffer & buf, const char delimiter = ',') { readCSVString(x, buf, delimiter); }
inline void readCSV(LocalDate & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
inline void readCSV(LocalDateTime & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
inline void readCSV(Uuid & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
inline void readCSV(UUID & x, ReadBuffer & buf) { readCSVSimple(x, buf); }
template <typename T>

2
dbms/src/IO/WriteHelpers.cpp
View File

@ -48,7 +48,7 @@ void formatUUID(const UInt8 * src16, UInt8 * dst36)
formatHex(&src16[10], &dst36[24], 6);
}
void formatUUID(const Uuid & uuid, UInt8 * dst36)
void formatUUID(const UUID & uuid, UInt8 * dst36)
{
char s[16+1];

8
dbms/src/IO/WriteHelpers.h
View File

@ -11,7 +11,7 @@
#include <common/find_first_symbols.h>
#include <Core/Types.h>
#include <Core/Uuid.h>
#include <Core/UUID.h>
#include <Common/Exception.h>
#include <Common/StringUtils.h>
#include <Common/UInt128.h>
@ -475,9 +475,9 @@ inline void writeXMLString(const StringRef & s, WriteBuffer & buf)
void formatHex(const UInt8 * __restrict src, UInt8 * __restrict dst, const size_t num_bytes);
void formatUUID(const UInt8 * src16, UInt8 * dst36);
void formatUUID(const Uuid & uuid, UInt8 * dst36);
void formatUUID(const UUID & uuid, UInt8 * dst36);
inline void writeUuidText(const Uuid & uuid, WriteBuffer & buf)
inline void writeUUIDText(const UUID & uuid, WriteBuffer & buf)
{
char s[36];
@ -623,7 +623,7 @@ inline void writeText(const char * x, size_t size, WriteBuffer & buf) { writeEsc
inline void writeText(const LocalDate & x, WriteBuffer & buf) { writeDateText(x, buf); }
inline void writeText(const LocalDateTime & x, WriteBuffer & buf) { writeDateTimeText(x, buf); }
inline void writeText(const Uuid & x, WriteBuffer & buf) { writeUuidText(x, buf); }
inline void writeText(const UUID & x, WriteBuffer & buf) { writeUUIDText(x, buf); }
/// String, date, datetime are in single quotes with C-style escaping. Numbers - without.
template <typename T>

12
dbms/src/Interpreters/convertFieldToType.cpp
View File

@ -15,7 +15,7 @@
#include <Core/AccurateComparison.h>
#include <Core/FieldVisitors.h>
#include <DataTypes/DataTypeUuid.h>
#include <DataTypes/DataTypeUUID.h>
namespace DB
{
@ -89,14 +89,14 @@ UInt64 stringToDateTime(const String & s)
return UInt64(date_time);
}
Uuid stringToUuid(const String & s)
UUID stringToUUID(const String & s)
{
ReadBufferFromString in(s);
Uuid uuid;
UUID uuid;
readText(uuid, in);
if (!in.eof())
throw Exception("String is too long for Uuid: " + s);
throw Exception("String is too long for UUID: " + s);
return uuid;
}
@ -124,7 +124,7 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type)
if (!is_date)
if (!(is_datetime = typeid_cast<const DataTypeDateTime *>(&type)))
if (!(is_uuid = typeid_cast<const DataTypeUuid *>(&type)))
if (!(is_uuid = typeid_cast<const DataTypeUUID *>(&type)))
if (!(is_enum = dynamic_cast<const IDataTypeEnum *>(&type)))
throw Exception{"Logical error: unknown numeric type " + type.getName(), ErrorCodes::LOGICAL_ERROR};
@ -146,7 +146,7 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type)
}
else if (is_uuid)
{
return stringToUuid(src.get<const String &>());
return stringToUUID(src.get<const String &>());
}
else if (is_enum)
{

6
dbms/src/Storages/MergeTree/MergeTreeData.cpp
View File

@ -13,7 +13,7 @@
#include <IO/HexWriteBuffer.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeUuid.h>
#include <DataTypes/DataTypeUUID.h>
#include <DataTypes/DataTypeFixedString.h>
#include <DataTypes/DataTypeEnum.h>
#include <DataTypes/DataTypeNested.h>
@ -241,7 +241,7 @@ void MergeTreeData::MergingParams::check(const NamesAndTypesList & columns) cons
&& !typeid_cast<const DataTypeUInt16 *>(column.type.get())
&& !typeid_cast<const DataTypeUInt32 *>(column.type.get())
&& !typeid_cast<const DataTypeUInt64 *>(column.type.get())
&& !typeid_cast<const DataTypeUuid *>(column.type.get())
&& !typeid_cast<const DataTypeUUID *>(column.type.get())
&& !typeid_cast<const DataTypeDate *>(column.type.get())
&& !typeid_cast<const DataTypeDateTime *>(column.type.get()))
throw Exception("Version column (" + version_column + ")"
@ -624,7 +624,7 @@ bool isMetadataOnlyConversion(const IDataType * from, const IDataType * to)
{ typeid(DataTypeDateTime), typeid(DataTypeUInt32) },
{ typeid(DataTypeUInt32), typeid(DataTypeDateTime) },
{ typeid(DataTypeDate), typeid(DataTypeUInt16) },
{ typeid(DataTypeUuid), typeid(DataTypeUuid) },
{ typeid(DataTypeUUID), typeid(DataTypeUUID) },
{ typeid(DataTypeUInt16), typeid(DataTypeDate) },
};

2
dbms/tests/queries/0_stateless/00306_insert_values_and_expressions.sql
View File

@ -1,5 +1,5 @@
DROP TABLE IF EXISTS test.insert;
CREATE TABLE test.insert (i UInt64, s String, u Uuid, d Date, t DateTime, a Array(UInt32)) ENGINE = Memory;
CREATE TABLE test.insert (i UInt64, s String, u UUID, d Date, t DateTime, a Array(UInt32)) ENGINE = Memory;
INSERT INTO test.insert VALUES (1, 'Hello', 'ab41bdd6-5cd4-11e7-907b-a6006ad3dba0', '2016-01-01', '2016-01-02 03:04:05', [1, 2, 3]), (1 + 1, concat('Hello', ', world'), toUuid(0), toDate('2016-01-01') + 1, toStartOfMinute(toDateTime('2016-01-02 03:04:05')), [[0,1],[2]][1]), (round(pi()), concat('hello', ', world!'), toUuid(toString('ab41bdd6-5cd4-11e7-907b-a6006ad3dba0')), toDate(toDateTime('2016-01-03 03:04:05')), toStartOfHour(toDateTime('2016-01-02 03:04:05')), []), (4, 'World', 'ab41bdd6-5cd4-11e7-907b-a6006ad3dba0', '2016-01-04', '2016-12-11 10:09:08', [3,2,1]);