diff --git a/.travis.yml b/.travis.yml
index 6dab6f478ab..7af12080396 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,7 +13,7 @@ matrix:
 #        apt:
 #          sources:
 #            - ubuntu-toolchain-r-test
-#          packages: [ g++-7,            libicu-dev, libreadline-dev, libmysqlclient-dev, unixodbc-dev, libltdl-dev, libssl-dev, libboost-dev, zlib1g-dev, libdouble-conversion-dev, libzookeeper-mt-dev, libsparsehash-dev, librdkafka-dev, libcapnp-dev, libsparsehash-dev, libgoogle-perftools-dev, bash, expect, python, python-lxml, python-termcolor, curl, perl, sudo ]
+#          packages: [ g++-7,            libicu-dev, libreadline-dev, libmysqlclient-dev, unixodbc-dev, libltdl-dev, libssl-dev, libboost-dev, zlib1g-dev, libdouble-conversion-dev, libzookeeper-mt-dev, libsparsehash-dev, librdkafka-dev, libcapnp-dev, libsparsehash-dev, libgoogle-perftools-dev, bash, expect, python, python-lxml, python-termcolor, curl, perl, sudo, openssl ]
 #
 #      env:
 #        - MATRIX_EVAL="export CC=gcc-7 && export CXX=g++-7"
@@ -36,7 +36,7 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-trusty-5.0
-          packages: [ g++-7, clang-5.0, lld-5.0, libicu-dev, libreadline-dev, libmysqlclient-dev, unixodbc-dev, libltdl-dev, libssl-dev, libboost-dev, zlib1g-dev, libdouble-conversion-dev, libzookeeper-mt-dev, libsparsehash-dev, librdkafka-dev, libcapnp-dev, libsparsehash-dev, libgoogle-perftools-dev, bash, expect, python, python-lxml, python-termcolor, curl, perl, sudo ]
+          packages: [ g++-7, clang-5.0, lld-5.0, libicu-dev, libreadline-dev, libmysqlclient-dev, unixodbc-dev, libltdl-dev, libssl-dev, libboost-dev, zlib1g-dev, libdouble-conversion-dev, libzookeeper-mt-dev, libsparsehash-dev, librdkafka-dev, libcapnp-dev, libsparsehash-dev, libgoogle-perftools-dev, bash, expect, python, python-lxml, python-termcolor, curl, perl, sudo, openssl]
 
       env:
         - MATRIX_EVAL="export CC=clang-5.0 && export CXX=clang++-5.0"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 847d0506427..fdb7f5303b1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,31 @@
-# ClickHouse 1.1.54356 Release Candidate, 2018-03-06
+# ClickHouse 1.1.54370 Release Candidate, 2018-03-16
+
+## New features:
+
+* Added the `system.macros` table and auto updating of macros when the config file is changed.
+* Added the `SYSTEM RELOAD CONFIG` query.
+* Added the `maxIntersections(left_col, right_col)` aggregate function, which returns the maximum number of simultaneously intersecting intervals `[left; right]`. The `maxIntersectionsPosition(left, right)` function returns the beginning of the "maximum" interval. ([Michael Furmur](https://github.com/yandex/ClickHouse/pull/2012)).
+
+## Improvements:
+
+* When inserting data in a `Replicated` table, fewer requests are made to `ZooKeeper` (and most of the user-level errors have disappeared from the `ZooKeeper` log).
+* Added the ability to create aliases for sets. Example: `WITH (1, 2, 3) AS set SELECT number IN set FROM system.numbers LIMIT 10`.
+
+## Bug fixes:
+
+* Fixed the `Illegal PREWHERE` error when reading from `Merge` tables over `Distributed` tables.
+* Added fixes that allow you to run `clickhouse-server` in IPv4-only Docker containers.
+* Fixed a race condition when reading from system `system.parts_columns` tables.
+* Removed double buffering during a synchronous insert to a `Distributed` table, which could have caused the connection to timeout.
+* Fixed a bug that caused excessively long waits for an unavailable replica before beginning a `SELECT` query.
+* Fixed incorrect dates in the `system.parts` table.
+* Fixed a bug that made it impossible to insert data in a `Replicated` table if `chroot` was non-empty in the configuration of the `ZooKeeper` cluster.
+* Fixed the vertical merging algorithm for an empty `ORDER BY` table.
+* Restored the ability to use dictionaries in queries to remote tables, even if these dictionaries are not present on the requestor server. This functionality was lost in release 1.1.54362.
+* Restored the behavior for queries like `SELECT * FROM remote('server2', default.table) WHERE col IN (SELECT col2 FROM default.table)` when the right side argument of the `IN` should use a remote `default.table` instead of a local one. This behavior was broken in version 1.1.54358.
+* Removed extraneous error-level logging of `Not found column ... in block`.
+
+# ClickHouse release 1.1.54356, 2018-03-06
 
 ## New features:
 
diff --git a/CHANGELOG_RU.md b/CHANGELOG_RU.md
index 2dfbdccb7a4..4e0b481e718 100644
--- a/CHANGELOG_RU.md
+++ b/CHANGELOG_RU.md
@@ -1,4 +1,32 @@
-# ClickHouse 1.1.54362 Release Candidate, 2018-03-11
+# ClickHouse 1.1.54370 Release Candidate, 2018-03-16
+
+## Новые возможности:
+
+* Добавлена системная таблица `system.macros` и автоматическое обновление макросов при изменении конфигурационного файла.
+* Добавлен запрос `SYSTEM RELOAD CONFIG`.
+* Добавлена агрегатная функция `maxIntersections(left_col, right_col)`, возвращающая максимальное количество одновременно пересекающихся интервалов `[left; right]`. Функция `maxIntersectionsPosition(left, right)` возвращает начало такого "максимального" интервала. ([Michael Furmur](https://github.com/yandex/ClickHouse/pull/2012)).
+
+## Улучшения:
+
+* При вставке данных в `Replicated`-таблицу делается меньше обращений к `ZooKeeper` (также из лога `ZooKeeper` исчезло большинство user-level ошибок).
+* Добавлена возможность создавать алиасы для множеств. Пример: `WITH (1, 2, 3) AS set SELECT number IN set FROM system.numbers LIMIT 10`.
+
+## Исправление ошибок:
+
+* Исправлена ошибка `Illegal PREWHERE` при чтении из Merge-таблицы над `Distributed`-таблицами.
+* Добавлены исправления, позволяющие запускать clickhouse-server в IPv4-only docker-контейнерах.
+* Исправлен race condition при чтении из системной таблицы `system.parts_columns`
+* Убрана двойная буферизация при синхронной вставке в `Distributed`-таблицу, которая могла приводить к timeout-ам соединений.
+* Исправлена ошибка, вызывающая чрезмерно долгое ожидание недоступной реплики перед началом выполнения `SELECT`.
+* Исправлено некорректное отображение дат в таблице `system.parts`.
+* Исправлена ошибка, приводящая к невозможности вставить данные в `Replicated`-таблицу, если в конфигурации кластера `ZooKeeper` задан непустой `chroot`.
+* Исправлен алгоритм вертикального мержа при пустом ключе `ORDER BY` таблицы.
+* Возвращена возможность использовать словари в запросах к удаленным таблицам, даже если этих словарей нет на сервере-инициаторе. Данная функциональность была потеряна в версии 1.1.54362.
+* Восстановлено поведение, при котором в запросах типа `SELECT * FROM remote('server2', default.table) WHERE col IN (SELECT col2 FROM default.table)` в правой части `IN` должна использоваться удаленная таблица `default.table`, а не локальная. данное поведение было нарушено в версии 1.1.54358.
+* Устранено ненужное Error-level логирование `Not found column ... in block`.
+
+
+# Релиз ClickHouse 1.1.54362, 2018-03-11
 
 ## Новые возможности:
 
diff --git a/cmake/find_poco.cmake b/cmake/find_poco.cmake
index 9051d63ae47..315e27b798f 100644
--- a/cmake/find_poco.cmake
+++ b/cmake/find_poco.cmake
@@ -49,7 +49,8 @@ elseif (NOT MISSING_INTERNAL_POCO_LIBRARY)
         set (Poco_DataODBC_INCLUDE_DIRS "${ClickHouse_SOURCE_DIR}/contrib/poco/Data/ODBC/include/")
     endif ()
 
-    if (OPENSSL_FOUND)
+    # TODO! fix internal ssl
+    if (OPENSSL_FOUND AND NOT USE_INTERNAL_SSL_LIBRARY)
         set (Poco_NetSSL_FOUND 1)
         set (Poco_NetSSL_LIBRARY PocoNetSSL)
         set (Poco_Crypto_LIBRARY PocoCrypto)
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index e74e9a5b7db..9015f7e7d36 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -100,13 +100,17 @@ if (USE_INTERNAL_RDKAFKA_LIBRARY)
     mark_as_advanced (ZLIB_INCLUDE_DIR)
 
     if (USE_INTERNAL_SSL_LIBRARY)
-        add_library(bundled-ssl ALIAS ${OPENSSL_SSL_LIBRARY})
-        set (WITH_BUNDLED_SSL 1)
+        if (MAKE_STATIC_LIBRARIES)
+            add_library(bundled-ssl ALIAS ${OPENSSL_SSL_LIBRARY})
+            set (WITH_BUNDLED_SSL 1 CACHE INTERNAL "")
+        else ()
+            set (WITH_SSL 0 CACHE INTERNAL "")
+        endif ()
     endif ()
 
     add_subdirectory (librdkafka)
 
-    if (USE_INTERNAL_SSL_LIBRARY)
+    if (USE_INTERNAL_SSL_LIBRARY AND MAKE_STATIC_LIBRARIES)
         target_include_directories(rdkafka PRIVATE BEFORE ${OPENSSL_INCLUDE_DIR})
     endif ()
     target_include_directories(rdkafka PRIVATE BEFORE ${ZLIB_INCLUDE_DIR})
@@ -127,16 +131,18 @@ endif ()
 
 
 if (USE_INTERNAL_POCO_LIBRARY)
-    set (ALLOW_DUPLICATE_CUSTOM_TARGETS 1)
     set (save_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
     set (save_CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
     set (_save ${ENABLE_TESTS})
     set (ENABLE_TESTS 0)
     set (CMAKE_DISABLE_FIND_PACKAGE_ZLIB 1)
     if (USE_INTERNAL_SSL_LIBRARY)
-        set (DISABLE_INTERNAL_OPENSSL 1)
-        set (ENABLE_NETSSL 0) # TODO!
-        set (ENABLE_CRYPTO 0) # TODO!
+        set (DISABLE_INTERNAL_OPENSSL 1 CACHE INTERNAL "")
+        set (ENABLE_NETSSL 0 CACHE INTERNAL "") # TODO!
+        set (ENABLE_CRYPTO 0 CACHE INTERNAL "") # TODO!
+    endif ()
+    if (MSVC)
+        set (ENABLE_DATA_ODBC 0 CACHE INTERNAL "") # TODO (build fail)
     endif ()
     add_subdirectory (poco)
     unset (CMAKE_DISABLE_FIND_PACKAGE_ZLIB)
diff --git a/contrib/boost b/contrib/boost
index eb5943711e8..5121cc9d037 160000
--- a/contrib/boost
+++ b/contrib/boost
@@ -1 +1 @@
-Subproject commit eb5943711e88d1008583e6ae3720a5489313d02e
+Subproject commit 5121cc9d0375c7b81b24b6087a51684e6cd62ded
diff --git a/contrib/libcityhash/src/config.h b/contrib/libcityhash/src/config.h
index c873732dd87..61c75fca818 100644
--- a/contrib/libcityhash/src/config.h
+++ b/contrib/libcityhash/src/config.h
@@ -5,7 +5,11 @@
 /* #undef AC_APPLE_UNIVERSAL_BUILD */
 
 /* Define to 1 if the compiler supports __builtin_expect. */
+#if _MSC_VER
+#define HAVE_BUILTIN_EXPECT 0
+#else
 #define HAVE_BUILTIN_EXPECT 1
+#endif
 
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #define HAVE_DLFCN_H 1
diff --git a/contrib/libfarmhash/CMakeLists.txt b/contrib/libfarmhash/CMakeLists.txt
index 7781028094d..16471da3f2f 100644
--- a/contrib/libfarmhash/CMakeLists.txt
+++ b/contrib/libfarmhash/CMakeLists.txt
@@ -2,4 +2,8 @@ add_library(farmhash
 	farmhash.cc
 	farmhash.h)
 
+if (MSVC)
+    target_compile_definitions (farmhash PRIVATE FARMHASH_NO_BUILTIN_EXPECT=1)
+endif ()
+
 target_include_directories (farmhash PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/contrib/libtcmalloc/src/config.h b/contrib/libtcmalloc/src/config.h
index 3338309073d..9f9a7a259e5 100644
--- a/contrib/libtcmalloc/src/config.h
+++ b/contrib/libtcmalloc/src/config.h
@@ -13,7 +13,11 @@
 /* #undef ENABLE_SIZED_DELETE */
 
 /* Define to 1 if compiler supports __builtin_expect */
+#if _MSC_VER
+#define HAVE_BUILTIN_EXPECT 0
+#else
 #define HAVE_BUILTIN_EXPECT 1
+#endif
 
 /* Define to 1 if compiler supports __builtin_stack_pointer */
 /* #undef HAVE_BUILTIN_STACK_POINTER */
diff --git a/dbms/CMakeLists.txt b/dbms/CMakeLists.txt
index 965b9b2bfe1..d740ce5a45c 100644
--- a/dbms/CMakeLists.txt
+++ b/dbms/CMakeLists.txt
@@ -131,7 +131,6 @@ target_link_libraries (clickhouse_common_io
     ${LINK_LIBRARIES_ONLY_ON_X86_64}
     ${LZ4_LIBRARY}
     ${ZSTD_LIBRARY}
-    ${ZOOKEEPER_LIBRARY}
     ${DOUBLE_CONVERSION_LIBRARIES}
     ${Poco_Net_LIBRARY}
     ${Poco_Data_LIBRARY}
@@ -158,10 +157,6 @@ if (NOT USE_INTERNAL_RE2_LIBRARY)
     target_include_directories (dbms BEFORE PRIVATE ${RE2_INCLUDE_DIR})
 endif ()
 
-if (NOT USE_INTERNAL_ZOOKEEPER_LIBRARY)
-    target_include_directories (clickhouse_common_io BEFORE PUBLIC ${ZOOKEEPER_INCLUDE_DIR})
-endif ()
-
 if (NOT USE_INTERNAL_BOOST_LIBRARY)
     target_include_directories (clickhouse_common_io BEFORE PUBLIC ${Boost_INCLUDE_DIRS})
 endif ()
diff --git a/dbms/cmake/version.cmake b/dbms/cmake/version.cmake
index b82d8afccbb..990c638bf46 100644
--- a/dbms/cmake/version.cmake
+++ b/dbms/cmake/version.cmake
@@ -1,6 +1,6 @@
 # This strings autochanged from release_lib.sh:
-set(VERSION_DESCRIBE v1.1.54363-testing)
-set(VERSION_REVISION 54363)
+set(VERSION_DESCRIBE v1.1.54371-testing)
+set(VERSION_REVISION 54371)
 # end of autochange
 
 set (VERSION_MAJOR 1)
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp b/dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp
index 5fc341b3095..eca854a031b 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp
@@ -70,7 +70,10 @@ AggregateFunctionPtr AggregateFunctionFactory::get(
         return combinator->transformAggregateFunction(nested_function, argument_types, parameters);
     }
 
-    return getImpl(name, argument_types, parameters, recursion_level);
+    auto res = getImpl(name, argument_types, parameters, recursion_level);
+    if (!res)
+        throw Exception("Logical error: AggregateFunctionFactory returned nullptr", ErrorCodes::LOGICAL_ERROR);
+    return res;
 }
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionMaxIntersections.cpp b/dbms/src/AggregateFunctions/AggregateFunctionMaxIntersections.cpp
new file mode 100644
index 00000000000..9f63d399fe7
--- /dev/null
+++ b/dbms/src/AggregateFunctions/AggregateFunctionMaxIntersections.cpp
@@ -0,0 +1,37 @@
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/AggregateFunctionMaxIntersections.h>
+#include <AggregateFunctions/FactoryHelpers.h>
+#include <AggregateFunctions/Helpers.h>
+
+
+namespace DB
+{
+
+namespace
+{
+    AggregateFunctionPtr createAggregateFunctionMaxIntersections(
+        AggregateFunctionIntersectionsKind kind,
+        const std::string & name, const DataTypes & argument_types, const Array & parameters)
+    {
+        assertBinary(name, argument_types);
+        assertNoParameters(name, parameters);
+
+        AggregateFunctionPtr res(createWithNumericType<AggregateFunctionIntersectionsMax>(*argument_types[0], kind, argument_types));
+        if (!res)
+            throw Exception("Illegal types " + argument_types[0]->getName() + " and " + argument_types[1]->getName()
+                + " of argument for aggregate function " + name, ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+        return res;
+    }
+}
+
+void registerAggregateFunctionsMaxIntersections(AggregateFunctionFactory & factory)
+{
+    factory.registerFunction("maxIntersections", [](const std::string & name, const DataTypes & argument_types, const Array & parameters)
+        { return createAggregateFunctionMaxIntersections(AggregateFunctionIntersectionsKind::Count, name, argument_types, parameters); });
+
+    factory.registerFunction("maxIntersectionsPosition", [](const std::string & name, const DataTypes & argument_types, const Array & parameters)
+        { return createAggregateFunctionMaxIntersections(AggregateFunctionIntersectionsKind::Position, name, argument_types, parameters); });
+}
+
+}
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionMaxIntersections.h b/dbms/src/AggregateFunctions/AggregateFunctionMaxIntersections.h
new file mode 100644
index 00000000000..11ec01e52e4
--- /dev/null
+++ b/dbms/src/AggregateFunctions/AggregateFunctionMaxIntersections.h
@@ -0,0 +1,170 @@
+#pragma once
+
+#include <common/logger_useful.h>
+
+#include <DataTypes/DataTypesNumber.h>
+#include <Columns/ColumnsNumber.h>
+
+#include <IO/ReadHelpers.h>
+#include <IO/WriteHelpers.h>
+
+#include <Common/ArenaAllocator.h>
+#include <Common/NaNUtils.h>
+
+#include <AggregateFunctions/IAggregateFunction.h>
+
+#define AGGREGATE_FUNCTION_MAX_INTERSECTIONS_MAX_ARRAY_SIZE 0xFFFFFF
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+    extern const int TOO_LARGE_ARRAY_SIZE;
+}
+
+
+/** maxIntersections: returns maximum count of the intersected intervals defined by start_column and end_column values,
+  * maxIntersectionsPosition: returns leftmost position of maximum intersection of intervals.
+  */
+
+/// Similar to GroupArrayNumericData.
+template <typename T>
+struct MaxIntersectionsData
+{
+    /// Left or right end of the interval and signed weight; with positive sign for begin of interval and negative sign for end of interval.
+    using Value = std::pair<T, Int64>;
+
+    // Switch to ordinary Allocator after 4096 bytes to avoid fragmentation and trash in Arena
+    using Allocator = MixedArenaAllocator<4096>;
+    using Array = PODArray<Value, 32, Allocator>;
+
+    Array value;
+};
+
+enum class AggregateFunctionIntersectionsKind
+{
+    Count,
+    Position
+};
+
+template <typename PointType>
+class AggregateFunctionIntersectionsMax final
+    : public IAggregateFunctionDataHelper<MaxIntersectionsData<PointType>, AggregateFunctionIntersectionsMax<PointType>>
+{
+private:
+    AggregateFunctionIntersectionsKind kind;
+
+public:
+    AggregateFunctionIntersectionsMax(AggregateFunctionIntersectionsKind kind_, const DataTypes & arguments)
+        : kind(kind_)
+    {
+        if (!arguments[0]->isNumber())
+            throw Exception{getName() + ": first argument must be represented by integer", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+
+        if (!arguments[1]->isNumber())
+            throw Exception{getName() + ": second argument must be represented by integer", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+
+        if (!arguments[0]->equals(*arguments[1]))
+            throw Exception{getName() + ": arguments must have the same type", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+    }
+
+    String getName() const override
+    {
+        return kind == AggregateFunctionIntersectionsKind::Count
+            ? "maxIntersections"
+            : "maxIntersectionsPosition";
+    }
+
+    DataTypePtr getReturnType() const override
+    {
+        if (kind == AggregateFunctionIntersectionsKind::Count)
+            return std::make_shared<DataTypeUInt64>();
+        else
+            return std::make_shared<DataTypeNumber<PointType>>();
+    }
+
+    void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena) const override
+    {
+        PointType left = static_cast<const ColumnVector<PointType> &>(*columns[0]).getData()[row_num];
+        PointType right = static_cast<const ColumnVector<PointType> &>(*columns[1]).getData()[row_num];
+
+        if (!isNaN(left))
+            this->data(place).value.push_back(std::make_pair(left, Int64(1)), arena);
+
+        if (!isNaN(right))
+            this->data(place).value.push_back(std::make_pair(right, Int64(-1)), arena);
+    }
+
+    void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const override
+    {
+        auto & cur_elems = this->data(place);
+        auto & rhs_elems = this->data(rhs);
+
+        cur_elems.value.insert(rhs_elems.value.begin(), rhs_elems.value.end(), arena);
+    }
+
+    void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
+    {
+        const auto & value = this->data(place).value;
+        size_t size = value.size();
+        writeVarUInt(size, buf);
+        buf.write(reinterpret_cast<const char *>(&value[0]), size * sizeof(value[0]));
+    }
+
+    void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena * arena) const override
+    {
+        size_t size = 0;
+        readVarUInt(size, buf);
+
+        if (unlikely(size > AGGREGATE_FUNCTION_MAX_INTERSECTIONS_MAX_ARRAY_SIZE))
+            throw Exception("Too large array size", ErrorCodes::TOO_LARGE_ARRAY_SIZE);
+
+        auto & value = this->data(place).value;
+
+        value.resize(size, arena);
+        buf.read(reinterpret_cast<char *>(&value[0]), size * sizeof(value[0]));
+    }
+
+    void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
+    {
+        Int64 current_intersections = 0;
+        Int64 max_intersections = 0;
+        PointType position_of_max_intersections = 0;
+
+        /// const_cast because we will sort the array
+        auto & array = const_cast<typename MaxIntersectionsData<PointType>::Array &>(this->data(place).value);
+
+        std::sort(array.begin(), array.end(), [](const auto & a, const auto & b) { return a.first < b.first; });
+
+        for (const auto & point_weight : array)
+        {
+            current_intersections += point_weight.second;
+            if (current_intersections > max_intersections)
+            {
+                max_intersections = current_intersections;
+                position_of_max_intersections = point_weight.first;
+            }
+        }
+
+        if (kind == AggregateFunctionIntersectionsKind::Count)
+        {
+            auto & result_column = static_cast<ColumnUInt64 &>(to).getData();
+            result_column.push_back(max_intersections);
+        }
+        else
+        {
+            auto & result_column = static_cast<ColumnVector<PointType> &>(to).getData();
+            result_column.push_back(position_of_max_intersections);
+        }
+    }
+
+    const char * getHeaderFilePath() const override
+    {
+        return __FILE__;
+    }
+};
+
+}
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionSumMap.cpp b/dbms/src/AggregateFunctions/AggregateFunctionSumMap.cpp
index 9aedeaabe24..7cad7c35092 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionSumMap.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionSumMap.cpp
@@ -37,7 +37,11 @@ AggregateFunctionPtr createAggregateFunctionSumMap(const std::string & name, con
         values_types.push_back(array_type->getNestedType());
     }
 
-    return AggregateFunctionPtr(createWithNumericType<AggregateFunctionSumMap>(*keys_type, keys_type, std::move(values_types)));
+    AggregateFunctionPtr res(createWithNumericType<AggregateFunctionSumMap>(*keys_type, keys_type, std::move(values_types)));
+    if (!res)
+        throw Exception("Illegal type of argument for aggregate function " + name, ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+    return res;
 }
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionUniq.cpp b/dbms/src/AggregateFunctions/AggregateFunctionUniq.cpp
index e64247796af..d6831ce1c43 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionUniq.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionUniq.cpp
@@ -33,6 +33,10 @@ AggregateFunctionPtr createAggregateFunctionUniq(const std::string & name, const
 {
     assertNoParameters(name, params);
 
+    if (argument_types.empty())
+        throw Exception("Incorrect number of arguments for aggregate function " + name,
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
     if (argument_types.size() == 1)
     {
         const IDataType & argument_type = *argument_types[0];
@@ -51,23 +55,18 @@ AggregateFunctionPtr createAggregateFunctionUniq(const std::string & name, const
             return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic, true>>(argument_types);
         else if (typeid_cast<const DataTypeUUID *>(&argument_type))
             return std::make_shared<AggregateFunctionUniq<DataTypeUUID::FieldType, Data>>();
-        else
-            throw Exception("Illegal type " + argument_types[0]->getName() + " of argument for aggregate function " + name,
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
-    else if (argument_types.size() > 1)
+    else
     {
         /// If there are several arguments, then no tuples allowed among them.
         for (const auto & type : argument_types)
             if (typeid_cast<const DataTypeTuple *>(type.get()))
                 throw Exception("Tuple argument of function " + name + " must be the only argument",
                     ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-
-        return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic, false>>(argument_types);
     }
-    else
-        throw Exception("Incorrect number of arguments for aggregate function " + name,
-            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
+    /// "Variadic" method also works as a fallback generic case for single argument.
+    return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic, false>>(argument_types);
 }
 
 template <template <typename> class Data, typename DataForVariadic>
@@ -75,6 +74,10 @@ AggregateFunctionPtr createAggregateFunctionUniq(const std::string & name, const
 {
     assertNoParameters(name, params);
 
+    if (argument_types.empty())
+        throw Exception("Incorrect number of arguments for aggregate function " + name,
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
     if (argument_types.size() == 1)
     {
         const IDataType & argument_type = *argument_types[0];
@@ -93,23 +96,18 @@ AggregateFunctionPtr createAggregateFunctionUniq(const std::string & name, const
             return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic, true>>(argument_types);
         else if (typeid_cast<const DataTypeUUID *>(&argument_type))
             return std::make_shared<AggregateFunctionUniq<DataTypeUUID::FieldType, Data<DataTypeUUID::FieldType>>>();
-        else
-            throw Exception("Illegal type " + argument_types[0]->getName() + " of argument for aggregate function " + name,
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
-    else if (argument_types.size() > 1)
+    else
     {
         /// If there are several arguments, then no tuples allowed among them.
         for (const auto & type : argument_types)
             if (typeid_cast<const DataTypeTuple *>(type.get()))
                 throw Exception("Tuple argument of function " + name + " must be the only argument",
                     ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-
-        return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic, false>>(argument_types);
     }
-    else
-        throw Exception("Incorrect number of arguments for aggregate function " + name,
-            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
+    /// "Variadic" method also works as a fallback generic case for single argument.
+    return std::make_shared<AggregateFunctionUniqVariadic<DataForVariadic, false>>(argument_types);
 }
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionUniq.h b/dbms/src/AggregateFunctions/AggregateFunctionUniq.h
index f5949a6d468..288d1fc5c3c 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionUniq.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionUniq.h
@@ -122,8 +122,8 @@ struct AggregateFunctionUniqExactData<String>
     static String getName() { return "uniqExact"; }
 };
 
-template <typename T, HyperLogLogMode mode>
-struct BaseUniqCombinedData
+template <typename T>
+struct AggregateFunctionUniqCombinedData
 {
     using Key = UInt32;
     using Set = CombinedCardinalityEstimator<
@@ -135,14 +135,15 @@ struct BaseUniqCombinedData
         TrivialHash,
         UInt32,
         HyperLogLogBiasEstimator<UniqCombinedBiasData>,
-        mode
-    >;
+        HyperLogLogMode::FullFeatured>;
 
     Set set;
+
+    static String getName() { return "uniqCombined"; }
 };
 
-template <HyperLogLogMode mode>
-struct BaseUniqCombinedData<String, mode>
+template <>
+struct AggregateFunctionUniqCombinedData<String>
 {
     using Key = UInt64;
     using Set = CombinedCardinalityEstimator<
@@ -154,44 +155,14 @@ struct BaseUniqCombinedData<String, mode>
         TrivialHash,
         UInt64,
         HyperLogLogBiasEstimator<UniqCombinedBiasData>,
-        mode
-    >;
+        HyperLogLogMode::FullFeatured>;
 
     Set set;
-};
 
-/// Aggregate functions uniqCombinedRaw, uniqCombinedLinearCounting, and uniqCombinedBiasCorrected
-///  are intended for development of new versions of the uniqCombined function.
-/// Users should only use uniqCombined.
-
-template <typename T>
-struct AggregateFunctionUniqCombinedRawData
-    : public BaseUniqCombinedData<T, HyperLogLogMode::Raw>
-{
-    static String getName() { return "uniqCombinedRaw"; }
-};
-
-template <typename T>
-struct AggregateFunctionUniqCombinedLinearCountingData
-    : public BaseUniqCombinedData<T, HyperLogLogMode::LinearCounting>
-{
-    static String getName() { return "uniqCombinedLinearCounting"; }
-};
-
-template <typename T>
-struct AggregateFunctionUniqCombinedBiasCorrectedData
-    : public BaseUniqCombinedData<T, HyperLogLogMode::BiasCorrected>
-{
-    static String getName() { return "uniqCombinedBiasCorrected"; }
-};
-
-template <typename T>
-struct AggregateFunctionUniqCombinedData
-    : public BaseUniqCombinedData<T, HyperLogLogMode::FullFeatured>
-{
     static String getName() { return "uniqCombined"; }
 };
 
+
 namespace detail
 {
 
@@ -288,10 +259,7 @@ struct OneAdder
                 data.set.insert(CityHash_v1_0_2::CityHash64(value.data, value.size));
             }
         }
-        else if constexpr (std::is_same_v<Data, AggregateFunctionUniqCombinedRawData<T>>
-            || std::is_same_v<Data, AggregateFunctionUniqCombinedLinearCountingData<T>>
-            || std::is_same_v<Data, AggregateFunctionUniqCombinedBiasCorrectedData<T>>
-            || std::is_same_v<Data, AggregateFunctionUniqCombinedData<T>>)
+        else if constexpr (std::is_same_v<Data, AggregateFunctionUniqCombinedData<T>>)
         {
             if constexpr (!std::is_same_v<T, String>)
             {
@@ -371,7 +339,7 @@ public:
 
 /** For multiple arguments. To compute, hashes them.
   * You can pass multiple arguments as is; You can also pass one argument - a tuple.
-  * But (for the possibility of effective implementation), you can not pass several arguments, among which there are tuples.
+  * But (for the possibility of efficient implementation), you can not pass several arguments, among which there are tuples.
   */
 template <typename Data, bool argument_is_tuple>
 class AggregateFunctionUniqVariadic final : public IAggregateFunctionDataHelper<Data, AggregateFunctionUniqVariadic<Data, argument_is_tuple>>
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp b/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp
index 1a3934af88f..d1d9b70f5f9 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp
@@ -42,6 +42,10 @@ AggregateFunctionPtr createAggregateFunctionUniqUpTo(const std::string & name, c
         threshold = threshold_param;
     }
 
+    if (argument_types.empty())
+        throw Exception("Incorrect number of arguments for aggregate function " + name,
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
     if (argument_types.size() == 1)
     {
         const IDataType & argument_type = *argument_types[0];
@@ -60,22 +64,18 @@ AggregateFunctionPtr createAggregateFunctionUniqUpTo(const std::string & name, c
             return std::make_shared<AggregateFunctionUniqUpToVariadic<true>>(argument_types, threshold);
         else if (typeid_cast<const DataTypeUUID *>(&argument_type))
             return std::make_shared<AggregateFunctionUniqUpTo<DataTypeUUID::FieldType>>(threshold);
-        else
-            throw Exception("Illegal type " + argument_types[0]->getName() + " of argument for aggregate function " + name, ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
-    else if (argument_types.size() > 1)
+    else
     {
         /// If there are several arguments, then no tuples allowed among them.
         for (const auto & type : argument_types)
             if (typeid_cast<const DataTypeTuple *>(type.get()))
                 throw Exception("Tuple argument of function " + name + " must be the only argument",
                     ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-
-        return std::make_shared<AggregateFunctionUniqUpToVariadic<false>>(argument_types, threshold);
     }
-    else
-        throw Exception("Incorrect number of arguments for aggregate function " + name,
-            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
+    /// "Variadic" method also works as a fallback generic case for single argument.
+    return std::make_shared<AggregateFunctionUniqUpToVariadic<false>>(argument_types, threshold);
 }
 
 }
diff --git a/dbms/src/AggregateFunctions/QuantileExact.h b/dbms/src/AggregateFunctions/QuantileExact.h
index c134ad1653d..568ad8d0950 100644
--- a/dbms/src/AggregateFunctions/QuantileExact.h
+++ b/dbms/src/AggregateFunctions/QuantileExact.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Common/PODArray.h>
+#include <Common/NaNUtils.h>
 #include <IO/WriteBuffer.h>
 #include <IO/ReadBuffer.h>
 #include <Core/Types.h>
@@ -32,7 +33,9 @@ struct QuantileExact
 
     void add(const Value & x)
     {
-        array.push_back(x);
+        /// We must skip NaNs as they are not compatible with comparison sorting.
+        if (!isNaN(x))
+            array.push_back(x);
     }
 
     template <typename Weight>
diff --git a/dbms/src/AggregateFunctions/QuantileExactWeighted.h b/dbms/src/AggregateFunctions/QuantileExactWeighted.h
index f524426392a..76e65f07dac 100644
--- a/dbms/src/AggregateFunctions/QuantileExactWeighted.h
+++ b/dbms/src/AggregateFunctions/QuantileExactWeighted.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Common/HashTable/HashMap.h>
+#include <Common/NaNUtils.h>
 
 
 namespace DB
@@ -33,12 +34,15 @@ struct QuantileExactWeighted
 
     void add(const Value & x)
     {
-        ++map[x];
+        /// We must skip NaNs as they are not compatible with comparison sorting.
+        if (!isNaN(x))
+            ++map[x];
     }
 
     void add(const Value & x, const Weight & weight)
     {
-        map[x] += weight;
+        if (!isNaN(x))
+            map[x] += weight;
     }
 
     void merge(const QuantileExactWeighted & rhs)
diff --git a/dbms/src/AggregateFunctions/QuantilesCommon.h b/dbms/src/AggregateFunctions/QuantilesCommon.h
index 53802834379..1f70fde74dd 100644
--- a/dbms/src/AggregateFunctions/QuantilesCommon.h
+++ b/dbms/src/AggregateFunctions/QuantilesCommon.h
@@ -4,6 +4,7 @@
 
 #include <Core/Field.h>
 #include <Common/FieldVisitors.h>
+#include <Common/NaNUtils.h>
 
 
 namespace DB
@@ -12,6 +13,7 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int PARAMETER_OUT_OF_BOUND;
 }
 
 
@@ -55,6 +57,10 @@ struct QuantileLevels
         for (size_t i = 0; i < size; ++i)
         {
             levels[i] = applyVisitor(FieldVisitorConvertToNumber<Float64>(), params[i]);
+
+            if (isNaN(levels[i]) || levels[i] < 0 || levels[i] > 1)
+                throw Exception("Quantile level is out of range [0..1]", ErrorCodes::PARAMETER_OUT_OF_BOUND);
+
             permutation[i] = i;
         }
 
diff --git a/dbms/src/AggregateFunctions/ReservoirSampler.h b/dbms/src/AggregateFunctions/ReservoirSampler.h
index 77d9f7285b7..ad5bf10f48f 100644
--- a/dbms/src/AggregateFunctions/ReservoirSampler.h
+++ b/dbms/src/AggregateFunctions/ReservoirSampler.h
@@ -9,6 +9,7 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <Common/PODArray.h>
+#include <Common/NaNUtils.h>
 #include <Poco/Exception.h>
 #include <pcg_random.hpp>
 
@@ -67,6 +68,9 @@ public:
 
     void insert(const T & v)
     {
+        if (isNaN(v))
+            return;
+
         sorted = false;
         ++total_values;
         if (samples.size() < sample_count)
diff --git a/dbms/src/AggregateFunctions/ReservoirSamplerDeterministic.h b/dbms/src/AggregateFunctions/ReservoirSamplerDeterministic.h
index bff3fcb78ea..44760d8e5a5 100644
--- a/dbms/src/AggregateFunctions/ReservoirSamplerDeterministic.h
+++ b/dbms/src/AggregateFunctions/ReservoirSamplerDeterministic.h
@@ -11,6 +11,7 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <Common/PODArray.h>
+#include <Common/NaNUtils.h>
 #include <Poco/Exception.h>
 
 
@@ -66,6 +67,9 @@ public:
 
     void insert(const T & v, const UInt64 determinator)
     {
+        if (isNaN(v))
+            return;
+
         const UInt32 hash = intHash64(determinator);
         if (!good(hash))
             return;
diff --git a/dbms/src/AggregateFunctions/registerAggregateFunctions.cpp b/dbms/src/AggregateFunctions/registerAggregateFunctions.cpp
index 59bda8bb8b5..644543e4f2e 100644
--- a/dbms/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/dbms/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -23,6 +23,7 @@ void registerAggregateFunctionsUniq(AggregateFunctionFactory &);
 void registerAggregateFunctionUniqUpTo(AggregateFunctionFactory &);
 void registerAggregateFunctionTopK(AggregateFunctionFactory &);
 void registerAggregateFunctionsBitwise(AggregateFunctionFactory &);
+void registerAggregateFunctionsMaxIntersections(AggregateFunctionFactory &);
 
 void registerAggregateFunctionCombinatorIf(AggregateFunctionCombinatorFactory &);
 void registerAggregateFunctionCombinatorArray(AggregateFunctionCombinatorFactory &);
@@ -53,6 +54,7 @@ void registerAggregateFunctions()
         registerAggregateFunctionUniqUpTo(factory);
         registerAggregateFunctionTopK(factory);
         registerAggregateFunctionsBitwise(factory);
+        registerAggregateFunctionsMaxIntersections(factory);
     }
 
     {
diff --git a/dbms/src/Analyzers/AnalyzeColumns.cpp b/dbms/src/Analyzers/AnalyzeColumns.cpp
index 6367699ea8e..73760c4ff01 100644
--- a/dbms/src/Analyzers/AnalyzeColumns.cpp
+++ b/dbms/src/Analyzers/AnalyzeColumns.cpp
@@ -173,7 +173,7 @@ ASTPtr createASTIdentifierForColumnInTable(const String & column, const CollectT
 void createASTsForAllColumnsInTable(const CollectTables::TableInfo & table, ASTs & res)
 {
     if (table.storage)
-        for (const auto & name : table.storage->getColumnNamesList())
+        for (const auto & name : table.storage->getColumns().getNamesOfPhysical())
             res.emplace_back(createASTIdentifierForColumnInTable(name, table));
     else
         for (size_t i = 0, size = table.structure_of_subquery.columns(); i < size; ++i)
@@ -315,7 +315,7 @@ void processIdentifier(
     }
     else if (table->storage)
     {
-        info.data_type = table->storage->getDataTypeByName(column_name);
+        info.data_type = table->storage->getColumn(column_name).type;
     }
     else
         throw Exception("Logical error: no storage and no structure of subquery is specified for table", ErrorCodes::LOGICAL_ERROR);
diff --git a/dbms/src/Analyzers/ExecuteTableFunctions.cpp b/dbms/src/Analyzers/ExecuteTableFunctions.cpp
index fab9c6c3a3f..d79fa1481f0 100644
--- a/dbms/src/Analyzers/ExecuteTableFunctions.cpp
+++ b/dbms/src/Analyzers/ExecuteTableFunctions.cpp
@@ -72,7 +72,7 @@ void ExecuteTableFunctions::dump(WriteBuffer & out) const
     {
         writeString(table.second->getName(), out);
         writeCString("\n\n", out);
-        writeString(table.second->getColumnsList().toString(), out);
+        writeString(table.second->getColumns().getAllPhysical().toString(), out);
         writeCString("\n", out);
     }
 }
diff --git a/dbms/src/Client/Connection.cpp b/dbms/src/Client/Connection.cpp
index 3c6c8d75d0e..0960ac8e77d 100644
--- a/dbms/src/Client/Connection.cpp
+++ b/dbms/src/Client/Connection.cpp
@@ -148,6 +148,10 @@ void Connection::receiveHello()
         {
             readStringBinary(server_timezone, *in);
         }
+        if (server_revision >= DBMS_MIN_REVISION_WITH_SERVER_DISPLAY_NAME)
+        {
+            readStringBinary(server_display_name, *in);
+        }
     }
     else if (packet_type == Protocol::Server::Exception)
         receiveException()->rethrow();
@@ -203,6 +207,14 @@ const String & Connection::getServerTimezone()
     return server_timezone;
 }
 
+const String & Connection::getServerDisplayName()
+{
+    if (!connected)
+        connect();
+
+    return server_display_name;
+}
+
 void Connection::forceConnected()
 {
     if (!connected)
diff --git a/dbms/src/Client/Connection.h b/dbms/src/Client/Connection.h
index c9b401c91ee..cac188f12c8 100644
--- a/dbms/src/Client/Connection.h
+++ b/dbms/src/Client/Connection.h
@@ -134,6 +134,7 @@ public:
     void getServerVersion(String & name, UInt64 & version_major, UInt64 & version_minor, UInt64 & revision);
 
     const String & getServerTimezone();
+    const String & getServerDisplayName();
 
     /// For log and exception messages.
     const String & getDescription() const;
@@ -213,6 +214,7 @@ private:
     UInt64 server_version_minor = 0;
     UInt64 server_revision = 0;
     String server_timezone;
+    String server_display_name;
 
     std::unique_ptr<Poco::Net::StreamSocket> socket;
     std::shared_ptr<ReadBuffer> in;
diff --git a/dbms/src/Common/AIO.h b/dbms/src/Common/AIO.h
index e7287c85d3d..254a7f02ecb 100644
--- a/dbms/src/Common/AIO.h
+++ b/dbms/src/Common/AIO.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#if !(defined(__FreeBSD__) || defined(__APPLE__))
+#if !(defined(__FreeBSD__) || defined(__APPLE__) || defined(_MSC_VER))
 
 #include <Common/Exception.h>
 #include <common/logger_useful.h>
diff --git a/dbms/src/Common/Config/ConfigReloader.cpp b/dbms/src/Common/Config/ConfigReloader.cpp
index 54cbf507055..e06fca6316a 100644
--- a/dbms/src/Common/Config/ConfigReloader.cpp
+++ b/dbms/src/Common/Config/ConfigReloader.cpp
@@ -73,6 +73,8 @@ void ConfigReloader::run()
 
 void ConfigReloader::reloadIfNewer(bool force, bool throw_on_error, bool fallback_to_preprocessed)
 {
+    std::lock_guard<std::mutex> lock(reload_mutex);
+
     FilesChangesTracker new_files = getNewFileList();
     if (force || new_files.isDifferOrNewerThan(files))
     {
diff --git a/dbms/src/Common/Config/ConfigReloader.h b/dbms/src/Common/Config/ConfigReloader.h
index 94b2d3c629c..e50b9e34837 100644
--- a/dbms/src/Common/Config/ConfigReloader.h
+++ b/dbms/src/Common/Config/ConfigReloader.h
@@ -42,6 +42,9 @@ public:
     /// Call this method to run the backround thread.
     void start();
 
+    /// Reload immediately. For SYSTEM RELOAD CONFIG query.
+    void reload() { reloadIfNewer(/* force */ true, /* throw_on_error */ true, /* fallback_to_preprocessed */ false); }
+
 private:
     void run();
 
@@ -74,6 +77,9 @@ private:
 
     std::atomic<bool> quit{false};
     std::thread thread;
+
+    /// Locked inside reloadIfNewer.
+    std::mutex reload_mutex;
 };
 
 }
diff --git a/dbms/src/Common/ErrorCodes.cpp b/dbms/src/Common/ErrorCodes.cpp
index 6c07a5e3422..46b4c3394e5 100644
--- a/dbms/src/Common/ErrorCodes.cpp
+++ b/dbms/src/Common/ErrorCodes.cpp
@@ -372,6 +372,7 @@ namespace ErrorCodes
     extern const int QUERY_WAS_CANCELLED = 394;
     extern const int FUNCTION_THROW_IF_VALUE_IS_NON_ZERO = 395;
     extern const int TOO_MANY_ROWS_OR_BYTES = 396;
+    extern const int QUERY_IS_NOT_SUPPORTED_IN_MATERIALIZED_VIEW = 397;
 
 
     extern const int KEEPER_EXCEPTION = 999;
diff --git a/dbms/src/Common/ExternalTable.h b/dbms/src/Common/ExternalTable.h
index 624604d30a1..7cc8069108b 100644
--- a/dbms/src/Common/ExternalTable.h
+++ b/dbms/src/Common/ExternalTable.h
@@ -198,7 +198,7 @@ public:
 
         /// Create table
         NamesAndTypesList columns = sample_block.getNamesAndTypesList();
-        StoragePtr storage = StorageMemory::create(data.second, columns, NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{});
+        StoragePtr storage = StorageMemory::create(data.second, ColumnsDescription{columns});
         storage->startup();
         context.addExternalTable(data.second, storage);
         BlockOutputStreamPtr output = storage->write(ASTPtr(), context.getSettingsRef());
diff --git a/dbms/src/Common/Macros.cpp b/dbms/src/Common/Macros.cpp
index cb3d43cd21c..56b766eda68 100644
--- a/dbms/src/Common/Macros.cpp
+++ b/dbms/src/Common/Macros.cpp
@@ -1,6 +1,8 @@
+#include <Poco/Util/AbstractConfiguration.h>
 #include <Common/Macros.h>
 #include <Common/Exception.h>
 
+
 namespace DB
 {
 
diff --git a/dbms/src/Common/Macros.h b/dbms/src/Common/Macros.h
index 0ebf52afd02..d2602cf62e7 100644
--- a/dbms/src/Common/Macros.h
+++ b/dbms/src/Common/Macros.h
@@ -1,10 +1,18 @@
 #pragma once
 
 #include <Core/Types.h>
-#include <Poco/Util/AbstractConfiguration.h>
 #include <map>
 
 
+namespace Poco
+{
+    namespace Util
+    {
+        class AbstractConfiguration;
+    }
+}
+
+
 namespace DB
 {
 
@@ -21,10 +29,12 @@ public:
       */
     String expand(const String & s, size_t level = 0) const;
 
-private:
     using MacroMap = std::map<String, String>;
+    const MacroMap getMacroMap() const { return macros; }
 
+private:
     MacroMap macros;
 };
 
+
 }
diff --git a/dbms/src/Common/ShellCommand.cpp b/dbms/src/Common/ShellCommand.cpp
index b3765874ac4..c9e625810ca 100644
--- a/dbms/src/Common/ShellCommand.cpp
+++ b/dbms/src/Common/ShellCommand.cpp
@@ -1,13 +1,12 @@
 #include <sys/types.h>
 #include <sys/wait.h>
-#include <unistd.h>
 #include <fcntl.h>
 #include <dlfcn.h>
-
 #include <Common/Exception.h>
 #include <Common/ShellCommand.h>
 #include <IO/WriteBufferFromVector.h>
 #include <IO/WriteHelpers.h>
+#include <port/unistd.h>
 
 
 namespace DB
diff --git a/dbms/src/Common/ZooKeeper/CMakeLists.txt b/dbms/src/Common/ZooKeeper/CMakeLists.txt
index 9bd72b6fa54..6a02d5733b1 100644
--- a/dbms/src/Common/ZooKeeper/CMakeLists.txt
+++ b/dbms/src/Common/ZooKeeper/CMakeLists.txt
@@ -5,7 +5,11 @@ add_headers_and_sources(clickhouse_common_zookeeper .)
 
 add_library(clickhouse_common_zookeeper ${SPLIT_SHARED} ${clickhouse_common_zookeeper_headers} ${clickhouse_common_zookeeper_sources})
 
-target_link_libraries (clickhouse_common_zookeeper clickhouse_common_io)
+if (NOT USE_INTERNAL_ZOOKEEPER_LIBRARY)
+    target_include_directories (clickhouse_common_zookeeper BEFORE PUBLIC ${ZOOKEEPER_INCLUDE_DIR})
+endif ()
+
+target_link_libraries (clickhouse_common_zookeeper clickhouse_common_io ${ZOOKEEPER_LIBRARY})
 
 if (ENABLE_TESTS)
     add_subdirectory (tests)
diff --git a/dbms/src/Common/ZooKeeper/KeeperException.h b/dbms/src/Common/ZooKeeper/KeeperException.h
index b6a46930b97..37b0a04b564 100644
--- a/dbms/src/Common/ZooKeeper/KeeperException.h
+++ b/dbms/src/Common/ZooKeeper/KeeperException.h
@@ -102,4 +102,19 @@ private:
 
 };
 
+
+class KeeperMultiException : public KeeperException
+{
+public:
+    MultiTransactionInfo info;
+
+    /// If it is user error throws KeeperMultiException else throws ordinary KeeperException
+    /// If it is ZOK does nothing
+    static void check(const MultiTransactionInfo & info);
+    static void check(int code, const Ops & ops, const OpResultsPtr & op_results);
+
+protected:
+    KeeperMultiException(const MultiTransactionInfo & info, size_t failed_op_index);
+};
+
 };
diff --git a/dbms/src/Common/ZooKeeper/Types.h b/dbms/src/Common/ZooKeeper/Types.h
index 4097627f395..1938081bb2e 100644
--- a/dbms/src/Common/ZooKeeper/Types.h
+++ b/dbms/src/Common/ZooKeeper/Types.h
@@ -12,6 +12,8 @@ namespace zkutil
 
 using ACLPtr = const ACL_vector *;
 using Stat = ::Stat;
+class ZooKeeper;
+
 
 struct Op
 {
@@ -19,7 +21,7 @@ public:
     Op() : data(new zoo_op_t) {}
     virtual ~Op() {}
 
-    virtual std::unique_ptr<Op> clone() const = 0;
+    virtual std::shared_ptr<Op> clone() const = 0;
 
     virtual std::string getPath() const = 0;
 
@@ -33,6 +35,9 @@ public:
     struct Check;
 };
 
+using OpPtr = std::shared_ptr<Op>;
+
+
 struct Op::Remove : public Op
 {
     Remove(const std::string & path_, int32_t version_) :
@@ -41,9 +46,9 @@ struct Op::Remove : public Op
         zoo_delete_op_init(data.get(), path.c_str(), version);
     }
 
-    std::unique_ptr<Op> clone() const override
+    OpPtr clone() const override
     {
-        return std::unique_ptr<zkutil::Op>(new Remove(path, version));
+        return std::make_shared<Remove>(path, version);
     }
 
     std::string getPath() const override { return path; }
@@ -59,9 +64,9 @@ struct Op::Create : public Op
 {
     Create(const std::string & path_pattern_, const std::string & value_, ACLPtr acl_, int32_t flags_);
 
-    std::unique_ptr<Op> clone() const override
+    OpPtr clone() const override
     {
-        return std::unique_ptr<zkutil::Op>(new Create(path_pattern, value, acl, flags));
+        return std::make_shared<Create>(path_pattern, value, acl, flags);
     }
 
     std::string getPathCreated() { return created_path.data(); }
@@ -91,9 +96,9 @@ struct Op::SetData : public Op
         zoo_set_op_init(data.get(), path.c_str(), value.c_str(), value.size(), version, &stat);
     }
 
-    std::unique_ptr<Op> clone() const override
+    OpPtr clone() const override
     {
-        return std::unique_ptr<zkutil::Op>(new SetData(path, value, version));
+        return std::make_shared<SetData>(path, value, version);
     }
 
     std::string getPath() const override { return path; }
@@ -122,9 +127,9 @@ struct Op::Check : public Op
         zoo_check_op_init(data.get(), path.c_str(), version);
     }
 
-    std::unique_ptr<Op> clone() const override
+    OpPtr clone() const override
     {
-        return std::unique_ptr<zkutil::Op>(new Check(path, version));
+        return std::make_shared<Check>(path, version);
     }
 
     std::string getPath() const override { return path; }
@@ -136,18 +141,46 @@ private:
     int32_t version;
 };
 
-struct OpResult : public zoo_op_result_t
-{
-    /// Pointers in this class point to fields of class Op.
-    /// Op instances have the same (or longer lifetime), therefore destructor is not required.
-};
-
-using OpPtr = std::unique_ptr<Op>;
 using Ops = std::vector<OpPtr>;
+
+
+/// C++ version of zoo_op_result_t
+struct OpResult
+{
+    int err;
+    std::string value;
+    std::unique_ptr<Stat> stat;
+
+    /// ZooKeeper is required for correct chroot path prefixes handling
+    explicit OpResult(const zoo_op_result_t & op_result, const ZooKeeper * zookeeper = nullptr);
+};
 using OpResults = std::vector<OpResult>;
 using OpResultsPtr = std::shared_ptr<OpResults>;
 using Strings = std::vector<std::string>;
 
+
+/// Simple structure to handle transaction execution results
+struct MultiTransactionInfo
+{
+    Ops ops;
+    int32_t code = ZOK;
+    OpResultsPtr op_results;
+
+    MultiTransactionInfo() = default;
+
+    MultiTransactionInfo(int32_t code_, const Ops & ops_, const OpResultsPtr & op_results_)
+        : ops(ops_), code(code_), op_results(op_results_) {}
+
+    bool empty() const
+    {
+        return ops.empty();
+    }
+
+    /// Returns failed op if zkutil::isUserError(code) is true
+    const Op & getFailedOp() const;
+};
+
+
 namespace CreateMode
 {
     extern const int Persistent;
diff --git a/dbms/src/Common/ZooKeeper/ZooKeeper.cpp b/dbms/src/Common/ZooKeeper/ZooKeeper.cpp
index 85bbe140d39..746ed4c609a 100644
--- a/dbms/src/Common/ZooKeeper/ZooKeeper.cpp
+++ b/dbms/src/Common/ZooKeeper/ZooKeeper.cpp
@@ -82,19 +82,21 @@ void ZooKeeper::processCallback(zhandle_t *, int type, int state, const char * p
 }
 
 void ZooKeeper::init(const std::string & hosts_, const std::string & identity_,
-                     int32_t session_timeout_ms_, bool check_root_exists)
+                     int32_t session_timeout_ms_, const std::string & chroot_)
 {
     log = &Logger::get("ZooKeeper");
     zoo_set_debug_level(ZOO_LOG_LEVEL_ERROR);
     hosts = hosts_;
     identity = identity_;
     session_timeout_ms = session_timeout_ms_;
+    chroot = chroot_;
 
-    impl = zookeeper_init(hosts.c_str(), nullptr, session_timeout_ms, nullptr, nullptr, 0);
+    std::string hosts_for_lib = hosts + chroot;
+    impl = zookeeper_init(hosts_for_lib.c_str(), nullptr, session_timeout_ms, nullptr, nullptr, 0);
     ProfileEvents::increment(ProfileEvents::ZooKeeperInit);
 
     if (!impl)
-        throw KeeperException("Fail to initialize zookeeper. Hosts are " + hosts);
+        throw KeeperException("Fail to initialize zookeeper. Hosts are " + hosts_for_lib);
 
     if (!identity.empty())
     {
@@ -107,16 +109,16 @@ void ZooKeeper::init(const std::string & hosts_, const std::string & identity_,
     else
         default_acl = &ZOO_OPEN_ACL_UNSAFE;
 
-    LOG_TRACE(log, "initialized, hosts: " << hosts);
+    LOG_TRACE(log, "initialized, hosts: " << hosts << (chroot.empty() ? "" : ", chroot: " + chroot));
 
-    if (check_root_exists && !exists("/"))
-        throw KeeperException("Zookeeper root doesn't exist. You should create root node before start.");
+    if (!chroot.empty() && !exists("/"))
+        throw KeeperException("Zookeeper root doesn't exist. You should create root node " + chroot + " before start.");
 }
 
 ZooKeeper::ZooKeeper(const std::string & hosts, const std::string & identity,
-                     int32_t session_timeout_ms, bool check_root_exists)
+                     int32_t session_timeout_ms, const std::string & chroot)
 {
-    init(hosts, identity, session_timeout_ms, check_root_exists);
+    init(hosts, identity, session_timeout_ms, chroot);
 }
 
 struct ZooKeeperArgs
@@ -127,10 +129,8 @@ struct ZooKeeperArgs
         config.keys(config_name, keys);
 
         std::vector<std::string> hosts_strings;
-        std::string root;
 
         session_timeout_ms = DEFAULT_SESSION_TIMEOUT;
-        has_chroot = false;
         for (const auto & key : keys)
         {
             if (startsWith(key, "node"))
@@ -150,7 +150,7 @@ struct ZooKeeperArgs
             }
             else if (key == "root")
             {
-                root = config.getString(config_name + "." + key);
+                chroot = config.getString(config_name + "." + key);
             }
             else throw KeeperException(std::string("Unknown key ") + key + " in config file");
         }
@@ -166,28 +166,25 @@ struct ZooKeeperArgs
             hosts += host;
         }
 
-        if (!root.empty())
+        if (!chroot.empty())
         {
-            if (root.front() != '/')
-                throw KeeperException(std::string("Root path in config file should start with '/', but got ") + root);
-            if (root.back() == '/')
-                root.pop_back();
-
-            hosts += root;
-            has_chroot = true;
+            if (chroot.front() != '/')
+                throw KeeperException(std::string("Root path in config file should start with '/', but got ") + chroot);
+            if (chroot.back() == '/')
+                chroot.pop_back();
         }
     }
 
     std::string hosts;
     std::string identity;
     int session_timeout_ms;
-    bool has_chroot;
+    std::string chroot;
 };
 
 ZooKeeper::ZooKeeper(const Poco::Util::AbstractConfiguration & config, const std::string & config_name)
 {
     ZooKeeperArgs args(config, config_name);
-    init(args.hosts, args.identity, args.session_timeout_ms, args.has_chroot);
+    init(args.hosts, args.identity, args.session_timeout_ms, args.chroot);
 }
 
 WatchCallback ZooKeeper::callbackForEvent(const EventPtr & event)
@@ -290,19 +287,18 @@ int32_t ZooKeeper::createImpl(const std::string & path, const std::string & data
     int code;
     /// The name of the created node can be longer than path if the sequential node is created.
     size_t name_buffer_size = path.size() + SEQUENTIAL_SUFFIX_SIZE;
-    char * name_buffer = new char[name_buffer_size];
+    std::string name_buffer(name_buffer_size, '\0');
 
-    code = zoo_create(impl, path.c_str(), data.c_str(), data.size(), getDefaultACL(), mode,  name_buffer, name_buffer_size);
+    code = zoo_create(impl, path.c_str(), data.c_str(), data.size(), getDefaultACL(), mode,  name_buffer.data(), name_buffer_size);
     ProfileEvents::increment(ProfileEvents::ZooKeeperCreate);
     ProfileEvents::increment(ProfileEvents::ZooKeeperTransactions);
 
     if (code == ZOK)
     {
-        path_created = std::string(name_buffer);
+        name_buffer.resize(strlen(name_buffer.data()));
+        path_created = std::move(name_buffer);
     }
 
-    delete[] name_buffer;
-
     return code;
 }
 
@@ -571,7 +567,19 @@ int32_t ZooKeeper::trySet(const std::string & path, const std::string & data,
     return code;
 }
 
-int32_t ZooKeeper::multiImpl(const Ops & ops_, OpResultsPtr * out_results_)
+/// Makes deep copy of zoo_op_result_t and removes chroot prefix from paths
+static void convertOpResults(const std::vector<zoo_op_result_t> & op_results_native, OpResultsPtr & out_op_results,
+                             const ZooKeeper * zookeeper = nullptr)
+{
+    if (!out_op_results)
+        out_op_results = std::make_shared<OpResults>();
+
+    out_op_results->reserve(op_results_native.size());
+    for (const zoo_op_result_t & res_native : op_results_native)
+        out_op_results->emplace_back(res_native, zookeeper);
+}
+
+int32_t ZooKeeper::multiImpl(const Ops & ops_, OpResultsPtr * out_op_results, MultiTransactionInfo * out_info)
 {
     if (ops_.empty())
         return ZOK;
@@ -585,7 +593,7 @@ int32_t ZooKeeper::multiImpl(const Ops & ops_, OpResultsPtr * out_results_)
         return ZINVALIDSTATE;
 
     size_t count = ops_.size();
-    OpResultsPtr out_results(new OpResults(count));
+    std::vector<zoo_op_result_t> out_results_native(count);
 
     /// Copy the struct containing pointers with default copy-constructor.
     /// It is safe because it hasn't got a destructor.
@@ -594,34 +602,31 @@ int32_t ZooKeeper::multiImpl(const Ops & ops_, OpResultsPtr * out_results_)
     for (const auto & op : ops_)
         ops.push_back(*(op->data));
 
-    int32_t code = zoo_multi(impl, static_cast<int>(ops.size()), ops.data(), out_results->data());
+    int32_t code = zoo_multi(impl, static_cast<int>(ops.size()), ops.data(), out_results_native.data());
     ProfileEvents::increment(ProfileEvents::ZooKeeperMulti);
     ProfileEvents::increment(ProfileEvents::ZooKeeperTransactions);
 
-    if (out_results_)
-        *out_results_ = out_results;
+    if (out_op_results || out_info)
+    {
+        OpResultsPtr op_results;
+        convertOpResults(out_results_native, op_results, this);
+
+        if (out_op_results)
+            *out_op_results = op_results;
+
+        if (out_info)
+            *out_info = MultiTransactionInfo(code, ops_, op_results);
+    }
 
     return code;
 }
 
 OpResultsPtr ZooKeeper::multi(const Ops & ops)
 {
-    OpResultsPtr results;
-    int code = tryMulti(ops, &results);
-    if (code != ZOK)
-    {
-        if (results && results->size() == ops.size())
-        {
-            for (size_t i = 0; i < ops.size(); ++i)
-            {
-                if (results->at(i).err == code)
-                    throw KeeperException("Transaction failed at op #" + std::to_string(i) + ": " + ops[i]->describe(), code);
-            }
-        }
-
-        throw KeeperException(code);
-    }
-    return results;
+    OpResultsPtr op_results;
+    int code = multiImpl(ops, &op_results);
+    KeeperMultiException::check(code, ops, op_results);
+    return op_results;
 }
 
 int32_t ZooKeeper::tryMulti(const Ops & ops_, OpResultsPtr * out_results_)
@@ -638,17 +643,9 @@ int32_t ZooKeeper::tryMulti(const Ops & ops_, OpResultsPtr * out_results_)
     return code;
 }
 
-int32_t ZooKeeper::tryMultiUnsafe(const Ops & ops, MultiTransactionInfo & info)
-{
-    info.code = multiImpl(ops, &info.op_results);
-    for (const OpPtr & op : ops)
-        info.ops.emplace_back(op->clone());
-    return info.code;
-}
-
 int32_t ZooKeeper::tryMultiWithRetries(const Ops & ops, OpResultsPtr * out_results, size_t * attempt)
 {
-    int32_t code = retry(std::bind(&ZooKeeper::multiImpl, this, std::ref(ops), out_results), attempt);
+    int32_t code = retry(std::bind(&ZooKeeper::multiImpl, this, std::ref(ops), out_results, nullptr), attempt);
     if (!(code == ZOK ||
         code == ZNONODE ||
         code == ZNODEEXISTS ||
@@ -754,7 +751,7 @@ ZooKeeper::~ZooKeeper()
 
 ZooKeeperPtr ZooKeeper::startNewSession() const
 {
-    return std::make_shared<ZooKeeper>(hosts, identity, session_timeout_ms);
+    return std::make_shared<ZooKeeper>(hosts, identity, session_timeout_ms, chroot);
 }
 
 Op::Create::Create(const std::string & path_pattern_, const std::string & value_, ACLPtr acl_, int32_t flags_)
@@ -981,26 +978,27 @@ ZooKeeper::TryRemoveFuture ZooKeeper::asyncTryRemove(const std::string & path, i
 
 ZooKeeper::MultiFuture ZooKeeper::asyncMultiImpl(const zkutil::Ops & ops_, bool throw_exception)
 {
-    size_t count = ops_.size();
-    OpResultsPtr results(new OpResults(count));
-
     /// We need to hold all references to ops data until the end of multi callback
     struct OpsHolder
     {
-        std::shared_ptr<zkutil::Ops> ops_ptr = std::make_shared<zkutil::Ops>();
-        std::shared_ptr<std::vector<zoo_op_t>> ops_raw_ptr = std::make_shared<std::vector<zoo_op_t>>();
+        std::shared_ptr<zkutil::Ops> ops_ptr;
+        std::shared_ptr<std::vector<zoo_op_t>> ops_native;
+        std::shared_ptr<std::vector<zoo_op_result_t>> op_results_native;
     } holder;
 
-    for (const auto & op : ops_)
-    {
-        holder.ops_ptr->emplace_back(op->clone());
-        holder.ops_raw_ptr->push_back(*holder.ops_ptr->back()->data);
-    }
+    /// Copy ops (swallow copy)
+    holder.ops_ptr = std::make_shared<zkutil::Ops>(ops_);
+    /// Copy native ops to contiguous vector
+    holder.ops_native = std::make_shared<std::vector<zoo_op_t>>();
+    for (const OpPtr & op : *holder.ops_ptr)
+        holder.ops_native->push_back(*op->data);
+    /// Allocate native result holders
+    holder.op_results_native = std::make_shared<std::vector<zoo_op_result_t>>(holder.ops_ptr->size());
 
-    MultiFuture future{ [throw_exception, results, holder] (int rc) {
+    MultiFuture future{ [throw_exception, holder, zookeeper=this] (int rc) {
         OpResultsAndCode res;
         res.code = rc;
-        res.results = results;
+        convertOpResults(*holder.op_results_native, res.results, zookeeper);
         res.ops_ptr = holder.ops_ptr;
         if (throw_exception && rc != ZOK)
             throw zkutil::KeeperException(rc);
@@ -1018,9 +1016,9 @@ ZooKeeper::MultiFuture ZooKeeper::asyncMultiImpl(const zkutil::Ops & ops_, bool
     if (expired())
         throw KeeperException(ZINVALIDSTATE);
 
-    auto & ops = *holder.ops_raw_ptr;
-
-    int32_t code = zoo_amulti(impl, static_cast<int>(ops.size()), ops.data(), results->data(),
+    int32_t code = zoo_amulti(impl, static_cast<int>(holder.ops_native->size()),
+                              holder.ops_native->data(),
+                              holder.op_results_native->data(),
                               [] (int rc, const void * data)
                               {
                                   MultiFuture::TaskPtr owned_task =
@@ -1069,4 +1067,58 @@ size_t getFailedOpIndex(const OpResultsPtr & op_results, int32_t transaction_ret
 }
 
 
+OpResult::OpResult(const zoo_op_result_t & op_result, const ZooKeeper * zookeeper)
+    : err(op_result.err)
+{
+    if (op_result.value)
+    {
+        value = std::string(op_result.value, op_result.value + op_result.valuelen);
+
+        /// Current version of libzookeeper does not cut chroot path prefixes
+        /// We do it here manually
+        if (zookeeper && !zookeeper->chroot.empty())
+        {
+            if (startsWith(value, zookeeper->chroot))
+                value = value.substr(zookeeper->chroot.length());
+            else
+                throw DB::Exception("Expected ZooKeeper path with chroot " + zookeeper->chroot + ", got " + value,
+                                    DB::ErrorCodes::LOGICAL_ERROR);
+        }
+    }
+
+    if (op_result.stat)
+        stat = std::make_unique<Stat>(*op_result.stat);
+}
+
+
+KeeperMultiException::KeeperMultiException(const MultiTransactionInfo & info_, size_t failed_op_index_)
+    :KeeperException(
+        "Transaction failed at op #" + std::to_string(failed_op_index_) + ": " + info_.ops.at(failed_op_index_)->describe(),
+        info_.code),
+    info(info_) {}
+
+void KeeperMultiException::check(int code, const Ops & ops, const OpResultsPtr & op_results)
+{
+    if (code == ZOK) {}
+    else if (zkutil::isUserError(code))
+        throw KeeperMultiException(MultiTransactionInfo(code, ops, op_results), getFailedOpIndex(op_results, code));
+    else
+        throw KeeperException(code);
+}
+
+void KeeperMultiException::check(const MultiTransactionInfo & info)
+{
+    if (info.code == ZOK) {}
+    else if (zkutil::isUserError(info.code))
+        throw KeeperMultiException(info, getFailedOpIndex(info.op_results, info.code));
+    else
+        throw KeeperException(info.code);
+}
+
+
+const Op & MultiTransactionInfo::getFailedOp() const
+{
+    return *ops.at(getFailedOpIndex(op_results, code));
+}
+
 }
diff --git a/dbms/src/Common/ZooKeeper/ZooKeeper.h b/dbms/src/Common/ZooKeeper/ZooKeeper.h
index 8d35e37d27f..dcfb5e9393d 100644
--- a/dbms/src/Common/ZooKeeper/ZooKeeper.h
+++ b/dbms/src/Common/ZooKeeper/ZooKeeper.h
@@ -8,10 +8,10 @@
 #include <memory>
 #include <mutex>
 #include <string>
-#include <unistd.h>
 #include <common/logger_useful.h>
 #include <Common/ProfileEvents.h>
 #include <Common/CurrentMetrics.h>
+#include <port/unistd.h>
 
 
 namespace ProfileEvents
@@ -56,7 +56,7 @@ public:
     using Ptr = std::shared_ptr<ZooKeeper>;
 
     ZooKeeper(const std::string & hosts, const std::string & identity = "",
-              int32_t session_timeout_ms = DEFAULT_SESSION_TIMEOUT, bool check_root_exists = false);
+              int32_t session_timeout_ms = DEFAULT_SESSION_TIMEOUT, const std::string & chroot = "");
 
     /** Config of the form:
         <zookeeper>
@@ -196,14 +196,16 @@ public:
     /// Performs several operations in a transaction.
     /// Throws on every error.
     OpResultsPtr multi(const Ops & ops);
-
     /// Throws only if some operation has returned an "unexpected" error
     /// - an error that would cause the corresponding try- method to throw.
     int32_t tryMulti(const Ops & ops, OpResultsPtr * out_results = nullptr);
-    /// Like previous one, but does not throw any ZooKeeper exceptions
-    int32_t tryMultiUnsafe(const Ops & ops, MultiTransactionInfo & info);
     /// Use only with read-only operations.
     int32_t tryMultiWithRetries(const Ops & ops, OpResultsPtr * out_results = nullptr, size_t * attempt = nullptr);
+    /// Throws nothing, just alias of multiImpl
+    int32_t tryMultiNoThrow(const Ops & ops, OpResultsPtr * out_op_results = nullptr, MultiTransactionInfo * out_info = nullptr)
+    {
+        return multiImpl(ops, out_op_results, out_info);
+    }
 
     Int64 getClientID();
 
@@ -366,9 +368,10 @@ public:
 private:
     friend struct WatchContext;
     friend class EphemeralNodeHolder;
+    friend struct OpResult;
+
+    void init(const std::string & hosts, const std::string & identity, int32_t session_timeout_ms, const std::string & chroot);
 
-    void init(const std::string & hosts, const std::string & identity,
-              int32_t session_timeout_ms, bool check_root_exists);
     void removeChildrenRecursive(const std::string & path);
     void tryRemoveChildrenRecursive(const std::string & path);
 
@@ -391,7 +394,7 @@ private:
             /// If the connection has been lost, wait timeout/3 hoping for connection re-establishment.
             static const int MAX_SLEEP_TIME = 10;
             if (code == ZCONNECTIONLOSS)
-                usleep(std::min(session_timeout_ms * 1000 / 3, MAX_SLEEP_TIME * 1000 * 1000));
+                usleep(std::min(session_timeout_ms * 1000u / 3, MAX_SLEEP_TIME * 1000u * 1000u));
 
             LOG_WARNING(log, "Error on attempt " << i << ": " << error2string(code)  << ". Retry");
             code = operation();
@@ -406,7 +409,7 @@ private:
     int32_t getImpl(const std::string & path, std::string & res, Stat * stat, WatchCallback watch_callback);
     int32_t setImpl(const std::string & path, const std::string & data, int32_t version = -1, Stat * stat = nullptr);
     int32_t getChildrenImpl(const std::string & path, Strings & res, Stat * stat, WatchCallback watch_callback);
-    int32_t multiImpl(const Ops & ops, OpResultsPtr * out_results = nullptr);
+    int32_t multiImpl(const Ops & ops, OpResultsPtr * out_op_results = nullptr, MultiTransactionInfo * out_info = nullptr);
     int32_t existsImpl(const std::string & path, Stat * stat_, WatchCallback watch_callback);
 
     MultiFuture asyncMultiImpl(const zkutil::Ops & ops_, bool throw_exception);
@@ -414,6 +417,7 @@ private:
     std::string hosts;
     std::string identity;
     int32_t session_timeout_ms;
+    std::string chroot;
 
     std::mutex mutex;
     ACLPtr default_acl;
@@ -493,41 +497,4 @@ private:
 
 using EphemeralNodeHolderPtr = EphemeralNodeHolder::Ptr;
 
-
-/// Simple structure to handle transaction execution results
-struct MultiTransactionInfo
-{
-    MultiTransactionInfo() = default;
-
-    Ops ops;
-    int32_t code = ZOK;
-    OpResultsPtr op_results;
-
-    bool empty() const
-    {
-        return ops.empty();
-    }
-
-    bool hasFailedOp() const
-    {
-        return zkutil::isUserError(code);
-    }
-
-    const Op & getFailedOp() const
-    {
-        return *ops.at(getFailedOpIndex(op_results, code));
-    }
-
-    KeeperException getException() const
-    {
-        if (hasFailedOp())
-        {
-            size_t i = getFailedOpIndex(op_results, code);
-            return KeeperException("Transaction failed at op #" + std::to_string(i) + ": " + ops.at(i)->describe(), code);
-        }
-        else
-            return KeeperException(code);
-    }
-};
-
 }
diff --git a/dbms/src/Common/ZooKeeper/tests/gtest_zkutil_test_multi_exception.cpp b/dbms/src/Common/ZooKeeper/tests/gtest_zkutil_test_multi_exception.cpp
index df71feab43e..695b9949a66 100644
--- a/dbms/src/Common/ZooKeeper/tests/gtest_zkutil_test_multi_exception.cpp
+++ b/dbms/src/Common/ZooKeeper/tests/gtest_zkutil_test_multi_exception.cpp
@@ -6,6 +6,9 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #include <gtest/gtest.h>
+#include <Common/ShellCommand.h>
+
+
 #pragma GCC diagnostic pop
 
 using namespace DB;
@@ -32,32 +35,32 @@ TEST(zkutil, multi_nice_exception_msg)
     zkutil::Ops ops;
 
     ASSERT_NO_THROW(
-        zookeeper->tryRemoveRecursive("/clickhouse_test_zkutil_multi");
+        zookeeper->tryRemoveRecursive("/clickhouse_test/zkutil_multi");
 
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi", "_", acl, zkutil::CreateMode::Persistent));
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi/a", "_", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi", "_", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi/a", "_", acl, zkutil::CreateMode::Persistent));
         zookeeper->multi(ops);
     );
 
     try
     {
         ops.clear();
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi/c", "_", acl, zkutil::CreateMode::Persistent));
-        ops.emplace_back(new zkutil::Op::Remove("/clickhouse_test_zkutil_multi/c", -1));
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi/a", "BadBoy", acl, zkutil::CreateMode::Persistent));
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi/b", "_", acl, zkutil::CreateMode::Persistent));
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi/a", "_", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi/c", "_", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Remove("/clickhouse_test/zkutil_multi/c", -1));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi/a", "BadBoy", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi/b", "_", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi/a", "_", acl, zkutil::CreateMode::Persistent));
 
         zookeeper->multi(ops);
         FAIL();
     }
     catch (...)
     {
-        zookeeper->tryRemoveRecursive("/clickhouse_test_zkutil_multi");
+        zookeeper->tryRemoveRecursive("/clickhouse_test/zkutil_multi");
 
         String msg = getCurrentExceptionMessage(false);
 
-        bool msg_has_reqired_patterns = msg.find("/clickhouse_test_zkutil_multi/a") != std::string::npos && msg.find("#2") != std::string::npos;
+        bool msg_has_reqired_patterns = msg.find("/clickhouse_test/zkutil_multi/a") != std::string::npos && msg.find("#2") != std::string::npos;
         EXPECT_TRUE(msg_has_reqired_patterns) << msg;
     }
 }
@@ -69,7 +72,7 @@ TEST(zkutil, multi_async)
     auto acl = zookeeper->getDefaultACL();
     zkutil::Ops ops;
 
-    zookeeper->tryRemoveRecursive("/clickhouse_test_zkutil_multi");
+    zookeeper->tryRemoveRecursive("/clickhouse_test/zkutil_multi");
 
     {
         ops.clear();
@@ -78,8 +81,8 @@ TEST(zkutil, multi_async)
 
     {
         ops.clear();
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi", "", acl, zkutil::CreateMode::Persistent));
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi/a", "", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi", "", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi/a", "", acl, zkutil::CreateMode::Persistent));
 
         auto fut = zookeeper->tryAsyncMulti(ops);
         ops.clear();
@@ -97,11 +100,11 @@ TEST(zkutil, multi_async)
         for (size_t i = 0; i < 10000; ++i)
         {
             ops.clear();
-            ops.emplace_back(new zkutil::Op::Remove("/clickhouse_test_zkutil_multi", -1));
-            ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi", "_", acl, zkutil::CreateMode::Persistent));
-            ops.emplace_back(new zkutil::Op::Check("/clickhouse_test_zkutil_multi", -1));
-            ops.emplace_back(new zkutil::Op::SetData("/clickhouse_test_zkutil_multi", "xxx", 42));
-            ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi/a", "_", acl, zkutil::CreateMode::Persistent));
+            ops.emplace_back(new zkutil::Op::Remove("/clickhouse_test/zkutil_multi", -1));
+            ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi", "_", acl, zkutil::CreateMode::Persistent));
+            ops.emplace_back(new zkutil::Op::Check("/clickhouse_test/zkutil_multi", -1));
+            ops.emplace_back(new zkutil::Op::SetData("/clickhouse_test/zkutil_multi", "xxx", 42));
+            ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi/a", "_", acl, zkutil::CreateMode::Persistent));
 
             futures.emplace_back(zookeeper->asyncMulti(ops));
         }
@@ -115,8 +118,8 @@ TEST(zkutil, multi_async)
 
     {
         ops.clear();
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi", "_", acl, zkutil::CreateMode::Persistent));
-        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test_zkutil_multi/a", "_", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi", "_", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(new zkutil::Op::Create("/clickhouse_test/zkutil_multi/a", "_", acl, zkutil::CreateMode::Persistent));
 
         auto fut = zookeeper->tryAsyncMulti(ops);
         ops.clear();
@@ -128,31 +131,55 @@ TEST(zkutil, multi_async)
     }
 }
 
+/// Run this test under sudo
+TEST(zkutil, multi_async_libzookeeper_segfault)
+{
+    auto zookeeper = std::make_unique<zkutil::ZooKeeper>("localhost:2181", "", 1000);
+    zkutil::Ops ops;
+
+    ops.emplace_back(new zkutil::Op::Check("/clickhouse_test/zkutil_multi", 0));
+
+    /// Uncomment to test
+    //auto cmd = ShellCommand::execute("sudo service zookeeper restart");
+    //cmd->wait();
+
+    auto future = zookeeper->asyncMulti(ops);
+    auto res = future.get();
+
+    EXPECT_TRUE(zkutil::isUnrecoverableErrorCode(res.code));
+}
+
 
 TEST(zkutil, multi_create_sequential)
 {
     try
     {
+        /// Create chroot node firstly
         auto zookeeper = std::make_unique<zkutil::ZooKeeper>("localhost:2181");
+        zookeeper->createAncestors("/clickhouse_test/");
+
+        zookeeper = std::make_unique<zkutil::ZooKeeper>("localhost:2181", "", zkutil::DEFAULT_SESSION_TIMEOUT, "/clickhouse_test");
         auto acl = zookeeper->getDefaultACL();
         zkutil::Ops ops;
 
-        String base_path = "/clickhouse_test/zkutil/multi_create_sequential";
+        String base_path = "/zkutil/multi_create_sequential";
         zookeeper->tryRemoveRecursive(base_path);
         zookeeper->createAncestors(base_path + "/");
 
-        String entry_path = base_path + "/queue-";
-        ops.emplace_back(new zkutil::Op::Create(entry_path, "", acl, zkutil::CreateMode::EphemeralSequential));
+        String sequential_node_prefix = base_path + "/queue-";
+        ops.emplace_back(new zkutil::Op::Create(sequential_node_prefix, "", acl, zkutil::CreateMode::EphemeralSequential));
         zkutil::OpResultsPtr results = zookeeper->multi(ops);
-        zkutil::OpResult & result = results->at(0);
+        zkutil::OpResult & sequential_node_result_op = results->at(0);
 
-        EXPECT_TRUE(result.value != nullptr);
-        EXPECT_TRUE(startsWith(result.value, entry_path));
+        EXPECT_FALSE(sequential_node_result_op.value.empty());
+        EXPECT_GT(sequential_node_result_op.value.length(), sequential_node_prefix.length());
+        EXPECT_EQ(sequential_node_result_op.value.substr(0, sequential_node_prefix.length()), sequential_node_prefix);
     }
     catch (...)
     {
         std::cerr << getCurrentExceptionMessage(false);
         throw;
     }
-
 }
+
+
diff --git a/dbms/src/Common/ZooKeeper/tests/zkutil_expiration_test.cpp b/dbms/src/Common/ZooKeeper/tests/zkutil_expiration_test.cpp
index 2079f7a84da..073e482e109 100644
--- a/dbms/src/Common/ZooKeeper/tests/zkutil_expiration_test.cpp
+++ b/dbms/src/Common/ZooKeeper/tests/zkutil_expiration_test.cpp
@@ -34,11 +34,11 @@ int main(int argc, char ** argv)
         {
             {
                 zkutil::Ops ops;
-                ops.emplace_back(std::make_unique<zkutil::Op::Create>("/test/zk_expiration_test", "hello", zk.getDefaultACL(), zkutil::CreateMode::Persistent));
-                ops.emplace_back(std::make_unique<zkutil::Op::Remove>("/test/zk_expiration_test", -1));
+                ops.emplace_back(std::make_shared<zkutil::Op::Create>("/test/zk_expiration_test", "hello", zk.getDefaultACL(), zkutil::CreateMode::Persistent));
+                ops.emplace_back(std::make_shared<zkutil::Op::Remove>("/test/zk_expiration_test", -1));
 
                 zkutil::MultiTransactionInfo info;
-                zk.tryMultiUnsafe(ops, info);
+                zk.tryMultiNoThrow(ops, nullptr, &info);
 
                 std::cout << time(nullptr) - time0 << "s: " << zkutil::ZooKeeper::error2string(info.code) << std::endl;
                 try
diff --git a/dbms/src/Common/ZooKeeper/tests/zkutil_test_commands.cpp b/dbms/src/Common/ZooKeeper/tests/zkutil_test_commands.cpp
index 3c9aed5113d..9b73f79ad7d 100644
--- a/dbms/src/Common/ZooKeeper/tests/zkutil_test_commands.cpp
+++ b/dbms/src/Common/ZooKeeper/tests/zkutil_test_commands.cpp
@@ -1,6 +1,6 @@
 #include <Common/ZooKeeper/ZooKeeper.h>
 #include <iostream>
-#include <unistd.h>
+#include <port/unistd.h>
 
 using namespace zkutil;
 
diff --git a/dbms/src/Common/isLocalAddress.h b/dbms/src/Common/isLocalAddress.h
index d90d7aef63a..981d343a97f 100644
--- a/dbms/src/Common/isLocalAddress.h
+++ b/dbms/src/Common/isLocalAddress.h
@@ -12,7 +12,6 @@ namespace Poco
 
 namespace DB
 {
-
     /** Lets you check if the address is similar to `localhost`.
      * The purpose of this check is usually to make an assumption,
      *  that when we go to this address via the Internet, we'll get to ourselves.
diff --git a/dbms/src/Common/localBackup.cpp b/dbms/src/Common/localBackup.cpp
index 3b93e0ee452..eb1f76d8c60 100644
--- a/dbms/src/Common/localBackup.cpp
+++ b/dbms/src/Common/localBackup.cpp
@@ -1,13 +1,10 @@
 #include <sys/stat.h>
-#include <unistd.h>
-
 #include <string>
 #include <iostream>
-
 #include <Poco/DirectoryIterator.h>
 #include <Poco/File.h>
-
 #include <Common/Exception.h>
+#include <port/unistd.h>
 
 
 namespace DB
diff --git a/dbms/src/Common/randomSeed.cpp b/dbms/src/Common/randomSeed.cpp
index 62925f55dd3..7618c41a020 100644
--- a/dbms/src/Common/randomSeed.cpp
+++ b/dbms/src/Common/randomSeed.cpp
@@ -1,12 +1,10 @@
 #include <time.h>
-#include <unistd.h>
+#include <port/unistd.h>
 #include <sys/types.h>
-
 #include <Common/Exception.h>
 #include <Common/randomSeed.h>
 #include <Common/SipHash.h>
 #include <Core/Types.h>
-
 #ifdef __APPLE__
 #include <common/apple_rt.h>
 #endif
diff --git a/dbms/src/Common/tests/compact_array.cpp b/dbms/src/Common/tests/compact_array.cpp
index 3beb8b6db9a..14c6b819c37 100644
--- a/dbms/src/Common/tests/compact_array.cpp
+++ b/dbms/src/Common/tests/compact_array.cpp
@@ -7,15 +7,13 @@
 #include <Common/CompactArray.h>
 #include <IO/WriteBufferFromFile.h>
 #include <IO/ReadBufferFromFile.h>
-
 #include <boost/filesystem.hpp>
-
 #include <string>
 #include <iostream>
 #include <fstream>
 #include <stdexcept>
-#include <unistd.h>
 #include <cstdlib>
+#include <port/unistd.h>
 
 namespace fs = boost::filesystem;
 
diff --git a/dbms/src/Core/Defines.h b/dbms/src/Core/Defines.h
index 8b69d83d69e..7f3a37613dc 100644
--- a/dbms/src/Core/Defines.h
+++ b/dbms/src/Core/Defines.h
@@ -60,6 +60,7 @@
 #define DBMS_MIN_REVISION_WITH_QUOTA_KEY_IN_CLIENT_INFO 54060
 #define DBMS_MIN_REVISION_WITH_TABLES_STATUS 54226
 #define DBMS_MIN_REVISION_WITH_TIME_ZONE_PARAMETER_IN_DATETIME_DATA_TYPE 54337
+#define DBMS_MIN_REVISION_WITH_SERVER_DISPLAY_NAME 54372
 
 /// Version of ClickHouse TCP protocol. Set to git tag with latest protocol change.
 #define DBMS_TCP_PROTOCOL_VERSION 54226
@@ -74,8 +75,18 @@
 #define DEFAULT_HTTP_READ_BUFFER_TIMEOUT 1800
 #define DEFAULT_HTTP_READ_BUFFER_CONNECTION_TIMEOUT 1
 
-#define ALWAYS_INLINE __attribute__((__always_inline__))
-#define NO_INLINE __attribute__((__noinline__))
+// more aliases: https://mailman.videolan.org/pipermail/x264-devel/2014-May/010660.html
+
+#if defined(_MSC_VER)
+    #define ALWAYS_INLINE __forceinline
+    #define NO_INLINE static __declspec(noinline)
+    #define MAY_ALIAS
+#else
+    #define ALWAYS_INLINE __attribute__((__always_inline__))
+    #define NO_INLINE __attribute__((__noinline__))
+    #define MAY_ALIAS __attribute__((__may_alias__))
+#endif
+
 
 #define PLATFORM_NOT_SUPPORTED "The only supported platforms are x86_64 and AArch64 (work in progress)"
 
diff --git a/dbms/src/Core/Field.h b/dbms/src/Core/Field.h
index f4c2f1ade86..795bc4b7070 100644
--- a/dbms/src/Core/Field.h
+++ b/dbms/src/Core/Field.h
@@ -198,14 +198,14 @@ public:
     template <typename T> T & get()
     {
         using TWithoutRef = std::remove_reference_t<T>;
-        TWithoutRef * __attribute__((__may_alias__)) ptr = reinterpret_cast<TWithoutRef*>(&storage);
+        TWithoutRef * MAY_ALIAS ptr = reinterpret_cast<TWithoutRef*>(&storage);
         return *ptr;
     };
 
     template <typename T> const T & get() const
     {
         using TWithoutRef = std::remove_reference_t<T>;
-        const TWithoutRef * __attribute__((__may_alias__)) ptr = reinterpret_cast<const TWithoutRef*>(&storage);
+        const TWithoutRef * MAY_ALIAS ptr = reinterpret_cast<const TWithoutRef*>(&storage);
         return *ptr;
     };
 
@@ -340,7 +340,7 @@ private:
     void createConcrete(T && x)
     {
         using JustT = std::decay_t<T>;
-        JustT * __attribute__((__may_alias__)) ptr = reinterpret_cast<JustT *>(&storage);
+        JustT * MAY_ALIAS ptr = reinterpret_cast<JustT *>(&storage);
         new (ptr) JustT(std::forward<T>(x));
         which = TypeToEnum<JustT>::value;
     }
@@ -350,7 +350,7 @@ private:
     void assignConcrete(T && x)
     {
         using JustT = std::decay_t<T>;
-        JustT * __attribute__((__may_alias__)) ptr = reinterpret_cast<JustT *>(&storage);
+        JustT * MAY_ALIAS ptr = reinterpret_cast<JustT *>(&storage);
         *ptr = std::forward<T>(x);
     }
 
@@ -398,7 +398,7 @@ private:
 
     void create(const char * data, size_t size)
     {
-        String * __attribute__((__may_alias__)) ptr = reinterpret_cast<String*>(&storage);
+        String * MAY_ALIAS ptr = reinterpret_cast<String*>(&storage);
         new (ptr) String(data, size);
         which = Types::String;
     }
@@ -434,7 +434,7 @@ private:
     template <typename T>
     void destroy()
     {
-        T * __attribute__((__may_alias__)) ptr = reinterpret_cast<T*>(&storage);
+        T * MAY_ALIAS ptr = reinterpret_cast<T*>(&storage);
         ptr->~T();
     }
 };
diff --git a/dbms/src/Core/NamesAndTypes.cpp b/dbms/src/Core/NamesAndTypes.cpp
index 14faaa133ea..a5240ba4a91 100644
--- a/dbms/src/Core/NamesAndTypes.cpp
+++ b/dbms/src/Core/NamesAndTypes.cpp
@@ -138,4 +138,14 @@ NamesAndTypesList NamesAndTypesList::addTypes(const Names & names) const
     return res;
 }
 
+bool NamesAndTypesList::contains(const String & name) const
+{
+    for (const NameAndTypePair & column : *this)
+    {
+        if (column.name == name)
+            return true;
+    }
+    return false;
+}
+
 }
diff --git a/dbms/src/Core/NamesAndTypes.h b/dbms/src/Core/NamesAndTypes.h
index 7aa9f3b3ff4..849141e43f7 100644
--- a/dbms/src/Core/NamesAndTypes.h
+++ b/dbms/src/Core/NamesAndTypes.h
@@ -69,6 +69,8 @@ public:
 
     /// Unlike `filter`, returns columns in the order in which they go in `names`.
     NamesAndTypesList addTypes(const Names & names) const;
+
+    bool contains(const String & name) const;
 };
 
 }
diff --git a/dbms/src/Core/iostream_debug_helpers.cpp b/dbms/src/Core/iostream_debug_helpers.cpp
index 3fbbb02a98f..2ad56c402b7 100644
--- a/dbms/src/Core/iostream_debug_helpers.cpp
+++ b/dbms/src/Core/iostream_debug_helpers.cpp
@@ -44,7 +44,7 @@ std::ostream & operator<<(std::ostream & stream, const IDataType & what)
 std::ostream & operator<<(std::ostream & stream, const IStorage & what)
 {
     stream << "IStorage(name = " << what.getName() << ", tableName = " << what.getTableName() << ") {"
-           << what.getColumnsList().toString()
+           << what.getColumns().getAllPhysical().toString()
            << "}";
     // isRemote supportsSampling supportsFinal supportsPrewhere
     return stream;
diff --git a/dbms/src/DataStreams/PrettyBlockOutputStream.cpp b/dbms/src/DataStreams/PrettyBlockOutputStream.cpp
index 58b61664b7c..2bb919d4806 100644
--- a/dbms/src/DataStreams/PrettyBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/PrettyBlockOutputStream.cpp
@@ -1,6 +1,5 @@
 #include <sys/ioctl.h>
-#include <unistd.h>
-
+#include <port/unistd.h>
 #include <DataStreams/PrettyBlockOutputStream.h>
 #include <IO/WriteBuffer.h>
 #include <IO/WriteHelpers.h>
diff --git a/dbms/src/DataStreams/RemoteBlockInputStream.cpp b/dbms/src/DataStreams/RemoteBlockInputStream.cpp
index 7b63b36cadc..7b851ec8469 100644
--- a/dbms/src/DataStreams/RemoteBlockInputStream.cpp
+++ b/dbms/src/DataStreams/RemoteBlockInputStream.cpp
@@ -138,7 +138,7 @@ void RemoteBlockInputStream::sendExternalTables()
             {
                 StoragePtr cur = table.second;
                 QueryProcessingStage::Enum stage = QueryProcessingStage::Complete;
-                BlockInputStreams input = cur->read(cur->getColumnNamesList(), {}, context,
+                BlockInputStreams input = cur->read(cur->getColumns().getNamesOfPhysical(), {}, context,
                     stage, DEFAULT_BLOCK_SIZE, 1);
                 if (input.size() == 0)
                     res.push_back(std::make_pair(std::make_shared<OneBlockInputStream>(cur->getSampleBlock()), table.first));
diff --git a/dbms/src/DataStreams/tests/filter_stream_hitlog.cpp b/dbms/src/DataStreams/tests/filter_stream_hitlog.cpp
index fe9ce592a43..2eb65c30df3 100644
--- a/dbms/src/DataStreams/tests/filter_stream_hitlog.cpp
+++ b/dbms/src/DataStreams/tests/filter_stream_hitlog.cpp
@@ -104,8 +104,8 @@ int main(int, char **)
 
         /// create an object of an existing hit log table
 
-        StoragePtr table = StorageLog::create("./", "HitLog", names_and_types_list,
-            NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
+        StoragePtr table = StorageLog::create(
+            "./", "HitLog", ColumnsDescription{names_and_types_list}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
         table->startup();
 
         /// read from it, apply the expression, filter, and write in tsv form to the console
diff --git a/dbms/src/DataStreams/tests/native_streams.cpp b/dbms/src/DataStreams/tests/native_streams.cpp
index bd0a998f88e..5d02d491ec4 100644
--- a/dbms/src/DataStreams/tests/native_streams.cpp
+++ b/dbms/src/DataStreams/tests/native_streams.cpp
@@ -95,8 +95,8 @@ try
 
     /// create an object of an existing hit log table
 
-    StoragePtr table = StorageLog::create("./", "HitLog", names_and_types_list,
-        NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
+    StoragePtr table = StorageLog::create(
+        "./", "HitLog", ColumnsDescription{names_and_types_list}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
     table->startup();
 
     /// read from it
diff --git a/dbms/src/DataStreams/tests/sorting_stream.cpp b/dbms/src/DataStreams/tests/sorting_stream.cpp
index cd6fe515a53..0cfffec295f 100644
--- a/dbms/src/DataStreams/tests/sorting_stream.cpp
+++ b/dbms/src/DataStreams/tests/sorting_stream.cpp
@@ -107,8 +107,8 @@ try
 
     /// create an object of an existing hit log table
 
-    StoragePtr table = StorageLog::create("./", "HitLog", names_and_types_list,
-        NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
+    StoragePtr table = StorageLog::create(
+        "./", "HitLog", ColumnsDescription{names_and_types_list}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
     table->startup();
 
     /// read from it, sort it, and write it in tsv form to the console
diff --git a/dbms/src/Databases/DatabaseDictionary.cpp b/dbms/src/Databases/DatabaseDictionary.cpp
index 8a10535fd09..503d0195168 100644
--- a/dbms/src/Databases/DatabaseDictionary.cpp
+++ b/dbms/src/Databases/DatabaseDictionary.cpp
@@ -41,8 +41,7 @@ Tables DatabaseDictionary::loadTables()
         {
             const DictionaryStructure & dictionary_structure = dict_ptr->getStructure();
             auto columns = StorageDictionary::getNamesAndTypes(dictionary_structure);
-            tables[name] = StorageDictionary::create(name,
-                columns, NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{}, dictionary_structure, name);
+            tables[name] = StorageDictionary::create(name, ColumnsDescription{columns}, dictionary_structure, name);
         }
     }
 
@@ -76,8 +75,7 @@ StoragePtr DatabaseDictionary::tryGetTable(
             {
                 const DictionaryStructure & dictionary_structure = dict_ptr->getStructure();
                 auto columns = StorageDictionary::getNamesAndTypes(dictionary_structure);
-                return StorageDictionary::create(table_name,
-                    columns, NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{}, dictionary_structure, table_name);
+                return StorageDictionary::create(table_name, ColumnsDescription{columns}, dictionary_structure, table_name);
             }
         }
     }
@@ -142,10 +140,7 @@ void DatabaseDictionary::renameTable(
 void DatabaseDictionary::alterTable(
     const Context &,
     const String &,
-    const NamesAndTypesList &,
-    const NamesAndTypesList &,
-    const NamesAndTypesList &,
-    const ColumnDefaults &,
+    const ColumnsDescription &,
     const ASTModifier &)
 {
     throw Exception("DatabaseDictionary: alterTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
diff --git a/dbms/src/Databases/DatabaseDictionary.h b/dbms/src/Databases/DatabaseDictionary.h
index 1308ea20a40..aba93faa5b1 100644
--- a/dbms/src/Databases/DatabaseDictionary.h
+++ b/dbms/src/Databases/DatabaseDictionary.h
@@ -79,10 +79,7 @@ public:
     void alterTable(
         const Context & context,
         const String & name,
-        const NamesAndTypesList & columns,
-        const NamesAndTypesList & materialized_columns,
-        const NamesAndTypesList & alias_columns,
-        const ColumnDefaults & column_defaults,
+        const ColumnsDescription & columns,
         const ASTModifier & engine_modifier) override;
 
     time_t getTableMetadataModificationTime(
diff --git a/dbms/src/Databases/DatabaseMemory.cpp b/dbms/src/Databases/DatabaseMemory.cpp
index 66b23f07ca6..57089862863 100644
--- a/dbms/src/Databases/DatabaseMemory.cpp
+++ b/dbms/src/Databases/DatabaseMemory.cpp
@@ -105,10 +105,7 @@ void DatabaseMemory::renameTable(
 void DatabaseMemory::alterTable(
     const Context &,
     const String &,
-    const NamesAndTypesList &,
-    const NamesAndTypesList &,
-    const NamesAndTypesList &,
-    const ColumnDefaults &,
+    const ColumnsDescription &,
     const ASTModifier &)
 {
     throw Exception("DatabaseMemory: alterTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
diff --git a/dbms/src/Databases/DatabaseMemory.h b/dbms/src/Databases/DatabaseMemory.h
index be095ad3755..586dcfbe4da 100644
--- a/dbms/src/Databases/DatabaseMemory.h
+++ b/dbms/src/Databases/DatabaseMemory.h
@@ -70,10 +70,7 @@ public:
     void alterTable(
         const Context & context,
         const String & name,
-        const NamesAndTypesList & columns,
-        const NamesAndTypesList & materialized_columns,
-        const NamesAndTypesList & alias_columns,
-        const ColumnDefaults & column_defaults,
+        const ColumnsDescription & columns,
         const ASTModifier & engine_modifier) override;
 
     time_t getTableMetadataModificationTime(
diff --git a/dbms/src/Databases/DatabaseOrdinary.cpp b/dbms/src/Databases/DatabaseOrdinary.cpp
index 0021f47c4c7..9dd705fbf9a 100644
--- a/dbms/src/Databases/DatabaseOrdinary.cpp
+++ b/dbms/src/Databases/DatabaseOrdinary.cpp
@@ -462,10 +462,7 @@ void DatabaseOrdinary::drop()
 void DatabaseOrdinary::alterTable(
     const Context & context,
     const String & name,
-    const NamesAndTypesList & columns,
-    const NamesAndTypesList & materialized_columns,
-    const NamesAndTypesList & alias_columns,
-    const ColumnDefaults & column_defaults,
+    const ColumnsDescription & columns,
     const ASTModifier & storage_modifier)
 {
     /// Read the definition of the table and replace the necessary parts with new ones.
@@ -486,7 +483,7 @@ void DatabaseOrdinary::alterTable(
 
     ASTCreateQuery & ast_create_query = typeid_cast<ASTCreateQuery &>(*ast);
 
-    ASTPtr new_columns = InterpreterCreateQuery::formatColumns(columns, materialized_columns, alias_columns, column_defaults);
+    ASTPtr new_columns = InterpreterCreateQuery::formatColumns(columns);
     ast_create_query.replace(ast_create_query.columns, new_columns);
 
     if (storage_modifier)
diff --git a/dbms/src/Databases/DatabaseOrdinary.h b/dbms/src/Databases/DatabaseOrdinary.h
index dbd44586c74..25e99114430 100644
--- a/dbms/src/Databases/DatabaseOrdinary.h
+++ b/dbms/src/Databases/DatabaseOrdinary.h
@@ -45,10 +45,7 @@ public:
     void alterTable(
         const Context & context,
         const String & name,
-        const NamesAndTypesList & columns,
-        const NamesAndTypesList & materialized_columns,
-        const NamesAndTypesList & alias_columns,
-        const ColumnDefaults & column_defaults,
+        const ColumnsDescription & columns,
         const ASTModifier & engine_modifier) override;
 
     time_t getTableMetadataModificationTime(
diff --git a/dbms/src/Databases/DatabasesCommon.cpp b/dbms/src/Databases/DatabasesCommon.cpp
index 83a14145d58..66d05d11184 100644
--- a/dbms/src/Databases/DatabasesCommon.cpp
+++ b/dbms/src/Databases/DatabasesCommon.cpp
@@ -67,7 +67,7 @@ std::pair<String, StoragePtr> createTableFromDefinition(
     if (!ast_create_query.columns)
         throw Exception("Missing definition of columns.", ErrorCodes::EMPTY_LIST_OF_COLUMNS_PASSED);
 
-    InterpreterCreateQuery::ColumnsInfo columns_info = InterpreterCreateQuery::getColumnsInfo(*ast_create_query.columns, context);
+    ColumnsDescription columns = InterpreterCreateQuery::getColumnsDescription(*ast_create_query.columns, context);
 
     return
     {
@@ -75,7 +75,7 @@ std::pair<String, StoragePtr> createTableFromDefinition(
         StorageFactory::instance().get(
             ast_create_query,
             database_data_path, ast_create_query.table, database_name, context, context.getGlobalContext(),
-            columns_info.columns, columns_info.materialized_columns, columns_info.alias_columns, columns_info.column_defaults,
+            columns,
             true, has_force_restore_data_flag)
     };
 }
diff --git a/dbms/src/Databases/IDatabase.h b/dbms/src/Databases/IDatabase.h
index 74cbe0b2202..f7b8af632ca 100644
--- a/dbms/src/Databases/IDatabase.h
+++ b/dbms/src/Databases/IDatabase.h
@@ -2,7 +2,7 @@
 
 #include <Core/Types.h>
 #include <Core/NamesAndTypes.h>
-#include <Storages/ColumnDefault.h>
+#include <Storages/ColumnsDescription.h>
 #include <ctime>
 #include <memory>
 #include <functional>
@@ -113,10 +113,7 @@ public:
     virtual void alterTable(
         const Context & context,
         const String & name,
-        const NamesAndTypesList & columns,
-        const NamesAndTypesList & materialized_columns,
-        const NamesAndTypesList & alias_columns,
-        const ColumnDefaults & column_defaults,
+        const ColumnsDescription & columns,
         const ASTModifier & engine_modifier) = 0;
 
     /// Returns time of table's metadata change, 0 if there is no corresponding metadata file.
diff --git a/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp b/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp
index 540b71a80dd..fcd73cdb889 100644
--- a/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp
+++ b/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp
@@ -8,7 +8,6 @@
 #include <Common/ProfileEvents.h>
 #include <Common/CurrentMetrics.h>
 #include <ext/range.h>
-#include <ext/scope_guard.h>
 #include <ext/map.h>
 
 
diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.cpp b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
index 04ee831bb1b..8c911771a20 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.cpp
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
@@ -6,6 +6,7 @@
 #include <common/logger_useful.h>
 #include <ext/bit_cast.h>
 #include <ext/range.h>
+#include <ext/scope_guard.h>
 
 namespace DB
 {
@@ -70,11 +71,11 @@ namespace
     Block dataToBlock(const Block & sample_block, const void * data)
     {
         if (!data)
-            return sample_block.cloneEmpty();
+            throw Exception("LibraryDictionarySource: No data returned", ErrorCodes::EXTERNAL_LIBRARY_ERROR);
 
         auto columns_received = static_cast<const ClickHouseLibrary::Table *>(data);
         if (columns_received->error_code)
-            throw Exception("Received error: " + std::to_string(columns_received->error_code) + " "
+            throw Exception("LibraryDictionarySource: Returned error: " + std::to_string(columns_received->error_code) + " "
                     + (columns_received->error_string ? columns_received->error_string : ""),
                 ErrorCodes::EXTERNAL_LIBRARY_ERROR);
 
@@ -85,7 +86,7 @@ namespace
         for (size_t col_n = 0; col_n < columns_received->size; ++col_n)
         {
             if (columns.size() != columns_received->data[col_n].size)
-                throw Exception("Received unexpected number of columns: " + std::to_string(columns_received->data[col_n].size)
+                throw Exception("LibraryDictionarySource: Returned unexpected number of columns: " + std::to_string(columns_received->data[col_n].size)
                         + ", must be " + std::to_string(columns.size()),
                     ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
 
@@ -123,9 +124,8 @@ LibraryDictionarySource::LibraryDictionarySource(const DictionaryStructure & dic
     description.init(sample_block);
     library = std::make_shared<SharedLibrary>(path);
     settings = std::make_shared<CStringsHolder>(getLibSettings(config, config_prefix + lib_config_settings));
-    auto fptr = library->tryGet<void * (*)()>("ClickHouseDictionary_v2_libNew");
-    if (fptr)
-        lib_data = fptr();
+    if (auto libNew = library->tryGet<decltype(lib_data) (*)(decltype(&settings->strings))>("ClickHouseDictionary_v2_libNew"))
+        lib_data = libNew(&settings->strings);
 }
 
 LibraryDictionarySource::LibraryDictionarySource(const LibraryDictionarySource & other)
@@ -138,15 +138,17 @@ LibraryDictionarySource::LibraryDictionarySource(const LibraryDictionarySource &
     , library{other.library}
     , description{other.description}
     , settings{other.settings}
-    , lib_data{other.lib_data}
 {
+    if (auto libClone = library->tryGet<decltype(lib_data) (*)(decltype(other.lib_data))>("ClickHouseDictionary_v2_libClone"))
+        lib_data = libClone(other.lib_data);
+    else if (auto libNew = library->tryGet<decltype(lib_data) (*)(decltype(&settings->strings))>("ClickHouseDictionary_v2_libNew"))
+        lib_data = libNew(&settings->strings);
 }
 
 LibraryDictionarySource::~LibraryDictionarySource()
 {
-    auto fptr = library->tryGet<void * (*)(void *)>("ClickHouseDictionary_v2_libDelete");
-    if (fptr)
-        fptr(lib_data);
+    if (auto libDelete = library->tryGet<void (*)(decltype(lib_data))>("ClickHouseDictionary_v2_libDelete"))
+        libDelete(lib_data);
 }
 
 BlockInputStreamPtr LibraryDictionarySource::loadAll()
@@ -165,12 +167,12 @@ BlockInputStreamPtr LibraryDictionarySource::loadAll()
     void * data_ptr = nullptr;
 
     /// Get function pointer before dataNew call because library->get may throw.
-    auto fptr
+    auto func_loadAll
         = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns))>("ClickHouseDictionary_v2_loadAll");
-    data_ptr = library->get<void * (*)(void *)>("ClickHouseDictionary_v2_dataNew")(lib_data);
-    auto data = fptr(data_ptr, &settings->strings, &columns);
+    data_ptr = library->get<decltype(data_ptr) (*)(decltype(lib_data))>("ClickHouseDictionary_v2_dataNew")(lib_data);
+    auto data = func_loadAll(data_ptr, &settings->strings, &columns);
     auto block = dataToBlock(description.sample_block, data);
-    library->get<void (*)(void *, void *)>("ClickHouseDictionary_v2_dataDelete")(lib_data, data_ptr);
+    SCOPE_EXIT(library->get<void (*)(decltype(lib_data), decltype(data_ptr))>("ClickHouseDictionary_v2_dataDelete")(lib_data, data_ptr));
     return std::make_shared<OneBlockInputStream>(block);
 }
 
@@ -191,12 +193,13 @@ BlockInputStreamPtr LibraryDictionarySource::loadIds(const std::vector<UInt64> &
     void * data_ptr = nullptr;
 
     /// Get function pointer before dataNew call because library->get may throw.
-    auto fptr = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns_pass), decltype(&ids_data))>(
-        "ClickHouseDictionary_v2_loadIds");
-    data_ptr = library->get<void * (*)(void *)>("ClickHouseDictionary_v2_dataNew")(lib_data);
-    auto data = fptr(data_ptr, &settings->strings, &columns_pass, &ids_data);
+    auto func_loadIds
+        = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns_pass), decltype(&ids_data))>(
+            "ClickHouseDictionary_v2_loadIds");
+    data_ptr = library->get<decltype(data_ptr) (*)(decltype(lib_data))>("ClickHouseDictionary_v2_dataNew")(lib_data);
+    auto data = func_loadIds(data_ptr, &settings->strings, &columns_pass, &ids_data);
     auto block = dataToBlock(description.sample_block, data);
-    library->get<void (*)(void *, void *)>("ClickHouseDictionary_v2_dataDelete")(lib_data, data_ptr);
+    SCOPE_EXIT(library->get<void (*)(decltype(lib_data), decltype(data_ptr))>("ClickHouseDictionary_v2_dataDelete")(lib_data, data_ptr));
     return std::make_shared<OneBlockInputStream>(block);
 }
 
@@ -218,30 +221,29 @@ BlockInputStreamPtr LibraryDictionarySource::loadKeys(const Columns & key_column
     void * data_ptr = nullptr;
 
     /// Get function pointer before dataNew call because library->get may throw.
-    auto fptr
+    auto func_loadKeys
         = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns_pass), decltype(&requested_rows_c))>(
             "ClickHouseDictionary_v2_loadKeys");
-    data_ptr = library->get<void * (*)(void *)>("ClickHouseDictionary_v2_dataNew")(lib_data);
-    auto data = fptr(data_ptr, &settings->strings, &columns_pass, &requested_rows_c);
+    data_ptr = library->get<decltype(data_ptr) (*)(decltype(lib_data))>("ClickHouseDictionary_v2_dataNew")(lib_data);
+    auto data = func_loadKeys(data_ptr, &settings->strings, &columns_pass, &requested_rows_c);
     auto block = dataToBlock(description.sample_block, data);
-    library->get<void (*)(void *, void *)>("ClickHouseDictionary_v2_dataDelete")(lib_data, data_ptr);
+    SCOPE_EXIT(library->get<void (*)(decltype(lib_data), decltype(data_ptr))>("ClickHouseDictionary_v2_dataDelete")(lib_data, data_ptr));
     return std::make_shared<OneBlockInputStream>(block);
 }
 
 bool LibraryDictionarySource::isModified() const
 {
-    auto fptr = library->tryGet<void * (*)(decltype(lib_data), decltype(&settings->strings))>("ClickHouseDictionary_v2_isModified");
-    if (fptr)
-        return fptr(lib_data, &settings->strings);
+    if (auto func_isModified
+        = library->tryGet<bool (*)(decltype(lib_data), decltype(&settings->strings))>("ClickHouseDictionary_v2_isModified"))
+        return func_isModified(lib_data, &settings->strings);
     return true;
 }
 
 bool LibraryDictionarySource::supportsSelectiveLoad() const
 {
-    auto fptr
-        = library->tryGet<void * (*)(decltype(lib_data), decltype(&settings->strings))>("ClickHouseDictionary_v2_supportsSelectiveLoad");
-    if (fptr)
-        return fptr(lib_data, &settings->strings);
+    if (auto func_supportsSelectiveLoad
+        = library->tryGet<bool (*)(decltype(lib_data), decltype(&settings->strings))>("ClickHouseDictionary_v2_supportsSelectiveLoad"))
+        return func_supportsSelectiveLoad(lib_data, &settings->strings);
     return true;
 }
 
diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.h b/dbms/src/Dictionaries/LibraryDictionarySource.h
index ce136b90318..1765968adca 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.h
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.h
@@ -1,26 +1,25 @@
 #pragma once
 
-#include <Common/SharedLibrary.h>
 #include <Dictionaries/DictionaryStructure.h>
 #include <Dictionaries/ExternalResultDescription.h>
 #include <Dictionaries/IDictionarySource.h>
+#include <Common/SharedLibrary.h>
 #include <common/LocalDateTime.h>
 
 
 namespace Poco
 {
-    class Logger;
+class Logger;
 
-    namespace Util
-    {
-        class AbstractConfiguration;
-    }
+namespace Util
+{
+    class AbstractConfiguration;
+}
 }
 
 
 namespace DB
 {
-
 class CStringsHolder;
 
 /// Allows loading dictionaries from dynamic libraries (.so)
@@ -55,7 +54,10 @@ public:
     bool supportsSelectiveLoad() const override;
 
     ///Not yet supported
-    bool hasUpdateField() const override { return false; }
+    bool hasUpdateField() const override
+    {
+        return false;
+    }
 
     DictionarySourcePtr clone() const override;
 
@@ -76,5 +78,4 @@ private:
     std::shared_ptr<CStringsHolder> settings;
     void * lib_data = nullptr;
 };
-
 }
diff --git a/dbms/src/Functions/FunctionsExternalDictionaries.h b/dbms/src/Functions/FunctionsExternalDictionaries.h
index cb77d84b751..bbf9b1b5c60 100644
--- a/dbms/src/Functions/FunctionsExternalDictionaries.h
+++ b/dbms/src/Functions/FunctionsExternalDictionaries.h
@@ -76,20 +76,19 @@ public:
 private:
     size_t getNumberOfArguments() const override { return 2; }
 
+    bool useDefaultImplementationForConstants() const final { return true; }
+    ColumnNumbers getArgumentsThatAreAlwaysConstant() const final { return {0}; }
+
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
         if (!arguments[0]->isString())
-            throw Exception{
-                "Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
-                    + ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
+                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!checkDataType<DataTypeUInt64>(arguments[1].get()) &&
             !checkDataType<DataTypeTuple>(arguments[1].get()))
-            throw Exception{
-                "Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
-                    + ", must be UInt64 or tuple(...).",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
+                + ", must be UInt64 or tuple(...).", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeUInt8>();
     }
@@ -100,9 +99,21 @@ private:
     {
         const auto dict_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[0]).column.get());
         if (!dict_name_col)
-            throw Exception{
-                "First argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"First argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
+
+        /** Do not require existence of the dictionary if the function is called for empty block.
+          * This is needed to allow successful query analysis on a server,
+          *  that is the initiator of a distributed query,
+          *  in the case when the function will be invoked for real data only at the remote servers.
+          * This feature is controversial and implemented specially
+          *  for backward compatibility with the case in Yandex Banner System.
+          */
+        if (block.rows() == 0)
+        {
+            auto & elem = block.getByPosition(result);
+            elem.column = elem.type->createColumn();
+            return;
+        }
 
         auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
         const auto dict_ptr = dict.get();
@@ -113,9 +124,7 @@ private:
             !executeDispatchComplex<ComplexKeyHashedDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchComplex<ComplexKeyCacheDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchComplex<TrieDictionary>(block, arguments, result, dict_ptr))
-            throw Exception{
-                "Unsupported dictionary type " + dict_ptr->getTypeName(),
-                ErrorCodes::UNKNOWN_TYPE};
+            throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE};
     }
 
     template <typename DictionaryType>
@@ -135,19 +144,8 @@ private:
             dict->has(ids, out->getData());
             block.getByPosition(result).column = std::move(out);
         }
-        else if (const auto id_col = checkAndGetColumnConst<ColumnVector<UInt64>>(id_col_untyped))
-        {
-            const PaddedPODArray<UInt64> ids(1, id_col->getValue<UInt64>());
-            PaddedPODArray<UInt8> out(1);
-
-            dict->has(ids, out);
-
-            block.getByPosition(result).column = DataTypeUInt8().createColumnConst(id_col->size(), toField(out.front()));
-        }
         else
-            throw Exception{
-                "Second argument of function " + getName() + " must be UInt64",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be UInt64", ErrorCodes::ILLEGAL_COLUMN};
 
         return true;
     }
@@ -161,11 +159,7 @@ private:
             return false;
 
         const ColumnWithTypeAndName & key_col_with_type = block.getByPosition(arguments[1]);
-        ColumnPtr key_col = key_col_with_type.column;
-
-        /// Functions in external dictionaries only support full-value (not constant) columns with keys.
-        if (ColumnPtr key_col_materialized = key_col_with_type.column->convertToFullColumnIfConst())
-            key_col = key_col_materialized;
+        const ColumnPtr & key_col = key_col_with_type.column;
 
         if (checkColumn<ColumnTuple>(key_col.get()))
         {
@@ -177,9 +171,7 @@ private:
             block.getByPosition(result).column = std::move(out);
         }
         else
-            throw Exception{
-                "Second argument of function " + getName() + " must be " + dict->getKeyDescription(),
-                ErrorCodes::TYPE_MISMATCH};
+            throw Exception{"Second argument of function " + getName() + " must be " + dict->getKeyDescription(), ErrorCodes::TYPE_MISMATCH};
 
         return true;
     }
@@ -195,15 +187,11 @@ static bool isDictGetFunctionInjective(const ExternalDictionaries & dictionaries
 
     const auto dict_name_col = checkAndGetColumnConst<ColumnString>(sample_block.getByPosition(0).column.get());
     if (!dict_name_col)
-        throw Exception{
-            "First argument of function dictGet... must be a constant string",
-            ErrorCodes::ILLEGAL_COLUMN};
+        throw Exception{"First argument of function dictGet... must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
     const auto attr_name_col = checkAndGetColumnConst<ColumnString>(sample_block.getByPosition(1).column.get());
     if (!attr_name_col)
-        throw Exception{
-            "Second argument of function dictGet... must be a constant string",
-            ErrorCodes::ILLEGAL_COLUMN};
+        throw Exception{"Second argument of function dictGet... must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
     return dictionaries.getDictionary(dict_name_col->getValue<String>())->isInjective(attr_name_col->getValue<String>());
 }
@@ -227,6 +215,9 @@ private:
     bool isVariadic() const override { return true; }
     size_t getNumberOfArguments() const override { return 0; }
 
+    bool useDefaultImplementationForConstants() const final { return true; }
+    ColumnNumbers getArgumentsThatAreAlwaysConstant() const final { return {0, 1}; }
+
     bool isInjective(const Block & sample_block) override
     {
         return isDictGetFunctionInjective(dictionaries, sample_block);
@@ -235,42 +226,33 @@ private:
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
         if (arguments.size() != 3 && arguments.size() != 4)
-            throw Exception{
-                "Number of arguments for function " + getName() + " doesn't match: passed "
-                    + toString(arguments.size()) + ", should be 3 or 4.",
-                ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception{"Number of arguments for function " + getName() + " doesn't match: passed "
+                + toString(arguments.size()) + ", should be 3 or 4.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
         if (!arguments[0]->isString())
         {
-            throw Exception{
-                "Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
-                    + ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
+                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
         }
 
         if (!arguments[1]->isString())
         {
-            throw Exception{
-                "Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
-                    + ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
+                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
         }
 
         if (!checkDataType<DataTypeUInt64>(arguments[2].get()) &&
             !checkDataType<DataTypeTuple>(arguments[2].get()))
         {
-            throw Exception{
-                "Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
-                    + ", must be UInt64 or tuple(...).",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
+                + ", must be UInt64 or tuple(...).", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
         }
 
+        /// This is for the case of range dictionaries.
         if (arguments.size() == 4 && !checkDataType<DataTypeDate>(arguments[3].get()))
         {
-            throw Exception{
-                "Illegal type " + arguments[3]->getName() + " of fourth argument of function " + getName()
-                    + ", must be Date.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[3]->getName() + " of fourth argument of function " + getName()
+                + ", must be Date.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
         }
 
         return std::make_shared<DataTypeString>();
@@ -282,9 +264,14 @@ private:
     {
         const auto dict_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[0]).column.get());
         if (!dict_name_col)
-            throw Exception{
-                "First argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"First argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
+
+        if (block.rows() == 0)
+        {
+            auto & elem = block.getByPosition(result);
+            elem.column = elem.type->createColumn();
+            return;
+        }
 
         auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
         const auto dict_ptr = dict.get();
@@ -296,9 +283,7 @@ private:
             !executeDispatchComplex<ComplexKeyCacheDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchComplex<TrieDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchRange<RangeHashedDictionary>(block, arguments, result, dict_ptr))
-            throw Exception{
-                "Unsupported dictionary type " + dict_ptr->getTypeName(),
-                ErrorCodes::UNKNOWN_TYPE};
+            throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE};
     }
 
     template <typename DictionaryType>
@@ -310,16 +295,12 @@ private:
             return false;
 
         if (arguments.size() != 3)
-            throw Exception{
-                "Function " + getName() + " for dictionary of type " + dict->getTypeName() +
-                " requires exactly 3 arguments",
-                ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception{"Function " + getName() + " for dictionary of type " + dict->getTypeName() +
+                " requires exactly 3 arguments", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -330,19 +311,8 @@ private:
             dict->getString(attr_name, id_col->getData(), out.get());
             block.getByPosition(result).column = std::move(out);
         }
-        else if (const auto id_col = checkAndGetColumnConst<ColumnVector<UInt64>>(id_col_untyped))
-        {
-            const PaddedPODArray<UInt64> ids(1, id_col->getValue<UInt64>());
-            auto out = ColumnString::create();
-            dict->getString(attr_name, ids, out.get());
-            block.getByPosition(result).column = DataTypeString().createColumnConst(id_col->size(), out->getDataAt(0).toString());
-        }
         else
-        {
-            throw Exception{
-                "Third argument of function " + getName() + " must be UInt64",
-                ErrorCodes::ILLEGAL_COLUMN};
-        }
+            throw Exception{"Third argument of function " + getName() + " must be UInt64", ErrorCodes::ILLEGAL_COLUMN};
 
         return true;
     }
@@ -356,16 +326,12 @@ private:
             return false;
 
         if (arguments.size() != 3)
-            throw Exception{
-                "Function " + getName() + " for dictionary of type " + dict->getTypeName() +
-                    " requires exactly 3 arguments",
-                ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception{"Function " + getName() + " for dictionary of type " + dict->getTypeName() +
+                " requires exactly 3 arguments", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -386,9 +352,7 @@ private:
             block.getByPosition(result).column = std::move(out);
         }
         else
-            throw Exception{
-                "Third argument of function " + getName() + " must be " + dict->getKeyDescription(),
-                ErrorCodes::TYPE_MISMATCH};
+            throw Exception{"Third argument of function " + getName() + " must be " + dict->getKeyDescription(), ErrorCodes::TYPE_MISMATCH};
 
         return true;
     }
@@ -402,16 +366,12 @@ private:
             return false;
 
         if (arguments.size() != 4)
-            throw Exception{
-                "Function " + getName() + " for dictionary of type " + dict->getTypeName() +
-                " requires exactly 4 arguments",
-                ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception{"Function " + getName() + " for dictionary of type " + dict->getTypeName() +
+                " requires exactly 4 arguments", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -423,9 +383,7 @@ private:
             executeRange(block, result, dict, attr_name, id_col, date_col_untyped);
         else
         {
-            throw Exception{
-                "Third argument of function " + getName() + " must be UInt64",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Third argument of function " + getName() + " must be UInt64", ErrorCodes::ILLEGAL_COLUMN};
         }
 
         return true;
@@ -451,9 +409,7 @@ private:
         }
         else
         {
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be Date",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Fourth argument of function " + getName() + " must be Date", ErrorCodes::ILLEGAL_COLUMN};
         }
     }
 
@@ -480,9 +436,7 @@ private:
         }
         else
         {
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be Date",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Fourth argument of function " + getName() + " must be Date", ErrorCodes::ILLEGAL_COLUMN};
         }
     }
 
@@ -507,34 +461,29 @@ public:
 private:
     size_t getNumberOfArguments() const override { return 4; }
 
+    bool useDefaultImplementationForConstants() const final { return true; }
+    ColumnNumbers getArgumentsThatAreAlwaysConstant() const final { return {0, 1}; }
+
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
         if (!arguments[0]->isString())
-            throw Exception{
-                "Illegal type " + arguments[0]->getName() + " of first argument of function " + getName() +
-                    ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[0]->getName() + " of first argument of function " + getName() +
+                ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!arguments[1]->isString())
-            throw Exception{
-                "Illegal type " + arguments[1]->getName() + " of second argument of function " + getName() +
-                    ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[1]->getName() + " of second argument of function " + getName() +
+                ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!checkDataType<DataTypeUInt64>(arguments[2].get()) &&
             !checkDataType<DataTypeTuple>(arguments[2].get()))
         {
-            throw Exception{
-                "Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
-                    + ", must be UInt64 or tuple(...).",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
+                + ", must be UInt64 or tuple(...).", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
         }
 
         if (!arguments[3]->isString())
-            throw Exception{
-                "Illegal type " + arguments[3]->getName() + " of fourth argument of function " + getName() +
-                    ", must be String.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Illegal type " + arguments[3]->getName() + " of fourth argument of function " + getName() +
+                ", must be String.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeString>();
     }
@@ -545,9 +494,14 @@ private:
     {
         const auto dict_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[0]).column.get());
         if (!dict_name_col)
-            throw Exception{
-                "First argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"First argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
+
+        if (block.rows() == 0)
+        {
+            auto & elem = block.getByPosition(result);
+            elem.column = elem.type->createColumn();
+            return;
+        }
 
         auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
         const auto dict_ptr = dict.get();
@@ -558,9 +512,7 @@ private:
             !executeDispatchComplex<ComplexKeyHashedDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchComplex<ComplexKeyCacheDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchComplex<TrieDictionary>(block, arguments, result, dict_ptr))
-            throw Exception{
-                "Unsupported dictionary type " + dict_ptr->getTypeName(),
-                ErrorCodes::UNKNOWN_TYPE};
+            throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE};
     }
 
     template <typename DictionaryType>
@@ -573,9 +525,7 @@ private:
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                    ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -585,9 +535,7 @@ private:
         else if (const auto id_col = checkAndGetColumnConst<ColumnVector<UInt64>>(id_col_untyped))
             executeDispatch(block, arguments, result, dict, attr_name, id_col);
         else
-            throw Exception{
-                "Third argument of function " + getName() + " must be UInt64",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Third argument of function " + getName() + " must be UInt64", ErrorCodes::ILLEGAL_COLUMN};
 
         return true;
     }
@@ -617,9 +565,7 @@ private:
             block.getByPosition(result).column = std::move(out);
         }
         else
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be String",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Fourth argument of function " + getName() + " must be String", ErrorCodes::ILLEGAL_COLUMN};
     }
 
     template <typename DictionaryType>
@@ -648,9 +594,7 @@ private:
             block.getByPosition(result).column = DataTypeString().createColumnConst(id_col->size(), out->getDataAt(0).toString());
         }
         else
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be String",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Fourth argument of function " + getName() + " must be String", ErrorCodes::ILLEGAL_COLUMN};
     }
 
     template <typename DictionaryType>
@@ -663,9 +607,7 @@ private:
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                    ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -692,9 +634,7 @@ private:
             dict->getString(attr_name, key_columns, key_types, def, out.get());
         }
         else
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be String",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Fourth argument of function " + getName() + " must be String", ErrorCodes::ILLEGAL_COLUMN};
 
         block.getByPosition(result).column = std::move(out);
         return true;
@@ -781,6 +721,9 @@ private:
     bool isVariadic() const override { return true; }
     size_t getNumberOfArguments() const override { return 0; }
 
+    bool useDefaultImplementationForConstants() const final { return true; }
+    ColumnNumbers getArgumentsThatAreAlwaysConstant() const final { return {0, 1}; }
+
     bool isInjective(const Block & sample_block) override
     {
         return isDictGetFunctionInjective(dictionaries, sample_block);
@@ -792,37 +735,21 @@ private:
             throw Exception{"Function " + getName() + " takes 3 or 4 arguments", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
         if (!arguments[0]->isString())
-        {
-            throw Exception{
-                "Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
-                    + ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
+                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!arguments[1]->isString())
-        {
-            throw Exception{
-                "Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
-                    + ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
+                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!checkDataType<DataTypeUInt64>(arguments[2].get()) &&
             !checkDataType<DataTypeTuple>(arguments[2].get()))
-        {
-            throw Exception{
-                "Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
-                    + ", must be UInt64 or tuple(...).",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
+                + ", must be UInt64 or tuple(...).", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (arguments.size() == 4 && !checkDataType<DataTypeDate>(arguments[3].get()))
-        {
-            throw Exception{
-                "Illegal type " + arguments[3]->getName() + " of fourth argument of function " + getName()
-                + ", must be Date.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[3]->getName() + " of fourth argument of function " + getName()
+                + ", must be Date.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataType>();
     }
@@ -833,9 +760,14 @@ private:
     {
         const auto dict_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[0]).column.get());
         if (!dict_name_col)
-            throw Exception{
-                "First argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"First argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
+
+        if (block.rows() == 0)
+        {
+            auto & elem = block.getByPosition(result);
+            elem.column = elem.type->createColumn();
+            return;
+        }
 
         auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
         const auto dict_ptr = dict.get();
@@ -847,9 +779,7 @@ private:
             !executeDispatchComplex<ComplexKeyCacheDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchComplex<TrieDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchRange<RangeHashedDictionary>(block, arguments, result, dict_ptr))
-            throw Exception{
-                "Unsupported dictionary type " + dict_ptr->getTypeName(),
-                ErrorCodes::UNKNOWN_TYPE};
+            throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE};
     }
 
     template <typename DictionaryType>
@@ -861,16 +791,12 @@ private:
             return false;
 
         if (arguments.size() != 3)
-            throw Exception{
-                "Function " + getName() + " for dictionary of type " + dict->getTypeName() +
-                " requires exactly 3 arguments.",
-                ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception{"Function " + getName() + " for dictionary of type " + dict->getTypeName() +
+                " requires exactly 3 arguments.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -891,11 +817,7 @@ private:
             block.getByPosition(result).column = DataTypeNumber<Type>().createColumnConst(id_col->size(), toField(data.front()));
         }
         else
-        {
-            throw Exception{
-                "Third argument of function " + getName() + " must be UInt64",
-                ErrorCodes::ILLEGAL_COLUMN};
-        }
+            throw Exception{"Third argument of function " + getName() + " must be UInt64", ErrorCodes::ILLEGAL_COLUMN};
 
         return true;
     }
@@ -909,16 +831,12 @@ private:
             return false;
 
         if (arguments.size() != 3)
-            throw Exception{
-                "Function " + getName() + " for dictionary of type " + dict->getTypeName() +
-                    " requires exactly 3 arguments",
-                ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception{"Function " + getName() + " for dictionary of type " + dict->getTypeName() +
+                " requires exactly 3 arguments", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -940,9 +858,7 @@ private:
             block.getByPosition(result).column = std::move(out);
         }
         else
-            throw Exception{
-                "Third argument of function " + getName() + " must be " + dict->getKeyDescription(),
-                ErrorCodes::TYPE_MISMATCH};
+            throw Exception{"Third argument of function " + getName() + " must be " + dict->getKeyDescription(), ErrorCodes::TYPE_MISMATCH};
 
         return true;
     }
@@ -956,16 +872,12 @@ private:
             return false;
 
         if (arguments.size() != 4)
-            throw Exception{
-                "Function " + getName() + " for dictionary of type " + dict->getTypeName() +
-                " requires exactly 4 arguments",
-                ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+            throw Exception{"Function " + getName() + " for dictionary of type " + dict->getTypeName() +
+                " requires exactly 4 arguments", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -976,11 +888,7 @@ private:
         else if (const auto id_col = checkAndGetColumnConst<ColumnVector<UInt64>>(id_col_untyped))
             executeRange(block, result, dict, attr_name, id_col, date_col_untyped);
         else
-        {
-            throw Exception{
-                "Third argument of function " + getName() + " must be UInt64",
-                ErrorCodes::ILLEGAL_COLUMN};
-        }
+            throw Exception{"Third argument of function " + getName() + " must be UInt64", ErrorCodes::ILLEGAL_COLUMN};
 
         return true;
     }
@@ -1013,11 +921,7 @@ private:
             block.getByPosition(result).column = std::move(out);
         }
         else
-        {
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be Date",
-                ErrorCodes::ILLEGAL_COLUMN};
-        }
+            throw Exception{"Fourth argument of function " + getName() + " must be Date", ErrorCodes::ILLEGAL_COLUMN};
     }
 
     template <typename DictionaryType>
@@ -1045,11 +949,7 @@ private:
             block.getByPosition(result).column = DataTypeNumber<Type>().createColumnConst(id_col->size(), toField(data.front()));
         }
         else
-        {
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be Date",
-                ErrorCodes::ILLEGAL_COLUMN};
-        }
+            throw Exception{"Fourth argument of function " + getName() + " must be Date", ErrorCodes::ILLEGAL_COLUMN};
     }
 
     const ExternalDictionaries & dictionaries;
@@ -1104,40 +1004,27 @@ public:
 private:
     size_t getNumberOfArguments() const override { return 4; }
 
+    bool useDefaultImplementationForConstants() const final { return true; }
+    ColumnNumbers getArgumentsThatAreAlwaysConstant() const final { return {0, 1}; }
+
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
         if (!arguments[0]->isString())
-        {
-            throw Exception{
-                "Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
-                    + ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
+                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!arguments[1]->isString())
-        {
-            throw Exception{
-                "Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
-                    + ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
+                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!checkDataType<DataTypeUInt64>(arguments[2].get()) &&
             !checkDataType<DataTypeTuple>(arguments[2].get()))
-        {
-            throw Exception{
-                "Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
-                    + ", must be UInt64 or tuple(...).",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
+                + ", must be UInt64 or tuple(...).", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!checkDataType<DataType>(arguments[3].get()))
-        {
-            throw Exception{
-                "Illegal type " + arguments[3]->getName() + " of fourth argument of function " + getName()
-                    + ", must be " + String(DataType{}.getFamilyName()) + ".",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[3]->getName() + " of fourth argument of function " + getName()
+                + ", must be " + String(DataType{}.getFamilyName()) + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataType>();
     }
@@ -1148,9 +1035,14 @@ private:
     {
         const auto dict_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[0]).column.get());
         if (!dict_name_col)
-            throw Exception{
-                "First argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"First argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
+
+        if (block.rows() == 0)
+        {
+            auto & elem = block.getByPosition(result);
+            elem.column = elem.type->createColumn();
+            return;
+        }
 
         auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
         const auto dict_ptr = dict.get();
@@ -1161,9 +1053,7 @@ private:
             !executeDispatchComplex<ComplexKeyHashedDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchComplex<ComplexKeyCacheDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatchComplex<TrieDictionary>(block, arguments, result, dict_ptr))
-            throw Exception{
-                "Unsupported dictionary type " + dict_ptr->getTypeName(),
-                ErrorCodes::UNKNOWN_TYPE};
+            throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE};
     }
 
     template <typename DictionaryType>
@@ -1176,9 +1066,7 @@ private:
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -1188,9 +1076,7 @@ private:
         else if (const auto id_col = checkAndGetColumnConst<ColumnVector<UInt64>>(id_col_untyped))
             executeDispatch(block, arguments, result, dict, attr_name, id_col);
         else
-            throw Exception{
-                "Third argument of function " + getName() + " must be UInt64",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Third argument of function " + getName() + " must be UInt64", ErrorCodes::ILLEGAL_COLUMN};
 
         return true;
     }
@@ -1223,9 +1109,7 @@ private:
             block.getByPosition(result).column = std::move(out);
         }
         else
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be " + String(DataType{}.getFamilyName()),
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Fourth argument of function " + getName() + " must be " + String(DataType{}.getFamilyName()), ErrorCodes::ILLEGAL_COLUMN};
     }
 
     template <typename DictionaryType>
@@ -1257,9 +1141,7 @@ private:
             block.getByPosition(result).column = DataTypeNumber<Type>().createColumnConst(id_col->size(), toField(data.front()));
         }
         else
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be " + String(DataType{}.getFamilyName()),
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Fourth argument of function " + getName() + " must be " + String(DataType{}.getFamilyName()), ErrorCodes::ILLEGAL_COLUMN};
     }
 
     template <typename DictionaryType>
@@ -1272,9 +1154,7 @@ private:
 
         const auto attr_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[1]).column.get());
         if (!attr_name_col)
-            throw Exception{
-                "Second argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Second argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
 
         String attr_name = attr_name_col->getValue<String>();
 
@@ -1308,9 +1188,7 @@ private:
             DictGetTraits<DataType>::getOrDefault(dict, attr_name, key_columns, key_types, def, data);
         }
         else
-            throw Exception{
-                "Fourth argument of function " + getName() + " must be " + String(DataType{}.getFamilyName()),
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Fourth argument of function " + getName() + " must be " + String(DataType{}.getFamilyName()), ErrorCodes::ILLEGAL_COLUMN};
 
         block.getByPosition(result).column = std::move(out);
         return true;
@@ -1368,23 +1246,18 @@ private:
     size_t getNumberOfArguments() const override { return 2; }
     bool isInjective(const Block & /*sample_block*/) override { return true; }
 
+    bool useDefaultImplementationForConstants() const final { return true; }
+    ColumnNumbers getArgumentsThatAreAlwaysConstant() const final { return {0}; }
+
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
         if (!arguments[0]->isString())
-        {
-            throw Exception{
-                "Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
-                    + ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
+                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!checkDataType<DataTypeUInt64>(arguments[1].get()))
-        {
-            throw Exception{
-                "Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
-                    + ", must be UInt64.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
+                + ", must be UInt64.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt64>());
     }
@@ -1395,9 +1268,14 @@ private:
     {
         const auto dict_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[0]).column.get());
         if (!dict_name_col)
-            throw Exception{
-                "First argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"First argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
+
+        if (block.rows() == 0)
+        {
+            auto & elem = block.getByPosition(result);
+            elem.column = elem.type->createColumn();
+            return;
+        }
 
         auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
         const auto dict_ptr = dict.get();
@@ -1405,9 +1283,7 @@ private:
         if (!executeDispatch<FlatDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatch<HashedDictionary>(block, arguments, result, dict_ptr) &&
             !executeDispatch<CacheDictionary>(block, arguments, result, dict_ptr))
-            throw Exception{
-                "Unsupported dictionary type " + dict_ptr->getTypeName(),
-                ErrorCodes::UNKNOWN_TYPE};
+            throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE};
     }
 
     template <typename DictionaryType>
@@ -1419,9 +1295,7 @@ private:
             return false;
 
         if (!dict->hasHierarchy())
-            throw Exception{
-                "Dictionary does not have a hierarchy",
-                ErrorCodes::UNSUPPORTED_METHOD};
+            throw Exception{"Dictionary does not have a hierarchy", ErrorCodes::UNSUPPORTED_METHOD};
 
         const auto get_hierarchies = [&] (const PaddedPODArray<UInt64> & in, PaddedPODArray<UInt64> & out, PaddedPODArray<UInt64> & offsets)
         {
@@ -1502,11 +1376,7 @@ private:
             block.getByPosition(result).column = block.getByPosition(result).type->createColumnConst(id_col->size(), (*array)[0].get<Array>());
         }
         else
-        {
-            throw Exception{
-                "Second argument of function " + getName() + " must be UInt64",
-                ErrorCodes::ILLEGAL_COLUMN};
-        }
+            throw Exception{"Second argument of function " + getName() + " must be UInt64", ErrorCodes::ILLEGAL_COLUMN};
 
         return true;
     }
@@ -1532,31 +1402,22 @@ public:
 private:
     size_t getNumberOfArguments() const override { return 3; }
 
+    bool useDefaultImplementationForConstants() const final { return true; }
+    ColumnNumbers getArgumentsThatAreAlwaysConstant() const final { return {0}; }
+
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
         if (!arguments[0]->isString())
-        {
-            throw Exception{
-                "Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
-                    + ", expected a string.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[0]->getName() + " of first argument of function " + getName()
+                + ", expected a string.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!checkDataType<DataTypeUInt64>(arguments[1].get()))
-        {
-            throw Exception{
-                "Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
-                    + ", must be UInt64.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[1]->getName() + " of second argument of function " + getName()
+                + ", must be UInt64.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         if (!checkDataType<DataTypeUInt64>(arguments[2].get()))
-        {
-            throw Exception{
-                "Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
-                    + ", must be UInt64.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
-        }
+            throw Exception{"Illegal type " + arguments[2]->getName() + " of third argument of function " + getName()
+                + ", must be UInt64.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeUInt8>();
     }
@@ -1567,9 +1428,14 @@ private:
     {
         const auto dict_name_col = checkAndGetColumnConst<ColumnString>(block.getByPosition(arguments[0]).column.get());
         if (!dict_name_col)
-            throw Exception{
-                "First argument of function " + getName() + " must be a constant string",
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"First argument of function " + getName() + " must be a constant string", ErrorCodes::ILLEGAL_COLUMN};
+
+        if (block.rows() == 0)
+        {
+            auto & elem = block.getByPosition(result);
+            elem.column = elem.type->createColumn();
+            return;
+        }
 
         auto dict = dictionaries.getDictionary(dict_name_col->getValue<String>());
         const auto dict_ptr = dict.get();
@@ -1577,9 +1443,7 @@ private:
         if (!executeDispatch<FlatDictionary>(block, arguments, result, dict_ptr)
             && !executeDispatch<HashedDictionary>(block, arguments, result, dict_ptr)
             && !executeDispatch<CacheDictionary>(block, arguments, result, dict_ptr))
-            throw Exception{
-                "Unsupported dictionary type " + dict_ptr->getTypeName(),
-                ErrorCodes::UNKNOWN_TYPE};
+            throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE};
     }
 
     template <typename DictionaryType>
@@ -1591,9 +1455,7 @@ private:
             return false;
 
         if (!dict->hasHierarchy())
-            throw Exception{
-                "Dictionary does not have a hierarchy",
-                ErrorCodes::UNSUPPORTED_METHOD};
+            throw Exception{"Dictionary does not have a hierarchy", ErrorCodes::UNSUPPORTED_METHOD};
 
         const auto child_id_col_untyped = block.getByPosition(arguments[1]).column.get();
         const auto ancestor_id_col_untyped = block.getByPosition(arguments[2]).column.get();
@@ -1603,10 +1465,8 @@ private:
         else if (const auto child_id_col = checkAndGetColumnConst<ColumnVector<UInt64>>(child_id_col_untyped))
             execute(block, result, dict, child_id_col, ancestor_id_col_untyped);
         else
-            throw Exception{
-                "Illegal column " + child_id_col_untyped->getName()
-                    + " of second argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Illegal column " + child_id_col_untyped->getName()
+                + " of second argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN};
 
         return true;
     }
@@ -1643,10 +1503,8 @@ private:
         }
         else
         {
-            throw Exception{
-                "Illegal column " + ancestor_id_col_untyped->getName()
-                    + " of third argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN};
+            throw Exception{"Illegal column " + ancestor_id_col_untyped->getName()
+                + " of third argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN};
         }
 
         return true;
@@ -1679,12 +1537,8 @@ private:
             block.getByPosition(result).column = DataTypeUInt8().createColumnConst(child_id_col->size(), UInt64(res));
         }
         else
-        {
-            throw Exception{
-                "Illegal column " + ancestor_id_col_untyped->getName()
-                    + " of third argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN};
-        }
+            throw Exception{"Illegal column " + ancestor_id_col_untyped->getName()
+                + " of third argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN};
 
         return true;
     }
diff --git a/dbms/src/Functions/FunctionsMiscellaneous.cpp b/dbms/src/Functions/FunctionsMiscellaneous.cpp
index 99ed8b2dda6..475fd47ce6f 100644
--- a/dbms/src/Functions/FunctionsMiscellaneous.cpp
+++ b/dbms/src/Functions/FunctionsMiscellaneous.cpp
@@ -1750,9 +1750,8 @@ void FunctionHasColumnInTable::executeImpl(Block & block, const ColumnNumbers &
     {
         std::vector<std::vector<String>> host_names = {{ host_name }};
         auto cluster = std::make_shared<Cluster>(global_context.getSettings(), host_names, !user_name.empty() ? user_name : "default", password, global_context.getTCPPort(), false);
-        auto names_and_types_list = getStructureOfRemoteTable(*cluster, database_name, table_name, global_context);
-        const auto & names = names_and_types_list.getNames();
-        has_column = std::find(names.begin(), names.end(), column_name) != names.end();
+        auto remote_columns = getStructureOfRemoteTable(*cluster, database_name, table_name, global_context);
+        has_column = remote_columns.hasPhysical(column_name);
     }
 
     block.getByPosition(result).column = DataTypeUInt8().createColumnConst(block.rows(), UInt64(has_column));
diff --git a/dbms/src/Functions/IFunction.cpp b/dbms/src/Functions/IFunction.cpp
index 81ada906a8d..ba05bc34e9d 100644
--- a/dbms/src/Functions/IFunction.cpp
+++ b/dbms/src/Functions/IFunction.cpp
@@ -15,7 +15,8 @@ namespace DB
 
 namespace ErrorCodes
 {
-extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int ILLEGAL_COLUMN;
 }
 
 namespace
@@ -127,7 +128,7 @@ NullPresence getNullPresense(const ColumnsWithTypeAndName & args)
 bool allArgumentsAreConstants(const Block & block, const ColumnNumbers & args)
 {
     for (auto arg : args)
-        if (!typeid_cast<const ColumnConst *>(block.getByPosition(arg).column.get()))
+        if (!block.getByPosition(arg).column->isColumnConst())
             return false;
     return true;
 }
@@ -135,11 +136,16 @@ bool allArgumentsAreConstants(const Block & block, const ColumnNumbers & args)
 
 bool PreparedFunctionImpl::defaultImplementationForConstantArguments(Block & block, const ColumnNumbers & args, size_t result)
 {
+    ColumnNumbers arguments_to_remain_constants = getArgumentsThatAreAlwaysConstant();
+
+    /// Check that these arguments are really constant.
+    for (auto arg_num : arguments_to_remain_constants)
+        if (arg_num < args.size() && !block.getByPosition(args[arg_num]).column->isColumnConst())
+            throw Exception("Argument at index " + toString(arg_num) + " for function " + getName() + " must be constant", ErrorCodes::ILLEGAL_COLUMN);
+
     if (args.empty() || !useDefaultImplementationForConstants() || !allArgumentsAreConstants(block, args))
         return false;
 
-    ColumnNumbers arguments_to_remain_constants = getArgumentsThatAreAlwaysConstant();
-
     Block temporary_block;
     bool have_converted_columns = false;
 
@@ -162,7 +168,7 @@ bool PreparedFunctionImpl::defaultImplementationForConstantArguments(Block & blo
       */
     if (!have_converted_columns)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: the function requires more arguments",
-                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
     temporary_block.insert(block.getByPosition(result));
 
diff --git a/dbms/src/IO/ReadBufferAIO.cpp b/dbms/src/IO/ReadBufferAIO.cpp
index c4680b0e409..b9f760b51da 100644
--- a/dbms/src/IO/ReadBufferAIO.cpp
+++ b/dbms/src/IO/ReadBufferAIO.cpp
@@ -1,4 +1,4 @@
-#if !(defined(__FreeBSD__) || defined(__APPLE__))
+#if !(defined(__FreeBSD__) || defined(__APPLE__) || defined(_MSC_VER))
 
 #include <IO/ReadBufferAIO.h>
 #include <Common/ProfileEvents.h>
diff --git a/dbms/src/IO/ReadBufferAIO.h b/dbms/src/IO/ReadBufferAIO.h
index ccbd7330851..9f8451338ac 100644
--- a/dbms/src/IO/ReadBufferAIO.h
+++ b/dbms/src/IO/ReadBufferAIO.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#if !(defined(__FreeBSD__) || defined(__APPLE__))
+#if !(defined(__FreeBSD__) || defined(__APPLE__) || defined(_MSC_VER))
 
 #include <IO/ReadBufferFromFileBase.h>
 #include <IO/ReadBuffer.h>
@@ -8,7 +8,6 @@
 #include <Core/Defines.h>
 #include <Common/AIO.h>
 #include <Common/CurrentMetrics.h>
-
 #include <string>
 #include <limits>
 #include <unistd.h>
diff --git a/dbms/src/IO/ReadBufferFromFileDescriptor.cpp b/dbms/src/IO/ReadBufferFromFileDescriptor.cpp
index eced314ff40..d2acffaf2e7 100644
--- a/dbms/src/IO/ReadBufferFromFileDescriptor.cpp
+++ b/dbms/src/IO/ReadBufferFromFileDescriptor.cpp
@@ -1,14 +1,10 @@
 #include <errno.h>
 #include <time.h>
-
 #include <optional>
-
 #include <Common/ProfileEvents.h>
 #include <Common/Stopwatch.h>
-
 #include <Common/Exception.h>
 #include <Common/CurrentMetrics.h>
-
 #include <IO/ReadBufferFromFileDescriptor.h>
 #include <IO/WriteHelpers.h>
 
diff --git a/dbms/src/IO/ReadBufferFromFileDescriptor.h b/dbms/src/IO/ReadBufferFromFileDescriptor.h
index 1331878912e..55065931148 100644
--- a/dbms/src/IO/ReadBufferFromFileDescriptor.h
+++ b/dbms/src/IO/ReadBufferFromFileDescriptor.h
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <unistd.h>
-
+#include <port/unistd.h>
 #include <IO/ReadBufferFromFileBase.h>
 #include <IO/ReadBuffer.h>
 
diff --git a/dbms/src/IO/ReadHelpers.h b/dbms/src/IO/ReadHelpers.h
index 875515149b6..2d3b405675f 100644
--- a/dbms/src/IO/ReadHelpers.h
+++ b/dbms/src/IO/ReadHelpers.h
@@ -52,6 +52,8 @@ inline char parseEscapeSequence(char c)
             return '\a';
         case 'b':
             return '\b';
+        case 'e':
+            return '\x1B';      /// \e escape sequence is non standard for C and C++ but supported by gcc and clang.
         case 'f':
             return '\f';
         case 'n':
diff --git a/dbms/src/IO/WriteBufferAIO.cpp b/dbms/src/IO/WriteBufferAIO.cpp
index ae1253df263..087717b452d 100644
--- a/dbms/src/IO/WriteBufferAIO.cpp
+++ b/dbms/src/IO/WriteBufferAIO.cpp
@@ -1,4 +1,4 @@
-#if !(defined(__FreeBSD__) || defined(__APPLE__))
+#if !(defined(__FreeBSD__) || defined(__APPLE__) || defined(_MSC_VER))
 
 #include <IO/WriteBufferAIO.h>
 #include <Common/ProfileEvents.h>
diff --git a/dbms/src/IO/WriteBufferAIO.h b/dbms/src/IO/WriteBufferAIO.h
index 0942934e87d..3c99eb40eed 100644
--- a/dbms/src/IO/WriteBufferAIO.h
+++ b/dbms/src/IO/WriteBufferAIO.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#if !(defined(__FreeBSD__) || defined(__APPLE__))
+#if !(defined(__FreeBSD__) || defined(__APPLE__) || defined(_MSC_VER))
 
 #include <IO/WriteBufferFromFileBase.h>
 #include <IO/WriteBuffer.h>
diff --git a/dbms/src/IO/WriteBufferFromFileDescriptor.cpp b/dbms/src/IO/WriteBufferFromFileDescriptor.cpp
index 8f6f2b1b126..d22fe7229b8 100644
--- a/dbms/src/IO/WriteBufferFromFileDescriptor.cpp
+++ b/dbms/src/IO/WriteBufferFromFileDescriptor.cpp
@@ -1,4 +1,4 @@
-#include <unistd.h>
+#include <port/unistd.h>
 #include <errno.h>
 
 #include <Common/Exception.h>
diff --git a/dbms/src/IO/createReadBufferFromFileBase.cpp b/dbms/src/IO/createReadBufferFromFileBase.cpp
index bae7a737d36..beb73eda861 100644
--- a/dbms/src/IO/createReadBufferFromFileBase.cpp
+++ b/dbms/src/IO/createReadBufferFromFileBase.cpp
@@ -1,6 +1,6 @@
 #include <IO/createReadBufferFromFileBase.h>
 #include <IO/ReadBufferFromFile.h>
-#if !defined(__APPLE__) && !defined(__FreeBSD__)
+#if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(_MSC_VER)
 #include <IO/ReadBufferAIO.h>
 #endif
 #include <Common/ProfileEvents.h>
@@ -14,7 +14,7 @@ namespace ProfileEvents
 
 namespace DB
 {
-#if defined(__APPLE__) || defined(__FreeBSD__)
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_MSC_VER)
 namespace ErrorCodes
 {
         extern const int NOT_IMPLEMENTED;
@@ -31,7 +31,7 @@ std::unique_ptr<ReadBufferFromFileBase> createReadBufferFromFileBase(const std::
     }
     else
     {
-#if !defined(__APPLE__) && !defined(__FreeBSD__)
+#if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(_MSC_VER)
         ProfileEvents::increment(ProfileEvents::CreatedReadBufferAIO);
         return std::make_unique<ReadBufferAIO>(filename_, buffer_size_, flags_, existing_memory_);
 #else
diff --git a/dbms/src/IO/createWriteBufferFromFileBase.cpp b/dbms/src/IO/createWriteBufferFromFileBase.cpp
index 94d16d1d41b..de06e2eb1cb 100644
--- a/dbms/src/IO/createWriteBufferFromFileBase.cpp
+++ b/dbms/src/IO/createWriteBufferFromFileBase.cpp
@@ -1,6 +1,6 @@
 #include <IO/createWriteBufferFromFileBase.h>
 #include <IO/WriteBufferFromFile.h>
-#if !defined(__APPLE__) && !defined(__FreeBSD__)
+#if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(_MSC_VER)
 #include <IO/WriteBufferAIO.h>
 #endif
 #include <Common/ProfileEvents.h>
@@ -15,7 +15,7 @@ namespace ProfileEvents
 namespace DB
 {
 
-#if defined(__APPLE__) || defined(__FreeBSD__)
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_MSC_VER)
 namespace ErrorCodes
 {
         extern const int NOT_IMPLEMENTED;
@@ -33,7 +33,7 @@ WriteBufferFromFileBase * createWriteBufferFromFileBase(const std::string & file
     }
     else
     {
-#if !defined(__APPLE__) && !defined(__FreeBSD__)
+#if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(_MSC_VER)
         ProfileEvents::increment(ProfileEvents::CreatedWriteBufferAIO);
         return new WriteBufferAIO(filename_, buffer_size_, flags_, mode, existing_memory_);
 #else
diff --git a/dbms/src/IO/tests/read_buffer_aio.cpp b/dbms/src/IO/tests/read_buffer_aio.cpp
index b6352d7a54a..2f641d0cd3c 100644
--- a/dbms/src/IO/tests/read_buffer_aio.cpp
+++ b/dbms/src/IO/tests/read_buffer_aio.cpp
@@ -1,14 +1,13 @@
 #include <IO/ReadBufferAIO.h>
 #include <Core/Defines.h>
-
 #include <boost/filesystem.hpp>
-
 #include <vector>
 #include <iostream>
 #include <fstream>
 #include <functional>
 #include <cstdlib>
-#include <unistd.h>
+#include <port/unistd.h>
+
 
 namespace
 {
diff --git a/dbms/src/Interpreters/ClientInfo.cpp b/dbms/src/Interpreters/ClientInfo.cpp
index 40ebabc60df..06fd5e9c589 100644
--- a/dbms/src/Interpreters/ClientInfo.cpp
+++ b/dbms/src/Interpreters/ClientInfo.cpp
@@ -1,5 +1,3 @@
-#include <unistd.h>
-
 #include <Interpreters/ClientInfo.h>
 #include <IO/ReadBuffer.h>
 #include <IO/WriteBuffer.h>
@@ -8,6 +6,7 @@
 #include <Core/Defines.h>
 #include <Common/getFQDNOrHostName.h>
 #include <Common/ClickHouseRevision.h>
+#include <port/unistd.h>
 
 
 namespace DB
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index 6fddcbc2f05..8fe51bf5c08 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -130,7 +130,7 @@ struct ContextShared
     ConfigurationPtr users_config;                          /// Config with the users, profiles and quotas sections.
     InterserverIOHandler interserver_io_handler;            /// Handler for interserver communication.
     BackgroundProcessingPoolPtr background_pool;            /// The thread pool for the background work performed by the tables.
-    Macros macros;                                          /// Substitutions extracted from config.
+    MultiVersion<Macros> macros;                            /// Substitutions extracted from config.
     std::unique_ptr<Compiler> compiler;                     /// Used for dynamic compilation of queries' parts if it necessary.
     std::shared_ptr<DDLWorker> ddl_worker;                  /// Process ddl commands from zk.
     /// Rules for selecting the compression settings, depending on the size of the part.
@@ -185,6 +185,8 @@ struct ContextShared
 
     pcg64 rng{randomSeed()};
 
+    Context::ConfigReloadCallback config_reload_callback;
+
     ContextShared(std::shared_ptr<IRuntimeComponentsFactory> runtime_components_factory_)
         : runtime_components_factory(std::move(runtime_components_factory_))
     {
@@ -1042,15 +1044,14 @@ void Context::setDefaultFormat(const String & name)
     default_format = name;
 }
 
-const Macros & Context::getMacros() const
+MultiVersion<Macros>::Version Context::getMacros() const
 {
-    return shared->macros;
+    return shared->macros.get();
 }
 
-void Context::setMacros(Macros && macros)
+void Context::setMacros(std::unique_ptr<Macros> && macros)
 {
-    /// We assume that this assignment occurs once when the server starts. If this is not the case, you need to use a mutex.
-    shared->macros = macros;
+    shared->macros.set(std::move(macros));
 }
 
 const Context & Context::getQueryContext() const
@@ -1622,6 +1623,22 @@ time_t Context::getUptimeSeconds() const
 }
 
 
+void Context::setConfigReloadCallback(ConfigReloadCallback && callback)
+{
+    /// Is initialized at server startup, so lock isn't required. Otherwise use mutex.
+    shared->config_reload_callback = std::move(callback);
+}
+
+void Context::reloadConfig() const
+{
+    /// Use mutex if callback may be changed after startup.
+    if (!shared->config_reload_callback)
+        throw Exception("Can't reload config beacuse config_reload_callback is not set.", ErrorCodes::LOGICAL_ERROR);
+
+    shared->config_reload_callback();
+}
+
+
 void Context::shutdown()
 {
     system_logs.reset();
diff --git a/dbms/src/Interpreters/Context.h b/dbms/src/Interpreters/Context.h
index bab3be07add..4f714842b62 100644
--- a/dbms/src/Interpreters/Context.h
+++ b/dbms/src/Interpreters/Context.h
@@ -7,6 +7,7 @@
 #include <mutex>
 #include <thread>
 
+#include <common/MultiVersion.h>
 #include <Core/Types.h>
 #include <Core/NamesAndTypes.h>
 #include <Interpreters/Settings.h>
@@ -80,7 +81,6 @@ using Dependencies = std::vector<DatabaseAndTableName>;
 using TableAndCreateAST = std::pair<StoragePtr, ASTPtr>;
 using TableAndCreateASTs = std::map<String, TableAndCreateAST>;
 
-
 /** A set of known objects that can be used in the query.
   * Consists of a shared part (always common to all sessions and queries)
   *  and copied part (which can be its own for each session or query).
@@ -206,8 +206,8 @@ public:
     String getDefaultFormat() const;    /// If default_format is not specified, some global default format is returned.
     void setDefaultFormat(const String & name);
 
-    const Macros & getMacros() const;
-    void setMacros(Macros && macros);
+    MultiVersion<Macros>::Version getMacros() const;
+    void setMacros(std::unique_ptr<Macros> && macros);
 
     Settings getSettings() const;
     void setSettings(const Settings & settings_);
@@ -360,6 +360,10 @@ public:
     /// Get the server uptime in seconds.
     time_t getUptimeSeconds() const;
 
+    using ConfigReloadCallback = std::function<void()>;
+    void setConfigReloadCallback(ConfigReloadCallback && callback);
+    void reloadConfig() const;
+
     void shutdown();
 
     enum class ApplicationType
diff --git a/dbms/src/Interpreters/DDLWorker.cpp b/dbms/src/Interpreters/DDLWorker.cpp
index 30cccb5d848..7deabb7872e 100644
--- a/dbms/src/Interpreters/DDLWorker.cpp
+++ b/dbms/src/Interpreters/DDLWorker.cpp
@@ -600,8 +600,8 @@ void DDLWorker::processTask(DDLTask & task)
 
     /// Delete active flag and create finish flag
     zkutil::Ops ops;
-    ops.emplace_back(std::make_unique<zkutil::Op::Remove>(active_node_path, -1));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(finished_node_path, task.execution_status.serializeText(),
+    ops.emplace_back(std::make_shared<zkutil::Op::Remove>(active_node_path, -1));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(finished_node_path, task.execution_status.serializeText(),
                                                           zookeeper->getDefaultACL(), zkutil::CreateMode::Persistent));
     zookeeper->multi(ops);
 }
@@ -780,8 +780,8 @@ void DDLWorker::cleanupQueue()
 
                 /// Remove the lock node and its parent atomically
                 zkutil::Ops ops;
-                ops.emplace_back(std::make_unique<zkutil::Op::Remove>(lock_path, -1));
-                ops.emplace_back(std::make_unique<zkutil::Op::Remove>(node_path, -1));
+                ops.emplace_back(std::make_shared<zkutil::Op::Remove>(lock_path, -1));
+                ops.emplace_back(std::make_shared<zkutil::Op::Remove>(node_path, -1));
                 zookeeper->multi(ops);
 
                 lock->unlockAssumeLockNodeRemovedManually();
@@ -800,8 +800,8 @@ void DDLWorker::createStatusDirs(const std::string & node_path)
 {
     zkutil::Ops ops;
     auto acl = zookeeper->getDefaultACL();
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(node_path + "/active", "", acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(node_path + "/finished", "", acl, zkutil::CreateMode::Persistent));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(node_path + "/active", "", acl, zkutil::CreateMode::Persistent));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(node_path + "/finished", "", acl, zkutil::CreateMode::Persistent));
 
     int code = zookeeper->tryMulti(ops);
     if (code != ZOK && code != ZNODEEXISTS)
@@ -1132,7 +1132,7 @@ BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, const Context & cont
         }
     }
 
-    query->cluster = context.getMacros().expand(query->cluster);
+    query->cluster = context.getMacros()->expand(query->cluster);
     ClusterPtr cluster = context.getCluster(query->cluster);
     DDLWorker & ddl_worker = context.getDDLWorker();
 
diff --git a/dbms/src/Interpreters/EmbeddedDictionaries.cpp b/dbms/src/Interpreters/EmbeddedDictionaries.cpp
index f5567e0a1bc..441bb7c92d8 100644
--- a/dbms/src/Interpreters/EmbeddedDictionaries.cpp
+++ b/dbms/src/Interpreters/EmbeddedDictionaries.cpp
@@ -49,7 +49,7 @@ bool EmbeddedDictionaries::reloadDictionary(
         {
             auto new_dictionary = reload_dictionary(config);
             if (new_dictionary)
-                dictionary.set(new_dictionary.release());
+                dictionary.set(std::move(new_dictionary));
         }
         catch (...)
         {
diff --git a/dbms/src/Interpreters/ExpressionAnalyzer.cpp b/dbms/src/Interpreters/ExpressionAnalyzer.cpp
index c3c663d59ad..500e4cd775d 100644
--- a/dbms/src/Interpreters/ExpressionAnalyzer.cpp
+++ b/dbms/src/Interpreters/ExpressionAnalyzer.cpp
@@ -190,7 +190,7 @@ ExpressionAnalyzer::ExpressionAnalyzer(
     }
 
     if (storage && source_columns.empty())
-        source_columns = storage->getSampleBlock().getNamesAndTypesList();
+        source_columns = storage->getColumns().getAllPhysical();
     else
         removeDuplicateColumns(source_columns);
 
@@ -712,7 +712,7 @@ static std::shared_ptr<InterpreterSelectWithUnionQuery> interpretSubquery(
         /// get columns list for target table
         auto database_table = getDatabaseAndTableNameFromIdentifier(*table);
         const auto & storage = context.getTable(database_table.first, database_table.second);
-        const auto & columns = storage->getColumnsListNonMaterialized();
+        const auto & columns = storage->getColumns().ordinary;
         select_expression_list->children.reserve(columns.size());
 
         /// manually substitute column names in place of asterisk
@@ -826,7 +826,7 @@ void ExpressionAnalyzer::addExternalStorage(ASTPtr & subquery_or_table_name_or_t
     Block sample = interpreter->getSampleBlock();
     NamesAndTypesList columns = sample.getNamesAndTypesList();
 
-    StoragePtr external_storage = StorageMemory::create(external_table_name, columns, NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{});
+    StoragePtr external_storage = StorageMemory::create(external_table_name, ColumnsDescription{columns});
     external_storage->startup();
 
     /** We replace the subquery with the name of the temporary table.
@@ -980,7 +980,8 @@ void ExpressionAnalyzer::normalizeTreeImpl(
         /// `IN t` can be specified, where t is a table, which is equivalent to `IN (SELECT * FROM t)`.
         if (functionIsInOrGlobalInOperator(func_node->name))
             if (ASTIdentifier * right = typeid_cast<ASTIdentifier *>(func_node->arguments->children.at(1).get()))
-                right->kind = ASTIdentifier::Table;
+                if (!aliases.count(right->name))
+                    right->kind = ASTIdentifier::Table;
 
         /// Special cases for count function.
         String func_name_lowercase = Poco::toLower(func_node->name);
@@ -1050,7 +1051,7 @@ void ExpressionAnalyzer::normalizeTreeImpl(
                 if (storage)
                 {
                     /// If we select from a table, get only not MATERIALIZED, not ALIAS columns.
-                    for (const auto & name_type : storage->getColumnsListNonMaterialized())
+                    for (const auto & name_type : storage->getColumns().ordinary)
                         all_columns.emplace_back(std::make_shared<ASTIdentifier>(name_type.name));
                 }
                 else
@@ -1147,7 +1148,8 @@ void ExpressionAnalyzer::addAliasColumns()
     if (!storage)
         return;
 
-    source_columns.insert(std::end(source_columns), std::begin(storage->alias_columns), std::end(storage->alias_columns));
+    const auto & aliases = storage->getColumns().aliases;
+    source_columns.insert(std::end(source_columns), std::begin(aliases), std::end(aliases));
 }
 
 
@@ -1456,8 +1458,13 @@ void ExpressionAnalyzer::optimizeLimitBy()
 
 void ExpressionAnalyzer::makeSetsForIndex()
 {
-    if (storage && ast && storage->supportsIndexForIn())
-        makeSetsForIndexImpl(ast, storage->getSampleBlock());
+    if (storage && select_query && storage->supportsIndexForIn())
+    {
+        if (select_query->where_expression)
+            makeSetsForIndexImpl(select_query->where_expression, storage->getSampleBlock());
+        if (select_query->prewhere_expression)
+            makeSetsForIndexImpl(select_query->prewhere_expression, storage->getSampleBlock());
+    }
 }
 
 
@@ -1482,40 +1489,42 @@ void ExpressionAnalyzer::makeSetsForIndexImpl(const ASTPtr & node, const Block &
 {
     for (auto & child : node->children)
     {
-        /// Process expression only in current subquery
-        if (!typeid_cast<ASTSubquery *>(child.get()))
-            makeSetsForIndexImpl(child, sample_block);
+        /// Don't descent into subqueries.
+        if (typeid_cast<ASTSubquery *>(child.get()))
+            continue;
+
+        /// Don't dive into lambda functions
+        const ASTFunction * func = typeid_cast<const ASTFunction *>(child.get());
+        if (func && func->name == "lambda")
+            continue;
+
+        makeSetsForIndexImpl(child, sample_block);
     }
 
     const ASTFunction * func = typeid_cast<const ASTFunction *>(node.get());
     if (func && functionIsInOperator(func->name))
     {
         const IAST & args = *func->arguments;
-        const ASTPtr & arg = args.children.at(1);
 
-        if (!prepared_sets.count(arg.get())) /// Not already prepared.
+        if (storage && storage->mayBenefitFromIndexForIn(args.children.at(0)))
         {
-            if (typeid_cast<ASTSubquery *>(arg.get()) || typeid_cast<ASTIdentifier *>(arg.get()))
+            const ASTPtr & arg = args.children.at(1);
+
+            if (!prepared_sets.count(arg.get())) /// Not already prepared.
             {
-                if (settings.use_index_for_in_with_subqueries && storage->mayBenefitFromIndexForIn(args.children.at(0)))
-                    tryMakeSetFromSubquery(arg);
-            }
-            else
-            {
-                try
+                if (typeid_cast<ASTSubquery *>(arg.get()) || typeid_cast<ASTIdentifier *>(arg.get()))
+                {
+                    if (settings.use_index_for_in_with_subqueries)
+                        tryMakeSetFromSubquery(arg);
+                }
+                else
                 {
                     ExpressionActionsPtr temp_actions = std::make_shared<ExpressionActions>(source_columns, settings);
                     getRootActions(func->arguments->children.at(0), true, false, temp_actions);
-                    makeExplicitSet(func, temp_actions->getSampleBlock(), true);
-                }
-                catch (const Exception & e)
-                {
-                    /// in `sample_block` there are no columns that are added by `getActions`
-                    if (e.code() != ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK && e.code() != ErrorCodes::UNKNOWN_IDENTIFIER)
-                        throw;
 
-                    /// TODO: Delete the catch in the next release
-                    tryLogCurrentException(&Poco::Logger::get("ExpressionAnalyzer"));
+                    Block sample_block_with_calculated_columns = temp_actions->getSampleBlock();
+                    if (sample_block_with_calculated_columns.has(args.children.at(0)->getColumnName()))
+                        makeExplicitSet(func, sample_block_with_calculated_columns, true);
                 }
             }
         }
@@ -1578,7 +1587,7 @@ void ExpressionAnalyzer::makeSet(const ASTFunction * node, const Block & sample_
           *   in the subquery_for_set object, this subquery is set as source and the temporary table _data1 as the table.
           * - this function shows the expression IN_data1.
           */
-        if (!subquery_for_set.source)
+        if (!subquery_for_set.source && (!storage || !storage->isRemote()))
         {
             auto interpreter = interpretSubquery(arg, context, subquery_depth, {});
             subquery_for_set.source = std::make_shared<LazyBlockInputStream>(
@@ -1645,15 +1654,7 @@ void ExpressionAnalyzer::makeExplicitSet(const ASTFunction * node, const Block &
     if (left_arg_tuple && left_arg_tuple->name == "tuple")
     {
         for (const auto & arg : left_arg_tuple->arguments->children)
-        {
-            const auto & data_type = sample_block.getByName(arg->getColumnName()).type;
-
-            /// NOTE prevent crash in query: SELECT (1, [1]) in (1, 1)
-            if (const auto array = typeid_cast<const DataTypeArray * >(data_type.get()))
-                throw Exception("Incorrect element of tuple: " + array->getName(), ErrorCodes::INCORRECT_ELEMENT_OF_SET);
-
-            set_element_types.push_back(data_type);
-        }
+            set_element_types.push_back(sample_block.getByName(arg->getColumnName()).type);
     }
     else
     {
diff --git a/dbms/src/Interpreters/InterpreterAlterQuery.cpp b/dbms/src/Interpreters/InterpreterAlterQuery.cpp
index f990fd8570f..f4708a67c3d 100644
--- a/dbms/src/Interpreters/InterpreterAlterQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterAlterQuery.cpp
@@ -110,7 +110,7 @@ void InterpreterAlterQuery::parseAlter(
             }
             if (ast_col_decl.default_expression)
             {
-                command.default_type = columnDefaultTypeFromString(ast_col_decl.default_specifier);
+                command.default_kind = columnDefaultKindFromString(ast_col_decl.default_specifier);
                 command.default_expression = ast_col_decl.default_expression;
             }
 
@@ -157,7 +157,7 @@ void InterpreterAlterQuery::parseAlter(
 
             if (ast_col_decl.default_expression)
             {
-                command.default_type = columnDefaultTypeFromString(ast_col_decl.default_specifier);
+                command.default_kind = columnDefaultKindFromString(ast_col_decl.default_specifier);
                 command.default_expression = ast_col_decl.default_expression;
             }
 
@@ -200,7 +200,7 @@ void InterpreterAlterQuery::PartitionCommands::validate(const IStorage * table)
         {
             String column_name = command.column_name.safeGet<String>();
 
-            if (!table->hasRealColumn(column_name))
+            if (!table->getColumns().hasPhysical(column_name))
             {
                 throw Exception("Wrong column name. Cannot find column " + column_name + " to clear it from partition",
                     DB::ErrorCodes::ILLEGAL_COLUMN);
diff --git a/dbms/src/Interpreters/InterpreterCreateQuery.cpp b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
index 2b6d333d1f6..3d70fc343b9 100644
--- a/dbms/src/Interpreters/InterpreterCreateQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
@@ -246,7 +246,7 @@ static ColumnsAndDefaults parseColumns(const ASTExpressionList & column_list_ast
                 explicit_type = block.getByName(column_name).type;
 
             defaults.emplace(column_name, ColumnDefault{
-                columnDefaultTypeFromString(col_decl_ptr->default_specifier),
+                columnDefaultKindFromString(col_decl_ptr->default_specifier),
                 col_decl_ptr->default_expression
             });
         }
@@ -256,7 +256,7 @@ static ColumnsAndDefaults parseColumns(const ASTExpressionList & column_list_ast
 }
 
 
-static NamesAndTypesList removeAndReturnColumns(ColumnsAndDefaults & columns_and_defaults, const ColumnDefaultType type)
+static NamesAndTypesList removeAndReturnColumns(ColumnsAndDefaults & columns_and_defaults, const ColumnDefaultKind kind)
 {
     auto & columns = columns_and_defaults.first;
     auto & defaults = columns_and_defaults.second;
@@ -266,7 +266,7 @@ static NamesAndTypesList removeAndReturnColumns(ColumnsAndDefaults & columns_and
     for (auto it = std::begin(columns); it != std::end(columns);)
     {
         const auto jt = defaults.find(it->name);
-        if (jt != std::end(defaults) && jt->second.type == type)
+        if (jt != std::end(defaults) && jt->second.kind == kind)
         {
             removed.push_back(*it);
             it = columns.erase(it);
@@ -301,15 +301,11 @@ ASTPtr InterpreterCreateQuery::formatColumns(const NamesAndTypesList & columns)
     return columns_list;
 }
 
-ASTPtr InterpreterCreateQuery::formatColumns(
-    const NamesAndTypesList & columns,
-    const NamesAndTypesList & materialized_columns,
-    const NamesAndTypesList & alias_columns,
-    const ColumnDefaults & column_defaults)
+ASTPtr InterpreterCreateQuery::formatColumns(const ColumnsDescription & columns)
 {
     auto columns_list = std::make_shared<ASTExpressionList>();
 
-    for (const auto & column : boost::join(columns, boost::join(materialized_columns, alias_columns)))
+    for (const auto & column : columns.getAll())
     {
         const auto column_declaration = std::make_shared<ASTColumnDeclaration>();
         ASTPtr column_declaration_ptr{column_declaration};
@@ -324,10 +320,10 @@ ASTPtr InterpreterCreateQuery::formatColumns(
         column_declaration->type = parseQuery(storage_p, pos, end, "data type");
         column_declaration->type->owned_string = type_name;
 
-        const auto it = column_defaults.find(column.name);
-        if (it != std::end(column_defaults))
+        const auto it = columns.defaults.find(column.name);
+        if (it != std::end(columns.defaults))
         {
-            column_declaration->default_specifier = toString(it->second.type);
+            column_declaration->default_specifier = toString(it->second.kind);
             column_declaration->default_expression = it->second.expression->clone();
         }
 
@@ -338,49 +334,46 @@ ASTPtr InterpreterCreateQuery::formatColumns(
 }
 
 
-InterpreterCreateQuery::ColumnsInfo InterpreterCreateQuery::getColumnsInfo(const ASTExpressionList & columns, const Context & context)
+ColumnsDescription InterpreterCreateQuery::getColumnsDescription(const ASTExpressionList & columns, const Context & context)
 {
-    ColumnsInfo res;
+    ColumnsDescription res;
 
     auto && columns_and_defaults = parseColumns(columns, context);
-    res.materialized_columns = removeAndReturnColumns(columns_and_defaults, ColumnDefaultType::Materialized);
-    res.alias_columns = removeAndReturnColumns(columns_and_defaults, ColumnDefaultType::Alias);
-    res.columns = std::move(columns_and_defaults.first);
-    res.column_defaults = std::move(columns_and_defaults.second);
+    res.materialized = removeAndReturnColumns(columns_and_defaults, ColumnDefaultKind::Materialized);
+    res.aliases = removeAndReturnColumns(columns_and_defaults, ColumnDefaultKind::Alias);
+    res.ordinary = std::move(columns_and_defaults.first);
+    res.defaults = std::move(columns_and_defaults.second);
 
-    if (res.columns.size() + res.materialized_columns.size() == 0)
+    if (res.ordinary.size() + res.materialized.size() == 0)
         throw Exception{"Cannot CREATE table without physical columns", ErrorCodes::EMPTY_LIST_OF_COLUMNS_PASSED};
 
     return res;
 }
 
 
-InterpreterCreateQuery::ColumnsInfo InterpreterCreateQuery::setColumns(
+ColumnsDescription InterpreterCreateQuery::setColumns(
     ASTCreateQuery & create, const Block & as_select_sample, const StoragePtr & as_storage) const
 {
-    ColumnsInfo res;
+    ColumnsDescription res;
 
     if (create.columns)
     {
-        res = getColumnsInfo(*create.columns, context);
+        res = getColumnsDescription(*create.columns, context);
     }
     else if (!create.as_table.empty())
     {
-        res.columns = as_storage->getColumnsListNonMaterialized();
-        res.materialized_columns = as_storage->materialized_columns;
-        res.alias_columns = as_storage->alias_columns;
-        res.column_defaults = as_storage->column_defaults;
+        res = as_storage->getColumns();
     }
     else if (create.select)
     {
         for (size_t i = 0; i < as_select_sample.columns(); ++i)
-            res.columns.emplace_back(as_select_sample.safeGetByPosition(i).name, as_select_sample.safeGetByPosition(i).type);
+            res.ordinary.emplace_back(as_select_sample.safeGetByPosition(i).name, as_select_sample.safeGetByPosition(i).type);
     }
     else
         throw Exception("Incorrect CREATE query: required list of column descriptions or AS section or SELECT.", ErrorCodes::INCORRECT_QUERY);
 
     /// Even if query has list of columns, canonicalize it (unfold Nested columns).
-    ASTPtr new_columns = formatColumns(res.columns, res.materialized_columns, res.alias_columns, res.column_defaults);
+    ASTPtr new_columns = formatColumns(res);
     if (create.columns)
         create.replace(create.columns, new_columns);
     else
@@ -394,11 +387,11 @@ InterpreterCreateQuery::ColumnsInfo InterpreterCreateQuery::setColumns(
             throw Exception("Column " + backQuoteIfNeed(column_name_and_type.name) + " already exists", ErrorCodes::DUPLICATE_COLUMN);
     };
 
-    for (const auto & elem : res.columns)
+    for (const auto & elem : res.ordinary)
         check_column_already_exists(elem);
-    for (const auto & elem : res.materialized_columns)
+    for (const auto & elem : res.materialized)
         check_column_already_exists(elem);
-    for (const auto & elem : res.alias_columns)
+    for (const auto & elem : res.aliases)
         check_column_already_exists(elem);
 
     return res;
@@ -489,7 +482,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
     }
 
     /// Set and retrieve list of columns.
-    ColumnsInfo columns = setColumns(create, as_select_sample, as_storage);
+    ColumnsDescription columns = setColumns(create, as_select_sample, as_storage);
 
     /// Set the table engine if it was not specified explicitly.
     setEngine(create);
@@ -523,17 +516,16 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
                     throw Exception("Table " + database_name + "." + table_name + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS);
             }
         }
-
+        else if (context.tryGetExternalTable(table_name) && create.if_not_exists)
+             return {};
+             
         res = StorageFactory::instance().get(create,
             data_path,
             table_name,
             database_name,
             context,
             context.getGlobalContext(),
-            columns.columns,
-            columns.materialized_columns,
-            columns.alias_columns,
-            columns.column_defaults,
+            columns,
             create.attach,
             false);
 
diff --git a/dbms/src/Interpreters/InterpreterCreateQuery.h b/dbms/src/Interpreters/InterpreterCreateQuery.h
index b72b7eb7d09..8bec93a0fdc 100644
--- a/dbms/src/Interpreters/InterpreterCreateQuery.h
+++ b/dbms/src/Interpreters/InterpreterCreateQuery.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Interpreters/IInterpreter.h>
-#include <Storages/ColumnDefault.h>
+#include <Storages/ColumnsDescription.h>
 
 
 class ThreadPool;
@@ -27,11 +27,7 @@ public:
 
     /// List of columns and their types in AST.
     static ASTPtr formatColumns(const NamesAndTypesList & columns);
-    static ASTPtr formatColumns(
-        const NamesAndTypesList & columns,
-        const NamesAndTypesList & materialized_columns,
-        const NamesAndTypesList & alias_columns,
-        const ColumnDefaults & column_defaults);
+    static ASTPtr formatColumns(const ColumnsDescription & columns);
 
     void setDatabaseLoadingThreadpool(ThreadPool & thread_pool_)
     {
@@ -48,23 +44,15 @@ public:
         internal = internal_;
     }
 
-    struct ColumnsInfo
-    {
-        NamesAndTypesList columns;
-        NamesAndTypesList materialized_columns;
-        NamesAndTypesList alias_columns;
-        ColumnDefaults column_defaults;
-    };
-
     /// Obtain information about columns, their types and default values, for case when columns in CREATE query is specified explicitly.
-    static ColumnsInfo getColumnsInfo(const ASTExpressionList & columns, const Context & context);
+    static ColumnsDescription getColumnsDescription(const ASTExpressionList & columns, const Context & context);
 
 private:
     BlockIO createDatabase(ASTCreateQuery & create);
     BlockIO createTable(ASTCreateQuery & create);
 
     /// Calculate list of columns of table and return it.
-    ColumnsInfo setColumns(ASTCreateQuery & create, const Block & as_select_sample, const StoragePtr & as_storage) const;
+    ColumnsDescription setColumns(ASTCreateQuery & create, const Block & as_select_sample, const StoragePtr & as_storage) const;
     void setEngine(ASTCreateQuery & create) const;
     void checkAccess(const ASTCreateQuery & create);
 
diff --git a/dbms/src/Interpreters/InterpreterDescribeQuery.cpp b/dbms/src/Interpreters/InterpreterDescribeQuery.cpp
index 65b0fea25f1..536c554e996 100644
--- a/dbms/src/Interpreters/InterpreterDescribeQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterDescribeQuery.cpp
@@ -99,9 +99,8 @@ BlockInputStreamPtr InterpreterDescribeQuery::executeImpl()
         }
 
         auto table_lock = table->lockStructure(false, __PRETTY_FUNCTION__);
-        columns = table->getColumnsList();
-        columns.insert(std::end(columns), std::begin(table->alias_columns), std::end(table->alias_columns));
-        column_defaults = table->column_defaults;
+        columns = table->getColumns().getAll();
+        column_defaults = table->getColumns().defaults;
     }
 
     Block sample_block = getSampleBlock();
@@ -120,7 +119,7 @@ BlockInputStreamPtr InterpreterDescribeQuery::executeImpl()
         }
         else
         {
-            res_columns[2]->insert(toString(it->second.type));
+            res_columns[2]->insert(toString(it->second.kind));
             res_columns[3]->insert(queryToString(it->second.expression));
         }
     }
diff --git a/dbms/src/Interpreters/InterpreterInsertQuery.cpp b/dbms/src/Interpreters/InterpreterInsertQuery.cpp
index 9c2d5e1d7df..c1888371c1e 100644
--- a/dbms/src/Interpreters/InterpreterInsertQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterInsertQuery.cpp
@@ -95,7 +95,7 @@ BlockIO InterpreterInsertQuery::execute()
 
     auto table_lock = table->lockStructure(true, __PRETTY_FUNCTION__);
 
-    NamesAndTypesList required_columns = table->getColumnsList();
+    NamesAndTypesList required_columns = table->getColumns().getAllPhysical();
 
     /// We create a pipeline of several streams, into which we will write data.
     BlockOutputStreamPtr out;
@@ -103,7 +103,7 @@ BlockIO InterpreterInsertQuery::execute()
     out = std::make_shared<PushingToViewsBlockOutputStream>(query.database, query.table, table, context, query_ptr, query.no_destination);
 
     out = std::make_shared<AddingDefaultBlockOutputStream>(
-        out, getSampleBlock(query, table), required_columns, table->column_defaults, context);
+        out, getSampleBlock(query, table), required_columns, table->getColumns().defaults, context);
 
     /// Do not squash blocks if it is a sync INSERT into Distributed, since it lead to double bufferization on client and server side.
     /// Client-side bufferization might cause excessive timeouts (especially in case of big blocks).
@@ -136,7 +136,7 @@ BlockIO InterpreterInsertQuery::execute()
         if (!allow_materialized)
         {
             Block in_header = res.in->getHeader();
-            for (const auto & name_type : table->materialized_columns)
+            for (const auto & name_type : table->getColumns().materialized)
                 if (in_header.has(name_type.name))
                     throw Exception("Cannot insert column " + name_type.name + ", because it is MATERIALIZED column.", ErrorCodes::ILLEGAL_COLUMN);
         }
diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.cpp b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
index 1d5a442bb62..ec6b9395701 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
@@ -63,6 +63,7 @@ namespace ErrorCodes
     extern const int ILLEGAL_PREWHERE;
     extern const int TOO_MANY_COLUMNS;
     extern const int LOGICAL_ERROR;
+    extern const int NOT_IMPLEMENTED;
 }
 
 InterpreterSelectQuery::InterpreterSelectQuery(
@@ -338,6 +339,9 @@ void InterpreterSelectQuery::executeImpl(Pipeline & pipeline, const BlockInputSt
     /** Read the data from Storage. from_stage - to what stage the request was completed in Storage. */
     QueryProcessingStage::Enum from_stage = executeFetchColumns(pipeline, dry_run);
 
+    if (from_stage == QueryProcessingStage::WithMergeableState && to_stage == QueryProcessingStage::WithMergeableState)
+        throw Exception("Distributed on Distributed is not supported", ErrorCodes::NOT_IMPLEMENTED);
+
     if (!dry_run)
         LOG_TRACE(log, QueryProcessingStage::toString(from_stage) << " -> " << QueryProcessingStage::toString(to_stage));
 
@@ -516,12 +520,13 @@ QueryProcessingStage::Enum InterpreterSelectQuery::executeFetchColumns(Pipeline
     /// Are ALIAS columns required for query execution?
     auto alias_columns_required = false;
 
-    if (storage && !storage->alias_columns.empty())
+    if (storage && !storage->getColumns().aliases.empty())
     {
+        const auto & column_defaults = storage->getColumns().defaults;
         for (const auto & column : required_columns)
         {
-            const auto default_it = storage->column_defaults.find(column);
-            if (default_it != std::end(storage->column_defaults) && default_it->second.type == ColumnDefaultType::Alias)
+            const auto default_it = column_defaults.find(column);
+            if (default_it != std::end(column_defaults) && default_it->second.kind == ColumnDefaultKind::Alias)
             {
                 alias_columns_required = true;
                 break;
@@ -535,8 +540,8 @@ QueryProcessingStage::Enum InterpreterSelectQuery::executeFetchColumns(Pipeline
 
             for (const auto & column : required_columns)
             {
-                const auto default_it = storage->column_defaults.find(column);
-                if (default_it != std::end(storage->column_defaults) && default_it->second.type == ColumnDefaultType::Alias)
+                const auto default_it = column_defaults.find(column);
+                if (default_it != std::end(column_defaults) && default_it->second.kind == ColumnDefaultKind::Alias)
                     required_columns_expr_list->children.emplace_back(setAlias(default_it->second.expression->clone(), column));
                 else
                     required_columns_expr_list->children.emplace_back(std::make_shared<ASTIdentifier>(column));
diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.cpp b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
index 419a4937a72..ef8197f5ffb 100644
--- a/dbms/src/Interpreters/InterpreterSystemQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
@@ -97,6 +97,9 @@ BlockIO InterpreterSystemQuery::execute()
                 throw Exception(status.message, status.code);
             break;
         }
+        case Type::RELOAD_CONFIG:
+            context.reloadConfig();
+            break;
         case Type::STOP_LISTEN_QUERIES:
         case Type::START_LISTEN_QUERIES:
         case Type::RESTART_REPLICAS:
diff --git a/dbms/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp b/dbms/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp
index 0a67da3a5d8..e5c04025c59 100644
--- a/dbms/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp
+++ b/dbms/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp
@@ -38,7 +38,6 @@ public:
     std::string getRemoteTableName() const { return remote_table; }
 
     std::string getTableName() const override { return ""; }
-    const DB::NamesAndTypesList & getColumnsListImpl() const override { return names_and_types; }
 
 protected:
     StorageDistributedFake(const std::string & remote_database_, const std::string & remote_table_, size_t shard_count_)
@@ -50,7 +49,6 @@ private:
     const std::string remote_database;
     const std::string remote_table;
     size_t shard_count;
-    DB::NamesAndTypesList names_and_types;
 };
 
 
diff --git a/dbms/src/Interpreters/tests/users.cpp b/dbms/src/Interpreters/tests/users.cpp
index 5da4ed26134..f4905398262 100644
--- a/dbms/src/Interpreters/tests/users.cpp
+++ b/dbms/src/Interpreters/tests/users.cpp
@@ -1,8 +1,6 @@
 #include <Common/Config/ConfigProcessor.h>
 #include <Interpreters/SecurityManager.h>
-
 #include <boost/filesystem.hpp>
-
 #include <vector>
 #include <string>
 #include <tuple>
@@ -10,8 +8,8 @@
 #include <fstream>
 #include <sstream>
 #include <stdexcept>
-#include <unistd.h>
 #include <cstdlib>
+#include <port/unistd.h>
 
 namespace
 {
diff --git a/dbms/src/Parsers/ASTSystemQuery.cpp b/dbms/src/Parsers/ASTSystemQuery.cpp
index 9f6914e7f4c..a50a98f03d6 100644
--- a/dbms/src/Parsers/ASTSystemQuery.cpp
+++ b/dbms/src/Parsers/ASTSystemQuery.cpp
@@ -39,6 +39,8 @@ const char * ASTSystemQuery::typeToString(Type type)
             return "RELOAD DICTIONARY";
         case Type::RELOAD_DICTIONARIES:
             return "RELOAD DICTIONARIES";
+        case Type::RELOAD_CONFIG:
+            return "RELOAD CONFIG";
         case Type::STOP_MERGES:
             return "STOP MERGES";
         case Type::START_MERGES:
diff --git a/dbms/src/Parsers/ASTSystemQuery.h b/dbms/src/Parsers/ASTSystemQuery.h
index 1821b73bc12..87eaded44ef 100644
--- a/dbms/src/Parsers/ASTSystemQuery.h
+++ b/dbms/src/Parsers/ASTSystemQuery.h
@@ -24,6 +24,7 @@ public:
         SYNC_REPLICA,
         RELOAD_DICTIONARY,
         RELOAD_DICTIONARIES,
+        RELOAD_CONFIG,
         STOP_MERGES,
         START_MERGES,
         STOP_REPLICATION_QUEUES,
diff --git a/dbms/src/Server/Benchmark.cpp b/dbms/src/Server/Benchmark.cpp
index 78a19a398a1..ee4d2dd8802 100644
--- a/dbms/src/Server/Benchmark.cpp
+++ b/dbms/src/Server/Benchmark.cpp
@@ -1,31 +1,24 @@
-#include <unistd.h>
+#include <port/unistd.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <time.h>
-
 #include <iostream>
 #include <fstream>
 #include <iomanip>
 #include <random>
 #include <pcg_random.hpp>
-
 #include <Poco/File.h>
 #include <Poco/Util/Application.h>
-
 #include <Common/Stopwatch.h>
 #include <common/ThreadPool.h>
 #include <AggregateFunctions/ReservoirSampler.h>
 #include <AggregateFunctions/registerAggregateFunctions.h>
-
 #include <boost/program_options.hpp>
-
 #include <Common/ConcurrentBoundedQueue.h>
-
 #include <Common/Exception.h>
 #include <Common/randomSeed.h>
 #include <Core/Types.h>
-
 #include <IO/ReadBufferFromFileDescriptor.h>
 #include <IO/WriteBufferFromFileDescriptor.h>
 #include <IO/WriteBufferFromFile.h>
@@ -33,13 +26,9 @@
 #include <IO/WriteHelpers.h>
 #include <IO/Operators.h>
 #include <IO/ConnectionTimeouts.h>
-
 #include <DataStreams/RemoteBlockInputStream.h>
-
 #include <Interpreters/Context.h>
-
 #include <Client/Connection.h>
-
 #include "InterruptListener.h"
 
 
diff --git a/dbms/src/Server/Client.cpp b/dbms/src/Server/Client.cpp
index 661d91e68d7..eb0e4482a37 100644
--- a/dbms/src/Server/Client.cpp
+++ b/dbms/src/Server/Client.cpp
@@ -1,8 +1,8 @@
-#include <unistd.h>
+#include <port/unistd.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <signal.h>
-
+#include <map>
 #include <iostream>
 #include <fstream>
 #include <iomanip>
@@ -10,13 +10,11 @@
 #include <algorithm>
 #include <optional>
 #include <boost/program_options.hpp>
-
+#include <boost/algorithm/string/replace.hpp>
 #include <Poco/File.h>
 #include <Poco/Util/Application.h>
-
 #include <common/readline_use.h>
 #include <common/find_first_symbols.h>
-
 #include <Common/ClickHouseRevision.h>
 #include <Common/Stopwatch.h>
 #include <Common/Exception.h>
@@ -28,12 +26,14 @@
 #include <Common/Throttler.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/typeid_cast.h>
+#include <Common/Config/ConfigProcessor.h>
 #include <Core/Types.h>
 #include <Core/QueryProcessingStage.h>
 #include <IO/ReadBufferFromFileDescriptor.h>
 #include <IO/WriteBufferFromFileDescriptor.h>
 #include <IO/WriteBufferFromFile.h>
 #include <IO/ReadBufferFromMemory.h>
+#include <IO/ReadBufferFromString.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <DataStreams/AsynchronousBlockInputStream.h>
@@ -101,7 +101,6 @@ private:
         "учшеж", "йгшеж", "дщпщгеж",
         "q", "й", "\\q", "\\Q", "\\й", "\\Й", ":q", "Жй"
     };
-
     bool is_interactive = true;          /// Use either readline interface or batch mode.
     bool need_render_progress = true;    /// Render query execution progress.
     bool echo_queries = false;           /// Print queries before execution in batch mode.
@@ -111,6 +110,7 @@ private:
     winsize terminal_size {};            /// Terminal size is needed to render progress bar.
 
     std::unique_ptr<Connection> connection;    /// Connection to DB.
+    String query_id;                     /// Current query_id.
     String query;                        /// Current query.
 
     String format;                       /// Query results output format.
@@ -138,6 +138,8 @@ private:
 
     String current_profile;
 
+    String prompt_by_server_display_name;
+
     /// Path to a file containing command history.
     String history_file;
 
@@ -153,6 +155,7 @@ private:
     /// If the last query resulted in exception.
     bool got_exception = false;
     String server_version;
+    String server_display_name;
 
     Stopwatch watch;
 
@@ -167,6 +170,49 @@ private:
     std::list<ExternalTable> external_tables;
 
 
+    struct ConnectionParameters
+    {
+        String host;
+        UInt16 port;
+        String default_database;
+        String user;
+        String password;
+        Protocol::Encryption security;
+        Protocol::Compression compression;
+        ConnectionTimeouts timeouts;
+
+        ConnectionParameters() {}
+
+        ConnectionParameters(const Poco::Util::AbstractConfiguration & config)
+        {
+            bool is_secure = config.getBool("secure", false);
+            security = is_secure
+                ? Protocol::Encryption::Enable
+                : Protocol::Encryption::Disable;
+
+            host = config.getString("host", "localhost");
+            port = config.getInt("port",
+                config.getInt(is_secure ? "tcp_secure_port" : "tcp_port",
+                    is_secure ? DBMS_DEFAULT_SECURE_PORT : DBMS_DEFAULT_PORT));
+
+            default_database = config.getString("database", "");
+            user = config.getString("user", "");
+            password = config.getString("password", "");
+
+            compression = config.getBool("compression", true)
+                ? Protocol::Compression::Enable
+                : Protocol::Compression::Disable;
+
+            timeouts = ConnectionTimeouts(
+                Poco::Timespan(config.getInt("connect_timeout", DBMS_DEFAULT_CONNECT_TIMEOUT_SEC), 0),
+                Poco::Timespan(config.getInt("receive_timeout", DBMS_DEFAULT_RECEIVE_TIMEOUT_SEC), 0),
+                Poco::Timespan(config.getInt("send_timeout", DBMS_DEFAULT_SEND_TIMEOUT_SEC), 0));
+        }
+    };
+
+    ConnectionParameters connection_parameters;
+
+
     void initialize(Poco::Util::Application & self)
     {
         Poco::Util::Application::initialize(self);
@@ -175,14 +221,22 @@ private:
         if (home_path_cstr)
             home_path = home_path_cstr;
 
+        std::string config_path;
         if (config().has("config-file"))
-            loadConfiguration(config().getString("config-file"));
+            config_path = config().getString("config-file");
         else if (Poco::File("./clickhouse-client.xml").exists())
-            loadConfiguration("./clickhouse-client.xml");
+            config_path = "./clickhouse-client.xml";
         else if (!home_path.empty() && Poco::File(home_path + "/.clickhouse-client/config.xml").exists())
-            loadConfiguration(home_path + "/.clickhouse-client/config.xml");
+            config_path = home_path + "/.clickhouse-client/config.xml";
         else if (Poco::File("/etc/clickhouse-client/config.xml").exists())
-            loadConfiguration("/etc/clickhouse-client/config.xml");
+            config_path = "/etc/clickhouse-client/config.xml";
+
+        if (!config_path.empty())
+        {
+            ConfigProcessor config_processor(config_path);
+            auto loaded_config = config_processor.loadConfig();
+            config().add(loaded_config.configuration);
+        }
 
         context.setApplicationType(Context::ApplicationType::CLIENT);
 
@@ -300,6 +354,7 @@ private:
             echo_queries = config().getBool("echo", false);
         }
 
+        connection_parameters = ConnectionParameters(config());
         connect();
 
         /// Initialize DateLUT here to avoid counting time spent here as query execution time.
@@ -329,8 +384,46 @@ private:
             }
         }
 
+        Strings keys;
+
+        prompt_by_server_display_name = config().getRawString("prompt_by_server_display_name.default", "{display_name} :) ");
+
+        config().keys("prompt_by_server_display_name", keys);
+
+        for (const String & key : keys)
+        {
+            if (key != "default" && server_display_name.find(key) != std::string::npos)
+            {
+                prompt_by_server_display_name = config().getRawString("prompt_by_server_display_name." + key);
+                break;
+            }
+        }
+
+        /// Prompt may contain escape sequences including \e[ or \x1b[ sequences to set terminal color.
+        {
+            String unescaped_prompt_by_server_display_name;
+            ReadBufferFromString in(prompt_by_server_display_name);
+            readEscapedString(unescaped_prompt_by_server_display_name, in);
+            prompt_by_server_display_name = std::move(unescaped_prompt_by_server_display_name);
+        }
+
+        /// Prompt may contain the following substitutions in a form of {name}.
+        std::map<String, String> prompt_substitutions
+        {
+            {"host", connection_parameters.host},
+            {"port", toString(connection_parameters.port)},
+            {"user", connection_parameters.user},
+            {"display_name", server_display_name},
+        };
+
+        /// Quite suboptimal.
+        for (const auto & [key, value]: prompt_substitutions)
+            boost::replace_all(prompt_by_server_display_name, "{" + key + "}", value);
+
         if (is_interactive)
         {
+            if (!query_id.empty())
+                throw Exception("query_id could be specified only in non-interactive mode", ErrorCodes::BAD_ARGUMENTS);
             if (print_time_to_stderr)
                 throw Exception("time option could be specified only in non-interactive mode", ErrorCodes::BAD_ARGUMENTS);
 
@@ -365,6 +458,7 @@ private:
         }
         else
         {
+            query_id = config().getString("query_id", "");
             nonInteractive();
 
             if (last_exception)
@@ -377,34 +471,23 @@ private:
 
     void connect()
     {
-        auto encryption = config().getBool("ssl", false)
-        ? Protocol::Encryption::Enable
-        : Protocol::Encryption::Disable;
-
-        String host = config().getString("host", "localhost");
-        UInt16 port = config().getInt("port", config().getInt(static_cast<bool>(encryption) ? "tcp_ssl_port" : "tcp_port", static_cast<bool>(encryption) ? DBMS_DEFAULT_SECURE_PORT : DBMS_DEFAULT_PORT));
-        String default_database = config().getString("database", "");
-        String user = config().getString("user", "");
-        String password = config().getString("password", "");
-
-        auto compression = config().getBool("compression", true)
-            ? Protocol::Compression::Enable
-            : Protocol::Compression::Disable;
-
         if (is_interactive)
             std::cout << "Connecting to "
-                << (!default_database.empty() ? "database " + default_database + " at " : "")
-                << host << ":" << port
-                << (!user.empty() ? " as user " + user : "")
+                << (!connection_parameters.default_database.empty() ? "database " + connection_parameters.default_database + " at " : "")
+                << connection_parameters.host << ":" << connection_parameters.port
+                << (!connection_parameters.user.empty() ? " as user " + connection_parameters.user : "")
                 << "." << std::endl;
 
-        ConnectionTimeouts timeouts(
-            Poco::Timespan(config().getInt("connect_timeout", DBMS_DEFAULT_CONNECT_TIMEOUT_SEC), 0),
-            Poco::Timespan(config().getInt("receive_timeout", DBMS_DEFAULT_RECEIVE_TIMEOUT_SEC), 0),
-            Poco::Timespan(config().getInt("send_timeout", DBMS_DEFAULT_SEND_TIMEOUT_SEC), 0));
-
         connection = std::make_unique<Connection>(
-            host, port, default_database, user, password, timeouts, "client", compression, encryption);
+            connection_parameters.host,
+            connection_parameters.port,
+            connection_parameters.default_database,
+            connection_parameters.user,
+            connection_parameters.password,
+            connection_parameters.timeouts,
+            "client",
+            connection_parameters.compression,
+            connection_parameters.security);
 
         String server_name;
         UInt64 server_version_major = 0;
@@ -420,6 +503,12 @@ private:
         connection->getServerVersion(server_name, server_version_major, server_version_minor, server_revision);
 
         server_version = toString(server_version_major) + "." + toString(server_version_minor) + "." + toString(server_revision);
+
+        if (server_display_name = connection->getServerDisplayName(); server_display_name.length() == 0)
+        {
+            server_display_name = config().getString("host", "localhost");
+        }
+
         if (is_interactive)
         {
             std::cout << "Connected to " << server_name
@@ -440,12 +529,17 @@ private:
         return select(1, &fds, 0, 0, &timeout) == 1;
     }
 
+    inline const String prompt() const
+    {
+        return boost::replace_all_copy(prompt_by_server_display_name, "{database}", config().getString("database", "default"));
+    }
 
     void loop()
     {
         String query;
         String prev_query;
-        while (char * line_ = readline(query.empty() ? ":) " : ":-] "))
+
+        while (char * line_ = readline(query.empty() ? prompt().c_str() : ":-] "))
         {
             String line = line_;
             free(line_);
@@ -726,7 +820,7 @@ private:
     /// Process the query that doesn't require transfering data blocks to the server.
     void processOrdinaryQuery()
     {
-        connection->sendQuery(query, "", QueryProcessingStage::Complete, &context.getSettingsRef(), nullptr, true);
+        connection->sendQuery(query, query_id, QueryProcessingStage::Complete, &context.getSettingsRef(), nullptr, true);
         sendExternalTables();
         receiveResult();
     }
@@ -744,7 +838,7 @@ private:
         if (!parsed_insert_query.data && (is_interactive || (stdin_is_not_tty && std_in.eof())))
             throw Exception("No data to insert", ErrorCodes::NO_DATA_TO_INSERT);
 
-        connection->sendQuery(query_without_data, "", QueryProcessingStage::Complete, &context.getSettingsRef(), nullptr, true);
+        connection->sendQuery(query_without_data, query_id, QueryProcessingStage::Complete, &context.getSettingsRef(), nullptr, true);
         sendExternalTables();
 
         /// Receive description of table structure.
@@ -1280,6 +1374,7 @@ public:
             ("ssl,s", "ssl")
             ("user,u", boost::program_options::value<std::string>(), "user")
             ("password", boost::program_options::value<std::string>(), "password")
+            ("query_id", boost::program_options::value<std::string>(), "query_id")
             ("query,q", boost::program_options::value<std::string>(), "query")
             ("database,d", boost::program_options::value<std::string>(), "database")
             ("pager", boost::program_options::value<std::string>(), "pager")
@@ -1368,6 +1463,8 @@ public:
             config().setString("config-file", options["config-file"].as<std::string>());
         if (options.count("host") && !options["host"].defaulted())
             config().setString("host", options["host"].as<std::string>());
+        if (options.count("query_id"))
+            config().setString("query_id", options["query_id"].as<std::string>());
         if (options.count("query"))
             config().setString("query", options["query"].as<std::string>());
         if (options.count("database"))
diff --git a/dbms/src/Server/ClusterCopier.cpp b/dbms/src/Server/ClusterCopier.cpp
index 77172a22b23..4233ce70e3f 100644
--- a/dbms/src/Server/ClusterCopier.cpp
+++ b/dbms/src/Server/ClusterCopier.cpp
@@ -20,6 +20,7 @@
 #include <Common/Exception.h>
 #include <Common/ZooKeeper/ZooKeeper.h>
 #include <Common/getFQDNOrHostName.h>
+#include <Common/isLocalAddress.h>
 #include <Client/Connection.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/Cluster.h>
@@ -37,7 +38,7 @@
 #include <Common/escapeForFileName.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnsNumber.h>
-#include <Storages/StorageDistributed.h>
+#include <DataTypes/DataTypeString.h>
 #include <Parsers/ParserCreateQuery.h>
 #include <Parsers/parseQuery.h>
 #include <Parsers/ParserQuery.h>
@@ -46,20 +47,20 @@
 #include <Parsers/ASTDropQuery.h>
 #include <Parsers/ASTLiteral.h>
 #include <Parsers/ASTExpressionList.h>
-#include <Databases/DatabaseMemory.h>
 #include <DataStreams/RemoteBlockInputStream.h>
 #include <DataStreams/SquashingBlockInputStream.h>
-#include <Common/isLocalAddress.h>
+#include <DataStreams/AsynchronousBlockInputStream.h>
 #include <DataStreams/copyData.h>
-#include <DataTypes/DataTypeString.h>
 #include <DataStreams/NullBlockOutputStream.h>
 #include <IO/Operators.h>
 #include <IO/ReadBufferFromString.h>
 #include <Functions/registerFunctions.h>
 #include <TableFunctions/registerTableFunctions.h>
 #include <AggregateFunctions/registerAggregateFunctions.h>
-#include <Server/StatusFile.h>
 #include <Storages/registerStorages.h>
+#include <Storages/StorageDistributed.h>
+#include <Databases/DatabaseMemory.h>
+#include <Server/StatusFile.h>
 #include <Common/formatReadable.h>
 #include <daemon/OwnPatternFormatter.h>
 
@@ -355,20 +356,23 @@ struct TaskCluster
 
 /// Atomically checks that is_dirty node is not exists, and made the remaining op
 /// Returns relative number of failed operation in the second field (the passed op has 0 index)
-static void checkNoNodeAndCommit(
+static zkutil::MultiTransactionInfo checkNoNodeAndCommit(
     const zkutil::ZooKeeperPtr & zookeeper,
     const String & checking_node_path,
-    zkutil::OpPtr && op,
-    zkutil::MultiTransactionInfo & info)
+    zkutil::OpPtr && op)
 {
     zkutil::Ops ops;
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(checking_node_path, "", zookeeper->getDefaultACL(), zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Remove>(checking_node_path, -1));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(checking_node_path, "", zookeeper->getDefaultACL(), zkutil::CreateMode::Persistent));
+    ops.emplace_back(std::make_shared<zkutil::Op::Remove>(checking_node_path, -1));
     ops.emplace_back(std::move(op));
 
-    zookeeper->tryMultiUnsafe(ops, info);
+    zkutil::MultiTransactionInfo info;
+    zookeeper->tryMultiNoThrow(ops, nullptr, &info);
+
     if (info.code != ZOK && !zkutil::isUserError(info.code))
-        throw info.getException();
+        throw zkutil::KeeperException(info.code);
+
+    return info;
 }
 
 
@@ -694,7 +698,7 @@ void DB::TaskCluster::reloadSettings(const Poco::Util::AbstractConfiguration & c
     settings_pull.load_balancing = LoadBalancing::NEAREST_HOSTNAME;
     settings_pull.readonly = 1;
     settings_pull.max_threads = 1;
-    settings_pull.max_block_size = std::min(8192UL, settings_pull.max_block_size.value);
+    settings_pull.max_block_size = settings_pull.max_block_size.changed ? settings_pull.max_block_size.value : 8192UL;
     settings_pull.preferred_block_size_bytes = 0;
 
     settings_push.insert_distributed_timeout = 0;
@@ -756,6 +760,7 @@ public:
 
         /// Do not initialize tables, will make deferred initialization in process()
 
+        getZooKeeper()->createAncestors(getWorkersPathVersion() + "/");
         getZooKeeper()->createAncestors(getWorkersPath() + "/");
     }
 
@@ -1008,32 +1013,65 @@ protected:
         return task_cluster->task_zookeeper_path + "/task_active_workers";
     }
 
+    String getWorkersPathVersion() const
+    {
+        return getWorkersPath() + "_version";
+    }
+
     String getCurrentWorkerNodePath() const
     {
         return getWorkersPath() + "/" + host_id;
     }
 
     zkutil::EphemeralNodeHolder::Ptr createTaskWorkerNodeAndWaitIfNeed(const zkutil::ZooKeeperPtr & zookeeper,
-                                                                       const String & description)
+                                                                       const String & description, bool unprioritized)
     {
+        std::chrono::milliseconds current_sleep_time = default_sleep_time;
+        static constexpr std::chrono::milliseconds max_sleep_time(30000); // 30 sec
+
+        if (unprioritized)
+            std::this_thread::sleep_for(current_sleep_time);
+
+        String workers_version_path = getWorkersPathVersion();
+        String workers_path = getWorkersPath();
+        String current_worker_path = getCurrentWorkerNodePath();
+
         while (true)
         {
             zkutil::Stat stat;
-            zookeeper->get(getWorkersPath(), &stat);
+            zookeeper->get(workers_version_path, &stat);
+            auto version = stat.version;
+            zookeeper->get(workers_path, &stat);
 
             if (static_cast<size_t>(stat.numChildren) >= task_cluster->max_workers)
             {
                 LOG_DEBUG(log, "Too many workers (" << stat.numChildren << ", maximum " << task_cluster->max_workers << ")"
                     << ". Postpone processing " << description);
-
-                std::this_thread::sleep_for(default_sleep_time);
-
-                updateConfigIfNeeded();
             }
             else
             {
-                return std::make_shared<zkutil::EphemeralNodeHolder>(getCurrentWorkerNodePath(), *zookeeper, true, false, description);
+                zkutil::Ops ops;
+                ops.emplace_back(new zkutil::Op::SetData(workers_version_path, description, version));
+                ops.emplace_back(new zkutil::Op::Create(current_worker_path, description, zookeeper->getDefaultACL(), zkutil::CreateMode::Ephemeral));
+                auto code = zookeeper->tryMulti(ops);
+
+                if (code == ZOK || code == ZNODEEXISTS)
+                    return std::make_shared<zkutil::EphemeralNodeHolder>(current_worker_path, *zookeeper, false, false, description);
+
+                if (code == ZBADVERSION)
+                {
+                    LOG_DEBUG(log, "A concurrent worker has just been added, will check free worker slots again");
+                }
+                else
+                    throw zkutil::KeeperException(code);
             }
+
+            if (unprioritized)
+                current_sleep_time = std::min(max_sleep_time, current_sleep_time + default_sleep_time);
+
+            std::this_thread::sleep_for(current_sleep_time);
+
+            updateConfigIfNeeded();
         }
     }
 
@@ -1120,8 +1158,8 @@ protected:
 
             if (!column.default_specifier.empty())
             {
-                ColumnDefaultType type = columnDefaultTypeFromString(column.default_specifier);
-                if (type == ColumnDefaultType::Materialized || type == ColumnDefaultType::Alias)
+                ColumnDefaultKind kind = columnDefaultKindFromString(column.default_specifier);
+                if (kind == ColumnDefaultKind::Materialized || kind == ColumnDefaultKind::Alias)
                     continue;
             }
 
@@ -1441,9 +1479,8 @@ protected:
             return parseQuery(p_query, query);
         };
 
-
         /// Load balancing
-        auto worker_node_holder = createTaskWorkerNodeAndWaitIfNeed(zookeeper, current_task_status_path);
+        auto worker_node_holder = createTaskWorkerNodeAndWaitIfNeed(zookeeper, current_task_status_path, task_shard.priority.is_remote);
 
         LOG_DEBUG(log, "Processing " << current_task_status_path);
 
@@ -1542,10 +1579,8 @@ protected:
         /// Try start processing, create node about it
         {
             String start_state = TaskStateWithOwner::getData(TaskState::Started, host_id);
-            auto op_create = std::make_unique<zkutil::Op::Create>(current_task_status_path, start_state, acl, zkutil::CreateMode::Persistent);
-
-            zkutil::MultiTransactionInfo info;
-            checkNoNodeAndCommit(zookeeper, is_dirty_flag_path, std::move(op_create), info);
+            auto op_create = std::make_shared<zkutil::Op::Create>(current_task_status_path, start_state, acl, zkutil::CreateMode::Persistent);
+            zkutil::MultiTransactionInfo info = checkNoNodeAndCommit(zookeeper, is_dirty_flag_path, std::move(op_create));
 
             if (info.code != ZOK)
             {
@@ -1608,8 +1643,15 @@ protected:
                 Context context_insert = context;
                 context_insert.getSettingsRef() = task_cluster->settings_push;
 
-                BlockIO io_select = InterpreterFactory::get(query_select_ast, context_select)->execute();
-                BlockIO io_insert = InterpreterFactory::get(query_insert_ast, context_insert)->execute();
+                BlockInputStreamPtr input;
+                BlockOutputStreamPtr output;
+                {
+                    BlockIO io_select = InterpreterFactory::get(query_select_ast, context_select)->execute();
+                    BlockIO io_insert = InterpreterFactory::get(query_insert_ast, context_insert)->execute();
+
+                    input = std::make_shared<AsynchronousBlockInputStream>(io_select.in);
+                    output = io_insert.out;
+                }
 
                 using ExistsFuture = zkutil::ZooKeeper::ExistsFuture;
                 auto future_is_dirty_checker = std::make_unique<ExistsFuture>(zookeeper->asyncExists(is_dirty_flag_path));
@@ -1664,7 +1706,7 @@ protected:
                 };
 
                 /// Main work is here
-                copyData(*io_select.in, *io_insert.out, cancel_check, update_stats);
+                copyData(*input, *output, cancel_check, update_stats);
 
                 // Just in case
                 if (future_is_dirty_checker != nullptr)
@@ -1683,9 +1725,8 @@ protected:
         /// Finalize the processing, change state of current partition task (and also check is_dirty flag)
         {
             String state_finished = TaskStateWithOwner::getData(TaskState::Finished, host_id);
-            auto op_set = std::make_unique<zkutil::Op::SetData>(current_task_status_path, state_finished, 0);
-            zkutil::MultiTransactionInfo info;
-            checkNoNodeAndCommit(zookeeper, is_dirty_flag_path, std::move(op_set), info);
+            auto op_set = std::make_shared<zkutil::Op::SetData>(current_task_status_path, state_finished, 0);
+            zkutil::MultiTransactionInfo info = checkNoNodeAndCommit(zookeeper, is_dirty_flag_path, std::move(op_set));
 
             if (info.code != ZOK)
             {
diff --git a/dbms/src/Server/HTTPHandler.cpp b/dbms/src/Server/HTTPHandler.cpp
index e06a3f0b885..fba60c5c12b 100644
--- a/dbms/src/Server/HTTPHandler.cpp
+++ b/dbms/src/Server/HTTPHandler.cpp
@@ -12,7 +12,7 @@
 #include <Common/ExternalTable.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/escapeForFileName.h>
-
+#include <Common/getFQDNOrHostName.h>
 #include <IO/ReadBufferFromIStream.h>
 #include <IO/ZlibInflatingReadBuffer.h>
 #include <IO/ReadBufferFromString.h>
@@ -198,6 +198,7 @@ HTTPHandler::HTTPHandler(IServer & server_)
     : server(server_)
     , log(&Logger::get("HTTPHandler"))
 {
+    server_display_name = server.config().getString("display_name", getFQDNOrHostName());
 }
 
 
@@ -629,7 +630,7 @@ void HTTPHandler::handleRequest(Poco::Net::HTTPServerRequest & request, Poco::Ne
     try
     {
         response.setContentType("text/plain; charset=UTF-8");
-
+        response.set("X-ClickHouse-Server-Display-Name", server_display_name);
         /// For keep-alive to work.
         if (request.getVersion() == Poco::Net::HTTPServerRequest::HTTP_1_1)
             response.setChunkedTransferEncoding(true);
diff --git a/dbms/src/Server/HTTPHandler.h b/dbms/src/Server/HTTPHandler.h
index b0b7164852e..72606afa827 100644
--- a/dbms/src/Server/HTTPHandler.h
+++ b/dbms/src/Server/HTTPHandler.h
@@ -55,6 +55,9 @@ private:
     IServer & server;
     Poco::Logger * log;
 
+    /// It is the name of the server that will be sent in an http-header X-ClickHouse-Server-Display-Name. 
+    String server_display_name;
+
     CurrentMetrics::Increment metric_increment{CurrentMetrics::HTTPConnection};
 
     /// Also initializes 'used_output'.
diff --git a/dbms/src/Server/LocalServer.cpp b/dbms/src/Server/LocalServer.cpp
index aec3f4152f1..1196c62f06f 100644
--- a/dbms/src/Server/LocalServer.cpp
+++ b/dbms/src/Server/LocalServer.cpp
@@ -275,7 +275,7 @@ try
 
     /// Maybe useless
     if (config().has("macros"))
-        context->setMacros(Macros(config(), "macros"));
+        context->setMacros(std::make_unique<Macros>(config(), "macros"));
 
     /// Skip networking
 
diff --git a/dbms/src/Server/PerformanceTest.cpp b/dbms/src/Server/PerformanceTest.cpp
index 81f679cd61e..7c9d4436f3c 100644
--- a/dbms/src/Server/PerformanceTest.cpp
+++ b/dbms/src/Server/PerformanceTest.cpp
@@ -3,14 +3,11 @@
 #include <limits>
 #include <regex>
 #include <thread>
-#include <unistd.h>
-
+#include <port/unistd.h>
 #include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 #include <sys/stat.h>
-
 #include <common/DateLUT.h>
-
 #include <AggregateFunctions/ReservoirSampler.h>
 #include <Client/Connection.h>
 #include <Common/ConcurrentBoundedQueue.h>
@@ -27,13 +24,11 @@
 #include <Interpreters/Settings.h>
 #include <common/ThreadPool.h>
 #include <common/getMemoryAmount.h>
-
 #include <Poco/AutoPtr.h>
 #include <Poco/Exception.h>
 #include <Poco/SAX/InputSource.h>
 #include <Poco/Util/XMLConfiguration.h>
 #include <Poco/XML/XMLStream.h>
-
 #include "InterruptListener.h"
 
 /** Tests launcher for ClickHouse.
diff --git a/dbms/src/Server/Server.cpp b/dbms/src/Server/Server.cpp
index db20c194573..820a593cd09 100644
--- a/dbms/src/Server/Server.cpp
+++ b/dbms/src/Server/Server.cpp
@@ -221,7 +221,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
     }
 
     if (config().has("macros"))
-        global_context->setMacros(Macros(config(), "macros"));
+        global_context->setMacros(std::make_unique<Macros>(config(), "macros"));
 
     /// Initialize main config reloader.
     std::string include_from_path = config().getString("include_from", "/etc/metrika.xml");
@@ -231,6 +231,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
         [&](ConfigurationPtr config)
         {
             global_context->setClustersConfig(config);
+            global_context->setMacros(std::make_unique<Macros>(*config, "macros"));
         },
         /* already_loaded = */ true);
 
@@ -250,6 +251,12 @@ int Server::main(const std::vector<std::string> & /*args*/)
         [&](ConfigurationPtr config) { global_context->setUsersConfig(config); },
         /* already_loaded = */ false);
 
+    /// Reload config in SYSTEM RELOAD CONFIG query.
+    global_context->setConfigReloadCallback([&]() {
+        main_config_reloader->reload();
+        users_config_reloader->reload();
+    });
+
     /// Limit on total number of concurrently executed queries.
     global_context->getProcessList().setMaxSize(config().getInt("max_concurrent_queries", 0));
 
@@ -387,7 +394,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
                     http_socket.setSendTimeout(settings.http_send_timeout);
 
                     servers.emplace_back(new Poco::Net::HTTPServer(
-                        new HTTPHandlerFactory(*this, "HTTPHandler-factory"),
+                        new HTTPHandlerFactory(*this, "HTTPSHandler-factory"),
                         server_pool,
                         http_socket,
                         http_params));
@@ -425,7 +432,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
                     tcp_socket.setReceiveTimeout(settings.receive_timeout);
                     tcp_socket.setSendTimeout(settings.send_timeout);
                     servers.emplace_back(new Poco::Net::TCPServer(
-                        new TCPHandlerFactory(*this),
+                        new TCPHandlerFactory(*this, /* secure= */ true ),
                                                                   server_pool,
                                                                   tcp_socket,
                                                                   new Poco::Net::TCPServerParams));
@@ -458,12 +465,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
             }
             catch (const Poco::Net::NetException & e)
             {
-                const auto code = e.code();
-                if (listen_try && (code == POCO_EPROTONOSUPPORT || code == POCO_EADDRNOTAVAIL || code == EAI_FAMILY
-#if defined(EAI_ADDRFAMILY)
-                    || code == EAI_ADDRFAMILY
-#endif
-                ))
+                if (listen_try)
                     LOG_ERROR(log, "Listen [" << listen_host << "]: " << e.code() << ": " << e.what() << ": " << e.message()
                         << "  If it is an IPv6 or IPv4 address and your host has disabled IPv6 or IPv4, then consider to "
                         "specify not disabled IPv4 or IPv6 address to listen in <listen_host> element of configuration "
diff --git a/dbms/src/Server/TCPHandler.cpp b/dbms/src/Server/TCPHandler.cpp
index 55f85c662dc..faf39dded67 100644
--- a/dbms/src/Server/TCPHandler.cpp
+++ b/dbms/src/Server/TCPHandler.cpp
@@ -508,6 +508,10 @@ void TCPHandler::sendHello()
     {
         writeStringBinary(DateLUT::instance().getTimeZone(), *out);
     }
+    if (client_revision >= DBMS_MIN_REVISION_WITH_SERVER_DISPLAY_NAME)
+    {
+        writeStringBinary(server_display_name, *out);
+    }
     out->next();
 }
 
@@ -630,7 +634,8 @@ bool TCPHandler::receiveData()
             if (!(storage = query_context.tryGetExternalTable(external_table_name)))
             {
                 NamesAndTypesList columns = block.getNamesAndTypesList();
-                storage = StorageMemory::create(external_table_name, columns, NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{});
+                storage = StorageMemory::create(external_table_name,
+                    ColumnsDescription{columns, NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{}});
                 storage->startup();
                 query_context.addExternalTable(external_table_name, storage);
             }
diff --git a/dbms/src/Server/TCPHandler.h b/dbms/src/Server/TCPHandler.h
index 444d8eb4990..f53850ee487 100644
--- a/dbms/src/Server/TCPHandler.h
+++ b/dbms/src/Server/TCPHandler.h
@@ -2,6 +2,7 @@
 
 #include <Poco/Net/TCPServerConnection.h>
 
+#include <Common/getFQDNOrHostName.h>
 #include <Common/CurrentMetrics.h>
 #include <Common/Stopwatch.h>
 #include <IO/Progress.h>
@@ -81,6 +82,7 @@ public:
         , connection_context(server.context())
         , query_context(server.context())
     {
+        server_display_name =  server.config().getString("display_name", getFQDNOrHostName());
     }
 
     void run();
@@ -111,7 +113,9 @@ private:
     QueryState state;
 
     CurrentMetrics::Increment metric_increment{CurrentMetrics::TCPConnection};
-
+    
+    /// It is the name of the server that will be sent to the client. 
+    String server_display_name;
 
     void runImpl();
 
diff --git a/dbms/src/Server/TCPHandlerFactory.h b/dbms/src/Server/TCPHandlerFactory.h
index 1f454b35a8f..0eb8be13a2d 100644
--- a/dbms/src/Server/TCPHandlerFactory.h
+++ b/dbms/src/Server/TCPHandlerFactory.h
@@ -17,9 +17,9 @@ private:
     Poco::Logger * log;
 
 public:
-    explicit TCPHandlerFactory(IServer & server_)
+    explicit TCPHandlerFactory(IServer & server_, bool secure_ = false)
         : server(server_)
-        , log(&Logger::get("TCPHandlerFactory"))
+        , log(&Logger::get(std::string("TCP") + (secure_ ? "S" : "") + "HandlerFactory"))
     {
     }
 
diff --git a/dbms/src/Server/clickhouse-client.xml b/dbms/src/Server/clickhouse-client.xml
index c19606c518b..3cd05d7fec9 100644
--- a/dbms/src/Server/clickhouse-client.xml
+++ b/dbms/src/Server/clickhouse-client.xml
@@ -13,4 +13,19 @@
             </invalidCertificateHandler>
         </client>
     </openSSL>
+    <!--
+        It's a custom prompt settings for the clickhouse-client
+        Possible macros: 
+            {host}
+            {port}
+            {user}
+            {database} 
+            {display_name}
+        Terminal colors: https://misc.flogisoft.com/bash/tip_colors_and_formatting
+    -->
+    <prompt_by_server_display_name>
+        <default>{display_name} :) </default>
+        <test>{display_name} \e[1;32m:)\e[0m  </test> <!-- if it matched to the substring "test" in the server display name - -->
+        <production>{display_name} \e[1;31m:)\e[0m </production> <!-- if it matched to the substring "production" in the server display name -->
+    </prompt_by_server_display_name>
 </config>
diff --git a/dbms/src/Server/config.d/more_clusters.xml b/dbms/src/Server/config.d/more_clusters.xml
new file mode 100644
index 00000000000..aecbf9e0ba7
--- /dev/null
+++ b/dbms/src/Server/config.d/more_clusters.xml
@@ -0,0 +1,49 @@
+<yandex>
+    <remote_servers>
+
+        <![CDATA[
+            You can run additional servers simply as
+             ./clickhouse-server -- --path=9001 --tcp_port=9001
+        ]]>
+
+        <single_remote_shard_at_port_9001>
+            <shard>
+                <replica>
+                    <host>localhost</host>
+                    <port>9001</port>
+                </replica>
+            </shard>
+        </single_remote_shard_at_port_9001>
+
+        <two_remote_shards_at_port_9001_9002>
+            <shard>
+                <replica>
+                    <host>localhost</host>
+                    <port>9001</port>
+                </replica>
+            </shard>
+            <shard>
+                <replica>
+                    <host>localhost</host>
+                    <port>9002</port>
+                </replica>
+            </shard>
+        </two_remote_shards_at_port_9001_9002>
+
+        <two_shards_one_local_one_remote_at_port_9001>
+            <shard>
+                <replica>
+                    <host>localhost</host>
+                    <port>9000</port>
+                </replica>
+            </shard>
+            <shard>
+                <replica>
+                    <host>localhost</host>
+                    <port>9001</port>
+                </replica>
+            </shard>
+        </two_shards_one_local_one_remote_at_port_9001>
+
+    </remote_servers>
+</yandex>
diff --git a/dbms/src/Server/config.xml b/dbms/src/Server/config.xml
index ca783df32ce..8cf1fd6b519 100644
--- a/dbms/src/Server/config.xml
+++ b/dbms/src/Server/config.xml
@@ -9,7 +9,7 @@
         <count>10</count>
         <!-- <console>1</console> --> <!-- Default behavior is autodetection (log to console if not daemon mode and is tty) -->
     </logger>
-
+    <!--display_name>production</display_name--> <!-- It is the name that will be shown in the client -->
     <http_port>8123</http_port>
     <tcp_port>9000</tcp_port>
 
@@ -199,7 +199,7 @@
         <timeout>0.1</timeout>
         <interval>60</interval>
         <root_path>one_min</root_path>
-        <hostname_in_path>true<hostname_in_path>
+        <hostname_in_path>true</hostname_in_path>
 
         <metrics>true</metrics>
         <events>true</events>
diff --git a/dbms/src/Storages/AlterCommands.cpp b/dbms/src/Storages/AlterCommands.cpp
index 8411dfe1bf6..274f9315f5f 100644
--- a/dbms/src/Storages/AlterCommands.cpp
+++ b/dbms/src/Storages/AlterCommands.cpp
@@ -21,21 +21,11 @@ namespace ErrorCodes
 }
 
 
-void AlterCommand::apply(
-    NamesAndTypesList & columns, NamesAndTypesList & materialized_columns, NamesAndTypesList & alias_columns,
-    ColumnDefaults & column_defaults) const
+void AlterCommand::apply(ColumnsDescription & columns_description) const
 {
     if (type == ADD_COLUMN)
     {
-        const auto exists_in = [this] (const NamesAndTypesList & columns)
-        {
-            return columns.end() != std::find_if(columns.begin(), columns.end(),
-                std::bind(namesEqual, std::cref(column_name), std::placeholders::_1));
-        };
-
-        if (exists_in(columns) ||
-            exists_in(materialized_columns) ||
-            exists_in(alias_columns))
+        if (columns_description.getAll().contains(column_name))
         {
             throw Exception{
                 "Cannot add column " + column_name + ": column with this name already exists",
@@ -67,25 +57,25 @@ void AlterCommand::apply(
             columns.emplace(insert_it, column_name, data_type);
         };
 
-        if (default_type == ColumnDefaultType::Default)
-            add_column(columns);
-        else if (default_type == ColumnDefaultType::Materialized)
-            add_column(materialized_columns);
-        else if (default_type == ColumnDefaultType::Alias)
-            add_column(alias_columns);
+        if (default_kind == ColumnDefaultKind::Default)
+            add_column(columns_description.ordinary);
+        else if (default_kind == ColumnDefaultKind::Materialized)
+            add_column(columns_description.materialized);
+        else if (default_kind == ColumnDefaultKind::Alias)
+            add_column(columns_description.aliases);
         else
-            throw Exception{"Unknown ColumnDefaultType value", ErrorCodes::LOGICAL_ERROR};
+            throw Exception{"Unknown ColumnDefaultKind value", ErrorCodes::LOGICAL_ERROR};
 
         if (default_expression)
-            column_defaults.emplace(column_name, ColumnDefault{default_type, default_expression});
+            columns_description.defaults.emplace(column_name, ColumnDefault{default_kind, default_expression});
 
         /// Slow, because each time a list is copied
-        columns = Nested::flatten(columns);
+        columns_description.ordinary = Nested::flatten(columns_description.ordinary);
     }
     else if (type == DROP_COLUMN)
     {
         /// look for a column in list and remove it if present, also removing corresponding entry from column_defaults
-        const auto remove_column = [&column_defaults, this] (NamesAndTypesList & columns)
+        const auto remove_column = [&columns_description, this] (NamesAndTypesList & columns)
         {
             auto removed = false;
             NamesAndTypesList::iterator column_it;
@@ -95,15 +85,15 @@ void AlterCommand::apply(
             {
                 removed = true;
                 column_it = columns.erase(column_it);
-                column_defaults.erase(column_name);
+                columns_description.defaults.erase(column_name);
             }
 
             return removed;
         };
 
-        if (!remove_column(columns) &&
-            !remove_column(materialized_columns) &&
-            !remove_column(alias_columns))
+        if (!remove_column(columns_description.ordinary) &&
+            !remove_column(columns_description.materialized) &&
+            !remove_column(columns_description.aliases))
         {
             throw Exception("Wrong column name. Cannot find column " + column_name + " to drop",
                             ErrorCodes::ILLEGAL_COLUMN);
@@ -111,14 +101,15 @@ void AlterCommand::apply(
     }
     else if (type == MODIFY_COLUMN)
     {
-        const auto default_it = column_defaults.find(column_name);
-        const auto had_default_expr = default_it != std::end(column_defaults);
-        const auto old_default_type = had_default_expr ? default_it->second.type : ColumnDefaultType{};
+        const auto default_it = columns_description.defaults.find(column_name);
+        const auto had_default_expr = default_it != std::end(columns_description.defaults);
+        const auto old_default_kind = had_default_expr ? default_it->second.kind : ColumnDefaultKind{};
 
         /// target column list
-        auto & new_columns = default_type == ColumnDefaultType::Default ?
-            columns : default_type == ColumnDefaultType::Materialized ?
-            materialized_columns : alias_columns;
+        auto & new_columns =
+            default_kind == ColumnDefaultKind::Default ? columns_description.ordinary
+            : default_kind == ColumnDefaultKind::Materialized ? columns_description.materialized
+            : columns_description.aliases;
 
         /// find column or throw exception
         const auto find_column = [this] (NamesAndTypesList & columns)
@@ -133,12 +124,13 @@ void AlterCommand::apply(
         };
 
         /// if default types differ, remove column from the old list, then add to the new list
-        if (default_type != old_default_type)
+        if (default_kind != old_default_kind)
         {
             /// source column list
-            auto & old_columns = old_default_type == ColumnDefaultType::Default ?
-                columns : old_default_type == ColumnDefaultType::Materialized ?
-                materialized_columns : alias_columns;
+            auto & old_columns =
+                old_default_kind == ColumnDefaultKind::Default ? columns_description.ordinary
+                : old_default_kind == ColumnDefaultKind::Materialized ? columns_description.materialized
+                : columns_description.aliases;
 
             const auto old_column_it = find_column(old_columns);
             new_columns.emplace_back(*old_column_it);
@@ -146,7 +138,7 @@ void AlterCommand::apply(
 
             /// do not forget to change the default type of old column
             if (had_default_expr)
-                column_defaults[column_name].type = default_type;
+                columns_description.defaults[column_name].kind = default_kind;
         }
 
         /// find column in one of three column lists
@@ -155,13 +147,13 @@ void AlterCommand::apply(
 
         if (!default_expression && had_default_expr)
             /// new column has no default expression, remove it from column_defaults along with it's type
-            column_defaults.erase(column_name);
+            columns_description.defaults.erase(column_name);
         else if (default_expression && !had_default_expr)
             /// new column has a default expression while the old one had not, add it it column_defaults
-            column_defaults.emplace(column_name, ColumnDefault{default_type, default_expression});
+            columns_description.defaults.emplace(column_name, ColumnDefault{default_kind, default_expression});
         else if (had_default_expr)
             /// both old and new columns have default expression, update it
-            column_defaults[column_name].expression = default_expression;
+            columns_description.defaults[column_name].expression = default_expression;
     }
     else if (type == MODIFY_PRIMARY_KEY)
     {
@@ -173,30 +165,20 @@ void AlterCommand::apply(
 }
 
 
-void AlterCommands::apply(NamesAndTypesList & columns,
-            NamesAndTypesList & materialized_columns,
-            NamesAndTypesList & alias_columns,
-            ColumnDefaults & column_defaults) const
+void AlterCommands::apply(ColumnsDescription & columns_description) const
 {
-    auto new_columns = columns;
-    auto new_materialized_columns = materialized_columns;
-    auto new_alias_columns = alias_columns;
-    auto new_column_defaults = column_defaults;
+    auto new_columns_description = columns_description;
 
     for (const AlterCommand & command : *this)
-        command.apply(new_columns, new_materialized_columns, new_alias_columns, new_column_defaults);
+        command.apply(new_columns_description);
 
-    columns = std::move(new_columns);
-    materialized_columns = std::move(new_materialized_columns);
-    alias_columns = std::move(new_alias_columns);
-    column_defaults = std::move(new_column_defaults);
+    columns_description = std::move(new_columns_description);
 }
 
 void AlterCommands::validate(IStorage * table, const Context & context)
 {
-    auto columns = table->getColumnsList();
-    columns.insert(std::end(columns), std::begin(table->alias_columns), std::end(table->alias_columns));
-    auto defaults = table->column_defaults;
+    auto all_columns = table->getColumns().getAll();
+    auto defaults = table->getColumns().defaults;
 
     std::vector<std::pair<NameAndTypePair, AlterCommand *>> defaulted_columns{};
 
@@ -208,12 +190,12 @@ void AlterCommands::validate(IStorage * table, const Context & context)
         if (command.type == AlterCommand::ADD_COLUMN || command.type == AlterCommand::MODIFY_COLUMN)
         {
             const auto & column_name = command.column_name;
-            const auto column_it = std::find_if(std::begin(columns), std::end(columns),
+            const auto column_it = std::find_if(std::begin(all_columns), std::end(all_columns),
                 std::bind(AlterCommand::namesEqual, std::cref(command.column_name), std::placeholders::_1));
 
             if (command.type == AlterCommand::ADD_COLUMN)
             {
-                if (std::end(columns) != column_it)
+                if (std::end(all_columns) != column_it)
                     throw Exception{
                         "Cannot add column " + column_name + ": column with this name already exists",
                         ErrorCodes::ILLEGAL_COLUMN};
@@ -221,17 +203,17 @@ void AlterCommands::validate(IStorage * table, const Context & context)
             else if (command.type == AlterCommand::MODIFY_COLUMN)
             {
 
-                if (std::end(columns) == column_it)
+                if (std::end(all_columns) == column_it)
                     throw Exception{
                         "Wrong column name. Cannot find column " + column_name + " to modify",
                         ErrorCodes::ILLEGAL_COLUMN};
 
-                columns.erase(column_it);
+                all_columns.erase(column_it);
                 defaults.erase(column_name);
             }
 
             /// we're creating dummy DataTypeUInt8 in order to prevent the NullPointerException in ExpressionActions
-            columns.emplace_back(column_name, command.data_type ? command.data_type : std::make_shared<DataTypeUInt8>());
+            all_columns.emplace_back(column_name, command.data_type ? command.data_type : std::make_shared<DataTypeUInt8>());
 
             if (command.default_expression)
             {
@@ -265,7 +247,7 @@ void AlterCommands::validate(IStorage * table, const Context & context)
             for (const auto & default_column : defaults)
             {
                 const auto & default_expression = default_column.second.expression;
-                const auto actions = ExpressionAnalyzer{default_expression, context, {}, columns}.getActions(true);
+                const auto actions = ExpressionAnalyzer{default_expression, context, {}, all_columns}.getActions(true);
                 const auto required_columns = actions->getRequiredColumns();
 
                 if (required_columns.end() != std::find(required_columns.begin(), required_columns.end(), command.column_name))
@@ -275,12 +257,12 @@ void AlterCommands::validate(IStorage * table, const Context & context)
             }
 
             auto found = false;
-            for (auto it = std::begin(columns); it != std::end(columns);)
+            for (auto it = std::begin(all_columns); it != std::end(all_columns);)
             {
                 if (AlterCommand::namesEqual(command.column_name, *it))
                 {
                     found = true;
-                    it = columns.erase(it);
+                    it = all_columns.erase(it);
                 }
                 else
                     ++it;
@@ -305,7 +287,7 @@ void AlterCommands::validate(IStorage * table, const Context & context)
     for (const auto & col_def : defaults)
     {
         const auto & column_name = col_def.first;
-        const auto column_it = std::find_if(columns.begin(), columns.end(), [&] (const NameAndTypePair & name_type)
+        const auto column_it = std::find_if(all_columns.begin(), all_columns.end(), [&] (const NameAndTypePair & name_type)
             { return AlterCommand::namesEqual(column_name, name_type); });
 
         const auto tmp_column_name = column_name + "_tmp";
@@ -321,7 +303,7 @@ void AlterCommands::validate(IStorage * table, const Context & context)
         defaulted_columns.emplace_back(NameAndTypePair{column_name, column_type_ptr}, nullptr);
     }
 
-    const auto actions = ExpressionAnalyzer{default_expr_list, context, {}, columns}.getActions(true);
+    const auto actions = ExpressionAnalyzer{default_expr_list, context, {}, all_columns}.getActions(true);
     const auto block = actions->getSampleBlock();
 
     /// set deduced types, modify default expression if necessary
@@ -351,7 +333,7 @@ void AlterCommands::validate(IStorage * table, const Context & context)
                     /// add a new alter command to modify existing column
                     this->emplace_back(AlterCommand{
                         AlterCommand::MODIFY_COLUMN, column_name, explicit_type,
-                        default_it->second.type, default_it->second.expression
+                        default_it->second.kind, default_it->second.expression
                     });
 
                     command_ptr = &this->back();
diff --git a/dbms/src/Storages/AlterCommands.h b/dbms/src/Storages/AlterCommands.h
index 543106254e6..306d5cec54c 100644
--- a/dbms/src/Storages/AlterCommands.h
+++ b/dbms/src/Storages/AlterCommands.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Core/NamesAndTypes.h>
-#include <Storages/ColumnDefault.h>
+#include <Storages/ColumnsDescription.h>
 
 namespace DB
 {
@@ -27,7 +27,7 @@ struct AlterCommand
     /// For ADD and MODIFY, a new column type.
     DataTypePtr data_type;
 
-    ColumnDefaultType default_type{};
+    ColumnDefaultKind default_kind{};
     ASTPtr default_expression{};
 
     /// For ADD - after which column to add a new one. If an empty string, add to the end. To add to the beginning now it is impossible.
@@ -43,16 +43,13 @@ struct AlterCommand
         return (name_with_dot == name_type.name.substr(0, name_without_dot.length() + 1) || name_without_dot == name_type.name);
     }
 
-    void apply(NamesAndTypesList & columns,
-               NamesAndTypesList & materialized_columns,
-               NamesAndTypesList & alias_columns,
-               ColumnDefaults & column_defaults) const;
+    void apply(ColumnsDescription & columns_description) const;
 
     AlterCommand() = default;
     AlterCommand(const Type type, const String & column_name, const DataTypePtr & data_type,
-                 const ColumnDefaultType default_type, const ASTPtr & default_expression,
+                 const ColumnDefaultKind default_kind, const ASTPtr & default_expression,
                  const String & after_column = String{})
-        : type{type}, column_name{column_name}, data_type{data_type}, default_type{default_type},
+        : type{type}, column_name{column_name}, data_type{data_type}, default_kind{default_kind},
         default_expression{default_expression}, after_column{after_column}
     {}
 };
@@ -63,10 +60,7 @@ class Context;
 class AlterCommands : public std::vector<AlterCommand>
 {
 public:
-    void apply(NamesAndTypesList & columns,
-               NamesAndTypesList & materialized_columns,
-               NamesAndTypesList & alias_columns,
-               ColumnDefaults & column_defaults) const;
+    void apply(ColumnsDescription & columns_description) const;
 
     void validate(IStorage * table, const Context & context);
 };
diff --git a/dbms/src/Storages/ColumnDefault.cpp b/dbms/src/Storages/ColumnDefault.cpp
index dcdfe2a6e51..0ff885ab1e5 100644
--- a/dbms/src/Storages/ColumnDefault.cpp
+++ b/dbms/src/Storages/ColumnDefault.cpp
@@ -6,12 +6,12 @@ namespace DB
 {
 
 
-ColumnDefaultType columnDefaultTypeFromString(const std::string & str)
+ColumnDefaultKind columnDefaultKindFromString(const std::string & str)
 {
-    static const std::unordered_map<std::string, ColumnDefaultType> map{
-        { "DEFAULT", ColumnDefaultType::Default },
-        { "MATERIALIZED", ColumnDefaultType::Materialized },
-        { "ALIAS", ColumnDefaultType::Alias }
+    static const std::unordered_map<std::string, ColumnDefaultKind> map{
+        { "DEFAULT", ColumnDefaultKind::Default },
+        { "MATERIALIZED", ColumnDefaultKind::Materialized },
+        { "ALIAS", ColumnDefaultKind::Alias }
     };
 
     const auto it = map.find(str);
@@ -19,22 +19,22 @@ ColumnDefaultType columnDefaultTypeFromString(const std::string & str)
 }
 
 
-std::string toString(const ColumnDefaultType type)
+std::string toString(const ColumnDefaultKind kind)
 {
-    static const std::unordered_map<ColumnDefaultType, std::string> map{
-        { ColumnDefaultType::Default, "DEFAULT" },
-        { ColumnDefaultType::Materialized, "MATERIALIZED" },
-        { ColumnDefaultType::Alias, "ALIAS" }
+    static const std::unordered_map<ColumnDefaultKind, std::string> map{
+        { ColumnDefaultKind::Default, "DEFAULT" },
+        { ColumnDefaultKind::Materialized, "MATERIALIZED" },
+        { ColumnDefaultKind::Alias, "ALIAS" }
     };
 
-    const auto it = map.find(type);
-    return it != std::end(map) ? it->second : throw Exception{"Invalid ColumnDefaultType"};
+    const auto it = map.find(kind);
+    return it != std::end(map) ? it->second : throw Exception{"Invalid ColumnDefaultKind"};
 }
 
 
 bool operator==(const ColumnDefault & lhs, const ColumnDefault & rhs)
 {
-    return lhs.type == rhs.type && queryToString(lhs.expression) == queryToString(rhs.expression);
+    return lhs.kind == rhs.kind && queryToString(lhs.expression) == queryToString(rhs.expression);
 }
 
 }
diff --git a/dbms/src/Storages/ColumnDefault.h b/dbms/src/Storages/ColumnDefault.h
index 33f17952d08..95eb4d5b597 100644
--- a/dbms/src/Storages/ColumnDefault.h
+++ b/dbms/src/Storages/ColumnDefault.h
@@ -9,7 +9,7 @@
 namespace DB
 {
 
-enum class ColumnDefaultType
+enum class ColumnDefaultKind
 {
     Default,
     Materialized,
@@ -17,13 +17,13 @@ enum class ColumnDefaultType
 };
 
 
-ColumnDefaultType columnDefaultTypeFromString(const std::string & str);
-std::string toString(const ColumnDefaultType type);
+ColumnDefaultKind columnDefaultKindFromString(const std::string & str);
+std::string toString(const ColumnDefaultKind type);
 
 
 struct ColumnDefault
 {
-    ColumnDefaultType type;
+    ColumnDefaultKind kind;
     ASTPtr expression;
 };
 
diff --git a/dbms/src/Storages/ColumnsDescription.cpp b/dbms/src/Storages/ColumnsDescription.cpp
index c0bfabea727..d17f532b0ef 100644
--- a/dbms/src/Storages/ColumnsDescription.cpp
+++ b/dbms/src/Storages/ColumnsDescription.cpp
@@ -1,3 +1,4 @@
+#include <Storages/ColumnsDescription.h>
 #include <Parsers/ExpressionListParsers.h>
 #include <Parsers/parseQuery.h>
 #include <Parsers/queryToString.h>
@@ -7,8 +8,13 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteBufferFromString.h>
 #include <IO/ReadBufferFromString.h>
-#include <Storages/ColumnsDescription.h>
 #include <DataTypes/DataTypeFactory.h>
+#include <Common/Exception.h>
+
+#include <ext/collection_cast.h>
+#include <ext/map.h>
+
+#include <boost/range/join.hpp>
 
 
 namespace DB
@@ -16,17 +22,53 @@ namespace DB
 
 namespace ErrorCodes
 {
+    extern const int NO_SUCH_COLUMN_IN_TABLE;
     extern const int CANNOT_PARSE_TEXT;
 }
 
 
-template <bool store>
-String ColumnsDescription<store>::toString() const
+NamesAndTypesList ColumnsDescription::getAllPhysical() const
+{
+    return ext::collection_cast<NamesAndTypesList>(boost::join(ordinary, materialized));
+}
+
+
+NamesAndTypesList ColumnsDescription::getAll() const
+{
+    return ext::collection_cast<NamesAndTypesList>(boost::join(ordinary, boost::join(materialized, aliases)));
+}
+
+
+Names ColumnsDescription::getNamesOfPhysical() const
+{
+    return ext::map<Names>(boost::join(ordinary, materialized), [] (const auto & it) { return it.name; });
+}
+
+
+NameAndTypePair ColumnsDescription::getPhysical(const String & column_name) const
+{
+    for (auto & it : boost::join(ordinary, materialized))
+        if (it.name == column_name)
+            return it;
+    throw Exception("There is no column " + column_name + " in table.", ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
+}
+
+
+bool ColumnsDescription::hasPhysical(const String & column_name) const
+{
+    for (auto & it : boost::join(ordinary, materialized))
+        if (it.name == column_name)
+            return true;
+    return false;
+}
+
+
+String ColumnsDescription::toString() const
 {
     WriteBufferFromOwnString buf;
 
     writeString("columns format version: 1\n", buf);
-    writeText(columns.size() + materialized.size() + alias.size(), buf);
+    writeText(ordinary.size() + materialized.size() + aliases.size(), buf);
     writeString(" columns:\n", buf);
 
     const auto write_columns = [this, &buf] (const NamesAndTypesList & columns)
@@ -46,23 +88,22 @@ String ColumnsDescription<store>::toString() const
             else
                 writeChar('\t', buf);
 
-            writeString(DB::toString(it->second.type), buf);
+            writeString(DB::toString(it->second.kind), buf);
             writeChar('\t', buf);
             writeString(queryToString(it->second.expression), buf);
             writeChar('\n', buf);
         }
     };
 
-    write_columns(columns);
+    write_columns(ordinary);
     write_columns(materialized);
-    write_columns(alias);
+    write_columns(aliases);
 
     return buf.str();
 }
 
 
-template <>
-ColumnsDescription<true> ColumnsDescription<true>::parse(const String & str)
+ColumnsDescription ColumnsDescription::parse(const String & str)
 {
     ReadBufferFromString buf{str};
 
@@ -74,7 +115,7 @@ ColumnsDescription<true> ColumnsDescription<true>::parse(const String & str)
     ParserExpression expr_parser;
     const DataTypeFactory & data_type_factory = DataTypeFactory::instance();
 
-    ColumnsDescription<true> result{};
+    ColumnsDescription result;
     for (size_t i = 0; i < count; ++i)
     {
         String column_name;
@@ -88,14 +129,14 @@ ColumnsDescription<true> ColumnsDescription<true>::parse(const String & str)
         {
             assertChar('\n', buf);
 
-            result.columns.emplace_back(column_name, std::move(type));
+            result.ordinary.emplace_back(column_name, std::move(type));
             continue;
         }
         assertChar('\t', buf);
 
-        String default_type_str;
-        readString(default_type_str, buf);
-        const auto default_type = columnDefaultTypeFromString(default_type_str);
+        String default_kind_str;
+        readString(default_kind_str, buf);
+        const auto default_kind = columnDefaultKindFromString(default_kind_str);
         assertChar('\t', buf);
 
         String default_expr_str;
@@ -106,14 +147,14 @@ ColumnsDescription<true> ColumnsDescription<true>::parse(const String & str)
         const auto end = begin + default_expr_str.size();
         ASTPtr default_expr = parseQuery(expr_parser, begin, end, "default expression");
 
-        if (ColumnDefaultType::Default == default_type)
-            result.columns.emplace_back(column_name, std::move(type));
-        else if (ColumnDefaultType::Materialized == default_type)
+        if (ColumnDefaultKind::Default == default_kind)
+            result.ordinary.emplace_back(column_name, std::move(type));
+        else if (ColumnDefaultKind::Materialized == default_kind)
             result.materialized.emplace_back(column_name, std::move(type));
-        else if (ColumnDefaultType::Alias == default_type)
-            result.alias.emplace_back(column_name, std::move(type));
+        else if (ColumnDefaultKind::Alias == default_kind)
+            result.aliases.emplace_back(column_name, std::move(type));
 
-        result.defaults.emplace(column_name, ColumnDefault{default_type, default_expr});
+        result.defaults.emplace(column_name, ColumnDefault{default_kind, default_expr});
     }
 
     assertEOF(buf);
@@ -121,8 +162,4 @@ ColumnsDescription<true> ColumnsDescription<true>::parse(const String & str)
     return result;
 }
 
-
-template struct ColumnsDescription<false>;
-template struct ColumnsDescription<true>;
-
 }
diff --git a/dbms/src/Storages/ColumnsDescription.h b/dbms/src/Storages/ColumnsDescription.h
index cce6232d33b..288d2712b3b 100644
--- a/dbms/src/Storages/ColumnsDescription.h
+++ b/dbms/src/Storages/ColumnsDescription.h
@@ -1,28 +1,62 @@
 #pragma once
 
-#include <Storages/ColumnDefault.h>
 #include <Core/NamesAndTypes.h>
+#include <Core/Names.h>
+#include <Storages/ColumnDefault.h>
+#include <Core/Block.h>
 
 
 namespace DB
 {
 
-
-template <bool store>
 struct ColumnsDescription
 {
-    template <typename T>
-    using by_value_or_cref = std::conditional_t<store, T, const T &>;
+    NamesAndTypesList ordinary;
+    NamesAndTypesList materialized;
+    NamesAndTypesList aliases;
+    ColumnDefaults defaults;
+
+    ColumnsDescription() = default;
+
+    ColumnsDescription(
+        NamesAndTypesList ordinary_,
+        NamesAndTypesList materialized_,
+        NamesAndTypesList aliases_,
+        ColumnDefaults defaults_)
+        : ordinary(std::move(ordinary_))
+        , materialized(std::move(materialized_))
+        , aliases(std::move(aliases_))
+        , defaults(std::move(defaults_))
+    {}
+
+    explicit ColumnsDescription(NamesAndTypesList ordinary_) : ordinary(std::move(ordinary_)) {}
+
+    bool operator==(const ColumnsDescription & other) const
+    {
+        return ordinary == other.ordinary
+            && materialized == other.materialized
+            && aliases == other.aliases
+            && defaults == other.defaults;
+    }
+
+    bool operator!=(const ColumnsDescription & other) const { return !(*this == other); }
+
+    /// ordinary + materialized.
+    NamesAndTypesList getAllPhysical() const;
+
+    /// ordinary + materialized + aliases.
+    NamesAndTypesList getAll() const;
+
+    Names getNamesOfPhysical() const;
+
+    NameAndTypePair getPhysical(const String & column_name) const;
+
+    bool hasPhysical(const String & column_name) const;
 
-    by_value_or_cref<NamesAndTypesList> columns;
-    by_value_or_cref<NamesAndTypesList> materialized;
-    by_value_or_cref<NamesAndTypesList> alias;
-    by_value_or_cref<ColumnDefaults> defaults;
 
     String toString() const;
 
     static ColumnsDescription parse(const String & str);
 };
 
-
 }
diff --git a/dbms/src/Storages/Distributed/DirectoryMonitor.cpp b/dbms/src/Storages/Distributed/DirectoryMonitor.cpp
index 3a5aff3ab50..efbd217a608 100644
--- a/dbms/src/Storages/Distributed/DirectoryMonitor.cpp
+++ b/dbms/src/Storages/Distributed/DirectoryMonitor.cpp
@@ -468,7 +468,7 @@ bool StorageDistributedDirectoryMonitor::maybeMarkAsBroken(const std::string & f
 
 std::string StorageDistributedDirectoryMonitor::getLoggerName() const
 {
-    return storage.name + '.' + storage.getName() + ".DirectoryMonitor";
+    return storage.table_name + '.' + storage.getName() + ".DirectoryMonitor";
 }
 
 }
diff --git a/dbms/src/Storages/Distributed/DistributedBlockOutputStream.cpp b/dbms/src/Storages/Distributed/DistributedBlockOutputStream.cpp
index 8db08dfb09a..607eb9efb67 100644
--- a/dbms/src/Storages/Distributed/DistributedBlockOutputStream.cpp
+++ b/dbms/src/Storages/Distributed/DistributedBlockOutputStream.cpp
@@ -337,7 +337,10 @@ void DistributedBlockOutputStream::writeSuffix()
             throw;
         }
 
-        LOG_DEBUG(log, getCurrentStateDescription());
+        double elapsed = watch.elapsedSeconds();
+        LOG_DEBUG(log, "It took " << std::fixed << std::setprecision(1) << elapsed << " sec. to insert " << blocks_inserted << " blocks"
+                       << " (average " << std::fixed << std::setprecision(1) << elapsed / blocks_inserted * 1000 << " ms. per block)"
+                       << ". " << getCurrentStateDescription());
     }
 }
 
diff --git a/dbms/src/Storages/Distributed/DistributedBlockOutputStream.h b/dbms/src/Storages/Distributed/DistributedBlockOutputStream.h
index 199700d742c..eed38adf417 100644
--- a/dbms/src/Storages/Distributed/DistributedBlockOutputStream.h
+++ b/dbms/src/Storages/Distributed/DistributedBlockOutputStream.h
@@ -118,7 +118,7 @@ private:
 
     size_t remote_jobs_count = 0;
     size_t local_jobs_count = 0;
-
+    
     std::atomic<unsigned> finished_jobs_count{0};
 
     Poco::Logger * log;
diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index a2970b0de96..ef9fd8004ce 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -83,6 +83,10 @@ public:
     /// The main name of the table type (for example, StorageMergeTree).
     virtual std::string getName() const = 0;
 
+    /** The name of the table.
+      */
+    virtual std::string getTableName() const = 0;
+
     /** Returns true if the storage receives data from a remote server or servers. */
     virtual bool isRemote() const { return false; }
 
diff --git a/dbms/src/Storages/ITableDeclaration.cpp b/dbms/src/Storages/ITableDeclaration.cpp
index da4cc920608..9a6ac0e2538 100644
--- a/dbms/src/Storages/ITableDeclaration.cpp
+++ b/dbms/src/Storages/ITableDeclaration.cpp
@@ -1,13 +1,12 @@
-#include <unordered_set>
+#include <Storages/ITableDeclaration.h>
+#include <Common/Exception.h>
+
+#include <boost/range/join.hpp>
 #include <sparsehash/dense_hash_map>
 #include <sparsehash/dense_hash_set>
-#include <Storages/ITableDeclaration.h>
-#include <Parsers/ASTIdentifier.h>
-#include <Parsers/ASTNameTypePair.h>
-#include <Interpreters/Context.h>
-#include <ext/map.h>
-#include <ext/identity.h>
-#include <ext/collection_cast.h>
+
+#include <unordered_set>
+#include <sstream>
 
 
 namespace DB
@@ -25,77 +24,22 @@ namespace ErrorCodes
 }
 
 
-NamesAndTypesList ITableDeclaration::getColumnsList() const
+void ITableDeclaration::setColumns(ColumnsDescription columns_)
 {
-    return ext::collection_cast<NamesAndTypesList>(getColumnsListRange());
+    if (columns_.ordinary.empty())
+        throw Exception("Empty list of columns passed", ErrorCodes::EMPTY_LIST_OF_COLUMNS_PASSED);
+    columns = std::move(columns_);
 }
 
 
-ITableDeclaration::ColumnsListRange ITableDeclaration::getColumnsListRange() const
-{
-    return boost::join(getColumnsListImpl(), materialized_columns);
-}
-
-
-bool ITableDeclaration::hasRealColumn(const String & column_name) const
-{
-    for (auto & it : getColumnsListRange())
-        if (it.name == column_name)
-            return true;
-    return false;
-}
-
-
-Names ITableDeclaration::getColumnNamesList() const
-{
-    return ext::map<Names>(getColumnsListRange(), [] (const auto & it) { return it.name; });
-}
-
-
-NameAndTypePair ITableDeclaration::getRealColumn(const String & column_name) const
-{
-    for (auto & it : getColumnsListRange())
-        if (it.name == column_name)
-            return it;
-    throw Exception("There is no column " + column_name + " in table.", ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
-}
-
-NameAndTypePair ITableDeclaration::getMaterializedColumn(const String & column_name) const
-{
-    for (auto & column : materialized_columns)
-        if (column.name == column_name)
-            return column;
-
-    throw Exception("There is no column " + column_name + " in table.", ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
-}
-
-bool ITableDeclaration::hasMaterializedColumn(const String & column_name) const
-{
-    for (auto & column : materialized_columns)
-        if (column.name == column_name)
-            return true;
-
-    return false;
-}
-
 bool ITableDeclaration::hasColumn(const String & column_name) const
 {
-    return hasRealColumn(column_name); /// By default, we assume that there are no virtual columns in the storage.
+    return getColumns().hasPhysical(column_name); /// By default, we assume that there are no virtual columns in the storage.
 }
 
 NameAndTypePair ITableDeclaration::getColumn(const String & column_name) const
 {
-    return getRealColumn(column_name); /// By default, we assume that there are no virtual columns in the storage.
-}
-
-
-const DataTypePtr ITableDeclaration::getDataTypeByName(const String & column_name) const
-{
-    for (const auto & column : getColumnsListRange())
-        if (column.name == column_name)
-            return column.type;
-
-    throw Exception("There is no column " + column_name + " in table.", ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
+    return getColumns().getPhysical(column_name); /// By default, we assume that there are no virtual columns in the storage.
 }
 
 
@@ -103,7 +47,7 @@ Block ITableDeclaration::getSampleBlock() const
 {
     Block res;
 
-    for (const auto & col : getColumnsListRange())
+    for (const auto & col : boost::join(getColumns().ordinary, getColumns().materialized))
         res.insert({ col.type->createColumn(), col.type, col.name });
 
     return res;
@@ -114,7 +58,7 @@ Block ITableDeclaration::getSampleBlockNonMaterialized() const
 {
     Block res;
 
-    for (const auto & col : getColumnsListNonMaterialized())
+    for (const auto & col : getColumns().ordinary)
         res.insert({ col.type->createColumn(), col.type, col.name });
 
     return res;
@@ -138,7 +82,7 @@ Block ITableDeclaration::getSampleBlockForColumns(const Names & column_names) co
 static std::string listOfColumns(const NamesAndTypesList & available_columns)
 {
     std::stringstream s;
-    for (NamesAndTypesList::const_iterator it = available_columns.begin(); it != available_columns.end(); ++it)
+    for (auto it = available_columns.begin(); it != available_columns.end(); ++it)
     {
         if (it != available_columns.begin())
             s << ", ";
@@ -175,7 +119,7 @@ static NamesAndTypesMap getColumnsMap(const Args &... args)
 
 void ITableDeclaration::check(const Names & column_names) const
 {
-    const NamesAndTypesList & available_columns = getColumnsList();
+    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
 
     if (column_names.empty())
         throw Exception("Empty list of columns queried. There are columns: " + listOfColumns(available_columns),
@@ -201,16 +145,16 @@ void ITableDeclaration::check(const Names & column_names) const
 }
 
 
-void ITableDeclaration::check(const NamesAndTypesList & columns) const
+void ITableDeclaration::check(const NamesAndTypesList & provided_columns) const
 {
-    const NamesAndTypesList & available_columns = getColumnsList();
+    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
     const auto columns_map = getColumnsMap(available_columns);
 
     using UniqueStrings = google::dense_hash_set<StringRef, StringRefHash>;
     UniqueStrings unique_names;
     unique_names.set_empty_key(StringRef());
 
-    for (const NameAndTypePair & column : columns)
+    for (const NameAndTypePair & column : provided_columns)
     {
         NamesAndTypesMap::const_iterator it = columns_map.find(column.name);
         if (columns_map.end() == it)
@@ -229,11 +173,11 @@ void ITableDeclaration::check(const NamesAndTypesList & columns) const
 }
 
 
-void ITableDeclaration::check(const NamesAndTypesList & columns, const Names & column_names) const
+void ITableDeclaration::check(const NamesAndTypesList & provided_columns, const Names & column_names) const
 {
-    const NamesAndTypesList & available_columns = getColumnsList();
+    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
     const auto available_columns_map = getColumnsMap(available_columns);
-    const NamesAndTypesMap & provided_columns_map = getColumnsMap(columns);
+    const NamesAndTypesMap & provided_columns_map = getColumnsMap(provided_columns);
 
     if (column_names.empty())
         throw Exception("Empty list of columns queried. There are columns: " + listOfColumns(available_columns),
@@ -268,7 +212,7 @@ void ITableDeclaration::check(const NamesAndTypesList & columns, const Names & c
 
 void ITableDeclaration::check(const Block & block, bool need_all) const
 {
-    const NamesAndTypesList & available_columns = getColumnsList();
+    const NamesAndTypesList & available_columns = getColumns().getAllPhysical();
     const auto columns_map = getColumnsMap(available_columns);
 
     using NameSet = std::unordered_set<String>;
@@ -304,15 +248,10 @@ void ITableDeclaration::check(const Block & block, bool need_all) const
     }
 }
 
-ITableDeclaration::ITableDeclaration(const NamesAndTypesList & columns, const NamesAndTypesList & materialized_columns,
-                                     const NamesAndTypesList & alias_columns, const ColumnDefaults & column_defaults)
-    : columns{columns},
-      materialized_columns{materialized_columns},
-      alias_columns{alias_columns},
-      column_defaults{column_defaults}
+
+ITableDeclaration::ITableDeclaration(ColumnsDescription columns_)
 {
-    if (columns.empty())
-        throw Exception("Empty list of columns passed to storage constructor", ErrorCodes::EMPTY_LIST_OF_COLUMNS_PASSED);
+    setColumns(std::move(columns_));
 }
 
 }
diff --git a/dbms/src/Storages/ITableDeclaration.h b/dbms/src/Storages/ITableDeclaration.h
index 841ebc6c753..270ab175576 100644
--- a/dbms/src/Storages/ITableDeclaration.h
+++ b/dbms/src/Storages/ITableDeclaration.h
@@ -1,62 +1,25 @@
 #pragma once
 
-#include <Core/Names.h>
-#include <Core/NamesAndTypes.h>
-#include <Common/Exception.h>
-#include <Core/Block.h>
-#include <Storages/ColumnDefault.h>
-
-#include <boost/range/iterator_range.hpp>
-#include <boost/range/join.hpp>
+#include <Storages/ColumnsDescription.h>
 
 
 namespace DB
 {
 
-class Context;
-
 /** Description of the table.
-  * Do not thread safe. See IStorage::lockStructure ().
+  * Is not thread safe. See IStorage::lockStructure ().
   */
 class ITableDeclaration
 {
 public:
-    /** The name of the table.
-      */
-    virtual std::string getTableName() const = 0;
+    virtual const ColumnsDescription & getColumns() const { return columns; }
+    virtual void setColumns(ColumnsDescription columns_);
 
-    /** Get a list of names and table column types, only non-virtual.
-      */
-    NamesAndTypesList getColumnsList() const;
-    const NamesAndTypesList & getColumnsListNonMaterialized() const { return getColumnsListImpl(); }
-
-    /** Get a list of column table names, only non-virtual.
-      */
-    virtual Names getColumnNamesList() const;
-
-    /** Get a description of the real (non-virtual) column by its name.
-      */
-    virtual NameAndTypePair getRealColumn(const String & column_name) const;
-
-    /** Is there a real (non-virtual) column with that name.
-      */
-    virtual bool hasRealColumn(const String & column_name) const;
-
-    NameAndTypePair getMaterializedColumn(const String & column_name) const;
-    bool hasMaterializedColumn(const String & column_name) const;
-
-    /** Get a description of any column by its name.
-      */
+    /// NOTE: These methods should include virtual columns, but should NOT include ALIAS columns
+    /// (they are treated separately).
     virtual NameAndTypePair getColumn(const String & column_name) const;
-
-    /** Is there a column with that name.
-      */
     virtual bool hasColumn(const String & column_name) const;
 
-    const DataTypePtr getDataTypeByName(const String & column_name) const;
-
-    /** The same, but in the form of a block-sample.
-      */
     Block getSampleBlock() const;
     Block getSampleBlockNonMaterialized() const;
     Block getSampleBlockForColumns(const Names & column_names) const;
@@ -81,29 +44,12 @@ public:
     void check(const Block & block, bool need_all = false) const;
 
 
+    ITableDeclaration() = default;
+    explicit ITableDeclaration(ColumnsDescription columns_);
     virtual ~ITableDeclaration() = default;
 
-    ITableDeclaration() = default;
-    ITableDeclaration(
-        const NamesAndTypesList & columns,
-        const NamesAndTypesList & materialized_columns,
-        const NamesAndTypesList & alias_columns,
-        const ColumnDefaults & column_defaults);
-
-    NamesAndTypesList columns;
-    NamesAndTypesList materialized_columns;
-    NamesAndTypesList alias_columns;
-    ColumnDefaults column_defaults;
-
 private:
-    virtual const NamesAndTypesList & getColumnsListImpl() const
-    {
-        return columns;
-    }
-
-    using ColumnsListRange = boost::range::joined_range<const NamesAndTypesList, const NamesAndTypesList>;
-    /// Returns a lazily joined range of table's ordinary and materialized columns, without unnecessary copying
-    ColumnsListRange getColumnsListRange() const;
+    ColumnsDescription columns;
 };
 
 }
diff --git a/dbms/src/Storages/MergeTree/AbandonableLockInZooKeeper.h b/dbms/src/Storages/MergeTree/AbandonableLockInZooKeeper.h
index 96ccd5d4dfc..35f56fa429f 100644
--- a/dbms/src/Storages/MergeTree/AbandonableLockInZooKeeper.h
+++ b/dbms/src/Storages/MergeTree/AbandonableLockInZooKeeper.h
@@ -19,7 +19,7 @@ namespace ErrorCodes
   * When the destructor is called or the session ends in ZooKeeper, it goes into the ABANDONED state.
   * (Including when the program is halted).
   */
-class AbandonableLockInZooKeeper : private boost::noncopyable
+class AbandonableLockInZooKeeper : public boost::noncopyable
 {
 public:
     enum State
@@ -31,44 +31,52 @@ public:
 
     AbandonableLockInZooKeeper(
         const String & path_prefix_, const String & temp_path, zkutil::ZooKeeper & zookeeper_, zkutil::Ops * precheck_ops = nullptr)
-        : zookeeper(zookeeper_), path_prefix(path_prefix_)
+        : zookeeper(&zookeeper_), path_prefix(path_prefix_)
     {
         String abandonable_path = temp_path + "/abandonable_lock-";
 
         /// Let's create an secondary ephemeral node.
         if (!precheck_ops || precheck_ops->empty())
         {
-            holder_path = zookeeper.create(abandonable_path, "", zkutil::CreateMode::EphemeralSequential);
+            holder_path = zookeeper->create(abandonable_path, "", zkutil::CreateMode::EphemeralSequential);
         }
         else
         {
-            precheck_ops->emplace_back(std::make_unique<zkutil::Op::Create>(
-                abandonable_path, "", zookeeper.getDefaultACL(), zkutil::CreateMode::EphemeralSequential));
+            precheck_ops->emplace_back(std::make_shared<zkutil::Op::Create>(
+                abandonable_path, "", zookeeper->getDefaultACL(), zkutil::CreateMode::EphemeralSequential));
 
-            if (zookeeper.tryMultiUnsafe(*precheck_ops, precheck_info) != ZOK)
-                return;
+            zkutil::OpResultsPtr op_results = zookeeper->multi(*precheck_ops);
 
-            holder_path = precheck_info.op_results->back().value;
+            holder_path = op_results->back().value;
         }
 
         /// Write the path to the secondary node in the main node.
-        path = zookeeper.create(path_prefix, holder_path, zkutil::CreateMode::PersistentSequential);
+        path = zookeeper->create(path_prefix, holder_path, zkutil::CreateMode::PersistentSequential);
 
         if (path.size() <= path_prefix.size())
             throw Exception("Logical error: name of sequential node is shorter than prefix.", ErrorCodes::LOGICAL_ERROR);
     }
 
-    AbandonableLockInZooKeeper(AbandonableLockInZooKeeper && rhs)
-        : zookeeper(rhs.zookeeper)
+    AbandonableLockInZooKeeper() = default;
+
+    AbandonableLockInZooKeeper(AbandonableLockInZooKeeper && rhs) noexcept
     {
-        std::swap(path_prefix, rhs.path_prefix);
-        std::swap(path, rhs.path);
-        std::swap(holder_path, rhs.holder_path);
+        *this = std::move(rhs);
+    }
+
+    AbandonableLockInZooKeeper & operator=(AbandonableLockInZooKeeper && rhs) noexcept
+    {
+        zookeeper = rhs.zookeeper;
+        rhs.zookeeper = nullptr;
+        path_prefix = std::move(rhs.path_prefix);
+        path = std::move(rhs.path);
+        holder_path = std::move(rhs.holder_path);
+        return *this;
     }
 
     bool isCreated() const
     {
-        return !holder_path.empty() && !path.empty();
+        return zookeeper && !holder_path.empty() && !path.empty();
     }
 
     String getPath() const
@@ -87,8 +95,8 @@ public:
     void unlock()
     {
         checkCreated();
-        zookeeper.remove(path);
-        zookeeper.remove(holder_path);
+        zookeeper->remove(path);
+        zookeeper->remove(holder_path);
         holder_path = "";
     }
 
@@ -96,8 +104,15 @@ public:
     void getUnlockOps(zkutil::Ops & ops)
     {
         checkCreated();
-        ops.emplace_back(std::make_unique<zkutil::Op::Remove>(path, -1));
-        ops.emplace_back(std::make_unique<zkutil::Op::Remove>(holder_path, -1));
+        ops.emplace_back(std::make_shared<zkutil::Op::Remove>(path, -1));
+        ops.emplace_back(std::make_shared<zkutil::Op::Remove>(holder_path, -1));
+    }
+
+    /// Do not delete nodes in destructor. You may call this method after 'getUnlockOps' and successful execution of these ops,
+    ///  because the nodes will be already deleted.
+    void assumeUnlocked()
+    {
+        holder_path.clear();
     }
 
     void checkCreated() const
@@ -108,13 +123,13 @@ public:
 
     ~AbandonableLockInZooKeeper()
     {
-        if (holder_path.empty())
+        if (!zookeeper || holder_path.empty())
             return;
 
         try
         {
-            zookeeper.tryRemoveEphemeralNodeWithRetries(holder_path);
-            zookeeper.trySet(path, ""); /// It's not necessary.
+            zookeeper->tryRemoveEphemeralNodeWithRetries(holder_path);
+            zookeeper->trySet(path, ""); /// It's not necessary.
         }
         catch (...)
         {
@@ -153,15 +168,10 @@ public:
     }
 
 private:
-    zkutil::ZooKeeper & zookeeper;
+    zkutil::ZooKeeper * zookeeper = nullptr;
     String path_prefix;
     String path;
     String holder_path;
-
-public:
-    /// Contains information about execution of passed precheck ops and block-creation payload
-    /// TODO: quite ugly interface to handle precheck ops
-    zkutil::MultiTransactionInfo precheck_info;
 };
 
 }
diff --git a/dbms/src/Storages/MergeTree/DataPartsExchange.cpp b/dbms/src/Storages/MergeTree/DataPartsExchange.cpp
index e2c884681d3..b2ff96e0fe3 100644
--- a/dbms/src/Storages/MergeTree/DataPartsExchange.cpp
+++ b/dbms/src/Storages/MergeTree/DataPartsExchange.cpp
@@ -1,4 +1,5 @@
 #include <Storages/MergeTree/DataPartsExchange.h>
+#include <Storages/IStorage.h>
 #include <Common/CurrentMetrics.h>
 #include <Common/NetException.h>
 #include <Common/typeid_cast.h>
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
index b5095e79118..0cd903038ed 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
@@ -216,7 +216,7 @@ Block MergeTreeBaseBlockInputStream::readFromPart()
             }
 
             progressImpl({ res.rows(), res.bytes() });
-            pre_reader->fillMissingColumns(res, task->ordered_names, task->should_reorder);
+            pre_reader->fillMissingColumns(res, task->ordered_names, task->should_reorder, res.rows());
 
             /// Compute the expression in PREWHERE.
             prewhere_actions->execute(res);
@@ -396,7 +396,7 @@ Block MergeTreeBaseBlockInputStream::readFromPart()
                 ///  as a result of reading components of Nested data structures with no data in filesystem.
                 /// We must fill these arrays to filter them correctly.
 
-                reader->fillMissingColumns(res, task->ordered_names, task->should_reorder);
+                reader->fillMissingColumns(res, task->ordered_names, task->should_reorder, post_filter.size(), true);
 
                 /// Filter the columns related to PREWHERE using pre_filter,
                 ///  other columns - using post_filter.
@@ -422,7 +422,7 @@ Block MergeTreeBaseBlockInputStream::readFromPart()
                 if (task->size_predictor)
                     task->size_predictor->update(res);
 
-                reader->fillMissingColumns(res, task->ordered_names, true);
+                reader->fillMissingColumns(res, task->ordered_names, true, res.rows());
 
                 res.checkNumberOfRows();
             }
@@ -464,7 +464,7 @@ Block MergeTreeBaseBlockInputStream::readFromPart()
             return res;
 
         progressImpl({ res.rows(), res.bytes() });
-        reader->fillMissingColumns(res, task->ordered_names, task->should_reorder);
+        reader->fillMissingColumns(res, task->ordered_names, task->should_reorder, res.rows());
     }
 
     return res;
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.cpp b/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.cpp
index e0a8dc94400..1e9cea1887f 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.cpp
@@ -141,8 +141,9 @@ try
         if (!column_names.empty())
             storage.check(data_part->columns, column_names);
 
-        pre_columns = storage.getColumnsList().addTypes(pre_column_names);
-        columns = storage.getColumnsList().addTypes(column_names);
+        const NamesAndTypesList & physical_columns = storage.getColumns().getAllPhysical();
+        pre_columns = physical_columns.addTypes(pre_column_names);
+        columns = physical_columns.addTypes(column_names);
     }
     else
     {
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp b/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp
index b0b09ae06eb..5d52eedfda1 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp
@@ -26,9 +26,9 @@ NameSet injectRequiredColumns(const MergeTreeData & storage, const MergeTreeData
             continue;
         }
 
-        const auto default_it = storage.column_defaults.find(column_name);
+        const auto default_it = storage.getColumns().defaults.find(column_name);
         /// columns has no explicit default expression
-        if (default_it == std::end(storage.column_defaults))
+        if (default_it == std::end(storage.getColumns().defaults))
             continue;
 
         /// collect identifiers required for evaluation
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.h b/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.h
index b694b4535da..055581eb518 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.h
@@ -1,8 +1,11 @@
 #pragma once
+
+#include <optional>
 #include <Core/NamesAndTypes.h>
 #include <Storages/MergeTree/RangesInDataPart.h>
 #include <Storages/MergeTree/MergeTreeRangeReader.h>
 
+
 namespace DB
 {
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.cpp b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
index 392c45a7cc7..ef4b8022323 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
@@ -80,10 +80,7 @@ namespace ErrorCodes
 
 MergeTreeData::MergeTreeData(
     const String & database_, const String & table_,
-    const String & full_path_, const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const String & full_path_, const ColumnsDescription & columns_,
     Context & context_,
     const ASTPtr & primary_expr_ast_,
     const ASTPtr & secondary_sort_expr_ast_,
@@ -95,7 +92,7 @@ MergeTreeData::MergeTreeData(
     bool require_part_metadata_,
     bool attach,
     BrokenPartCallback broken_part_callback_)
-    : ITableDeclaration{columns_, materialized_columns_, alias_columns_, column_defaults_},
+    : ITableDeclaration{columns_},
     context(context_),
     sampling_expression(sampling_expression_),
     index_granularity(settings_.index_granularity),
@@ -113,7 +110,7 @@ MergeTreeData::MergeTreeData(
     data_parts_by_state_and_info(data_parts_indexes.get<TagByStateAndInfo>())
 {
     /// NOTE: using the same columns list as is read when performing actual merges.
-    merging_params.check(getColumnsList());
+    merging_params.check(getColumns().getAllPhysical());
 
     if (!primary_expr_ast)
         throw Exception("Primary key cannot be empty", ErrorCodes::BAD_ARGUMENTS);
@@ -225,11 +222,11 @@ void MergeTreeData::initPrimaryKey()
     primary_sort_descr.clear();
     addSortDescription(primary_sort_descr, primary_expr_ast);
 
-    primary_expr = ExpressionAnalyzer(primary_expr_ast, context, nullptr, getColumnsList()).getActions(false);
+    primary_expr = ExpressionAnalyzer(primary_expr_ast, context, nullptr, getColumns().getAllPhysical()).getActions(false);
 
     {
         ExpressionActionsPtr projected_expr =
-                ExpressionAnalyzer(primary_expr_ast, context, nullptr, getColumnsList()).getActions(true);
+            ExpressionAnalyzer(primary_expr_ast, context, nullptr, getColumns().getAllPhysical()).getActions(true);
         primary_key_sample = projected_expr->getSampleBlock();
     }
 
@@ -244,10 +241,10 @@ void MergeTreeData::initPrimaryKey()
     if (secondary_sort_expr_ast)
     {
         addSortDescription(sort_descr, secondary_sort_expr_ast);
-        secondary_sort_expr = ExpressionAnalyzer(secondary_sort_expr_ast, context, nullptr, getColumnsList()).getActions(false);
+        secondary_sort_expr = ExpressionAnalyzer(secondary_sort_expr_ast, context, nullptr, getColumns().getAllPhysical()).getActions(false);
 
         ExpressionActionsPtr projected_expr =
-                ExpressionAnalyzer(secondary_sort_expr_ast, context, nullptr, getColumnsList()).getActions(true);
+            ExpressionAnalyzer(secondary_sort_expr_ast, context, nullptr, getColumns().getAllPhysical()).getActions(true);
         auto secondary_key_sample = projected_expr->getSampleBlock();
 
         checkKeyExpression(*secondary_sort_expr, secondary_key_sample, "Secondary");
@@ -260,7 +257,7 @@ void MergeTreeData::initPartitionKey()
     if (!partition_expr_ast || partition_expr_ast->children.empty())
         return;
 
-    partition_expr = ExpressionAnalyzer(partition_expr_ast, context, nullptr, getColumnsList()).getActions(false);
+    partition_expr = ExpressionAnalyzer(partition_expr_ast, context, nullptr, getColumns().getAllPhysical()).getActions(false);
     for (const ASTPtr & ast : partition_expr_ast->children)
     {
         String col_name = ast->getColumnName();
@@ -864,11 +861,8 @@ bool isMetadataOnlyConversion(const IDataType * from, const IDataType * to)
 void MergeTreeData::checkAlter(const AlterCommands & commands)
 {
     /// Check that needed transformations can be applied to the list of columns without considering type conversions.
-    auto new_columns = columns;
-    auto new_materialized_columns = materialized_columns;
-    auto new_alias_columns = alias_columns;
-    auto new_column_defaults = column_defaults;
-    commands.apply(new_columns, new_materialized_columns, new_alias_columns, new_column_defaults);
+    auto new_columns = getColumns();
+    commands.apply(new_columns);
 
     /// Set of columns that shouldn't be altered.
     NameSet columns_alter_forbidden;
@@ -909,7 +903,7 @@ void MergeTreeData::checkAlter(const AlterCommands & commands)
         columns_alter_forbidden.insert(merging_params.sign_column);
 
     std::map<String, const IDataType *> old_types;
-    for (const auto & column : columns)
+    for (const auto & column : getColumns().getAllPhysical())
         old_types.emplace(column.name, column.type.get());
 
     for (const AlterCommand & command : commands)
@@ -937,11 +931,7 @@ void MergeTreeData::checkAlter(const AlterCommands & commands)
     NameToNameMap unused_map;
     bool unused_bool;
 
-    /// augment plain columns with materialized columns for convert expression creation
-    new_columns.insert(std::end(new_columns),
-        std::begin(new_materialized_columns), std::end(new_materialized_columns));
-
-    createConvertExpression(nullptr, getColumnsList(), new_columns, unused_expression, unused_map, unused_bool);
+    createConvertExpression(nullptr, getColumns().getAllPhysical(), new_columns.getAllPhysical(), unused_expression, unused_map, unused_bool);
 }
 
 void MergeTreeData::createConvertExpression(const DataPartPtr & part, const NamesAndTypesList & old_columns, const NamesAndTypesList & new_columns,
@@ -1845,7 +1835,7 @@ void MergeTreeData::addPartContributionToColumnSizes(const DataPartPtr & part)
     const auto & files = part->checksums.files;
 
     /// TODO This method doesn't take into account columns with multiple files.
-    for (const auto & column : getColumnsList())
+    for (const auto & column : getColumns().getAllPhysical())
     {
         const auto escaped_name = escapeForFileName(column.name);
         const auto bin_file_name = escaped_name + ".bin";
@@ -1878,7 +1868,7 @@ void MergeTreeData::removePartContributionToColumnSizes(const DataPartPtr & part
     const auto & files = part->checksums.files;
 
     /// TODO This method doesn't take into account columns with multiple files.
-    for (const auto & column : columns)
+    for (const auto & column : getColumns().getAllPhysical())
     {
         const auto escaped_name = escapeForFileName(column.name);
         const auto bin_file_name = escaped_name + ".bin";
@@ -2204,7 +2194,7 @@ MergeTreeData::DataPartsVector MergeTreeData::Transaction::commit()
     return total_covered_parts;
 }
 
-bool MergeTreeData::isPrimaryKeyColumn(const ASTPtr &node) const
+bool MergeTreeData::isPrimaryKeyColumnPossiblyWrappedInFunctions(const ASTPtr & node) const
 {
     String column_name = node->getColumnName();
 
@@ -2212,6 +2202,10 @@ bool MergeTreeData::isPrimaryKeyColumn(const ASTPtr &node) const
         if (column_name == column.column_name)
             return true;
 
+    if (const ASTFunction * func = typeid_cast<const ASTFunction *>(node.get()))
+        if (func->arguments->children.size() == 1)
+            return isPrimaryKeyColumnPossiblyWrappedInFunctions(func->arguments->children.front());
+
     return false;
 }
 
@@ -2223,16 +2217,16 @@ bool MergeTreeData::mayBenefitFromIndexForIn(const ASTPtr & left_in_operand) con
     if (left_in_operand_tuple && left_in_operand_tuple->name == "tuple")
     {
         for (const auto & item : left_in_operand_tuple->arguments->children)
-            if (!isPrimaryKeyColumn(item))
+            if (!isPrimaryKeyColumnPossiblyWrappedInFunctions(item))
                 /// The tuple itself may be part of the primary key, so check that as a last resort.
-                return isPrimaryKeyColumn(left_in_operand);
+                return isPrimaryKeyColumnPossiblyWrappedInFunctions(left_in_operand);
 
         /// tuple() is invalid but can still be found here since this method may be called before the arguments are validated.
         return !left_in_operand_tuple->arguments->children.empty();
     }
     else
     {
-        return isPrimaryKeyColumn(left_in_operand);
+        return isPrimaryKeyColumnPossiblyWrappedInFunctions(left_in_operand);
     }
 }
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.h b/dbms/src/Storages/MergeTree/MergeTreeData.h
index 519e7223d13..47abd959645 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.h
@@ -4,7 +4,8 @@
 #include <Common/SimpleIncrement.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/ExpressionActions.h>
-#include <Storages/IStorage.h>
+#include <Storages/ITableDeclaration.h>
+#include <Storages/AlterCommands.h>
 #include <Storages/MergeTree/MergeTreePartInfo.h>
 #include <Storages/MergeTree/MergeTreeSettings.h>
 #include <IO/ReadBufferFromString.h>
@@ -270,10 +271,8 @@ public:
     /// require_part_metadata - should checksums.txt and columns.txt exist in the part directory.
     /// attach - whether the existing table is attached or the new table is created.
     MergeTreeData(const String & database_, const String & table_,
-                  const String & full_path_, const NamesAndTypesList & columns_,
-                  const NamesAndTypesList & materialized_columns_,
-                  const NamesAndTypesList & alias_columns_,
-                  const ColumnDefaults & column_defaults_,
+                  const String & full_path_,
+                  const ColumnsDescription & columns_,
                   Context & context_,
                   const ASTPtr & primary_expr_ast_,
                   const ASTPtr & secondary_sort_expr_ast_,
@@ -305,8 +304,6 @@ public:
 
     Int64 getMaxDataPartIndex();
 
-    const NamesAndTypesList & getColumnsListImpl() const override { return columns; }
-
     NameAndTypePair getColumn(const String & column_name) const override
     {
         if (column_name == "_part")
@@ -316,12 +313,12 @@ public:
         if (column_name == "_sample_factor")
             return NameAndTypePair("_sample_factor", std::make_shared<DataTypeFloat64>());
 
-        return ITableDeclaration::getColumn(column_name);
+        return getColumns().getPhysical(column_name);
     }
 
     bool hasColumn(const String & column_name) const override
     {
-        return ITableDeclaration::hasColumn(column_name)
+        return getColumns().hasPhysical(column_name)
             || column_name == "_part"
             || column_name == "_part_index"
             || column_name == "_sample_factor";
@@ -329,7 +326,7 @@ public:
 
     String getDatabaseName() const { return database_name; }
 
-    String getTableName() const override { return table_name; }
+    String getTableName() const { return table_name; }
 
     String getFullPath() const { return full_path; }
 
@@ -431,9 +428,6 @@ public:
         const ASTPtr & new_primary_key,
         bool skip_sanity_checks);
 
-    /// Must be called with locked lockStructureForAlter().
-    void setColumnsList(const NamesAndTypesList & new_columns) { columns = new_columns; }
-
     /// Should be called if part data is suspected to be corrupted.
     void reportBrokenPart(const String & name)
     {
@@ -507,6 +501,7 @@ public:
     /// For ATTACH/DETACH/DROP PARTITION.
     String getPartitionIDFromQuery(const ASTPtr & partition, const Context & context);
 
+
     MergeTreeDataFormatVersion format_version;
 
     Context & context;
@@ -680,8 +675,8 @@ private:
         DataPartPtr & out_covering_part,
         std::lock_guard<std::mutex> & data_parts_lock) const;
 
-    /// Checks whether the column is in the primary key.
-    bool isPrimaryKeyColumn(const ASTPtr &node) const;
+    /// Checks whether the column is in the primary key, possibly wrapped in a chain of functions with single argument.
+    bool isPrimaryKeyColumnPossiblyWrappedInFunctions(const ASTPtr &node) const;
 };
 
 }
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
index cf9e6eef15c..ae8677c57be 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
@@ -330,12 +330,12 @@ static void extractMergingAndGatheringColumns(const NamesAndTypesList & all_colu
     NamesAndTypesList & merging_columns, Names & merging_column_names
 )
 {
-    Names primary_key_columns_dup = primary_key_expressions->getRequiredColumns();
-    std::set<String> key_columns(primary_key_columns_dup.cbegin(), primary_key_columns_dup.cend());
+    Names primary_key_columns_vec = primary_key_expressions->getRequiredColumns();
+    std::set<String> key_columns(primary_key_columns_vec.cbegin(), primary_key_columns_vec.cend());
     if (secondary_key_expressions)
     {
-        Names secondary_key_columns_dup = secondary_key_expressions->getRequiredColumns();
-        key_columns.insert(secondary_key_columns_dup.begin(), secondary_key_columns_dup.end());
+        Names secondary_key_columns_vec = secondary_key_expressions->getRequiredColumns();
+        key_columns.insert(secondary_key_columns_vec.begin(), secondary_key_columns_vec.end());
     }
 
     /// Force sign column for Collapsing mode
@@ -350,6 +350,10 @@ static void extractMergingAndGatheringColumns(const NamesAndTypesList & all_colu
     if (merging_params.mode == MergeTreeData::MergingParams::VersionedCollapsing)
         key_columns.emplace(merging_params.sign_column);
 
+    /// Force to merge at least one column in case of empty key
+    if (key_columns.empty())
+        key_columns.emplace(all_columns.front().name);
+
     /// TODO: also force "summing" and "aggregating" columns to make Horizontal merge only for such columns
 
     for (auto & column : all_columns)
@@ -536,8 +540,8 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMerger::mergePartsToTemporaryPart
     for (const MergeTreeData::DataPartPtr & part : parts)
         part->accumulateColumnSizes(merged_column_to_size);
 
-    Names all_column_names = data.getColumnNamesList();
-    NamesAndTypesList all_columns = data.getColumnsList();
+    Names all_column_names = data.getColumns().getNamesOfPhysical();
+    NamesAndTypesList all_columns = data.getColumns().getAllPhysical();
     const SortDescription sort_desc = data.getSortDescription();
 
     NamesAndTypesList gathering_columns, merging_columns;
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
index df273f2d6b5..79f3ddb523f 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
@@ -1,3 +1,5 @@
+#include <optional>
+
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <IO/CompressedStream.h>
@@ -28,273 +30,15 @@ namespace DB
 
 namespace ErrorCodes
 {
-    extern const int CHECKSUM_DOESNT_MATCH;
     extern const int FILE_DOESNT_EXIST;
     extern const int NO_FILE_IN_DATA_PART;
     extern const int EXPECTED_END_OF_FILE;
-    extern const int BAD_SIZE_OF_FILE_IN_DATA_PART;
     extern const int CORRUPTED_DATA;
-    extern const int FORMAT_VERSION_TOO_OLD;
-    extern const int UNKNOWN_FORMAT;
-    extern const int UNEXPECTED_FILE_IN_DATA_PART;
     extern const int NOT_FOUND_EXPECTED_DATA_PART;
+    extern const int BAD_SIZE_OF_FILE_IN_DATA_PART;
 }
 
 
-void MergeTreeDataPartChecksum::checkEqual(const MergeTreeDataPartChecksum & rhs, bool have_uncompressed, const String & name) const
-{
-    if (is_compressed && have_uncompressed)
-    {
-        if (!rhs.is_compressed)
-            throw Exception("No uncompressed checksum for file " + name, ErrorCodes::CHECKSUM_DOESNT_MATCH);
-        if (rhs.uncompressed_size != uncompressed_size)
-            throw Exception("Unexpected uncompressed size of file " + name + " in data part", ErrorCodes::BAD_SIZE_OF_FILE_IN_DATA_PART);
-        if (rhs.uncompressed_hash != uncompressed_hash)
-            throw Exception("Checksum mismatch for uncompressed file " + name + " in data part", ErrorCodes::CHECKSUM_DOESNT_MATCH);
-        return;
-    }
-    if (rhs.file_size != file_size)
-        throw Exception("Unexpected size of file " + name + " in data part", ErrorCodes::BAD_SIZE_OF_FILE_IN_DATA_PART);
-    if (rhs.file_hash != file_hash)
-        throw Exception("Checksum mismatch for file " + name + " in data part", ErrorCodes::CHECKSUM_DOESNT_MATCH);
-}
-
-void MergeTreeDataPartChecksum::checkSize(const String & path) const
-{
-    Poco::File file(path);
-    if (!file.exists())
-        throw Exception(path + " doesn't exist", ErrorCodes::FILE_DOESNT_EXIST);
-    UInt64 size = file.getSize();
-    if (size != file_size)
-        throw Exception(path + " has unexpected size: " + toString(size) + " instead of " + toString(file_size),
-            ErrorCodes::BAD_SIZE_OF_FILE_IN_DATA_PART);
-}
-
-
-void MergeTreeDataPartChecksums::checkEqual(const MergeTreeDataPartChecksums & rhs, bool have_uncompressed) const
-{
-    for (const auto & it : rhs.files)
-    {
-        const String & name = it.first;
-
-        if (!files.count(name))
-            throw Exception("Unexpected file " + name + " in data part", ErrorCodes::UNEXPECTED_FILE_IN_DATA_PART);
-    }
-
-    for (const auto & it : files)
-    {
-        const String & name = it.first;
-
-        auto jt = rhs.files.find(name);
-        if (jt == rhs.files.end())
-            throw Exception("No file " + name + " in data part", ErrorCodes::NO_FILE_IN_DATA_PART);
-
-        it.second.checkEqual(jt->second, have_uncompressed, name);
-    }
-}
-
-void MergeTreeDataPartChecksums::checkSizes(const String & path) const
-{
-    for (const auto & it : files)
-    {
-        const String & name = it.first;
-        it.second.checkSize(path + name);
-    }
-}
-
-bool MergeTreeDataPartChecksums::read(ReadBuffer & in)
-{
-    files.clear();
-
-    assertString("checksums format version: ", in);
-    int format_version;
-    readText(format_version, in);
-    assertChar('\n', in);
-
-    switch (format_version)
-    {
-        case 1:
-            return false;
-        case 2:
-            return read_v2(in);
-        case 3:
-            return read_v3(in);
-        case 4:
-            return read_v4(in);
-        default:
-            throw Exception("Bad checksums format version: " + DB::toString(format_version), ErrorCodes::UNKNOWN_FORMAT);
-    }
-}
-
-bool MergeTreeDataPartChecksums::read_v2(ReadBuffer & in)
-{
-    size_t count;
-
-    readText(count, in);
-    assertString(" files:\n", in);
-
-    for (size_t i = 0; i < count; ++i)
-    {
-        String name;
-        Checksum sum;
-
-        readString(name, in);
-        assertString("\n\tsize: ", in);
-        readText(sum.file_size, in);
-        assertString("\n\thash: ", in);
-        readText(sum.file_hash.first, in);
-        assertString(" ", in);
-        readText(sum.file_hash.second, in);
-        assertString("\n\tcompressed: ", in);
-        readText(sum.is_compressed, in);
-        if (sum.is_compressed)
-        {
-            assertString("\n\tuncompressed size: ", in);
-            readText(sum.uncompressed_size, in);
-            assertString("\n\tuncompressed hash: ", in);
-            readText(sum.uncompressed_hash.first, in);
-            assertString(" ", in);
-            readText(sum.uncompressed_hash.second, in);
-        }
-        assertChar('\n', in);
-
-        files.insert(std::make_pair(name, sum));
-    }
-
-    return true;
-}
-
-bool MergeTreeDataPartChecksums::read_v3(ReadBuffer & in)
-{
-    size_t count;
-
-    readVarUInt(count, in);
-
-    for (size_t i = 0; i < count; ++i)
-    {
-        String name;
-        Checksum sum;
-
-        readBinary(name, in);
-        readVarUInt(sum.file_size, in);
-        readPODBinary(sum.file_hash, in);
-        readBinary(sum.is_compressed, in);
-
-        if (sum.is_compressed)
-        {
-            readVarUInt(sum.uncompressed_size, in);
-            readPODBinary(sum.uncompressed_hash, in);
-        }
-
-        files.emplace(std::move(name), sum);
-    }
-
-    return true;
-}
-
-bool MergeTreeDataPartChecksums::read_v4(ReadBuffer & from)
-{
-    CompressedReadBuffer in{from};
-    return read_v3(in);
-}
-
-void MergeTreeDataPartChecksums::write(WriteBuffer & to) const
-{
-    writeString("checksums format version: 4\n", to);
-
-    CompressedWriteBuffer out{to, CompressionSettings(CompressionMethod::LZ4), 1 << 16};
-    writeVarUInt(files.size(), out);
-
-    for (const auto & it : files)
-    {
-        const String & name = it.first;
-        const Checksum & sum = it.second;
-
-        writeBinary(name, out);
-        writeVarUInt(sum.file_size, out);
-        writePODBinary(sum.file_hash, out);
-        writeBinary(sum.is_compressed, out);
-
-        if (sum.is_compressed)
-        {
-            writeVarUInt(sum.uncompressed_size, out);
-            writePODBinary(sum.uncompressed_hash, out);
-        }
-    }
-}
-
-void MergeTreeDataPartChecksums::addFile(const String & file_name, UInt64 file_size, MergeTreeDataPartChecksum::uint128 file_hash)
-{
-    files[file_name] = Checksum(file_size, file_hash);
-}
-
-void MergeTreeDataPartChecksums::add(MergeTreeDataPartChecksums && rhs_checksums)
-{
-    for (auto & checksum : rhs_checksums.files)
-        files[std::move(checksum.first)] = std::move(checksum.second);
-
-    rhs_checksums.files.clear();
-}
-
-/// Checksum computed from the set of control sums of .bin files.
-void MergeTreeDataPartChecksums::summaryDataChecksum(SipHash & hash) const
-{
-    /// We use fact that iteration is in deterministic (lexicographical) order.
-    for (const auto & it : files)
-    {
-        const String & name = it.first;
-        const Checksum & sum = it.second;
-
-        if (!endsWith(name, ".bin"))
-            continue;
-
-        UInt64 len = name.size();
-        hash.update(len);
-        hash.update(name.data(), len);
-        hash.update(sum.uncompressed_size);
-        hash.update(sum.uncompressed_hash);
-    }
-}
-
-String MergeTreeDataPartChecksums::toString() const
-{
-    WriteBufferFromOwnString out;
-    write(out);
-    return out.str();
-}
-
-MergeTreeDataPartChecksums MergeTreeDataPartChecksums::parse(const String & s)
-{
-    ReadBufferFromString in(s);
-    MergeTreeDataPartChecksums res;
-    if (!res.read(in))
-        throw Exception("Checksums format is too old", ErrorCodes::FORMAT_VERSION_TOO_OLD);
-    assertEOF(in);
-    return res;
-}
-
-const MergeTreeDataPartChecksums::Checksum * MergeTreeDataPart::tryGetChecksum(const String & name, const String & ext) const
-{
-    if (checksums.empty())
-        return nullptr;
-
-    const auto & files = checksums.files;
-    const auto file_name = escapeForFileName(name) + ext;
-    auto it = files.find(file_name);
-
-    return (it == files.end()) ? nullptr : &it->second;
-}
-
-const MergeTreeDataPartChecksums::Checksum * MergeTreeDataPart::tryGetBinChecksum(const String & name) const
-{
-    return tryGetChecksum(name, ".bin");
-}
-
-const MergeTreeDataPartChecksums::Checksum * MergeTreeDataPart::tryGetMrkChecksum(const String & name) const
-{
-    return tryGetChecksum(name, ".mrk");
-}
-
 static ReadBufferFromFile openForReading(const String & path)
 {
     return ReadBufferFromFile(path, std::min(static_cast<Poco::File::FileSize>(DBMS_DEFAULT_BUFFER_SIZE), Poco::File(path).getSize()));
@@ -418,7 +162,7 @@ UInt64 MergeTreeDataPart::getColumnMrkSize(const String & name) const
   */
 String MergeTreeDataPart::getColumnNameWithMinumumCompressedSize() const
 {
-    const auto & columns = storage.getColumnsList();
+    const auto & columns = storage.getColumns().getAllPhysical();
     const std::string * minimum_size_column = nullptr;
     UInt64 minimum_size = std::numeric_limits<UInt64>::max();
 
@@ -774,7 +518,7 @@ void MergeTreeDataPart::accumulateColumnSizes(ColumnToSize & column_to_size) con
 {
     std::shared_lock<std::shared_mutex> part_lock(columns_lock);
 
-    for (const NameAndTypePair & name_type : storage.columns)
+    for (const NameAndTypePair & name_type : storage.getColumns().getAllPhysical())
     {
         name_type.type->enumerateStreams([&](const IDataType::SubstreamPath & substream_path)
         {
@@ -794,7 +538,7 @@ void MergeTreeDataPart::loadColumns(bool require)
             throw Exception("No columns.txt in part " + name, ErrorCodes::NO_FILE_IN_DATA_PART);
 
         /// If there is no file with a list of columns, write it down.
-        for (const NameAndTypePair & column : storage.getColumnsList())
+        for (const NameAndTypePair & column : storage.getColumns().getAllPhysical())
             if (Poco::File(getFullPath() + escapeForFileName(column.name) + ".bin").exists())
                 columns.push_back(column);
 
@@ -926,6 +670,29 @@ bool MergeTreeDataPart::hasColumnFiles(const String & column) const
 }
 
 
+const MergeTreeDataPartChecksums::Checksum * MergeTreeDataPart::tryGetChecksum(const String & name, const String & ext) const
+{
+    if (checksums.empty())
+        return nullptr;
+
+    const auto & files = checksums.files;
+    const auto file_name = escapeForFileName(name) + ext;
+    auto it = files.find(file_name);
+
+    return (it == files.end()) ? nullptr : &it->second;
+}
+
+const MergeTreeDataPartChecksums::Checksum * MergeTreeDataPart::tryGetBinChecksum(const String & name) const
+{
+    return tryGetChecksum(name, ".bin");
+}
+
+const MergeTreeDataPartChecksums::Checksum * MergeTreeDataPart::tryGetMrkChecksum(const String & name) const
+{
+    return tryGetChecksum(name, ".mrk");
+}
+
+
 UInt64 MergeTreeDataPart::getIndexSizeInBytes() const
 {
     UInt64 res = 0;
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPart.h b/dbms/src/Storages/MergeTree/MergeTreeDataPart.h
index 43ddf7abfdd..a617dfedacd 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataPart.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPart.h
@@ -5,82 +5,14 @@
 #include <Core/NamesAndTypes.h>
 #include <Storages/MergeTree/MergeTreePartInfo.h>
 #include <Storages/MergeTree/MergeTreePartition.h>
+#include <Storages/MergeTree/MergeTreeDataPartChecksum.h>
 #include <Columns/IColumn.h>
 #include <shared_mutex>
 
 
-class SipHash;
-
-
 namespace DB
 {
 
-
-/// Checksum of one file.
-struct MergeTreeDataPartChecksum
-{
-    using uint128 = CityHash_v1_0_2::uint128;
-
-    UInt64 file_size {};
-    uint128 file_hash {};
-
-    bool is_compressed = false;
-    UInt64 uncompressed_size {};
-    uint128 uncompressed_hash {};
-
-    MergeTreeDataPartChecksum() {}
-    MergeTreeDataPartChecksum(UInt64 file_size_, uint128 file_hash_) : file_size(file_size_), file_hash(file_hash_) {}
-    MergeTreeDataPartChecksum(UInt64 file_size_, uint128 file_hash_, UInt64 uncompressed_size_, uint128 uncompressed_hash_)
-        : file_size(file_size_), file_hash(file_hash_), is_compressed(true),
-        uncompressed_size(uncompressed_size_), uncompressed_hash(uncompressed_hash_) {}
-
-    void checkEqual(const MergeTreeDataPartChecksum & rhs, bool have_uncompressed, const String & name) const;
-    void checkSize(const String & path) const;
-};
-
-
-/** Checksums of all non-temporary files.
-  * For compressed files, the check sum and the size of the decompressed data are stored to not depend on the compression method.
-  */
-struct MergeTreeDataPartChecksums
-{
-    using Checksum = MergeTreeDataPartChecksum;
-
-    /// The order is important.
-    using FileChecksums = std::map<String, Checksum>;
-    FileChecksums files;
-
-    void addFile(const String & file_name, UInt64 file_size, Checksum::uint128 file_hash);
-
-    void add(MergeTreeDataPartChecksums && rhs_checksums);
-
-    /// Checks that the set of columns and their checksums are the same. If not, throws an exception.
-    /// If have_uncompressed, for compressed files it compares the checksums of the decompressed data. Otherwise, it compares only the checksums of the files.
-    void checkEqual(const MergeTreeDataPartChecksums & rhs, bool have_uncompressed) const;
-
-    /// Checks that the directory contains all the needed files of the correct size. Does not check the checksum.
-    void checkSizes(const String & path) const;
-
-    /// Serializes and deserializes in human readable form.
-    bool read(ReadBuffer & in); /// Returns false if the checksum is too old.
-    bool read_v2(ReadBuffer & in);
-    bool read_v3(ReadBuffer & in);
-    bool read_v4(ReadBuffer & in);
-    void write(WriteBuffer & out) const;
-
-    bool empty() const
-    {
-        return files.empty();
-    }
-
-    /// Checksum from the set of checksums of .bin files.
-    void summaryDataChecksum(SipHash & hash) const;
-
-    String toString() const;
-    static MergeTreeDataPartChecksums parse(const String & s);
-};
-
-
 class MergeTreeData;
 
 
@@ -139,7 +71,8 @@ struct MergeTreeDataPart
     std::atomic<UInt64> size_in_bytes {0};  /// size in bytes, 0 - if not counted;
                                             ///  is used from several threads without locks (it is changed with ALTER).
     time_t modification_time = 0;
-    mutable std::atomic<time_t> remove_time { std::numeric_limits<time_t>::max() }; /// When the part is removed from the working set. Changes once.
+    /// When the part is removed from the working set. Changes once.
+    mutable std::atomic<time_t> remove_time { std::numeric_limits<time_t>::max() };
 
     /// If true, the destructor will delete the directory with the part.
     bool is_temp = false;
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp
new file mode 100644
index 00000000000..b9be8e3d9f0
--- /dev/null
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp
@@ -0,0 +1,448 @@
+#include "MergeTreeDataPartChecksum.h"
+#include <Common/SipHash.h>
+#include <IO/ReadHelpers.h>
+#include <IO/WriteHelpers.h>
+#include <IO/ReadBufferFromString.h>
+#include <IO/WriteBufferFromString.h>
+#include <IO/CompressedReadBuffer.h>
+#include <IO/CompressedWriteBuffer.h>
+#include <Poco/File.h>
+
+
+namespace DB
+{
+
+
+namespace ErrorCodes
+{
+    extern const int CHECKSUM_DOESNT_MATCH;
+    extern const int BAD_SIZE_OF_FILE_IN_DATA_PART;
+    extern const int FORMAT_VERSION_TOO_OLD;
+    extern const int FILE_DOESNT_EXIST;
+    extern const int UNEXPECTED_FILE_IN_DATA_PART;
+    extern const int UNKNOWN_FORMAT;
+    extern const int NO_FILE_IN_DATA_PART;
+}
+
+
+void MergeTreeDataPartChecksum::checkEqual(const MergeTreeDataPartChecksum & rhs, bool have_uncompressed, const String & name) const
+{
+    if (is_compressed && have_uncompressed)
+    {
+        if (!rhs.is_compressed)
+            throw Exception("No uncompressed checksum for file " + name, ErrorCodes::CHECKSUM_DOESNT_MATCH);
+        if (rhs.uncompressed_size != uncompressed_size)
+            throw Exception("Unexpected uncompressed size of file " + name + " in data part", ErrorCodes::BAD_SIZE_OF_FILE_IN_DATA_PART);
+        if (rhs.uncompressed_hash != uncompressed_hash)
+            throw Exception("Checksum mismatch for uncompressed file " + name + " in data part", ErrorCodes::CHECKSUM_DOESNT_MATCH);
+        return;
+    }
+    if (rhs.file_size != file_size)
+        throw Exception("Unexpected size of file " + name + " in data part", ErrorCodes::BAD_SIZE_OF_FILE_IN_DATA_PART);
+    if (rhs.file_hash != file_hash)
+        throw Exception("Checksum mismatch for file " + name + " in data part", ErrorCodes::CHECKSUM_DOESNT_MATCH);
+}
+
+void MergeTreeDataPartChecksum::checkSize(const String & path) const
+{
+    Poco::File file(path);
+    if (!file.exists())
+        throw Exception(path + " doesn't exist", ErrorCodes::FILE_DOESNT_EXIST);
+    UInt64 size = file.getSize();
+    if (size != file_size)
+        throw Exception(path + " has unexpected size: " + toString(size) + " instead of " + toString(file_size),
+            ErrorCodes::BAD_SIZE_OF_FILE_IN_DATA_PART);
+}
+
+
+void MergeTreeDataPartChecksums::checkEqual(const MergeTreeDataPartChecksums & rhs, bool have_uncompressed) const
+{
+    for (const auto & it : rhs.files)
+    {
+        const String & name = it.first;
+
+        if (!files.count(name))
+            throw Exception("Unexpected file " + name + " in data part", ErrorCodes::UNEXPECTED_FILE_IN_DATA_PART);
+    }
+
+    for (const auto & it : files)
+    {
+        const String & name = it.first;
+
+        auto jt = rhs.files.find(name);
+        if (jt == rhs.files.end())
+            throw Exception("No file " + name + " in data part", ErrorCodes::NO_FILE_IN_DATA_PART);
+
+        it.second.checkEqual(jt->second, have_uncompressed, name);
+    }
+}
+
+void MergeTreeDataPartChecksums::checkSizes(const String & path) const
+{
+    for (const auto & it : files)
+    {
+        const String & name = it.first;
+        it.second.checkSize(path + name);
+    }
+}
+
+bool MergeTreeDataPartChecksums::read(ReadBuffer & in, size_t format_version)
+{
+    switch (format_version)
+    {
+        case 1:
+            return false;
+        case 2:
+            return read_v2(in);
+        case 3:
+            return read_v3(in);
+        case 4:
+            return read_v4(in);
+        default:
+            throw Exception("Bad checksums format version: " + DB::toString(format_version), ErrorCodes::UNKNOWN_FORMAT);
+    }
+}
+
+bool MergeTreeDataPartChecksums::read(ReadBuffer & in)
+{
+    files.clear();
+
+    assertString("checksums format version: ", in);
+    size_t format_version;
+    readText(format_version, in);
+    assertChar('\n', in);
+
+    read(in, format_version);
+    return true;
+}
+
+bool MergeTreeDataPartChecksums::read_v2(ReadBuffer & in)
+{
+    size_t count;
+
+    readText(count, in);
+    assertString(" files:\n", in);
+
+    for (size_t i = 0; i < count; ++i)
+    {
+        String name;
+        Checksum sum;
+
+        readString(name, in);
+        assertString("\n\tsize: ", in);
+        readText(sum.file_size, in);
+        assertString("\n\thash: ", in);
+        readText(sum.file_hash.first, in);
+        assertString(" ", in);
+        readText(sum.file_hash.second, in);
+        assertString("\n\tcompressed: ", in);
+        readText(sum.is_compressed, in);
+        if (sum.is_compressed)
+        {
+            assertString("\n\tuncompressed size: ", in);
+            readText(sum.uncompressed_size, in);
+            assertString("\n\tuncompressed hash: ", in);
+            readText(sum.uncompressed_hash.first, in);
+            assertString(" ", in);
+            readText(sum.uncompressed_hash.second, in);
+        }
+        assertChar('\n', in);
+
+        files.insert(std::make_pair(name, sum));
+    }
+
+    return true;
+}
+
+bool MergeTreeDataPartChecksums::read_v3(ReadBuffer & in)
+{
+    size_t count;
+
+    readVarUInt(count, in);
+
+    for (size_t i = 0; i < count; ++i)
+    {
+        String name;
+        Checksum sum;
+
+        readBinary(name, in);
+        readVarUInt(sum.file_size, in);
+        readPODBinary(sum.file_hash, in);
+        readBinary(sum.is_compressed, in);
+
+        if (sum.is_compressed)
+        {
+            readVarUInt(sum.uncompressed_size, in);
+            readPODBinary(sum.uncompressed_hash, in);
+        }
+
+        files.emplace(std::move(name), sum);
+    }
+
+    return true;
+}
+
+bool MergeTreeDataPartChecksums::read_v4(ReadBuffer & from)
+{
+    CompressedReadBuffer in{from};
+    return read_v3(in);
+}
+
+void MergeTreeDataPartChecksums::write(WriteBuffer & to) const
+{
+    writeString("checksums format version: 4\n", to);
+
+    CompressedWriteBuffer out{to, CompressionSettings(CompressionMethod::LZ4), 1 << 16};
+
+    writeVarUInt(files.size(), out);
+
+    for (const auto & it : files)
+    {
+        const String & name = it.first;
+        const Checksum & sum = it.second;
+
+        writeBinary(name, out);
+        writeVarUInt(sum.file_size, out);
+        writePODBinary(sum.file_hash, out);
+        writeBinary(sum.is_compressed, out);
+
+        if (sum.is_compressed)
+        {
+            writeVarUInt(sum.uncompressed_size, out);
+            writePODBinary(sum.uncompressed_hash, out);
+        }
+    }
+}
+
+void MergeTreeDataPartChecksums::addFile(const String & file_name, UInt64 file_size, MergeTreeDataPartChecksum::uint128 file_hash)
+{
+    files[file_name] = Checksum(file_size, file_hash);
+}
+
+void MergeTreeDataPartChecksums::add(MergeTreeDataPartChecksums && rhs_checksums)
+{
+    for (auto & checksum : rhs_checksums.files)
+        files[std::move(checksum.first)] = std::move(checksum.second);
+
+    rhs_checksums.files.clear();
+}
+
+/// Checksum computed from the set of control sums of .bin files.
+void MergeTreeDataPartChecksums::computeTotalChecksumDataOnly(SipHash & hash) const
+{
+    /// We use fact that iteration is in deterministic (lexicographical) order.
+    for (const auto & it : files)
+    {
+        const String & name = it.first;
+        const Checksum & sum = it.second;
+
+        if (!endsWith(name, ".bin"))
+            continue;
+
+        UInt64 len = name.size();
+        hash.update(len);
+        hash.update(name.data(), len);
+        hash.update(sum.uncompressed_size);
+        hash.update(sum.uncompressed_hash);
+    }
+}
+
+String MergeTreeDataPartChecksums::getSerializedString() const
+{
+    WriteBufferFromOwnString out;
+    write(out);
+    return out.str();
+}
+
+MergeTreeDataPartChecksums MergeTreeDataPartChecksums::deserializeFrom(const String & s)
+{
+    ReadBufferFromString in(s);
+    MergeTreeDataPartChecksums res;
+    if (!res.read(in))
+        throw Exception("Checksums format is too old", ErrorCodes::FORMAT_VERSION_TOO_OLD);
+    assertEOF(in);
+    return res;
+}
+
+bool MergeTreeDataPartChecksums::isBadChecksumsErrorCode(int code)
+{
+    return code == ErrorCodes::CHECKSUM_DOESNT_MATCH
+           || code == ErrorCodes::BAD_SIZE_OF_FILE_IN_DATA_PART
+           || code == ErrorCodes::NO_FILE_IN_DATA_PART
+           || code == ErrorCodes::UNEXPECTED_FILE_IN_DATA_PART;
+}
+
+void MinimalisticDataPartChecksums::serialize(WriteBuffer & to) const
+{
+    writeString("checksums format version: 5\n", to);
+
+    writeVarUInt(num_compressed_files, to);
+    writeVarUInt(num_uncompressed_files, to);
+
+    writePODBinary(hash_of_all_files, to);
+    writePODBinary(hash_of_uncompressed_files, to);
+    writePODBinary(uncompressed_hash_of_compressed_files, to);
+}
+
+String MinimalisticDataPartChecksums::getSerializedString()
+{
+    WriteBufferFromOwnString wb;
+    serialize(wb);
+    return wb.str();
+}
+
+bool MinimalisticDataPartChecksums::deserialize(ReadBuffer & in)
+{
+    assertString("checksums format version: ", in);
+    size_t format_version;
+    readText(format_version, in);
+    assertChar('\n', in);
+
+    if (format_version < MINIMAL_VERSION_WITH_MINIMALISTIC_CHECKSUMS)
+    {
+        auto full_checksums_ptr = std::make_unique<MergeTreeDataPartChecksums>();
+        if (!full_checksums_ptr->read(in, format_version))
+            return false;
+
+        computeTotalChecksums(*full_checksums_ptr);
+        full_checksums = std::move(full_checksums_ptr);
+        return true;
+    }
+
+    if (format_version > MINIMAL_VERSION_WITH_MINIMALISTIC_CHECKSUMS)
+        throw Exception("Unknown checksums format version: " + DB::toString(format_version), ErrorCodes::UNKNOWN_FORMAT);
+
+    readVarUInt(num_compressed_files, in);
+    readVarUInt(num_uncompressed_files, in);
+
+    readPODBinary(hash_of_all_files, in);
+    readPODBinary(hash_of_uncompressed_files, in);
+    readPODBinary(uncompressed_hash_of_compressed_files, in);
+
+    return true;
+}
+
+void MinimalisticDataPartChecksums::computeTotalChecksums(const MergeTreeDataPartChecksums & full_checksums)
+{
+    num_compressed_files = 0;
+    num_uncompressed_files = 0;
+
+    SipHash hash_of_all_files_;
+    SipHash hash_of_uncompressed_files_;
+    SipHash uncompressed_hash_of_compressed_files_;
+
+    auto update_hash = [] (SipHash & hash, const std::string & data)
+    {
+        UInt64 len = data.size();
+        hash.update(len);
+        hash.update(data.data(), len);
+    };
+
+    for (const auto & elem : full_checksums.files)
+    {
+        const String & name = elem.first;
+        const auto & checksum = elem.second;
+
+        update_hash(hash_of_all_files_, name);
+        hash_of_all_files_.update(checksum.file_hash);
+
+        if (!checksum.is_compressed)
+        {
+            ++num_uncompressed_files;
+            update_hash(hash_of_uncompressed_files_, name);
+            hash_of_uncompressed_files_.update(checksum.file_hash);
+        }
+        else
+        {
+            ++num_compressed_files;
+            update_hash(uncompressed_hash_of_compressed_files_, name);
+            uncompressed_hash_of_compressed_files_.update(checksum.uncompressed_hash);
+        }
+    }
+
+    auto get_hash = [] (SipHash & hash, uint128 & data)
+    {
+        hash.get128(data.first, data.second);
+    };
+
+    get_hash(hash_of_all_files_, hash_of_all_files);
+    get_hash(hash_of_uncompressed_files_, hash_of_uncompressed_files);
+    get_hash(uncompressed_hash_of_compressed_files_, uncompressed_hash_of_compressed_files);
+}
+
+String MinimalisticDataPartChecksums::getSerializedString(const MergeTreeDataPartChecksums & full_checksums, bool minimalistic)
+{
+    if (!minimalistic)
+        return full_checksums.getSerializedString();
+
+    MinimalisticDataPartChecksums checksums;
+    checksums.computeTotalChecksums(full_checksums);
+    return checksums.getSerializedString();
+}
+
+void MinimalisticDataPartChecksums::checkEqual(const MinimalisticDataPartChecksums & rhs, bool check_uncompressed_hash_in_compressed_files)
+{
+    if (full_checksums && rhs.full_checksums)
+        full_checksums->checkEqual(*rhs.full_checksums, check_uncompressed_hash_in_compressed_files);
+
+    // If full checksums were checked, check total checksums just in case
+    checkEqualImpl(rhs, check_uncompressed_hash_in_compressed_files);
+}
+
+void MinimalisticDataPartChecksums::checkEqual(const MergeTreeDataPartChecksums & rhs, bool check_uncompressed_hash_in_compressed_files)
+{
+    if (full_checksums)
+        full_checksums->checkEqual(rhs, check_uncompressed_hash_in_compressed_files);
+
+    // If full checksums were checked, check total checksums just in case
+    MinimalisticDataPartChecksums rhs_minimalistic;
+    rhs_minimalistic.computeTotalChecksums(rhs);
+    checkEqualImpl(rhs_minimalistic, check_uncompressed_hash_in_compressed_files);
+}
+
+void MinimalisticDataPartChecksums::checkEqualImpl(const MinimalisticDataPartChecksums & rhs, bool check_uncompressed_hash_in_compressed_files)
+{
+    if (num_compressed_files != rhs.num_compressed_files || num_uncompressed_files != rhs.num_uncompressed_files)
+    {
+        std::stringstream error_msg;
+        error_msg << "Different number of files: " << rhs.num_compressed_files << " compressed (expected " << num_compressed_files << ")"
+            << " and " << rhs.num_uncompressed_files << " uncompressed ones (expected " << num_uncompressed_files << ")";
+
+        throw Exception(error_msg.str(), ErrorCodes::CHECKSUM_DOESNT_MATCH);
+    }
+
+    Strings errors;
+
+    if (hash_of_uncompressed_files != rhs.hash_of_uncompressed_files)
+        errors.emplace_back("hash of uncompressed files doesn't match");
+
+    if (check_uncompressed_hash_in_compressed_files)
+    {
+        if (uncompressed_hash_of_compressed_files != rhs.uncompressed_hash_of_compressed_files)
+            errors.emplace_back("uncompressed hash of compressed files doesn't match");
+    }
+    else
+    {
+        if (hash_of_all_files != rhs.hash_of_all_files)
+            errors.emplace_back("total hash of all files doesn't match");
+    }
+
+    if (!errors.empty())
+    {
+        String error_msg = "Checksums of parts don't match: " + errors.front();
+        for (size_t i = 1; i < errors.size(); ++i)
+            error_msg += ", " + errors[i];
+
+        throw Exception(error_msg, ErrorCodes::CHECKSUM_DOESNT_MATCH);
+    }
+}
+
+MinimalisticDataPartChecksums MinimalisticDataPartChecksums::deserializeFrom(const String & s)
+{
+    MinimalisticDataPartChecksums res;
+    ReadBufferFromString rb(s);
+    res.deserialize(rb);
+    return res;
+}
+
+}
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.h b/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.h
new file mode 100644
index 00000000000..2471d0ef681
--- /dev/null
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.h
@@ -0,0 +1,121 @@
+#pragma once
+#include <Core/Types.h>
+#include <IO/ReadBuffer.h>
+#include <IO/WriteBuffer.h>
+#include <city.h>
+#include <map>
+#include <memory>
+
+
+class SipHash;
+
+
+namespace DB
+{
+
+/// Checksum of one file.
+struct MergeTreeDataPartChecksum
+{
+    using uint128 = CityHash_v1_0_2::uint128;
+
+    UInt64 file_size {};
+    uint128 file_hash {};
+
+    bool is_compressed = false;
+    UInt64 uncompressed_size {};
+    uint128 uncompressed_hash {};
+
+    MergeTreeDataPartChecksum() {}
+    MergeTreeDataPartChecksum(UInt64 file_size_, uint128 file_hash_) : file_size(file_size_), file_hash(file_hash_) {}
+    MergeTreeDataPartChecksum(UInt64 file_size_, uint128 file_hash_, UInt64 uncompressed_size_, uint128 uncompressed_hash_)
+        : file_size(file_size_), file_hash(file_hash_), is_compressed(true),
+        uncompressed_size(uncompressed_size_), uncompressed_hash(uncompressed_hash_) {}
+
+    void checkEqual(const MergeTreeDataPartChecksum & rhs, bool have_uncompressed, const String & name) const;
+    void checkSize(const String & path) const;
+};
+
+
+/** Checksums of all non-temporary files.
+  * For compressed files, the check sum and the size of the decompressed data are stored to not depend on the compression method.
+  */
+struct MergeTreeDataPartChecksums
+{
+    using Checksum = MergeTreeDataPartChecksum;
+
+    /// The order is important.
+    using FileChecksums = std::map<String, Checksum>;
+    FileChecksums files;
+
+    void addFile(const String & file_name, UInt64 file_size, Checksum::uint128 file_hash);
+
+    void add(MergeTreeDataPartChecksums && rhs_checksums);
+
+    bool empty() const
+    {
+        return files.empty();
+    }
+
+    /// Checks that the set of columns and their checksums are the same. If not, throws an exception.
+    /// If have_uncompressed, for compressed files it compares the checksums of the decompressed data.
+    /// Otherwise, it compares only the checksums of the files.
+    void checkEqual(const MergeTreeDataPartChecksums & rhs, bool have_uncompressed) const;
+
+    static bool isBadChecksumsErrorCode(int code);
+
+    /// Checks that the directory contains all the needed files of the correct size. Does not check the checksum.
+    void checkSizes(const String & path) const;
+
+    /// Returns false if the checksum is too old.
+    bool read(ReadBuffer & in);
+    /// Assume that header with version (the first line) is read
+    bool read(ReadBuffer & in, size_t format_version);
+    bool read_v2(ReadBuffer & in);
+    bool read_v3(ReadBuffer & in);
+    bool read_v4(ReadBuffer & in);
+
+    void write(WriteBuffer & out) const;
+
+    /// Checksum from the set of checksums of .bin files (for deduplication).
+    void computeTotalChecksumDataOnly(SipHash & hash) const;
+
+    String getSerializedString() const;
+    static MergeTreeDataPartChecksums deserializeFrom(const String & s);
+};
+
+
+/// A kind of MergeTreeDataPartChecksums intended to be stored in ZooKeeper (to save its RAM)
+/// MinimalisticDataPartChecksums and MergeTreeDataPartChecksums hasve the same serialization format
+///  for versions less than MINIMAL_VERSION_WITH_MINIMALISTIC_CHECKSUMS.
+struct MinimalisticDataPartChecksums
+{
+    UInt64 num_compressed_files = 0;
+    UInt64 num_uncompressed_files = 0;
+
+    using uint128 = MergeTreeDataPartChecksum::uint128;
+    uint128 hash_of_all_files {};
+    uint128 hash_of_uncompressed_files {};
+    uint128 uncompressed_hash_of_compressed_files {};
+
+    /// Is set only for old formats
+    std::unique_ptr<MergeTreeDataPartChecksums> full_checksums;
+
+    static constexpr size_t MINIMAL_VERSION_WITH_MINIMALISTIC_CHECKSUMS = 5;
+
+    MinimalisticDataPartChecksums() = default;
+    void computeTotalChecksums(const MergeTreeDataPartChecksums & full_checksums);
+
+    bool deserialize(ReadBuffer & in);
+    static MinimalisticDataPartChecksums deserializeFrom(const String & s);
+
+    void serialize(WriteBuffer & to) const;
+    String getSerializedString();
+    static String getSerializedString(const MergeTreeDataPartChecksums & full_checksums, bool minimalistic);
+
+    void checkEqual(const MinimalisticDataPartChecksums & rhs, bool check_uncompressed_hash_in_compressed_files);
+    void checkEqual(const MergeTreeDataPartChecksums & rhs, bool check_uncompressed_hash_in_compressed_files);
+    void checkEqualImpl(const MinimalisticDataPartChecksums & rhs, bool check_uncompressed_hash_in_compressed_files);
+};
+
+
+}
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
index fb7c1735ced..afc9700cf0b 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
@@ -175,7 +175,7 @@ BlockInputStreams MergeTreeDataSelectExecutor::read(
         }
     }
 
-    NamesAndTypesList available_real_columns = data.getColumnsList();
+    NamesAndTypesList available_real_columns = data.getColumns().getAllPhysical();
 
     NamesAndTypesList available_real_and_virtual_columns = available_real_columns;
     for (const auto & name : virt_column_names)
@@ -857,7 +857,7 @@ void MergeTreeDataSelectExecutor::createPositiveSignCondition(
     arguments->children.push_back(sign);
     arguments->children.push_back(one);
 
-    out_expression = ExpressionAnalyzer(function, context, {}, data.getColumnsList()).getActions(false);
+    out_expression = ExpressionAnalyzer(function, context, {}, data.getColumns().getAllPhysical()).getActions(false);
     out_column = function->getColumnName();
 }
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
index fd0b0265ced..1b3caeeb259 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <Core/QueryProcessingStage.h>
+#include <Storages/SelectQueryInfo.h>
 #include <Storages/MergeTree/MergeTreeData.h>
 #include <Storages/MergeTree/RangesInDataPart.h>
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataWriter.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataWriter.cpp
index fabbca3a473..e85efa435fd 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataWriter.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataWriter.cpp
@@ -205,7 +205,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataWriter::writeTempPart(BlockWithPa
     ///  either default lz4 or compression method with zero thresholds on absolute and relative part size.
     auto compression_settings = data.context.chooseCompressionSettings(0, 0);
 
-    NamesAndTypesList columns = data.getColumnsList().filter(block.getNames());
+    NamesAndTypesList columns = data.getColumns().getAllPhysical().filter(block.getNames());
     MergedBlockOutputStream out(data, new_data_part->getFullPath(), columns, compression_settings);
 
     out.writePrefix();
diff --git a/dbms/src/Storages/MergeTree/MergeTreeReadPool.cpp b/dbms/src/Storages/MergeTree/MergeTreeReadPool.cpp
index e95c576274c..370797968b3 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeReadPool.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeReadPool.cpp
@@ -238,8 +238,9 @@ std::vector<size_t> MergeTreeReadPool::fillPerPartInfo(
             if (!required_column_names.empty())
                 data.check(part.data_part->columns, required_column_names);
 
-            per_part_pre_columns.push_back(data.getColumnsList().addTypes(required_pre_column_names));
-            per_part_columns.push_back(data.getColumnsList().addTypes(required_column_names));
+            const NamesAndTypesList & physical_columns = data.getColumns().getAllPhysical();
+            per_part_pre_columns.push_back(physical_columns.addTypes(required_pre_column_names));
+            per_part_columns.push_back(physical_columns.addTypes(required_column_names));
         }
         else
         {
diff --git a/dbms/src/Storages/MergeTree/MergeTreeReader.cpp b/dbms/src/Storages/MergeTree/MergeTreeReader.cpp
index 63d763d5939..8f29c93511d 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeReader.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeReader.cpp
@@ -413,7 +413,8 @@ static bool arrayHasNoElementsRead(const IColumn & column)
 }
 
 
-void MergeTreeReader::fillMissingColumns(Block & res, const Names & ordered_names, bool always_reorder)
+void MergeTreeReader::fillMissingColumns(Block & res, const Names & ordered_names, bool always_reorder,
+                                         size_t rows, bool never_evaluate_defaults)
 {
     if (!res)
         throw Exception("Empty block passed to fillMissingColumns", ErrorCodes::LOGICAL_ERROR);
@@ -444,8 +445,6 @@ void MergeTreeReader::fillMissingColumns(Block & res, const Names & ordered_name
         bool should_evaluate_defaults = false;
         bool should_sort = always_reorder;
 
-        size_t rows = res.rows();
-
         /// insert default values only for columns without default expressions
         for (const auto & requested_column : columns)
         {
@@ -463,7 +462,7 @@ void MergeTreeReader::fillMissingColumns(Block & res, const Names & ordered_name
             if (!has_column)
             {
                 should_sort = true;
-                if (storage.column_defaults.count(requested_column.name) != 0)
+                if (storage.getColumns().defaults.count(requested_column.name) != 0)
                 {
                     should_evaluate_defaults = true;
                     continue;
@@ -497,11 +496,11 @@ void MergeTreeReader::fillMissingColumns(Block & res, const Names & ordered_name
         }
 
         /// evaluate defaulted columns if necessary
-        if (should_evaluate_defaults)
-            evaluateMissingDefaults(res, columns, storage.column_defaults, storage.context);
+        if (!never_evaluate_defaults && should_evaluate_defaults)
+            evaluateMissingDefaults(res, columns, storage.getColumns().defaults, storage.context);
 
         /// sort columns to ensure consistent order among all blocks
-        if (should_sort)
+        if (!never_evaluate_defaults && should_sort)
         {
             Block ordered_block;
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeReader.h b/dbms/src/Storages/MergeTree/MergeTreeReader.h
index c2cd086d343..b76cf19ff93 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeReader.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeReader.h
@@ -44,7 +44,11 @@ public:
     /// Add columns from ordered_names that are not present in the block.
     /// Missing columns are added in the order specified by ordered_names.
     /// If at least one column was added, reorders all columns in the block according to ordered_names.
-    void fillMissingColumns(Block & res, const Names & ordered_names, const bool always_reorder);
+    /// Rows is the number of rows will be used to create default columns. It's res.rows() when all columns in block has the same size.
+    /// This function may be used in order to create default columns in nested structures. In that case block may has
+    /// columns with different size, and default columns can't be evaluated, so never_evaluate_defaults = false is used.
+    void fillMissingColumns(Block & res, const Names & ordered_names, const bool always_reorder,
+                            size_t rows, bool never_evaluate_defaults = false);
 
 private:
     class Stream
diff --git a/dbms/src/Storages/MergeTree/MergeTreeSettings.h b/dbms/src/Storages/MergeTree/MergeTreeSettings.h
index f91ca880a66..424c634afaf 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeSettings.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeSettings.h
@@ -131,6 +131,12 @@ struct MergeTreeSettings
       *  for backward compatibility.                                                                          \
       */                                                                                                      \
     M(SettingBool, compatibility_allow_sampling_expression_not_in_primary_key, false)                         \
+                                                                                                              \
+    /** Use small format (dozens bytes) for part checksums in ZooKeeper                                       \
+      *  instead of ordinary ones (dozens KB).                                                                \
+      * Before enabling check that all replicas support new format.                                           \
+      */                                                                                                      \
+    M(SettingBool, use_minimalistic_checksums_in_zookeeper, false)
 
     /// Settings that should not change after the creation of a table.
 #define APPLY_FOR_IMMUTABLE_MERGE_TREE_SETTINGS(M)  \
diff --git a/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp b/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
index cf7bc0d33f7..077ea9fed5d 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
@@ -41,9 +41,9 @@ MergeTreeWhereOptimizer::MergeTreeWhereOptimizer(
     Logger * log)
         : primary_key_columns{ext::map<std::unordered_set>(data.getPrimarySortDescription(),
             [] (const SortColumnDescription & col) { return col.column_name; })},
-        table_columns{ext::map<std::unordered_set>(data.getColumnsList(),
+        table_columns{ext::map<std::unordered_set>(data.getColumns().getAllPhysical(),
             [] (const NameAndTypePair & col) { return col.name; })},
-        block_with_constants{PKCondition::getBlockWithConstants(query_info.query, context, data.getColumnsList())},
+        block_with_constants{PKCondition::getBlockWithConstants(query_info.query, context, data.getColumns().getAllPhysical())},
         prepared_sets(query_info.sets),
         log{log}
 {
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeAlterThread.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeAlterThread.cpp
index ef7582c497c..f0513c04f9e 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeAlterThread.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeAlterThread.cpp
@@ -56,12 +56,7 @@ void ReplicatedMergeTreeAlterThread::run()
 
             zkutil::Stat stat;
             const String columns_str = zookeeper->get(storage.zookeeper_path + "/columns", &stat, wakeup_event);
-            auto columns_desc = ColumnsDescription<true>::parse(columns_str);
-
-            auto & columns = columns_desc.columns;
-            auto & materialized_columns = columns_desc.materialized;
-            auto & alias_columns = columns_desc.alias;
-            auto & column_defaults = columns_desc.defaults;
+            auto columns_in_zk = ColumnsDescription::parse(columns_str);
 
             bool changed_version = (stat.version != storage.columns_version);
 
@@ -92,42 +87,13 @@ void ReplicatedMergeTreeAlterThread::run()
 
                     auto table_lock = storage.lockStructureForAlter(__PRETTY_FUNCTION__);
 
-                    const auto columns_changed = columns != storage.data.getColumnsListNonMaterialized();
-                    const auto materialized_columns_changed = materialized_columns != storage.data.materialized_columns;
-                    const auto alias_columns_changed = alias_columns != storage.data.alias_columns;
-                    const auto column_defaults_changed = column_defaults != storage.data.column_defaults;
-
-                    if (columns_changed || materialized_columns_changed || alias_columns_changed ||
-                        column_defaults_changed)
+                    if (columns_in_zk != storage.getColumns())
                     {
                         LOG_INFO(log, "Columns list changed in ZooKeeper. Applying changes locally.");
 
                         storage.context.getDatabase(storage.database_name)->alterTable(
-                            storage.context, storage.table_name,
-                            columns, materialized_columns, alias_columns, column_defaults, {});
-
-                        if (columns_changed)
-                        {
-                            storage.data.setColumnsList(columns);
-                        }
-
-                        if (materialized_columns_changed)
-                        {
-                            storage.materialized_columns = materialized_columns;
-                            storage.data.materialized_columns = std::move(materialized_columns);
-                        }
-
-                        if (alias_columns_changed)
-                        {
-                            storage.alias_columns = alias_columns;
-                            storage.data.alias_columns = std::move(alias_columns);
-                        }
-
-                        if (column_defaults_changed)
-                        {
-                            storage.column_defaults = column_defaults;
-                            storage.data.column_defaults = std::move(column_defaults);
-                        }
+                            storage.context, storage.table_name, columns_in_zk, {});
+                        storage.setColumns(std::move(columns_in_zk));
 
                         /// Reinitialize primary key because primary key column types might have changed.
                         storage.data.initPrimaryKey();
@@ -158,7 +124,7 @@ void ReplicatedMergeTreeAlterThread::run()
                     if (!changed_version)
                         parts = storage.data.getDataParts();
 
-                    const auto columns_plus_materialized = storage.data.getColumnsList();
+                    const auto columns_for_parts = storage.getColumns().getAllPhysical();
 
                     for (const MergeTreeData::DataPartPtr & part : parts)
                     {
@@ -166,7 +132,7 @@ void ReplicatedMergeTreeAlterThread::run()
                         /// TODO: You can skip checking for too large changes if ZooKeeper has, for example,
                         /// node /flags/force_alter.
                         auto transaction = storage.data.alterDataPart(
-                            part, columns_plus_materialized, storage.data.primary_expr_ast, false);
+                            part, columns_for_parts, storage.data.primary_expr_ast, false);
 
                         if (!transaction)
                             continue;
@@ -175,10 +141,12 @@ void ReplicatedMergeTreeAlterThread::run()
 
                         /// Update part metadata in ZooKeeper.
                         zkutil::Ops ops;
-                        ops.emplace_back(std::make_unique<zkutil::Op::SetData>(
+                        ops.emplace_back(std::make_shared<zkutil::Op::SetData>(
                             storage.replica_path + "/parts/" + part->name + "/columns", transaction->getNewColumns().toString(), -1));
-                        ops.emplace_back(std::make_unique<zkutil::Op::SetData>(
-                            storage.replica_path + "/parts/" + part->name + "/checksums", transaction->getNewChecksums().toString(), -1));
+                        ops.emplace_back(std::make_shared<zkutil::Op::SetData>(
+                            storage.replica_path + "/parts/" + part->name + "/checksums",
+                            storage.getChecksumsForZooKeeper(transaction->getNewChecksums()),
+                            -1));
 
                         try
                         {
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.cpp
index e34f0f68b6d..52bc1c4be3f 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.cpp
@@ -133,7 +133,7 @@ void ReplicatedMergeTreeBlockOutputStream::write(const Block & block)
         if (deduplicate)
         {
             SipHash hash;
-            part->checksums.summaryDataChecksum(hash);
+            part->checksums.computeTotalChecksumDataOnly(hash);
             union
             {
                 char bytes[16];
@@ -218,32 +218,35 @@ void ReplicatedMergeTreeBlockOutputStream::commitPart(zkutil::ZooKeeperPtr & zoo
         block_id_path = storage.zookeeper_path + "/blocks/" + block_id;
 
         /// Lets check for duplicates in advance, to avoid superflous block numbers allocation
-        deduplication_check_ops.emplace_back(std::make_unique<zkutil::Op::Create>(block_id_path, "", acl, zkutil::CreateMode::Persistent));
-        deduplication_check_ops.emplace_back(std::make_unique<zkutil::Op::Remove>(block_id_path, -1));
+        deduplication_check_ops.emplace_back(std::make_shared<zkutil::Op::Create>(block_id_path, "", acl, zkutil::CreateMode::Persistent));
+        deduplication_check_ops.emplace_back(std::make_shared<zkutil::Op::Remove>(block_id_path, -1));
         deduplication_check_ops_ptr = &deduplication_check_ops;
     }
 
-    /// 2 RTT
-    AbandonableLockInZooKeeper block_number_lock = storage.allocateBlockNumber(part->info.partition_id, zookeeper, deduplication_check_ops_ptr);
-    if (!block_number_lock.isCreated())
+    AbandonableLockInZooKeeper block_number_lock;
+    try
     {
-        zkutil::MultiTransactionInfo & info = block_number_lock.precheck_info;
+        /// 2 RTT
+        block_number_lock = storage.allocateBlockNumber(part->info.partition_id, zookeeper, deduplication_check_ops_ptr);
+    }
+    catch (zkutil::KeeperMultiException & e)
+    {
+        zkutil::MultiTransactionInfo & info = e.info;
 
-        if (!info.empty() && info.code != ZOK)
+        if (deduplicate_block && info.code == ZNODEEXISTS && info.getFailedOp().getPath() == block_id_path)
         {
-            if (deduplicate_block && info.code == ZNODEEXISTS && info.getFailedOp().getPath() == block_id_path)
-            {
-                LOG_INFO(log, "Block with ID " << block_id << " already exists; ignoring it (skip the insertion)");
-                part->is_duplicate = true;
-                last_block_is_duplicate = true;
-                ProfileEvents::increment(ProfileEvents::DuplicatedInsertedBlocks);
-                return;
-            }
-
-            throw Exception("Cannot allocate block number in ZooKeeper: " + info.getException().displayText(), ErrorCodes::KEEPER_EXCEPTION);
+            LOG_INFO(log, "Block with ID " << block_id << " already exists; ignoring it (skip the insertion)");
+            part->is_duplicate = true;
+            last_block_is_duplicate = true;
+            ProfileEvents::increment(ProfileEvents::DuplicatedInsertedBlocks);
+            return;
         }
 
-        throw Exception("Cannot allocate block number in ZooKeeper", ErrorCodes::KEEPER_EXCEPTION);
+        throw Exception("Cannot allocate block number in ZooKeeper: " + e.displayText(), ErrorCodes::KEEPER_EXCEPTION);
+    }
+    catch (zkutil::KeeperException & e)
+    {
+        throw Exception("Cannot allocate block number in ZooKeeper: " + e.displayText(), ErrorCodes::KEEPER_EXCEPTION);
     }
 
     Int64 block_number = block_number_lock.getNumber();
@@ -279,7 +282,7 @@ void ReplicatedMergeTreeBlockOutputStream::commitPart(zkutil::ZooKeeperPtr & zoo
     {
         /// Make final duplicate check and commit block_id
         ops.emplace_back(
-            std::make_unique<zkutil::Op::Create>(
+            std::make_shared<zkutil::Op::Create>(
                 block_id_path,
                 toString(block_number),  /// We will able to know original part number for duplicate blocks, if we want.
                 acl,
@@ -288,27 +291,27 @@ void ReplicatedMergeTreeBlockOutputStream::commitPart(zkutil::ZooKeeperPtr & zoo
 
     /// Information about the part, in the replica data.
 
-    ops.emplace_back(std::make_unique<zkutil::Op::Check>(
+    ops.emplace_back(std::make_shared<zkutil::Op::Check>(
         storage.zookeeper_path + "/columns",
         storage.columns_version));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(
         storage.replica_path + "/parts/" + part->name,
         "",
         acl,
         zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(
         storage.replica_path + "/parts/" + part->name + "/columns",
         part->columns.toString(),
         acl,
         zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(
         storage.replica_path + "/parts/" + part->name + "/checksums",
-        part->checksums.toString(),
+        storage.getChecksumsForZooKeeper(part->checksums),
         acl,
         zkutil::CreateMode::Persistent));
 
     /// Replication log.
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(
         storage.zookeeper_path + "/log/log-",
         log_entry.toString(),
         acl,
@@ -336,7 +339,7 @@ void ReplicatedMergeTreeBlockOutputStream::commitPart(zkutil::ZooKeeperPtr & zoo
             */
 
         ops.emplace_back(
-            std::make_unique<zkutil::Op::Create>(
+            std::make_shared<zkutil::Op::Create>(
                 quorum_info.status_path,
                 quorum_entry.toString(),
                 acl,
@@ -344,7 +347,7 @@ void ReplicatedMergeTreeBlockOutputStream::commitPart(zkutil::ZooKeeperPtr & zoo
 
         /// Make sure that during the insertion time, the replica was not reinitialized or disabled (when the server is finished).
         ops.emplace_back(
-            std::make_unique<zkutil::Op::Check>(
+            std::make_shared<zkutil::Op::Check>(
                 storage.replica_path + "/is_active",
                 quorum_info.is_active_node_version));
 
@@ -352,7 +355,7 @@ void ReplicatedMergeTreeBlockOutputStream::commitPart(zkutil::ZooKeeperPtr & zoo
         /// But then the `host` value will change. We will check this.
         /// It's great that these two nodes change in the same transaction (see MergeTreeRestartingThread).
         ops.emplace_back(
-            std::make_unique<zkutil::Op::Check>(
+            std::make_shared<zkutil::Op::Check>(
                 storage.replica_path + "/host",
                 quorum_info.host_node_version));
     }
@@ -361,12 +364,15 @@ void ReplicatedMergeTreeBlockOutputStream::commitPart(zkutil::ZooKeeperPtr & zoo
     storage.data.renameTempPartAndAdd(part, nullptr, &transaction);
 
     zkutil::MultiTransactionInfo info;
-    zookeeper->tryMultiUnsafe(ops, info); /// 1 RTT
+    zookeeper->tryMultiNoThrow(ops, nullptr, &info); /// 1 RTT
 
     if (info.code == ZOK)
     {
         transaction.commit();
         storage.merge_selecting_event.set();
+
+        /// Lock nodes have been already deleted, do not delete them in destructor
+        block_number_lock.assumeUnlocked();
     }
     else if (zkutil::isUserError(info.code))
     {
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
index ecd201ef765..0352374fd0f 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
@@ -98,12 +98,12 @@ void ReplicatedMergeTreeCleanupThread::clearOldLogs()
     zkutil::Ops ops;
     for (size_t i = 0; i < entries.size(); ++i)
     {
-        ops.emplace_back(std::make_unique<zkutil::Op::Remove>(storage.zookeeper_path + "/log/" + entries[i], -1));
+        ops.emplace_back(std::make_shared<zkutil::Op::Remove>(storage.zookeeper_path + "/log/" + entries[i], -1));
 
         if (ops.size() > 4 * zkutil::MULTI_BATCH_SIZE || i + 1 == entries.size())
         {
             /// Simultaneously with clearing the log, we check to see if replica was added since we received replicas list.
-            ops.emplace_back(std::make_unique<zkutil::Op::Check>(storage.zookeeper_path + "/replicas", stat.version));
+            ops.emplace_back(std::make_shared<zkutil::Op::Check>(storage.zookeeper_path + "/replicas", stat.version));
             zookeeper->multi(ops);
             ops.clear();
         }
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp
index f64826f6266..85e58f4551b 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp
@@ -237,7 +237,7 @@ void ReplicatedMergeTreePartCheckThread::checkPart(const String & part_name)
 
             try
             {
-                auto zk_checksums = MergeTreeData::DataPart::Checksums::parse(
+                auto zk_checksums = MinimalisticDataPartChecksums::deserializeFrom(
                     zookeeper->get(storage.replica_path + "/parts/" + part_name + "/checksums"));
                 zk_checksums.checkEqual(part->checksums, true);
 
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
index b2fe028f5d7..c5d4a41d496 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
@@ -164,11 +164,11 @@ void ReplicatedMergeTreeQueue::updateTimesInZooKeeper(
     zkutil::Ops ops;
 
     if (min_unprocessed_insert_time_changed)
-        ops.emplace_back(std::make_unique<zkutil::Op::SetData>(
+        ops.emplace_back(std::make_shared<zkutil::Op::SetData>(
             replica_path + "/min_unprocessed_insert_time", toString(*min_unprocessed_insert_time_changed), -1));
 
     if (max_processed_insert_time_changed)
-        ops.emplace_back(std::make_unique<zkutil::Op::SetData>(
+        ops.emplace_back(std::make_shared<zkutil::Op::SetData>(
             replica_path + "/max_processed_insert_time", toString(*max_processed_insert_time_changed), -1));
 
     if (!ops.empty())
@@ -334,7 +334,7 @@ bool ReplicatedMergeTreeQueue::pullLogsToQueue(zkutil::ZooKeeperPtr zookeeper, z
                 zkutil::ZooKeeper::ValueAndStat res = future.second.get();
                 copied_entries.emplace_back(LogEntry::parse(res.value, res.stat));
 
-                ops.emplace_back(std::make_unique<zkutil::Op::Create>(
+                ops.emplace_back(std::make_shared<zkutil::Op::Create>(
                     replica_path + "/queue/queue-", res.value, zookeeper->getDefaultACL(), zkutil::CreateMode::PersistentSequential));
 
                 const auto & entry = *copied_entries.back();
@@ -349,11 +349,11 @@ bool ReplicatedMergeTreeQueue::pullLogsToQueue(zkutil::ZooKeeperPtr zookeeper, z
                 }
             }
 
-            ops.emplace_back(std::make_unique<zkutil::Op::SetData>(
+            ops.emplace_back(std::make_shared<zkutil::Op::SetData>(
                 replica_path + "/log_pointer", toString(last_entry_index + 1), -1));
 
             if (min_unprocessed_insert_time_changed)
-                ops.emplace_back(std::make_unique<zkutil::Op::SetData>(
+                ops.emplace_back(std::make_shared<zkutil::Op::SetData>(
                     replica_path + "/min_unprocessed_insert_time", toString(*min_unprocessed_insert_time_changed), -1));
 
             try
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp
index 64e4c31e4a8..f8ea02cff9b 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp
@@ -94,16 +94,22 @@ void ReplicatedMergeTreeRestartingThread::run()
                         /// The exception when you try to zookeeper_init usually happens if DNS does not work. We will try to do it again.
                         tryLogCurrentException(__PRETTY_FUNCTION__);
 
+                        if (first_time)
+                            storage.startup_event.set();
                         wakeup_event.tryWait(retry_period_ms);
                         continue;
                     }
 
                     if (!need_stop && !tryStartup())
                     {
+                        if (first_time)
+                            storage.startup_event.set();
                         wakeup_event.tryWait(retry_period_ms);
                         continue;
                     }
 
+                    if (first_time)
+                        storage.startup_event.set();
                     break;
                 }
 
@@ -150,6 +156,7 @@ void ReplicatedMergeTreeRestartingThread::run()
         }
         catch (...)
         {
+            storage.startup_event.set();
             tryLogCurrentException(__PRETTY_FUNCTION__);
         }
 
@@ -322,9 +329,9 @@ void ReplicatedMergeTreeRestartingThread::activateReplica()
 
     /// Simultaneously declare that this replica is active, and update the host.
     zkutil::Ops ops;
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(is_active_path,
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(is_active_path,
         active_node_identifier, zookeeper->getDefaultACL(), zkutil::CreateMode::Ephemeral));
-    ops.emplace_back(std::make_unique<zkutil::Op::SetData>(storage.replica_path + "/host", address.toString(), -1));
+    ops.emplace_back(std::make_shared<zkutil::Op::SetData>(storage.replica_path + "/host", address.toString(), -1));
 
     try
     {
diff --git a/dbms/src/Storages/MergeTree/registerStorageMergeTree.cpp b/dbms/src/Storages/MergeTree/registerStorageMergeTree.cpp
index 89787fca4f0..4cdff05c2e3 100644
--- a/dbms/src/Storages/MergeTree/registerStorageMergeTree.cpp
+++ b/dbms/src/Storages/MergeTree/registerStorageMergeTree.cpp
@@ -628,14 +628,13 @@ static StoragePtr create(const StorageFactory::Arguments & args)
     if (replicated)
         return StorageReplicatedMergeTree::create(
             zookeeper_path, replica_name, args.attach, args.data_path, args.database_name, args.table_name,
-            args.columns, args.materialized_columns, args.alias_columns, args.column_defaults,
+            args.columns,
             args.context, primary_expr_list, secondary_sorting_expr_list, date_column_name, partition_expr_list,
             sampling_expression, merging_params, storage_settings,
             args.has_force_restore_data_flag);
     else
         return StorageMergeTree::create(
-            args.data_path, args.database_name, args.table_name,
-            args.columns, args.materialized_columns, args.alias_columns, args.column_defaults, args.attach,
+            args.data_path, args.database_name, args.table_name, args.columns, args.attach,
             args.context, primary_expr_list, secondary_sorting_expr_list, date_column_name, partition_expr_list,
             sampling_expression, merging_params, storage_settings,
             args.has_force_restore_data_flag);
diff --git a/dbms/src/Storages/StorageBuffer.cpp b/dbms/src/Storages/StorageBuffer.cpp
index 6b9ec92ce75..5c59ffa7c40 100644
--- a/dbms/src/Storages/StorageBuffer.cpp
+++ b/dbms/src/Storages/StorageBuffer.cpp
@@ -48,14 +48,11 @@ namespace ErrorCodes
 }
 
 
-StorageBuffer::StorageBuffer(const std::string & name_, const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+StorageBuffer::StorageBuffer(const std::string & name_, const ColumnsDescription & columns_,
     Context & context_,
     size_t num_shards_, const Thresholds & min_thresholds_, const Thresholds & max_thresholds_,
     const String & destination_database_, const String & destination_table_, bool allow_materialized_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
+    : IStorage{columns_},
     name(name_), context(context_),
     num_shards(num_shards_), buffers(num_shards_),
     min_thresholds(min_thresholds_), max_thresholds(max_thresholds_),
@@ -326,6 +323,20 @@ BlockOutputStreamPtr StorageBuffer::write(const ASTPtr & /*query*/, const Settin
 }
 
 
+bool StorageBuffer::mayBenefitFromIndexForIn(const ASTPtr & left_in_operand) const
+{
+    if (no_destination)
+        return false;
+
+    auto destination = context.getTable(destination_database, destination_table);
+
+    if (destination.get() == this)
+        throw Exception("Destination table is myself. Read will cause infinite loop.", ErrorCodes::INFINITE_LOOP);
+
+    return destination->mayBenefitFromIndexForIn(left_in_operand);
+}
+
+
 void StorageBuffer::startup()
 {
     if (context.getSettingsRef().readonly)
@@ -598,11 +609,10 @@ void StorageBuffer::alter(const AlterCommands & params, const String & database_
     /// So that no blocks of the old structure remain.
     optimize({} /*query*/, {} /*partition_id*/, false /*final*/, false /*deduplicate*/, context);
 
-    params.apply(columns, materialized_columns, alias_columns, column_defaults);
-
-    context.getDatabase(database_name)->alterTable(
-        context, table_name,
-        columns, materialized_columns, alias_columns, column_defaults, {});
+    ColumnsDescription new_columns = getColumns();
+    params.apply(new_columns);
+    context.getDatabase(database_name)->alterTable(context, table_name, new_columns, {});
+    setColumns(std::move(new_columns));
 }
 
 
@@ -641,7 +651,6 @@ void registerStorageBuffer(StorageFactory & factory)
 
         return StorageBuffer::create(
             args.table_name, args.columns,
-            args.materialized_columns, args.alias_columns, args.column_defaults,
             args.context,
             num_buckets,
             StorageBuffer::Thresholds{min_time, min_rows, min_bytes},
diff --git a/dbms/src/Storages/StorageBuffer.h b/dbms/src/Storages/StorageBuffer.h
index 9d9f72340c5..ea8a0562628 100644
--- a/dbms/src/Storages/StorageBuffer.h
+++ b/dbms/src/Storages/StorageBuffer.h
@@ -75,6 +75,8 @@ public:
     bool supportsFinal() const override { return true; }
     bool supportsIndexForIn() const override { return true; }
 
+    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand) const override;
+
     /// The structure of the subordinate table is not checked and does not change.
     void alter(const AlterCommands & params, const String & database_name, const String & table_name, const Context & context) override;
 
@@ -123,10 +125,7 @@ protected:
     /** num_shards - the level of internal parallelism (the number of independent buffers)
       * The buffer is flushed if all minimum thresholds or at least one of the maximum thresholds are exceeded.
       */
-    StorageBuffer(const std::string & name_, const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+    StorageBuffer(const std::string & name_, const ColumnsDescription & columns_,
         Context & context_,
         size_t num_shards_, const Thresholds & min_thresholds_, const Thresholds & max_thresholds_,
         const String & destination_database_, const String & destination_table_, bool allow_materialized_);
diff --git a/dbms/src/Storages/StorageCatBoostPool.cpp b/dbms/src/Storages/StorageCatBoostPool.cpp
index cbaf523e3bf..9fa8133617c 100644
--- a/dbms/src/Storages/StorageCatBoostPool.cpp
+++ b/dbms/src/Storages/StorageCatBoostPool.cpp
@@ -220,7 +220,7 @@ void StorageCatBoostPool::parseColumnDescription()
 
 void StorageCatBoostPool::createSampleBlockAndColumns()
 {
-    columns.clear();
+    ColumnsDescription columns;
     NamesAndTypesList cat_columns;
     NamesAndTypesList num_columns;
     sample_block.clear();
@@ -239,19 +239,21 @@ void StorageCatBoostPool::createSampleBlockAndColumns()
         else if (desc.column_type == DatasetColumnType::Num)
             num_columns.emplace_back(desc.column_name, type);
         else
-            materialized_columns.emplace_back(desc.column_name, type);
+            columns.materialized.emplace_back(desc.column_name, type);
 
         if (!desc.alias.empty())
         {
             auto alias = std::make_shared<ASTIdentifier>(desc.column_name);
-            column_defaults[desc.alias] = {ColumnDefaultType::Alias, alias};
-            alias_columns.emplace_back(desc.alias, type);
+            columns.defaults[desc.alias] = {ColumnDefaultKind::Alias, alias};
+            columns.aliases.emplace_back(desc.alias, type);
         }
 
         sample_block.insert(ColumnWithTypeAndName(type, desc.column_name));
     }
-    columns.insert(columns.end(), num_columns.begin(), num_columns.end());
-    columns.insert(columns.end(), cat_columns.begin(), cat_columns.end());
+    columns.ordinary.insert(columns.ordinary.end(), num_columns.begin(), num_columns.end());
+    columns.ordinary.insert(columns.ordinary.end(), cat_columns.begin(), cat_columns.end());
+
+    setColumns(columns);
 }
 
 BlockInputStreams StorageCatBoostPool::read(const Names & column_names,
diff --git a/dbms/src/Storages/StorageDictionary.cpp b/dbms/src/Storages/StorageDictionary.cpp
index 2bb69748c6d..b3dbf39e9c2 100644
--- a/dbms/src/Storages/StorageDictionary.cpp
+++ b/dbms/src/Storages/StorageDictionary.cpp
@@ -24,13 +24,10 @@ namespace ErrorCodes
 
 StorageDictionary::StorageDictionary(
     const String & table_name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const ColumnsDescription & columns_,
     const DictionaryStructure & dictionary_structure_,
     const String & dictionary_name_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_}, table_name(table_name_),
+    : IStorage{columns_}, table_name(table_name_),
     dictionary_name(dictionary_name_),
     logger(&Poco::Logger::get("StorageDictionary"))
 {
@@ -75,7 +72,7 @@ void StorageDictionary::checkNamesAndTypesCompatibleWithDictionary(const Diction
     auto dictionary_names_and_types = getNamesAndTypes(dictionary_structure);
     std::set<NameAndTypePair> namesAndTypesSet(dictionary_names_and_types.begin(), dictionary_names_and_types.end());
 
-    for (auto & column : columns)
+    for (auto & column : getColumns().ordinary)
     {
         if (namesAndTypesSet.find(column) == namesAndTypesSet.end())
         {
@@ -105,8 +102,7 @@ void registerStorageDictionary(StorageFactory & factory)
         const DictionaryStructure & dictionary_structure = dictionary->getStructure();
 
         return StorageDictionary::create(
-            args.table_name, args.columns, args.materialized_columns, args.alias_columns,
-            args.column_defaults, dictionary_structure, dictionary_name);
+            args.table_name, args.columns, dictionary_structure, dictionary_name);
     });
 }
 
diff --git a/dbms/src/Storages/StorageDictionary.h b/dbms/src/Storages/StorageDictionary.h
index 0f21373f546..0320a514839 100644
--- a/dbms/src/Storages/StorageDictionary.h
+++ b/dbms/src/Storages/StorageDictionary.h
@@ -22,7 +22,6 @@ class StorageDictionary : public ext::shared_ptr_helper<StorageDictionary>, publ
 public:
     std::string getName() const override { return "Dictionary"; }
     std::string getTableName() const override { return table_name; }
-    const NamesAndTypesList & getColumnsListImpl() const override { return columns; }
     BlockInputStreams read(const Names & column_names,
         const SelectQueryInfo & query_info,
         const Context & context,
@@ -62,10 +61,7 @@ private:
 
 protected:
     StorageDictionary(const String & table_name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         const DictionaryStructure & dictionary_structure_,
         const String & dictionary_name_);
 };
diff --git a/dbms/src/Storages/StorageDistributed.cpp b/dbms/src/Storages/StorageDistributed.cpp
index c1681e6fbea..e239ae3d65e 100644
--- a/dbms/src/Storages/StorageDistributed.cpp
+++ b/dbms/src/Storages/StorageDistributed.cpp
@@ -52,6 +52,7 @@ namespace ErrorCodes
     extern const int READONLY;
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
     extern const int INCORRECT_NUMBER_OF_COLUMNS;
+    extern const int INFINITE_LOOP;
 }
 
 
@@ -130,39 +131,44 @@ StorageDistributed::~StorageDistributed() = default;
 
 
 StorageDistributed::StorageDistributed(
-    const std::string & name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const String & database_name,
+    const String & table_name_,
+    const ColumnsDescription & columns_,
     const String & remote_database_,
     const String & remote_table_,
     const String & cluster_name_,
     const Context & context_,
     const ASTPtr & sharding_key_,
-    const String & data_path_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
-    name(name_),
+    const String & data_path_,
+    bool attach)
+    : IStorage{columns_},
+    table_name(table_name_),
     remote_database(remote_database_), remote_table(remote_table_),
-    context(context_), cluster_name(context.getMacros().expand(cluster_name_)), has_sharding_key(sharding_key_),
-    sharding_key_expr(sharding_key_ ? ExpressionAnalyzer(sharding_key_, context, nullptr, columns).getActions(false) : nullptr),
+    context(context_), cluster_name(context.getMacros()->expand(cluster_name_)), has_sharding_key(sharding_key_),
+      sharding_key_expr(sharding_key_ ? ExpressionAnalyzer(sharding_key_, context, nullptr, getColumns().getAllPhysical()).getActions(false) : nullptr),
     sharding_key_column_name(sharding_key_ ? sharding_key_->getColumnName() : String{}),
-    path(data_path_.empty() ? "" : (data_path_ + escapeForFileName(name) + '/'))
+    path(data_path_.empty() ? "" : (data_path_ + escapeForFileName(table_name) + '/'))
 {
+    /// Sanity check. Skip check if the table is already created to allow the server to start.
+    if (!attach && !cluster_name.empty())
+    {
+        size_t num_local_shards = context.getCluster(cluster_name)->getLocalShardCount();
+        if (num_local_shards && remote_database == database_name && remote_table == table_name)
+            throw Exception("Distributed table " + table_name + " looks at itself", ErrorCodes::INFINITE_LOOP);
+    }
 }
 
 
 StoragePtr StorageDistributed::createWithOwnCluster(
     const std::string & name_,
-    const NamesAndTypesList & columns_,
+    const ColumnsDescription & columns_,
     const String & remote_database_,
     const String & remote_table_,
     ClusterPtr & owned_cluster_,
     const Context & context_)
 {
     auto res = ext::shared_ptr_helper<StorageDistributed>::create(
-        name_, columns_, NamesAndTypesList(), NamesAndTypesList(), ColumnDefaults(),
-        remote_database_, remote_table_, String{}, context_, ASTPtr(), String());
+        String{}, name_, columns_, remote_database_, remote_table_, String{}, context_, ASTPtr(), String(), false);
 
     res->owned_cluster = owned_cluster_;
 
@@ -182,7 +188,9 @@ BlockInputStreams StorageDistributed::read(
 
     const Settings & settings = context.getSettingsRef();
 
-    size_t result_size = (cluster->getRemoteShardCount() * settings.max_parallel_replicas) + cluster->getLocalShardCount();
+    size_t num_local_shards = cluster->getLocalShardCount();
+    size_t num_remote_shards = cluster->getRemoteShardCount();
+    size_t result_size = (num_remote_shards * settings.max_parallel_replicas) + num_local_shards;
 
     processed_stage = result_size == 1 || settings.distributed_group_by_no_merge
         ? QueryProcessingStage::Complete
@@ -203,7 +211,7 @@ BlockInputStreams StorageDistributed::read(
 
 BlockOutputStreamPtr StorageDistributed::write(const ASTPtr & query, const Settings & settings)
 {
-    auto cluster = (owned_cluster) ? owned_cluster : context.getCluster(cluster_name);
+    auto cluster = getCluster();
 
     /// Ban an attempt to make async insert into the table belonging to DatabaseMemory
     if (path.empty() && !owned_cluster && !settings.insert_distributed_sync.value)
@@ -236,11 +244,11 @@ void StorageDistributed::alter(const AlterCommands & params, const String & data
             throw Exception("Storage engine " + getName() + " doesn't support primary key.", ErrorCodes::NOT_IMPLEMENTED);
 
     auto lock = lockStructureForAlter(__PRETTY_FUNCTION__);
-    params.apply(columns, materialized_columns, alias_columns, column_defaults);
 
-    context.getDatabase(database_name)->alterTable(
-        context, table_name,
-        columns, materialized_columns, alias_columns, column_defaults, {});
+    ColumnsDescription new_columns = getColumns();
+    params.apply(new_columns);
+    context.getDatabase(database_name)->alterTable(context, table_name, new_columns, {});
+    setColumns(std::move(new_columns));
 }
 
 
@@ -291,13 +299,13 @@ NameAndTypePair StorageDistributed::getColumn(const String & column_name) const
     if (const auto & type = VirtualColumnFactory::tryGetType(column_name))
         return { column_name, type };
 
-    return getRealColumn(column_name);
+    return getColumns().getPhysical(column_name);
 }
 
 
 bool StorageDistributed::hasColumn(const String & column_name) const
 {
-    return VirtualColumnFactory::hasColumn(column_name) || IStorage::hasColumn(column_name);
+    return VirtualColumnFactory::hasColumn(column_name) || getColumns().hasPhysical(column_name);
 }
 
 void StorageDistributed::createDirectoryMonitors()
@@ -331,13 +339,13 @@ ConnectionPoolPtr StorageDistributed::requireConnectionPool(const std::string &
 
 size_t StorageDistributed::getShardCount() const
 {
-    return getCluster()->getRemoteShardCount();
+    return getCluster()->getShardCount();
 }
 
 
 ClusterPtr StorageDistributed::getCluster() const
 {
-    return (owned_cluster) ? owned_cluster : context.getCluster(cluster_name);
+    return owned_cluster ? owned_cluster : context.getCluster(cluster_name);
 }
 
 void StorageDistributed::ClusterNodeData::requireConnectionPool(const std::string & name, const StorageDistributed & storage)
@@ -390,7 +398,7 @@ void registerStorageDistributed(StorageFactory & factory)
         /// Check that sharding_key exists in the table and has numeric type.
         if (sharding_key)
         {
-            auto sharding_expr = ExpressionAnalyzer(sharding_key, args.context, nullptr, args.columns).getActions(true);
+            auto sharding_expr = ExpressionAnalyzer(sharding_key, args.context, nullptr, args.columns.getAllPhysical()).getActions(true);
             const Block & block = sharding_expr->getSampleBlock();
 
             if (block.columns() != 1)
@@ -404,10 +412,10 @@ void registerStorageDistributed(StorageFactory & factory)
         }
 
         return StorageDistributed::create(
-            args.table_name, args.columns,
-            args.materialized_columns, args.alias_columns, args.column_defaults,
+            args.database_name, args.table_name, args.columns,
             remote_database, remote_table, cluster_name,
-            args.context, sharding_key, args.data_path);
+            args.context, sharding_key, args.data_path,
+            args.attach);
     });
 }
 
diff --git a/dbms/src/Storages/StorageDistributed.h b/dbms/src/Storages/StorageDistributed.h
index 6afb54ba007..41a11fa3199 100644
--- a/dbms/src/Storages/StorageDistributed.h
+++ b/dbms/src/Storages/StorageDistributed.h
@@ -34,20 +34,19 @@ public:
     ~StorageDistributed() override;
 
     static StoragePtr createWithOwnCluster(
-        const std::string & name_,            /// The name of the table.
-        const NamesAndTypesList & columns_,        /// List of columns.
+        const std::string & table_name_,
+        const ColumnsDescription & columns_,
         const String & remote_database_,      /// database on remote servers.
         const String & remote_table_,         /// The name of the table on the remote servers.
         ClusterPtr & owned_cluster_,
         const Context & context_);
 
     std::string getName() const override { return "Distributed"; }
-    std::string getTableName() const override { return name; }
+    std::string getTableName() const override { return table_name; }
     bool supportsSampling() const override { return true; }
     bool supportsFinal() const override { return true; }
     bool supportsPrewhere() const override { return true; }
 
-    const NamesAndTypesList & getColumnsListImpl() const override { return columns; }
     NameAndTypePair getColumn(const String & column_name) const override;
     bool hasColumn(const String & column_name) const override;
 
@@ -64,7 +63,7 @@ public:
     BlockOutputStreamPtr write(const ASTPtr & query, const Settings & settings) override;
 
     void drop() override {}
-    void rename(const String & /*new_path_to_db*/, const String & /*new_database_name*/, const String & new_table_name) override { name = new_table_name; }
+    void rename(const String & /*new_path_to_db*/, const String & /*new_database_name*/, const String & new_table_name) override { table_name = new_table_name; }
     /// in the sub-tables, you need to manually add and delete columns
     /// the structure of the sub-table is not checked
     void alter(const AlterCommands & params, const String & database_name, const String & table_name, const Context & context) override;
@@ -95,7 +94,7 @@ public:
     ClusterPtr getCluster() const;
 
 
-    String name;
+    String table_name;
     String remote_database;
     String remote_table;
 
@@ -131,17 +130,16 @@ public:
 
 protected:
     StorageDistributed(
-        const std::string & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const String & database_name,
+        const String & table_name_,
+        const ColumnsDescription & columns_,
         const String & remote_database_,
         const String & remote_table_,
         const String & cluster_name_,
         const Context & context_,
         const ASTPtr & sharding_key_,
-        const String & data_path_);
+        const String & data_path_,
+        bool attach);
 };
 
 }
diff --git a/dbms/src/Storages/StorageFactory.cpp b/dbms/src/Storages/StorageFactory.cpp
index 0bcc7166c1d..e6e661571aa 100644
--- a/dbms/src/Storages/StorageFactory.cpp
+++ b/dbms/src/Storages/StorageFactory.cpp
@@ -45,10 +45,7 @@ StoragePtr StorageFactory::get(
     const String & database_name,
     Context & local_context,
     Context & context,
-    const NamesAndTypesList & columns,
-    const NamesAndTypesList & materialized_columns,
-    const NamesAndTypesList & alias_columns,
-    const ColumnDefaults & column_defaults,
+    const ColumnsDescription & columns,
     bool attach,
     bool has_force_restore_data_flag) const
 {
@@ -67,9 +64,7 @@ StoragePtr StorageFactory::get(
     {
         /// Check for some special types, that are not allowed to be stored in tables. Example: NULL data type.
         /// Exception: any type is allowed in View, because plain (non-materialized) View does not store anything itself.
-        checkAllTypesAreAllowedInTable(columns);
-        checkAllTypesAreAllowedInTable(materialized_columns);
-        checkAllTypesAreAllowedInTable(alias_columns);
+        checkAllTypesAreAllowedInTable(columns.getAll());
 
         if (query.is_materialized_view)
         {
@@ -130,9 +125,6 @@ StoragePtr StorageFactory::get(
         .local_context = local_context,
         .context = context,
         .columns = columns,
-        .materialized_columns = materialized_columns,
-        .alias_columns = alias_columns,
-        .column_defaults = column_defaults,
         .attach = attach,
         .has_force_restore_data_flag = has_force_restore_data_flag
     };
diff --git a/dbms/src/Storages/StorageFactory.h b/dbms/src/Storages/StorageFactory.h
index 1af131943ba..2acb9fb7c00 100644
--- a/dbms/src/Storages/StorageFactory.h
+++ b/dbms/src/Storages/StorageFactory.h
@@ -14,7 +14,7 @@ class ASTStorage;
 
 
 /** Allows to create a table by the name and parameters of the engine.
-  * In 'columns', 'materialized_columns', etc., Nested data structures must be flattened.
+  * In 'columns' Nested data structures must be flattened.
   * You should subsequently call IStorage::startup method to work with table.
   */
 class StorageFactory : public ext::singleton<StorageFactory>
@@ -31,10 +31,7 @@ public:
         const String & database_name;
         Context & local_context;
         Context & context;
-        const NamesAndTypesList & columns;
-        const NamesAndTypesList & materialized_columns;
-        const NamesAndTypesList & alias_columns;
-        const ColumnDefaults & column_defaults;
+        const ColumnsDescription & columns;
         bool attach;
         bool has_force_restore_data_flag;
     };
@@ -48,10 +45,7 @@ public:
         const String & database_name,
         Context & local_context,
         Context & context,
-        const NamesAndTypesList & columns,
-        const NamesAndTypesList & materialized_columns,
-        const NamesAndTypesList & alias_columns,
-        const ColumnDefaults & column_defaults,
+        const ColumnsDescription & columns,
         bool attach,
         bool has_force_restore_data_flag) const;
 
diff --git a/dbms/src/Storages/StorageFile.cpp b/dbms/src/Storages/StorageFile.cpp
index 78fb3990978..2f606d5cbcf 100644
--- a/dbms/src/Storages/StorageFile.cpp
+++ b/dbms/src/Storages/StorageFile.cpp
@@ -54,12 +54,9 @@ StorageFile::StorageFile(
         const std::string & db_dir_path,
         const std::string & table_name_,
         const std::string & format_name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         Context & context_)
-    : IStorage(columns_, materialized_columns_, alias_columns_, column_defaults_),
+    : IStorage(columns_),
     table_name(table_name_), format_name(format_name_), context_global(context_), table_fd(table_fd_)
 {
     if (table_fd < 0) /// Will use file
@@ -311,7 +308,6 @@ void registerStorageFile(StorageFactory & factory)
         return StorageFile::create(
             source_path, source_fd,
             args.data_path, args.table_name, format_name, args.columns,
-            args.materialized_columns, args.alias_columns, args.column_defaults,
             args.context);
     });
 }
diff --git a/dbms/src/Storages/StorageFile.h b/dbms/src/Storages/StorageFile.h
index 8501415001c..4292ea6d7f9 100644
--- a/dbms/src/Storages/StorageFile.h
+++ b/dbms/src/Storages/StorageFile.h
@@ -31,11 +31,6 @@ public:
         return table_name;
     }
 
-    const NamesAndTypesList & getColumnsListImpl() const override
-    {
-        return columns;
-    }
-
     BlockInputStreams read(
         const Names & column_names,
         const SelectQueryInfo & query_info,
@@ -61,7 +56,7 @@ protected:
     /** there are three options (ordered by priority):
     - use specified file descriptor if (fd >= 0)
     - use specified table_path if it isn't empty
-    - create own tabale inside data/db/table/
+    - create own table inside data/db/table/
     */
     StorageFile(
         const std::string & table_path_,
@@ -69,10 +64,7 @@ protected:
         const std::string & db_dir_path,
         const std::string & table_name_,
         const std::string & format_name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         Context & context_);
 
 private:
diff --git a/dbms/src/Storages/StorageJoin.cpp b/dbms/src/Storages/StorageJoin.cpp
index 846c18d7055..aab48c3ed2a 100644
--- a/dbms/src/Storages/StorageJoin.cpp
+++ b/dbms/src/Storages/StorageJoin.cpp
@@ -24,24 +24,12 @@ StorageJoin::StorageJoin(
     const String & name_,
     const Names & key_names_,
     ASTTableJoin::Kind kind_, ASTTableJoin::Strictness strictness_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_)
-    : StorageSetOrJoinBase{path_, name_, columns_, materialized_columns_, alias_columns_, column_defaults_},
+    const ColumnsDescription & columns_)
+    : StorageSetOrJoinBase{path_, name_, columns_},
     key_names(key_names_), kind(kind_), strictness(strictness_)
 {
-    /// Check that key exists in table definition.
-    const auto check_key_exists = [] (const NamesAndTypesList & columns, const String & key)
-    {
-        for (const auto & column : columns)
-            if (column.name == key)
-                return true;
-        return false;
-    };
-
     for (const auto & key : key_names)
-        if (!check_key_exists(columns, key) && !check_key_exists(materialized_columns, key))
+        if (!getColumns().hasPhysical(key))
             throw Exception{
                 "Key column (" + key + ") does not exist in table declaration.",
                 ErrorCodes::NO_SUCH_COLUMN_IN_TABLE};
@@ -58,7 +46,7 @@ void StorageJoin::assertCompatible(ASTTableJoin::Kind kind_, ASTTableJoin::Stric
 {
     /// NOTE Could be more loose.
     if (!(kind == kind_ && strictness == strictness_))
-        throw Exception("Table " + name + " has incompatible type of JOIN.", ErrorCodes::INCOMPATIBLE_TYPE_OF_JOIN);
+        throw Exception("Table " + table_name + " has incompatible type of JOIN.", ErrorCodes::INCOMPATIBLE_TYPE_OF_JOIN);
 }
 
 
@@ -123,7 +111,7 @@ void registerStorageJoin(StorageFactory & factory)
         return StorageJoin::create(
             args.data_path, args.table_name,
             key_names, kind, strictness,
-            args.columns, args.materialized_columns, args.alias_columns, args.column_defaults);
+            args.columns);
     });
 }
 
diff --git a/dbms/src/Storages/StorageJoin.h b/dbms/src/Storages/StorageJoin.h
index 135236beddb..c005450e772 100644
--- a/dbms/src/Storages/StorageJoin.h
+++ b/dbms/src/Storages/StorageJoin.h
@@ -47,10 +47,7 @@ protected:
         const String & name_,
         const Names & key_names_,
         ASTTableJoin::Kind kind_, ASTTableJoin::Strictness strictness_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_);
+        const ColumnsDescription & columns_);
 };
 
 }
diff --git a/dbms/src/Storages/StorageKafka.cpp b/dbms/src/Storages/StorageKafka.cpp
index c3b14a468ca..80e4942839e 100644
--- a/dbms/src/Storages/StorageKafka.cpp
+++ b/dbms/src/Storages/StorageKafka.cpp
@@ -4,6 +4,8 @@
 
 #include <thread>
 #include <boost/algorithm/string/replace.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/trim.hpp>
 #include <Common/Exception.h>
 #include <Common/setThreadName.h>
 #include <Common/typeid_cast.h>
@@ -218,13 +220,10 @@ StorageKafka::StorageKafka(
     const std::string & table_name_,
     const std::string & database_name_,
     Context & context_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const ColumnsDescription & columns_,
     const String & brokers_, const String & group_, const Names & topics_,
     const String & format_name_, const String & schema_name_, size_t num_consumers_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
+    : IStorage{columns_},
     table_name(table_name_), database_name(database_name_), context(context_),
     topics(topics_), brokers(brokers_), group(group_), format_name(format_name_), schema_name(schema_name_),
     num_consumers(num_consumers_), log(&Logger::get("StorageKafka (" + table_name_ + ")")),
@@ -291,6 +290,7 @@ void StorageKafka::startup()
 
         // Make consumer available
         pushConsumer(consumer);
+        ++num_created_consumers;
     }
 
     // Start the reader thread
@@ -306,7 +306,7 @@ void StorageKafka::shutdown()
 
     // Unsubscribe from assignments
     LOG_TRACE(log, "Unsubscribing from assignments");
-    for (size_t i = 0; i < num_consumers; ++i)
+    for (size_t i = 0; i < num_created_consumers; ++i)
     {
         auto consumer = claimConsumer();
         consumer->unsubscribe();
@@ -576,9 +576,14 @@ void registerStorageKafka(StorageFactory & factory)
                 throw Exception("Number of consumers must be a positive integer", ErrorCodes::BAD_ARGUMENTS);
         }
 
-        // Parse topic list and consumer group
+        // Parse topic list
         Names topics;
-        topics.push_back(static_cast<const ASTLiteral &>(*engine_args[1]).value.safeGet<String>());
+        String topic_arg = static_cast<const ASTLiteral &>(*engine_args[1]).value.safeGet<String>();
+        boost::split(topics, topic_arg , [](char c){ return c == ','; });
+        for(String & topic : topics)
+            boost::trim(topic);
+
+        // Parse consumer group
         String group = static_cast<const ASTLiteral &>(*engine_args[2]).value.safeGet<String>();
 
         // Parse format from string
@@ -591,7 +596,6 @@ void registerStorageKafka(StorageFactory & factory)
 
         return StorageKafka::create(
             args.table_name, args.database_name, args.context, args.columns,
-            args.materialized_columns, args.alias_columns, args.column_defaults,
             brokers, group, topics, format, schema, num_consumers);
     });
 }
diff --git a/dbms/src/Storages/StorageKafka.h b/dbms/src/Storages/StorageKafka.h
index 39df9c136a1..45530517e94 100644
--- a/dbms/src/Storages/StorageKafka.h
+++ b/dbms/src/Storages/StorageKafka.h
@@ -76,7 +76,12 @@ private:
     const String group;
     const String format_name;
     const String schema_name;
-    size_t num_consumers; /// Total number of created consumers
+     /// Total number of consumers
+    size_t num_consumers;
+    /// Number of actually created consumers.
+    /// Can differ from num_consumers in case of exception in startup() (or if startup() hasn't been called).
+    /// In this case we still need to be able to shutdown() properly.
+    size_t num_created_consumers = 0;
     Poco::Logger * log;
 
     // Consumer list
@@ -102,10 +107,7 @@ protected:
         const std::string & table_name_,
         const std::string & database_name_,
         Context & context_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         const String & brokers_, const String & group_, const Names & topics_,
         const String & format_name_, const String & schema_name_, size_t num_consumers_);
 };
diff --git a/dbms/src/Storages/StorageLog.cpp b/dbms/src/Storages/StorageLog.cpp
index 711d48621f0..04d9f18ffd1 100644
--- a/dbms/src/Storages/StorageLog.cpp
+++ b/dbms/src/Storages/StorageLog.cpp
@@ -358,12 +358,9 @@ void LogBlockOutputStream::writeMarks(MarksForColumns && marks)
 StorageLog::StorageLog(
     const std::string & path_,
     const std::string & name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const ColumnsDescription & columns_,
     size_t max_compress_block_size_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
+    : IStorage{columns_},
     path(path_), name(name_),
     max_compress_block_size(max_compress_block_size_),
     file_checker(path + escapeForFileName(name) + '/' + "sizes.json")
@@ -374,7 +371,7 @@ StorageLog::StorageLog(
      /// create files if they do not exist
     Poco::File(path + escapeForFileName(name) + '/').createDirectories();
 
-    for (const auto & column : getColumnsList())
+    for (const auto & column : getColumns().getAllPhysical())
         addFiles(column.name, *column.type);
 
     marks_file = Poco::File(path + escapeForFileName(name) + '/' + DBMS_STORAGE_LOG_MARKS_FILE_NAME);
@@ -468,8 +465,8 @@ void StorageLog::rename(const String & new_path_to_db, const String & /*new_data
 
 const StorageLog::Marks & StorageLog::getMarksWithRealRowCount() const
 {
-    const String & column_name = columns.front().name;
-    const IDataType & column_type = *columns.front().type;
+    const String & column_name = getColumns().ordinary.front().name;
+    const IDataType & column_type = *getColumns().ordinary.front().type;
     String filename;
 
     /** We take marks from first column.
@@ -502,7 +499,7 @@ BlockInputStreams StorageLog::read(
     processed_stage = QueryProcessingStage::FetchColumns;
     loadMarks();
 
-    NamesAndTypesList columns = Nested::collect(getColumnsList().addTypes(column_names));
+    NamesAndTypesList all_columns = Nested::collect(getColumns().getAllPhysical().addTypes(column_names));
 
     std::shared_lock<std::shared_mutex> lock(rwlock);
 
@@ -526,7 +523,7 @@ BlockInputStreams StorageLog::read(
 
         res.emplace_back(std::make_shared<LogBlockInputStream>(
             max_block_size,
-            columns,
+            all_columns,
             *this,
             mark_begin,
             rows_end - rows_begin,
@@ -562,7 +559,6 @@ void registerStorageLog(StorageFactory & factory)
 
         return StorageLog::create(
             args.data_path, args.table_name, args.columns,
-            args.materialized_columns, args.alias_columns, args.column_defaults,
             args.context.getSettings().max_compress_block_size);
     });
 }
diff --git a/dbms/src/Storages/StorageLog.h b/dbms/src/Storages/StorageLog.h
index 4f38f403138..b52a90ec563 100644
--- a/dbms/src/Storages/StorageLog.h
+++ b/dbms/src/Storages/StorageLog.h
@@ -52,10 +52,7 @@ protected:
     StorageLog(
         const std::string & path_,
         const std::string & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         size_t max_compress_block_size_);
 
 private:
diff --git a/dbms/src/Storages/StorageMaterializedView.cpp b/dbms/src/Storages/StorageMaterializedView.cpp
index 33eec0ad8f7..c008eecb1c4 100644
--- a/dbms/src/Storages/StorageMaterializedView.cpp
+++ b/dbms/src/Storages/StorageMaterializedView.cpp
@@ -1,4 +1,5 @@
 #include <Parsers/ASTSelectQuery.h>
+#include <Parsers/ASTSelectWithUnionQuery.h>
 #include <Parsers/ASTCreateQuery.h>
 #include <Parsers/ASTDropQuery.h>
 #include <Parsers/ASTIdentifier.h>
@@ -22,6 +23,7 @@ namespace ErrorCodes
 {
     extern const int LOGICAL_ERROR;
     extern const int INCORRECT_QUERY;
+    extern const int QUERY_IS_NOT_SUPPORTED_IN_MATERIALIZED_VIEW;
 }
 
 
@@ -46,7 +48,7 @@ static void extractDependentTable(ASTSelectQuery & query, String & select_databa
     else if (auto ast_select = typeid_cast<ASTSelectWithUnionQuery *>(query_table.get()))
     {
         if (ast_select->list_of_selects->children.size() != 1)
-            throw Exception("UNION is not supported for MATERIALIZED VIEW", ErrorCodes::INCORRECT_QUERY);
+            throw Exception("UNION is not supported for MATERIALIZED VIEW", ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_MATERIALIZED_VIEW);
 
         auto & inner_query = ast_select->list_of_selects->children.at(0);
 
@@ -59,17 +61,36 @@ static void extractDependentTable(ASTSelectQuery & query, String & select_databa
 }
 
 
+static void checkAllowedQueries(const ASTSelectQuery & query)
+{
+    if (query.prewhere_expression || query.final() || query.sample_size())
+        throw Exception("MATERIALIZED VIEW cannot have PREWHERE, SAMPLE or FINAL.", DB::ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_MATERIALIZED_VIEW);
+
+    auto query_table = query.table();
+
+    if (!query_table)
+        return;
+
+    if (auto ast_select = typeid_cast<const ASTSelectWithUnionQuery *>(query_table.get()))
+    {
+        if (ast_select->list_of_selects->children.size() != 1)
+            throw Exception("UNION is not supported for MATERIALIZED VIEW", ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_MATERIALIZED_VIEW);
+
+        const auto & inner_query = ast_select->list_of_selects->children.at(0);
+
+        checkAllowedQueries(typeid_cast<const ASTSelectQuery &>(*inner_query));
+    }
+}
+
+
 StorageMaterializedView::StorageMaterializedView(
     const String & table_name_,
     const String & database_name_,
     Context & local_context,
     const ASTCreateQuery & query,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const ColumnsDescription & columns_,
     bool attach_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_}, table_name(table_name_),
+    : IStorage{columns_}, table_name(table_name_),
     database_name(database_name_), global_context(local_context.getGlobalContext())
 {
     if (!query.select)
@@ -83,11 +104,13 @@ StorageMaterializedView::StorageMaterializedView(
     /// Default value, if only table name exist in the query
     select_database_name = local_context.getCurrentDatabase();
     if (query.select->list_of_selects->children.size() != 1)
-        throw Exception("UNION is not supported for MATERIALIZED VIEW", ErrorCodes::INCORRECT_QUERY);
+        throw Exception("UNION is not supported for MATERIALIZED VIEW", ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_MATERIALIZED_VIEW);
 
     inner_query = query.select->list_of_selects->children.at(0);
 
-    extractDependentTable(typeid_cast<ASTSelectQuery &>(*inner_query), select_database_name, select_table_name);
+    ASTSelectQuery & select_query = typeid_cast<ASTSelectQuery &>(*inner_query);
+    extractDependentTable(select_query, select_database_name, select_table_name);
+    checkAllowedQueries(select_query);
 
     if (!select_table_name.empty())
         global_context.addDependency(
@@ -181,11 +204,44 @@ void StorageMaterializedView::drop()
     }
 }
 
+void StorageMaterializedView::checkStatementCanBeForwarded() const
+{
+    if (!has_inner_table)
+        throw Exception(
+            "MATERIALIZED VIEW targets existing table " + target_database_name + "." + target_table_name + ". "
+            + "Execute the statement directly on it.", ErrorCodes::INCORRECT_QUERY);
+}
+
 bool StorageMaterializedView::optimize(const ASTPtr & query, const ASTPtr & partition, bool final, bool deduplicate, const Context & context)
 {
+    checkStatementCanBeForwarded();
     return getTargetTable()->optimize(query, partition, final, deduplicate, context);
 }
 
+void StorageMaterializedView::dropPartition(const ASTPtr & query, const ASTPtr & partition, bool detach, const Context & context)
+{
+    checkStatementCanBeForwarded();
+    getTargetTable()->dropPartition(query, partition, detach, context);
+}
+
+void StorageMaterializedView::clearColumnInPartition(const ASTPtr & partition, const Field & column_name, const Context & context)
+{
+    checkStatementCanBeForwarded();
+    getTargetTable()->clearColumnInPartition(partition, column_name, context);
+}
+
+void StorageMaterializedView::attachPartition(const ASTPtr & partition, bool part, const Context & context)
+{
+    checkStatementCanBeForwarded();
+    getTargetTable()->attachPartition(partition, part, context);
+}
+
+void StorageMaterializedView::freezePartition(const ASTPtr & partition, const String & with_name, const Context & context)
+{
+    checkStatementCanBeForwarded();
+    getTargetTable()->freezePartition(partition, with_name, context);
+}
+
 void StorageMaterializedView::shutdown()
 {
     /// Make sure the dependency is removed after DETACH TABLE
@@ -213,8 +269,7 @@ void registerStorageMaterializedView(StorageFactory & factory)
         /// Pass local_context here to convey setting for inner table
         return StorageMaterializedView::create(
             args.table_name, args.database_name, args.local_context, args.query,
-            args.columns, args.materialized_columns, args.alias_columns, args.column_defaults,
-            args.attach);
+            args.columns, args.attach);
     });
 }
 
diff --git a/dbms/src/Storages/StorageMaterializedView.h b/dbms/src/Storages/StorageMaterializedView.h
index 4dd0980e874..7edffe28d76 100644
--- a/dbms/src/Storages/StorageMaterializedView.h
+++ b/dbms/src/Storages/StorageMaterializedView.h
@@ -17,9 +17,7 @@ class StorageMaterializedView : public ext::shared_ptr_helper<StorageMaterialize
 public:
     std::string getName() const override { return "MaterializedView"; }
     std::string getTableName() const override { return table_name; }
-    const NamesAndTypesList & getColumnsListImpl() const override { return columns; }
     ASTPtr getInnerQuery() const { return inner_query->clone(); };
-    StoragePtr getTargetTable() const;
 
     NameAndTypePair getColumn(const String & column_name) const override;
     bool hasColumn(const String & column_name) const override;
@@ -28,10 +26,18 @@ public:
     bool supportsPrewhere() const override { return getTargetTable()->supportsPrewhere(); }
     bool supportsFinal() const override { return getTargetTable()->supportsFinal(); }
     bool supportsIndexForIn() const override { return getTargetTable()->supportsIndexForIn(); }
+    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand) const override { return getTargetTable()->mayBenefitFromIndexForIn(left_in_operand); }
 
     BlockOutputStreamPtr write(const ASTPtr & query, const Settings & settings) override;
     void drop() override;
+
     bool optimize(const ASTPtr & query, const ASTPtr & partition, bool final, bool deduplicate, const Context & context) override;
+
+    void dropPartition(const ASTPtr & query, const ASTPtr & partition, bool detach, const Context & context) override;
+    void clearColumnInPartition(const ASTPtr & partition, const Field & column_name, const Context & context) override;
+    void attachPartition(const ASTPtr & partition, bool part, const Context & context) override;
+    void freezePartition(const ASTPtr & partition, const String & with_name, const Context & context) override;
+
     void shutdown() override;
     bool checkTableCanBeDropped() const override;
 
@@ -56,16 +62,17 @@ private:
     Context & global_context;
     bool has_inner_table = false;
 
+    StoragePtr getTargetTable() const;
+
+    void checkStatementCanBeForwarded() const;
+
 protected:
     StorageMaterializedView(
         const String & table_name_,
         const String & database_name_,
         Context & local_context,
         const ASTCreateQuery & query,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         bool attach_);
 };
 
diff --git a/dbms/src/Storages/StorageMemory.cpp b/dbms/src/Storages/StorageMemory.cpp
index 96af6a9a138..7b36796c324 100644
--- a/dbms/src/Storages/StorageMemory.cpp
+++ b/dbms/src/Storages/StorageMemory.cpp
@@ -74,14 +74,8 @@ private:
 };
 
 
-StorageMemory::StorageMemory(
-    const std::string & name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
-    name(name_)
+StorageMemory::StorageMemory(String table_name_, ColumnsDescription columns_description_)
+    : IStorage{std::move(columns_description_)}, table_name(std::move(table_name_))
 {
 }
 
@@ -144,7 +138,7 @@ void registerStorageMemory(StorageFactory & factory)
                 "Engine " + args.engine_name + " doesn't support any arguments (" + toString(args.engine_args.size()) + " given)",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        return StorageMemory::create(args.table_name, args.columns, args.materialized_columns, args.alias_columns, args.column_defaults);
+        return StorageMemory::create(args.table_name, args.columns);
     });
 }
 
diff --git a/dbms/src/Storages/StorageMemory.h b/dbms/src/Storages/StorageMemory.h
index 956e4354727..454fdcc2823 100644
--- a/dbms/src/Storages/StorageMemory.h
+++ b/dbms/src/Storages/StorageMemory.h
@@ -24,7 +24,7 @@ friend class MemoryBlockOutputStream;
 
 public:
     std::string getName() const override { return "Memory"; }
-    std::string getTableName() const override { return name; }
+    std::string getTableName() const override { return table_name; }
 
     size_t getSize() const { return data.size(); }
 
@@ -39,10 +39,10 @@ public:
     BlockOutputStreamPtr write(const ASTPtr & query, const Settings & settings) override;
 
     void drop() override;
-    void rename(const String & /*new_path_to_db*/, const String & /*new_database_name*/, const String & new_table_name) override { name = new_table_name; }
+    void rename(const String & /*new_path_to_db*/, const String & /*new_database_name*/, const String & new_table_name) override { table_name = new_table_name; }
 
 private:
-    String name;
+    String table_name;
 
     /// The data itself. `list` - so that when inserted to the end, the existing iterators are not invalidated.
     BlocksList data;
@@ -50,12 +50,7 @@ private:
     std::mutex mutex;
 
 protected:
-    StorageMemory(
-        const std::string & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_);
+    StorageMemory(String table_name_, ColumnsDescription columns_description_);
 };
 
 }
diff --git a/dbms/src/Storages/StorageMerge.cpp b/dbms/src/Storages/StorageMerge.cpp
index 7ceecc62a43..c0f264e7f85 100644
--- a/dbms/src/Storages/StorageMerge.cpp
+++ b/dbms/src/Storages/StorageMerge.cpp
@@ -37,14 +37,11 @@ namespace ErrorCodes
 
 StorageMerge::StorageMerge(
     const std::string & name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const ColumnsDescription & columns_,
     const String & source_database_,
     const String & table_name_regexp_,
     const Context & context_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
+    : IStorage{columns_},
     name(name_), source_database(source_database_),
     table_name_regexp(table_name_regexp_), context(context_)
 {
@@ -114,6 +111,27 @@ namespace
 }
 
 
+bool StorageMerge::mayBenefitFromIndexForIn(const ASTPtr & left_in_operand) const
+{
+    /// It's beneficial if it is true for at least one table.
+    StorageListWithLocks selected_tables = getSelectedTables();
+
+    size_t i = 0;
+    for (const auto & table : selected_tables)
+    {
+        if (table.first->mayBenefitFromIndexForIn(left_in_operand))
+            return true;
+
+        ++i;
+        /// For simplicity reasons, check only first ten tables.
+        if (i > 10)
+            break;
+    }
+
+    return false;
+}
+
+
 BlockInputStreams StorageMerge::read(
     const Names & column_names,
     const SelectQueryInfo & query_info,
@@ -184,7 +202,7 @@ BlockInputStreams StorageMerge::read(
 
         /// If there are only virtual columns in query, you must request at least one other column.
         if (real_column_names.size() == 0)
-            real_column_names.push_back(ExpressionActions::getSmallestColumn(table->getColumnsList()));
+            real_column_names.push_back(ExpressionActions::getSmallestColumn(table->getColumns().getAllPhysical()));
 
         /// Substitute virtual column for its value when querying tables.
         ASTPtr modified_query_ast = query->clone();
@@ -336,11 +354,11 @@ void StorageMerge::alter(const AlterCommands & params, const String & database_n
             throw Exception("Storage engine " + getName() + " doesn't support primary key.", ErrorCodes::NOT_IMPLEMENTED);
 
     auto lock = lockStructureForAlter(__PRETTY_FUNCTION__);
-    params.apply(columns, materialized_columns, alias_columns, column_defaults);
 
-    context.getDatabase(database_name)->alterTable(
-        context, table_name,
-        columns, materialized_columns, alias_columns, column_defaults, {});
+    ColumnsDescription new_columns = getColumns();
+    params.apply(new_columns);
+    context.getDatabase(database_name)->alterTable(context, table_name, new_columns, {});
+    setColumns(new_columns);
 }
 
 
@@ -367,7 +385,6 @@ void registerStorageMerge(StorageFactory & factory)
 
         return StorageMerge::create(
             args.table_name, args.columns,
-            args.materialized_columns, args.alias_columns, args.column_defaults,
             source_database, table_name_regexp, args.context);
     });
 }
diff --git a/dbms/src/Storages/StorageMerge.h b/dbms/src/Storages/StorageMerge.h
index 9bef645c0e0..e48cfc1d1fc 100644
--- a/dbms/src/Storages/StorageMerge.h
+++ b/dbms/src/Storages/StorageMerge.h
@@ -26,7 +26,6 @@ public:
     bool supportsFinal() const override { return true; }
     bool supportsIndexForIn() const override { return true; }
 
-    const NamesAndTypesList & getColumnsListImpl() const override { return columns; }
     NameAndTypePair getColumn(const String & column_name) const override;
     bool hasColumn(const String & column_name) const override;
 
@@ -45,6 +44,8 @@ public:
     /// the structure of sub-tables is not checked
     void alter(const AlterCommands & params, const String & database_name, const String & table_name, const Context & context) override;
 
+    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand) const override;
+
 private:
     String name;
     String source_database;
@@ -60,10 +61,7 @@ private:
 protected:
     StorageMerge(
         const std::string & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         const String & source_database_,
         const String & table_name_regexp_,
         const Context & context_);
diff --git a/dbms/src/Storages/StorageMergeTree.cpp b/dbms/src/Storages/StorageMergeTree.cpp
index 8ee9f3c7c5b..293c3254a8f 100644
--- a/dbms/src/Storages/StorageMergeTree.cpp
+++ b/dbms/src/Storages/StorageMergeTree.cpp
@@ -35,10 +35,7 @@ StorageMergeTree::StorageMergeTree(
     const String & path_,
     const String & database_name_,
     const String & table_name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const ColumnsDescription & columns_,
     bool attach,
     Context & context_,
     const ASTPtr & primary_expr_ast_,
@@ -49,12 +46,10 @@ StorageMergeTree::StorageMergeTree(
     const MergeTreeData::MergingParams & merging_params_,
     const MergeTreeSettings & settings_,
     bool has_force_restore_data_flag)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
-    path(path_), database_name(database_name_), table_name(table_name_), full_path(path + escapeForFileName(table_name) + '/'),
+    : path(path_), database_name(database_name_), table_name(table_name_), full_path(path + escapeForFileName(table_name) + '/'),
     context(context_), background_pool(context_.getBackgroundPool()),
     data(database_name, table_name,
          full_path, columns_,
-         materialized_columns_, alias_columns_, column_defaults_,
          context_, primary_expr_ast_, secondary_sorting_expr_list_, date_column_name, partition_expr_ast_,
          sampling_expression_, merging_params_,
          settings_, false, attach),
@@ -157,16 +152,8 @@ void StorageMergeTree::alter(
 
     data.checkAlter(params);
 
-    auto new_columns = data.getColumnsListNonMaterialized();
-    auto new_materialized_columns = data.materialized_columns;
-    auto new_alias_columns = data.alias_columns;
-    auto new_column_defaults = data.column_defaults;
-
-    params.apply(new_columns, new_materialized_columns, new_alias_columns, new_column_defaults);
-
-    auto columns_for_parts = new_columns;
-    columns_for_parts.insert(std::end(columns_for_parts),
-        std::begin(new_materialized_columns), std::end(new_materialized_columns));
+    auto new_columns = data.getColumns();
+    params.apply(new_columns);
 
     std::vector<MergeTreeData::AlterDataPartTransactionPtr> transactions;
 
@@ -187,6 +174,7 @@ void StorageMergeTree::alter(
         throw Exception("MODIFY PRIMARY KEY only supported for tables without sampling key", ErrorCodes::BAD_ARGUMENTS);
 
     auto parts = data.getDataParts({MergeTreeDataPartState::PreCommitted, MergeTreeDataPartState::Committed, MergeTreeDataPartState::Outdated});
+    auto columns_for_parts = new_columns.getAllPhysical();
     for (const MergeTreeData::DataPartPtr & part : parts)
     {
         if (auto transaction = data.alterDataPart(part, columns_for_parts, new_primary_key_ast, false))
@@ -212,19 +200,8 @@ void StorageMergeTree::alter(
         };
     }
 
-    context.getDatabase(database_name)->alterTable(
-        context, table_name,
-        new_columns, new_materialized_columns, new_alias_columns, new_column_defaults,
-        storage_modifier);
-
-    materialized_columns = new_materialized_columns;
-    alias_columns = new_alias_columns;
-    column_defaults = new_column_defaults;
-
-    data.setColumnsList(new_columns);
-    data.materialized_columns = std::move(new_materialized_columns);
-    data.alias_columns = std::move(new_alias_columns);
-    data.column_defaults = std::move(new_column_defaults);
+    context.getDatabase(database_name)->alterTable(context, table_name, new_columns, storage_modifier);
+    setColumns(std::move(new_columns));
 
     if (primary_key_is_modified)
     {
@@ -438,17 +415,10 @@ void StorageMergeTree::clearColumnInPartition(const ASTPtr & partition, const Fi
     alter_command.type = AlterCommand::DROP_COLUMN;
     alter_command.column_name = get<String>(column_name);
 
-    auto new_columns = data.getColumnsListNonMaterialized();
-    auto new_materialized_columns = data.materialized_columns;
-    auto new_alias_columns = data.alias_columns;
-    auto new_column_defaults = data.column_defaults;
-
-    alter_command.apply(new_columns, new_materialized_columns, new_alias_columns, new_column_defaults);
-
-    auto columns_for_parts = new_columns;
-    columns_for_parts.insert(std::end(columns_for_parts),
-        std::begin(new_materialized_columns), std::end(new_materialized_columns));
+    auto new_columns = getColumns();
+    alter_command.apply(new_columns);
 
+    auto columns_for_parts = new_columns.getAllPhysical();
     for (const auto & part : parts)
     {
         if (part->info.partition_id != partition_id)
diff --git a/dbms/src/Storages/StorageMergeTree.h b/dbms/src/Storages/StorageMergeTree.h
index e1121ec84d0..a2787a8bb30 100644
--- a/dbms/src/Storages/StorageMergeTree.h
+++ b/dbms/src/Storages/StorageMergeTree.h
@@ -2,6 +2,7 @@
 
 #include <ext/shared_ptr_helper.h>
 
+#include <Storages/IStorage.h>
 #include <Storages/MergeTree/MergeTreeData.h>
 #include <Storages/MergeTree/MergeTreeDataSelectExecutor.h>
 #include <Storages/MergeTree/MergeTreeDataWriter.h>
@@ -31,11 +32,15 @@ public:
     }
 
     std::string getTableName() const override { return table_name; }
-    bool supportsSampling() const override { return data.supportsSampling(); }
-    bool supportsFinal() const override { return data.supportsFinal(); }
-    bool supportsPrewhere() const override { return data.supportsPrewhere(); }
 
-    const NamesAndTypesList & getColumnsListImpl() const override { return data.getColumnsListNonMaterialized(); }
+    bool supportsSampling() const override { return data.supportsSampling(); }
+    bool supportsPrewhere() const override { return data.supportsPrewhere(); }
+    bool supportsFinal() const override { return data.supportsFinal(); }
+    bool supportsIndexForIn() const override { return true; }
+    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand) const override { return data.mayBenefitFromIndexForIn(left_in_operand); }
+
+    const ColumnsDescription & getColumns() const override { return data.getColumns(); }
+    void setColumns(ColumnsDescription columns_) override { return data.setColumns(std::move(columns_)); }
 
     NameAndTypePair getColumn(const String & column_name) const override
     {
@@ -72,9 +77,6 @@ public:
 
     void alter(const AlterCommands & params, const String & database_name, const String & table_name, const Context & context) override;
 
-    bool supportsIndexForIn() const override { return true; }
-    bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand) const override { return data.mayBenefitFromIndexForIn(left_in_operand); }
-
     bool checkTableCanBeDropped() const override;
 
     MergeTreeData & getData() { return data; }
@@ -135,10 +137,7 @@ protected:
         const String & path_,
         const String & database_name_,
         const String & table_name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         bool attach,
         Context & context_,
         const ASTPtr & primary_expr_ast_,
diff --git a/dbms/src/Storages/StorageMySQL.cpp b/dbms/src/Storages/StorageMySQL.cpp
index f3f18518d83..3c63ebe4ca5 100644
--- a/dbms/src/Storages/StorageMySQL.cpp
+++ b/dbms/src/Storages/StorageMySQL.cpp
@@ -23,8 +23,8 @@ StorageMySQL::StorageMySQL(
     mysqlxx::Pool && pool,
     const std::string & remote_database_name,
     const std::string & remote_table_name,
-    const NamesAndTypesList & columns_)
-    : IStorage{columns_, {}, {}, {}}
+    const ColumnsDescription & columns_)
+    : IStorage{columns_}
     , name(name)
     , remote_database_name(remote_database_name)
     , remote_table_name(remote_table_name)
@@ -43,7 +43,7 @@ BlockInputStreams StorageMySQL::read(
 {
     check(column_names);
     processed_stage = QueryProcessingStage::FetchColumns;
-    String query = transformQueryForExternalDatabase(*query_info.query, columns, remote_database_name, remote_table_name, context);
+    String query = transformQueryForExternalDatabase(*query_info.query, getColumns().ordinary, remote_database_name, remote_table_name, context);
 
     Block sample_block;
     for (const String & name : column_names)
diff --git a/dbms/src/Storages/StorageMySQL.h b/dbms/src/Storages/StorageMySQL.h
index 9558605ff0e..9e2b233283e 100644
--- a/dbms/src/Storages/StorageMySQL.h
+++ b/dbms/src/Storages/StorageMySQL.h
@@ -24,7 +24,7 @@ public:
         mysqlxx::Pool && pool,
         const std::string & remote_database_name,
         const std::string & remote_table_name,
-        const NamesAndTypesList & columns_);
+        const ColumnsDescription & columns);
 
     std::string getName() const override { return "MySQL"; }
     std::string getTableName() const override { return name; }
diff --git a/dbms/src/Storages/StorageNull.cpp b/dbms/src/Storages/StorageNull.cpp
index 0cee00aa1b8..25ecfecf2c9 100644
--- a/dbms/src/Storages/StorageNull.cpp
+++ b/dbms/src/Storages/StorageNull.cpp
@@ -25,8 +25,7 @@ void registerStorageNull(StorageFactory & factory)
                 "Engine " + args.engine_name + " doesn't support any arguments (" + toString(args.engine_args.size()) + " given)",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        return StorageNull::create(args.table_name,
-            args.columns, args.materialized_columns, args.alias_columns, args.column_defaults);
+        return StorageNull::create(args.table_name, args.columns);
     });
 }
 
@@ -34,11 +33,10 @@ void StorageNull::alter(const AlterCommands & params, const String & database_na
 {
     auto lock = lockStructureForAlter(__PRETTY_FUNCTION__);
 
-    params.apply(columns, materialized_columns, alias_columns, column_defaults);
-
-    context.getDatabase(database_name)->alterTable(
-        context, table_name,
-        columns, materialized_columns, alias_columns, column_defaults, {});
+    ColumnsDescription new_columns = getColumns();
+    params.apply(new_columns);
+    context.getDatabase(database_name)->alterTable(context, table_name, new_columns, {});
+    setColumns(std::move(new_columns));
 }
 
 }
diff --git a/dbms/src/Storages/StorageNull.h b/dbms/src/Storages/StorageNull.h
index ef3f0f6fcd1..cdde480a951 100644
--- a/dbms/src/Storages/StorageNull.h
+++ b/dbms/src/Storages/StorageNull.h
@@ -18,7 +18,7 @@ class StorageNull : public ext::shared_ptr_helper<StorageNull>, public IStorage
 {
 public:
     std::string getName() const override { return "Null"; }
-    std::string getTableName() const override { return name; }
+    std::string getTableName() const override { return table_name; }
 
     BlockInputStreams read(
         const Names & column_names,
@@ -38,22 +38,19 @@ public:
 
     void rename(const String & /*new_path_to_db*/, const String & /*new_database_name*/, const String & new_table_name) override
     {
-        name = new_table_name;
+        table_name = new_table_name;
     }
 
     void alter(const AlterCommands & params, const String & database_name, const String & table_name, const Context & context) override;
 
 private:
-    String name;
+    String table_name;
 
 protected:
-    StorageNull(
-        const std::string & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_)
-        : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_}, name(name_)  {}
+    StorageNull(String table_name_, ColumnsDescription columns_description_)
+        : IStorage{std::move(columns_description_)}, table_name(std::move(table_name_))
+    {
+    }
 };
 
 }
diff --git a/dbms/src/Storages/StorageODBC.cpp b/dbms/src/Storages/StorageODBC.cpp
index 67362bf2f90..09791c0e314 100644
--- a/dbms/src/Storages/StorageODBC.cpp
+++ b/dbms/src/Storages/StorageODBC.cpp
@@ -21,8 +21,8 @@ StorageODBC::StorageODBC(
     const std::string & connection_string,
     const std::string & remote_database_name,
     const std::string & remote_table_name,
-    const NamesAndTypesList & columns_)
-    : IStorage{columns_, {}, {}, {}}
+    const ColumnsDescription & columns_)
+    : IStorage{columns_}
     , name(name)
     , remote_database_name(remote_database_name)
     , remote_table_name(remote_table_name)
@@ -43,7 +43,8 @@ BlockInputStreams StorageODBC::read(
 {
     check(column_names);
     processed_stage = QueryProcessingStage::FetchColumns;
-    String query = transformQueryForExternalDatabase(*query_info.query, columns, remote_database_name, remote_table_name, context);
+    String query = transformQueryForExternalDatabase(
+        *query_info.query, getColumns().ordinary, remote_database_name, remote_table_name, context);
 
     Block sample_block;
     for (const String & name : column_names)
diff --git a/dbms/src/Storages/StorageODBC.h b/dbms/src/Storages/StorageODBC.h
index f582c74a263..5632fe38282 100644
--- a/dbms/src/Storages/StorageODBC.h
+++ b/dbms/src/Storages/StorageODBC.h
@@ -30,7 +30,7 @@ public:
         const std::string & connection_string,
         const std::string & remote_database_name,
         const std::string & remote_table_name,
-        const NamesAndTypesList & columns_);
+        const ColumnsDescription & columns_);
 
     std::string getName() const override { return "ODBC"; }
     std::string getTableName() const override { return name; }
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.cpp b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
index 22fb515b7e6..f11d9fe28b8 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
@@ -174,10 +174,7 @@ StorageReplicatedMergeTree::StorageReplicatedMergeTree(
     const String & replica_name_,
     bool attach,
     const String & path_, const String & database_name_, const String & name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const ColumnsDescription & columns_,
     Context & context_,
     const ASTPtr & primary_expr_ast_,
     const ASTPtr & secondary_sorting_expr_list_,
@@ -187,14 +184,13 @@ StorageReplicatedMergeTree::StorageReplicatedMergeTree(
     const MergeTreeData::MergingParams & merging_params_,
     const MergeTreeSettings & settings_,
     bool has_force_restore_data_flag)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_}, context(context_),
+    : context(context_),
     current_zookeeper(context.getZooKeeper()), database_name(database_name_),
     table_name(name_), full_path(path_ + escapeForFileName(table_name) + '/'),
-    zookeeper_path(context.getMacros().expand(zookeeper_path_)),
-    replica_name(context.getMacros().expand(replica_name_)),
+    zookeeper_path(context.getMacros()->expand(zookeeper_path_)),
+    replica_name(context.getMacros()->expand(replica_name_)),
     data(database_name, table_name,
         full_path, columns_,
-        materialized_columns_, alias_columns_, column_defaults_,
         context_, primary_expr_ast_, secondary_sorting_expr_list_, date_column_name, partition_expr_ast_,
         sampling_expression_, merging_params_,
         settings_, true, attach,
@@ -484,27 +480,25 @@ void StorageReplicatedMergeTree::createTableIfNotExists()
     auto acl = zookeeper->getDefaultACL();
 
     zkutil::Ops ops;
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path, "",
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(zookeeper_path, "",
         acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/metadata", metadata,
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(zookeeper_path + "/metadata", metadata,
         acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/columns", ColumnsDescription<false>{
-        data.getColumnsListNonMaterialized(), data.materialized_columns,
-        data.alias_columns, data.column_defaults}.toString(),
+    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/columns", getColumns().toString(),
         acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/log", "",
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(zookeeper_path + "/log", "",
         acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/blocks", "",
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(zookeeper_path + "/blocks", "",
         acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/block_numbers", "",
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(zookeeper_path + "/block_numbers", "",
         acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/nonincrement_block_numbers", "",
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(zookeeper_path + "/nonincrement_block_numbers", "",
         acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/leader_election", "",
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(zookeeper_path + "/leader_election", "",
         acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/temp", "",
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(zookeeper_path + "/temp", "",
         acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(zookeeper_path + "/replicas", "",
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(zookeeper_path + "/replicas", "",
         acl, zkutil::CreateMode::Persistent));
 
     auto code = zookeeper->tryMulti(ops);
@@ -524,39 +518,27 @@ void StorageReplicatedMergeTree::checkTableStructure(bool skip_sanity_checks, bo
     TableMetadata(data).check(metadata_str);
 
     zkutil::Stat stat;
-    auto columns_desc = ColumnsDescription<true>::parse(zookeeper->get(zookeeper_path + "/columns", &stat));
-
-    auto & columns = columns_desc.columns;
-    auto & materialized_columns = columns_desc.materialized;
-    auto & alias_columns = columns_desc.alias;
-    auto & column_defaults = columns_desc.defaults;
+    auto columns_from_zk = ColumnsDescription::parse(zookeeper->get(zookeeper_path + "/columns", &stat));
     columns_version = stat.version;
 
-    if (columns != data.getColumnsListNonMaterialized() ||
-        materialized_columns != data.materialized_columns ||
-        alias_columns != data.alias_columns ||
-        column_defaults != data.column_defaults)
+    const ColumnsDescription & old_columns = getColumns();
+    if (columns_from_zk != old_columns)
     {
         if (allow_alter &&
             (skip_sanity_checks ||
-             data.getColumnsListNonMaterialized().sizeOfDifference(columns) +
-             data.materialized_columns.sizeOfDifference(materialized_columns) <= 2))
+             old_columns.ordinary.sizeOfDifference(columns_from_zk.ordinary) +
+             old_columns.materialized.sizeOfDifference(columns_from_zk.materialized) <= 2))
         {
             LOG_WARNING(log, "Table structure in ZooKeeper is a little different from local table structure. Assuming ALTER.");
 
             /// Without any locks, because table has not been created yet.
-            context.getDatabase(database_name)->alterTable(
-                context, table_name,
-                columns, materialized_columns, alias_columns, column_defaults, {});
+            context.getDatabase(database_name)->alterTable(context, table_name, columns_from_zk, {});
 
-            data.setColumnsList(columns);
-            data.materialized_columns = std::move(materialized_columns);
-            data.alias_columns = std::move(alias_columns);
-            data.column_defaults = std::move(column_defaults);
+            setColumns(std::move(columns_from_zk));
         }
         else
         {
-            throw Exception("Table structure in ZooKeeper is too much different from local table structure.",
+            throw Exception("Table structure in ZooKeeper is too different from local table structure",
                             ErrorCodes::INCOMPATIBLE_COLUMNS);
         }
     }
@@ -591,12 +573,12 @@ void StorageReplicatedMergeTree::createReplica()
     /// Create an empty replica. We'll create `columns` node at the end - we'll use it as a sign that replica creation is complete.
     auto acl = zookeeper->getDefaultACL();
     zkutil::Ops ops;
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(replica_path, "", acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(replica_path + "/host", "", acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(replica_path + "/log_pointer", "", acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(replica_path + "/queue", "", acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(replica_path + "/parts", "", acl, zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(replica_path + "/flags", "", acl, zkutil::CreateMode::Persistent));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(replica_path, "", acl, zkutil::CreateMode::Persistent));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(replica_path + "/host", "", acl, zkutil::CreateMode::Persistent));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(replica_path + "/log_pointer", "", acl, zkutil::CreateMode::Persistent));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(replica_path + "/queue", "", acl, zkutil::CreateMode::Persistent));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(replica_path + "/parts", "", acl, zkutil::CreateMode::Persistent));
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(replica_path + "/flags", "", acl, zkutil::CreateMode::Persistent));
 
     try
     {
@@ -714,12 +696,7 @@ void StorageReplicatedMergeTree::createReplica()
         LOG_DEBUG(log, "Copied " << source_queue.size() << " queue entries");
     }
 
-    zookeeper->create(replica_path + "/columns", ColumnsDescription<false>{
-            data.getColumnsListNonMaterialized(),
-            data.materialized_columns,
-            data.alias_columns,
-            data.column_defaults
-        }.toString(), zkutil::CreateMode::Persistent);
+    zookeeper->create(replica_path + "/columns", getColumns().toString(), zkutil::CreateMode::Persistent);
 }
 
 
@@ -796,7 +773,6 @@ void StorageReplicatedMergeTree::checkParts(bool skip_sanity_checks)
         unexpected_parts_rows += part->rows_count;
     }
 
-
     /// Additional helpful statistics
     auto get_blocks_count_in_data_part = [&] (const String & part_name) -> UInt64
     {
@@ -816,7 +792,6 @@ void StorageReplicatedMergeTree::checkParts(bool skip_sanity_checks)
     for (const String & name : expected_parts)
         expected_parts_blocks += get_blocks_count_in_data_part(name);
 
-
     std::stringstream sanity_report;
     sanity_report << "There are "
         << unexpected_parts.size() << " unexpected parts with " << unexpected_parts_rows << " rows ("
@@ -863,7 +838,7 @@ void StorageReplicatedMergeTree::checkParts(bool skip_sanity_checks)
         LOG_ERROR(log, "Adding unexpected local part to ZooKeeper: " << part->name);
 
         zkutil::Ops ops;
-        checkPartAndAddToZooKeeper(part, ops);
+        checkPartChecksumsAndAddCommitOps(zookeeper, part, ops);
         zookeeper->multi(ops);
     }
 
@@ -889,7 +864,7 @@ void StorageReplicatedMergeTree::checkParts(bool skip_sanity_checks)
         /// We assume that this occurs before the queue is loaded (queue.initialize).
         zkutil::Ops ops;
         removePartFromZooKeeper(name, ops);
-        ops.emplace_back(std::make_unique<zkutil::Op::Create>(
+        ops.emplace_back(std::make_shared<zkutil::Op::Create>(
             replica_path + "/queue/queue-", log_entry.toString(), zookeeper->getDefaultACL(), zkutil::CreateMode::PersistentSequential));
         zookeeper->multi(ops);
     }
@@ -903,11 +878,9 @@ void StorageReplicatedMergeTree::checkParts(bool skip_sanity_checks)
 }
 
 
-void StorageReplicatedMergeTree::checkPartAndAddToZooKeeper(
-    const MergeTreeData::DataPartPtr & part, zkutil::Ops & ops, String part_name)
+void StorageReplicatedMergeTree::checkPartChecksumsAndAddCommitOps(const zkutil::ZooKeeperPtr & zookeeper,
+    const MergeTreeData::DataPartPtr & part, zkutil::Ops & ops, String part_name, NameSet * absent_replicas_paths)
 {
-    auto zookeeper = getZooKeeper();
-
     if (part_name.empty())
         part_name = part->name;
 
@@ -917,24 +890,34 @@ void StorageReplicatedMergeTree::checkPartAndAddToZooKeeper(
     Strings replicas = zookeeper->getChildren(zookeeper_path + "/replicas");
     std::shuffle(replicas.begin(), replicas.end(), rng);
     String expected_columns_str = part->columns.toString();
+    bool has_been_alredy_added = false;
 
     for (const String & replica : replicas)
     {
         zkutil::Stat stat_before, stat_after;
+        String current_part_path = zookeeper_path + "/replicas/" + replica + "/parts/" + part_name;
+
         String columns_str;
-        if (!zookeeper->tryGet(zookeeper_path + "/replicas/" + replica + "/parts/" + part_name + "/columns", columns_str, &stat_before))
+        if (!zookeeper->tryGet(current_part_path + "/columns", columns_str, &stat_before))
+        {
+            if (absent_replicas_paths)
+                absent_replicas_paths->emplace(current_part_path);
+
             continue;
+        }
+
         if (columns_str != expected_columns_str)
         {
             LOG_INFO(log, "Not checking checksums of part " << part_name << " with replica " << replica
                 << " because columns are different");
             continue;
         }
+
         String checksums_str;
         /// Let's check that the node's version with the columns did not change while we were reading the checksums.
         /// This ensures that the columns and the checksum refer to the same data.
-        if (!zookeeper->tryGet(zookeeper_path + "/replicas/" + replica + "/parts/" + part_name + "/checksums", checksums_str) ||
-            !zookeeper->exists(zookeeper_path + "/replicas/" + replica + "/parts/" + part_name + "/columns", &stat_after) ||
+        if (!zookeeper->tryGet(current_part_path + "/checksums", checksums_str) ||
+            !zookeeper->exists(current_part_path + "/columns", &stat_after) ||
             stat_before.version != stat_after.version)
         {
             LOG_INFO(log, "Not checking checksums of part " << part_name << " with replica " << replica
@@ -942,36 +925,90 @@ void StorageReplicatedMergeTree::checkPartAndAddToZooKeeper(
             continue;
         }
 
-        auto checksums = MergeTreeData::DataPart::Checksums::parse(checksums_str);
-        checksums.checkEqual(part->checksums, true);
+        auto zk_checksums = MinimalisticDataPartChecksums::deserializeFrom(checksums_str);
+        zk_checksums.checkEqual(part->checksums, true);
+
+        if (replica == replica_name)
+            has_been_alredy_added = true;
     }
 
-    if (zookeeper->exists(replica_path + "/parts/" + part_name))
+    if (!has_been_alredy_added)
     {
-        LOG_ERROR(log, "checkPartAndAddToZooKeeper: node " << replica_path + "/parts/" + part_name << " already exists");
-        return;
+        auto acl = zookeeper->getDefaultACL();
+        String part_path = replica_path + "/parts/" + part_name;
+
+        ops.emplace_back(std::make_shared<zkutil::Op::Check>(
+            zookeeper_path + "/columns", expected_columns_version));
+        ops.emplace_back(std::make_shared<zkutil::Op::Create>(
+            part_path, "", acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(std::make_shared<zkutil::Op::Create>(
+            part_path + "/columns", part->columns.toString(), acl, zkutil::CreateMode::Persistent));
+        ops.emplace_back(std::make_shared<zkutil::Op::Create>(
+            part_path + "/checksums", getChecksumsForZooKeeper(part->checksums), acl, zkutil::CreateMode::Persistent));
     }
+    else
+    {
+        LOG_WARNING(log, "checkPartAndAddToZooKeeper: node " << replica_path + "/parts/" + part_name << " already exists."
+            << " Will not commit any nodes.");
+    }
+}
 
-    auto acl = zookeeper->getDefaultACL();
+MergeTreeData::DataPartsVector StorageReplicatedMergeTree::checkPartChecksumsAndCommit(MergeTreeData::Transaction & transaction,
+    const MergeTreeData::DataPartPtr & part)
+{
+    auto zookeeper = getZooKeeper();
 
-    ops.emplace_back(std::make_unique<zkutil::Op::Check>(
-        zookeeper_path + "/columns",
-        expected_columns_version));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(
-        replica_path + "/parts/" + part_name,
-        "",
-        acl,
-        zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(
-        replica_path + "/parts/" + part_name + "/columns",
-        part->columns.toString(),
-        acl,
-        zkutil::CreateMode::Persistent));
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(
-        replica_path + "/parts/" + part_name + "/checksums",
-        part->checksums.toString(),
-        acl,
-        zkutil::CreateMode::Persistent));
+    while (true)
+    {
+        zkutil::Ops ops;
+        NameSet absent_part_paths_on_replicas;
+
+        /// Checksums are checked here and `ops` is filled. In fact, the part is added to ZK just below, when executing `multi`.
+        checkPartChecksumsAndAddCommitOps(zookeeper, part, ops, part->name, &absent_part_paths_on_replicas);
+
+        /// Do not commit if the part is obsolete, we have just briefly checked its checksums
+        if (transaction.isEmpty())
+            return {};
+
+        /// Will check that the part did not suddenly appear on skipped replicas
+        if (!absent_part_paths_on_replicas.empty())
+        {
+            zkutil::Ops new_ops;
+            for (const String & part_path : absent_part_paths_on_replicas)
+            {
+                new_ops.emplace_back(std::make_shared<zkutil::Op::Create>(part_path, "", zookeeper->getDefaultACL(), zkutil::CreateMode::Persistent));
+                new_ops.emplace_back(std::make_shared<zkutil::Op::Remove>(part_path, -1));
+            }
+
+            /// Add check ops at the beginning
+            new_ops.insert(new_ops.end(), ops.begin(), ops.end());
+            ops = std::move(new_ops);
+        }
+
+        try
+        {
+            zookeeper->multi(ops);
+            return transaction.commit();
+        }
+        catch (zkutil::KeeperMultiException & e)
+        {
+            size_t num_check_ops = 2 * absent_part_paths_on_replicas.size();
+            size_t failed_op_index = zkutil::getFailedOpIndex(e.info.op_results, e.info.code);
+
+            if (failed_op_index < num_check_ops && e.info.code == ZNODEEXISTS)
+            {
+                LOG_INFO(log, "The part " << e.info.getFailedOp().describe() << " on a replica suddenly appeared, will recheck checksums");
+            }
+            else
+                throw;
+        }
+    }
+}
+
+String StorageReplicatedMergeTree::getChecksumsForZooKeeper(const MergeTreeDataPartChecksums & checksums)
+{
+    return MinimalisticDataPartChecksums::getSerializedString(checksums,
+                                                              static_cast<bool>(data.settings.use_minimalistic_checksums_in_zookeeper));
 }
 
 
@@ -1196,22 +1233,18 @@ void StorageReplicatedMergeTree::tryExecuteMerge(const StorageReplicatedMergeTre
         part = merger.mergePartsToTemporaryPart(
             future_merged_part, *merge_entry, aio_threshold, entry.create_time, reserved_space.get(), entry.deduplicate);
 
-        zkutil::Ops ops;
+        merger.renameMergedTemporaryPart(part, parts, &transaction);
 
         try
         {
-            /// Checksums are checked here and `ops` is filled. In fact, the part is added to ZK just below, when executing `multi`.
-            checkPartAndAddToZooKeeper(part, ops, entry.new_part_name);
+            checkPartChecksumsAndCommit(transaction, part);
         }
         catch (const Exception & e)
         {
-            if (e.code() == ErrorCodes::CHECKSUM_DOESNT_MATCH
-                || e.code() == ErrorCodes::BAD_SIZE_OF_FILE_IN_DATA_PART
-                || e.code() == ErrorCodes::NO_FILE_IN_DATA_PART
-                || e.code() == ErrorCodes::UNEXPECTED_FILE_IN_DATA_PART)
+            if (MergeTreeDataPartChecksums::isBadChecksumsErrorCode(e.code()))
             {
                 do_fetch = true;
-                part->remove();
+                transaction.rollback();
 
                 ProfileEvents::increment(ProfileEvents::DataAfterMergeDiffersFromReplica);
 
@@ -1235,15 +1268,6 @@ void StorageReplicatedMergeTree::tryExecuteMerge(const StorageReplicatedMergeTre
             throw;
         }
 
-        merger.renameMergedTemporaryPart(part, parts, &transaction);
-
-        /// Do not commit if the part is obsolete
-        if (!transaction.isEmpty())
-        {
-            getZooKeeper()->multi(ops); /// After long merge, get fresh ZK handle, because previous session may be expired.
-            transaction.commit();
-        }
-
         /** Removing old chunks from ZK and from the disk is delayed - see ReplicatedMergeTreeCleanupThread, clearOldParts.
           */
 
@@ -1330,7 +1354,7 @@ bool StorageReplicatedMergeTree::executeFetch(const StorageReplicatedMergeTree::
                     Stat stat;
                     String path = zookeeper_path + "/replicas/" + replicas[i] + "/host";
                     zookeeper->get(path, &stat);
-                    ops.emplace_back(std::make_unique<zkutil::Op::Check>(path, stat.version));
+                    ops.emplace_back(std::make_shared<zkutil::Op::Check>(path, stat.version));
                 }
 
                 /// We verify that while we were collecting versions, the replica with the necessary part did not come alive.
@@ -1349,7 +1373,7 @@ bool StorageReplicatedMergeTree::executeFetch(const StorageReplicatedMergeTree::
 
                     if (quorum_entry.part_name == entry.new_part_name)
                     {
-                        ops.emplace_back(std::make_unique<zkutil::Op::Remove>(quorum_path, quorum_stat.version));
+                        ops.emplace_back(std::make_shared<zkutil::Op::Remove>(quorum_path, quorum_stat.version));
 
                         auto part_info = MergeTreePartInfo::fromPartName(entry.new_part_name, data.format_version);
 
@@ -1361,13 +1385,13 @@ bool StorageReplicatedMergeTree::executeFetch(const StorageReplicatedMergeTree::
 
                         auto acl = zookeeper->getDefaultACL();
 
-                        ops.emplace_back(std::make_unique<zkutil::Op::Create>(
+                        ops.emplace_back(std::make_shared<zkutil::Op::Create>(
                             zookeeper_path + "/nonincrement_block_numbers/" + part_info.partition_id + "/block-" + padIndex(part_info.min_block),
                             "",
                             acl,
                             zkutil::CreateMode::Persistent));
 
-                        ops.emplace_back(std::make_unique<zkutil::Op::Create>(
+                        ops.emplace_back(std::make_shared<zkutil::Op::Create>(
                             zookeeper_path + "/quorum/failed_parts/" + entry.new_part_name,
                             "",
                             acl,
@@ -1375,7 +1399,7 @@ bool StorageReplicatedMergeTree::executeFetch(const StorageReplicatedMergeTree::
 
                         /// Deleting from `blocks`.
                         if (!entry.block_id.empty() && zookeeper->exists(zookeeper_path + "/blocks/" + entry.block_id))
-                            ops.emplace_back(std::make_unique<zkutil::Op::Remove>(zookeeper_path + "/blocks/" + entry.block_id, -1));
+                            ops.emplace_back(std::make_shared<zkutil::Op::Remove>(zookeeper_path + "/blocks/" + entry.block_id, -1));
 
                         auto code = zookeeper->tryMulti(ops);
 
@@ -1529,19 +1553,12 @@ void StorageReplicatedMergeTree::executeClearColumnInPartition(const LogEntry &
     alter_command.type = AlterCommand::DROP_COLUMN;
     alter_command.column_name = entry.column_name;
 
-    auto new_columns = data.getColumnsListNonMaterialized();
-    auto new_materialized_columns = data.materialized_columns;
-    auto new_alias_columns = data.alias_columns;
-    auto new_column_defaults = data.column_defaults;
-
-    alter_command.apply(new_columns, new_materialized_columns, new_alias_columns, new_column_defaults);
-
-    auto columns_for_parts = new_columns;
-    columns_for_parts.insert(std::end(columns_for_parts),
-        std::begin(new_materialized_columns), std::end(new_materialized_columns));
+    auto new_columns = getColumns();
+    alter_command.apply(new_columns);
 
     size_t modified_parts = 0;
     auto parts = data.getDataParts();
+    auto columns_for_parts = new_columns.getAllPhysical();
     for (const auto & part : parts)
     {
         if (!entry_part_info.contains(part->info))
@@ -1555,10 +1572,10 @@ void StorageReplicatedMergeTree::executeClearColumnInPartition(const LogEntry &
 
         /// Update part metadata in ZooKeeper.
         zkutil::Ops ops;
-        ops.emplace_back(std::make_unique<zkutil::Op::SetData>(
+        ops.emplace_back(std::make_shared<zkutil::Op::SetData>(
             replica_path + "/parts/" + part->name + "/columns", transaction->getNewColumns().toString(), -1));
-        ops.emplace_back(std::make_unique<zkutil::Op::SetData>(
-            replica_path + "/parts/" + part->name + "/checksums", transaction->getNewChecksums().toString(), -1));
+        ops.emplace_back(std::make_shared<zkutil::Op::SetData>(
+            replica_path + "/parts/" + part->name + "/checksums", getChecksumsForZooKeeper(transaction->getNewChecksums()), -1));
 
         zookeeper->multi(ops);
 
@@ -2000,9 +2017,9 @@ void StorageReplicatedMergeTree::removePartFromZooKeeper(const String & part_nam
 {
     String part_path = replica_path + "/parts/" + part_name;
 
-    ops.emplace_back(std::make_unique<zkutil::Op::Remove>(part_path + "/checksums", -1));
-    ops.emplace_back(std::make_unique<zkutil::Op::Remove>(part_path + "/columns", -1));
-    ops.emplace_back(std::make_unique<zkutil::Op::Remove>(part_path, -1));
+    ops.emplace_back(std::make_shared<zkutil::Op::Remove>(part_path + "/checksums", -1));
+    ops.emplace_back(std::make_shared<zkutil::Op::Remove>(part_path + "/columns", -1));
+    ops.emplace_back(std::make_shared<zkutil::Op::Remove>(part_path, -1));
 }
 
 
@@ -2019,7 +2036,7 @@ void StorageReplicatedMergeTree::removePartAndEnqueueFetch(const String & part_n
     log_entry->new_part_name = part_name;
 
     zkutil::Ops ops;
-    ops.emplace_back(std::make_unique<zkutil::Op::Create>(
+    ops.emplace_back(std::make_shared<zkutil::Op::Create>(
         replica_path + "/queue/queue-", log_entry->toString(), zookeeper->getDefaultACL(),
         zkutil::CreateMode::PersistentSequential));
 
@@ -2169,8 +2186,8 @@ void StorageReplicatedMergeTree::updateQuorum(const String & part_name)
             /// The quorum is reached. Delete the node, and update information about the last part that was successfully written with quorum.
 
             zkutil::Ops ops;
-            ops.emplace_back(std::make_unique<zkutil::Op::Remove>(quorum_status_path, stat.version));
-            ops.emplace_back(std::make_unique<zkutil::Op::SetData>(quorum_last_part_path, part_name, -1));
+            ops.emplace_back(std::make_shared<zkutil::Op::Remove>(quorum_status_path, stat.version));
+            ops.emplace_back(std::make_shared<zkutil::Op::SetData>(quorum_last_part_path, part_name, -1));
             auto code = zookeeper->tryMulti(ops);
 
             if (code == ZOK)
@@ -2301,24 +2318,15 @@ bool StorageReplicatedMergeTree::fetchPart(const String & part_name, const Strin
 
         if (!to_detached)
         {
-            zkutil::Ops ops;
+            MergeTreeData::Transaction transaction;
+            data.renameTempPartAndReplace(part, nullptr, &transaction);
 
             /** NOTE
               * Here, an error occurs if ALTER occurred with a change in the column type or column deletion,
               *  and the part on remote server has not yet been modified.
               * After a while, one of the following attempts to make `fetchPart` succeed.
               */
-            checkPartAndAddToZooKeeper(part, ops, part_name);
-
-            MergeTreeData::Transaction transaction;
-            data.renameTempPartAndReplace(part, nullptr, &transaction);
-
-            /// Do not commit if the part is obsolete
-            if (!transaction.isEmpty())
-            {
-                getZooKeeper()->multi(ops);
-                replaced_parts = transaction.commit();
-            }
+            replaced_parts = checkPartChecksumsAndCommit(transaction, part);
 
             /** If a quorum is tracked for this part, you must update it.
               * If you do not have time, in case of losing the session, when you restart the server - see the `ReplicatedMergeTreeRestartingThread::updateQuorumIfWeHavePart` method.
@@ -2378,6 +2386,9 @@ void StorageReplicatedMergeTree::startup()
 
     /// In this thread replica will be activated.
     restarting_thread = std::make_unique<ReplicatedMergeTreeRestartingThread>(*this);
+
+    /// Wait while restarting_thread initializes LeaderElection (and so on) or makes first attmept to do it
+    startup_event.wait();
 }
 
 
@@ -2573,15 +2584,10 @@ void StorageReplicatedMergeTree::alter(const AlterCommands & params,
             if (param.type == AlterCommand::MODIFY_PRIMARY_KEY)
                 throw Exception("Modification of primary key is not supported for replicated tables", ErrorCodes::NOT_IMPLEMENTED);
 
-        NamesAndTypesList new_columns = data.getColumnsListNonMaterialized();
-        NamesAndTypesList new_materialized_columns = data.materialized_columns;
-        NamesAndTypesList new_alias_columns = data.alias_columns;
-        ColumnDefaults new_column_defaults = data.column_defaults;
-        params.apply(new_columns, new_materialized_columns, new_alias_columns, new_column_defaults);
+        ColumnsDescription new_columns = data.getColumns();
+        params.apply(new_columns);
 
-        new_columns_str = ColumnsDescription<false>{
-            new_columns, new_materialized_columns,
-            new_alias_columns, new_column_defaults}.toString();
+        new_columns_str = new_columns.toString();
 
         /// Do ALTER.
         getZooKeeper()->set(zookeeper_path + "/columns", new_columns_str, -1, &stat);
@@ -3768,5 +3774,4 @@ void StorageReplicatedMergeTree::clearBlocksInPartition(
     LOG_TRACE(log, "Deleted " << to_delete_futures.size() << " deduplication block IDs in partition ID " << partition_id);
 }
 
-
 }
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.h b/dbms/src/Storages/StorageReplicatedMergeTree.h
index b1cbf630b1b..b16e2538fe5 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.h
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.h
@@ -84,7 +84,8 @@ public:
     bool supportsPrewhere() const override { return data.supportsPrewhere(); }
     bool supportsReplication() const override { return true; }
 
-    const NamesAndTypesList & getColumnsListImpl() const override { return data.getColumnsListNonMaterialized(); }
+    const ColumnsDescription & getColumns() const override { return data.getColumns(); }
+    void setColumns(ColumnsDescription columns_) override { return data.setColumns(std::move(columns_)); }
 
     NameAndTypePair getColumn(const String & column_name) const override
     {
@@ -240,6 +241,9 @@ private:
 
     zkutil::LeaderElectionPtr leader_election;
 
+    /// When activated, replica is initialized and startup() method could exit
+    Poco::Event startup_event;
+
     /// Do I need to complete background threads (except restarting_thread)?
     std::atomic<bool> shutdown_called {false};
     Poco::Event shutdown_event;
@@ -316,7 +320,14 @@ private:
       * Adds actions to `ops` that add data about the part into ZooKeeper.
       * Call under TableStructureLock.
       */
-    void checkPartAndAddToZooKeeper(const MergeTreeData::DataPartPtr & part, zkutil::Ops & ops, String name_override = "");
+    void checkPartChecksumsAndAddCommitOps(const zkutil::ZooKeeperPtr & zookeeper, const MergeTreeData::DataPartPtr & part,
+                                           zkutil::Ops & ops, String part_name = "", NameSet * absent_replicas_paths = nullptr);
+
+    String getChecksumsForZooKeeper(const MergeTreeDataPartChecksums & checksums);
+
+    /// Accepts a PreComitted part, atomically checks its checksums with ones on other replicas and commit the part
+    MergeTreeData::DataPartsVector checkPartChecksumsAndCommit(MergeTreeData::Transaction & transaction,
+                                                               const MergeTreeData::DataPartPtr & part);
 
     /// Adds actions to `ops` that remove a part from ZooKeeper.
     void removePartFromZooKeeper(const String & part_name, zkutil::Ops & ops);
@@ -443,10 +454,7 @@ protected:
         const String & replica_name_,
         bool attach,
         const String & path_, const String & database_name_, const String & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         Context & context_,
         const ASTPtr & primary_expr_ast_,
         const ASTPtr & secondary_sorting_expr_list_,
diff --git a/dbms/src/Storages/StorageSet.cpp b/dbms/src/Storages/StorageSet.cpp
index 1303aa6271f..5ba5d737435 100644
--- a/dbms/src/Storages/StorageSet.cpp
+++ b/dbms/src/Storages/StorageSet.cpp
@@ -88,18 +88,14 @@ BlockOutputStreamPtr StorageSetOrJoinBase::write(const ASTPtr & /*query*/, const
 
 StorageSetOrJoinBase::StorageSetOrJoinBase(
     const String & path_,
-    const String & name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
-    name(name_)
+    const String & table_name_,
+    const ColumnsDescription & columns_)
+    : IStorage{columns_}, table_name(table_name_)
 {
     if (path_.empty())
         throw Exception("Join and Set storages require data path", ErrorCodes::INCORRECT_FILE_NAME);
 
-    path = path_ + escapeForFileName(name_) + '/';
+    path = path_ + escapeForFileName(table_name_) + '/';
 }
 
 
@@ -107,11 +103,8 @@ StorageSetOrJoinBase::StorageSetOrJoinBase(
 StorageSet::StorageSet(
     const String & path_,
     const String & name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_)
-    : StorageSetOrJoinBase{path_, name_, columns_, materialized_columns_, alias_columns_, column_defaults_},
+    const ColumnsDescription & columns_)
+    : StorageSetOrJoinBase{path_, name_, columns_},
     set(std::make_shared<Set>(SizeLimits()))
 {
     restore();
@@ -181,7 +174,7 @@ void StorageSetOrJoinBase::rename(const String & new_path_to_db, const String &
     Poco::File(path).renameTo(new_path);
 
     path = new_path + "/";
-    name = new_table_name;
+    table_name = new_table_name;
 }
 
 
@@ -194,9 +187,7 @@ void registerStorageSet(StorageFactory & factory)
                 "Engine " + args.engine_name + " doesn't support any arguments (" + toString(args.engine_args.size()) + " given)",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        return StorageSet::create(
-            args.data_path, args.table_name, args.columns,
-            args.materialized_columns, args.alias_columns, args.column_defaults);
+        return StorageSet::create(args.data_path, args.table_name, args.columns);
     });
 }
 
diff --git a/dbms/src/Storages/StorageSet.h b/dbms/src/Storages/StorageSet.h
index 2546967b24a..d1e4ae89226 100644
--- a/dbms/src/Storages/StorageSet.h
+++ b/dbms/src/Storages/StorageSet.h
@@ -19,7 +19,7 @@ class StorageSetOrJoinBase : public IStorage
     friend class SetOrJoinBlockOutputStream;
 
 public:
-    String getTableName() const override { return name; }
+    String getTableName() const override { return table_name; }
 
     void rename(const String & new_path_to_db, const String & new_database_name, const String & new_table_name) override;
 
@@ -30,14 +30,11 @@ public:
 protected:
     StorageSetOrJoinBase(
         const String & path_,
-        const String & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_);
+        const String & table_name_,
+        const ColumnsDescription & columns_);
 
     String path;
-    String name;
+    String table_name;
 
     UInt64 increment = 0;    /// For the backup file names.
 
@@ -78,10 +75,7 @@ protected:
     StorageSet(
         const String & path_,
         const String & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_);
+        const ColumnsDescription & columns_);
 };
 
 }
diff --git a/dbms/src/Storages/StorageStripeLog.cpp b/dbms/src/Storages/StorageStripeLog.cpp
index 5f746dc246c..1bebca62322 100644
--- a/dbms/src/Storages/StorageStripeLog.cpp
+++ b/dbms/src/Storages/StorageStripeLog.cpp
@@ -193,13 +193,10 @@ private:
 StorageStripeLog::StorageStripeLog(
     const std::string & path_,
     const std::string & name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const ColumnsDescription & columns_,
     bool attach,
     size_t max_compress_block_size_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
+    : IStorage{columns_},
     path(path_), name(name_),
     max_compress_block_size(max_compress_block_size_),
     file_checker(path + escapeForFileName(name) + '/' + "sizes.json"),
@@ -301,7 +298,6 @@ void registerStorageStripeLog(StorageFactory & factory)
 
         return StorageStripeLog::create(
             args.data_path, args.table_name, args.columns,
-            args.materialized_columns, args.alias_columns, args.column_defaults,
             args.attach, args.context.getSettings().max_compress_block_size);
     });
 }
diff --git a/dbms/src/Storages/StorageStripeLog.h b/dbms/src/Storages/StorageStripeLog.h
index e1514f8329f..115f070f8d0 100644
--- a/dbms/src/Storages/StorageStripeLog.h
+++ b/dbms/src/Storages/StorageStripeLog.h
@@ -68,10 +68,7 @@ protected:
     StorageStripeLog(
         const std::string & path_,
         const std::string & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         bool attach,
         size_t max_compress_block_size_);
 };
diff --git a/dbms/src/Storages/StorageTinyLog.cpp b/dbms/src/Storages/StorageTinyLog.cpp
index 4ed7d6dfff2..cb62c911e63 100644
--- a/dbms/src/Storages/StorageTinyLog.cpp
+++ b/dbms/src/Storages/StorageTinyLog.cpp
@@ -276,13 +276,10 @@ void TinyLogBlockOutputStream::write(const Block & block)
 StorageTinyLog::StorageTinyLog(
     const std::string & path_,
     const std::string & name_,
-    const NamesAndTypesList & columns_,
-    const NamesAndTypesList & materialized_columns_,
-    const NamesAndTypesList & alias_columns_,
-    const ColumnDefaults & column_defaults_,
+    const ColumnsDescription & columns_,
     bool attach,
     size_t max_compress_block_size_)
-    : IStorage{columns_, materialized_columns_, alias_columns_, column_defaults_},
+    : IStorage{columns_},
     path(path_), name(name_),
     max_compress_block_size(max_compress_block_size_),
     file_checker(path + escapeForFileName(name) + '/' + "sizes.json"),
@@ -299,7 +296,7 @@ StorageTinyLog::StorageTinyLog(
             throwFromErrno("Cannot create directory " + full_path, ErrorCodes::CANNOT_CREATE_DIRECTORY);
     }
 
-    for (const auto & col : getColumnsList())
+    for (const auto & col : getColumns().getAllPhysical())
         addFiles(col.name, *col.type);
 }
 
@@ -351,7 +348,7 @@ BlockInputStreams StorageTinyLog::read(
     check(column_names);
     processed_stage = QueryProcessingStage::FetchColumns;
     return BlockInputStreams(1, std::make_shared<TinyLogBlockInputStream>(
-        max_block_size, Nested::collect(getColumnsList().addTypes(column_names)), *this, context.getSettingsRef().max_read_buffer_size));
+        max_block_size, Nested::collect(getColumns().getAllPhysical().addTypes(column_names)), *this, context.getSettingsRef().max_read_buffer_size));
 }
 
 
@@ -379,7 +376,6 @@ void registerStorageTinyLog(StorageFactory & factory)
 
         return StorageTinyLog::create(
             args.data_path, args.table_name, args.columns,
-            args.materialized_columns, args.alias_columns, args.column_defaults,
             args.attach, args.context.getSettings().max_compress_block_size);
     });
 }
diff --git a/dbms/src/Storages/StorageTinyLog.h b/dbms/src/Storages/StorageTinyLog.h
index e64301227ad..acaf7944f30 100644
--- a/dbms/src/Storages/StorageTinyLog.h
+++ b/dbms/src/Storages/StorageTinyLog.h
@@ -71,10 +71,7 @@ protected:
     StorageTinyLog(
         const std::string & path_,
         const std::string & name_,
-        const NamesAndTypesList & columns_,
-        const NamesAndTypesList & materialized_columns_,
-        const NamesAndTypesList & alias_columns_,
-        const ColumnDefaults & column_defaults_,
+        const ColumnsDescription & columns_,
         bool attach,
         size_t max_compress_block_size_);
 };
diff --git a/dbms/src/Storages/StorageView.cpp b/dbms/src/Storages/StorageView.cpp
index 76cd481a855..06809ffb4e3 100644
--- a/dbms/src/Storages/StorageView.cpp
+++ b/dbms/src/Storages/StorageView.cpp
@@ -19,8 +19,8 @@ namespace ErrorCodes
 StorageView::StorageView(
     const String & table_name_,
     const ASTCreateQuery & query,
-    const NamesAndTypesList & columns_)
-    : IStorage{columns_, {}, {}, {}}, table_name(table_name_)
+    const ColumnsDescription & columns_)
+    : IStorage{columns_}, table_name(table_name_)
 {
     if (!query.select)
         throw Exception("SELECT query is not specified for " + getName(), ErrorCodes::INCORRECT_QUERY);
diff --git a/dbms/src/Storages/StorageView.h b/dbms/src/Storages/StorageView.h
index 6a16e0d16e6..20a8f76189c 100644
--- a/dbms/src/Storages/StorageView.h
+++ b/dbms/src/Storages/StorageView.h
@@ -42,7 +42,7 @@ protected:
     StorageView(
         const String & table_name_,
         const ASTCreateQuery & query,
-        const NamesAndTypesList & columns_);
+        const ColumnsDescription & columns_);
 };
 
 }
diff --git a/dbms/src/Storages/System/StorageSystemAsynchronousMetrics.cpp b/dbms/src/Storages/System/StorageSystemAsynchronousMetrics.cpp
index 44f8d933c99..bc2f76379e9 100644
--- a/dbms/src/Storages/System/StorageSystemAsynchronousMetrics.cpp
+++ b/dbms/src/Storages/System/StorageSystemAsynchronousMetrics.cpp
@@ -16,10 +16,10 @@ StorageSystemAsynchronousMetrics::StorageSystemAsynchronousMetrics(const std::st
     : name(name_),
     async_metrics(async_metrics_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         {"metric", std::make_shared<DataTypeString>()},
         {"value", std::make_shared<DataTypeFloat64>()},
-    };
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemBuildOptions.cpp b/dbms/src/Storages/System/StorageSystemBuildOptions.cpp
index c8da9f12c40..e62e6e9bbfd 100644
--- a/dbms/src/Storages/System/StorageSystemBuildOptions.cpp
+++ b/dbms/src/Storages/System/StorageSystemBuildOptions.cpp
@@ -13,10 +13,10 @@ namespace DB
 StorageSystemBuildOptions::StorageSystemBuildOptions(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "name", std::make_shared<DataTypeString>() },
         { "value", std::make_shared<DataTypeString>() },
-    };
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemClusters.cpp b/dbms/src/Storages/System/StorageSystemClusters.cpp
index 084f295de74..904d22d180e 100644
--- a/dbms/src/Storages/System/StorageSystemClusters.cpp
+++ b/dbms/src/Storages/System/StorageSystemClusters.cpp
@@ -14,7 +14,7 @@ namespace DB
 StorageSystemClusters::StorageSystemClusters(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "cluster",      std::make_shared<DataTypeString>() },
         { "shard_num",    std::make_shared<DataTypeUInt32>() },
         { "shard_weight", std::make_shared<DataTypeUInt32>() },
@@ -24,8 +24,8 @@ StorageSystemClusters::StorageSystemClusters(const std::string & name_)
         { "port",         std::make_shared<DataTypeUInt16>() },
         { "is_local",     std::make_shared<DataTypeUInt8>() },
         { "user",         std::make_shared<DataTypeString>() },
-        { "default_database", std::make_shared<DataTypeString>() }
-    };
+        { "default_database", std::make_shared<DataTypeString>() },
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemColumns.cpp b/dbms/src/Storages/System/StorageSystemColumns.cpp
index 5f9116b08a5..18598b1c1dc 100644
--- a/dbms/src/Storages/System/StorageSystemColumns.cpp
+++ b/dbms/src/Storages/System/StorageSystemColumns.cpp
@@ -18,7 +18,7 @@ namespace DB
 StorageSystemColumns::StorageSystemColumns(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "database",           std::make_shared<DataTypeString>() },
         { "table",              std::make_shared<DataTypeString>() },
         { "name",               std::make_shared<DataTypeString>() },
@@ -28,7 +28,7 @@ StorageSystemColumns::StorageSystemColumns(const std::string & name_)
         { "data_compressed_bytes",      std::make_shared<DataTypeUInt64>() },
         { "data_uncompressed_bytes",    std::make_shared<DataTypeUInt64>() },
         { "marks_bytes",                std::make_shared<DataTypeUInt64>() },
-    };
+    }));
 }
 
 
@@ -137,9 +137,8 @@ BlockInputStreams StorageSystemColumns::read(
                     throw;
             }
 
-            columns = storage->getColumnsList();
-            columns.insert(std::end(columns), std::begin(storage->alias_columns), std::end(storage->alias_columns));
-            column_defaults = storage->column_defaults;
+            columns = storage->getColumns().getAll();
+            column_defaults = storage->getColumns().defaults;
 
             /** Info about sizes of columns for tables of MergeTree family.
               * NOTE: It is possible to add getter for this info to IStorage interface.
@@ -172,7 +171,7 @@ BlockInputStreams StorageSystemColumns::read(
                 }
                 else
                 {
-                    res_columns[i++]->insert(toString(it->second.type));
+                    res_columns[i++]->insert(toString(it->second.kind));
                     res_columns[i++]->insert(queryToString(it->second.expression));
                 }
             }
diff --git a/dbms/src/Storages/System/StorageSystemDatabases.cpp b/dbms/src/Storages/System/StorageSystemDatabases.cpp
index 93917b81000..49c78688616 100644
--- a/dbms/src/Storages/System/StorageSystemDatabases.cpp
+++ b/dbms/src/Storages/System/StorageSystemDatabases.cpp
@@ -13,12 +13,12 @@ namespace DB
 StorageSystemDatabases::StorageSystemDatabases(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         {"name", std::make_shared<DataTypeString>()},
         {"engine", std::make_shared<DataTypeString>()},
         {"data_path", std::make_shared<DataTypeString>()},
         {"metadata_path", std::make_shared<DataTypeString>()},
-    };
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemDictionaries.cpp b/dbms/src/Storages/System/StorageSystemDictionaries.cpp
index 93c742ef1a7..c57c1c7f459 100644
--- a/dbms/src/Storages/System/StorageSystemDictionaries.cpp
+++ b/dbms/src/Storages/System/StorageSystemDictionaries.cpp
@@ -21,7 +21,7 @@ namespace DB
 StorageSystemDictionaries::StorageSystemDictionaries(const std::string & name)
     : name{name}
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "name", std::make_shared<DataTypeString>() },
         { "origin", std::make_shared<DataTypeString>() },
         { "type", std::make_shared<DataTypeString>() },
@@ -35,8 +35,8 @@ StorageSystemDictionaries::StorageSystemDictionaries(const std::string & name)
         { "load_factor", std::make_shared<DataTypeFloat64>() },
         { "creation_time", std::make_shared<DataTypeDateTime>() },
         { "source", std::make_shared<DataTypeString>() },
-        { "last_exception", std::make_shared<DataTypeString>() }
-    };
+        { "last_exception", std::make_shared<DataTypeString>() },
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemEvents.cpp b/dbms/src/Storages/System/StorageSystemEvents.cpp
index 96a02d72332..1dc49ad37b2 100644
--- a/dbms/src/Storages/System/StorageSystemEvents.cpp
+++ b/dbms/src/Storages/System/StorageSystemEvents.cpp
@@ -13,11 +13,11 @@ namespace DB
 StorageSystemEvents::StorageSystemEvents(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList
+    setColumns(ColumnsDescription(
     {
         {"event", std::make_shared<DataTypeString>()},
-        {"value", std::make_shared<DataTypeUInt64>()}
-    };
+        {"value", std::make_shared<DataTypeUInt64>()},
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemFunctions.cpp b/dbms/src/Storages/System/StorageSystemFunctions.cpp
index 74e58338d40..909bf1d8089 100644
--- a/dbms/src/Storages/System/StorageSystemFunctions.cpp
+++ b/dbms/src/Storages/System/StorageSystemFunctions.cpp
@@ -16,10 +16,10 @@ namespace DB
 StorageSystemFunctions::StorageSystemFunctions(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "name",         std::make_shared<DataTypeString>() },
-        { "is_aggregate", std::make_shared<DataTypeUInt8>()  }
-    };
+        { "is_aggregate", std::make_shared<DataTypeUInt8>()  },
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemGraphite.cpp b/dbms/src/Storages/System/StorageSystemGraphite.cpp
index 76f3defe885..f558adc1d95 100644
--- a/dbms/src/Storages/System/StorageSystemGraphite.cpp
+++ b/dbms/src/Storages/System/StorageSystemGraphite.cpp
@@ -125,15 +125,15 @@ static Strings getAllGraphiteSections(const AbstractConfiguration & config)
 StorageSystemGraphite::StorageSystemGraphite(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         {"config_name", std::make_shared<DataTypeString>()},
         {"regexp",      std::make_shared<DataTypeString>()},
         {"function",    std::make_shared<DataTypeString>()},
         {"age",         std::make_shared<DataTypeUInt64>()},
         {"precision",   std::make_shared<DataTypeUInt64>()},
         {"priority",    std::make_shared<DataTypeUInt16>()},
-        {"is_default",  std::make_shared<DataTypeUInt8>()}
-    };
+        {"is_default",  std::make_shared<DataTypeUInt8>()},
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemMacros.cpp b/dbms/src/Storages/System/StorageSystemMacros.cpp
new file mode 100644
index 00000000000..456730bde4b
--- /dev/null
+++ b/dbms/src/Storages/System/StorageSystemMacros.cpp
@@ -0,0 +1,48 @@
+#include <Common/Macros.h>
+#include <Columns/ColumnString.h>
+#include <DataTypes/DataTypeString.h>
+#include <DataStreams/OneBlockInputStream.h>
+#include <Storages/System/StorageSystemMacros.h>
+#include <Interpreters/Context.h>
+
+
+namespace DB
+{
+
+
+StorageSystemMacros::StorageSystemMacros(const std::string & name_)
+        : name(name_)
+{
+    setColumns(ColumnsDescription({
+            {"macro", std::make_shared<DataTypeString>()},
+            {"substitution", std::make_shared<DataTypeString>()},
+    }));
+}
+
+
+BlockInputStreams StorageSystemMacros::read(
+        const Names & column_names,
+        const SelectQueryInfo &,
+        const Context & context,
+        QueryProcessingStage::Enum & processed_stage,
+        const size_t /*max_block_size*/,
+        const unsigned /*num_streams*/)
+{
+    check(column_names);
+    processed_stage = QueryProcessingStage::FetchColumns;
+
+    MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
+
+    auto macros = context.getMacros();
+
+    for (const auto & macro : macros->getMacroMap())
+    {
+        res_columns[0]->insert(macro.first);
+        res_columns[1]->insert(macro.second);
+    }
+
+    return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
+}
+
+
+}
diff --git a/dbms/src/Storages/System/StorageSystemMacros.h b/dbms/src/Storages/System/StorageSystemMacros.h
new file mode 100644
index 00000000000..d4bb5ab3732
--- /dev/null
+++ b/dbms/src/Storages/System/StorageSystemMacros.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <ext/shared_ptr_helper.h>
+#include <Storages/IStorage.h>
+
+
+namespace DB
+{
+
+class Context;
+
+
+/** Information about macros for introspection.
+  */
+class StorageSystemMacros : public ext::shared_ptr_helper<StorageSystemMacros>, public IStorage
+{
+public:
+    std::string getName() const override { return "SystemMacros"; }
+    std::string getTableName() const override { return name; }
+
+    BlockInputStreams read(
+            const Names & column_names,
+            const SelectQueryInfo & query_info,
+            const Context & context,
+            QueryProcessingStage::Enum & processed_stage,
+            size_t max_block_size,
+            unsigned num_streams) override;
+
+private:
+    const std::string name;
+
+protected:
+    StorageSystemMacros(const std::string & name_);
+};
+
+}
diff --git a/dbms/src/Storages/System/StorageSystemMerges.cpp b/dbms/src/Storages/System/StorageSystemMerges.cpp
index f6667c19908..d3af993e29e 100644
--- a/dbms/src/Storages/System/StorageSystemMerges.cpp
+++ b/dbms/src/Storages/System/StorageSystemMerges.cpp
@@ -14,7 +14,7 @@ namespace DB
 StorageSystemMerges::StorageSystemMerges(const std::string & name)
     : name{name}
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "database",                    std::make_shared<DataTypeString>() },
         { "table",                       std::make_shared<DataTypeString>() },
         { "elapsed",                     std::make_shared<DataTypeFloat64>() },
@@ -31,7 +31,7 @@ StorageSystemMerges::StorageSystemMerges(const std::string & name)
         { "columns_written",             std::make_shared<DataTypeUInt64>() },
         { "memory_usage",                std::make_shared<DataTypeUInt64>() },
         { "thread_number",               std::make_shared<DataTypeUInt64>() },
-    };
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemMetrics.cpp b/dbms/src/Storages/System/StorageSystemMetrics.cpp
index c60d7f4b4f5..9d3b1cc9fbc 100644
--- a/dbms/src/Storages/System/StorageSystemMetrics.cpp
+++ b/dbms/src/Storages/System/StorageSystemMetrics.cpp
@@ -14,10 +14,10 @@ namespace DB
 StorageSystemMetrics::StorageSystemMetrics(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         {"metric", std::make_shared<DataTypeString>()},
         {"value",  std::make_shared<DataTypeInt64>()},
-    };
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemModels.cpp b/dbms/src/Storages/System/StorageSystemModels.cpp
index da0249b1705..5175989b861 100644
--- a/dbms/src/Storages/System/StorageSystemModels.cpp
+++ b/dbms/src/Storages/System/StorageSystemModels.cpp
@@ -14,13 +14,13 @@ namespace DB
 StorageSystemModels::StorageSystemModels(const std::string & name)
     : name{name}
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "name", std::make_shared<DataTypeString>() },
         { "origin", std::make_shared<DataTypeString>() },
         { "type", std::make_shared<DataTypeString>() },
         { "creation_time", std::make_shared<DataTypeDateTime>() },
-        { "last_exception", std::make_shared<DataTypeString>() }
-    };
+        { "last_exception", std::make_shared<DataTypeString>() },
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemNumbers.cpp b/dbms/src/Storages/System/StorageSystemNumbers.cpp
index 30586bbbba3..49a3c7ca513 100644
--- a/dbms/src/Storages/System/StorageSystemNumbers.cpp
+++ b/dbms/src/Storages/System/StorageSystemNumbers.cpp
@@ -47,7 +47,7 @@ private:
 StorageSystemNumbers::StorageSystemNumbers(const std::string & name_, bool multithreaded_, size_t limit_)
     : name(name_), multithreaded(multithreaded_), limit(limit_)
 {
-    columns = NamesAndTypesList{{"number", std::make_shared<DataTypeUInt64>()}};
+    setColumns(ColumnsDescription({{"number", std::make_shared<DataTypeUInt64>()}}));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemOne.cpp b/dbms/src/Storages/System/StorageSystemOne.cpp
index 4ddc64031e3..7714a0ea53c 100644
--- a/dbms/src/Storages/System/StorageSystemOne.cpp
+++ b/dbms/src/Storages/System/StorageSystemOne.cpp
@@ -13,7 +13,7 @@ namespace DB
 StorageSystemOne::StorageSystemOne(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{{"dummy", std::make_shared<DataTypeUInt8>()}};
+    setColumns(ColumnsDescription({{"dummy", std::make_shared<DataTypeUInt8>()}}));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemParts.cpp b/dbms/src/Storages/System/StorageSystemParts.cpp
index 0914cae72da..a07e8bc26dd 100644
--- a/dbms/src/Storages/System/StorageSystemParts.cpp
+++ b/dbms/src/Storages/System/StorageSystemParts.cpp
@@ -66,7 +66,9 @@ void StorageSystemParts::processNextStorage(MutableColumns & columns, const Stor
         columns[i++]->insert(static_cast<UInt64>(part->rows_count));
         columns[i++]->insert(static_cast<UInt64>(part->size_in_bytes));
         columns[i++]->insert(static_cast<UInt64>(part->modification_time));
-        columns[i++]->insert(static_cast<UInt64>(part->remove_time.load(std::memory_order_relaxed)));
+
+        time_t remove_time = part->remove_time.load(std::memory_order_relaxed);
+        columns[i++]->insert(static_cast<UInt64>(remove_time == std::numeric_limits<time_t>::max() ? 0 : remove_time));
 
         /// For convenience, in returned refcount, don't add references that was due to local variables in this method: all_parts, active_parts.
         columns[i++]->insert(static_cast<UInt64>(part.use_count() - 1));
diff --git a/dbms/src/Storages/System/StorageSystemPartsBase.cpp b/dbms/src/Storages/System/StorageSystemPartsBase.cpp
index f1f99c312f4..9d94655fc18 100644
--- a/dbms/src/Storages/System/StorageSystemPartsBase.cpp
+++ b/dbms/src/Storages/System/StorageSystemPartsBase.cpp
@@ -245,20 +245,20 @@ BlockInputStreams StorageSystemPartsBase::read(
 
     /// Create the result.
 
-    MutableColumns columns = getSampleBlock().cloneEmptyColumns();
+    MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
     if (has_state_column)
-        columns.push_back(ColumnString::create());
+        res_columns.push_back(ColumnString::create());
 
     while (StoragesInfo info = stream.next())
     {
-        processNextStorage(columns, info, has_state_column);
+        processNextStorage(res_columns, info, has_state_column);
     }
 
     Block block = getSampleBlock();
     if (has_state_column)
         block.insert(ColumnWithTypeAndName(std::make_shared<DataTypeString>(), "_state"));
 
-    return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(block.cloneWithColumns(std::move(columns))));
+    return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(block.cloneWithColumns(std::move(res_columns))));
 }
 
 NameAndTypePair StorageSystemPartsBase::getColumn(const String & column_name) const
@@ -280,7 +280,7 @@ bool StorageSystemPartsBase::hasColumn(const String & column_name) const
 StorageSystemPartsBase::StorageSystemPartsBase(std::string name_, NamesAndTypesList && columns_)
     : name(std::move(name_))
 {
-    columns = columns_;
+    setColumns(ColumnsDescription(std::move(columns_)));
 }
 
 }
diff --git a/dbms/src/Storages/System/StorageSystemPartsColumns.cpp b/dbms/src/Storages/System/StorageSystemPartsColumns.cpp
index 9667399c534..8e55625c5cd 100644
--- a/dbms/src/Storages/System/StorageSystemPartsColumns.cpp
+++ b/dbms/src/Storages/System/StorageSystemPartsColumns.cpp
@@ -61,9 +61,8 @@ void StorageSystemPartsColumns::processNextStorage(MutableColumns & columns, con
         String default_expression;
     };
 
-    NamesAndTypesList columns_list = info.storage->getColumnsList();
-    columns_list.insert(std::end(columns_list), std::begin(info.storage->alias_columns), std::end(info.storage->alias_columns));
-    const auto & column_defaults = info.storage->column_defaults;
+    NamesAndTypesList columns_list = info.storage->getColumns().getAll();
+    const auto & column_defaults = info.storage->getColumns().defaults;
     std::unordered_map<String, ColumnInfo> columns_info;
 
     for (const auto & column : columns_list)
@@ -73,7 +72,7 @@ void StorageSystemPartsColumns::processNextStorage(MutableColumns & columns, con
         const auto it = column_defaults.find(column.name);
         if (it != std::end(column_defaults))
         {
-            column_info.default_kind = toString(it->second.type);
+            column_info.default_kind = toString(it->second.kind);
             column_info.default_expression = queryToString(it->second.expression);
         }
 
diff --git a/dbms/src/Storages/System/StorageSystemProcesses.cpp b/dbms/src/Storages/System/StorageSystemProcesses.cpp
index 55f3bb120db..793e3124a2a 100644
--- a/dbms/src/Storages/System/StorageSystemProcesses.cpp
+++ b/dbms/src/Storages/System/StorageSystemProcesses.cpp
@@ -14,7 +14,7 @@ namespace DB
 StorageSystemProcesses::StorageSystemProcesses(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "is_initial_query",     std::make_shared<DataTypeUInt8>() },
 
         { "user",                 std::make_shared<DataTypeString>() },
@@ -50,8 +50,8 @@ StorageSystemProcesses::StorageSystemProcesses(const std::string & name_)
         { "written_bytes",        std::make_shared<DataTypeUInt64>() },
         { "memory_usage",         std::make_shared<DataTypeInt64>() },
         { "peak_memory_usage",    std::make_shared<DataTypeInt64>() },
-        { "query",                std::make_shared<DataTypeString>() }
-    };
+        { "query",                std::make_shared<DataTypeString>() },
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemReplicas.cpp b/dbms/src/Storages/System/StorageSystemReplicas.cpp
index 6dc11214b7c..ea2c8b1cde2 100644
--- a/dbms/src/Storages/System/StorageSystemReplicas.cpp
+++ b/dbms/src/Storages/System/StorageSystemReplicas.cpp
@@ -17,7 +17,7 @@ namespace DB
 StorageSystemReplicas::StorageSystemReplicas(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "database",                             std::make_shared<DataTypeString>()   },
         { "table",                                std::make_shared<DataTypeString>()   },
         { "engine",                               std::make_shared<DataTypeString>()   },
@@ -44,7 +44,7 @@ StorageSystemReplicas::StorageSystemReplicas(const std::string & name_)
         { "absolute_delay",                       std::make_shared<DataTypeUInt64>()   },
         { "total_replicas",                       std::make_shared<DataTypeUInt8>()    },
         { "active_replicas",                      std::make_shared<DataTypeUInt8>()    },
-    };
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp b/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp
index a2432525044..77b265ad065 100644
--- a/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp
+++ b/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp
@@ -20,7 +20,7 @@ namespace DB
 StorageSystemReplicationQueue::StorageSystemReplicationQueue(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         /// Table properties.
         { "database",                std::make_shared<DataTypeString>() },
         { "table",                   std::make_shared<DataTypeString>() },
@@ -43,7 +43,7 @@ StorageSystemReplicationQueue::StorageSystemReplicationQueue(const std::string &
         { "num_postponed",           std::make_shared<DataTypeUInt32>() },
         { "postpone_reason",         std::make_shared<DataTypeString>() },
         { "last_postpone_time",      std::make_shared<DataTypeDateTime>() },
-    };
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemSettings.cpp b/dbms/src/Storages/System/StorageSystemSettings.cpp
index 6099883eeb6..efb50c559cc 100644
--- a/dbms/src/Storages/System/StorageSystemSettings.cpp
+++ b/dbms/src/Storages/System/StorageSystemSettings.cpp
@@ -14,12 +14,12 @@ namespace DB
 StorageSystemSettings::StorageSystemSettings(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "name",        std::make_shared<DataTypeString>() },
         { "value",       std::make_shared<DataTypeString>() },
         { "changed",     std::make_shared<DataTypeUInt8>() },
-        { "description", std::make_shared<DataTypeString>() }
-    };
+        { "description", std::make_shared<DataTypeString>() },
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/StorageSystemTables.cpp b/dbms/src/Storages/System/StorageSystemTables.cpp
index 852392a63d1..99ed89739f9 100644
--- a/dbms/src/Storages/System/StorageSystemTables.cpp
+++ b/dbms/src/Storages/System/StorageSystemTables.cpp
@@ -114,7 +114,7 @@ protected:
 StorageSystemTables::StorageSystemTables(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList
+    setColumns(ColumnsDescription(
     {
         {"database", std::make_shared<DataTypeString>()},
         {"name", std::make_shared<DataTypeString>()},
@@ -122,7 +122,7 @@ StorageSystemTables::StorageSystemTables(const std::string & name_)
         {"is_temporary", std::make_shared<DataTypeUInt8>()},
         {"data_path", std::make_shared<DataTypeString>()},
         {"metadata_path", std::make_shared<DataTypeString>()},
-    };
+    }));
 
     virtual_columns =
     {
diff --git a/dbms/src/Storages/System/StorageSystemZooKeeper.cpp b/dbms/src/Storages/System/StorageSystemZooKeeper.cpp
index 80ca3bc2f0e..67660ea3446 100644
--- a/dbms/src/Storages/System/StorageSystemZooKeeper.cpp
+++ b/dbms/src/Storages/System/StorageSystemZooKeeper.cpp
@@ -22,7 +22,7 @@ namespace DB
 StorageSystemZooKeeper::StorageSystemZooKeeper(const std::string & name_)
     : name(name_)
 {
-    columns = NamesAndTypesList{
+    setColumns(ColumnsDescription({
         { "name",           std::make_shared<DataTypeString>() },
         { "value",          std::make_shared<DataTypeString>() },
         { "czxid",          std::make_shared<DataTypeInt64>() },
@@ -37,7 +37,7 @@ StorageSystemZooKeeper::StorageSystemZooKeeper(const std::string & name_)
         { "numChildren",    std::make_shared<DataTypeInt32>() },
         { "pzxid",          std::make_shared<DataTypeInt64>() },
         { "path",           std::make_shared<DataTypeString>() },
-    };
+    }));
 }
 
 
diff --git a/dbms/src/Storages/System/attachSystemTables.cpp b/dbms/src/Storages/System/attachSystemTables.cpp
index cc49f047d9d..93d4809b3c7 100644
--- a/dbms/src/Storages/System/attachSystemTables.cpp
+++ b/dbms/src/Storages/System/attachSystemTables.cpp
@@ -10,6 +10,7 @@
 #include <Storages/System/StorageSystemEvents.h>
 #include <Storages/System/StorageSystemFunctions.h>
 #include <Storages/System/StorageSystemGraphite.h>
+#include <Storages/System/StorageSystemMacros.h>
 #include <Storages/System/StorageSystemMerges.h>
 #include <Storages/System/StorageSystemMetrics.h>
 #include <Storages/System/StorageSystemModels.h>
@@ -56,6 +57,7 @@ void attachSystemTablesServer(IDatabase & system_database, bool has_zookeeper)
     system_database.attachTable("models", StorageSystemModels::create("models"));
     system_database.attachTable("clusters", StorageSystemClusters::create("clusters"));
     system_database.attachTable("graphite_retentions", StorageSystemGraphite::create("graphite_retentions"));
+    system_database.attachTable("macros", StorageSystemMacros::create("macros"));
 
     if (has_zookeeper)
         system_database.attachTable("zookeeper", StorageSystemZooKeeper::create("zookeeper"));
diff --git a/dbms/src/Storages/tests/hit_log.cpp b/dbms/src/Storages/tests/hit_log.cpp
index 3dd75206a2b..305974b22d9 100644
--- a/dbms/src/Storages/tests/hit_log.cpp
+++ b/dbms/src/Storages/tests/hit_log.cpp
@@ -98,8 +98,8 @@ try
 
     /// create a hit log table
 
-    StoragePtr table = StorageLog::create("./", "HitLog", names_and_types_list,
-        NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
+    StoragePtr table = StorageLog::create(
+        "./", "HitLog", ColumnsDescription{names_and_types_list}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
     table->startup();
 
     /// create a description of how to read data from the tab separated dump
diff --git a/dbms/src/Storages/tests/remove_symlink_directory.cpp b/dbms/src/Storages/tests/remove_symlink_directory.cpp
index 16b2a1b4750..59011c557ee 100644
--- a/dbms/src/Storages/tests/remove_symlink_directory.cpp
+++ b/dbms/src/Storages/tests/remove_symlink_directory.cpp
@@ -1,6 +1,5 @@
-#include <unistd.h>
+#include <port/unistd.h>
 #include <iostream>
-
 #include <Poco/File.h>
 #include <Poco/Path.h>
 #include <Common/Exception.h>
diff --git a/dbms/src/Storages/tests/storage_log.cpp b/dbms/src/Storages/tests/storage_log.cpp
index 6d9cb5d0def..edad84b5b8c 100644
--- a/dbms/src/Storages/tests/storage_log.cpp
+++ b/dbms/src/Storages/tests/storage_log.cpp
@@ -25,8 +25,8 @@ try
     names_and_types.emplace_back("a", std::make_shared<DataTypeUInt64>());
     names_and_types.emplace_back("b", std::make_shared<DataTypeUInt8>());
 
-    StoragePtr table = StorageLog::create("./", "test", names_and_types,
-        NamesAndTypesList{}, NamesAndTypesList{}, ColumnDefaults{}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
+    StoragePtr table = StorageLog::create(
+        "./", "test", ColumnsDescription{names_and_types}, DEFAULT_MAX_COMPRESS_BLOCK_SIZE);
     table->startup();
 
     /// write into it
@@ -36,7 +36,7 @@ try
         {
             ColumnWithTypeAndName column;
             column.name = "a";
-            column.type = table->getDataTypeByName("a");
+            column.type = table->getColumn("a").type;
             auto col = column.type->createColumn();
             ColumnUInt64::Container & vec = typeid_cast<ColumnUInt64 &>(*col).getData();
 
@@ -51,7 +51,7 @@ try
         {
             ColumnWithTypeAndName column;
             column.name = "b";
-            column.type = table->getDataTypeByName("b");
+            column.type = table->getColumn("b").type;
             auto col = column.type->createColumn();
             ColumnUInt8::Container & vec = typeid_cast<ColumnUInt8 &>(*col).getData();
 
diff --git a/dbms/src/TableFunctions/TableFunctionMerge.cpp b/dbms/src/TableFunctions/TableFunctionMerge.cpp
index d37d2002d5a..45aa42fea32 100644
--- a/dbms/src/TableFunctions/TableFunctionMerge.cpp
+++ b/dbms/src/TableFunctions/TableFunctionMerge.cpp
@@ -51,7 +51,7 @@ static NamesAndTypesList chooseColumns(const String & source_database, const Str
         throw Exception("Error while executing table function merge. In database " + source_database + " no one matches regular expression: "
             + table_name_regexp_, ErrorCodes::UNKNOWN_TABLE);
 
-    return any_table->getColumnsList();
+    return any_table->getColumns().getAllPhysical();
 }
 
 
@@ -79,10 +79,7 @@ StoragePtr TableFunctionMerge::executeImpl(const ASTPtr & ast_function, const Co
 
     auto res = StorageMerge::create(
         getName(),
-        chooseColumns(source_database, table_name_regexp, context),
-        NamesAndTypesList{},
-        NamesAndTypesList{},
-        ColumnDefaults{},
+        ColumnsDescription{chooseColumns(source_database, table_name_regexp, context)},
         source_database,
         table_name_regexp,
         context);
diff --git a/dbms/src/TableFunctions/TableFunctionMySQL.cpp b/dbms/src/TableFunctions/TableFunctionMySQL.cpp
index f1b4e911385..1f7839ada86 100644
--- a/dbms/src/TableFunctions/TableFunctionMySQL.cpp
+++ b/dbms/src/TableFunctions/TableFunctionMySQL.cpp
@@ -152,7 +152,7 @@ StoragePtr TableFunctionMySQL::executeImpl(const ASTPtr & ast_function, const Co
         std::move(pool),
         database_name,
         table_name,
-        columns);
+        ColumnsDescription{columns});
 
     res->startup();
     return res;
diff --git a/dbms/src/TableFunctions/TableFunctionODBC.cpp b/dbms/src/TableFunctions/TableFunctionODBC.cpp
index cc4c430ae8f..b75e48de054 100644
--- a/dbms/src/TableFunctions/TableFunctionODBC.cpp
+++ b/dbms/src/TableFunctions/TableFunctionODBC.cpp
@@ -113,7 +113,7 @@ StoragePtr TableFunctionODBC::executeImpl(const ASTPtr & ast_function, const Con
         columns.emplace_back(reinterpret_cast<char *>(column_name), getDataType(type));
     }
 
-    auto result = StorageODBC::create(table_name, connection_string, "", table_name, columns);
+    auto result = StorageODBC::create(table_name, connection_string, "", table_name, ColumnsDescription{columns});
     result->startup();
     return result;
 }
diff --git a/dbms/src/TableFunctions/getStructureOfRemoteTable.cpp b/dbms/src/TableFunctions/getStructureOfRemoteTable.cpp
index 3cb68d25416..56bb257f252 100644
--- a/dbms/src/TableFunctions/getStructureOfRemoteTable.cpp
+++ b/dbms/src/TableFunctions/getStructureOfRemoteTable.cpp
@@ -1,12 +1,12 @@
+#include <TableFunctions/getStructureOfRemoteTable.h>
 #include <Interpreters/Cluster.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/InterpreterDescribeQuery.h>
 #include <DataStreams/RemoteBlockInputStream.h>
 #include <DataTypes/DataTypeFactory.h>
 #include <Storages/IStorage.h>
-#include <Parsers/IAST.h>
-
-#include <TableFunctions/getStructureOfRemoteTable.h>
+#include <Parsers/ExpressionListParsers.h>
+#include <Parsers/parseQuery.h>
 
 
 namespace DB
@@ -18,21 +18,21 @@ namespace ErrorCodes
 }
 
 
-NamesAndTypesList getStructureOfRemoteTable(
+ColumnsDescription getStructureOfRemoteTable(
     const Cluster & cluster,
     const std::string & database,
     const std::string & table,
     const Context & context)
 {
-    /// Request for a table description
-    String query = "DESC TABLE " + backQuoteIfNeed(database) + "." + backQuoteIfNeed(table);
-    NamesAndTypesList res;
-
     /// Send to the first any remote shard.
     const auto & shard_info = cluster.getAnyShardInfo();
 
     if (shard_info.isLocal())
-        return context.getTable(database, table)->getColumnsList();
+        return context.getTable(database, table)->getColumns();
+
+    /// Request for a table description
+    String query = "DESC TABLE " + backQuoteIfNeed(database) + "." + backQuoteIfNeed(table);
+    ColumnsDescription res;
 
     auto input = std::make_shared<RemoteBlockInputStream>(shard_info.pool, query, InterpreterDescribeQuery::getSampleBlock(), context);
     input->setPoolMode(PoolMode::GET_ONE);
@@ -41,18 +41,41 @@ NamesAndTypesList getStructureOfRemoteTable(
 
     const DataTypeFactory & data_type_factory = DataTypeFactory::instance();
 
+    ParserExpression expr_parser;
+
     while (Block current = input->read())
     {
         ColumnPtr name = current.getByName("name").column;
         ColumnPtr type = current.getByName("type").column;
+        ColumnPtr default_kind = current.getByName("default_type").column;
+        ColumnPtr default_expr = current.getByName("default_expression").column;
         size_t size = name->size();
 
         for (size_t i = 0; i < size; ++i)
         {
             String column_name = (*name)[i].get<const String &>();
             String data_type_name = (*type)[i].get<const String &>();
+            String kind_name = (*default_kind)[i].get<const String &>();
 
-            res.emplace_back(column_name, data_type_factory.get(data_type_name));
+            auto data_type = data_type_factory.get(data_type_name);
+
+            if (kind_name.empty())
+                res.ordinary.emplace_back(column_name, std::move(data_type));
+            else
+            {
+                auto kind = columnDefaultKindFromString(kind_name);
+
+                String expr_str = (*default_expr)[i].get<const String &>();
+                ASTPtr expr = parseQuery(expr_parser, expr_str.data(), expr_str.data() + expr_str.size(), "default expression");
+                res.defaults.emplace(column_name, ColumnDefault{kind, expr});
+
+                if (ColumnDefaultKind::Default == kind)
+                    res.ordinary.emplace_back(column_name, std::move(data_type));
+                else if (ColumnDefaultKind::Materialized == kind)
+                    res.materialized.emplace_back(column_name, std::move(data_type));
+                else if (ColumnDefaultKind::Alias == kind)
+                    res.aliases.emplace_back(column_name, std::move(data_type));
+            }
         }
     }
 
diff --git a/dbms/src/TableFunctions/getStructureOfRemoteTable.h b/dbms/src/TableFunctions/getStructureOfRemoteTable.h
index 70b3d83b8f1..20417ef50e1 100644
--- a/dbms/src/TableFunctions/getStructureOfRemoteTable.h
+++ b/dbms/src/TableFunctions/getStructureOfRemoteTable.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Core/NamesAndTypes.h>
+#include <Storages/ColumnsDescription.h>
 
 
 namespace DB
@@ -11,7 +11,7 @@ class Context;
 
 /// Find the names and types of the table columns on any server in the cluster.
 /// Used to implement the `remote` table function and others.
-NamesAndTypesList getStructureOfRemoteTable(
+ColumnsDescription getStructureOfRemoteTable(
     const Cluster & cluster,
     const std::string & database,
     const std::string & table,
diff --git a/dbms/tests/CMakeLists.txt b/dbms/tests/CMakeLists.txt
index 30978652315..128ffee582f 100644
--- a/dbms/tests/CMakeLists.txt
+++ b/dbms/tests/CMakeLists.txt
@@ -26,5 +26,5 @@ if (ENABLE_TESTS)
     configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CTestCustom.cmake ${CMAKE_BINARY_DIR})
 
     # maybe add --no-long ?
-    add_test(NAME with_server COMMAND bash -c "env BUILD_DIR=${ClickHouse_BINARY_DIR} TEST_OPT='--skip compile' ${CMAKE_CURRENT_SOURCE_DIR}/clickhouse-test-server")
+    add_test(NAME with_server COMMAND bash -c "env BUILD_DIR=${ClickHouse_BINARY_DIR} TEST_OPT0='--skip compile' ${CMAKE_CURRENT_SOURCE_DIR}/clickhouse-test-server")
 endif ()
diff --git a/dbms/tests/clickhouse-test-server b/dbms/tests/clickhouse-test-server
index 82d254017bf..38b6515a746 100755
--- a/dbms/tests/clickhouse-test-server
+++ b/dbms/tests/clickhouse-test-server
@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 
+set -x
 set -o errexit
 set -o pipefail
 
@@ -24,21 +25,38 @@ export CLICKHOUSE_CONFIG=${CLICKHOUSE_CONFIG:=${CONFIG_SERVER_DIR}server-test.xm
 rm -rf $DATA_DIR
 mkdir -p $LOG_DIR
 
+openssl dhparam -out `${BIN_DIR}clickhouse-extract-from-config --config=$CLICKHOUSE_CONFIG  --key=openSSL.server.dhParamsFile` 256
+openssl req -subj "/CN=localhost" -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout `${BIN_DIR}clickhouse-extract-from-config --config=$CLICKHOUSE_CONFIG  --key=openSSL.server.privateKeyFile` -out `${BIN_DIR}clickhouse-extract-from-config --config=$CLICKHOUSE_CONFIG  --key=openSSL.server.certificateFile`
+
+if [ "$TEST_GDB" ]; then
+    echo -e "run \nset pagination off \nset logging file $DATA_DIR/gdb.log \nset logging on \nthread apply all backtrace \ndetach \nquit " > $DATA_DIR/gdb.cmd
+    GDB="gdb -x $DATA_DIR/gdb.cmd --args "
+fi
 
 # Start a local clickhouse server which will be used to run tests
 #PATH=$PATH:$BIN_DIR \
-${BIN_DIR}clickhouse-server --config-file=${CLICKHOUSE_CONFIG} > $LOG_DIR/stdout 2>&1 &
+$GDB ${BIN_DIR}clickhouse-server --config-file=${CLICKHOUSE_CONFIG} > $LOG_DIR/stdout 2>&1 &
 CH_PID=$!
 sleep 3
 
+if [ "$GDB" ]; then
+    # Long symbols read
+    sleep 40
+fi
+
+tail -n50 $LOG_DIR/*
+
 # Define needed stuff to kill test clickhouse server after tests completion
 function finish {
-  kill $CH_PID || true
-  wait
-  tail -n 50 $LOG_DIR/stdout
-  rm -rf $DATA_DIR
+    kill $CH_PID || true
+    wait
+    tail -n 50 $LOG_DIR/*
+    if [ "$GDB" ]; then
+        cat $DATA_DIR/gdb.log || true
+    fi
+    rm -rf $DATA_DIR
 }
-trap finish EXIT
+trap finish EXIT SIGINT SIGQUIT SIGTERM
 
 # Do tests
 if [ -n "$*" ]; then
@@ -46,5 +64,5 @@ if [ -n "$*" ]; then
 else
     ${BIN_DIR}clickhouse-client --config ${CONFIG_CLIENT} -q 'SELECT * from system.build_options;'
     PATH=$PATH:$BIN_DIR \
-      ${TEST_DIR}clickhouse-test --binary ${BIN_DIR}clickhouse --configclient ${CONFIG_CLIENT} --configserver ${CLICKHOUSE_CONFIG} --tmp $DATA_DIR/tmp --queries ${QUERIES_DIR} $TEST_OPT
+      ${TEST_DIR}clickhouse-test --binary ${BIN_DIR}clickhouse --configclient ${CONFIG_CLIENT} --configserver ${CLICKHOUSE_CONFIG} --tmp $DATA_DIR/tmp --queries ${QUERIES_DIR} $TEST_OPT0 $TEST_OPT
 fi
diff --git a/dbms/tests/client-test.xml b/dbms/tests/client-test.xml
index 0cd3bdd5dc0..8747c773a66 100644
--- a/dbms/tests/client-test.xml
+++ b/dbms/tests/client-test.xml
@@ -1,4 +1,17 @@
 <!-- Config for connecting to test server -->
 <yandex>
     <tcp_port>59000</tcp_port>
+    <tcp_ssl_port>59440</tcp_ssl_port>
+    <openSSL>
+        <client>
+            <loadDefaultCAFile>true</loadDefaultCAFile>
+            <cacheSessions>true</cacheSessions>
+            <disableProtocols>sslv2,sslv3</disableProtocols>
+            <preferServerCiphers>true</preferServerCiphers>
+            <verificationMode>none</verificationMode>
+            <invalidCertificateHandler>
+                <name>AcceptCertificateHandler</name>
+            </invalidCertificateHandler>
+        </client>
+    </openSSL>
 </yandex>
diff --git a/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp
index 7bb6e2eb726..9ddaf69e1fd 100644
--- a/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp
+++ b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp
@@ -158,7 +158,7 @@ void * ClickHouseDictionary_v2_loadKeys(void * data_ptr,
     return nullptr;
 }
 
-void * ClickHouseDictionary_v2_libNew()
+void * ClickHouseDictionary_v2_libNew(ClickHouseLibrary::CStrings * /*settings*/)
 {
     auto lib_ptr = new LibHolder;
     return lib_ptr;
diff --git a/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_c.c b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_c.c
index 9d95894302a..6caea3ac2cf 100644
--- a/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_c.c
+++ b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_c.c
@@ -39,7 +39,7 @@ void * ClickHouseDictionary_v2_loadKeys(
     return 0;
 }
 
-void * ClickHouseDictionary_v2_libNew()
+void * ClickHouseDictionary_v2_libNew(ClickHouseLibCStrings * settings)
 {
     int size = 101;
     void * lib_ptr = malloc(size);
diff --git a/dbms/tests/integration/README.md b/dbms/tests/integration/README.md
index 0f8f615b616..cc704022e79 100644
--- a/dbms/tests/integration/README.md
+++ b/dbms/tests/integration/README.md
@@ -5,7 +5,7 @@ This directory contains tests that involve several ClickHouse instances, custom
 ### Running
 
 Prerequisites:
-* Ubuntu 14.04 (Trusty).
+* Ubuntu 14.04 (Trusty) or higher.
 * [docker](https://www.docker.com/community-edition#/download). Minimum required API version: 1.25, check with `docker version`.
 
 You must install latest Docker from
diff --git a/dbms/tests/integration/test_cluster_copier/task0_description.xml b/dbms/tests/integration/test_cluster_copier/task0_description.xml
index 0031a18c552..e8e4df99254 100644
--- a/dbms/tests/integration/test_cluster_copier/task0_description.xml
+++ b/dbms/tests/integration/test_cluster_copier/task0_description.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <yandex>
     <!-- How many simualteneous workers are posssible -->
-    <max_workers>4</max_workers>
+    <max_workers>3</max_workers>
 
     <!-- Common setting for pull and push operations -->
     <settings>
diff --git a/dbms/tests/integration/test_system_queries/test.py b/dbms/tests/integration/test_system_queries/test.py
index 063d9c005bd..46ab2561a83 100644
--- a/dbms/tests/integration/test_system_queries/test.py
+++ b/dbms/tests/integration/test_system_queries/test.py
@@ -74,6 +74,17 @@ def test_DROP_DNS_CACHE(started_cluster):
     assert TSV(instance.query("SELECT DISTINCT host_name, host_address FROM system.clusters WHERE cluster='lost_host_cluster'")) == TSV("lost_host\t127.0.0.1\n")
 
 
+def test_RELOAD_CONFIG_AND_MACROS(started_cluster):
+
+    macros = "<yandex><macros><mac>ro</mac></macros></yandex>"
+    create_macros = 'echo "{}" > /etc/clickhouse-server/config.d/macros.xml'.format(macros)
+
+    instance = cluster.instances['ch1']
+
+    instance.exec_in_container(['bash', '-c', create_macros], privileged=True, user='root')
+    instance.query("SYSTEM RELOAD CONFIG")
+    assert TSV(instance.query("select * from system.macros")) == TSV("mac\tro\n")
+
 if __name__ == '__main__':
     with contextmanager(started_cluster)() as cluster:
        for name, instance in cluster.instances.items():
diff --git a/dbms/tests/queries/0_stateless/00172_constexprs_in_set.reference b/dbms/tests/queries/0_stateless/00172_constexprs_in_set.reference
index c06d3de5a56..ac284bbc084 100644
--- a/dbms/tests/queries/0_stateless/00172_constexprs_in_set.reference
+++ b/dbms/tests/queries/0_stateless/00172_constexprs_in_set.reference
@@ -4,3 +4,4 @@
 1
 1
 1
+1	0
diff --git a/dbms/tests/queries/0_stateless/00172_constexprs_in_set.sql b/dbms/tests/queries/0_stateless/00172_constexprs_in_set.sql
index 3c438417053..5d79185ee8d 100644
--- a/dbms/tests/queries/0_stateless/00172_constexprs_in_set.sql
+++ b/dbms/tests/queries/0_stateless/00172_constexprs_in_set.sql
@@ -4,3 +4,4 @@ SELECT toDate('2015-06-12') IN (toDate('2015-06-12'));
 SELECT today() IN (toDate('2014-01-01'), toDate(now()));
 SELECT - -1 IN (2 - 1);
 SELECT - -1 IN (2 - 1, 3);
+WITH (1, 2) AS a SELECT 1 IN a, 3 IN a;
diff --git a/dbms/tests/queries/0_stateless/00371_union_all.sql b/dbms/tests/queries/0_stateless/00371_union_all.sql
index 893e100e12b..0a738b6b20c 100644
--- a/dbms/tests/queries/0_stateless/00371_union_all.sql
+++ b/dbms/tests/queries/0_stateless/00371_union_all.sql
@@ -1,2 +1,2 @@
 select toUInt64(1) union all select countIf(n>0) from (select 2 as n);
-select [1,2,3] AS q UNION ALL select groupArray(arrayJoin([4,5,6])) AS q ORDER BY q;
+SELECT q FROM (select [1,2,3] AS q UNION ALL select groupArray(arrayJoin([4,5,6])) AS q ORDER BY q) ORDER BY q;
diff --git a/dbms/tests/queries/0_stateless/00416_pocopatch_progress_in_http_headers.sh b/dbms/tests/queries/0_stateless/00416_pocopatch_progress_in_http_headers.sh
index 12f20a956ad..8e762515da1 100755
--- a/dbms/tests/queries/0_stateless/00416_pocopatch_progress_in_http_headers.sh
+++ b/dbms/tests/queries/0_stateless/00416_pocopatch_progress_in_http_headers.sh
@@ -5,7 +5,7 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 
 # This test will fail with external poco (progress not supported)
 
-${CLICKHOUSE_CURL} -vsS "${CLICKHOUSE_URL}?max_block_size=1&send_progress_in_http_headers=1&http_headers_progress_interval_ms=0" -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep -E 'Content-Encoding|X-ClickHouse|^[0-9]'
+${CLICKHOUSE_CURL} -vsS "${CLICKHOUSE_URL}?max_block_size=1&send_progress_in_http_headers=1&http_headers_progress_interval_ms=0" -d 'SELECT number FROM system.numbers LIMIT 10' 2>&1 | grep -E 'Content-Encoding|X-ClickHouse-Progress|^[0-9]'
 ${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}?max_block_size=1&send_progress_in_http_headers=1&http_headers_progress_interval_ms=0&enable_http_compression=1" -H 'Accept-Encoding: gzip' -d 'SELECT number FROM system.numbers LIMIT 10' | gzip -d
 
 # 'send_progress_in_http_headers' is false by default
diff --git a/dbms/tests/queries/0_stateless/00501_http_head.sh b/dbms/tests/queries/0_stateless/00501_http_head.sh
index c15b8679fab..578e27da751 100755
--- a/dbms/tests/queries/0_stateless/00501_http_head.sh
+++ b/dbms/tests/queries/0_stateless/00501_http_head.sh
@@ -7,7 +7,7 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 . $CURDIR/../shell_config.sh
 
 ( ${CLICKHOUSE_CURL} -s --head "${CLICKHOUSE_URL}?query=SELECT%201";
-  ${CLICKHOUSE_CURL} -s --head "${CLICKHOUSE_URL}?query=select+*+from+system.numbers+limit+1000000" ) | grep -v "Date:"
+  ${CLICKHOUSE_CURL} -s --head "${CLICKHOUSE_URL}?query=select+*+from+system.numbers+limit+1000000" ) | grep -v "Date:" | grep -v "X-ClickHouse-Server-Display-Name:"
 
 if [[ `${CLICKHOUSE_CURL} -sS -X POST -I "${CLICKHOUSE_URL}?query=SELECT+1" | grep -c '411 Length Required'` -ne 1 ]]; then
     echo FAIL
diff --git a/dbms/tests/queries/0_stateless/00505_tcp_ssl.reference b/dbms/tests/queries/0_stateless/00505_tcp_ssl.reference
index 1191247b6d9..01e79c32a8c 100644
--- a/dbms/tests/queries/0_stateless/00505_tcp_ssl.reference
+++ b/dbms/tests/queries/0_stateless/00505_tcp_ssl.reference
@@ -1,2 +1,3 @@
 1
 2
+3
diff --git a/dbms/tests/queries/0_stateless/00505_tcp_ssl.sh b/dbms/tests/queries/0_stateless/00505_tcp_ssl.sh
index 40b90d572b0..47f3c3b35da 100755
--- a/dbms/tests/queries/0_stateless/00505_tcp_ssl.sh
+++ b/dbms/tests/queries/0_stateless/00505_tcp_ssl.sh
@@ -13,4 +13,6 @@ else
     # Auto port detect
     ${CLICKHOUSE_CLIENT} --ssl -q "SELECT 1";
     ${CLICKHOUSE_CLIENT} --ssl --port=${CLICKHOUSE_PORT_TCP_SSL} -q "SELECT 2";
+
+    ${CLICKHOUSE_CURL} -sS --insecure ${CLICKHOUSE_URL_HTTPS}?query=SELECT%203
 fi
diff --git a/dbms/tests/queries/0_stateless/00515_shard_desc_table_functions_and_subqueries.reference b/dbms/tests/queries/0_stateless/00515_shard_desc_table_functions_and_subqueries.reference
index 20d07b74593..b0615b7993f 100644
--- a/dbms/tests/queries/0_stateless/00515_shard_desc_table_functions_and_subqueries.reference
+++ b/dbms/tests/queries/0_stateless/00515_shard_desc_table_functions_and_subqueries.reference
@@ -12,15 +12,15 @@ val4	UInt64	ALIAS	val
 -
 date	Date		
 val	UInt64		
-val2	UInt8		
-val3	UInt8		
-val4	UInt64		
+val2	UInt8	DEFAULT	42
+val3	UInt8	DEFAULT	CAST((val2 + 1) AS UInt8)
+val4	UInt64	ALIAS	val
 -
 date	Date		
 val	UInt64		
-val2	UInt8		
-val3	UInt8		
-val4	UInt64		
+val2	UInt8	DEFAULT	42
+val3	UInt8	DEFAULT	CAST((val2 + 1) AS UInt8)
+val4	UInt64	ALIAS	val
 -
 1	UInt8		
 -
diff --git a/dbms/tests/queries/0_stateless/00534_filimonov.data b/dbms/tests/queries/0_stateless/00534_filimonov.data
index 53c64592d0a..2dd470403c0 100644
--- a/dbms/tests/queries/0_stateless/00534_filimonov.data
+++ b/dbms/tests/queries/0_stateless/00534_filimonov.data
@@ -427,3 +427,6 @@ SELECT COVAR_POPArray([CAST( 0  AS Int8)],arrayPopBack([CAST( 0  AS Int8)]));
 SELECT COVAR_SAMPArray([CAST( 0  AS Int8)],arrayPopBack([CAST( 0  AS Int8)]));
 SELECT medianTimingWeightedArray([CAST( 0  AS Int8)],arrayPopBack([CAST( 0  AS Int8)]));
 SELECT quantilesDeterministicArray([CAST( 0  AS Int8)],arrayPopBack([CAST( 0  AS Int32)]));
+
+SELECT maxIntersections([], [])
+SELECT sumMap([], [])
diff --git a/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments7.sh b/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments7.sh
index 78b9afafe55..af34af94458 100755
--- a/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments7.sh
+++ b/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments7.sh
@@ -5,4 +5,4 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 
 . $CURDIR/00534_long_functions_bad_arguments.lib
 
-test_variant 'SELECT $_('');'
+test_variant "SELECT \$_('');"
diff --git a/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments8.sh b/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments8.sh
new file mode 100755
index 00000000000..f884a926c3b
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments8.sh
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. $CURDIR/../shell_config.sh
+
+. $CURDIR/00534_long_functions_bad_arguments.lib
+
+test_variant 'SELECT $_(NULL, NULL);'
+test_variant 'SELECT $_([], []);'
+test_variant 'SELECT $_([NULL],[NULL]);'
diff --git a/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments9.sh b/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments9.sh
new file mode 100755
index 00000000000..bc1ceda33fa
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00534_long_functions_bad_arguments9.sh
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+. $CURDIR/../shell_config.sh
+
+. $CURDIR/00534_long_functions_bad_arguments.lib
+
+test_variant 'SELECT $_(NULL, NULL, NULL);'
+test_variant 'SELECT $_([], [], []);'
+test_variant 'SELECT $_([NULL], [NULL], [NULL]);'
diff --git a/dbms/tests/queries/0_stateless/00563_complex_in_expression.reference b/dbms/tests/queries/0_stateless/00563_complex_in_expression.reference
index b7d32274dd7..480b2d124fe 100644
--- a/dbms/tests/queries/0_stateless/00563_complex_in_expression.reference
+++ b/dbms/tests/queries/0_stateless/00563_complex_in_expression.reference
@@ -1,3 +1,7 @@
 2018-01-29	100	key
 2018-01-29	100	key
 2
+0	1
+1	0
+2	0
+99	1
diff --git a/dbms/tests/queries/0_stateless/00563_complex_in_expression.sql b/dbms/tests/queries/0_stateless/00563_complex_in_expression.sql
index 522ff0168ed..1a84e560509 100644
--- a/dbms/tests/queries/0_stateless/00563_complex_in_expression.sql
+++ b/dbms/tests/queries/0_stateless/00563_complex_in_expression.sql
@@ -22,4 +22,11 @@ ALL INNER JOIN
     FROM test.join_with_index
     WHERE toUInt64(data) IN (0, 529335254087962442)
 ) USING (key);
-DROP TABLE IF EXISTS test.join_with_index;
\ No newline at end of file
+
+SELECT _uniq, _uniq IN (0, 99)
+FROM test.join_with_index
+ARRAY JOIN
+    [key, data] AS _uniq
+ORDER BY _uniq;
+
+DROP TABLE IF EXISTS test.join_with_index;
diff --git a/dbms/tests/queries/0_stateless/00569_parse_date_time_best_effort.reference b/dbms/tests/queries/0_stateless/00569_parse_date_time_best_effort.reference
index c0ad225ca1e..38264a337f0 100644
--- a/dbms/tests/queries/0_stateless/00569_parse_date_time_best_effort.reference
+++ b/dbms/tests/queries/0_stateless/00569_parse_date_time_best_effort.reference
@@ -7,7 +7,7 @@ s                                                   a                     b
 02/01/17 010203 MSK               2017-01-01 22:02:03   2017-01-01 22:02:03
 02/01/17 010203 MSK+0100          2017-01-01 21:02:03   2017-01-01 21:02:03
 02/01/17 010203 UTC+0300          2017-01-01 22:02:03   2017-01-01 22:02:03
-020117 010203 UTC+0300            1970-01-01 84:30:19   1970-01-01 84:30:19
+020117 010203 UTC+0300            1970-01-01 04:30:19   1970-01-01 04:30:19
 02/01/17 010203Z                  2017-01-02 01:02:03   2017-01-02 01:02:03
 02/01/1970 010203Z                1970-01-02 01:02:03   1970-01-02 01:02:03
 02/01/70 010203Z                  1970-01-02 01:02:03   1970-01-02 01:02:03
diff --git a/dbms/tests/queries/0_stateless/00578_merge_trees_without_primary_key.sql b/dbms/tests/queries/0_stateless/00578_merge_trees_without_primary_key.sql
index efd881ae006..2e1c0d24024 100644
--- a/dbms/tests/queries/0_stateless/00578_merge_trees_without_primary_key.sql
+++ b/dbms/tests/queries/0_stateless/00578_merge_trees_without_primary_key.sql
@@ -1,7 +1,7 @@
 SELECT '*** MergeTree ***';
 
 DROP TABLE IF EXISTS test.unsorted;
-CREATE TABLE test.unsorted (x UInt32, y String) ENGINE MergeTree ORDER BY tuple();
+CREATE TABLE test.unsorted (x UInt32, y String) ENGINE MergeTree ORDER BY tuple() SETTINGS vertical_merge_algorithm_min_rows_to_activate=0, vertical_merge_algorithm_min_columns_to_activate=0;
 
 INSERT INTO test.unsorted VALUES (1, 'a'), (5, 'b');
 INSERT INTO test.unsorted VALUES (2, 'c'), (4, 'd');
diff --git a/dbms/tests/queries/0_stateless/00600_create_temporary_table_if_not_exists.reference b/dbms/tests/queries/0_stateless/00600_create_temporary_table_if_not_exists.reference
new file mode 100644
index 00000000000..01e79c32a8c
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00600_create_temporary_table_if_not_exists.reference
@@ -0,0 +1,3 @@
+1
+2
+3
diff --git a/dbms/tests/queries/0_stateless/00600_create_temporary_table_if_not_exists.sql b/dbms/tests/queries/0_stateless/00600_create_temporary_table_if_not_exists.sql
new file mode 100644
index 00000000000..3f4c80ddcc6
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00600_create_temporary_table_if_not_exists.sql
@@ -0,0 +1,4 @@
+CREATE TEMPORARY TABLE IF NOT EXISTS temporary_table (column UInt32) ENGINE = Memory;
+CREATE TEMPORARY TABLE IF NOT EXISTS temporary_table (column UInt32) ENGINE = Memory;
+INSERT INTO temporary_table VALUES (1), (2), (3);
+SELECT column FROM temporary_table ORDER BY column;
\ No newline at end of file
diff --git a/dbms/tests/queries/0_stateless/00604_shard_remote_and_columns_with_defaults.reference b/dbms/tests/queries/0_stateless/00604_shard_remote_and_columns_with_defaults.reference
new file mode 100644
index 00000000000..8a5c72b9000
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00604_shard_remote_and_columns_with_defaults.reference
@@ -0,0 +1,13 @@
+1	1
+2	2
+*** With a DEFAULT column ***
+1	1
+2	2
+*** With a MATERIALIZED column ***
+1
+1	2
+*** With an ALIAS column ***
+1
+2
+1	2
+2	3
diff --git a/dbms/tests/queries/0_stateless/00604_shard_remote_and_columns_with_defaults.sql b/dbms/tests/queries/0_stateless/00604_shard_remote_and_columns_with_defaults.sql
new file mode 100644
index 00000000000..c1c47d225db
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00604_shard_remote_and_columns_with_defaults.sql
@@ -0,0 +1,38 @@
+DROP TABLE IF EXISTS test.t1;
+DROP TABLE IF EXISTS test.t2;
+DROP TABLE IF EXISTS test.t3;
+DROP TABLE IF EXISTS test.t4;
+
+CREATE TABLE test.t1(x UInt32, y UInt32) ENGINE TinyLog;
+CREATE TABLE test.t2(x UInt32, y UInt32 DEFAULT x + 1) ENGINE TinyLog;
+CREATE TABLE test.t3(x UInt32, y UInt32 MATERIALIZED x + 1) ENGINE TinyLog;
+CREATE TABLE test.t4(x UInt32, y UInt32 ALIAS x + 1) ENGINE TinyLog;
+
+INSERT INTO test.t1 VALUES (1, 1);
+INSERT INTO test.t2 VALUES (1, 1);
+INSERT INTO test.t3 VALUES (1);
+INSERT INTO test.t4 VALUES (1);
+
+INSERT INTO FUNCTION remote('127.0.0.2', test.t1) VALUES (2, 2);
+INSERT INTO FUNCTION remote('127.0.0.2', test.t2) VALUES (2, 2);
+--TODO: INSERT into remote tables with MATERIALIZED columns.
+--INSERT INTO FUNCTION remote('127.0.0.2', test.t3) VALUES (2);
+INSERT INTO FUNCTION remote('127.0.0.2', test.t4) VALUES (2);
+
+SELECT * FROM remote('127.0.0.2', test.t1) ORDER BY x;
+
+SELECT '*** With a DEFAULT column ***';
+SELECT * FROM remote('127.0.0.2', test.t2) ORDER BY x;
+
+SELECT '*** With a MATERIALIZED column ***';
+SELECT * FROM remote('127.0.0.2', test.t3) ORDER BY x;
+SELECT x, y FROM remote('127.0.0.2', test.t3) ORDER BY x;
+
+SELECT '*** With an ALIAS column ***';
+SELECT * FROM remote('127.0.0.2', test.t4) ORDER BY x;
+SELECT x, y FROM remote('127.0.0.2', test.t4) ORDER BY x;
+
+DROP TABLE test.t1;
+DROP TABLE test.t2;
+DROP TABLE test.t3;
+DROP TABLE test.t4;
diff --git a/dbms/tests/queries/0_stateless/00605_intersections_aggregate_functions.reference b/dbms/tests/queries/0_stateless/00605_intersections_aggregate_functions.reference
new file mode 100644
index 00000000000..61c83cba41c
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00605_intersections_aggregate_functions.reference
@@ -0,0 +1,2 @@
+4
+5
diff --git a/dbms/tests/queries/0_stateless/00605_intersections_aggregate_functions.sql b/dbms/tests/queries/0_stateless/00605_intersections_aggregate_functions.sql
new file mode 100644
index 00000000000..c23583dd8c8
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00605_intersections_aggregate_functions.sql
@@ -0,0 +1,20 @@
+DROP TABLE IF EXISTS test.test;
+CREATE TABLE test.test(start Integer, end Integer) engine = Memory;
+INSERT INTO test.test(start,end) VALUES (1,3),(2,7),(3,999),(4,7),(5,8);
+
+/*
+1 2 3 4 5 6 7 8 9
+------------------>
+1---3
+  2---------7
+    3-------------
+      4-----7
+        5-----8
+------------------>
+1 2 3 3 4 4 4 2 1  //intersections count for each point
+*/
+
+SELECT maxIntersections(start,end) FROM test.test;
+SELECT maxIntersectionsPosition(start,end) FROM test.test;
+
+DROP TABLE test.test;
diff --git a/dbms/tests/queries/0_stateless/00606_quantiles_and_nans.reference b/dbms/tests/queries/0_stateless/00606_quantiles_and_nans.reference
new file mode 100644
index 00000000000..d00491fd7e5
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00606_quantiles_and_nans.reference
@@ -0,0 +1 @@
+1
diff --git a/dbms/tests/queries/0_stateless/00606_quantiles_and_nans.sql b/dbms/tests/queries/0_stateless/00606_quantiles_and_nans.sql
new file mode 100644
index 00000000000..c89883e356b
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00606_quantiles_and_nans.sql
@@ -0,0 +1 @@
+SELECT DISTINCT eq FROM (WITH range(number % 10) AS arr, arrayMap(x -> x = intDiv(number, 10) ? nan : x, arr) AS arr_with_nan, arrayFilter(x -> x != intDiv(number, 10), arr) AS arr_filtered SELECT number, arrayReduce('quantileExact', arr_with_nan) AS q1, arrayReduce('quantileExact', arr_filtered) AS q2, q1 = q2 AS eq FROM numbers(100));
\ No newline at end of file
diff --git a/dbms/tests/queries/0_stateless/00607_index_in_in.reference b/dbms/tests/queries/0_stateless/00607_index_in_in.reference
new file mode 100644
index 00000000000..a9e2f17562a
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00607_index_in_in.reference
@@ -0,0 +1,6 @@
+1
+1
+1
+1
+1
+1
diff --git a/dbms/tests/queries/0_stateless/00607_index_in_in.sql b/dbms/tests/queries/0_stateless/00607_index_in_in.sql
new file mode 100644
index 00000000000..a1e2efa6a71
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00607_index_in_in.sql
@@ -0,0 +1,16 @@
+DROP TABLE IF EXISTS test.merge_tree;
+CREATE TABLE test.merge_tree (x UInt32) ENGINE = MergeTree ORDER BY x SETTINGS index_granularity = 1;
+INSERT INTO test.merge_tree VALUES (0), (1);
+
+SET force_primary_key = 1;
+SET max_rows_to_read = 1;
+
+SELECT count() FROM test.merge_tree WHERE x = 0;
+SELECT count() FROM test.merge_tree WHERE toUInt32(x) = 0;
+SELECT count() FROM test.merge_tree WHERE toUInt64(x) = 0;
+
+SELECT count() FROM test.merge_tree WHERE x IN (0, 0);
+SELECT count() FROM test.merge_tree WHERE toUInt32(x) IN (0, 0);
+SELECT count() FROM test.merge_tree WHERE toUInt64(x) IN (0, 0);
+
+DROP TABLE test.merge_tree;
diff --git a/dbms/tests/queries/0_stateless/00608_uniq_array.reference b/dbms/tests/queries/0_stateless/00608_uniq_array.reference
new file mode 100644
index 00000000000..1f242fa6f00
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00608_uniq_array.reference
@@ -0,0 +1,3 @@
+3
+3
+3
diff --git a/dbms/tests/queries/0_stateless/00608_uniq_array.sql b/dbms/tests/queries/0_stateless/00608_uniq_array.sql
new file mode 100644
index 00000000000..d4b0efd8fb4
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00608_uniq_array.sql
@@ -0,0 +1,3 @@
+SELECT uniq(x) FROM (SELECT arrayJoin([[1, 2], [1, 2], [1, 2, 3], []]) AS x);
+SELECT uniqExact(x) FROM (SELECT arrayJoin([[1, 2], [1, 2], [1, 2, 3], []]) AS x);
+SELECT uniqUpTo(2)(x) FROM (SELECT arrayJoin([[1, 2], [1, 2], [1, 2, 3], []]) AS x);
diff --git a/dbms/tests/queries/0_stateless/00609_distributed_with_case_when_then.reference b/dbms/tests/queries/0_stateless/00609_distributed_with_case_when_then.reference
new file mode 100644
index 00000000000..c5bb9a19a34
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00609_distributed_with_case_when_then.reference
@@ -0,0 +1,6 @@
+hello
+world
+2
+hello
+world
+2
diff --git a/dbms/tests/queries/0_stateless/00609_distributed_with_case_when_then.sql b/dbms/tests/queries/0_stateless/00609_distributed_with_case_when_then.sql
new file mode 100644
index 00000000000..8d7568415a2
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00609_distributed_with_case_when_then.sql
@@ -0,0 +1,16 @@
+DROP TABLE IF EXISTS test.mergetree;
+DROP TABLE IF EXISTS test.distributed;
+
+CREATE TABLE test.mergetree (x UInt64, s String) ENGINE = MergeTree ORDER BY x;
+INSERT INTO test.mergetree VALUES (1, 'hello'), (2, 'world');
+
+SELECT CASE x WHEN 1 THEN 'hello' WHEN 2 THEN 'world' ELSE  'unknow' END FROM test.mergetree;
+SELECT count() AS cnt FROM (SELECT CASE x WHEN 1 THEN 'hello' WHEN 2 THEN 'world' ELSE  'unknow' END FROM test.mergetree);
+
+CREATE TABLE test.distributed AS test.mergetree ENGINE = Distributed(test_shard_localhost, test, mergetree);
+
+SELECT CASE x WHEN 1 THEN 'hello' WHEN 2 THEN 'world' ELSE  'unknow' END FROM test.distributed;
+SELECT count() AS cnt FROM (SELECT CASE x WHEN 1 THEN 'hello' WHEN 2 THEN 'world' ELSE  'unknow' END FROM test.distributed);
+
+DROP TABLE test.mergetree;
+DROP TABLE test.distributed;
diff --git a/dbms/tests/queries/0_stateless/00609_mv_index_in_in.reference b/dbms/tests/queries/0_stateless/00609_mv_index_in_in.reference
new file mode 100644
index 00000000000..49fe65e4358
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00609_mv_index_in_in.reference
@@ -0,0 +1,3 @@
+1	2000-01-01
+1	2000-01-01
+1	2000-01-01
diff --git a/dbms/tests/queries/0_stateless/00609_mv_index_in_in.sql b/dbms/tests/queries/0_stateless/00609_mv_index_in_in.sql
new file mode 100644
index 00000000000..da583a7c2f4
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00609_mv_index_in_in.sql
@@ -0,0 +1,16 @@
+USE test;
+
+DROP TABLE IF EXISTS test;
+DROP TABLE IF EXISTS test_mv;
+
+create table test (a Int8) engine=Memory;
+
+insert into test values (1);
+create materialized view test_mv Engine=MergeTree(date, (a), 8192) populate as select a, toDate('2000-01-01') date from test;
+
+select * from test_mv; -- OK
+select * from test_mv where a in (select a from test_mv); -- EMPTY (bug)
+select * from ".inner.test_mv" where a in (select a from test_mv); -- OK
+
+DROP TABLE test;
+DROP TABLE test_mv;
diff --git a/dbms/tests/queries/0_stateless/00609_prewhere_and_default.reference b/dbms/tests/queries/0_stateless/00609_prewhere_and_default.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00609_prewhere_and_default.sql b/dbms/tests/queries/0_stateless/00609_prewhere_and_default.sql
new file mode 100644
index 00000000000..915f0c85823
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00609_prewhere_and_default.sql
@@ -0,0 +1,12 @@
+drop table if exists test.table;
+create table test.table (key UInt64, val UInt64) engine = MergeTree order by key settings index_granularity=8192;
+insert into test.table select number, number / 8192 from system.numbers limit 100000; 
+alter table test.table add column def UInt64 default val + 1;
+select * from test.table prewhere val > 2 format Null;
+
+drop table if exists test.table;
+create table test.table (key UInt64, val UInt64) engine = MergeTree order by key settings index_granularity=8192;
+insert into test.table select number, number / 8192 from system.numbers limit 100000; 
+alter table test.table add column def UInt64;
+select * from test.table prewhere val > 2 format Null;
+
diff --git a/dbms/tests/queries/0_stateless/00610_materialized_view_forward_alter_partition_statements.reference b/dbms/tests/queries/0_stateless/00610_materialized_view_forward_alter_partition_statements.reference
new file mode 100644
index 00000000000..d989886d07a
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00610_materialized_view_forward_alter_partition_statements.reference
@@ -0,0 +1,6 @@
+-- Before DROP PARTITION --
+2018-01-01	2
+2018-01-01	3
+2018-02-01	4
+-- After DROP PARTITION --
+2018-02-01	4
diff --git a/dbms/tests/queries/0_stateless/00610_materialized_view_forward_alter_partition_statements.sql b/dbms/tests/queries/0_stateless/00610_materialized_view_forward_alter_partition_statements.sql
new file mode 100644
index 00000000000..5469318068e
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00610_materialized_view_forward_alter_partition_statements.sql
@@ -0,0 +1,18 @@
+DROP TABLE IF EXISTS test.tab;
+DROP TABLE IF EXISTS test.mv;
+
+CREATE TABLE test.tab(d Date, x UInt32) ENGINE MergeTree(d, x, 8192);
+CREATE MATERIALIZED VIEW test.mv(d Date, y UInt64) ENGINE MergeTree(d, y, 8192) AS SELECT d, x + 1 AS y FROM test.tab;
+
+INSERT INTO test.tab VALUES ('2018-01-01', 1), ('2018-01-01', 2), ('2018-02-01', 3);
+
+SELECT '-- Before DROP PARTITION --';
+SELECT * FROM test.mv ORDER BY y;
+
+ALTER TABLE test.mv DROP PARTITION 201801;
+
+SELECT '-- After DROP PARTITION --';
+SELECT * FROM test.mv ORDER BY y;
+
+DROP TABLE test.tab;
+DROP TABLE test.mv;
diff --git a/dbms/tests/queries/0_stateless/00611_zookeeper_different_checksums_formats.reference b/dbms/tests/queries/0_stateless/00611_zookeeper_different_checksums_formats.reference
new file mode 100644
index 00000000000..da05f197b7e
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00611_zookeeper_different_checksums_formats.reference
@@ -0,0 +1,9 @@
+1
+1
+0	[]
+1	[]
+0	[]
+1	[]
+DETACH
+0	[]
+1	[]
diff --git a/dbms/tests/queries/0_stateless/00611_zookeeper_different_checksums_formats.sql b/dbms/tests/queries/0_stateless/00611_zookeeper_different_checksums_formats.sql
new file mode 100644
index 00000000000..9076485cfa1
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00611_zookeeper_different_checksums_formats.sql
@@ -0,0 +1,24 @@
+DROP TABLE IF EXISTS test.table_old;
+DROP TABLE IF EXISTS test.table_new;
+
+CREATE TABLE test.table_old (k UInt64, d Array(String)) ENGINE = ReplicatedMergeTree('/clickhouse/test/tables/checksums_test', 'old') ORDER BY k SETTINGS use_minimalistic_checksums_in_zookeeper=0;
+CREATE TABLE test.table_new (k UInt64, d Array(String)) ENGINE = ReplicatedMergeTree('/clickhouse/test/tables/checksums_test', 'new') ORDER BY k SETTINGS use_minimalistic_checksums_in_zookeeper=1;
+
+SET insert_quorum=2;
+INSERT INTO test.table_old VALUES (0, []);
+SELECT value LIKE '%checksums format version: 4%' FROM system.zookeeper WHERE path='/clickhouse/test/tables/checksums_test/replicas/old/parts/all_0_0_0' AND name = 'checksums';
+
+INSERT INTO test.table_new VALUES (1, []);
+SELECT value LIKE '%checksums format version: 5%' FROM system.zookeeper WHERE path='/clickhouse/test/tables/checksums_test/replicas/new/parts/all_1_1_0' AND name = 'checksums';
+
+OPTIMIZE TABLE test.table_old;
+SELECT * FROM test.table_old ORDER BY k;
+SELECT * FROM test.table_new ORDER BY k;
+
+SELECT 'DETACH';
+DETACH TABLE test.table_old;
+ATTACH TABLE test.table_old (k UInt64, d Array(String)) ENGINE = ReplicatedMergeTree('/clickhouse/test/tables/checksums_test', 'old') ORDER BY k SETTINGS use_minimalistic_checksums_in_zookeeper=1;
+SELECT * FROM test.table_old ORDER BY k;
+
+DROP TABLE IF EXISTS test.table_old;
+DROP TABLE IF EXISTS test.table_new;
\ No newline at end of file
diff --git a/dbms/tests/queries/shell_config.sh b/dbms/tests/queries/shell_config.sh
index b060c56877d..0aec2aab89e 100644
--- a/dbms/tests/queries/shell_config.sh
+++ b/dbms/tests/queries/shell_config.sh
@@ -18,6 +18,7 @@ export CLICKHOUSE_PORT_HTTPS=${CLICKHOUSE_PORT_HTTPS:=`${CLICKHOUSE_EXTRACT_CONF
 export CLICKHOUSE_PORT_HTTPS=${CLICKHOUSE_PORT_HTTPS:="8443"}
 export CLICKHOUSE_PORT_HTTP_PROTO=${CLICKHOUSE_PORT_HTTP_PROTO:="http"}
 export CLICKHOUSE_URL=${CLICKHOUSE_URL:="${CLICKHOUSE_PORT_HTTP_PROTO}://${CLICKHOUSE_HOST}:${CLICKHOUSE_PORT_HTTP}/"}
+export CLICKHOUSE_URL_HTTPS=${CLICKHOUSE_URL_HTTPS:="https://${CLICKHOUSE_HOST}:${CLICKHOUSE_PORT_HTTPS}/"}
 export CLICKHOUSE_CURL=${CLICKHOUSE_CURL:="curl --max-time 10"}
 export CLICKHOUSE_TMP=${CLICKHOUSE_TMP:="."}
 mkdir -p ${CLICKHOUSE_TMP}
diff --git a/dbms/tests/server-test.xml b/dbms/tests/server-test.xml
index cdb8e9caf5d..78e53e576e2 100644
--- a/dbms/tests/server-test.xml
+++ b/dbms/tests/server-test.xml
@@ -13,8 +13,35 @@
     <listen_try>1</listen_try>
     <http_port>58123</http_port>
     <tcp_port>59000</tcp_port>
-    <listen_host>0.0.0.0</listen_host>
+    <https_port>58443</https_port>
+    <tcp_ssl_port>59440</tcp_ssl_port>
     <interserver_http_port>59009</interserver_http_port>
+    <openSSL>
+        <server> <!-- Used for https server AND secure tcp port -->
+            <!-- openssl req -subj "/CN=localhost" -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout /etc/clickhouse-server/server.key -out /etc/clickhouse-server/server.crt -->
+            <certificateFile>/tmp/clickhouse/server.crt</certificateFile>
+            <privateKeyFile>/tmp/clickhouse/server.key</privateKeyFile>
+            <!-- openssl dhparam -out /etc/clickhouse-server/dhparam.pem 4096 -->
+            <dhParamsFile>/tmp/clickhouse/dhparam.pem</dhParamsFile>
+            <verificationMode>none</verificationMode>
+            <loadDefaultCAFile>true</loadDefaultCAFile>
+            <cacheSessions>true</cacheSessions>
+            <disableProtocols>sslv2,sslv3</disableProtocols>
+            <preferServerCiphers>true</preferServerCiphers>
+        </server>
+
+        <client> <!-- Used for connecting to https dictionary source -->
+            <loadDefaultCAFile>true</loadDefaultCAFile>
+            <cacheSessions>true</cacheSessions>
+            <disableProtocols>sslv2,sslv3</disableProtocols>
+            <preferServerCiphers>true</preferServerCiphers>
+            <verificationMode>none</verificationMode>
+            <invalidCertificateHandler>
+                <name>AcceptCertificateHandler</name>
+            </invalidCertificateHandler>
+        </client>
+    </openSSL>
+
     <keep_alive_timeout>3</keep_alive_timeout>
     <path>/tmp/clickhouse/data/</path>
     <tmp_path>/tmp/clickhouse/tmp/</tmp_path>
diff --git a/debian/.pbuilderrc b/debian/.pbuilderrc
index 33abbb1ab89..ba1cdb2c324 100644
--- a/debian/.pbuilderrc
+++ b/debian/.pbuilderrc
@@ -164,11 +164,11 @@ esac
 case "$DIST" in
     "bionic" )
         EXTRAPACKAGES+=" liblld-6.0-dev libclang-6.0-dev liblld-6.0 "
-        export CMAKE_FLAGS="-DUSE_EMBEDDED_COMPILER=1 -DLLVM_VERSION_POSTFIX=-6.0 $CMAKE_FLAGS"
+        export CMAKE_FLAGS="-DENABLE_EMBEDDED_COMPILER=1 -DLLVM_VERSION_POSTFIX=-6.0 $CMAKE_FLAGS"
         ;;
     "artful" | "experimental" | "unstable" | "testing" )
         EXTRAPACKAGES+=" liblld-5.0-dev libclang-5.0-dev liblld-5.0 "
-        export CMAKE_FLAGS="-DUSE_EMBEDDED_COMPILER=1 $CMAKE_FLAGS"
+        export CMAKE_FLAGS="-DENABLE_EMBEDDED_COMPILER=1 $CMAKE_FLAGS"
         ;;
 esac
 
@@ -188,7 +188,7 @@ export DEB_BUILD_OPTIONS=parallel=`nproc`
 
 # Floating bug with permissions:
 [ -n "$CCACHEDIR" ] && sudo mkdir -p $CCACHEDIR
-[ -n "$CCACHEDIR" ] && sudo chmod -R a+rwx $CCACHEDIR
+[ -n "$CCACHEDIR" ] && sudo chmod -R a+rwx $CCACHEDIR || true
 # chown -R $BUILDUSERID:$BUILDUSERID $CCACHEDIR
 
 
diff --git a/debian/changelog b/debian/changelog
index b5eaa0afae3..2ff28b59456 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,5 @@
-clickhouse (1.1.54363) unstable; urgency=low
+clickhouse (1.1.54371) unstable; urgency=low
 
   * Modified source code
 
- --  <robot-metrika-test@yandex-team.ru>  Tue, 13 Mar 2018 21:18:53 +0300
+ --  <robot-metrika-test@yandex-team.ru>  Fri, 23 Mar 2018 01:11:42 +0300
diff --git a/debian/control b/debian/control
index df43f4538ee..79666ace2e5 100644
--- a/debian/control
+++ b/debian/control
@@ -51,5 +51,5 @@ Description: debugging symbols for clickhouse-server-base
 Package: clickhouse-test
 Priority: extra
 Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, clickhouse-client, bash, expect, python, python-lxml, python-termcolor, curl, perl, sudo
+Depends: ${shlibs:Depends}, ${misc:Depends}, clickhouse-client, bash, expect, python, python-lxml, python-termcolor, curl, perl, sudo, openssl
 Description: Clickhouse tests
diff --git a/debian/pbuilder-hooks/B90test-server b/debian/pbuilder-hooks/B90test-server
index 5f163771582..eac7b5a6374 100755
--- a/debian/pbuilder-hooks/B90test-server
+++ b/debian/pbuilder-hooks/B90test-server
@@ -3,8 +3,8 @@ set -e
 set -x
 
 for PKG in $(ls /tmp/buildd/*.deb | sed -e's,.*/,,;s,_.*,,' ); do
-    apt-get install -y --force-yes "$PKG" || true 
-    apt-get remove -y "$PKG" || true 
+    apt-get install -y --force-yes "$PKG" || true
+    apt-get remove -y "$PKG" || true
 done
 
 dpkg -i /tmp/buildd/*.deb || true
@@ -16,21 +16,43 @@ ln -fs /usr/share/zoneinfo/Europe/Moscow /etc/localtime
 echo 'Europe/Moscow' > /etc/timezone
 dpkg-reconfigure -f noninteractive tzdata
 
+mkdir -p /etc/clickhouse-server/config.d /etc/clickhouse-client/config.d
 
-service clickhouse-server start
-sleep 3
+TEST_CONNECT=${TEST_CONNECT=1}
+if [ "${TEST_CONNECT}" ]; then
 
-# TODO: remove me or make only on error:
-tail -n100 /var/log/clickhouse-server/*
+    TEST_SSL=${TEST_SSL=1}
+    if  [ "${TEST_SSL}" ]; then
+        echo "<yandex><https_port>8443</https_port><tcp_ssl_port>9440</tcp_ssl_port></yandex>" > /etc/clickhouse-server/config.d/ssl.xml
+        echo "<yandex><openSSL><client><verificationMode>none</verificationMode><invalidCertificateHandler><name>AcceptCertificateHandler</name></invalidCertificateHandler></client></openSSL></yandex>" > /etc/clickhouse-client/config.d/ssl.xml
 
-clickhouse-client -q "SELECT * from system.build_options;"
-clickhouse-client -q "SELECT toDateTime(1);"
+        openssl dhparam -out /etc/clickhouse-server/dhparam.pem 256
+        openssl req -subj "/CN=localhost" -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout /etc/clickhouse-server/server.key -out /etc/clickhouse-server/server.crt
+        CLIENT_ADD="--ssl"
+    fi
 
+    function finish {
+        service clickhouse-server stop
+        tail -n 100 /var/log/clickhouse-server/*
+        sleep 1
+        killall -9 clickhouse-server || true
+    }
+    trap finish EXIT SIGINT SIGQUIT SIGTERM
 
-( [ "${TEST_RUN}" ] && clickhouse-test --queries /usr/share/clickhouse-test/queries --tmp /tmp/clickhouse-test/ ${TEST_OPT} ) || ${TEST_TRUE:=true}
+    service clickhouse-server start
+    sleep 3
 
+    # TODO: remove me or make only on error:
+    tail -n100 /var/log/clickhouse-server/*
 
-service clickhouse-server stop
+    clickhouse-client -q "SELECT * from system.build_options;"
+    clickhouse-client ${CLIENT_ADD} -q "SELECT toDateTime(1);"
+
+    ( [ "${TEST_RUN}" ] && clickhouse-test --queries /usr/share/clickhouse-test/queries --tmp /tmp/clickhouse-test/ ${TEST_OPT} ) || ${TEST_TRUE:=true}
+
+    service clickhouse-server stop
+
+fi
 
 # Test debug symbols
 # gdb -ex quit --args /usr/bin/clickhouse-server
diff --git a/debian/rules b/debian/rules
index 8f3818c0478..7990db33b1c 100755
--- a/debian/rules
+++ b/debian/rules
@@ -2,7 +2,7 @@
 # -*- makefile -*-
 
 # Uncomment this to turn on verbose mode.
-#export DH_VERBOSE=1
+export DH_VERBOSE=1
 
 # -pie only for static mode
 export DEB_BUILD_MAINT_OPTIONS=hardening=+all,-pie
diff --git a/docker/client/Dockerfile b/docker/client/Dockerfile
index 61f27405b83..9c8f3d087a3 100644
--- a/docker/client/Dockerfile
+++ b/docker/client/Dockerfile
@@ -1,6 +1,6 @@
 FROM ubuntu:16.04
 
-ARG repository="deb https://repo.yandex.ru/clickhouse/xenial/ dists/stable/main/binary-amd64/"
+ARG repository="deb http://repo.yandex.ru/clickhouse/deb/stable/ main/"
 ARG version=\*
 
 RUN apt-get update && \
diff --git a/docker/server/Dockerfile b/docker/server/Dockerfile
index ddc189877ac..2d4f998eff1 100644
--- a/docker/server/Dockerfile
+++ b/docker/server/Dockerfile
@@ -1,6 +1,6 @@
 FROM ubuntu:16.04
 
-ARG repository="deb https://repo.yandex.ru/clickhouse/xenial/ dists/stable/main/binary-amd64/"
+ARG repository="deb http://repo.yandex.ru/clickhouse/deb/stable/ main/"
 ARG version=\*
 
 RUN apt-get update && \
diff --git a/docker/server/docker_related_config.xml b/docker/server/docker_related_config.xml
index 7171a8b5ff7..ab6f82ad4c4 100644
--- a/docker/server/docker_related_config.xml
+++ b/docker/server/docker_related_config.xml
@@ -1,4 +1,6 @@
 <yandex>
      <!-- Listen wildcard address to allow accepting connections from other containers and host network. -->
     <listen_host>0.0.0.0</listen_host>
+    <listen_host>::</listen_host>
+    <listen_try>1</listen_try>
 </yandex>
diff --git a/docs/en/agg_functions/reference.md b/docs/en/agg_functions/reference.md
index d907f79647c..90ff9da58e7 100644
--- a/docs/en/agg_functions/reference.md
+++ b/docs/en/agg_functions/reference.md
@@ -19,7 +19,7 @@ In some cases, you can rely on the order of execution. This applies to cases whe
 
 When a `SELECT` query has the `GROUP BY` clause or at least one aggregate function, ClickHouse (in contrast to MySQL) requires that all expressions in the `SELECT`, `HAVING`, and `ORDER BY` clauses be calculated from keys or from aggregate functions. In other words, each column selected from the table must be used either in keys or inside aggregate functions. To get behavior like in MySQL, you can put the other columns in the `any` aggregate function.
 
-## anyHeavy
+## anyHeavy(x)
 
 Selects a frequently occurring value using the [heavy hitters](http://www.cs.umd.edu/~samir/498/karp.pdf) algorithm. If there is a value that occurs more than in half the cases in each of the query's execution threads, this value is returned. Normally, the result is nondeterministic.
 
@@ -33,7 +33,7 @@ anyHeavy(column)
 
 **Example**
 
-Take the [OnTime](../getting_started/example_datasets/ontime.md#example_datasets-ontime)data set and select any frequently occurring value in the `AirlineID` column.
+Take the [OnTime](../getting_started/example_datasets/ontime.md#example_datasets-ontime) data set and select any frequently occurring value in the `AirlineID` column.
 
 ```sql
 SELECT anyHeavy(AirlineID) AS res
@@ -170,7 +170,7 @@ In some cases, you can still rely on the order of execution. This applies to cas
 
 <a name="agg_functions_groupArrayInsertAt"></a>
 
-## groupArrayInsertAt
+## groupArrayInsertAt(x)
 
 Inserts a value into the array in the specified position.
 
@@ -257,7 +257,7 @@ The performance of the function is lower than for ` quantile`, ` quantileTiming`
 
 The result depends on the order of running the query, and is nondeterministic.
 
-## median
+## median(x)
 
 All the quantile functions have corresponding median functions: `median`, `medianDeterministic`, `medianTiming`, `medianTimingWeighted`, `medianExact`, `medianExactWeighted`, `medianTDigest`. They are synonyms and their behavior is identical.
 
@@ -287,16 +287,12 @@ The result is equal to the square root of `varSamp(x)`.
 
 The result is equal to the square root of `varPop(x)`.
 
-## topK
+## topK(N)(column)
 
 Returns an array of the most frequent values in the specified column. The resulting array is sorted in descending order of frequency of values (not by the values themselves).
 
 Implements the [ Filtered Space-Saving](http://www.l2f.inesc-id.pt/~fmmb/wiki/uploads/Work/misnis.ref0a.pdf)  algorithm for analyzing TopK, based on the reduce-and-combine algorithm from [Parallel Space Saving](https://arxiv.org/pdf/1401.0702.pdf).
 
-```
-topK(N)(column)
-```
-
 This function doesn't provide a guaranteed result. In certain situations, errors might occur and it might return frequent values that aren't the most frequent values.
 
 We recommend using the `N < 10 ` value; performance is reduced with large `N` values. Maximum value of ` N = 65536`.
diff --git a/docs/en/dicts/external_dicts_dict_layout.md b/docs/en/dicts/external_dicts_dict_layout.md
index 38be4187de4..ad635db94f5 100644
--- a/docs/en/dicts/external_dicts_dict_layout.md
+++ b/docs/en/dicts/external_dicts_dict_layout.md
@@ -2,11 +2,11 @@
 
 # Storing dictionaries in memory
 
-There are [many different ways](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-manner) to store dictionaries in memory.
+There are [many different ways](external_dicts_dict_layout#dicts-external_dicts_dict_layout-manner) to store dictionaries in memory.
 
-We recommend [flat](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-flat), [hashed](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-hashed), and [complex_key_hashed](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-complex_key_hashed). which provide optimal processing speed.
+We recommend [flat](external_dicts_dict_layout#dicts-external_dicts_dict_layout-flat), [hashed](external_dicts_dict_layout#dicts-external_dicts_dict_layout-hashed), and [complex_key_hashed](external_dicts_dict_layout#dicts-external_dicts_dict_layout-complex_key_hashed). which provide optimal processing speed.
 
-Caching is not recommended because of potentially poor performance and difficulties in selecting optimal parameters. Read more about this in the "[cache](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-cache)" section.
+Caching is not recommended because of potentially poor performance and difficulties in selecting optimal parameters. Read more about this in the "[cache](external_dicts_dict_layout#dicts-external_dicts_dict_layout-cache)" section.
 
 There are several ways to improve dictionary performance:
 
@@ -46,6 +46,7 @@ The configuration looks like this:
 - [range_hashed](#dicts-external_dicts_dict_layout-range_hashed)
 - [complex_key_hashed](#dicts-external_dicts_dict_layout-complex_key_hashed)
 - [complex_key_cache](#dicts-external_dicts_dict_layout-complex_key_cache)
+- [ip_trie](#dicts-external_dicts_dict_layout-ip_trie)
 
 <a name="dicts-external_dicts_dict_layout-flat"></a>
 
@@ -87,7 +88,7 @@ Configuration example:
 
 ### complex_key_hashed
 
-This type of storage is designed for use with compound [keys](external_dicts_dict_structure.md#dicts-external_dicts_dict_structure). It is similar to hashed.
+This type of storage is designed for use with compound [keys](external_dicts_dict_structure#dicts-external_dicts_dict_structure). It is similar to hashed.
 
 Configuration example:
 
@@ -108,10 +109,18 @@ This storage method works the same way as hashed and allows using date/time rang
 Example: The table contains discounts for each advertiser in the format:
 
 ```
-+------------------+-----------------------------+------------+----------+  | advertiser id | discount start date | discount end date | amount |  +==================+=============================+============+==========+  | 123              | 2015-01-01                  | 2015-01-15 | 0.15     |  +------------------+-----------------------------+------------+----------+  | 123              | 2015-01-16                  | 2015-01-31 | 0.25     |  +------------------+-----------------------------+------------+----------+  | 456              | 2015-01-01                  | 2015-01-15 | 0.05     |  +------------------+-----------------------------+------------+----------+
+  +---------------+---------------------+-------------------+--------+
+  | advertiser id | discount start date | discount end date | amount |
+  +===============+=====================+===================+========+
+  | 123           | 2015-01-01          | 2015-01-15        | 0.15   |
+  +---------------+---------------------+-------------------+--------+
+  | 123           | 2015-01-16          | 2015-01-31        | 0.25   |
+  +---------------+---------------------+-------------------+--------+
+  | 456           | 2015-01-01          | 2015-01-15        | 0.05   |
+  +---------------+---------------------+-------------------+--------+
 ```
 
-To use a sample for date ranges, define `range_min` and `range_max` in [structure](external_dicts_dict_structure.md#dicts-external_dicts_dict_structure).
+To use a sample for date ranges, define `range_min` and `range_max` in [structure](external_dicts_dict_structure#dicts-external_dicts_dict_structure).
 
 Example:
 
@@ -188,7 +197,7 @@ This is the least effective of all the ways to store dictionaries. The speed of
 
 To improve cache performance, use a subquery with ` LIMIT`, and call the function with the dictionary externally.
 
-Supported [sources](external_dicts_dict_sources.md#dicts-external_dicts_dict_sources): MySQL, ClickHouse, executable, HTTP.
+Supported [sources](external_dicts_dict_sources#dicts-external_dicts_dict_sources): MySQL, ClickHouse, executable, HTTP.
 
 Example of settings:
 
@@ -218,4 +227,66 @@ Do not use ClickHouse as a source, because it is slow to process queries with ra
 
 ### complex_key_cache
 
-This type of storage is designed for use with compound [keys](external_dicts_dict_structure.md#dicts-external_dicts_dict_structure). Similar to `cache`.
+This type of storage is designed for use with compound [keys](external_dicts_dict_structure#dicts-external_dicts_dict_structure). Similar to `cache`.
+
+<a name="dicts-external_dicts_dict_layout-ip_trie"></a>
+
+### ip_trie
+
+
+The table stores IP prefixes for each key (IP address), which makes it possible to map IP addresses to metadata such as ASN or threat score.
+
+Example: in the table there are prefixes matches to AS number and country:
+
+```
+  +-----------------+-------+--------+
+  | prefix          | asn   | cca2   |
+  +=================+=======+========+
+  | 202.79.32.0/20  | 17501 | NP     |
+  +-----------------+-------+--------+
+  | 2620:0:870::/48 | 3856  | US     |
+  +-----------------+-------+--------+
+  | 2a02:6b8:1::/48 | 13238 | RU     |
+  +-----------------+-------+--------+
+  | 2001:db8::/32   | 65536 | ZZ     |
+  +-----------------+-------+--------+
+```
+
+When using such a layout, the structure should have the "key" element.
+
+Example:
+
+```xml
+<structure>
+    <key>
+        <attribute>
+            <name>prefix</name>
+            <type>String</type>
+        </attribute>
+    </key>
+    <attribute>
+            <name>asn</name>
+            <type>UInt32</type>
+            <null_value />
+    </attribute>
+    <attribute>
+            <name>cca2</name>
+            <type>String</type>
+            <null_value>??</null_value>
+    </attribute>
+    ...
+```
+
+These key must have only one attribute of type String, containing a valid IP prefix. Other types are not yet supported.
+
+For querying, same functions (dictGetT with tuple) as for complex key dictionaries have to be used:
+
+    dictGetT('dict_name', 'attr_name', tuple(ip))
+
+The function accepts either UInt32 for IPv4 address or FixedString(16) for IPv6 address in wire format:
+
+    dictGetString('prefix', 'asn', tuple(IPv6StringToNum('2001:db8::1')))
+
+No other type is supported. The function returns attribute for a prefix matching the given IP address. If there are overlapping prefixes, the most specific one is returned.
+
+The data is stored currently in a bitwise trie, it has to fit in memory.
diff --git a/docs/en/getting_started/index.md b/docs/en/getting_started/index.md
index 3d81e359227..42fc1c75551 100644
--- a/docs/en/getting_started/index.md
+++ b/docs/en/getting_started/index.md
@@ -16,7 +16,7 @@ The terminal must use UTF-8 encoding (the default in Ubuntu).
 
 For testing and development, the system can be installed on a single server or on a desktop computer.
 
-### Installing from packages
+### Installing from packages Debian/Ubuntu
 
 In `/etc/apt/sources.list` (or in a separate `/etc/apt/sources.list.d/clickhouse.list` file), add the repository:
 
@@ -24,7 +24,6 @@ In `/etc/apt/sources.list` (or in a separate `/etc/apt/sources.list.d/clickhouse
 deb http://repo.yandex.ru/clickhouse/deb/stable/ main/
 ```
 
-On other versions of Ubuntu, replace `trusty` with `xenial` or `precise`.
 If you want to use the most recent test version, replace 'stable' with 'testing'.
 
 Then run:
diff --git a/docs/en/operations/settings/settings.md b/docs/en/operations/settings/settings.md
index a87328cb06c..e006f302c68 100644
--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@@ -338,15 +338,3 @@ It works for JSONEachRow and TSKV formats.
 ## output_format_json_quote_64bit_integers
 
 If the value is true, integers appear in quotes when using JSON\* Int64 and UInt64 formats  (for compatibility with most JavaScript implementations); otherwise, integers are output without the quotes.
-
-<a name="settings-strict_insert_defaults"></a>
-
-## strict_insert_defaults
-
-Strictly assigns default values when adding data.
-
-If data is not specified for a column when running an [ INSERT](../../query_language/queries.md#queries-insert)  query, ClickHouse assigns default values to the fields. Default values are defined in the ` DEFAULT` property for each column in the table settings. If ` DEFAULT` is not defined for a column:
-
-- `If strict_insert_defaults = 0`, column fields are assigned zeros and empty strings.
-- `If strict_insert_defaults = 1`, ClickHouse throws an exception and requires the user to pass data to the column.
-
diff --git a/docs/en/table_engines/kafka.md b/docs/en/table_engines/kafka.md
index 55d2027309d..85943e44fc5 100644
--- a/docs/en/table_engines/kafka.md
+++ b/docs/en/table_engines/kafka.md
@@ -9,7 +9,7 @@ Kafka lets you:
 - Process streams as they become available.
 
 ```
-Kafka(broker_list, topic_list, group_name, format[, schema])
+Kafka(broker_list, topic_list, group_name, format[, schema, num_consumers])
 ```
 
 Parameters:
@@ -19,6 +19,7 @@ Parameters:
 - `group_name` – A group of Kafka consumers (`group1`). Reading margins are tracked for each group separately. If you don't want messages to be duplicated in the cluster, use the same group name everywhere.
 - `format` – Message format. Uses the same notation as the SQL ` FORMAT` function, such as ` JSONEachRow`. For more information, see the section "Formats".
 - `schema` – An optional parameter that must be used if the format requires a schema definition. For example, [Cap'n Proto](https://capnproto.org/)  requires the path to the schema file and the name of the root ` schema.capnp:Message` object.
+- `num_consumers` - Number of created consumers per engine. By default `1`. Create more consumers if the throughput of a single consumer is insufficient. The total number of consumers shouldn't exceed the number of partitions in given topic, as there can be at most 1 consumers assigned to any single partition.
 
 Example:
 
@@ -77,3 +78,23 @@ To stop receiving topic data or to change the conversion logic, detach the mater
 
 If you want to change the target table by using `ALTER` materialized view, we recommend disabling the material view to avoid discrepancies between the target table and the data from the view.
 
+
+## Configuration
+
+Similarly to GraphiteMergeTree, Kafka engine supports extended configuration through the ClickHouse config file. There are two configuration keys you can use - global (`kafka`), and per-topic (`kafka_topic_*`). The global configuration is applied first, then per-topic configuration (if exists).
+
+```xml
+  <!--  Global configuration options for all tables of Kafka engine type -->
+  <kafka>
+    <debug>cgrp</debug>
+    <auto_offset_reset>smallest</auto_offset_reset>
+  </kafka>
+
+  <!-- Configuration specific for topic "logs" -->
+  <kafka_topic_logs>
+    <retry_backoff_ms>250</retry_backoff_ms>
+    <fetch_min_bytes>100000</fetch_min_bytes>
+  </kafka_topic_logs>
+```
+
+See [librdkafka configuration reference](https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md) for the list of possible configuration options. Use underscores instead of dots in the ClickHouse configuration, for example `check.crcs=true` would correspond to `<check_crcs>true</check_crcs>`.
diff --git a/docs/mkdocs_en.yml b/docs/mkdocs_en.yml
index c94e33c7818..d5fadb3f1e1 100644
--- a/docs/mkdocs_en.yml
+++ b/docs/mkdocs_en.yml
@@ -220,7 +220,7 @@ pages:
   - 'Internal dictionaries': 'dicts/internal_dicts.md'
 
 - 'Operation':
-  - 'Operation': 'operations/index.md'
+#  - 'Operation': 'operations/index.md'
   - 'Access rights': 'operations/access_rights.md'
   - 'Configuration files': 'operations/configuration_files.md'
   - 'Quotas': 'operations/quotas.md'
diff --git a/docs/mkdocs_ru.yml b/docs/mkdocs_ru.yml
index eb8c002847d..931925a2fc1 100644
--- a/docs/mkdocs_ru.yml
+++ b/docs/mkdocs_ru.yml
@@ -84,7 +84,7 @@ pages:
   - 'AggregatingMergeTree': 'table_engines/aggregatingmergetree.md'
   - 'CollapsingMergeTree': 'table_engines/collapsingmergetree.md'
   - 'GraphiteMergeTree': 'table_engines/graphitemergetree.md'
-  - 'Data replication': 'table_engines/replication.md'
+  - 'Репликация данных': 'table_engines/replication.md'
   - 'Distributed': 'table_engines/distributed.md'
   - 'Dictionary': 'table_engines/dictionary.md'
   - 'Merge': 'table_engines/merge.md'
@@ -222,7 +222,7 @@ pages:
   - 'Встроенные словари': 'dicts/internal_dicts.md'
 
 - 'Эксплуатация':
-  - 'Эксплуатация': 'operations/index.md'
+#  - 'Эксплуатация': 'operations/index.md'
   - 'Права доступа': 'operations/access_rights.md'
   - 'Конфигурационные файлы': 'operations/configuration_files.md'
   - 'Квоты': 'operations/quotas.md'
diff --git a/docs/ru/dicts/external_dicts_dict_layout.md b/docs/ru/dicts/external_dicts_dict_layout.md
index e88ddf7c735..ff1b9c0cdd5 100644
--- a/docs/ru/dicts/external_dicts_dict_layout.md
+++ b/docs/ru/dicts/external_dicts_dict_layout.md
@@ -2,11 +2,11 @@
 
 # Хранение словарей в памяти
 
-Словари можно размещать в памяти [множеством способов](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-manner).
+Словари можно размещать в памяти [множеством способов](external_dicts_dict_layout#dicts-external_dicts_dict_layout-manner).
 
-Рекомендуем [flat](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-flat), [hashed](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-hashed) и [complex_key_hashed](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-complex_key_hashed). Скорость обработки словарей при этом максимальна.
+Рекомендуем [flat](external_dicts_dict_layout#dicts-external_dicts_dict_layout-flat), [hashed](external_dicts_dict_layout#dicts-external_dicts_dict_layout-hashed) и [complex_key_hashed](external_dicts_dict_layout#dicts-external_dicts_dict_layout-complex_key_hashed). Скорость обработки словарей при этом максимальна.
 
-Размещение с кэшированием не рекомендуется использовать из-за потенциально низкой производительности и сложностей в подборе оптимальных параметров. Читайте об этом подробнее в разделе " [cache](external_dicts_dict_layout.md#dicts-external_dicts_dict_layout-cache)".
+Размещение с кэшированием не рекомендуется использовать из-за потенциально низкой производительности и сложностей в подборе оптимальных параметров. Читайте об этом подробнее в разделе " [cache](external_dicts_dict_layout#dicts-external_dicts_dict_layout-cache)".
 
 Повысить производительнось словарей можно следующими способами:
 
@@ -46,6 +46,7 @@
 -   [range_hashed](#dicts-external_dicts_dict_layout-range_hashed)
 -   [complex_key_hashed](#dicts-external_dicts_dict_layout-complex_key_hashed)
 -   [complex_key_cache](#dicts-external_dicts_dict_layout-complex_key_cache)
+-   [ip_trie](#dicts-external_dicts_dict_layout-ip_trie)
 
 <a name="dicts-external_dicts_dict_layout-flat"></a>
 
@@ -87,7 +88,7 @@
 
 ### complex_key_hashed
 
-Тип размещения предназначен для использования с составными [ключами](external_dicts_dict_structure.md#dicts-external_dicts_dict_structure). Аналогичен `hashed`.
+Тип размещения предназначен для использования с составными [ключами](external_dicts_dict_structure#dicts-external_dicts_dict_structure). Аналогичен `hashed`.
 
 Пример конфигурации:
 
@@ -119,7 +120,7 @@
   +------------------+-----------------------------+------------+----------+
 ```
 
-Чтобы использовать выборку по диапазонам дат, необходимо в [structure](external_dicts_dict_structure.md#dicts-external_dicts_dict_structure) определить элементы `range_min`, `range_max`.
+Чтобы использовать выборку по диапазонам дат, необходимо в [structure](external_dicts_dict_structure#dicts-external_dicts_dict_structure) определить элементы `range_min`, `range_max`.
 
 Пример:
 
@@ -196,7 +197,7 @@
 
 Чтобы увеличить производительность кэша, используйте подзапрос с `LIMIT`, а снаружи вызывайте функцию со словарём.
 
-Поддерживаются [источники](external_dicts_dict_sources.md#dicts-external_dicts_dict_sources): MySQL, ClickHouse, executable, HTTP.
+Поддерживаются [источники](external_dicts_dict_sources#dicts-external_dicts_dict_sources): MySQL, ClickHouse, executable, HTTP.
 
 Пример настройки:
 
@@ -226,4 +227,65 @@
 
 ### complex_key_cache
 
-Тип размещения предназначен для использования с составными [ключами](external_dicts_dict_structure.md#dicts-external_dicts_dict_structure). Аналогичен `cache`.
+Тип размещения предназначен для использования с составными [ключами](external_dicts_dict_structure#dicts-external_dicts_dict_structure). Аналогичен `cache`.
+
+<a name="dicts-external_dicts_dict_layout-ip_trie"></a>
+
+### ip_trie
+
+Тип размещения предназначен для сопоставления префиксов сети (IP адресов) с метаданными, такими как ASN.
+
+Пример: таблица содержит префиксы сети и соответствующие им номера AS и коды стран:
+
+```
+  +-----------------+-------+--------+
+  | prefix          | asn   | cca2   |
+  +=================+=======+========+
+  | 202.79.32.0/20  | 17501 | NP     |
+  +-----------------+-------+--------+
+  | 2620:0:870::/48 | 3856  | US     |
+  +-----------------+-------+--------+
+  | 2a02:6b8:1::/48 | 13238 | RU     |
+  +-----------------+-------+--------+
+  | 2001:db8::/32   | 65536 | ZZ     |
+  +-----------------+-------+--------+
+```
+
+При использовании такого макета структура должна иметь составной ключ.
+
+Пример:
+
+```xml
+<structure>
+    <key>
+        <attribute>
+            <name>prefix</name>
+            <type>String</type>
+        </attribute>
+    </key>
+    <attribute>
+            <name>asn</name>
+            <type>UInt32</type>
+            <null_value />
+    </attribute>
+    <attribute>
+            <name>cca2</name>
+            <type>String</type>
+            <null_value>??</null_value>
+    </attribute>
+    ...
+```
+
+Этот ключ должен иметь только один атрибут типа String, содержащий допустимый префикс IP. Другие типы еще не поддерживаются.
+
+Для запросов необходимо использовать те же функции (`dictGetT` с кортежем), что и для словарей с составными ключами:
+
+    dictGetT('dict_name', 'attr_name', tuple(ip))
+
+Функция принимает либо UInt32 для адреса IPv4, либо FixedString(16) для адреса IPv6:
+
+    dictGetString('prefix', 'asn', tuple(IPv6StringToNum('2001:db8::1')))
+
+Никакие другие типы не поддерживаются. Функция возвращает атрибут для префикса, соответствующего данному IP-адресу. Если есть перекрывающиеся префиксы, возвращается наиболее специфический.
+
+Данные хранятся в побитовом дереве (trie), он должены полностью помещаться в оперативной памяти.
diff --git a/docs/ru/getting_started/index.md b/docs/ru/getting_started/index.md
index be4ce4f0333..3847663b3d5 100644
--- a/docs/ru/getting_started/index.md
+++ b/docs/ru/getting_started/index.md
@@ -16,7 +16,7 @@ grep -q sse4_2 /proc/cpuinfo && echo "SSE 4.2 supported" || echo "SSE 4.2 not su
 
 В целях тестирования и разработки, система может быть установлена на один сервер или на рабочий компьютер.
 
-### Установка из пакетов
+### Установка из пакетов для Debian/Ubuntu 
 
 Пропишите в `/etc/apt/sources.list` (или в отдельный файл `/etc/apt/sources.list.d/clickhouse.list`) репозитории:
 
@@ -24,7 +24,6 @@ grep -q sse4_2 /proc/cpuinfo && echo "SSE 4.2 supported" || echo "SSE 4.2 not su
 deb http://repo.yandex.ru/clickhouse/deb/stable/ main/
 ```
 
-На других версиях Ubuntu, замените `trusty` на `xenial` или `precise`.
 Если вы хотите использовать наиболее свежую тестовую версию, замените stable на testing.
 
 Затем выполните:
diff --git a/docs/ru/operations/settings/query_complexity.md b/docs/ru/operations/settings/query_complexity.md
index 83251f6813c..afbba3bc688 100644
--- a/docs/ru/operations/settings/query_complexity.md
+++ b/docs/ru/operations/settings/query_complexity.md
@@ -27,21 +27,40 @@
 
 При использовании метода GET HTTP интерфейса, автоматически выставляется readonly = 1. То есть, для запросов, модифицирующие данные, можно использовать только метод POST. Сам запрос при этом можно отправлять как в теле POST-а, так и в параметре URL.
 
+<a name="settings_max_memory_usage"></a>
+
 ## max_memory_usage
 
-Максимальное количество потребляемой памяти при выполнении запроса на одном сервере. По умолчанию - 10 GB.
+Максимальный возможный объем оперативной памяти для выполнения запроса на одном сервере.
+
+В конфигурационном файле по-умолчанию, ограничение равно 10 ГБ.
 
 Настройка не учитывает объём свободной памяти или общий объём памяти на машине.
 Ограничение действует на один запрос, в пределах одного сервера.
-Текущее потребление оперативки для каждого запроса можно посмотреть с помощью SHOW PROCESSLIST.
-Также отслеживается пиковое потребление оперативки для каждого запроса, и выводится в лог.
+Текущее потребление памяти для каждого запроса можно посмотреть с помощью `SHOW PROCESSLIST`.
+Также отслеживается и выводится в лог пиковое потребление памяти для каждого запроса.
 
-Некоторые случаи потребления оперативки не отслеживаются:
+Потребление памяти не отслеживается для состояний некоторых агрегатных функций.
 
--   большие константы (например, очень длинная константная строка);
--   состояния некоторых агрегатных функций;
+Потребление памяти не полностью учитывается для состояний агрегатных функций `min`, `max`, `any`, `anyLast`, `argMin`, `argMax` от аргументов `String` и `Array`.
 
-Потребление оперативки не полностью учитывается для состояний агрегатных функций min, max, any, anyLast, argMin, argMax от аргументов String и Array.
+Потребление памяти ограничивается также параметрами `max_memory_usage_for_user` и `max_memory_usage_for_all_queries`.
+
+## max_memory_usage_for_user
+
+Максимальный возможный объем оперативной памяти для запросов пользователя на одном сервере.
+
+Значения по умолчанию определены в файле [Settings.h](https://github.com/yandex/ClickHouse/blob/master/dbms/src/Interpreters/Settings.h#L244). По умолчанию размер не ограничен (`max_memory_usage_for_user = 0`).
+
+Смотрите также описание настройки [max_memory_usage](#settings_max_memory_usage).
+
+## max_memory_usage_for_all_queries
+
+Максимальный возможный объем оперативной памяти для всех запросов на одном сервере.
+
+Значения по умолчанию определены в файле [Settings.h](https://github.com/yandex/ClickHouse/blob/master/dbms/src/Interpreters/Settings.h#L245). По умолчанию размер не ограничен (`max_memory_usage_for_all_queries = 0`).
+
+Смотрите также описание настройки [max_memory_usage](#settings_max_memory_usage).
 
 ## max_rows_to_read
 
diff --git a/docs/ru/operations/settings/settings.md b/docs/ru/operations/settings/settings.md
index 624dadcf096..62d183234a4 100644
--- a/docs/ru/operations/settings/settings.md
+++ b/docs/ru/operations/settings/settings.md
@@ -335,15 +335,3 @@ ClickHouse применяет настройку в том случае, ког
 ## output_format_json_quote_64bit_integers
 
 Если значение истинно, то при использовании JSON\* форматов UInt64 и Int64 числа выводятся в кавычках (из соображений совместимости с большинством реализаций JavaScript), иначе - без кавычек.
-
-<a name="settings-strict_insert_defaults"></a>
-
-## strict_insert_defaults
-
-Строгое присвоение значений по умолчанию при добавлении данных.
-
-Если при выполнении запроса [INSERT](../../query_language/queries.md#queries-insert) данные для столбца не заданы, то ClickHouse присваивает полям значения по умолчанию. Значения по умолчанию определяются свойством `DEFAULT` для каждого столбца в настройках таблицы. Если для столбца не определен `DEFAULT`, то когда:
-
--   `strict_insert_defaults=0` - полям столбца присваиваются нули и пустые строки.
--   `strict_insert_defaults=1` - ClickHouse генерирует исключение и обязывает пользователя передать данные в столбец.
-
diff --git a/docs/ru/query_language/queries.md b/docs/ru/query_language/queries.md
index 53063705410..c5a1d46273e 100644
--- a/docs/ru/query_language/queries.md
+++ b/docs/ru/query_language/queries.md
@@ -76,7 +76,7 @@ CREATE [TEMPORARY] TABLE [IF NOT EXISTS] [db.]name ENGINE = engine AS SELECT ...
 Его значения не могут быть вставлены в таблицу, он не подставляется при использовании звёздочки в запросе SELECT.
 Он может быть использован в SELECT-ах - в таком случае, во время разбора запроса, алиас раскрывается.
 
-При добавлении новых столбцов с помощью запроса ALTER, старые данные для этих столбцов не записываются. Вместо этого, при чтении старых данных, для которых отсутствуют значения новых столбцов, выполняется вычисление выражений по умолчанию налету. При этом, если выполнение выражения требует использования других столбцов, не указанных в запросе, то эти столбцы будут дополнительно прочитаны, но только для тех блоков данных, для которых это необходимо.
+При добавлении новых столбцов с помощью запроса ALTER, старые данные для этих столбцов не записываются. Вместо этого, при чтении старых данных, для которых отсутствуют значения новых столбцов, выполняется вычисление выражений по умолчанию на лету. При этом, если выполнение выражения требует использования других столбцов, не указанных в запросе, то эти столбцы будут дополнительно прочитаны, но только для тех блоков данных, для которых это необходимо.
 
 Если добавить в таблицу новый столбец, а через некоторое время изменить его выражение по умолчанию, то используемые значения для старых данных (для данных, где значения не хранились на диске) поменяются. Также заметим, что при выполнении фоновых слияний, данные для столбцов, отсутствующих в одном из сливаемых кусков, записываются в объединённый кусок.
 
diff --git a/docs/ru/table_engines/kafka.md b/docs/ru/table_engines/kafka.md
index 127820a8ef2..8225192e337 100644
--- a/docs/ru/table_engines/kafka.md
+++ b/docs/ru/table_engines/kafka.md
@@ -9,7 +9,7 @@ Kafka позволяет:
 - Обрабатывать потоки по мере их появления.
 
 ```
-Kafka(broker_list, topic_list, group_name, format[, schema])
+Kafka(broker_list, topic_list, group_name, format[, schema, num_consumers])
 ```
 
 Параметры:
@@ -19,6 +19,7 @@ Kafka(broker_list, topic_list, group_name, format[, schema])
 - `group_name` - Группа потребителя Kafka (`group1`). Отступы для чтения отслеживаются для каждой группы отдельно. Если необходимо, чтобы сообщения не повторялись на кластере, используйте везде одно имя группы.
 - `format` - Формат сообщений. Имеет те же обозначения, что выдает SQL-выражение `FORMAT`, например, `JSONEachRow`. Подробнее смотрите в разделе "Форматы".
 - `schema` - Опциональный параметр, необходимый, если используется формат, требующий определения схемы. Например, [Cap'n Proto](https://capnproto.org/) требует путь к файлу со схемой и название корневого объекта `schema.capnp:Message`.
+- `num_consumers` - Количество потребителей (consumer) на таблицу. По умолчанию `1`. Укажите больше потребителей, если пропускная способность одного потребителя недостаточна. Общее число потребителей не должно превышать количество партиций в топике, так как на одну партицию может быть назначено не более одного потребителя.
 
 Пример:
 
@@ -75,4 +76,25 @@ Kafka(broker_list, topic_list, group_name, format[, schema])
   ATTACH MATERIALIZED VIEW consumer;
 ```
 
-Если необходимо изменить целевую таблицу с помощью `ALTER`, то материализованное представление рекомендуется отключить, чтобы избежать несостыковки между целевой таблицей и данными от представления.
\ No newline at end of file
+Если необходимо изменить целевую таблицу с помощью `ALTER`, то материализованное представление рекомендуется отключить, чтобы избежать несостыковки между целевой таблицей и данными от представления.
+
+
+## Конфигурация
+
+Аналогично GraphiteMergeTree, движок Kafka поддерживает расширенную конфигурацию с помощью конфигурационного файла ClickHouse. Существует два конфигурационных ключа, которые можно использовать - глобальный (`kafka`) и по топикам (`kafka_topic_*`). Сначала применяется глобальная конфигурация, затем конфигурация по топикам (если она существует).
+
+```xml
+  <!--  Global configuration options for all tables of Kafka engine type -->
+  <kafka>
+    <debug>cgrp</debug>
+    <auto_offset_reset>smallest</auto_offset_reset>
+  </kafka>
+
+  <!-- Configuration specific for topic "logs" -->
+  <kafka_topic_logs>
+    <retry_backoff_ms>250</retry_backoff_ms>
+    <fetch_min_bytes>100000</fetch_min_bytes>
+  </kafka_topic_logs>
+```
+
+В документе [librdkafka configuration reference](https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md) можно увидеть список возможных опций конфигурации. Используйте подчёркивания (`_`) вместо точек в конфигурации ClickHouse, например, `check.crcs=true` будет соответствовать `<check_crcs>true</check_crcs>`.
\ No newline at end of file
diff --git a/docs/ru/table_engines/merge.md b/docs/ru/table_engines/merge.md
index b3d9ced8f89..1124e54b5bb 100644
--- a/docs/ru/table_engines/merge.md
+++ b/docs/ru/table_engines/merge.md
@@ -2,33 +2,33 @@
 
 Движок Merge (не путайте с движком `MergeTree`) не хранит данные самостоятельно, а позволяет читать одновременно из произвольного количества других таблиц.
 Чтение автоматически распараллеливается. Запись в таблицу не поддерживается. При чтении будут использованы индексы тех таблиц, из которых реально идёт чтение, если они существуют.
-Движок Merge принимает параметры: имя базы данных и регулярное выражение для таблиц. Пример:
+Движок Merge принимает параметры: имя базы данных и регулярное выражение для таблиц. Пример.
 
 ```text
 Merge(hits, '^WatchLog')
 ```
 
--   данные будут читаться из таблиц в базе hits, имена которых соответствуют регулярному выражению '`^WatchLog`'.
+Данные будут читаться из таблиц в базе hits, имена которых соответствуют регулярному выражению '`^WatchLog`'.
 
 Вместо имени базы данных может использоваться константное выражение, возвращающее строку. Например, `currentDatabase()`.
 
-Регулярные выражения - re2 (как PCRE, но без особых извратов), регистрозависимые.
+Регулярные выражения — [re2](https://github.com/google/re2) (поддерживает подмножество PCRE), регистрозависимые.
 Смотрите замечание об экранировании в регулярных выражениях в разделе "match".
 
-При выборе таблиц для чтения, сама Merge-таблица не будет выбрана, даже если попадает под регулярное выражение - чтобы не возникло циклов.
-Впрочем, вы можете создать две Merge-таблицы, которые будут пытаться бесконечно читать данные друг-друга. Этого делать не нужно.
+При выборе таблиц для чтения, сама Merge-таблица не будет выбрана, даже если попадает под регулярное выражение, чтобы не возникло циклов.
+Впрочем, вы можете создать две Merge-таблицы, которые будут пытаться бесконечно читать данные друг друга, но делать этого не нужно.
 
-Типичный способ использования движка Merge - возможность работы с большим количеством таблиц типа TinyLog, как с одной.
+Типичный способ использования движка Merge — работа с большим количеством таблиц типа TinyLog, как с одной.
 
 ## Виртуальные столбцы
 
-Виртуальные столбцы - столбцы, предоставляемые движком таблиц, независимо от определения таблицы. То есть, такие столбцы не указываются в CREATE TABLE, но доступны для SELECT-а.
+Виртуальные столбцы — столбцы, предоставляемые движком таблиц независимо от определения таблицы. То есть, такие столбцы не указываются в CREATE TABLE, но доступны для SELECT-а.
 
 Виртуальные столбцы отличаются от обычных следующими особенностями:
 
 -   они не указываются в определении таблицы;
 -   в них нельзя вставить данные при INSERT-е;
--   при INSERT-е без указания списка столбцов, виртуальные столбцы не учитываются;
+-   при INSERT-е без указания списка столбцов виртуальные столбцы не учитываются;
 -   они не выбираются при использовании звёздочки (`SELECT *`);
 -   виртуальные столбцы не показываются в запросах `SHOW CREATE TABLE` и `DESC TABLE`;
 
diff --git a/docs/ru/table_engines/mergetree.md b/docs/ru/table_engines/mergetree.md
index 4da83967e26..714d368909d 100644
--- a/docs/ru/table_engines/mergetree.md
+++ b/docs/ru/table_engines/mergetree.md
@@ -2,45 +2,45 @@
 
 # MergeTree
 
-Движок MergeTree поддерживает индекс по первичному ключу и по дате, и обеспечивает возможность обновления данных в реальном времени.
+Движок MergeTree поддерживает индекс по первичному ключу и по дате и обеспечивает возможность обновления данных в реальном времени.
 Это наиболее продвинутый движок таблиц в ClickHouse. Не путайте с движком Merge.
 
-Движок принимает параметры: имя столбца типа Date, содержащего дату; выражение для семплирования (не обязательно); кортеж, определяющий первичный ключ таблицы; гранулированность индекса. Пример:
+Движок принимает параметры: имя столбца типа Date, содержащего дату; выражение для семплирования (не обязательно); кортеж, определяющий первичный ключ таблицы; гранулированность индекса.
 
-Пример без поддержки сэмплирования:
+Пример без поддержки сэмплирования.
 
 ```text
 MergeTree(EventDate, (CounterID, EventDate), 8192)
 ```
 
-Пример с поддержкой сэмплирования:
+Пример с поддержкой сэмплирования.
 
 ```text
 MergeTree(EventDate, intHash32(UserID), (CounterID, EventDate, intHash32(UserID)), 8192)
 ```
 
-В таблице типа MergeTree обязательно должен быть отдельный столбец, содержащий дату. В этом примере, это - столбец EventDate. Тип столбца с датой - обязательно Date (а не DateTime).
+В таблице типа MergeTree обязательно должен быть отдельный столбец, содержащий дату, здесь это столбец EventDate. Тип столбца с датой — обязательно Date (а не DateTime).
 
 Первичным ключом может быть кортеж из произвольных выражений (обычно это просто кортеж столбцов) или одно выражение.
 
-Выражение для сэмплирования (использовать не обязательно) - произвольное выражение. Оно должно также присутствовать в первичном ключе. В примере используется хэширование по идентификатору посетителя, чтобы псевдослучайно перемешать данные в таблице для каждого CounterID и EventDate. То есть, при использовании секции SAMPLE в запросе, вы получите равномерно-псевдослучайную выборку данных для подмножества посетителей.
+Выражение для сэмплирования (использовать не обязательно) — произвольное выражение. Оно должно также присутствовать в первичном ключе. В примере используется хэширование по идентификатору посетителя, чтобы псевдослучайно перемешать данные в таблице для каждого CounterID и EventDate. То есть, при использовании секции SAMPLE в запросе вы получите равномерно-псевдослучайную выборку данных для подмножества посетителей.
 
-Таблица реализована, как набор кусочков. Каждый кусочек сортирован по первичному ключу. Также, для каждого кусочка прописана минимальная и максимальная дата. При вставке в таблицу, создаётся новый сортированный кусочек. В фоне, периодически инициируется процесс слияния. При слиянии, выбирается несколько кусочков, обычно наименьших, и сливаются в один большой сортированный кусочек.
+Таблица реализована как набор кусочков. Каждый кусочек сортирован по первичному ключу. Также для каждого кусочка прописана минимальная и максимальная дата. При вставке в таблицу создаётся новый сортированный кусочек. В фоне периодически инициируется процесс слияния. При слиянии выбирается несколько кусочков, обычно наименьших, и сливаются в один большой сортированный кусочек.
 
 То есть, при вставке в таблицу производится инкрементальная сортировка. Слияние реализовано таким образом, что таблица постоянно состоит из небольшого количества сортированных кусочков, а также само слияние делает не слишком много работы.
 
-При вставке, данные относящиеся к разным месяцам, разбиваются на разные кусочки. Кусочки, соответствующие разным месяцам, никогда не объединяются. Это сделано, чтобы обеспечить локальность модификаций данных (для упрощения бэкапов).
+При вставке данные, относящиеся к разным месяцам, разбиваются на разные кусочки. Кусочки, соответствующие разным месяцам, никогда не объединяются. Это сделано, чтобы обеспечить локальность модификаций данных (для упрощения бэкапов).
 
-Кусочки объединяются до некоторого предельного размера - чтобы не было слишком длительных слияний.
+Кусочки объединяются до некоторого предельного размера, чтобы не было слишком длительных слияний.
 
-Для каждого кусочка также пишется индексный файл. Индексный файл содержит значение первичного ключа для каждой index_granularity строки таблицы. То есть, это - разреженный индекс сортированных данных.
+Для каждого кусочка также пишется индексный файл. Индексный файл содержит значение первичного ключа для каждой index_granularity строки таблицы. То есть, это разреженный индекс сортированных данных.
 
-Для столбцов также пишутся "засечки" каждую index_granularity строку, чтобы данные можно было читать в определённом диапазоне.
+Для столбцов также пишутся «засечки» каждую index_granularity строку, чтобы данные можно было читать в определённом диапазоне.
 
 При чтении из таблицы, запрос SELECT анализируется на предмет того, можно ли использовать индексы.
 Индекс может использоваться, если в секции WHERE/PREWHERE, в качестве одного из элементов конъюнкции, или целиком, есть выражение, представляющее операции сравнения на равенства, неравенства, а также IN над столбцами, входящими в первичный ключ / дату, а также логические связки над ними.
 
-Таким образом, обеспечивается возможность быстро выполнять запросы по одному или многим диапазонам первичного ключа. Например, в указанном примере, будут быстро работать запросы для конкретного счётчика; для конкретного счётчика и диапазона дат; для конкретного счётчика и даты, для нескольких счётчиков и диапазона дат и т. п.
+Таким образом, обеспечивается возможность быстро выполнять запросы по одному или многим диапазонам первичного ключа. Например, в указанном примере будут быстро работать запросы для конкретного счётчика; для конкретного счётчика и диапазона дат; для конкретного счётчика и даты, для нескольких счётчиков и диапазона дат и т. п.
 
 ```sql
 SELECT count() FROM table WHERE EventDate = toDate(now()) AND CounterID = 34
@@ -50,22 +50,22 @@ SELECT count() FROM table WHERE ((EventDate >= toDate('2014-01-01') AND EventDat
 
 Во всех этих случаях будет использоваться индекс по дате и по первичному ключу. Видно, что индекс используется даже для достаточно сложных выражений. Чтение из таблицы организовано так, что использование индекса не может быть медленнее full scan-а.
 
-В этом примере, индекс не может использоваться:
+В этом примере индекс не может использоваться.
 
 ```sql
 SELECT count() FROM table WHERE CounterID = 34 OR URL LIKE '%upyachka%'
 ```
 
-Чтобы проверить сможет ли ClickHouse использовать индекс при выполнении запроса, используйте настройки [force_index_by_date](../operations/settings/settings.md#settings-settings-force_index_by_date) и [force_primary_key](../operations/settings/settings.md#settings-settings-force_primary_key).
+Чтобы проверить, сможет ли ClickHouse использовать индекс при выполнении запроса, используйте настройки [force_index_by_date](../operations/settings/settings.md#settings-settings-force_index_by_date) и [force_primary_key](../operations/settings/settings.md#settings-settings-force_primary_key).
 
-Индекс по дате обеспечивает чтение только кусков, содержащих даты из нужного диапазона. При этом, кусок данных может содержать данные за многие даты (до целого месяца), а в пределах одного куска, данные лежат упорядоченными по первичному ключу, который может не содержать дату в качестве первого столбца. В связи с этим, при использовании запроса с указанием условия только на дату, но не на префикс первичного ключа, будет читаться данных больше, чем за одну дату.
+Индекс по дате обеспечивает чтение только кусков, содержащих даты из нужного диапазона. При этом кусок данных может содержать данные за многие даты (до целого месяца), а в пределах одного куска данные лежат упорядоченными по первичному ключу, который может не содержать дату в качестве первого столбца. В связи с этим, при использовании запроса с указанием условия только на дату, но не на префикс первичного ключа, будет читаться данных больше, чем за одну дату.
 
-Для конкуррентного доступа к таблице, используется мульти-версионность. То есть, при одновременном чтении и обновлении таблицы, данные будут читаться из набора кусочков, актуального на момент запроса. Длинных блокировок нет. Вставки никак не мешают чтениям.
+Для конкуррентного доступа к таблице используется мультиверсионность. То есть, при одновременном чтении и обновлении таблицы, данные будут читаться из набора кусочков, актуального на момент запроса. Длинных блокировок нет. Вставки никак не мешают чтениям.
 
 Чтения из таблицы автоматически распараллеливаются.
 
 Поддерживается запрос `OPTIMIZE`, который вызывает один внеочередной шаг слияния.
 
-Вы можете использовать одну большую таблицу, постоянно добавляя в неё данные небольшими пачками - именно для этого предназначен движок MergeTree.
+Вы можете использовать одну большую таблицу, постоянно добавляя в неё данные небольшими пачками, именно для этого предназначен движок MergeTree.
 
-Для всех типов таблиц семейства MergeTree возможна репликация данных - смотрите раздел "Репликация данных".
+Для всех типов таблиц семейства MergeTree возможна репликация данных — смотрите раздел «Репликация данных».
diff --git a/docs/ru/table_engines/replacingmergetree.md b/docs/ru/table_engines/replacingmergetree.md
index 4c86b489f99..8e09810ca2b 100644
--- a/docs/ru/table_engines/replacingmergetree.md
+++ b/docs/ru/table_engines/replacingmergetree.md
@@ -2,15 +2,15 @@
 
 Движок таблиц отличается от `MergeTree` тем, что выполняет удаление дублирующихся записей с одинаковым значением первичного ключа.
 
-Последний, необязательный параметр движка таблицы - столбец с "версией". При слиянии, для всех строк с одинаковым значением первичного ключа, оставляет только одну строку: если задан столбец версии - строку с максимальной версией, иначе - последнюю строку.
+Последний, необязательный параметр движка таблицы — столбец с версией. При слиянии для всех строк с одинаковым значением первичного ключа оставляет только одну строку: если задан столбец версии — строку с максимальной версией, иначе — последнюю строку.
 
-Столбец с версией должен иметь тип из семейства `UInt`, либо `Date` или `DateTime`.
+Столбец с версией должен иметь тип из семейства `UInt`, или `Date`, или `DateTime`.
 
 ```sql
 ReplacingMergeTree(EventDate, (OrderID, EventDate, BannerID, ...), 8192, ver)
 ```
 
-Обратите внимание, что дедупликация данных производится лишь во время слияний. Слияние происходят в фоне, в неизвестный момент времени, на который вы не можете ориентироваться. Некоторая часть данных может так и остаться необработанной. Хотя вы можете вызвать внеочередное слияние с помощью запроса OPTIMIZE, на это не стоит рассчитывать, так как запрос OPTIMIZE приводит к чтению и записи большого объёма данных.
+Обратите внимание, что дедупликация данных производится лишь во время слияний. Слияние происходят в фоне в неизвестный момент времени, на который вы не можете ориентироваться. Некоторая часть данных может так и остаться необработанной. Хотя вы можете вызвать внеочередное слияние с помощью запроса OPTIMIZE, на это не стоит рассчитывать, так как запрос OPTIMIZE приводит к чтению и записи большого объёма данных.
 
 Таким образом, `ReplacingMergeTree` подходит для фоновой чистки дублирующихся данных в целях экономии места, но не даёт гарантий отсутствия дубликатов.
 
diff --git a/docs/ru/table_engines/replication.md b/docs/ru/table_engines/replication.md
index f76f7644a77..30d8882d4eb 100644
--- a/docs/ru/table_engines/replication.md
+++ b/docs/ru/table_engines/replication.md
@@ -2,26 +2,28 @@
 
 # Репликация данных
 
-## ReplicatedAggregatingMergeTree
+Репликация поддерживается только для таблиц семейства MergeTree:
 
-## ReplicatedCollapsingMergeTree
+- ReplicatedMergeTree
+- ReplicatedSummingMergeTree
+- ReplicatedReplacingMergeTree
+- ReplicatedAggregatingMergeTree
+- ReplicatedCollapsingMergeTree
+- ReplicatedGraphiteMergeTree
 
-## ReplicatedGraphiteMergeTree
+Репликация работает на уровне отдельных таблиц, а не всего сервера. То есть, на сервере могут быть расположены одновременно реплицируемые и не реплицируемые таблицы.
 
-## ReplicatedMergeTree
+Репликация не зависит от шардирования. На каждом шарде репликация работает независимо.
 
-## ReplicatedReplacingMergeTree
+Реплицируются сжатые данные запросов `INSERT`, `ALTER` (см. подробности в описании запроса [ALTER](../query_language/queries.md#query_language_queries_alter)).
 
-## ReplicatedSummingMergeTree
+Запросы `CREATE`, `DROP`, `ATTACH`, `DETACH`, `RENAME` выполняются на одном сервере и не реплицируются:
 
-Репликация поддерживается только для таблиц семейства MergeTree. Репликация работает на уровне отдельных таблиц, а не всего сервера. То есть, на сервере могут быть расположены одновременно реплицируемые и не реплицируемые таблицы.
+- `CREATE TABLE` создаёт новую реплицируемую таблицу на том сервере, где выполняется запрос, а если на других серверах такая таблица уже есть - добавляет новую реплику.
+- `DROP TABLE` удаляет реплику, расположенную на том сервере, где выполняется запрос.
+- `RENAME` переименовывает таблицу на одной из реплик - то есть, реплицируемые таблицы на разных репликах могут называться по разному.
 
-Реплицируются INSERT, ALTER (см. подробности в описании запроса ALTER). Реплицируются сжатые данные, а не тексты запросов.
-Запросы CREATE, DROP, ATTACH, DETACH, RENAME не реплицируются - то есть, относятся к одному серверу. Запрос CREATE TABLE создаёт новую реплицируемую таблицу на том сервере, где выполняется запрос; а если на других серверах такая таблица уже есть - добавляет новую реплику. Запрос DROP TABLE удаляет реплику, расположенную на том сервере, где выполняется запрос. Запрос RENAME переименовывает таблицу на одной из реплик - то есть, реплицируемые таблицы на разных репликах могут называться по разному.
-
-Репликация никак не связана с шардированием. На каждом шарде репликация работает независимо.
-
-Репликация является опциональной возможностью. Для использования репликации, укажите в конфигурационном файле адреса ZooKeeper кластера. Пример:
+Чтобы использовать репликацию, укажите в конфигурационном файле адреса ZooKeeper кластера. Пример:
 
 ```xml
 <zookeeper>
@@ -40,25 +42,25 @@
 </zookeeper>
 ```
 
-**Используйте версию ZooKeeper не старее 3.4.5.** Для примера, в Ubuntu Precise слишком старая версия в пакете.
+Используйте ZooKeeper версии 3.4.5 или более новый.
 
 Можно указать любой имеющийся у вас ZooKeeper-кластер - система будет использовать в нём одну директорию для своих данных (директория указывается при создании реплицируемой таблицы).
 
 Если в конфигурационном файле не настроен ZooKeeper, то вы не сможете создать реплицируемые таблицы, а уже имеющиеся реплицируемые таблицы будут доступны в режиме только на чтение.
 
-При запросах SELECT, ZooKeeper не используется. То есть, репликация никак не влияет на производительность SELECT-ов - запросы работают так же быстро, как и для нереплицируемых таблиц. При запросах к распределенным реплицированным таблицам поведение ClickHouse регулируется настройками [max_replica_delay_for_distributed_queries](../operations/settings/settings.md#settings_settings_max_replica_delay_for_distributed_queries) и [fallback_to_stale_replicas_for_distributed_queries](../operations/settings/settings.md#settings-settings-fallback_to_stale_replicas_for_distributed_queries).
+При запросах `SELECT`, ZooKeeper не используется, т.е. репликация не влияет на производительность `SELECT` и запросы работают так же быстро, как и для нереплицируемых таблиц. При запросах к распределенным реплицированным таблицам поведение ClickHouse регулируется настройками [max_replica_delay_for_distributed_queries](../operations/settings/settings.md#settings_settings_max_replica_delay_for_distributed_queries) и [fallback_to_stale_replicas_for_distributed_queries](../operations/settings/settings.md#settings-settings-fallback_to_stale_replicas_for_distributed_queries).
 
-При каждом запросе INSERT (точнее, на каждый вставляемый блок данных; запрос INSERT содержит один блок, или по блоку на каждые max_insert_block_size = 1048576 строк), делается около десятка записей в ZooKeeper в рамках нескольких транзакций. Это приводит к некоторому увеличению задержек при INSERT-е, по сравнению с нереплицируемыми таблицами. Но если придерживаться обычных рекомендаций - вставлять данные пачками не более одного INSERT-а в секунду, то это не составляет проблем. На всём кластере ClickHouse, использующим для координации один кластер ZooKeeper, может быть в совокупности несколько сотен INSERT-ов в секунду. Пропускная способность при вставке данных (количество строчек в секунду) такая же высокая, как для нереплицируемых таблиц.
+При каждом запросе `INSERT` (точнее, на каждый вставляемый блок данных; запрос INSERT содержит один блок, или по блоку на каждые `max_insert_block_size = 1048576` строк), делается около десятка записей в ZooKeeper в рамках нескольких транзакций. Это приводит к некоторому увеличению задержек при `INSERT`, по сравнению с нереплицируемыми таблицами. Но если придерживаться обычных рекомендаций - вставлять данные пачками не более одного `INSERT` в секунду, то это не составляет проблем. На всём кластере ClickHouse, использующим для координации один кластер ZooKeeper, может быть в совокупности несколько сотен `INSERT` в секунду. Пропускная способность при вставке данных (количество строчек в секунду) такая же высокая, как для нереплицируемых таблиц.
 
 Для очень больших кластеров, можно использовать разные кластеры ZooKeeper для разных шардов. Впрочем, на кластере Яндекс.Метрики (примерно 300 серверов) такой необходимости не возникает.
 
-Репликация асинхронная, мульти-мастер. Запросы INSERT (а также ALTER) можно отправлять на любой доступный сервер. Данные вставятся на этот сервер, а затем приедут на остальные серверы. В связи с асинхронностью, только что вставленные данные, появляются на остальных репликах с небольшой задержкой. Если часть реплик недоступна - данные на них запишутся тогда, когда они станут доступны. Если реплика доступна, то задержка составляет столько времени, сколько требуется для передачи блока сжатых данных по сети.
+Репликация асинхронная, мульти-мастер. Запросы `INSERT` (а также `ALTER`) можно отправлять на любой доступный сервер. Данные вставятся на сервер, где выполнен запрос, а затем скопируются на остальные серверы. В связи с асинхронностью, только что вставленные данные появляются на остальных репликах с небольшой задержкой. Если часть реплик недоступна, данные на них запишутся тогда, когда они станут доступны. Если реплика доступна, то задержка составляет столько времени, сколько требуется для передачи блока сжатых данных по сети.
 
-Кворумная запись отсутствует. То есть, вы не можете записать данные с подтверждением их получения более одной репликой. Если вы записали пачку данных на одну реплику, и данные ещё не успели разъехаться по остальным репликам, после чего сервер с этими данными перестал существовать, то эта пачка данных будет потеряна.
+По-умолчанию, запрос INSERT ждёт подтверждения записи только от одной реплики. Если данные были успешно записаны только на одну реплику, и сервер с этой репликой перестал существовать, то записанные данные будут потеряны. Вы можете включить подтверждение записи от нескольких реплик, используя настройку `insert_quorum`.
 
-Каждый блок данных записывается атомарно. Запрос INSERT разбивается на блоки данных размером до max_insert_block_size = 1048576 строк. То есть, если в запросе INSERT менее 1048576 строк, то он делается атомарно.
+Каждый блок данных записывается атомарно. Запрос INSERT разбивается на блоки данных размером до `max_insert_block_size = 1048576` строк. То есть, если в запросе `INSERT` менее 1048576 строк, то он делается атомарно.
 
-Блоки данных дедуплицируются. При многократной записи одного и того же блока данных (блоков данных одинакового размера, содержащих одни и те же строчки в одном и том же порядке), блок будет записан только один раз. Это сделано для того, чтобы в случае сбоя в сети, когда клиентское приложение не может понять, были ли данные записаны в БД, можно было просто повторить запрос INSERT. При этом не имеет значения, на какую реплику будут отправлены INSERT-ы с одинаковыми данными. То есть, обеспечивается идемпотентность INSERT-ов. Это работает только для последних 100 вставленных в таблицу блоков.
+Блоки данных дедуплицируются. При многократной записи одного и того же блока данных (блоков данных одинакового размера, содержащих одни и те же строчки в одном и том же порядке), блок будет записан только один раз. Это сделано для того, чтобы в случае сбоя в сети, когда клиентское приложение не может понять, были ли данные записаны в БД, можно было просто повторить запрос `INSERT`. При этом не имеет значения, на какую реплику будут отправлены INSERT-ы с одинаковыми данными. То есть, обеспечивается идемпотентность `INSERT`. Параметры дедупликации регулируются настройками сервера [merge_tree](../operations/server_settings/settings.md#server_settings-merge_tree).
 
 При репликации, по сети передаются только исходные вставляемые данные. Дальнейшие преобразования данных (слияния) координируются и делаются на всех репликах одинаковым образом. За счёт этого минимизируется использование сети, и благодаря этому, репликация хорошо работает при расположении реплик в разных датацентрах. (Стоит заметить, что дублирование данных в разных датацентрах, по сути, является основной задачей репликации).
 
@@ -101,19 +103,21 @@ ReplicatedMergeTree('/clickhouse/tables/{layer}-{shard}/hits', '{replica}', Even
 
 Имя реплики - то, что идентифицирует разные реплики одной и той же таблицы. Можно использовать для него имя сервера, как показано в примере. Впрочем, достаточно, чтобы имя было уникально лишь в пределах каждого шарда.
 
-Можно не использовать подстановки, а прописать всё явно. Это может быть удобным для тестирования и при настройке маленьких кластеров, но менее удобным при работе с большими кластерами.
+Можно не использовать подстановки, а указать соответствующие параметры явно. Это может быть удобным для тестирования и при настройке маленьких кластеров. Однако в этом случае нельзя пользоваться распределенными DDL-запросами (`ON CLUSTER`).
 
-Выполните запрос CREATE TABLE на каждой реплике. Запрос создаёт новую реплицируемую таблицу, или добавляет новую реплику к имеющимся.
+При работе с большими кластерами мы рекомендуем использовать подстановки, они уменьшают вероятность ошибки.
+
+Выполните запрос `CREATE TABLE` на каждой реплике. Запрос создаёт новую реплицируемую таблицу, или добавляет новую реплику к имеющимся.
 
 Если вы добавляете новую реплику после того, как таблица на других репликах уже содержит некоторые данные, то после выполнения запроса, данные на новую реплику будут скачаны с других реплик. То есть, новая реплика синхронизирует себя с остальными.
 
-Для удаления реплики, выполните запрос DROP TABLE. При этом, удаляется только одна реплика - расположенная на том сервере, где вы выполняете запрос.
+Для удаления реплики, выполните запрос `DROP TABLE`. При этом, удаляется только одна реплика - расположенная на том сервере, где вы выполняете запрос.
 
 ## Восстановление после сбоя
 
 Если при старте сервера, недоступен ZooKeeper, реплицируемые таблицы переходят в режим только для чтения. Система будет пытаться периодически установить соединение с ZooKeeper.
 
-Если при INSERT-е недоступен ZooKeeper, или происходит ошибка при взаимодействии с ним, будет выкинуто исключение.
+Если при `INSERT` недоступен ZooKeeper, или происходит ошибка при взаимодействии с ним, будет выкинуто исключение.
 
 При подключении к ZooKeeper, система проверяет соответствие между имеющимся в локальной файловой системе набором данных и ожидаемым набором данных (информация о котором хранится в ZooKeeper). Если имеются небольшие несоответствия, то система устраняет их, синхронизируя данные с реплик.
 
@@ -121,7 +125,7 @@ ReplicatedMergeTree('/clickhouse/tables/{layer}-{shard}/hits', '{replica}', Even
 
 Стоит заметить, что ClickHouse не делает самостоятельно никаких деструктивных действий типа автоматического удаления большого количества данных.
 
-При старте сервера (или создании новой сессии с ZooKeeper), проверяется только количество и размеры всех файлов. Если у файлов совпадают размеры, но изменены байты где-то посередине, то это обнаруживается не сразу, а только при попытке их прочитать при каком-либо запросе SELECT - запрос кинет исключение о несоответствующей чексумме или размере сжатого блока. В этом случае, куски данных добавляются в очередь на проверку, и при необходимости, скачиваются с реплик.
+При старте сервера (или создании новой сессии с ZooKeeper), проверяется только количество и размеры всех файлов. Если у файлов совпадают размеры, но изменены байты где-то посередине, то это обнаруживается не сразу, а только при попытке их прочитать при каком-либо запросе `SELECT` - запрос кинет исключение о несоответствующей чексумме или размере сжатого блока. В этом случае, куски данных добавляются в очередь на проверку, и при необходимости, скачиваются с реплик.
 
 Если обнаруживается, что локальный набор данных слишком сильно отличается от ожидаемого, то срабатывает защитный механизм - сервер сообщает об этом в лог и отказывается запускаться. Это сделано, так как такой случай может свидетельствовать об ошибке конфигурации - например, если реплика одного шарда была случайно сконфигурирована, как реплика другого шарда. Тем не менее, пороги защитного механизма поставлены довольно низкими, и такая ситуация может возникнуть и при обычном восстановлении после сбоя. В этом случае, восстановление делается полуавтоматически - "по кнопке".
 
@@ -138,13 +142,13 @@ sudo -u clickhouse touch /var/lib/clickhouse/flags/force_restore_data
 Если на одном из серверов исчезли все данные и метаданные, восстановление делается следующим образом:
 
 1.  Установите на сервер ClickHouse. Корректно пропишите подстановки в конфигурационном файле, отвечающие за идентификатор шарда и реплики, если вы их используете.
-2.  Если у вас были нереплицируемые таблицы, которые должны быть вручную продублированы на серверах, скопируйте их данные (в директории /var/lib/clickhouse/data/db_name/table_name/) с реплики.
-3.  Скопируйте с реплики определения таблиц, находящиеся в /var/lib/clickhouse/metadata/. Если в определениях таблиц, идентификатор шарда или реплики, прописаны в явном виде - исправьте их, чтобы они соответствовали данной реплике. (Альтернативный вариант - запустить сервер и сделать самостоятельно все запросы ATTACH TABLE, которые должны были бы быть в соответствующих .sql файлах в /var/lib/clickhouse/metadata/.)
-4.  Создайте в ZooKeeper узел /path_to_table/replica_name/flags/force_restore_data с любым содержимым или выполните команду для восстановления всех реплицируемых таблиц: `sudo -u clickhouse touch /var/lib/clickhouse/flags/force_restore_data`
+2.  Если у вас были нереплицируемые таблицы, которые должны быть вручную продублированы на серверах, скопируйте их данные (в директории `/var/lib/clickhouse/data/db_name/table_name/`) с реплики.
+3.  Скопируйте с реплики определения таблиц, находящиеся в `/var/lib/clickhouse/metadata/`. Если в определениях таблиц, идентификатор шарда или реплики, прописаны в явном виде - исправьте их, чтобы они соответствовали данной реплике. (Альтернативный вариант - запустить сервер и сделать самостоятельно все запросы `ATTACH TABLE`, которые должны были бы быть в соответствующих .sql файлах в `/var/lib/clickhouse/metadata/`.)
+4.  Создайте в ZooKeeper узел `/path_to_table/replica_name/flags/force_restore_data` с любым содержимым или выполните команду для восстановления всех реплицируемых таблиц: `sudo -u clickhouse touch /var/lib/clickhouse/flags/force_restore_data`
 
 Затем запустите сервер (перезапустите, если уже запущен). Данные будут скачаны с реплик.
 
-В качестве альтернативного варианта восстановления, вы можете удалить из ZooKeeper информацию о потерянной реплике - `/path_to_table/replica_name`, и затем создать реплику заново, как написано в разделе "Создание реплицируемых таблиц".
+В качестве альтернативного варианта восстановления, вы можете удалить из ZooKeeper информацию о потерянной реплике - `/path_to_table/replica_name`, и затем создать реплику заново, как написано в разделе "[Создание реплицируемых таблиц](#table_engines-replication-creation_of_rep_tables)".
 
 Отсутствует ограничение на использование сетевой полосы при восстановлении. Имейте это ввиду, если восстанавливаете сразу много реплик.
 
@@ -152,24 +156,24 @@ sudo -u clickhouse touch /var/lib/clickhouse/flags/force_restore_data
 
 Здесь и далее, под `MergeTree` подразумеваются все движки таблиц семейства `MergeTree`, так же для `ReplicatedMergeTree`.
 
-Если у вас была таблица типа MergeTree, репликация которой делалась вручную, вы можете преобразовать её в реплицируемую таблицу. Это может понадобиться лишь в случаях, когда вы уже успели накопить большое количество данных в таблице типа MergeTree, а сейчас хотите включить репликацию.
+Если у вас была таблица типа `MergeTree`, репликация которой делалась вручную, вы можете преобразовать её в реплицируемую таблицу. Это может понадобиться лишь в случаях, когда вы уже успели накопить большое количество данных в таблице типа `MergeTree`, а сейчас хотите включить репликацию.
 
 Если на разных репликах данные отличаются, то сначала синхронизируйте их, либо удалите эти данные на всех репликах кроме одной.
 
-Переименуйте имеющуюся MergeTree таблицу, затем создайте со старым именем таблицу типа ReplicatedMergeTree.
+Переименуйте имеющуюся MergeTree таблицу, затем создайте со старым именем таблицу типа `ReplicatedMergeTree`.
 Перенесите данные из старой таблицы в поддиректорию detached в директории с данными новой таблицы (`/var/lib/clickhouse/data/db_name/table_name/`).
-Затем добавьте эти куски данных в рабочий набор с помощью выполнения запросов ALTER TABLE ATTACH PARTITION на одной из реплик.
+Затем добавьте эти куски данных в рабочий набор с помощью выполнения запросов `ALTER TABLE ATTACH PARTITION` на одной из реплик.
 
 ## Преобразование из ReplicatedMergeTree в MergeTree
 
-Создайте таблицу типа MergeTree с другим именем. Перенесите в её директорию с данными все данные из директории с данными таблицы типа ReplicatedMergeTree. Затем удалите таблицу типа ReplicatedMergeTree и перезапустите сервер.
+Создайте таблицу типа MergeTree с другим именем. Перенесите в её директорию с данными все данные из директории с данными таблицы типа `ReplicatedMergeTree`. Затем удалите таблицу типа `ReplicatedMergeTree` и перезапустите сервер.
 
-Если вы хотите избавиться от таблицы ReplicatedMergeTree, не запуская сервер, то
+Если вы хотите избавиться от таблицы `ReplicatedMergeTree`, не запуская сервер, то
 
--   удалите соответствующий файл .sql в директории с метаданными (`/var/lib/clickhouse/metadata/`);
+-   удалите соответствующий файл `.sql` в директории с метаданными (`/var/lib/clickhouse/metadata/`);
 -   удалите соответствующий путь в ZooKeeper (`/path_to_table/replica_name`);
 
-После этого, вы можете запустить сервер, создать таблицу типа MergeTree, перенести данные в её директорию, и перезапустить сервер.
+После этого, вы можете запустить сервер, создать таблицу типа `MergeTree`, перенести данные в её директорию, и перезапустить сервер.
 
 ## Восстановление в случае потери или повреждения метаданных на ZooKeeper кластере
 
diff --git a/libs/libcommon/cmake/find_gperftools.cmake b/libs/libcommon/cmake/find_gperftools.cmake
index b9fcc40c0c6..a311f2ba74e 100644
--- a/libs/libcommon/cmake/find_gperftools.cmake
+++ b/libs/libcommon/cmake/find_gperftools.cmake
@@ -4,7 +4,7 @@ else ()
     option (USE_INTERNAL_GPERFTOOLS_LIBRARY "Set to FALSE to use system gperftools (tcmalloc) library instead of bundled" ${NOT_UNBUNDLED})
 endif ()
 
-if (ARCH_FREEBSD)
+if (ARCH_FREEBSD OR MSVC)
     option (ENABLE_TCMALLOC "Set to TRUE to enable tcmalloc" OFF)
 else ()
     option (ENABLE_TCMALLOC "Set to TRUE to enable tcmalloc" ON)
diff --git a/libs/libcommon/include/common/DateLUT.h b/libs/libcommon/include/common/DateLUT.h
index c86b4010108..75a7457d101 100644
--- a/libs/libcommon/include/common/DateLUT.h
+++ b/libs/libcommon/include/common/DateLUT.h
@@ -2,7 +2,6 @@
 
 #include <common/DateLUTImpl.h>
 #include <ext/singleton.h>
-
 #include <unordered_map>
 #include <atomic>
 #include <mutex>
@@ -10,8 +9,12 @@
 
 // Also defined in Core/Defines.h
 #if !defined(ALWAYS_INLINE)
+#if defined(_MSC_VER)
+    #define ALWAYS_INLINE __forceinline
+#else
     #define ALWAYS_INLINE __attribute__((__always_inline__))
 #endif
+#endif
 
 
 /// This class provides lazy initialization and lookup of singleton DateLUTImpl objects for a given timezone.
diff --git a/libs/libcommon/include/common/DateLUTImpl.h b/libs/libcommon/include/common/DateLUTImpl.h
index 669f228cb34..535c863eeb3 100644
--- a/libs/libcommon/include/common/DateLUTImpl.h
+++ b/libs/libcommon/include/common/DateLUTImpl.h
@@ -70,6 +70,7 @@ private:
     std::string time_zone;
 
 
+    /// We can correctly process only timestamps that less DATE_LUT_MAX (i.e. up to 2105 year inclusively)
     inline size_t findIndex(time_t t) const
     {
         /// First guess.
@@ -242,8 +243,10 @@ public:
     {
         size_t index = findIndex(t);
 
+        /// If it is not 1970 year (findIndex found nothing appropriate),
+        ///  than limit number of hours to avoid insane results like 1970-01-01 89:28:15
         if (unlikely(index == 0))
-            return (t + offset_at_start_of_epoch) / 3600;
+            return static_cast<unsigned>((t + offset_at_start_of_epoch) / 3600) % 24;
 
         time_t res = t - lut[index].date;
 
diff --git a/libs/libcommon/include/common/LocalDate.h b/libs/libcommon/include/common/LocalDate.h
index 93d045786e9..8eddc6f9115 100644
--- a/libs/libcommon/include/common/LocalDate.h
+++ b/libs/libcommon/include/common/LocalDate.h
@@ -18,7 +18,7 @@
   *
   * packed - for memcmp to work naturally (but because m_year is 2 bytes, on little endian, comparison is correct only before year 2047)
   */
-class __attribute__ ((__packed__)) LocalDate
+class LocalDate
 {
 private:
     unsigned short m_year;
diff --git a/libs/libcommon/include/common/LocalDateTime.h b/libs/libcommon/include/common/LocalDateTime.h
index 133bef46723..d0c208edadc 100644
--- a/libs/libcommon/include/common/LocalDateTime.h
+++ b/libs/libcommon/include/common/LocalDateTime.h
@@ -17,7 +17,7 @@
   *
   * packed - for memcmp to work naturally (but because m_year is 2 bytes, on little endian, comparison is correct only before year 2047)
   */
-class __attribute__ ((__packed__)) LocalDateTime
+class LocalDateTime
 {
 private:
     unsigned short m_year;
diff --git a/libs/libcommon/include/common/MultiVersion.h b/libs/libcommon/include/common/MultiVersion.h
index 6b55bfa9e05..3014689f861 100644
--- a/libs/libcommon/include/common/MultiVersion.h
+++ b/libs/libcommon/include/common/MultiVersion.h
@@ -30,30 +30,13 @@ public:
     /// Default initialization - by nullptr.
     MultiVersion() = default;
 
-    /// Initialization with first version.
-    MultiVersion(const Version & value)
-    {
-        set(value);
-    }
-
-    /// Take an ownership of first version.
-    MultiVersion(const T * value)
-    {
-        set(value);
-    }
-
-    MultiVersion(Version && value)
-    {
-        set(std::move(value));
-    }
-
     MultiVersion(std::unique_ptr<const T> && value)
     {
         set(std::move(value));
     }
 
     /// Obtain current version for read-only usage. Returns shared_ptr, that manages lifetime of version.
-    const Version get() const
+    Version get() const
     {
         /// NOTE: is it possible to lock-free replace of shared_ptr?
         std::lock_guard lock(mutex);
@@ -61,21 +44,10 @@ public:
     }
 
     /// Update an object with new version.
-    void set(const Version & value)
-    {
-        std::lock_guard lock(mutex);
-        current_version = value;
-    }
-
-    /// Update an object with new version and take an ownership of it.
-    void set(const T * value)
-    {
-        set(Version(value));
-    }
-
     void set(std::unique_ptr<const T> && value)
     {
-        set(Version(value.release()));
+        std::lock_guard lock(mutex);
+        current_version = std::move(value);
     }
 
 private:
diff --git a/libs/libcommon/include/common/likely.h b/libs/libcommon/include/common/likely.h
index 7a0a98fcdc0..787d46c0e67 100644
--- a/libs/libcommon/include/common/likely.h
+++ b/libs/libcommon/include/common/likely.h
@@ -1,4 +1,9 @@
 #pragma once
 
-#define likely(x)    (__builtin_expect(!!(x), 1))
-#define unlikely(x)    (__builtin_expect(!!(x), 0))
+#if _MSC_VER
+#define likely(x)   (x)
+#define unlikely(x) (x)
+#else
+#define likely(x)   (__builtin_expect(!!(x), 1))
+#define unlikely(x) (__builtin_expect(!!(x), 0))
+#endif
diff --git a/libs/libcommon/include/common/mremap.h b/libs/libcommon/include/common/mremap.h
index a6a841adc52..edb62070247 100644
--- a/libs/libcommon/include/common/mremap.h
+++ b/libs/libcommon/include/common/mremap.h
@@ -1,7 +1,10 @@
 #pragma once
 
 #include <cstddef>
+#include <sys/types.h>
+#if !_MSC_VER
 #include <sys/mman.h>
+#endif
 
 #if defined(MREMAP_MAYMOVE)
 // we already have implementation (linux)
diff --git a/libs/libcommon/include/port/ssize_t.h b/libs/libcommon/include/port/ssize_t.h
new file mode 100644
index 00000000000..62199bbe1f0
--- /dev/null
+++ b/libs/libcommon/include/port/ssize_t.h
@@ -0,0 +1,8 @@
+#pragma once
+
+#ifdef _MSC_VER
+    #include <basetsd.h>
+    typedef SSIZE_T ssize_t;
+#else
+    #include <sys/types.h>
+#endif
diff --git a/libs/libcommon/include/port/unistd.h b/libs/libcommon/include/port/unistd.h
new file mode 100644
index 00000000000..2c08bd0bcd2
--- /dev/null
+++ b/libs/libcommon/include/port/unistd.h
@@ -0,0 +1,11 @@
+#pragma once
+
+// https://stackoverflow.com/questions/341817/is-there-a-replacement-for-unistd-h-for-windows-visual-c
+
+#ifdef _MSC_VER
+    #include <io.h>
+#else
+    #include <unistd.h>
+#endif
+
+#include "ssize_t.h"
diff --git a/libs/libcommon/src/DateLUT.cpp b/libs/libcommon/src/DateLUT.cpp
index 40634698dbc..22c50a9f694 100644
--- a/libs/libcommon/src/DateLUT.cpp
+++ b/libs/libcommon/src/DateLUT.cpp
@@ -56,13 +56,13 @@ std::string determineDefaultTimeZone()
         /// then the relative path is the time zone id.
         fs::path relative_path = tz_file_path.lexically_relative(tz_database_path);
         if (!relative_path.empty() && *relative_path.begin() != ".." && *relative_path.begin() != ".")
-            return relative_path.native();
+            return relative_path.string();
 
         /// The file is not inside the tz_database_dir, so we hope that it was copied and
         /// try to find the file with exact same contents in the database.
 
         size_t tzfile_size = fs::file_size(tz_file_path);
-        Poco::SHA1Engine::Digest tzfile_sha1 = calcSHA1(tz_file_path.native());
+        Poco::SHA1Engine::Digest tzfile_sha1 = calcSHA1(tz_file_path.string());
 
         fs::recursive_directory_iterator begin(tz_database_path);
         fs::recursive_directory_iterator end;
@@ -80,8 +80,8 @@ std::string determineDefaultTimeZone()
             if (candidate_it->status().type() != fs::regular_file || path.filename() == "localtime")
                 continue;
 
-            if (fs::file_size(path) == tzfile_size && calcSHA1(path.native()) == tzfile_sha1)
-                return path.lexically_relative(tz_database_path).native();
+            if (fs::file_size(path) == tzfile_size && calcSHA1(path.string()) == tzfile_sha1)
+                return path.lexically_relative(tz_database_path).string();
         }
     }
     catch (const Poco::Exception & ex)
diff --git a/libs/libcommon/src/DateLUTImpl.cpp b/libs/libcommon/src/DateLUTImpl.cpp
index 570b277602c..5b3fc2a295e 100644
--- a/libs/libcommon/src/DateLUTImpl.cpp
+++ b/libs/libcommon/src/DateLUTImpl.cpp
@@ -64,7 +64,7 @@ DateLUTImpl::DateLUTImpl(const std::string & time_zone_)
     {
         cctz::time_zone::civil_lookup lookup = cctz_time_zone.lookup(date);
 
-        start_of_day = std::chrono::system_clock::to_time_t(lookup.pre);    /// Ambiguouty is possible.
+        start_of_day = std::chrono::system_clock::to_time_t(lookup.pre);    /// Ambiguity is possible.
 
         Values & values = lut[i];
         values.year = date.year();
diff --git a/libs/libcommon/src/mremap.cpp b/libs/libcommon/src/mremap.cpp
index e01acc8d5d8..5d1ba5287bc 100644
--- a/libs/libcommon/src/mremap.cpp
+++ b/libs/libcommon/src/mremap.cpp
@@ -1,9 +1,8 @@
+#include <common/mremap.h>
 #include <cstddef>
 #include <cstdlib>
 #include <cstring>
-#include <sys/mman.h>
 #include <errno.h>
-#include <common/mremap.h>
 
 #if defined(MREMAP_FIXED)
 // we already have implementation (linux)
@@ -22,18 +21,26 @@ void * mremap(
         return nullptr;
     }
 
+#if _MSC_VER
+    void * new_address = ::operator new(new_size);
+#else
     void * new_address = mmap(nullptr, new_size, mmap_prot, mmap_flags, mmap_fd, mmap_offset);
     if (MAP_FAILED == new_address)
     {
         return MAP_FAILED;
     }
+#endif
 
     memcpy(new_address, old_address, old_size);
 
+#if _MSC_VER
+    delete old_address;
+#else
     if (munmap(old_address, old_size))
     {
         abort();
     }
+#endif
 
     return new_address;
 }
diff --git a/libs/libcommon/src/tests/CMakeLists.txt b/libs/libcommon/src/tests/CMakeLists.txt
index 56b9a927e76..68d8a7e68ce 100644
--- a/libs/libcommon/src/tests/CMakeLists.txt
+++ b/libs/libcommon/src/tests/CMakeLists.txt
@@ -15,6 +15,7 @@ target_link_libraries (date_lut3 common ${PLATFORM_LIBS})
 target_link_libraries (date_lut4 common ${PLATFORM_LIBS})
 target_link_libraries (date_lut_default_timezone common ${PLATFORM_LIBS})
 target_link_libraries (multi_version common)
+add_check(multi_version)
 
 add_executable (unit_tests_libcommon gtest_json_test.cpp gtest_strong_typedef.cpp)
 target_link_libraries (unit_tests_libcommon gtest_main common)
diff --git a/libs/libcommon/src/tests/multi_version.cpp b/libs/libcommon/src/tests/multi_version.cpp
index 94035360008..9cab2e095e4 100644
--- a/libs/libcommon/src/tests/multi_version.cpp
+++ b/libs/libcommon/src/tests/multi_version.cpp
@@ -19,7 +19,7 @@ void thread1(MV & x, T & result)
 
 void thread2(MV & x, const char * result)
 {
-    x.set(std::make_shared<T>(result));
+    x.set(std::make_unique<T>(result));
 }
 
 
@@ -31,7 +31,7 @@ int main(int argc, char ** argv)
         const char * s2 = "Goodbye!";
 
         size_t n = 1000;
-        MV x(std::make_shared<T>(s1));
+        MV x(std::make_unique<T>(s1));
         Results results(n);
 
         ThreadPool tp(8);
diff --git a/libs/libdaemon/include/daemon/BaseDaemon.h b/libs/libdaemon/include/daemon/BaseDaemon.h
index 20c38469d16..112502e06f6 100644
--- a/libs/libdaemon/include/daemon/BaseDaemon.h
+++ b/libs/libdaemon/include/daemon/BaseDaemon.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <sys/types.h>
-#include <unistd.h>
+#include <port/unistd.h>
 #include <iostream>
 #include <memory>
 #include <functional>
diff --git a/libs/libdaemon/src/BaseDaemon.cpp b/libs/libdaemon/src/BaseDaemon.cpp
index 1d4a4dffc2a..e262b2df17c 100644
--- a/libs/libdaemon/src/BaseDaemon.cpp
+++ b/libs/libdaemon/src/BaseDaemon.cpp
@@ -63,6 +63,7 @@
 #include <Common/ClickHouseRevision.h>
 #include <daemon/OwnPatternFormatter.h>
 
+
 using Poco::Logger;
 using Poco::AutoPtr;
 using Poco::Observer;
@@ -310,19 +311,6 @@ private:
         LOG_ERROR(log, "(from thread " << thread_num << ") "
             << "Received signal " << strsignal(sig) << " (" << sig << ")" << ".");
 
-        if (sig == SIGSEGV)
-        {
-            /// Print info about address and reason.
-            if (nullptr == info.si_addr)
-                LOG_ERROR(log, "Address: NULL pointer.");
-            else
-                LOG_ERROR(log, "Address: " << info.si_addr
-                    << (info.si_code == SEGV_ACCERR ? ". Attempted access has violated the permissions assigned to the memory area." : ""));
-        }
-
-        if (already_printed_stack_trace)
-            return;
-
         void * caller_address = nullptr;
 
 #if defined(__x86_64__)
@@ -333,11 +321,151 @@ private:
         caller_address = reinterpret_cast<void *>(context.uc_mcontext->__ss.__rip);
         #else
         caller_address = reinterpret_cast<void *>(context.uc_mcontext.gregs[REG_RIP]);
+        auto err_mask = context.uc_mcontext.gregs[REG_ERR];
         #endif
 #elif defined(__aarch64__)
         caller_address = reinterpret_cast<void *>(context.uc_mcontext.pc);
 #endif
 
+        switch (sig)
+        {
+            case SIGSEGV:
+            {
+                /// Print info about address and reason.
+                if (nullptr == info.si_addr)
+                    LOG_ERROR(log, "Address: NULL pointer.");
+                else
+                    LOG_ERROR(log, "Address: " << info.si_addr);
+
+#if defined(__x86_64__) && !defined(__FreeBSD__) && !defined(__APPLE__)
+                if ((err_mask & 0x02))
+                    LOG_ERROR(log, "Access: write.");
+                else
+                    LOG_ERROR(log, "Access: read.");
+#endif
+
+                switch (info.si_code)
+                {
+                    case SEGV_ACCERR:
+                        LOG_ERROR(log, "Attempted access has violated the permissions assigned to the memory area.");
+                        break;
+                    case SEGV_MAPERR:
+                        LOG_ERROR(log, "Address not mapped to object.");
+                        break;
+                    default:
+                        LOG_ERROR(log, "Unknown si_code.");
+                        break;
+                }
+                break;
+            }
+
+            case SIGBUS:
+            {
+                switch (info.si_code)
+                {
+                    case BUS_ADRALN:
+                        LOG_ERROR(log, "Invalid address alignment.");
+                        break;
+                    case BUS_ADRERR:
+                        LOG_ERROR(log, "Non-existant physical address.");
+                        break;
+                    case BUS_OBJERR:
+                        LOG_ERROR(log, "Object specific hardware error.");
+                        break;
+
+                    // Linux specific
+#if defined(BUS_MCEERR_AR)
+                    case BUS_MCEERR_AR:
+                        LOG_ERROR(log, "Hardware memory error: action required.");
+                        break;
+#endif
+#if defined(BUS_MCEERR_AO)
+                    case BUS_MCEERR_AO:
+                        LOG_ERROR(log, "Hardware memory error: action optional.");
+                        break;
+#endif
+
+                    default:
+                        LOG_ERROR(log, "Unknown si_code.");
+                        break;
+                }
+                break;
+            }
+
+            case SIGILL:
+            {
+                switch (info.si_code)
+                {
+                    case ILL_ILLOPC:
+                        LOG_ERROR(log, "Illegal opcode.");
+                        break;
+                    case ILL_ILLOPN:
+                        LOG_ERROR(log, "Illegal operand.");
+                        break;
+                    case ILL_ILLADR:
+                        LOG_ERROR(log, "Illegal addressing mode.");
+                        break;
+                    case ILL_ILLTRP:
+                        LOG_ERROR(log, "Illegal trap.");
+                        break;
+                    case ILL_PRVOPC:
+                        LOG_ERROR(log, "Privileged opcode.");
+                        break;
+                    case ILL_PRVREG:
+                        LOG_ERROR(log, "Privileged register.");
+                        break;
+                    case ILL_COPROC:
+                        LOG_ERROR(log, "Coprocessor error.");
+                        break;
+                    case ILL_BADSTK:
+                        LOG_ERROR(log, "Internal stack error.");
+                        break;
+                    default:
+                        LOG_ERROR(log, "Unknown si_code.");
+                        break;
+                }
+                break;
+            }
+
+            case SIGFPE:
+            {
+                switch (info.si_code)
+                {
+                    case FPE_INTDIV:
+                        LOG_ERROR(log, "Integer divide by zero.");
+                        break;
+                    case FPE_INTOVF:
+                        LOG_ERROR(log, "Integer overflow.");
+                        break;
+                    case FPE_FLTDIV:
+                        LOG_ERROR(log, "Floating point divide by zero.");
+                        break;
+                    case FPE_FLTOVF:
+                        LOG_ERROR(log, "Floating point overflow.");
+                        break;
+                    case FPE_FLTUND:
+                        LOG_ERROR(log, "Floating point underflow.");
+                        break;
+                    case FPE_FLTRES:
+                        LOG_ERROR(log, "Floating point inexact result.");
+                        break;
+                    case FPE_FLTINV:
+                        LOG_ERROR(log, "Floating point invalid operation.");
+                        break;
+                    case FPE_FLTSUB:
+                        LOG_ERROR(log, "Subscript out of range.");
+                        break;
+                    default:
+                        LOG_ERROR(log, "Unknown si_code.");
+                        break;
+                }
+                break;
+            }
+        }
+
+        if (already_printed_stack_trace)
+            return;
+
         static const int max_frames = 50;
         void * frames[max_frames];
 
diff --git a/libs/libpocoext/src/ThreadNumber.cpp b/libs/libpocoext/src/ThreadNumber.cpp
index 266627d3168..6458ea8c221 100644
--- a/libs/libpocoext/src/ThreadNumber.cpp
+++ b/libs/libpocoext/src/ThreadNumber.cpp
@@ -1,16 +1,14 @@
-#include <pthread.h>
-#include <common/likely.h>
-
 #include <Poco/Ext/ThreadNumber.h>
-
+#include <common/likely.h>
+#include <atomic>
 
 static thread_local unsigned thread_number = 0;
-static unsigned threads = 0;
+static std::atomic_uint threads{0};
 
 unsigned Poco::ThreadNumber::get()
 {
     if (unlikely(thread_number == 0))
-        thread_number = __sync_add_and_fetch(&threads, 1);
+        thread_number = ++threads;
 
     return thread_number;
 }
diff --git a/release b/release
index 0fba786373b..ae19a8ada46 100755
--- a/release
+++ b/release
@@ -13,6 +13,7 @@ DEB_CXX=${DEB_CXX:=g++-7}
 CONTROL=debian/control
 DEBUILD_NOSIGN_OPTIONS="-us -uc"
 DEBUILD_NODEPS_OPTIONS="-d"
+USE_PBUILDER=1
 
 if [ -z "$REVISION" ] ; then
     get_revision_author
@@ -35,11 +36,14 @@ do
         REVISION=`git rev-parse HEAD`
         shift
     elif [[ $1 == '--pbuilder' ]]; then
-        USE_PBUILDER=1
+        # Default
+        shift
+    elif [[ $1 == '--no-pbuilder' ]]; then
+        USE_PBUILDER=
         shift
     elif [[ $1 == '--fast' ]]; then
         # Wrong but fast pbuilder mode: create base package with all depends
-        EXTRAPACKAGES="$EXTRAPACKAGES debhelper cmake gcc-7 g++-7 libc6-dev libmariadbclient-dev libicu-dev libltdl-dev libreadline-dev libssl-dev unixodbc-dev psmisc bash expect python python-lxml python-termcolor curl perl sudo"
+        EXTRAPACKAGES="$EXTRAPACKAGES debhelper cmake gcc-7 g++-7 libc6-dev libmariadbclient-dev libicu-dev libltdl-dev libreadline-dev libssl-dev unixodbc-dev psmisc bash expect python python-lxml python-termcolor curl perl sudo openssl"
         shift
     else
         echo "Unknown option $1"
diff --git a/utils/build/build_msvc2017.bat b/utils/build/build_msvc2017.bat
new file mode 100644
index 00000000000..880802999ab
--- /dev/null
+++ b/utils/build/build_msvc2017.bat
@@ -0,0 +1,14 @@
+
+:: WINDOWS BUILD NOT SUPPORTED!
+:: Script only for development
+
+cd ../..
+git clone --recursive https://github.com/madler/zlib contrib/zlib
+md build
+cd build
+
+:: Stage 1: try build client
+cmake .. -G "Visual Studio 15 2017 Win64" -DENABLE_CLICKHOUSE_ALL=0 -DENABLE_CLICKHOUSE_CLIENT=1 > cmake.log
+cmake --build . --target clickhouse -- /m > build.log
+:: Stage 2: try build minimal server
+:: Stage 3: enable all possible features (ssl, ...)
diff --git a/utils/compressor/CMakeLists.txt b/utils/compressor/CMakeLists.txt
index ae4333337db..ca4dd334fb5 100644
--- a/utils/compressor/CMakeLists.txt
+++ b/utils/compressor/CMakeLists.txt
@@ -7,7 +7,7 @@ set_target_properties(util-clickhouse-compressor PROPERTIES OUTPUT_NAME "clickho
 #install (TARGETS util-clickhouse-compressor RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse-compressor)
 
 add_executable (zstd_test zstd_test.cpp)
-target_link_libraries (zstd_test ${ZSTD_LIBRARY} Threads::Threads)
+target_link_libraries (zstd_test ${ZSTD_LIBRARY} common Threads::Threads)
 if (NOT USE_INTERNAL_ZSTD_LIBRARY)
     target_include_directories (zstd_test BEFORE PRIVATE ${ZSTD_INCLUDE_DIR})
 endif ()
diff --git a/utils/compressor/zstd_test.cpp b/utils/compressor/zstd_test.cpp
index 6a8b9cb5be6..01016830e7d 100644
--- a/utils/compressor/zstd_test.cpp
+++ b/utils/compressor/zstd_test.cpp
@@ -1,7 +1,8 @@
-#include <unistd.h>
+#include <port/unistd.h>
 #include <zstd.h>
 #include <vector>
 #include <stdexcept>
+#include <sys/types.h>
 
 
 int main(int argc, char ** argv)
diff --git a/utils/iotest/iotest.cpp b/utils/iotest/iotest.cpp
index 439672fc25c..a4849638e48 100644
--- a/utils/iotest/iotest.cpp
+++ b/utils/iotest/iotest.cpp
@@ -1,28 +1,21 @@
 #include <fcntl.h>
-#include <unistd.h>
+#include <port/unistd.h>
 #include <stdlib.h>
 #include <time.h>
-
 #include <iostream>
 #include <iomanip>
 #include <vector>
 #include <random>
 #include <pcg_random.hpp>
-
 #include <Poco/NumberParser.h>
 #include <Poco/NumberFormatter.h>
 #include <Poco/Exception.h>
-
 #include <Common/Exception.h>
 #include <Common/randomSeed.h>
-
 #include <common/ThreadPool.h>
 #include <Common/Stopwatch.h>
-
 #include <IO/BufferWithOwnMemory.h>
-
 #include <cstdlib>
-
 #ifdef __APPLE__
 #include <common/apple_rt.h>
 #endif
diff --git a/utils/iotest/iotest_aio.cpp b/utils/iotest/iotest_aio.cpp
index f86b4e76e3e..bfab8249d19 100644
--- a/utils/iotest/iotest_aio.cpp
+++ b/utils/iotest/iotest_aio.cpp
@@ -1,28 +1,21 @@
 #include <fcntl.h>
-#include <unistd.h>
+#include <port/unistd.h>
 #include <stdlib.h>
 #include <time.h>
-
 #include <iostream>
 #include <iomanip>
 #include <vector>
-
 #include <Poco/NumberParser.h>
 #include <Poco/NumberFormatter.h>
 #include <Poco/Exception.h>
-
 #include <Common/Exception.h>
-
 #include <common/ThreadPool.h>
 #include <Common/Stopwatch.h>
-
 #include <IO/BufferWithOwnMemory.h>
-
 #include <stdlib.h>
 #if !defined(__APPLE__) && !defined(__FreeBSD__)
 #include <malloc.h>
 #endif
-
 #include <fcntl.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -33,6 +26,7 @@
 #endif
 #include <sys/syscall.h>
 
+
 using DB::throwFromErrno;
 
 inline int io_setup(unsigned nr, aio_context_t *ctxp)
diff --git a/utils/iotest/iotest_nonblock.cpp b/utils/iotest/iotest_nonblock.cpp
index fdd25860825..8f1ad435bf0 100644
--- a/utils/iotest/iotest_nonblock.cpp
+++ b/utils/iotest/iotest_nonblock.cpp
@@ -1,5 +1,5 @@
 #include <fcntl.h>
-#include <unistd.h>
+#include <port/unistd.h>
 #include <stdlib.h>
 #include <time.h>
 #include <stdlib.h>
@@ -7,24 +7,18 @@
 #include <malloc.h>
 #endif
 #include <poll.h>
-
 #include <iostream>
 #include <iomanip>
 #include <vector>
-
 #include <random>
 #include <pcg_random.hpp>
-
 #include <Poco/NumberParser.h>
 #include <Poco/NumberFormatter.h>
 #include <Poco/Exception.h>
-
 #include <Common/Exception.h>
 #include <Common/randomSeed.h>
-
 #include <common/ThreadPool.h>
 #include <Common/Stopwatch.h>
-
 #ifdef __APPLE__
 #include <common/apple_rt.h>
 #endif
diff --git a/utils/travis/normal.sh b/utils/travis/normal.sh
index 6f94981b735..ba5b294535f 100755
--- a/utils/travis/normal.sh
+++ b/utils/travis/normal.sh
@@ -1,9 +1,11 @@
-#!/bin/sh
+#!/bin/bash
 
 # Manual run:
 # env CXX=g++-7 CC=gcc-7 utils/travis/normal.sh
 # env CXX=clang++-5.0 CC=clang-5.0 utils/travis/normal.sh
 
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+
 set -e
 set -x
 
@@ -20,7 +22,7 @@ date
 
 mkdir -p build
 cd build
-cmake .. -DCMAKE_CXX_COMPILER=`which $DEB_CXX $CXX` -DCMAKE_C_COMPILER=`which $DEB_CC $CC` \
+cmake $CUR_DIR/../.. -DCMAKE_CXX_COMPILER=`which $DEB_CXX $CXX` -DCMAKE_C_COMPILER=`which $DEB_CC $CC` \
     `# Does not optimize to speedup build, skip debug info to use less disk` \
     -DCMAKE_C_FLAGS_ADD="-O0 -g0" -DCMAKE_CXX_FLAGS_ADD="-O0 -g0" \
     `# ignore ccache disabler on trusty` \
@@ -33,6 +35,6 @@ cmake .. -DCMAKE_CXX_COMPILER=`which $DEB_CXX $CXX` -DCMAKE_C_COMPILER=`which $D
     `# Skip tests:` \
     `# 00281 requires internal compiler` \
     `# 00428 requires sudo (not all vms allow this)` \
-    && ( [ ${TEST_RUN=1} ] && ( ( cd .. && env TEST_OPT="--skip long compile 00428 $TEST_OPT" bash -x dbms/tests/clickhouse-test-server ) || ${TEST_TRUE=false} ) || true )
+    && ( [ ${TEST_RUN=1} ] && ( ( cd $CUR_DIR/../.. && env TEST_OPT="--skip long compile 00428 $TEST_OPT" bash -x dbms/tests/clickhouse-test-server ) || ${TEST_TRUE=false} ) || true )
 
 date
diff --git a/utils/travis/pbuilder.sh b/utils/travis/pbuilder.sh
index 635db59fdaf..9d5cce6a366 100755
--- a/utils/travis/pbuilder.sh
+++ b/utils/travis/pbuilder.sh
@@ -1,4 +1,6 @@
-#!/bin/sh
+#!/bin/bash
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 
 # env CXX=clang++-5.0 CC=clang-5.0 DH_VERBOSE=1 utils/travis/pbuilder.sh
 
@@ -14,6 +16,7 @@ env TEST_RUN=${TEST_RUN=1} \
     `# 00281 requires internal compiler` \
     `# 00416 requires patched poco from contrib/` \
     TEST_OPT="--skip long pocopatch $TEST_OPT" \
+    TEST_SSL="" `# <Error> Application: SSL context exception: Error loading certificate from file /etc/clickhouse-server/server.crt: No error -- when using system poco on artful` \
     TEST_TRUE=${TEST_TRUE=false} \
     `# travisci will not upload ccache cache after timeout (48min), use our less timeout` \
     PBUILDER_OPT="--timeout ${PBUILDER_TIMEOUT:=35m} $PBUILDER_OPT" \
@@ -25,6 +28,6 @@ env TEST_RUN=${TEST_RUN=1} \
     `# Use all possible contrib libs from system` \
     `# psmisc - killall` \
     EXTRAPACKAGES="psmisc clang-5.0 lld-5.0 liblld-5.0-dev libclang-5.0-dev liblld-5.0 libc++abi-dev libc++-dev libboost-program-options-dev libboost-system-dev libboost-filesystem-dev libboost-thread-dev zlib1g-dev liblz4-dev libdouble-conversion-dev libzookeeper-mt-dev libsparsehash-dev librdkafka-dev libpoco-dev libsparsehash-dev libgoogle-perftools-dev libzstd-dev libre2-dev $EXTRAPACKAGES" \
-    ./release --pbuilder $RELEASE_OPT
+    $CUR_DIR/../../release $RELEASE_OPT
 
 date