diff --git a/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp b/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp
index 1be85f7e1b8dedf3494d8d7ec2417f6bb22f72df..f093e47e6404902f16ae0d31393d4287d22e6809 100644
--- a/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp
@@ -2,7 +2,7 @@
 #include <Common/typeid_cast.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <DataTypes/DataTypeAggregateFunction.h>
-#include <DataTypes/DataTypeDomainSimpleAggregateFunction.h>
+#include <DataTypes/DataTypeCustomSimpleAggregateFunction.h>
 
 
 namespace DB
@@ -24,7 +24,7 @@ AggregatingSortedBlockInputStream::AggregatingSortedBlockInputStream(
         ColumnWithTypeAndName & column = header.safeGetByPosition(i);
 
         /// We leave only states of aggregate functions.
-        if (!dynamic_cast<const DataTypeAggregateFunction *>(column.type.get()) && !findSimpleAggregateFunction(column.type))
+        if (!dynamic_cast<const DataTypeAggregateFunction *>(column.type.get()) && !dynamic_cast<const DataTypeCustomSimpleAggregateFunction *>(column.type->getCustomName()))
         {
             column_numbers_not_to_aggregate.push_back(i);
             continue;
@@ -42,7 +42,7 @@ AggregatingSortedBlockInputStream::AggregatingSortedBlockInputStream(
             continue;
         }
 
-        if (auto simple_aggr = findSimpleAggregateFunction(column.type))
+        if (auto simple_aggr = dynamic_cast<const DataTypeCustomSimpleAggregateFunction *>(column.type->getCustomName()))
         {
             // simple aggregate function
             SimpleAggregateDescription desc{simple_aggr->getFunction(), i};
diff --git a/dbms/src/DataTypes/IDataTypeDomain.h b/dbms/src/DataTypes/DataTypeCustom.h
similarity index 62%
rename from dbms/src/DataTypes/IDataTypeDomain.h
rename to dbms/src/DataTypes/DataTypeCustom.h
index a840964d28a24fe3849590456f7750af4bf1d6ae..93882361e20ecf1bf6cf7673a98d37cca62a92c2 100644
--- a/dbms/src/DataTypes/IDataTypeDomain.h
+++ b/dbms/src/DataTypes/DataTypeCustom.h
@@ -1,8 +1,8 @@
 #pragma once
 
+#include <memory>
 #include <cstddef>
 #include <Core/Types.h>
-#include <DataTypes/IDataType.h>
 
 namespace DB
 {
@@ -12,45 +12,21 @@ class WriteBuffer;
 struct FormatSettings;
 class IColumn;
 
-/** Allow to customize an existing data type and set a different name. Derived class IDataTypeDomainCustomSerialization allows
- * further customization of serialization/deserialization methods. See use in IPv4 and IPv6 data type domains.
- *
- * IDataTypeDomain can be chained for further delegation (only for getName for the moment).
+/** Allow to customize an existing data type and set a different name and/or text serialization/deserialization methods.
+ * See use in IPv4 and IPv6 data types, and also in SimpleAggregateFunction.
   */
-class IDataTypeDomain
+class IDataTypeCustomName
 {
-private:
-    mutable DataTypeDomainPtr delegate;
-
 public:
-    virtual ~IDataTypeDomain() {}
-
-    String getName() const
-    {
-        if (delegate)
-            return delegate->getName();
-        else
-            return doGetName();
-    }
-
-    void appendDomain(DataTypeDomainPtr delegate_) const
-    {
-        if (delegate == nullptr)
-            delegate = std::move(delegate_);
-        else
-            delegate->appendDomain(std::move(delegate_));
-    }
-
-    const IDataTypeDomain * getDomain() const { return delegate.get(); }
-
-protected:
-    virtual String doGetName() const = 0;
+    virtual ~IDataTypeCustomName() {}
+
+    virtual String getName() const = 0;
 };
 
-class IDataTypeDomainCustomSerialization : public IDataTypeDomain
+class IDataTypeCustomTextSerialization
 {
 public:
-    virtual ~IDataTypeDomainCustomSerialization() {}
+    virtual ~IDataTypeCustomTextSerialization() {}
 
     /** Text serialization for displaying on a terminal or saving into a text file, and the like.
       * Without escaping or quoting.
@@ -82,4 +58,31 @@ public:
     virtual void serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const = 0;
 };
 
+using DataTypeCustomNamePtr = std::unique_ptr<const IDataTypeCustomName>;
+using DataTypeCustomTextSerializationPtr = std::unique_ptr<const IDataTypeCustomTextSerialization>;
+
+/** Describe a data type customization
+ */
+struct DataTypeCustomDesc
+{
+    DataTypeCustomNamePtr name;
+    DataTypeCustomTextSerializationPtr text_serialization;
+
+    DataTypeCustomDesc(DataTypeCustomNamePtr name_, DataTypeCustomTextSerializationPtr text_serialization_)
+            : name(std::move(name_)), text_serialization(std::move(text_serialization_)) {}
+};
+
+using DataTypeCustomDescPtr = std::unique_ptr<DataTypeCustomDesc>;
+
+/** A simple implementation of IDataTypeCustomName
+ */
+class DataTypeCustomFixedName : public IDataTypeCustomName
+{
+private:
+    String name;
+public:
+    DataTypeCustomFixedName(String name_) : name(name_) {}
+    String getName() const override { return name; }
+};
+
 } // namespace DB
diff --git a/dbms/src/DataTypes/DataTypeDomainIPv4AndIPv6.cpp b/dbms/src/DataTypes/DataTypeCustomIPv4AndIPv6.cpp
similarity index 62%
rename from dbms/src/DataTypes/DataTypeDomainIPv4AndIPv6.cpp
rename to dbms/src/DataTypes/DataTypeCustomIPv4AndIPv6.cpp
index f57a6167d3dc121574ee3abd1c2c5419f42bdd97..8d12a9847db0807a438ac699e64bda68b8c1c915 100644
--- a/dbms/src/DataTypes/DataTypeDomainIPv4AndIPv6.cpp
+++ b/dbms/src/DataTypes/DataTypeCustomIPv4AndIPv6.cpp
@@ -1,9 +1,9 @@
 #include <Columns/ColumnsNumber.h>
 #include <Common/Exception.h>
 #include <Common/formatIPv6.h>
-#include <DataTypes/DataTypeDomainWithSimpleSerialization.h>
+#include <DataTypes/DataTypeCustomSimpleTextSerialization.h>
 #include <DataTypes/DataTypeFactory.h>
-#include <DataTypes/IDataTypeDomain.h>
+#include <DataTypes/DataTypeCustom.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/FunctionsCoding.h>
 
@@ -20,20 +20,15 @@ namespace ErrorCodes
 namespace
 {
 
-class DataTypeDomainIPv4 : public DataTypeDomainWithSimpleSerialization
+class DataTypeCustomIPv4Serialization : public DataTypeCustomSimpleTextSerialization
 {
 public:
-    String doGetName() const override
-    {
-        return "IPv4";
-    }
-
     void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override
     {
         const auto col = checkAndGetColumn<ColumnUInt32>(&column);
         if (!col)
         {
-            throw Exception(getName() + " domain can only serialize columns of type UInt32." + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
+            throw Exception("IPv4 type can only serialize columns of type UInt32." + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
         }
 
         char buffer[IPV4_MAX_TEXT_LENGTH + 1] = {'\0'};
@@ -48,7 +43,7 @@ public:
         ColumnUInt32 * col = typeid_cast<ColumnUInt32 *>(&column);
         if (!col)
         {
-            throw Exception(getName() + " domain can only deserialize columns of type UInt32." + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
+            throw Exception("IPv4 type can only deserialize columns of type UInt32." + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
         }
 
         char buffer[IPV4_MAX_TEXT_LENGTH + 1] = {'\0'};
@@ -63,20 +58,16 @@ public:
     }
 };
 
-class DataTypeDomainIPv6 : public DataTypeDomainWithSimpleSerialization
+class DataTypeCustomIPv6Serialization : public DataTypeCustomSimpleTextSerialization
 {
 public:
-    String doGetName() const override
-    {
-        return "IPv6";
-    }
 
     void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override
     {
         const auto col = checkAndGetColumn<ColumnFixedString>(&column);
         if (!col)
         {
-            throw Exception(getName() + " domain can only serialize columns of type FixedString(16)." + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
+            throw Exception("IPv6 type domain can only serialize columns of type FixedString(16)." + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
         }
 
         char buffer[IPV6_MAX_TEXT_LENGTH + 1] = {'\0'};
@@ -91,7 +82,7 @@ public:
         ColumnFixedString * col = typeid_cast<ColumnFixedString *>(&column);
         if (!col)
         {
-            throw Exception(getName() + " domain can only deserialize columns of type FixedString(16)." + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
+            throw Exception("IPv6 type domain can only deserialize columns of type FixedString(16)." + column.getName(), ErrorCodes::ILLEGAL_COLUMN);
         }
 
         char buffer[IPV6_MAX_TEXT_LENGTH + 1] = {'\0'};
@@ -100,7 +91,7 @@ public:
         std::string ipv6_value(IPV6_BINARY_LENGTH, '\0');
         if (!parseIPv6(buffer, reinterpret_cast<unsigned char *>(ipv6_value.data())))
         {
-            throw Exception("Invalid " + getName() + " value.", ErrorCodes::CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING);
+            throw Exception("Invalid IPv6 value.", ErrorCodes::CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING);
         }
 
         col->insertString(ipv6_value);
@@ -111,8 +102,17 @@ public:
 
 void registerDataTypeDomainIPv4AndIPv6(DataTypeFactory & factory)
 {
-    factory.registerDataTypeDomain("IPv4", [] { return std::make_pair(DataTypeFactory::instance().get("UInt32"), std::make_unique<DataTypeDomainIPv4>()); });
-    factory.registerDataTypeDomain("IPv6", [] { return std::make_pair(DataTypeFactory::instance().get("FixedString(16)"), std::make_unique<DataTypeDomainIPv6>()); });
+    factory.registerSimpleDataTypeCustom("IPv4", []
+    {
+        return std::make_pair(DataTypeFactory::instance().get("UInt32"),
+            std::make_unique<DataTypeCustomDesc>(std::make_unique<DataTypeCustomFixedName>("IPv4"), std::make_unique<DataTypeCustomIPv4Serialization>()));
+    });
+
+    factory.registerSimpleDataTypeCustom("IPv6", []
+    {
+        return std::make_pair(DataTypeFactory::instance().get("FixedString(16)"),
+                              std::make_unique<DataTypeCustomDesc>(std::make_unique<DataTypeCustomFixedName>("IPv6"), std::make_unique<DataTypeCustomIPv6Serialization>()));
+    });
 }
 
 } // namespace DB
diff --git a/dbms/src/DataTypes/DataTypeDomainSimpleAggregateFunction.cpp b/dbms/src/DataTypes/DataTypeCustomSimpleAggregateFunction.cpp
similarity index 81%
rename from dbms/src/DataTypes/DataTypeDomainSimpleAggregateFunction.cpp
rename to dbms/src/DataTypes/DataTypeCustomSimpleAggregateFunction.cpp
index 82e3b873f5e11bcdf983af76b16025ce04151ac2..2cb0f87facd300e8ce62ef9c2329d535abc15bfc 100644
--- a/dbms/src/DataTypes/DataTypeDomainSimpleAggregateFunction.cpp
+++ b/dbms/src/DataTypes/DataTypeCustomSimpleAggregateFunction.cpp
@@ -5,7 +5,7 @@
 
 #include <Columns/ColumnAggregateFunction.h>
 
-#include <DataTypes/DataTypeDomainSimpleAggregateFunction.h>
+#include <DataTypes/DataTypeCustomSimpleAggregateFunction.h>
 #include <DataTypes/DataTypeLowCardinality.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypeArray.h>
@@ -33,7 +33,7 @@ namespace ErrorCodes
 static const std::vector<String> supported_functions{"any", "anyLast", "min", "max", "sum"};
 
 
-String DataTypeDomainSimpleAggregateFunction::doGetName() const
+String DataTypeCustomSimpleAggregateFunction::getName() const
 {
     std::stringstream stream;
     stream << "SimpleAggregateFunction(" << function->getName();
@@ -58,7 +58,7 @@ String DataTypeDomainSimpleAggregateFunction::doGetName() const
 }
 
 
-static std::pair<DataTypePtr, DataTypeDomainPtr> create(const ASTPtr & arguments)
+static std::pair<DataTypePtr, DataTypeCustomDescPtr> create(const ASTPtr & arguments)
 {
     String function_name;
     AggregateFunctionPtr function;
@@ -117,7 +117,6 @@ static std::pair<DataTypePtr, DataTypeDomainPtr> create(const ASTPtr & arguments
     }
 
     DataTypePtr storage_type = DataTypeFactory::instance().get(argument_types[0]->getName());
-    DataTypeDomainPtr domain = std::make_unique<DataTypeDomainSimpleAggregateFunction>(function, argument_types, params_row);
 
     if (!function->getReturnType()->equals(*removeLowCardinality(storage_type)))
     {
@@ -125,32 +124,14 @@ static std::pair<DataTypePtr, DataTypeDomainPtr> create(const ASTPtr & arguments
                         ErrorCodes::BAD_ARGUMENTS);
     }
 
-    return std::make_pair(storage_type, std::move(domain));
-}
-
-static const DataTypeDomainSimpleAggregateFunction * findSimpleAggregateFunction(const IDataTypeDomain * domain)
-{
-    if (domain == nullptr)
-        return nullptr;
-
-    if (auto simple_aggr = dynamic_cast<const DataTypeDomainSimpleAggregateFunction *>(domain))
-        return simple_aggr;
-
-    if (domain->getDomain() != nullptr)
-        return findSimpleAggregateFunction(domain->getDomain());
+    DataTypeCustomNamePtr custom_name = std::make_unique<DataTypeCustomSimpleAggregateFunction>(function, argument_types, params_row);
 
-    return nullptr;
+    return std::make_pair(storage_type, std::make_unique<DataTypeCustomDesc>(std::move(custom_name), nullptr));
 }
 
-const DataTypeDomainSimpleAggregateFunction * findSimpleAggregateFunction(DataTypePtr dataType)
-{
-    return findSimpleAggregateFunction(dataType->getDomain());
-}
-
-
 void registerDataTypeDomainSimpleAggregateFunction(DataTypeFactory & factory)
 {
-    factory.registerDataTypeDomain("SimpleAggregateFunction", create);
+    factory.registerDataTypeCustom("SimpleAggregateFunction", create);
 }
 
 }
diff --git a/dbms/src/DataTypes/DataTypeDomainSimpleAggregateFunction.h b/dbms/src/DataTypes/DataTypeCustomSimpleAggregateFunction.h
similarity index 67%
rename from dbms/src/DataTypes/DataTypeDomainSimpleAggregateFunction.h
rename to dbms/src/DataTypes/DataTypeCustomSimpleAggregateFunction.h
index 98989eeac1184363613b31b455da9f8a0b33a055..3e82b546903ff2a0b27f9a4191e451e07220e8ec 100644
--- a/dbms/src/DataTypes/DataTypeDomainSimpleAggregateFunction.h
+++ b/dbms/src/DataTypes/DataTypeCustomSimpleAggregateFunction.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <DataTypes/IDataTypeDomain.h>
+#include <DataTypes/DataTypeCustom.h>
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <Common/FieldVisitors.h>
 
@@ -21,10 +21,10 @@ namespace DB
  * SimpleAggregateFunction(anyLast, LowCardinality(Nullable(String)))
  * SimpleAggregateFunction(anyLast, IPv4)
  *
- * Technically, a standard IDataType is instanciated and a DataTypeDomainSimpleAggregateFunction is added as domain.
+ * Technically, a standard IDataType is instanciated and customized with IDataTypeCustomName and DataTypeCustomDesc.
   */
 
-class DataTypeDomainSimpleAggregateFunction : public IDataTypeDomain
+class DataTypeCustomSimpleAggregateFunction : public IDataTypeCustomName
 {
 private:
     const AggregateFunctionPtr function;
@@ -32,14 +32,11 @@ private:
     const Array parameters;
 
 public:
-    DataTypeDomainSimpleAggregateFunction(const AggregateFunctionPtr & function_, const DataTypes & argument_types_, const Array & parameters_)
+    DataTypeCustomSimpleAggregateFunction(const AggregateFunctionPtr & function_, const DataTypes & argument_types_, const Array & parameters_)
             : function(function_), argument_types(argument_types_), parameters(parameters_) {}
 
     const AggregateFunctionPtr getFunction() const { return function; }
-    String doGetName() const override;
+    String getName() const override;
 };
 
-/// recursively follow data type domain to find a DataTypeDomainSimpleAggregateFunction
-const DataTypeDomainSimpleAggregateFunction * findSimpleAggregateFunction(DataTypePtr dataType);
-
 }
diff --git a/dbms/src/DataTypes/DataTypeDomainWithSimpleSerialization.cpp b/dbms/src/DataTypes/DataTypeCustomSimpleTextSerialization.cpp
similarity index 73%
rename from dbms/src/DataTypes/DataTypeDomainWithSimpleSerialization.cpp
rename to dbms/src/DataTypes/DataTypeCustomSimpleTextSerialization.cpp
index 12b1837be1f0969f4ee23f8346d2aa7437758838..44ce27a6e88fd86e2fd00f96d86c686b963a9f4c 100644
--- a/dbms/src/DataTypes/DataTypeDomainWithSimpleSerialization.cpp
+++ b/dbms/src/DataTypes/DataTypeCustomSimpleTextSerialization.cpp
@@ -1,4 +1,4 @@
-#include <DataTypes/DataTypeDomainWithSimpleSerialization.h>
+#include <DataTypes/DataTypeCustomSimpleTextSerialization.h>
 
 #include <IO/ReadBufferFromString.h>
 #include <IO/ReadHelpers.h>
@@ -9,7 +9,7 @@ namespace
 {
 using namespace DB;
 
-static String serializeToString(const DataTypeDomainWithSimpleSerialization & domain, const IColumn & column, size_t row_num, const FormatSettings & settings)
+static String serializeToString(const DataTypeCustomSimpleTextSerialization & domain, const IColumn & column, size_t row_num, const FormatSettings & settings)
 {
     WriteBufferFromOwnString buffer;
     domain.serializeText(column, row_num, buffer, settings);
@@ -17,7 +17,7 @@ static String serializeToString(const DataTypeDomainWithSimpleSerialization & do
     return buffer.str();
 }
 
-static void deserializeFromString(const DataTypeDomainWithSimpleSerialization & domain, IColumn & column, const String & s, const FormatSettings & settings)
+static void deserializeFromString(const DataTypeCustomSimpleTextSerialization & domain, IColumn & column, const String & s, const FormatSettings & settings)
 {
     ReadBufferFromString istr(s);
     domain.deserializeText(column, istr, settings);
@@ -28,59 +28,59 @@ static void deserializeFromString(const DataTypeDomainWithSimpleSerialization &
 namespace DB
 {
 
-DataTypeDomainWithSimpleSerialization::~DataTypeDomainWithSimpleSerialization()
+DataTypeCustomSimpleTextSerialization::~DataTypeCustomSimpleTextSerialization()
 {
 }
 
-void DataTypeDomainWithSimpleSerialization::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
+void DataTypeCustomSimpleTextSerialization::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
     writeEscapedString(serializeToString(*this, column, row_num, settings), ostr);
 }
 
-void DataTypeDomainWithSimpleSerialization::deserializeTextEscaped(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
+void DataTypeCustomSimpleTextSerialization::deserializeTextEscaped(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
 {
     String str;
     readEscapedString(str, istr);
     deserializeFromString(*this, column, str, settings);
 }
 
-void DataTypeDomainWithSimpleSerialization::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
+void DataTypeCustomSimpleTextSerialization::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
     writeQuotedString(serializeToString(*this, column, row_num, settings), ostr);
 }
 
-void DataTypeDomainWithSimpleSerialization::deserializeTextQuoted(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
+void DataTypeCustomSimpleTextSerialization::deserializeTextQuoted(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
 {
     String str;
     readQuotedString(str, istr);
     deserializeFromString(*this, column, str, settings);
 }
 
-void DataTypeDomainWithSimpleSerialization::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
+void DataTypeCustomSimpleTextSerialization::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
     writeCSVString(serializeToString(*this, column, row_num, settings), ostr);
 }
 
-void DataTypeDomainWithSimpleSerialization::deserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
+void DataTypeCustomSimpleTextSerialization::deserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
 {
     String str;
     readCSVString(str, istr, settings.csv);
     deserializeFromString(*this, column, str, settings);
 }
 
-void DataTypeDomainWithSimpleSerialization::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
+void DataTypeCustomSimpleTextSerialization::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
     writeJSONString(serializeToString(*this, column, row_num, settings), ostr, settings);
 }
 
-void DataTypeDomainWithSimpleSerialization::deserializeTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
+void DataTypeCustomSimpleTextSerialization::deserializeTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
 {
     String str;
     readJSONString(str, istr);
     deserializeFromString(*this, column, str, settings);
 }
 
-void DataTypeDomainWithSimpleSerialization::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
+void DataTypeCustomSimpleTextSerialization::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
     writeXMLString(serializeToString(*this, column, row_num, settings), ostr);
 }
diff --git a/dbms/src/DataTypes/DataTypeDomainWithSimpleSerialization.h b/dbms/src/DataTypes/DataTypeCustomSimpleTextSerialization.h
similarity index 89%
rename from dbms/src/DataTypes/DataTypeDomainWithSimpleSerialization.h
rename to dbms/src/DataTypes/DataTypeCustomSimpleTextSerialization.h
index 3ccb409163669cb217807b7de00d555fd0f52a0a..fb9be86d95f47a27b9642f8d109d7a7e809bcc3b 100644
--- a/dbms/src/DataTypes/DataTypeDomainWithSimpleSerialization.h
+++ b/dbms/src/DataTypes/DataTypeCustomSimpleTextSerialization.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <DataTypes/IDataTypeDomain.h>
+#include <DataTypes/DataTypeCustom.h>
 
 namespace DB
 {
@@ -10,12 +10,12 @@ class WriteBuffer;
 struct FormatSettings;
 class IColumn;
 
-/** Simple DataTypeDomain that uses serializeText/deserializeText
+/** Simple IDataTypeCustomTextSerialization that uses serializeText/deserializeText
  * for all serialization and deserialization. */
-class DataTypeDomainWithSimpleSerialization : public IDataTypeDomainCustomSerialization
+class DataTypeCustomSimpleTextSerialization : public IDataTypeCustomTextSerialization
 {
 public:
-    virtual ~DataTypeDomainWithSimpleSerialization() override;
+    virtual ~DataTypeCustomSimpleTextSerialization() override;
 
     // Methods that subclasses must override in order to get full serialization/deserialization support.
     virtual void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override = 0;
diff --git a/dbms/src/DataTypes/DataTypeFactory.cpp b/dbms/src/DataTypes/DataTypeFactory.cpp
index a405075e884a5a5f008a06fc91268556c7ce0d38..8c4c899516a9b7defbd6dc762e866aed528b1079 100644
--- a/dbms/src/DataTypes/DataTypeFactory.cpp
+++ b/dbms/src/DataTypes/DataTypeFactory.cpp
@@ -1,5 +1,5 @@
 #include <DataTypes/DataTypeFactory.h>
-#include <DataTypes/IDataTypeDomain.h>
+#include <DataTypes/DataTypeCustom.h>
 #include <Parsers/parseQuery.h>
 #include <Parsers/ParserCreateQuery.h>
 #include <Parsers/ASTFunction.h>
@@ -115,20 +115,20 @@ void DataTypeFactory::registerSimpleDataType(const String & name, SimpleCreator
     }, case_sensitiveness);
 }
 
-void DataTypeFactory::registerDataTypeDomain(const String & family_name, CreatorWithDomain creator, CaseSensitiveness case_sensitiveness)
+void DataTypeFactory::registerDataTypeCustom(const String & family_name, CreatorWithCustom creator, CaseSensitiveness case_sensitiveness)
 {
     registerDataType(family_name, [creator](const ASTPtr & ast)
     {
         auto res = creator(ast);
-        res.first->appendDomain(std::move(res.second));
+        res.first->setCustomization(std::move(res.second));
 
         return res.first;
     }, case_sensitiveness);
 }
 
-void DataTypeFactory::registerDataTypeDomain(const String & name, SimpleCreatorWithDomain creator, CaseSensitiveness case_sensitiveness)
+void DataTypeFactory::registerSimpleDataTypeCustom(const String &name, SimpleCreatorWithCustom creator, CaseSensitiveness case_sensitiveness)
 {
-    registerDataTypeDomain(name, [creator](const ASTPtr & /*ast*/)
+    registerDataTypeCustom(name, [creator](const ASTPtr & /*ast*/)
     {
         return creator();
     }, case_sensitiveness);
diff --git a/dbms/src/DataTypes/DataTypeFactory.h b/dbms/src/DataTypes/DataTypeFactory.h
index e4a82b342d120023988ee54872fd2fd75264518e..a6c714c1a0e95e3326d171b3861faefddb60518b 100644
--- a/dbms/src/DataTypes/DataTypeFactory.h
+++ b/dbms/src/DataTypes/DataTypeFactory.h
@@ -17,9 +17,6 @@ namespace DB
 class IDataType;
 using DataTypePtr = std::shared_ptr<const IDataType>;
 
-class IDataTypeDomain;
-using DataTypeDomainPtr = std::unique_ptr<const IDataTypeDomain>;
-
 
 /** Creates a data type by name of data type family and parameters.
   */
@@ -28,8 +25,8 @@ class DataTypeFactory final : public ext::singleton<DataTypeFactory>, public IFa
 private:
     using SimpleCreator = std::function<DataTypePtr()>;
     using DataTypesDictionary = std::unordered_map<String, Creator>;
-    using CreatorWithDomain = std::function<std::pair<DataTypePtr,DataTypeDomainPtr>(const ASTPtr & parameters)>;
-    using SimpleCreatorWithDomain = std::function<std::pair<DataTypePtr,DataTypeDomainPtr>()>;
+    using CreatorWithCustom = std::function<std::pair<DataTypePtr,DataTypeCustomDescPtr>(const ASTPtr & parameters)>;
+    using SimpleCreatorWithCustom = std::function<std::pair<DataTypePtr,DataTypeCustomDescPtr>()>;
 
 public:
     DataTypePtr get(const String & full_name) const;
@@ -42,11 +39,11 @@ public:
     /// Register a simple data type, that have no parameters.
     void registerSimpleDataType(const String & name, SimpleCreator creator, CaseSensitiveness case_sensitiveness = CaseSensitive);
 
-    /// Register a type family with a dynamic domain
-    void registerDataTypeDomain(const String & family_name, CreatorWithDomain creator, CaseSensitiveness case_sensitiveness = CaseSensitive);
+    /// Register a customized type family
+    void registerDataTypeCustom(const String & family_name, CreatorWithCustom creator, CaseSensitiveness case_sensitiveness = CaseSensitive);
 
-    /// Register a simple data type domain
-    void registerDataTypeDomain(const String & name, SimpleCreatorWithDomain creator, CaseSensitiveness case_sensitiveness = CaseSensitive);
+    /// Register a simple customized data type
+    void registerSimpleDataTypeCustom(const String & name, SimpleCreatorWithCustom creator, CaseSensitiveness case_sensitiveness = CaseSensitive);
 
 private:
     const Creator& findCreatorByName(const String & family_name) const;
diff --git a/dbms/src/DataTypes/IDataType.cpp b/dbms/src/DataTypes/IDataType.cpp
index 0270f1d792393f86ee17816ae7cf7958bf0efc7f..09c080f56cc3e30127a657685da31572c5abc3cb 100644
--- a/dbms/src/DataTypes/IDataType.cpp
+++ b/dbms/src/DataTypes/IDataType.cpp
@@ -9,7 +9,7 @@
 #include <IO/WriteHelpers.h>
 
 #include <DataTypes/IDataType.h>
-#include <DataTypes/IDataTypeDomain.h>
+#include <DataTypes/DataTypeCustom.h>
 #include <DataTypes/NestedUtils.h>
 
 
@@ -23,8 +23,7 @@ namespace ErrorCodes
     extern const int DATA_TYPE_CANNOT_BE_PROMOTED;
 }
 
-IDataType::IDataType()
-    : domain(nullptr)
+IDataType::IDataType() : custom_name(nullptr), custom_text_serialization(nullptr)
 {
 }
 
@@ -34,9 +33,9 @@ IDataType::~IDataType()
 
 String IDataType::getName() const
 {
-    if (domain)
+    if (custom_name)
     {
-        return domain->getName();
+        return custom_name->getName();
     }
     else
     {
@@ -142,9 +141,9 @@ void IDataType::insertDefaultInto(IColumn & column) const
 
 void IDataType::serializeAsTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
+    if (custom_text_serialization)
     {
-        ser_domain->serializeTextEscaped(column, row_num, ostr, settings);
+        custom_text_serialization->serializeTextEscaped(column, row_num, ostr, settings);
     }
     else
     {
@@ -154,9 +153,9 @@ void IDataType::serializeAsTextEscaped(const IColumn & column, size_t row_num, W
 
 void IDataType::deserializeAsTextEscaped(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
+    if (custom_text_serialization)
     {
-        ser_domain->deserializeTextEscaped(column, istr, settings);
+        custom_text_serialization->deserializeTextEscaped(column, istr, settings);
     }
     else
     {
@@ -166,9 +165,9 @@ void IDataType::deserializeAsTextEscaped(IColumn & column, ReadBuffer & istr, co
 
 void IDataType::serializeAsTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
+    if (custom_text_serialization)
     {
-        ser_domain->serializeTextQuoted(column, row_num, ostr, settings);
+        custom_text_serialization->serializeTextQuoted(column, row_num, ostr, settings);
     }
     else
     {
@@ -178,9 +177,9 @@ void IDataType::serializeAsTextQuoted(const IColumn & column, size_t row_num, Wr
 
 void IDataType::deserializeAsTextQuoted(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
+    if (custom_text_serialization)
     {
-        ser_domain->deserializeTextQuoted(column, istr, settings);
+        custom_text_serialization->deserializeTextQuoted(column, istr, settings);
     }
     else
     {
@@ -190,9 +189,9 @@ void IDataType::deserializeAsTextQuoted(IColumn & column, ReadBuffer & istr, con
 
 void IDataType::serializeAsTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
-  {
-      ser_domain->serializeTextCSV(column, row_num, ostr, settings);
+    if (custom_text_serialization)
+    {
+        custom_text_serialization->serializeTextCSV(column, row_num, ostr, settings);
     }
     else
     {
@@ -202,9 +201,9 @@ void IDataType::serializeAsTextCSV(const IColumn & column, size_t row_num, Write
 
 void IDataType::deserializeAsTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
+    if (custom_text_serialization)
     {
-        ser_domain->deserializeTextCSV(column, istr, settings);
+        custom_text_serialization->deserializeTextCSV(column, istr, settings);
     }
     else
     {
@@ -214,9 +213,9 @@ void IDataType::deserializeAsTextCSV(IColumn & column, ReadBuffer & istr, const
 
 void IDataType::serializeAsText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
+    if (custom_text_serialization)
     {
-        ser_domain->serializeText(column, row_num, ostr, settings);
+        custom_text_serialization->serializeText(column, row_num, ostr, settings);
     }
     else
     {
@@ -226,9 +225,9 @@ void IDataType::serializeAsText(const IColumn & column, size_t row_num, WriteBuf
 
 void IDataType::serializeAsTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
+    if (custom_text_serialization)
     {
-        ser_domain->serializeTextJSON(column, row_num, ostr, settings);
+        custom_text_serialization->serializeTextJSON(column, row_num, ostr, settings);
     }
     else
     {
@@ -238,9 +237,9 @@ void IDataType::serializeAsTextJSON(const IColumn & column, size_t row_num, Writ
 
 void IDataType::deserializeAsTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
+    if (custom_text_serialization)
     {
-        ser_domain->deserializeTextJSON(column, istr, settings);
+        custom_text_serialization->deserializeTextJSON(column, istr, settings);
     }
     else
     {
@@ -250,9 +249,9 @@ void IDataType::deserializeAsTextJSON(IColumn & column, ReadBuffer & istr, const
 
 void IDataType::serializeAsTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    if (auto ser_domain = dynamic_cast<const IDataTypeDomainCustomSerialization *>(domain.get()))
+    if (custom_text_serialization)
     {
-        ser_domain->serializeTextXML(column, row_num, ostr, settings);
+        custom_text_serialization->serializeTextXML(column, row_num, ostr, settings);
     }
     else
     {
@@ -260,12 +259,14 @@ void IDataType::serializeAsTextXML(const IColumn & column, size_t row_num, Write
     }
 }
 
-void IDataType::appendDomain(DataTypeDomainPtr new_domain) const
+void IDataType::setCustomization(DataTypeCustomDescPtr custom_desc_) const
 {
-    if (domain == nullptr)
-        domain = std::move(new_domain);
-    else
-        domain->appendDomain(std::move(new_domain));
+    /// replace only if not null
+    if (custom_desc_->name)
+        custom_name = std::move(custom_desc_->name);
+
+    if (custom_desc_->text_serialization)
+        custom_text_serialization = std::move(custom_desc_->text_serialization);
 }
 
 }
diff --git a/dbms/src/DataTypes/IDataType.h b/dbms/src/DataTypes/IDataType.h
index a95402bf20ad7e8f8c8331c8b4b4cd4f0eee9b21..6446f8ada43e413527f61dd7abcb2c7388a7ffe0 100644
--- a/dbms/src/DataTypes/IDataType.h
+++ b/dbms/src/DataTypes/IDataType.h
@@ -4,6 +4,7 @@
 #include <Common/COWPtr.h>
 #include <boost/noncopyable.hpp>
 #include <Core/Field.h>
+#include <DataTypes/DataTypeCustom.h>
 
 
 namespace DB
@@ -12,9 +13,6 @@ namespace DB
 class ReadBuffer;
 class WriteBuffer;
 
-class IDataTypeDomain;
-using DataTypeDomainPtr = std::unique_ptr<const IDataTypeDomain>;
-
 class IDataType;
 struct FormatSettings;
 
@@ -461,19 +459,19 @@ public:
 
 private:
     friend class DataTypeFactory;
-    /** Sets domain on existing DataType or append it to existing domain, can be considered as second phase
-      * of construction explicitly done by DataTypeFactory.
+    /** Customize this DataType
       */
-    void appendDomain(DataTypeDomainPtr new_domain) const;
+    void setCustomization(DataTypeCustomDescPtr custom_desc_) const;
 
 private:
-    /** This is mutable to allow setting domain on `const IDataType` post construction,
-     * simplifying creation of domains for all types, without them even knowing
-     * of domain existence.
+    /** This is mutable to allow setting custom name and serialization on `const IDataType` post construction.
      */
-    mutable DataTypeDomainPtr domain;
+    mutable DataTypeCustomNamePtr custom_name;
+    mutable DataTypeCustomTextSerializationPtr custom_text_serialization;
+
 public:
-    const IDataTypeDomain * getDomain() const { return domain.get(); }
+    const IDataTypeCustomName * getCustomName() const { return custom_name.get(); }
+    const IDataTypeCustomTextSerialization * getCustomTextSerialization() const { return custom_text_serialization.get(); }
 };