Merge remote-tracking branch 'upstream/master' into fix25

.gitmodules

@@ -103,3 +103,6 @@
 [submodule "contrib/fastops"]
 	path = contrib/fastops
 	url = https://github.com/ClickHouse-Extras/fastops
+[submodule "contrib/orc"]
+	path = contrib/orc
+	url = https://github.com/apache/orc

CHANGELOG.md

@@ -1,3 +1,13 @@
+## ClickHouse release 19.13.3.26, 2019-08-22
+
+### Bug Fix
+* Fix `ALTER TABLE ... UPDATE` query for tables with `enable_mixed_granularity_parts=1`. [#6543](https://github.com/yandex/ClickHouse/pull/6543) ([alesapin](https://github.com/alesapin))
+* Fix NPE when using IN clause with a subquery with a tuple. [#6125](https://github.com/yandex/ClickHouse/issues/6125) [#6550](https://github.com/yandex/ClickHouse/pull/6550) ([tavplubix](https://github.com/tavplubix))
+* Fixed an issue that if a stale replica becomes alive, it may still have data parts that were removed by DROP PARTITION. [#6522](https://github.com/yandex/ClickHouse/issues/6522) [#6523](https://github.com/yandex/ClickHouse/pull/6523) ([tavplubix](https://github.com/tavplubix))
+* Fixed issue with parsing CSV [#6426](https://github.com/yandex/ClickHouse/issues/6426) [#6559](https://github.com/yandex/ClickHouse/pull/6559) ([tavplubix](https://github.com/tavplubix))
+* Fixed data race in system.parts table and ALTER query. This fixes [#6245](https://github.com/yandex/ClickHouse/issues/6245). [#6513](https://github.com/yandex/ClickHouse/pull/6513) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed wrong code in mutations that may lead to memory corruption. Fixed segfault with read of address `0x14c0` that may happed due to concurrent `DROP TABLE` and `SELECT` from `system.parts` or `system.parts_columns`. Fixed race condition in preparation of mutation queries. Fixed deadlock caused by `OPTIMIZE` of Replicated tables and concurrent modification operations like ALTERs. [#6514](https://github.com/yandex/ClickHouse/pull/6514) ([alexey-milovidov](https://github.com/alexey-milovidov))
+
 ## ClickHouse release 19.13.2.19, 2019-08-14
 
 ### New Feature
@@ -31,6 +41,16 @@
 * Fix build with external `libcxx` [#6010](https://github.com/yandex/ClickHouse/pull/6010) ([Ivan](https://github.com/abyss7))
 * Fix shared build with `rdkafka` library [#6101](https://github.com/yandex/ClickHouse/pull/6101) ([Ivan](https://github.com/abyss7))
 
+## ClickHouse release 19.11.8.46, 2019-08-22
+
+### Bug Fix
+* Fix `ALTER TABLE ... UPDATE` query for tables with `enable_mixed_granularity_parts=1`. [#6543](https://github.com/yandex/ClickHouse/pull/6543) ([alesapin](https://github.com/alesapin))
+* Fix NPE when using IN clause with a subquery with a tuple. [#6125](https://github.com/yandex/ClickHouse/issues/6125) [#6550](https://github.com/yandex/ClickHouse/pull/6550) ([tavplubix](https://github.com/tavplubix))
+* Fixed an issue that if a stale replica becomes alive, it may still have data parts that were removed by DROP PARTITION. [#6522](https://github.com/yandex/ClickHouse/issues/6522) [#6523](https://github.com/yandex/ClickHouse/pull/6523) ([tavplubix](https://github.com/tavplubix))
+* Fixed issue with parsing CSV [#6426](https://github.com/yandex/ClickHouse/issues/6426) [#6559](https://github.com/yandex/ClickHouse/pull/6559) ([tavplubix](https://github.com/tavplubix))
+* Fixed data race in system.parts table and ALTER query. This fixes [#6245](https://github.com/yandex/ClickHouse/issues/6245). [#6513](https://github.com/yandex/ClickHouse/pull/6513) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed wrong code in mutations that may lead to memory corruption. Fixed segfault with read of address `0x14c0` that may happed due to concurrent `DROP TABLE` and `SELECT` from `system.parts` or `system.parts_columns`. Fixed race condition in preparation of mutation queries. Fixed deadlock caused by `OPTIMIZE` of Replicated tables and concurrent modification operations like ALTERs. [#6514](https://github.com/yandex/ClickHouse/pull/6514) ([alexey-milovidov](https://github.com/alexey-milovidov))
+
 ## ClickHouse release 19.11.7.40, 2019-08-14
 
 ### Bug fix

CMakeLists.txt

@@ -481,6 +481,7 @@ include (cmake/find_mimalloc.cmake)
 include (cmake/find_simdjson.cmake)
 include (cmake/find_rapidjson.cmake)
 include (cmake/find_fastops.cmake)
+include (cmake/find_orc.cmake)
 
 find_contrib_lib(cityhash)
 find_contrib_lib(farmhash)

cmake/find_orc.cmake

@@ -0,0 +1,8 @@
+##TODO replace hardcode to find procedure
+
+set(USE_ORC 0)
+set(USE_INTERNAL_ORC_LIBRARY ON)
+
+if (ARROW_LIBRARY)
+    set(USE_ORC 1)
+endif()

contrib/CMakeLists.txt

@@ -10,6 +10,18 @@ endif ()
 
 set_property(DIRECTORY PROPERTY EXCLUDE_FROM_ALL 1)
 
+if (USE_INTERNAL_ORC_LIBRARY)
+    set(BUILD_JAVA OFF)
+    set (ANALYZE_JAVA OFF)
+    set (BUILD_CPP_TESTS OFF)
+    set (BUILD_TOOLS OFF)
+    option(BUILD_JAVA OFF)
+    option (ANALYZE_JAVA OFF)
+    option (BUILD_CPP_TESTS OFF)
+    option (BUILD_TOOLS OFF)
+    set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/contrib/orc/cmake_modules")
+    add_subdirectory(orc)
+endif()
 
 if (USE_INTERNAL_UNWIND_LIBRARY)
     add_subdirectory (libunwind-cmake)

contrib/arrow-cmake/CMakeLists.txt

@@ -47,6 +47,71 @@ target_include_directories(${THRIFT_LIBRARY} SYSTEM PUBLIC ${ClickHouse_SOURCE_D
 target_link_libraries(${THRIFT_LIBRARY} PRIVATE Threads::Threads)
 
 
+# === orc
+
+set(ORC_SOURCE_DIR ${ClickHouse_SOURCE_DIR}/contrib/orc/c++)
+set(ORC_INCLUDE_DIR ${ORC_SOURCE_DIR}/include)
+set(ORC_SOURCE_SRC_DIR ${ORC_SOURCE_DIR}/src)
+set(ORC_SOURCE_WRAP_DIR ${ORC_SOURCE_DIR}/wrap)
+
+set(ORC_BUILD_SRC_DIR ${CMAKE_CURRENT_BINARY_DIR}/../orc/c++/src)
+set(ORC_BUILD_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/../orc/c++/include)
+
+set(GOOGLE_PROTOBUF_DIR ${ClickHouse_SOURCE_DIR}/contrib/protobuf/src/)
+set(ORC_ADDITION_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR})
+set(ARROW_SRC_DIR ${ClickHouse_SOURCE_DIR}/contrib/arrow/cpp/src)
+
+set(PROTOBUF_EXECUTABLE ${CMAKE_CURRENT_BINARY_DIR}/../protobuf/cmake/protoc)
+set(PROTO_DIR ${ORC_SOURCE_DIR}/../proto)
+
+
+add_custom_command(OUTPUT orc_proto.pb.h orc_proto.pb.cc
+        COMMAND ${PROTOBUF_EXECUTABLE}
+        -I ${PROTO_DIR}
+        --cpp_out="${CMAKE_CURRENT_BINARY_DIR}"
+        "${PROTO_DIR}/orc_proto.proto")
+
+include_directories(SYSTEM ${ORC_INCLUDE_DIR})
+include_directories(SYSTEM ${ORC_SOURCE_SRC_DIR})
+include_directories(SYSTEM ${ORC_SOURCE_WRAP_DIR})
+include_directories(SYSTEM ${GOOGLE_PROTOBUF_DIR})
+include_directories(SYSTEM ${ORC_BUILD_SRC_DIR})
+include_directories(SYSTEM ${ORC_BUILD_INCLUDE_DIR})
+include_directories(SYSTEM ${ORC_ADDITION_SOURCE_DIR})
+include_directories(SYSTEM ${ARROW_SRC_DIR})
+
+
+set(ORC_SRCS
+        ${ARROW_SRC_DIR}/arrow/adapters/orc/adapter.cc
+        ${ORC_SOURCE_SRC_DIR}/Exceptions.cc
+        ${ORC_SOURCE_SRC_DIR}/OrcFile.cc
+        ${ORC_SOURCE_SRC_DIR}/Reader.cc
+        ${ORC_SOURCE_SRC_DIR}/ByteRLE.cc
+        ${ORC_SOURCE_SRC_DIR}/ColumnPrinter.cc
+        ${ORC_SOURCE_SRC_DIR}/ColumnReader.cc
+        ${ORC_SOURCE_SRC_DIR}/ColumnWriter.cc
+        ${ORC_SOURCE_SRC_DIR}/Common.cc
+        ${ORC_SOURCE_SRC_DIR}/Compression.cc
+        ${ORC_SOURCE_SRC_DIR}/Exceptions.cc
+        ${ORC_SOURCE_SRC_DIR}/Int128.cc
+        ${ORC_SOURCE_SRC_DIR}/LzoDecompressor.cc
+        ${ORC_SOURCE_SRC_DIR}/MemoryPool.cc
+        ${ORC_SOURCE_SRC_DIR}/OrcFile.cc
+        ${ORC_SOURCE_SRC_DIR}/Reader.cc
+        ${ORC_SOURCE_SRC_DIR}/RLE.cc
+        ${ORC_SOURCE_SRC_DIR}/RLEv1.cc
+        ${ORC_SOURCE_SRC_DIR}/RLEv2.cc
+        ${ORC_SOURCE_SRC_DIR}/Statistics.cc
+        ${ORC_SOURCE_SRC_DIR}/StripeStream.cc
+        ${ORC_SOURCE_SRC_DIR}/Timezone.cc
+        ${ORC_SOURCE_SRC_DIR}/TypeImpl.cc
+        ${ORC_SOURCE_SRC_DIR}/Vector.cc
+        ${ORC_SOURCE_SRC_DIR}/Writer.cc
+        ${ORC_SOURCE_SRC_DIR}/io/InputStream.cc
+        ${ORC_SOURCE_SRC_DIR}/io/OutputStream.cc
+        ${ORC_ADDITION_SOURCE_DIR}/orc_proto.pb.cc
+        )
+
 
 # === arrow
 
@@ -103,6 +168,7 @@ set(ARROW_SRCS
   ${LIBRARY_DIR}/util/thread-pool.cc
   ${LIBRARY_DIR}/util/trie.cc
   ${LIBRARY_DIR}/util/utf8.cc
+  ${ORC_SRCS}
 )
 
 set(ARROW_SRCS ${ARROW_SRCS}
@@ -151,8 +217,9 @@ endif()
 
 
 add_library(${ARROW_LIBRARY} ${ARROW_SRCS})
+add_dependencies(${ARROW_LIBRARY} protoc)
 target_include_directories(${ARROW_LIBRARY} SYSTEM PUBLIC ${ClickHouse_SOURCE_DIR}/contrib/arrow/cpp/src PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/cpp/src ${Boost_INCLUDE_DIRS})
-target_link_libraries(${ARROW_LIBRARY} PRIVATE ${DOUBLE_CONVERSION_LIBRARIES} Threads::Threads)
+target_link_libraries(${ARROW_LIBRARY} PRIVATE ${DOUBLE_CONVERSION_LIBRARIES} ${PROTOBUF_LIBRARIES} Threads::Threads)
 if (ARROW_WITH_LZ4)
     target_link_libraries(${ARROW_LIBRARY} PRIVATE ${LZ4_LIBRARY})
 endif()

contrib/orc

@@ -0,0 +1 @@
+Subproject commit 5981208e39447df84827f6a961d1da76bacb6078

dbms/CMakeLists.txt

@@ -114,6 +114,7 @@ add_headers_and_sources(dbms src/Columns)
 add_headers_and_sources(dbms src/Storages)
 add_headers_and_sources(dbms src/Storages/Distributed)
 add_headers_and_sources(dbms src/Storages/MergeTree)
+add_headers_and_sources(dbms src/Storages/LiveView)
 add_headers_and_sources(dbms src/Client)
 add_headers_and_sources(dbms src/Formats)
 add_headers_and_sources(dbms src/Processors)

dbms/programs/CMakeLists.txt

@@ -98,7 +98,7 @@ endif()
 
 if (CLICKHOUSE_SPLIT_BINARY)
     set (CLICKHOUSE_ALL_TARGETS clickhouse-server clickhouse-client clickhouse-local clickhouse-benchmark clickhouse-performance-test
-            clickhouse-extract-from-config clickhouse-compressor clickhouse-format clickhouse-copier)
+            clickhouse-extract-from-config clickhouse-compressor clickhouse-format clickhouse-obfuscator clickhouse-copier)
 
     if (ENABLE_CLICKHOUSE_ODBC_BRIDGE)
         list (APPEND CLICKHOUSE_ALL_TARGETS clickhouse-odbc-bridge)

dbms/programs/obfuscator/Obfuscator.cpp

@@ -22,6 +22,7 @@
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/HashTable/HashMap.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Core/Block.h>
 #include <common/StringRef.h>
 #include <common/DateLUT.h>
@@ -263,11 +264,11 @@ public:
 
     ColumnPtr generate(const IColumn & column) override
     {
-        const auto & src_data = static_cast<const ColumnVector<Float> &>(column).getData();
+        const auto & src_data = assert_cast<const ColumnVector<Float> &>(column).getData();
         size_t size = src_data.size();
 
         auto res_column = ColumnVector<Float>::create(size);
-        auto & res_data = static_cast<ColumnVector<Float> &>(*res_column).getData();
+        auto & res_data = assert_cast<ColumnVector<Float> &>(*res_column).getData();
 
         for (size_t i = 0; i < size; ++i)
         {
@@ -355,7 +356,7 @@ public:
 
     ColumnPtr generate(const IColumn & column) override
     {
-        const ColumnFixedString & column_fixed_string = static_cast<const ColumnFixedString &>(column);
+        const ColumnFixedString & column_fixed_string = assert_cast<const ColumnFixedString &>(column);
         const size_t string_size = column_fixed_string.getN();
 
         const auto & src_data = column_fixed_string.getChars();
@@ -392,11 +393,11 @@ public:
 
     ColumnPtr generate(const IColumn & column) override
     {
-        const auto & src_data = static_cast<const ColumnVector<UInt32> &>(column).getData();
+        const auto & src_data = assert_cast<const ColumnVector<UInt32> &>(column).getData();
         size_t size = src_data.size();
 
         auto res_column = ColumnVector<UInt32>::create(size);
-        auto & res_data = static_cast<ColumnVector<UInt32> &>(*res_column).getData();
+        auto & res_data = assert_cast<ColumnVector<UInt32> &>(*res_column).getData();
 
         for (size_t i = 0; i < size; ++i)
         {
@@ -749,7 +750,7 @@ public:
 
     void train(const IColumn & column) override
     {
-        const ColumnString & column_string = static_cast<const ColumnString &>(column);
+        const ColumnString & column_string = assert_cast<const ColumnString &>(column);
         size_t size = column_string.size();
 
         for (size_t i = 0; i < size; ++i)
@@ -766,7 +767,7 @@ public:
 
     ColumnPtr generate(const IColumn & column) override
     {
-        const ColumnString & column_string = static_cast<const ColumnString &>(column);
+        const ColumnString & column_string = assert_cast<const ColumnString &>(column);
         size_t size = column_string.size();
 
         auto res_column = ColumnString::create();
@@ -801,7 +802,7 @@ public:
 
     void train(const IColumn & column) override
     {
-        const ColumnArray & column_array = static_cast<const ColumnArray &>(column);
+        const ColumnArray & column_array = assert_cast<const ColumnArray &>(column);
         const IColumn & nested_column = column_array.getData();
 
         nested_model->train(nested_column);
@@ -814,7 +815,7 @@ public:
 
     ColumnPtr generate(const IColumn & column) override
     {
-        const ColumnArray & column_array = static_cast<const ColumnArray &>(column);
+        const ColumnArray & column_array = assert_cast<const ColumnArray &>(column);
         const IColumn & nested_column = column_array.getData();
 
         ColumnPtr new_nested_column = nested_model->generate(nested_column);
@@ -834,7 +835,7 @@ public:
 
     void train(const IColumn & column) override
     {
-        const ColumnNullable & column_nullable = static_cast<const ColumnNullable &>(column);
+        const ColumnNullable & column_nullable = assert_cast<const ColumnNullable &>(column);
         const IColumn & nested_column = column_nullable.getNestedColumn();
 
         nested_model->train(nested_column);
@@ -847,7 +848,7 @@ public:
 
     ColumnPtr generate(const IColumn & column) override
     {
-        const ColumnNullable & column_nullable = static_cast<const ColumnNullable &>(column);
+        const ColumnNullable & column_nullable = assert_cast<const ColumnNullable &>(column);
         const IColumn & nested_column = column_nullable.getNestedColumn();
 
         ColumnPtr new_nested_column = nested_model->generate(nested_column);

dbms/programs/odbc-bridge/ODBCBlockInputStream.cpp

@@ -3,6 +3,7 @@
 #include <Columns/ColumnNullable.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnsNumber.h>
+#include <Common/assert_cast.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <common/logger_useful.h>
@@ -44,46 +45,46 @@ namespace
         switch (type)
         {
             case ValueType::vtUInt8:
-                static_cast<ColumnUInt8 &>(column).insertValue(value.convert<UInt64>());
+                assert_cast<ColumnUInt8 &>(column).insertValue(value.convert<UInt64>());
                 break;
             case ValueType::vtUInt16:
-                static_cast<ColumnUInt16 &>(column).insertValue(value.convert<UInt64>());
+                assert_cast<ColumnUInt16 &>(column).insertValue(value.convert<UInt64>());
                 break;
             case ValueType::vtUInt32:
-                static_cast<ColumnUInt32 &>(column).insertValue(value.convert<UInt64>());
+                assert_cast<ColumnUInt32 &>(column).insertValue(value.convert<UInt64>());
                 break;
             case ValueType::vtUInt64:
-                static_cast<ColumnUInt64 &>(column).insertValue(value.convert<UInt64>());
+                assert_cast<ColumnUInt64 &>(column).insertValue(value.convert<UInt64>());
                 break;
             case ValueType::vtInt8:
-                static_cast<ColumnInt8 &>(column).insertValue(value.convert<Int64>());
+                assert_cast<ColumnInt8 &>(column).insertValue(value.convert<Int64>());
                 break;
             case ValueType::vtInt16:
-                static_cast<ColumnInt16 &>(column).insertValue(value.convert<Int64>());
+                assert_cast<ColumnInt16 &>(column).insertValue(value.convert<Int64>());
                 break;
             case ValueType::vtInt32:
-                static_cast<ColumnInt32 &>(column).insertValue(value.convert<Int64>());
+                assert_cast<ColumnInt32 &>(column).insertValue(value.convert<Int64>());
                 break;
             case ValueType::vtInt64:
-                static_cast<ColumnInt64 &>(column).insertValue(value.convert<Int64>());
+                assert_cast<ColumnInt64 &>(column).insertValue(value.convert<Int64>());
                 break;
             case ValueType::vtFloat32:
-                static_cast<ColumnFloat32 &>(column).insertValue(value.convert<Float64>());
+                assert_cast<ColumnFloat32 &>(column).insertValue(value.convert<Float64>());
                 break;
             case ValueType::vtFloat64:
-                static_cast<ColumnFloat64 &>(column).insertValue(value.convert<Float64>());
+                assert_cast<ColumnFloat64 &>(column).insertValue(value.convert<Float64>());
                 break;
             case ValueType::vtString:
-                static_cast<ColumnString &>(column).insert(value.convert<String>());
+                assert_cast<ColumnString &>(column).insert(value.convert<String>());
                 break;
             case ValueType::vtDate:
-                static_cast<ColumnUInt16 &>(column).insertValue(UInt16{LocalDate{value.convert<String>()}.getDayNum()});
+                assert_cast<ColumnUInt16 &>(column).insertValue(UInt16{LocalDate{value.convert<String>()}.getDayNum()});
                 break;
             case ValueType::vtDateTime:
-                static_cast<ColumnUInt32 &>(column).insertValue(time_t{LocalDateTime{value.convert<String>()}});
+                assert_cast<ColumnUInt32 &>(column).insertValue(time_t{LocalDateTime{value.convert<String>()}});
                 break;
             case ValueType::vtUUID:
-                static_cast<ColumnUInt128 &>(column).insert(parse<UUID>(value.convert<std::string>()));
+                assert_cast<ColumnUInt128 &>(column).insert(parse<UUID>(value.convert<std::string>()));
                 break;
         }
     }
@@ -114,7 +115,7 @@ Block ODBCBlockInputStream::readImpl()
             {
                 if (description.types[idx].second)
                 {
-                    ColumnNullable & column_nullable = static_cast<ColumnNullable &>(*columns[idx]);
+                    ColumnNullable & column_nullable = assert_cast<ColumnNullable &>(*columns[idx]);
                     insertValue(column_nullable.getNestedColumn(), description.types[idx].first, value);
                     column_nullable.getNullMapData().emplace_back(0);
                 }

dbms/programs/server/config.xml

@@ -217,6 +217,7 @@
 
          See https://clickhouse.yandex/docs/en/table_engines/replication/
       -->
+
     <zookeeper incl="zookeeper-servers" optional="true" />
 
     <!-- Substitutions for parameters of replicated tables.

dbms/src/AggregateFunctions/AggregateFunctionArray.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Columns/ColumnArray.h>
+#include <Common/assert_cast.h>
 #include <DataTypes/DataTypeArray.h>
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <IO/WriteHelpers.h>
@@ -81,9 +82,9 @@ public:
         const IColumn * nested[num_arguments];
 
         for (size_t i = 0; i < num_arguments; ++i)
-            nested[i] = &static_cast<const ColumnArray &>(*columns[i]).getData();
+            nested[i] = &assert_cast<const ColumnArray &>(*columns[i]).getData();
 
-        const ColumnArray & first_array_column = static_cast<const ColumnArray &>(*columns[0]);
+        const ColumnArray & first_array_column = assert_cast<const ColumnArray &>(*columns[0]);
         const IColumn::Offsets & offsets = first_array_column.getOffsets();
 
         size_t begin = offsets[row_num - 1];
@@ -92,7 +93,7 @@ public:
         /// Sanity check. NOTE We can implement specialization for a case with single argument, if the check will hurt performance.
         for (size_t i = 1; i < num_arguments; ++i)
         {
-            const ColumnArray & ith_column = static_cast<const ColumnArray &>(*columns[i]);
+            const ColumnArray & ith_column = assert_cast<const ColumnArray &>(*columns[i]);
             const IColumn::Offsets & ith_offsets = ith_column.getOffsets();
 
             if (ith_offsets[row_num] != end || (row_num != 0 && ith_offsets[row_num - 1] != begin))

dbms/src/AggregateFunctions/AggregateFunctionBitwise.h

@@ -5,6 +5,7 @@
 
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnVector.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
 
@@ -55,7 +56,7 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
-        this->data(place).update(static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
+        this->data(place).update(assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
     }
 
     void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena *) const override
@@ -75,7 +76,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnVector<T> &>(to).getData().push_back(this->data(place).value);
+        assert_cast<ColumnVector<T> &>(to).getData().push_back(this->data(place).value);
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }

dbms/src/AggregateFunctions/AggregateFunctionBoundingRatio.h

@@ -7,6 +7,7 @@
 #include <IO/WriteHelpers.h>
 #include <AggregateFunctions/Helpers.h>
 #include <AggregateFunctions/IAggregateFunction.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -151,7 +152,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnFloat64 &>(to).getData().push_back(getBoundingRatio(data(place)));
+        assert_cast<ColumnFloat64 &>(to).getData().push_back(getBoundingRatio(data(place)));
     }
 
     const char * getHeaderFilePath() const override

dbms/src/AggregateFunctions/AggregateFunctionCount.h

@@ -7,6 +7,7 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnNullable.h>
 #include <AggregateFunctions/IAggregateFunction.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -59,7 +60,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt64 &>(to).getData().push_back(data(place).count);
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(data(place).count);
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }
@@ -86,7 +87,7 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
-        data(place).count += !static_cast<const ColumnNullable &>(*columns[0]).isNullAt(row_num);
+        data(place).count += !assert_cast<const ColumnNullable &>(*columns[0]).isNullAt(row_num);
     }
 
     void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena *) const override
@@ -106,7 +107,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt64 &>(to).getData().push_back(data(place).count);
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(data(place).count);
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }
@@ -143,7 +144,7 @@ public:
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
         for (size_t i = 0; i < number_of_arguments; ++i)
-            if (is_nullable[i] && static_cast<const ColumnNullable &>(*columns[i]).isNullAt(row_num))
+            if (is_nullable[i] && assert_cast<const ColumnNullable &>(*columns[i]).isNullAt(row_num))
                 return;
 
         ++data(place).count;
@@ -166,7 +167,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt64 &>(to).getData().push_back(data(place).count);
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(data(place).count);
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }

dbms/src/AggregateFunctions/AggregateFunctionEntropy.h

@@ -7,6 +7,7 @@
 #include <AggregateFunctions/UniqVariadicHash.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnVector.h>
+#include <Common/assert_cast.h>
 
 #include <cmath>
 
@@ -115,7 +116,7 @@ public:
         if constexpr (!std::is_same_v<UInt128, Value>)
         {
             /// Here we manage only with numerical types
-            const auto & column = static_cast<const ColumnVector <Value> &>(*columns[0]);
+            const auto & column = assert_cast<const ColumnVector <Value> &>(*columns[0]);
             this->data(place).add(column.getData()[row_num]);
         }
         else
@@ -141,7 +142,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        auto & column = static_cast<ColumnVector<Float64> &>(to);
+        auto & column = assert_cast<ColumnVector<Float64> &>(to);
         column.getData().push_back(this->data(place).get());
     }
 

dbms/src/AggregateFunctions/AggregateFunctionForEach.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Columns/ColumnArray.h>
+#include <Common/assert_cast.h>
 #include <DataTypes/DataTypeArray.h>
 #include <AggregateFunctions/IAggregateFunction.h>
 
@@ -149,9 +150,9 @@ public:
         const IColumn * nested[num_arguments];
 
         for (size_t i = 0; i < num_arguments; ++i)
-            nested[i] = &static_cast<const ColumnArray &>(*columns[i]).getData();
+            nested[i] = &assert_cast<const ColumnArray &>(*columns[i]).getData();
 
-        const ColumnArray & first_array_column = static_cast<const ColumnArray &>(*columns[0]);
+        const ColumnArray & first_array_column = assert_cast<const ColumnArray &>(*columns[0]);
         const IColumn::Offsets & offsets = first_array_column.getOffsets();
 
         size_t begin = offsets[row_num - 1];
@@ -160,7 +161,7 @@ public:
         /// Sanity check. NOTE We can implement specialization for a case with single argument, if the check will hurt performance.
         for (size_t i = 1; i < num_arguments; ++i)
         {
-            const ColumnArray & ith_column = static_cast<const ColumnArray &>(*columns[i]);
+            const ColumnArray & ith_column = assert_cast<const ColumnArray &>(*columns[i]);
             const IColumn::Offsets & ith_offsets = ith_column.getOffsets();
 
             if (ith_offsets[row_num] != end || (row_num != 0 && ith_offsets[row_num - 1] != begin))
@@ -228,7 +229,7 @@ public:
     {
         const AggregateFunctionForEachData & state = data(place);
 
-        ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+        ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
         ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
         IColumn & elems_to = arr_to.getData();
 

dbms/src/AggregateFunctions/AggregateFunctionGroupArray.h

@@ -12,6 +12,7 @@
 #include <Columns/ColumnString.h>
 
 #include <Common/ArenaAllocator.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
 
@@ -68,7 +69,7 @@ public:
         if (limit_num_elems && this->data(place).value.size() >= max_elems)
             return;
 
-        this->data(place).value.push_back(static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num], arena);
+        this->data(place).value.push_back(assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num], arena);
     }
 
     void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const override
@@ -119,14 +120,14 @@ public:
         const auto & value = this->data(place).value;
         size_t size = value.size();
 
-        ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+        ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
         ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
 
         offsets_to.push_back(offsets_to.back() + size);
 
         if (size)
         {
-            typename ColumnVector<T>::Container & data_to = static_cast<ColumnVector<T> &>(arr_to.getData()).getData();
+            typename ColumnVector<T>::Container & data_to = assert_cast<ColumnVector<T> &>(arr_to.getData()).getData();
             data_to.insert(this->data(place).value.begin(), this->data(place).value.end());
         }
     }
@@ -191,7 +192,7 @@ struct GroupArrayListNodeString : public GroupArrayListNodeBase<GroupArrayListNo
     /// Create node from string
     static Node * allocate(const IColumn & column, size_t row_num, Arena * arena)
     {
-        StringRef string = static_cast<const ColumnString &>(column).getDataAt(row_num);
+        StringRef string = assert_cast<const ColumnString &>(column).getDataAt(row_num);
 
         Node * node = reinterpret_cast<Node *>(arena->alignedAlloc(sizeof(Node) + string.size, alignof(Node)));
         node->next = nullptr;
@@ -203,7 +204,7 @@ struct GroupArrayListNodeString : public GroupArrayListNodeBase<GroupArrayListNo
 
     void insertInto(IColumn & column)
     {
-        static_cast<ColumnString &>(column).insertData(data(), size);
+        assert_cast<ColumnString &>(column).insertData(data(), size);
     }
 };
 
@@ -374,7 +375,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        auto & column_array = static_cast<ColumnArray &>(to);
+        auto & column_array = assert_cast<ColumnArray &>(to);
 
         auto & offsets = column_array.getOffsets();
         offsets.push_back(offsets.back() + data(place).elems);
@@ -383,7 +384,7 @@ public:
 
         if (std::is_same_v<Node, GroupArrayListNodeString>)
         {
-            auto & string_offsets = static_cast<ColumnString &>(column_data).getOffsets();
+            auto & string_offsets = assert_cast<ColumnString &>(column_data).getOffsets();
             string_offsets.reserve(string_offsets.size() + data(place).elems);
         }
 

dbms/src/AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h

@@ -10,6 +10,7 @@
 #include <Columns/ColumnVector.h>
 
 #include <Common/FieldVisitors.h>
+#include <Common/assert_cast.h>
 #include <Interpreters/convertFieldToType.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
@@ -180,7 +181,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        ColumnArray & to_array = static_cast<ColumnArray &>(to);
+        ColumnArray & to_array = assert_cast<ColumnArray &>(to);
         IColumn & to_data = to_array.getData();
         ColumnArray::Offsets & to_offsets = to_array.getOffsets();
 

dbms/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.h

@@ -11,6 +11,7 @@
 #include <Columns/ColumnArray.h>
 
 #include <Common/ArenaAllocator.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
 
@@ -164,7 +165,7 @@ public:
         const auto & data = this->data(place);
         size_t size = data.value.size();
 
-        ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+        ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
         ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
 
         offsets_to.push_back(offsets_to.back() + size);

dbms/src/AggregateFunctions/AggregateFunctionGroupBitmap.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Columns/ColumnVector.h>
-#include <boost/noncopyable.hpp>
+#include <Common/assert_cast.h>
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <AggregateFunctions/AggregateFunctionGroupBitmapData.h>
 #include <DataTypes/DataTypesNumber.h>
@@ -26,7 +26,7 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
-        this->data(place).rbs.add(static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
+        this->data(place).rbs.add(assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
     }
 
     void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena *) const override
@@ -46,7 +46,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnVector<T> &>(to).getData().push_back(this->data(place).rbs.size());
+        assert_cast<ColumnVector<T> &>(to).getData().push_back(this->data(place).rbs.size());
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }

dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h

@@ -10,6 +10,7 @@
 #include <Columns/ColumnArray.h>
 
 #include <Common/HashTable/HashSet.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
 
@@ -63,7 +64,7 @@ public:
     {
         if (limit_num_elems && this->data(place).value.size() >= max_elems)
             return;
-        this->data(place).value.insert(static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
+        this->data(place).value.insert(assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
     }
 
     void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena *) const override
@@ -100,7 +101,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+        ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
         ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
 
         const typename State::Set & set = this->data(place).value;
@@ -108,7 +109,7 @@ public:
 
         offsets_to.push_back(offsets_to.back() + size);
 
-        typename ColumnVector<T>::Container & data_to = static_cast<ColumnVector<T> &>(arr_to.getData()).getData();
+        typename ColumnVector<T>::Container & data_to = assert_cast<ColumnVector<T> &>(arr_to.getData()).getData();
         size_t old_size = data_to.size();
         data_to.resize(old_size + size);
 
@@ -254,7 +255,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+        ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
         ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
         IColumn & data_to = arr_to.getData();
 

dbms/src/AggregateFunctions/AggregateFunctionHistogram.h

@@ -6,6 +6,7 @@
 #include <Columns/ColumnVector.h>
 #include <Columns/ColumnTuple.h>
 #include <Columns/ColumnArray.h>
+#include <Common/assert_cast.h>
 
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeArray.h>
@@ -333,7 +334,7 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
     {
-        auto val = static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num];
+        auto val = assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num];
         this->data(place).add(static_cast<Data::Mean>(val), 1, max_bins);
     }
 
@@ -356,13 +357,13 @@ public:
     {
         auto & data = this->data(const_cast<AggregateDataPtr>(place));
 
-        auto & to_array = static_cast<ColumnArray &>(to);
+        auto & to_array = assert_cast<ColumnArray &>(to);
         ColumnArray::Offsets & offsets_to = to_array.getOffsets();
-        auto & to_tuple = static_cast<ColumnTuple &>(to_array.getData());
+        auto & to_tuple = assert_cast<ColumnTuple &>(to_array.getData());
 
-        auto & to_lower = static_cast<ColumnVector<Data::Mean> &>(to_tuple.getColumn(0));
+        auto & to_lower = assert_cast<ColumnVector<Data::Mean> &>(to_tuple.getColumn(0));
-        auto & to_upper = static_cast<ColumnVector<Data::Mean> &>(to_tuple.getColumn(1));
+        auto & to_upper = assert_cast<ColumnVector<Data::Mean> &>(to_tuple.getColumn(1));
-        auto & to_weights = static_cast<ColumnVector<Data::Weight> &>(to_tuple.getColumn(2));
+        auto & to_weights = assert_cast<ColumnVector<Data::Weight> &>(to_tuple.getColumn(2));
         data.insertResultInto(to_lower, to_upper, to_weights, max_bins);
 
         offsets_to.push_back(to_tuple.size());

dbms/src/AggregateFunctions/AggregateFunctionIf.h

@@ -2,6 +2,7 @@
 
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnsNumber.h>
+#include <Common/assert_cast.h>
 #include <AggregateFunctions/IAggregateFunction.h>
 
 
@@ -75,7 +76,7 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena) const override
     {
-        if (static_cast<const ColumnUInt8 &>(*columns[num_arguments - 1]).getData()[row_num])
+        if (assert_cast<const ColumnUInt8 &>(*columns[num_arguments - 1]).getData()[row_num])
             nested_func->add(place, columns, row_num, arena);
     }
 

dbms/src/AggregateFunctions/AggregateFunctionMLMethod.cpp

@@ -7,6 +7,7 @@
 #include <Columns/ColumnTuple.h>
 #include <Common/FieldVisitors.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include "AggregateFunctionFactory.h"
 #include "FactoryHelpers.h"
 #include "Helpers.h"
@@ -147,14 +148,14 @@ void LinearModelData::returnWeights(IColumn & to) const
 {
     size_t size = weights.size() + 1;
 
-    ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+    ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
     ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
 
     size_t old_size = offsets_to.back();
     offsets_to.push_back(old_size + size);
 
     typename ColumnFloat64::Container & val_to
-            = static_cast<ColumnFloat64 &>(arr_to.getData()).getData();
+            = assert_cast<ColumnFloat64 &>(arr_to.getData()).getData();
 
     val_to.reserve(old_size + size);
     for (size_t i = 0; i + 1 < size; ++i)

dbms/src/AggregateFunctions/AggregateFunctionMaxIntersections.h

@@ -10,6 +10,7 @@
 
 #include <Common/ArenaAllocator.h>
 #include <Common/NaNUtils.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
 
@@ -88,8 +89,8 @@ public:
 
     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 left = assert_cast<const ColumnVector<PointType> &>(*columns[0]).getData()[row_num];
-        PointType right = static_cast<const ColumnVector<PointType> &>(*columns[1]).getData()[row_num];
+        PointType right = assert_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);
@@ -152,12 +153,12 @@ public:
 
         if (kind == AggregateFunctionIntersectionsKind::Count)
         {
-            auto & result_column = static_cast<ColumnUInt64 &>(to).getData();
+            auto & result_column = assert_cast<ColumnUInt64 &>(to).getData();
             result_column.push_back(max_intersections);
         }
         else
         {
-            auto & result_column = static_cast<ColumnVector<PointType> &>(to).getData();
+            auto & result_column = assert_cast<ColumnVector<PointType> &>(to).getData();
             result_column.push_back(position_of_max_intersections);
         }
     }

dbms/src/AggregateFunctions/AggregateFunctionMerge.h

@@ -4,6 +4,7 @@
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnAggregateFunction.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -70,7 +71,7 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena) const override
     {
-        nested_func->merge(place, static_cast<const ColumnAggregateFunction &>(*columns[0]).getData()[row_num], arena);
+        nested_func->merge(place, assert_cast<const ColumnAggregateFunction &>(*columns[0]).getData()[row_num], arena);
     }
 
     void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const override

dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h

@@ -7,6 +7,7 @@
 #include <Columns/ColumnString.h>
 #include <DataTypes/IDataType.h>
 #include <common/StringRef.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
 
@@ -38,9 +39,9 @@ public:
     void insertResultInto(IColumn & to) const
     {
         if (has())
-            static_cast<ColumnVector<T> &>(to).getData().push_back(value);
+            assert_cast<ColumnVector<T> &>(to).getData().push_back(value);
         else
-            static_cast<ColumnVector<T> &>(to).insertDefault();
+            assert_cast<ColumnVector<T> &>(to).insertDefault();
     }
 
     void write(WriteBuffer & buf, const IDataType & /*data_type*/) const
@@ -61,7 +62,7 @@ public:
     void change(const IColumn & column, size_t row_num, Arena *)
     {
         has_value = true;
-        value = static_cast<const ColumnVector<T> &>(column).getData()[row_num];
+        value = assert_cast<const ColumnVector<T> &>(column).getData()[row_num];
     }
 
     /// Assuming to.has()
@@ -112,7 +113,7 @@ public:
 
     bool changeIfLess(const IColumn & column, size_t row_num, Arena * arena)
     {
-        if (!has() || static_cast<const ColumnVector<T> &>(column).getData()[row_num] < value)
+        if (!has() || assert_cast<const ColumnVector<T> &>(column).getData()[row_num] < value)
         {
             change(column, row_num, arena);
             return true;
@@ -134,7 +135,7 @@ public:
 
     bool changeIfGreater(const IColumn & column, size_t row_num, Arena * arena)
     {
-        if (!has() || static_cast<const ColumnVector<T> &>(column).getData()[row_num] > value)
+        if (!has() || assert_cast<const ColumnVector<T> &>(column).getData()[row_num] > value)
         {
             change(column, row_num, arena);
             return true;
@@ -161,7 +162,7 @@ public:
 
     bool isEqualTo(const IColumn & column, size_t row_num) const
     {
-        return has() && static_cast<const ColumnVector<T> &>(column).getData()[row_num] == value;
+        return has() && assert_cast<const ColumnVector<T> &>(column).getData()[row_num] == value;
     }
 };
 
@@ -204,9 +205,9 @@ public:
     void insertResultInto(IColumn & to) const
     {
         if (has())
-            static_cast<ColumnString &>(to).insertDataWithTerminatingZero(getData(), size);
+            assert_cast<ColumnString &>(to).insertDataWithTerminatingZero(getData(), size);
         else
-            static_cast<ColumnString &>(to).insertDefault();
+            assert_cast<ColumnString &>(to).insertDefault();
     }
 
     void write(WriteBuffer & buf, const IDataType & /*data_type*/) const
@@ -281,7 +282,7 @@ public:
 
     void change(const IColumn & column, size_t row_num, Arena * arena)
     {
-        changeImpl(static_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num), arena);
+        changeImpl(assert_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num), arena);
     }
 
     void change(const Self & to, Arena * arena)
@@ -330,7 +331,7 @@ public:
 
     bool changeIfLess(const IColumn & column, size_t row_num, Arena * arena)
     {
-        if (!has() || static_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num) < getStringRef())
+        if (!has() || assert_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num) < getStringRef())
         {
             change(column, row_num, arena);
             return true;
@@ -352,7 +353,7 @@ public:
 
     bool changeIfGreater(const IColumn & column, size_t row_num, Arena * arena)
     {
-        if (!has() || static_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num) > getStringRef())
+        if (!has() || assert_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num) > getStringRef())
         {
             change(column, row_num, arena);
             return true;
@@ -379,7 +380,7 @@ public:
 
     bool isEqualTo(const IColumn & column, size_t row_num) const
     {
-        return has() && static_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num) == getStringRef();
+        return has() && assert_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num) == getStringRef();
     }
 };
 

dbms/src/AggregateFunctions/AggregateFunctionNull.h

@@ -3,6 +3,7 @@
 #include <array>
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnNullable.h>
+#include <Common/assert_cast.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
@@ -149,7 +150,7 @@ public:
     {
         if (result_is_nullable)
         {
-            ColumnNullable & to_concrete = static_cast<ColumnNullable &>(to);
+            ColumnNullable & to_concrete = assert_cast<ColumnNullable &>(to);
             if (getFlag(place))
             {
                 nested_function->insertResultInto(nestedPlace(place), to_concrete.getNestedColumn());
@@ -194,7 +195,7 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena * arena) const override
     {
-        const ColumnNullable * column = static_cast<const ColumnNullable *>(columns[0]);
+        const ColumnNullable * column = assert_cast<const ColumnNullable *>(columns[0]);
         if (!column->isNullAt(row_num))
         {
             this->setFlag(place);
@@ -233,7 +234,7 @@ public:
         {
             if (is_nullable[i])
             {
-                const ColumnNullable & nullable_col = static_cast<const ColumnNullable &>(*columns[i]);
+                const ColumnNullable & nullable_col = assert_cast<const ColumnNullable &>(*columns[i]);
                 if (nullable_col.isNullAt(row_num))
                 {
                     /// If at least one column has a null value in the current row,

dbms/src/AggregateFunctions/AggregateFunctionQuantile.h

@@ -21,6 +21,7 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
+#include <Common/assert_cast.h>
 
 #include <type_traits>
 
@@ -143,7 +144,7 @@ public:
 
         if constexpr (returns_many)
         {
-            ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+            ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
             ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
 
             size_t size = levels.size();
@@ -154,7 +155,7 @@ public:
 
             if constexpr (returns_float)
             {
-                auto & data_to = static_cast<ColumnVector<FloatReturnType> &>(arr_to.getData()).getData();
+                auto & data_to = assert_cast<ColumnVector<FloatReturnType> &>(arr_to.getData()).getData();
                 size_t old_size = data_to.size();
                 data_to.resize(data_to.size() + size);
 
@@ -172,7 +173,7 @@ public:
         else
         {
             if constexpr (returns_float)
-                static_cast<ColumnVector<FloatReturnType> &>(to).getData().push_back(data.getFloat(level));
+                assert_cast<ColumnVector<FloatReturnType> &>(to).getData().push_back(data.getFloat(level));
             else
                 static_cast<ColVecType &>(to).getData().push_back(data.get(level));
         }

dbms/src/AggregateFunctions/AggregateFunctionResample.h

@@ -3,6 +3,7 @@
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnArray.h>
 #include <DataTypes/DataTypeArray.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -169,8 +170,8 @@ public:
         ConstAggregateDataPtr place,
         IColumn & to) const override
     {
-        auto & col = static_cast<ColumnArray &>(to);
+        auto & col = assert_cast<ColumnArray &>(to);
-        auto & col_offsets = static_cast<ColumnArray::ColumnOffsets &>(col.getOffsetsColumn());
+        auto & col_offsets = assert_cast<ColumnArray::ColumnOffsets &>(col.getOffsetsColumn());
 
         for (size_t i = 0; i < total; ++i)
             nested_function->insertResultInto(place + i * sod, col.getData());

dbms/src/AggregateFunctions/AggregateFunctionRetention.h

@@ -5,6 +5,7 @@
 #include <unordered_set>
 #include <Columns/ColumnsNumber.h>
 #include <Columns/ColumnArray.h>
+#include <Common/assert_cast.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeArray.h>
 #include <IO/ReadHelpers.h>
@@ -100,7 +101,7 @@ public:
     {
         for (const auto i : ext::range(0, events_size))
         {
-            auto event = static_cast<const ColumnVector<UInt8> *>(columns[i])->getData()[row_num];
+            auto event = assert_cast<const ColumnVector<UInt8> *>(columns[i])->getData()[row_num];
             if (event)
             {
                 this->data(place).add(i);
@@ -125,8 +126,8 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        auto & data_to = static_cast<ColumnUInt8 &>(static_cast<ColumnArray &>(to).getData()).getData();
+        auto & data_to = assert_cast<ColumnUInt8 &>(assert_cast<ColumnArray &>(to).getData()).getData();
-        auto & offsets_to = static_cast<ColumnArray &>(to).getOffsets();
+        auto & offsets_to = assert_cast<ColumnArray &>(to).getOffsets();
 
         ColumnArray::Offset current_offset = data_to.size();
         data_to.resize(current_offset + events_size);

dbms/src/AggregateFunctions/AggregateFunctionSequenceMatch.h

@@ -4,6 +4,7 @@
 #include <DataTypes/DataTypeDateTime.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnsNumber.h>
+#include <Common/assert_cast.h>
 #include <ext/range.h>
 #include <Common/PODArray.h>
 #include <IO/ReadHelpers.h>
@@ -152,12 +153,12 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, const size_t row_num, Arena *) const override
     {
-        const auto timestamp = static_cast<const ColumnVector<T> *>(columns[0])->getData()[row_num];
+        const auto timestamp = assert_cast<const ColumnVector<T> *>(columns[0])->getData()[row_num];
 
         typename Data::Events events;
         for (const auto i : ext::range(1, arg_count))
         {
-            const auto event = static_cast<const ColumnUInt8 *>(columns[i])->getData()[row_num];
+            const auto event = assert_cast<const ColumnUInt8 *>(columns[i])->getData()[row_num];
             events.set(i - 1, event);
         }
 
@@ -574,7 +575,7 @@ public:
         auto events_it = events_begin;
 
         bool match = this->pattern_has_time ? this->backtrackingMatch(events_it, events_end) : this->dfaMatch(events_it, events_end);
-        static_cast<ColumnUInt8 &>(to).getData().push_back(match);
+        assert_cast<ColumnUInt8 &>(to).getData().push_back(match);
     }
 };
 
@@ -594,7 +595,7 @@ public:
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
         const_cast<Data &>(this->data(place)).sort();
-        static_cast<ColumnUInt64 &>(to).getData().push_back(count(place));
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(count(place));
     }
 
 private:

dbms/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.h

@@ -3,6 +3,7 @@
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnVector.h>
 #include <Columns/ColumnTuple.h>
+#include <Common/assert_cast.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeTuple.h>
@@ -120,8 +121,8 @@ public:
         Arena *
     ) const override
     {
-        auto col_x = static_cast<const ColumnVector<X> *>(columns[0]);
+        auto col_x = assert_cast<const ColumnVector<X> *>(columns[0]);
-        auto col_y = static_cast<const ColumnVector<Y> *>(columns[1]);
+        auto col_y = assert_cast<const ColumnVector<Y> *>(columns[1]);
 
         X x = col_x->getData()[row_num];
         Y y = col_y->getData()[row_num];
@@ -181,9 +182,9 @@ public:
         Ret k = this->data(place).getK();
         Ret b = this->data(place).getB(k);
 
-        auto & col_tuple = static_cast<ColumnTuple &>(to);
+        auto & col_tuple = assert_cast<ColumnTuple &>(to);
-        auto & col_k = static_cast<ColumnVector<Ret> &>(col_tuple.getColumn(0));
+        auto & col_k = assert_cast<ColumnVector<Ret> &>(col_tuple.getColumn(0));
-        auto & col_b = static_cast<ColumnVector<Ret> &>(col_tuple.getColumn(1));
+        auto & col_b = assert_cast<ColumnVector<Ret> &>(col_tuple.getColumn(1));
 
         col_k.getData().push_back(k);
         col_b.getData().push_back(b);

dbms/src/AggregateFunctions/AggregateFunctionState.h

@@ -4,6 +4,7 @@
 #include <DataTypes/DataTypeAggregateFunction.h>
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnAggregateFunction.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -81,7 +82,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnAggregateFunction &>(to).getData().push_back(const_cast<AggregateDataPtr>(place));
+        assert_cast<ColumnAggregateFunction &>(to).getData().push_back(const_cast<AggregateDataPtr>(place));
     }
 
     /// Aggregate function or aggregate function state.

dbms/src/AggregateFunctions/AggregateFunctionStatistics.h

@@ -5,9 +5,11 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnsNumber.h>
+#include <Common/assert_cast.h>
 
 #include <cmath>
 
+
 namespace DB
 {
 
@@ -52,7 +54,7 @@ class AggregateFunctionVarianceData
 public:
     void update(const IColumn & column, size_t row_num)
     {
-        T received = static_cast<const ColumnVector<T> &>(column).getData()[row_num];
+        T received = assert_cast<const ColumnVector<T> &>(column).getData()[row_num];
         Float64 val = static_cast<Float64>(received);
         Float64 delta = val - mean;
 
@@ -95,7 +97,7 @@ public:
 
     void publish(IColumn & to) const
     {
-        static_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(m2, count));
+        assert_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(m2, count));
     }
 
 private:
@@ -265,11 +267,11 @@ private:
 public:
     void update(const IColumn & column_left, const IColumn & column_right, size_t row_num)
     {
-        T left_received = static_cast<const ColumnVector<T> &>(column_left).getData()[row_num];
+        T left_received = assert_cast<const ColumnVector<T> &>(column_left).getData()[row_num];
         Float64 left_val = static_cast<Float64>(left_received);
         Float64 left_delta = left_val - left_mean;
 
-        U right_received = static_cast<const ColumnVector<U> &>(column_right).getData()[row_num];
+        U right_received = assert_cast<const ColumnVector<U> &>(column_right).getData()[row_num];
         Float64 right_val = static_cast<Float64>(right_received);
         Float64 right_delta = right_val - right_mean;
 
@@ -345,9 +347,9 @@ public:
     void publish(IColumn & to) const
     {
         if constexpr (compute_marginal_moments)
-            static_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, Base::left_m2, Base::right_m2, count));
+            assert_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, Base::left_m2, Base::right_m2, count));
         else
-            static_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, count));
+            assert_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, count));
     }
 
 private:

dbms/src/AggregateFunctions/AggregateFunctionSumMap.h

@@ -12,6 +12,7 @@
 #include <Columns/ColumnDecimal.h>
 
 #include <Common/FieldVisitors.h>
+#include <Common/assert_cast.h>
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <map>
 
@@ -83,7 +84,7 @@ public:
     void add(AggregateDataPtr place, const IColumn ** columns, const size_t row_num, Arena *) const override
     {
         // Column 0 contains array of keys of known type
-        const ColumnArray & array_column0 = static_cast<const ColumnArray &>(*columns[0]);
+        const ColumnArray & array_column0 = assert_cast<const ColumnArray &>(*columns[0]);
         const IColumn::Offsets & offsets0 = array_column0.getOffsets();
         const auto & keys_vec = static_cast<const ColVecType &>(array_column0.getData());
         const size_t keys_vec_offset = offsets0[row_num - 1];
@@ -94,7 +95,7 @@ public:
         for (size_t col = 0, size = values_types.size(); col < size; ++col)
         {
             Field value;
-            const ColumnArray & array_column = static_cast<const ColumnArray &>(*columns[col + 1]);
+            const ColumnArray & array_column = assert_cast<const ColumnArray &>(*columns[col + 1]);
             const IColumn::Offsets & offsets = array_column.getOffsets();
             const size_t values_vec_offset = offsets[row_num - 1];
             const size_t values_vec_size = (offsets[row_num] - values_vec_offset);
@@ -228,8 +229,8 @@ public:
 
         size_t size = merged_maps.size();
 
-        auto & to_tuple = static_cast<ColumnTuple &>(to);
+        auto & to_tuple = assert_cast<ColumnTuple &>(to);
-        auto & to_keys_arr = static_cast<ColumnArray &>(to_tuple.getColumn(0));
+        auto & to_keys_arr = assert_cast<ColumnArray &>(to_tuple.getColumn(0));
         auto & to_keys_col = to_keys_arr.getData();
 
         // Advance column offsets
@@ -239,7 +240,7 @@ public:
 
         for (size_t col = 0; col < values_types.size(); ++col)
         {
-            auto & to_values_arr = static_cast<ColumnArray &>(to_tuple.getColumn(col + 1));
+            auto & to_values_arr = assert_cast<ColumnArray &>(to_tuple.getColumn(col + 1));
             auto & to_values_offsets = to_values_arr.getOffsets();
             to_values_offsets.push_back(to_values_offsets.back() + size);
             to_values_arr.getData().reserve(size);
@@ -254,7 +255,7 @@ public:
             // Write 0..n arrays of values
             for (size_t col = 0; col < values_types.size(); ++col)
             {
-                auto & to_values_col = static_cast<ColumnArray &>(to_tuple.getColumn(col + 1)).getData();
+                auto & to_values_col = assert_cast<ColumnArray &>(to_tuple.getColumn(col + 1)).getData();
                 to_values_col.insert(elem.second[col]);
             }
         }

dbms/src/AggregateFunctions/AggregateFunctionTimeSeriesGroupSum.h

@@ -16,6 +16,7 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <Common/ArenaAllocator.h>
+#include <Common/assert_cast.h>
 #include <ext/range.h>
 #include "IAggregateFunction.h"
 
@@ -235,9 +236,9 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, const size_t row_num, Arena *) const override
     {
-        auto uid = static_cast<const ColumnVector<UInt64> *>(columns[0])->getData()[row_num];
+        auto uid = assert_cast<const ColumnVector<UInt64> *>(columns[0])->getData()[row_num];
-        auto ts = static_cast<const ColumnVector<Int64> *>(columns[1])->getData()[row_num];
+        auto ts = assert_cast<const ColumnVector<Int64> *>(columns[1])->getData()[row_num];
-        auto val = static_cast<const ColumnVector<Float64> *>(columns[2])->getData()[row_num];
+        auto val = assert_cast<const ColumnVector<Float64> *>(columns[2])->getData()[row_num];
         if (uid && ts && val)
         {
             this->data(place).add(uid, ts, val);
@@ -255,7 +256,7 @@ public:
         const auto & value = this->data(place).result;
         size_t size = value.size();
 
-        ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+        ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
         ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
         size_t old_size = offsets_to.back();
 
@@ -264,9 +265,9 @@ public:
         if (size)
         {
             typename ColumnInt64::Container & ts_to
-                = static_cast<ColumnInt64 &>(static_cast<ColumnTuple &>(arr_to.getData()).getColumn(0)).getData();
+                = assert_cast<ColumnInt64 &>(assert_cast<ColumnTuple &>(arr_to.getData()).getColumn(0)).getData();
             typename ColumnFloat64::Container & val_to
-                = static_cast<ColumnFloat64 &>(static_cast<ColumnTuple &>(arr_to.getData()).getColumn(1)).getData();
+                = assert_cast<ColumnFloat64 &>(assert_cast<ColumnTuple &>(arr_to.getData()).getColumn(1)).getData();
             ts_to.reserve(old_size + size);
             val_to.reserve(old_size + size);
             size_t i = 0;

dbms/src/AggregateFunctions/AggregateFunctionTopK.h

@@ -10,8 +10,8 @@
 #include <Columns/ColumnArray.h>
 
 #include <Common/SpaceSaving.h>
-
 #include <Common/FieldVisitors.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
 
@@ -62,9 +62,9 @@ public:
             set.resize(reserved);
 
         if constexpr (is_weighted)
-            set.insert(static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num], columns[1]->getUInt(row_num));
+            set.insert(assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num], columns[1]->getUInt(row_num));
         else
-            set.insert(static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
+            set.insert(assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num]);
     }
 
     void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena *) const override
@@ -86,7 +86,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+        ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
         ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
 
         const typename State::Set & set = this->data(place).value;
@@ -95,7 +95,7 @@ public:
 
         offsets_to.push_back(offsets_to.back() + size);
 
-        typename ColumnVector<T>::Container & data_to = static_cast<ColumnVector<T> &>(arr_to.getData()).getData();
+        typename ColumnVector<T>::Container & data_to = assert_cast<ColumnVector<T> &>(arr_to.getData()).getData();
         size_t old_size = data_to.size();
         data_to.resize(old_size + size);
 
@@ -215,7 +215,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        ColumnArray & arr_to = static_cast<ColumnArray &>(to);
+        ColumnArray & arr_to = assert_cast<ColumnArray &>(to);
         ColumnArray::Offsets & offsets_to = arr_to.getOffsets();
         IColumn & data_to = arr_to.getData();
 

dbms/src/AggregateFunctions/AggregateFunctionUniq.h

@@ -17,6 +17,7 @@
 #include <Common/HyperLogLogWithSmallSetOptimization.h>
 #include <Common/CombinedCardinalityEstimator.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/UniquesHashSet.h>
 #include <AggregateFunctions/IAggregateFunction.h>
@@ -170,7 +171,7 @@ struct OneAdder
         {
             if constexpr (!std::is_same_v<T, String>)
             {
-                const auto & value = static_cast<const ColumnVector<T> &>(column).getData()[row_num];
+                const auto & value = assert_cast<const ColumnVector<T> &>(column).getData()[row_num];
                 data.set.insert(AggregateFunctionUniqTraits<T>::hash(value));
             }
             else
@@ -183,7 +184,7 @@ struct OneAdder
         {
             if constexpr (!std::is_same_v<T, String>)
             {
-                data.set.insert(static_cast<const ColumnVector<T> &>(column).getData()[row_num]);
+                data.set.insert(assert_cast<const ColumnVector<T> &>(column).getData()[row_num]);
             }
             else
             {
@@ -240,7 +241,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).set.size());
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).set.size());
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }
@@ -296,7 +297,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).set.size());
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).set.size());
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }

dbms/src/AggregateFunctions/AggregateFunctionUniqCombined.h

@@ -4,6 +4,7 @@
 #include <Common/FieldVisitors.h>
 #include <Common/SipHash.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypeUUID.h>
@@ -131,7 +132,7 @@ public:
     {
         if constexpr (!std::is_same_v<T, String>)
         {
-            const auto & value = static_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num];
+            const auto & value = assert_cast<const ColumnVector<T> &>(*columns[0]).getData()[row_num];
             this->data(place).set.insert(detail::AggregateFunctionUniqCombinedTraits<T>::hash(value));
         }
         else
@@ -158,7 +159,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).set.size());
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).set.size());
     }
 
     const char * getHeaderFilePath() const override
@@ -222,7 +223,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).set.size());
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).set.size());
     }
 
     const char * getHeaderFilePath() const override

dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.h

@@ -2,6 +2,7 @@
 
 #include <Common/FieldVisitors.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <AggregateFunctions/UniqVariadicHash.h>
@@ -101,7 +102,7 @@ struct __attribute__((__packed__)) AggregateFunctionUniqUpToData
 
     void add(const IColumn & column, size_t row_num, UInt8 threshold)
     {
-        insert(static_cast<const ColumnVector<T> &>(column).getData()[row_num], threshold);
+        insert(assert_cast<const ColumnVector<T> &>(column).getData()[row_num], threshold);
     }
 };
 
@@ -123,7 +124,7 @@ struct AggregateFunctionUniqUpToData<UInt128> : AggregateFunctionUniqUpToData<UI
 {
     void add(const IColumn & column, size_t row_num, UInt8 threshold)
     {
-        UInt128 value = static_cast<const ColumnVector<UInt128> &>(column).getData()[row_num];
+        UInt128 value = assert_cast<const ColumnVector<UInt128> &>(column).getData()[row_num];
         insert(sipHash64(value), threshold);
     }
 };
@@ -176,7 +177,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).size());
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).size());
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }
@@ -240,7 +241,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).size());
+        assert_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).size());
     }
 
     const char * getHeaderFilePath() const override { return __FILE__; }

dbms/src/AggregateFunctions/AggregateFunctionWindowFunnel.h

@@ -9,6 +9,7 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <Common/ArenaAllocator.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
 
@@ -215,11 +216,11 @@ public:
 
     void add(AggregateDataPtr place, const IColumn ** columns, const size_t row_num, Arena *) const override
     {
-        const auto timestamp = static_cast<const ColumnVector<T> *>(columns[0])->getData()[row_num];
+        const auto timestamp = assert_cast<const ColumnVector<T> *>(columns[0])->getData()[row_num];
         // reverse iteration and stable sorting are needed for events that are qualified by more than one condition.
         for (auto i = events_size; i > 0; --i)
         {
-            auto event = static_cast<const ColumnVector<UInt8> *>(columns[i])->getData()[row_num];
+            auto event = assert_cast<const ColumnVector<UInt8> *>(columns[i])->getData()[row_num];
             if (event)
                 this->data(place).add(timestamp, i);
         }
@@ -242,7 +243,7 @@ public:
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
     {
-        static_cast<ColumnUInt8 &>(to).getData().push_back(getEventLevel(this->data(place)));
+        assert_cast<ColumnUInt8 &>(to).getData().push_back(getEventLevel(this->data(place)));
     }
 
     const char * getHeaderFilePath() const override

dbms/src/AggregateFunctions/UniqVariadicHash.h

@@ -4,6 +4,7 @@
 #include <Core/Defines.h>
 #include <Common/SipHash.h>
 #include <Common/UInt128.h>
+#include <Common/assert_cast.h>
 #include <Columns/ColumnTuple.h>
 
 
@@ -67,7 +68,7 @@ struct UniqVariadicHash<false, true>
     {
         UInt64 hash;
 
-        const auto & tuple_columns = static_cast<const ColumnTuple *>(columns[0])->getColumns();
+        const auto & tuple_columns = assert_cast<const ColumnTuple *>(columns[0])->getColumns();
 
         const auto * column = tuple_columns.data();
         const auto * columns_end = column + num_args;
@@ -116,7 +117,7 @@ struct UniqVariadicHash<true, true>
 {
     static inline UInt128 apply(size_t num_args, const IColumn ** columns, size_t row_num)
     {
-        const auto & tuple_columns = static_cast<const ColumnTuple *>(columns[0])->getColumns();
+        const auto & tuple_columns = assert_cast<const ColumnTuple *>(columns[0])->getColumns();
 
         const auto * column = tuple_columns.data();
         const auto * columns_end = column + num_args;

dbms/src/Columns/ColumnAggregateFunction.cpp

@@ -1,5 +1,6 @@
 #include <Columns/ColumnAggregateFunction.h>
 #include <Columns/ColumnsCommon.h>
+#include <Common/assert_cast.h>
 #include <AggregateFunctions/AggregateFunctionState.h>
 #include <DataStreams/ColumnGathererStream.h>
 #include <IO/WriteBufferFromArena.h>
@@ -158,7 +159,7 @@ void ColumnAggregateFunction::ensureOwnership()
 
 void ColumnAggregateFunction::insertRangeFrom(const IColumn & from, size_t start, size_t length)
 {
-    const ColumnAggregateFunction & from_concrete = static_cast<const ColumnAggregateFunction &>(from);
+    const ColumnAggregateFunction & from_concrete = assert_cast<const ColumnAggregateFunction &>(from);
 
     if (start + length > from_concrete.data.size())
         throw Exception("Parameters start = " + toString(start) + ", length = " + toString(length)
@@ -353,7 +354,7 @@ void ColumnAggregateFunction::insertMergeFrom(ConstAggregateDataPtr place)
 
 void ColumnAggregateFunction::insertMergeFrom(const IColumn & from, size_t n)
 {
-    insertMergeFrom(static_cast<const ColumnAggregateFunction &>(from).data[n]);
+    insertMergeFrom(assert_cast<const ColumnAggregateFunction &>(from).data[n]);
 }
 
 Arena & ColumnAggregateFunction::createOrGetArena()
@@ -492,7 +493,7 @@ MutableColumns ColumnAggregateFunction::scatter(IColumn::ColumnIndex num_columns
     }
 
     for (size_t i = 0; i < num_rows; ++i)
-        static_cast<ColumnAggregateFunction &>(*columns[selector[i]]).data.push_back(data[i]);
+        assert_cast<ColumnAggregateFunction &>(*columns[selector[i]]).data.push_back(data[i]);
 
     return columns;
 }

dbms/src/Columns/ColumnArray.cpp

@@ -16,7 +16,7 @@
 #include <Common/Arena.h>
 #include <Common/SipHash.h>
 #include <Common/typeid_cast.h>
-
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -227,7 +227,7 @@ void ColumnArray::insert(const Field & x)
 
 void ColumnArray::insertFrom(const IColumn & src_, size_t n)
 {
-    const ColumnArray & src = static_cast<const ColumnArray &>(src_);
+    const ColumnArray & src = assert_cast<const ColumnArray &>(src_);
     size_t size = src.sizeAt(n);
     size_t offset = src.offsetAt(n);
 
@@ -257,7 +257,7 @@ void ColumnArray::popBack(size_t n)
 
 int ColumnArray::compareAt(size_t n, size_t m, const IColumn & rhs_, int nan_direction_hint) const
 {
-    const ColumnArray & rhs = static_cast<const ColumnArray &>(rhs_);
+    const ColumnArray & rhs = assert_cast<const ColumnArray &>(rhs_);
 
     /// Suboptimal
     size_t lhs_size = sizeAt(n);
@@ -373,7 +373,7 @@ void ColumnArray::insertRangeFrom(const IColumn & src, size_t start, size_t leng
     if (length == 0)
         return;
 
-    const ColumnArray & src_concrete = static_cast<const ColumnArray &>(src);
+    const ColumnArray & src_concrete = assert_cast<const ColumnArray &>(src);
 
     if (start + length > src_concrete.getOffsets().size())
         throw Exception("Parameter out of bound in ColumnArray::insertRangeFrom method. [start(" + std::to_string(start) + ") + length(" + std::to_string(length) + ") > offsets.size(" + std::to_string(src_concrete.getOffsets().size()) + ")]",
@@ -429,10 +429,10 @@ ColumnPtr ColumnArray::filterNumber(const Filter & filt, ssize_t result_size_hin
 
     auto res = ColumnArray::create(data->cloneEmpty());
 
-    auto & res_elems = static_cast<ColumnVector<T> &>(res->getData()).getData();
+    auto & res_elems = assert_cast<ColumnVector<T> &>(res->getData()).getData();
     Offsets & res_offsets = res->getOffsets();
 
-    filterArraysImpl<T>(static_cast<const ColumnVector<T> &>(*data).getData(), getOffsets(), res_elems, res_offsets, filt, result_size_hint);
+    filterArraysImpl<T>(assert_cast<const ColumnVector<T> &>(*data).getData(), getOffsets(), res_elems, res_offsets, filt, result_size_hint);
     return res;
 }
 
@@ -554,11 +554,11 @@ ColumnPtr ColumnArray::filterNullable(const Filter & filt, ssize_t result_size_h
     if (getOffsets().size() == 0)
         return ColumnArray::create(data);
 
-    const ColumnNullable & nullable_elems = static_cast<const ColumnNullable &>(*data);
+    const ColumnNullable & nullable_elems = assert_cast<const ColumnNullable &>(*data);
 
     auto array_of_nested = ColumnArray::create(nullable_elems.getNestedColumnPtr(), offsets);
     auto filtered_array_of_nested_owner = array_of_nested->filter(filt, result_size_hint);
-    auto & filtered_array_of_nested = static_cast<const ColumnArray &>(*filtered_array_of_nested_owner);
+    auto & filtered_array_of_nested = assert_cast<const ColumnArray &>(*filtered_array_of_nested_owner);
     auto & filtered_offsets = filtered_array_of_nested.getOffsetsPtr();
 
     auto res_null_map = ColumnUInt8::create();
@@ -577,7 +577,7 @@ ColumnPtr ColumnArray::filterTuple(const Filter & filt, ssize_t result_size_hint
     if (getOffsets().size() == 0)
         return ColumnArray::create(data);
 
-    const ColumnTuple & tuple = static_cast<const ColumnTuple &>(*data);
+    const ColumnTuple & tuple = assert_cast<const ColumnTuple &>(*data);
 
     /// Make temporary arrays for each components of Tuple, then filter and collect back.
 
@@ -593,11 +593,11 @@ ColumnPtr ColumnArray::filterTuple(const Filter & filt, ssize_t result_size_hint
 
     Columns tuple_columns(tuple_size);
     for (size_t i = 0; i < tuple_size; ++i)
-        tuple_columns[i] = static_cast<const ColumnArray &>(*temporary_arrays[i]).getDataPtr();
+        tuple_columns[i] = assert_cast<const ColumnArray &>(*temporary_arrays[i]).getDataPtr();
 
     return ColumnArray::create(
         ColumnTuple::create(tuple_columns),
-        static_cast<const ColumnArray &>(*temporary_arrays.front()).getOffsetsPtr());
+        assert_cast<const ColumnArray &>(*temporary_arrays.front()).getOffsetsPtr());
 }
 
 
@@ -789,7 +789,7 @@ ColumnPtr ColumnArray::replicateString(const Offsets & replicate_offsets) const
     if (0 == col_size)
         return res;
 
-    ColumnArray & res_ = static_cast<ColumnArray &>(*res);
+    ColumnArray & res_ = assert_cast<ColumnArray &>(*res);
 
     const ColumnString & src_string = typeid_cast<const ColumnString &>(*data);
     const ColumnString::Chars & src_chars = src_string.getChars();
@@ -901,7 +901,7 @@ ColumnPtr ColumnArray::replicateGeneric(const Offsets & replicate_offsets) const
         throw Exception("Size of offsets doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
 
     MutableColumnPtr res = cloneEmpty();
-    ColumnArray & res_concrete = static_cast<ColumnArray &>(*res);
+    ColumnArray & res_concrete = assert_cast<ColumnArray &>(*res);
 
     if (0 == col_size)
         return res;
@@ -922,7 +922,7 @@ ColumnPtr ColumnArray::replicateGeneric(const Offsets & replicate_offsets) const
 
 ColumnPtr ColumnArray::replicateNullable(const Offsets & replicate_offsets) const
 {
-    const ColumnNullable & nullable = static_cast<const ColumnNullable &>(*data);
+    const ColumnNullable & nullable = assert_cast<const ColumnNullable &>(*data);
 
     /// Make temporary arrays for each components of Nullable. Then replicate them independently and collect back to result.
     /// NOTE Offsets are calculated twice and it is redundant.
@@ -934,15 +934,15 @@ ColumnPtr ColumnArray::replicateNullable(const Offsets & replicate_offsets) cons
 
     return ColumnArray::create(
         ColumnNullable::create(
-            static_cast<const ColumnArray &>(*array_of_nested).getDataPtr(),
+            assert_cast<const ColumnArray &>(*array_of_nested).getDataPtr(),
-            static_cast<const ColumnArray &>(*array_of_null_map).getDataPtr()),
+            assert_cast<const ColumnArray &>(*array_of_null_map).getDataPtr()),
-        static_cast<const ColumnArray &>(*array_of_nested).getOffsetsPtr());
+        assert_cast<const ColumnArray &>(*array_of_nested).getOffsetsPtr());
 }
 
 
 ColumnPtr ColumnArray::replicateTuple(const Offsets & replicate_offsets) const
 {
-    const ColumnTuple & tuple = static_cast<const ColumnTuple &>(*data);
+    const ColumnTuple & tuple = assert_cast<const ColumnTuple &>(*data);
 
     /// Make temporary arrays for each components of Tuple. In the same way as for Nullable.
 
@@ -958,11 +958,11 @@ ColumnPtr ColumnArray::replicateTuple(const Offsets & replicate_offsets) const
 
     Columns tuple_columns(tuple_size);
     for (size_t i = 0; i < tuple_size; ++i)
-        tuple_columns[i] = static_cast<const ColumnArray &>(*temporary_arrays[i]).getDataPtr();
+        tuple_columns[i] = assert_cast<const ColumnArray &>(*temporary_arrays[i]).getDataPtr();
 
     return ColumnArray::create(
         ColumnTuple::create(tuple_columns),
-        static_cast<const ColumnArray &>(*temporary_arrays.front()).getOffsetsPtr());
+        assert_cast<const ColumnArray &>(*temporary_arrays.front()).getOffsetsPtr());
 }
 
 

dbms/src/Columns/ColumnArray.h

@@ -4,6 +4,7 @@
 #include <Columns/ColumnVector.h>
 #include <Core/Defines.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -89,12 +90,12 @@ public:
 
     Offsets & ALWAYS_INLINE getOffsets()
     {
-        return static_cast<ColumnOffsets &>(*offsets).getData();
+        return assert_cast<ColumnOffsets &>(*offsets).getData();
     }
 
     const Offsets & ALWAYS_INLINE getOffsets() const
     {
-        return static_cast<const ColumnOffsets &>(*offsets).getData();
+        return assert_cast<const ColumnOffsets &>(*offsets).getData();
     }
 
     const ColumnPtr & getDataPtr() const { return data; }

dbms/src/Columns/ColumnConst.h

@@ -4,6 +4,7 @@
 #include <Common/Exception.h>
 #include <Columns/IColumn.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -175,7 +176,7 @@ public:
 
     int compareAt(size_t, size_t, const IColumn & rhs, int nan_direction_hint) const override
     {
-        return data->compareAt(0, 0, *static_cast<const ColumnConst &>(rhs).data, nan_direction_hint);
+        return data->compareAt(0, 0, *assert_cast<const ColumnConst &>(rhs).data, nan_direction_hint);
     }
 
     MutableColumns scatter(ColumnIndex num_columns, const Selector & selector) const override;

dbms/src/Columns/ColumnDecimal.cpp

@@ -1,6 +1,7 @@
 #include <Common/Exception.h>
 #include <Common/Arena.h>
 #include <Common/SipHash.h>
+#include <Common/assert_cast.h>
 
 #include <common/unaligned.h>
 
@@ -133,7 +134,7 @@ void ColumnDecimal<T>::insertData(const char * src, size_t /*length*/)
 template <typename T>
 void ColumnDecimal<T>::insertRangeFrom(const IColumn & src, size_t start, size_t length)
 {
-    const ColumnDecimal & src_vec = static_cast<const ColumnDecimal &>(src);
+    const ColumnDecimal & src_vec = assert_cast<const ColumnDecimal &>(src);
 
     if (start + length > src_vec.data.size())
         throw Exception("Parameters start = " + toString(start) + ", length = " + toString(length) +

dbms/src/Columns/ColumnFixedString.cpp

@@ -5,6 +5,7 @@
 #include <Common/SipHash.h>
 #include <Common/memcpySmall.h>
 #include <Common/memcmpSmall.h>
+#include <Common/assert_cast.h>
 
 #include <DataStreams/ColumnGathererStream.h>
 
@@ -33,7 +34,7 @@ MutableColumnPtr ColumnFixedString::cloneResized(size_t size) const
 
     if (size > 0)
     {
-        auto & new_col = static_cast<ColumnFixedString &>(*new_col_holder);
+        auto & new_col = assert_cast<ColumnFixedString &>(*new_col_holder);
         new_col.chars.resize(size * n);
 
         size_t count = std::min(this->size(), size);
@@ -60,7 +61,7 @@ void ColumnFixedString::insert(const Field & x)
 
 void ColumnFixedString::insertFrom(const IColumn & src_, size_t index)
 {
-    const ColumnFixedString & src = static_cast<const ColumnFixedString &>(src_);
+    const ColumnFixedString & src = assert_cast<const ColumnFixedString &>(src_);
 
     if (n != src.getN())
         throw Exception("Size of FixedString doesn't match", ErrorCodes::SIZE_OF_FIXED_STRING_DOESNT_MATCH);
@@ -140,7 +141,7 @@ void ColumnFixedString::getPermutation(bool reverse, size_t limit, int /*nan_dir
 
 void ColumnFixedString::insertRangeFrom(const IColumn & src, size_t start, size_t length)
 {
-    const ColumnFixedString & src_concrete = static_cast<const ColumnFixedString &>(src);
+    const ColumnFixedString & src_concrete = assert_cast<const ColumnFixedString &>(src);
 
     if (start + length > src_concrete.size())
         throw Exception("Parameters start = "

dbms/src/Columns/ColumnFixedString.h

@@ -3,6 +3,7 @@
 #include <Common/PODArray.h>
 #include <Common/memcmpSmall.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Columns/IColumn.h>
 #include <Columns/ColumnVectorHelper.h>
 
@@ -102,7 +103,7 @@ public:
 
     int compareAt(size_t p1, size_t p2, const IColumn & rhs_, int /*nan_direction_hint*/) const override
     {
-        const ColumnFixedString & rhs = static_cast<const ColumnFixedString &>(rhs_);
+        const ColumnFixedString & rhs = assert_cast<const ColumnFixedString &>(rhs_);
         return memcmpSmallAllowOverflow15(chars.data() + p1 * n, rhs.chars.data() + p2 * n, n);
     }
 

dbms/src/Columns/ColumnLowCardinality.cpp

@@ -3,6 +3,8 @@
 #include <DataStreams/ColumnGathererStream.h>
 #include <DataTypes/NumberTraits.h>
 #include <Common/HashTable/HashMap.h>
+#include <Common/assert_cast.h>
+
 
 namespace DB
 {
@@ -244,7 +246,7 @@ MutableColumnPtr ColumnLowCardinality::cloneResized(size_t size) const
 
 int ColumnLowCardinality::compareAt(size_t n, size_t m, const IColumn & rhs, int nan_direction_hint) const
 {
-    const auto & low_cardinality_column = static_cast<const ColumnLowCardinality &>(rhs);
+    const auto & low_cardinality_column = assert_cast<const ColumnLowCardinality &>(rhs);
     size_t n_index = getIndexes().getUInt(n);
     size_t m_index = low_cardinality_column.getIndexes().getUInt(m);
     return getDictionary().compareAt(n_index, m_index, low_cardinality_column.getDictionary(), nan_direction_hint);

dbms/src/Columns/ColumnLowCardinality.h

@@ -2,6 +2,7 @@
 #include <Columns/IColumn.h>
 #include <Columns/IColumnUnique.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <AggregateFunctions/AggregateFunctionCount.h>
 #include "ColumnsNumber.h"
 
@@ -166,10 +167,10 @@ public:
 
         switch (idx.getSizeOfIndexType())
         {
-            case sizeof(UInt8): return static_cast<const ColumnUInt8 *>(indexes)->getElement(row);
+            case sizeof(UInt8): return assert_cast<const ColumnUInt8 *>(indexes)->getElement(row);
-            case sizeof(UInt16): return static_cast<const ColumnUInt16 *>(indexes)->getElement(row);
+            case sizeof(UInt16): return assert_cast<const ColumnUInt16 *>(indexes)->getElement(row);
-            case sizeof(UInt32): return static_cast<const ColumnUInt32 *>(indexes)->getElement(row);
+            case sizeof(UInt32): return assert_cast<const ColumnUInt32 *>(indexes)->getElement(row);
-            case sizeof(UInt64): return static_cast<const ColumnUInt64 *>(indexes)->getElement(row);
+            case sizeof(UInt64): return assert_cast<const ColumnUInt64 *>(indexes)->getElement(row);
             default: throw Exception("Unexpected size of index type for low cardinality column.", ErrorCodes::LOGICAL_ERROR);
         }
     }

dbms/src/Columns/ColumnNullable.cpp

@@ -2,6 +2,7 @@
 #include <Common/SipHash.h>
 #include <Common/NaNUtils.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Columns/ColumnNullable.h>
 #include <Columns/ColumnConst.h>
 #include <DataStreams/ColumnGathererStream.h>
@@ -129,7 +130,7 @@ const char * ColumnNullable::deserializeAndInsertFromArena(const char * pos)
 
 void ColumnNullable::insertRangeFrom(const IColumn & src, size_t start, size_t length)
 {
-    const ColumnNullable & nullable_col = static_cast<const ColumnNullable &>(src);
+    const ColumnNullable & nullable_col = assert_cast<const ColumnNullable &>(src);
     getNullMapColumn().insertRangeFrom(*nullable_col.null_map, start, length);
     getNestedColumn().insertRangeFrom(*nullable_col.nested_column, start, length);
 }
@@ -150,7 +151,7 @@ void ColumnNullable::insert(const Field & x)
 
 void ColumnNullable::insertFrom(const IColumn & src, size_t n)
 {
-    const ColumnNullable & src_concrete = static_cast<const ColumnNullable &>(src);
+    const ColumnNullable & src_concrete = assert_cast<const ColumnNullable &>(src);
     getNestedColumn().insertFrom(src_concrete.getNestedColumn(), n);
     getNullMapData().push_back(src_concrete.getNullMapData()[n]);
 }
@@ -190,7 +191,7 @@ int ColumnNullable::compareAt(size_t n, size_t m, const IColumn & rhs_, int null
     /// the ordering specified by either NULLS FIRST or NULLS LAST in the
     /// ORDER BY construction.
 
-    const ColumnNullable & nullable_rhs = static_cast<const ColumnNullable &>(rhs_);
+    const ColumnNullable & nullable_rhs = assert_cast<const ColumnNullable &>(rhs_);
 
     bool lval_is_null = isNullAt(n);
     bool rval_is_null = nullable_rhs.isNullAt(m);
@@ -458,7 +459,7 @@ ColumnPtr makeNullable(const ColumnPtr & column)
         return column;
 
     if (isColumnConst(*column))
-        return ColumnConst::create(makeNullable(static_cast<const ColumnConst &>(*column).getDataColumnPtr()), column->size());
+        return ColumnConst::create(makeNullable(assert_cast<const ColumnConst &>(*column).getDataColumnPtr()), column->size());
 
     return ColumnNullable::create(column, ColumnUInt8::create(column->size(), 0));
 }

dbms/src/Columns/ColumnNullable.h

@@ -3,6 +3,7 @@
 #include <Columns/IColumn.h>
 #include <Columns/ColumnsNumber.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -45,7 +46,7 @@ public:
     std::string getName() const override { return "Nullable(" + nested_column->getName() + ")"; }
     MutableColumnPtr cloneResized(size_t size) const override;
     size_t size() const override { return nested_column->size(); }
-    bool isNullAt(size_t n) const override { return static_cast<const ColumnUInt8 &>(*null_map).getData()[n] != 0;}
+    bool isNullAt(size_t n) const override { return assert_cast<const ColumnUInt8 &>(*null_map).getData()[n] != 0;}
     Field operator[](size_t n) const override;
     void get(size_t n, Field & res) const override;
     bool getBool(size_t n) const override { return isNullAt(n) ? 0 : nested_column->getBool(n); }
@@ -116,8 +117,8 @@ public:
     /// Return the column that represents the byte map.
     const ColumnPtr & getNullMapColumnPtr() const { return null_map; }
 
-    ColumnUInt8 & getNullMapColumn() { return static_cast<ColumnUInt8 &>(*null_map); }
+    ColumnUInt8 & getNullMapColumn() { return assert_cast<ColumnUInt8 &>(*null_map); }
-    const ColumnUInt8 & getNullMapColumn() const { return static_cast<const ColumnUInt8 &>(*null_map); }
+    const ColumnUInt8 & getNullMapColumn() const { return assert_cast<const ColumnUInt8 &>(*null_map); }
 
     NullMap & getNullMapData() { return getNullMapColumn().getData(); }
     const NullMap & getNullMapData() const { return getNullMapColumn().getData(); }

dbms/src/Columns/ColumnString.cpp

@@ -1,6 +1,7 @@
 #include <Core/Defines.h>
 #include <Common/Arena.h>
 #include <Common/memcmpSmall.h>
+#include <Common/assert_cast.h>
 #include <Columns/Collator.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnsCommon.h>
@@ -68,7 +69,7 @@ void ColumnString::insertRangeFrom(const IColumn & src, size_t start, size_t len
     if (length == 0)
         return;
 
-    const ColumnString & src_concrete = static_cast<const ColumnString &>(src);
+    const ColumnString & src_concrete = assert_cast<const ColumnString &>(src);
 
     if (start + length > src_concrete.offsets.size())
         throw Exception("Parameter out of bound in IColumnString::insertRangeFrom method.",
@@ -360,7 +361,7 @@ void ColumnString::getExtremes(Field & min, Field & max) const
 
 int ColumnString::compareAtWithCollation(size_t n, size_t m, const IColumn & rhs_, const Collator & collator) const
 {
-    const ColumnString & rhs = static_cast<const ColumnString &>(rhs_);
+    const ColumnString & rhs = assert_cast<const ColumnString &>(rhs_);
 
     return collator.compare(
         reinterpret_cast<const char *>(&chars[offsetAt(n)]), sizeAt(n),

dbms/src/Columns/ColumnString.h

@@ -8,6 +8,7 @@
 #include <Common/SipHash.h>
 #include <Common/memcpySmall.h>
 #include <Common/memcmpSmall.h>
+#include <Common/assert_cast.h>
 
 
 class Collator;
@@ -121,7 +122,7 @@ public:
 
     void insertFrom(const IColumn & src_, size_t n) override
     {
-        const ColumnString & src = static_cast<const ColumnString &>(src_);
+        const ColumnString & src = assert_cast<const ColumnString &>(src_);
         const size_t size_to_append = src.offsets[n] - src.offsets[n - 1];  /// -1th index is Ok, see PaddedPODArray.
 
         if (size_to_append == 1)
@@ -204,7 +205,7 @@ public:
 
     int compareAt(size_t n, size_t m, const IColumn & rhs_, int /*nan_direction_hint*/) const override
     {
-        const ColumnString & rhs = static_cast<const ColumnString &>(rhs_);
+        const ColumnString & rhs = assert_cast<const ColumnString &>(rhs_);
         return memcmpSmallAllowOverflow15(chars.data() + offsetAt(n), sizeAt(n) - 1, rhs.chars.data() + rhs.offsetAt(m), rhs.sizeAt(m) - 1);
     }
 

dbms/src/Columns/ColumnTuple.cpp

@@ -5,6 +5,7 @@
 #include <ext/map.h>
 #include <ext/range.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -118,7 +119,7 @@ void ColumnTuple::insert(const Field & x)
 
 void ColumnTuple::insertFrom(const IColumn & src_, size_t n)
 {
-    const ColumnTuple & src = static_cast<const ColumnTuple &>(src_);
+    const ColumnTuple & src = assert_cast<const ColumnTuple &>(src_);
 
     const size_t tuple_size = columns.size();
     if (src.columns.size() != tuple_size)
@@ -172,7 +173,7 @@ void ColumnTuple::insertRangeFrom(const IColumn & src, size_t start, size_t leng
     const size_t tuple_size = columns.size();
     for (size_t i = 0; i < tuple_size; ++i)
         columns[i]->insertRangeFrom(
-            *static_cast<const ColumnTuple &>(src).columns[i],
+            *assert_cast<const ColumnTuple &>(src).columns[i],
             start, length);
 }
 
@@ -245,7 +246,7 @@ int ColumnTuple::compareAt(size_t n, size_t m, const IColumn & rhs, int nan_dire
 {
     const size_t tuple_size = columns.size();
     for (size_t i = 0; i < tuple_size; ++i)
-        if (int res = columns[i]->compareAt(n, m, *static_cast<const ColumnTuple &>(rhs).columns[i], nan_direction_hint))
+        if (int res = columns[i]->compareAt(n, m, *assert_cast<const ColumnTuple &>(rhs).columns[i], nan_direction_hint))
             return res;
 
     return 0;

dbms/src/Columns/ColumnUnique.h

@@ -11,6 +11,7 @@
 #include <DataTypes/NumberTraits.h>
 
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <ext/range.h>
 
 #include <common/unaligned.h>
@@ -140,8 +141,8 @@ private:
     static size_t numSpecialValues(bool is_nullable) { return is_nullable ? 2 : 1; }
     size_t numSpecialValues() const { return numSpecialValues(is_nullable); }
 
-    ColumnType * getRawColumnPtr() { return static_cast<ColumnType *>(column_holder.get()); }
+    ColumnType * getRawColumnPtr() { return assert_cast<ColumnType *>(column_holder.get()); }
-    const ColumnType * getRawColumnPtr() const { return static_cast<const ColumnType *>(column_holder.get()); }
+    const ColumnType * getRawColumnPtr() const { return assert_cast<const ColumnType *>(column_holder.get()); }
 
     template <typename IndexType>
     MutableColumnPtr uniqueInsertRangeImpl(
@@ -232,7 +233,7 @@ void ColumnUnique<ColumnType>::updateNullMask()
         size_t size = getRawColumnPtr()->size();
 
         if (nested_null_mask->size() != size)
-            static_cast<ColumnUInt8 &>(*nested_null_mask).getData().resize_fill(size);
+            assert_cast<ColumnUInt8 &>(*nested_null_mask).getData().resize_fill(size);
     }
 }
 

dbms/src/Columns/ColumnVector.cpp

@@ -8,6 +8,7 @@
 #include <Common/SipHash.h>
 #include <Common/NaNUtils.h>
 #include <Common/RadixSort.h>
+#include <Common/assert_cast.h>
 #include <IO/WriteBuffer.h>
 #include <IO/WriteHelpers.h>
 #include <Columns/ColumnsCommon.h>
@@ -224,7 +225,7 @@ Float64 ColumnVector<T>::getFloat64(size_t n) const
 template <typename T>
 void ColumnVector<T>::insertRangeFrom(const IColumn & src, size_t start, size_t length)
 {
-    const ColumnVector & src_vec = static_cast<const ColumnVector &>(src);
+    const ColumnVector & src_vec = assert_cast<const ColumnVector &>(src);
 
     if (start + length > src_vec.data.size())
         throw Exception("Parameters start = "

dbms/src/Columns/ColumnsCommon.cpp

@@ -61,43 +61,18 @@ std::vector<size_t> countColumnsSizeInSelector(IColumn::ColumnIndex num_columns,
     return counts;
 }
 
-/** clang 4 generates better code than gcc 6.
+bool memoryIsByte(const void * data, size_t size, uint8_t byte)
-  * And both gcc and clang could not vectorize trivial loop by bytes automatically.
-  */
-bool memoryIsZero(const void * data, size_t size)
 {
-    const Int8 * pos = reinterpret_cast<const Int8 *>(data);
+    if (size == 0)
-    const Int8 * end = pos + size;
-
-#ifdef __SSE2__
-    const __m128 zero16 = _mm_setzero_ps();
-    const Int8 * end64 = pos + size / 64 * 64;
-
-    for (; pos < end64; pos += 64)
-        if (_mm_movemask_ps(_mm_cmpneq_ps(
-                _mm_loadu_ps(reinterpret_cast<const float *>(pos)),
-                zero16))
-            | _mm_movemask_ps(_mm_cmpneq_ps(
-                _mm_loadu_ps(reinterpret_cast<const float *>(pos + 16)),
-                zero16))
-            | _mm_movemask_ps(_mm_cmpneq_ps(
-                _mm_loadu_ps(reinterpret_cast<const float *>(pos + 32)),
-                zero16))
-            | _mm_movemask_ps(_mm_cmpneq_ps(
-                _mm_loadu_ps(reinterpret_cast<const float *>(pos + 48)),
-                zero16)))
-            return false;
-
-    /// TODO Add duff device for tail?
-#endif
-
-    for (; pos < end; ++pos)
-        if (*pos)
-            return false;
-
         return true;
+    auto ptr = reinterpret_cast<const uint8_t *>(data);
+    return *ptr == byte && memcmp(ptr, ptr + 1, size - 1) == 0;
 }
 
+bool memoryIsZero(const void * data, size_t size)
+{
+    return memoryIsByte(data, size, 0x0);
+}
 
 namespace ErrorCodes
 {

dbms/src/Columns/ColumnsCommon.h

@@ -22,7 +22,7 @@ std::vector<size_t> countColumnsSizeInSelector(IColumn::ColumnIndex num_columns,
 
 /// Returns true, if the memory contains only zeros.
 bool memoryIsZero(const void * data, size_t size);
-
+bool memoryIsByte(const void * data, size_t size, uint8_t byte);
 
 /// The general implementation of `filter` function for ColumnArray and ColumnString.
 template <typename T>

dbms/src/Columns/FilterDescription.cpp

@@ -1,4 +1,5 @@
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Columns/FilterDescription.h>
 #include <Columns/ColumnsNumber.h>
 #include <Columns/ColumnNullable.h>
@@ -25,7 +26,7 @@ ConstantFilterDescription::ConstantFilterDescription(const IColumn & column)
 
     if (isColumnConst(column))
     {
-        const ColumnConst & column_const = static_cast<const ColumnConst &>(column);
+        const ColumnConst & column_const = assert_cast<const ColumnConst &>(column);
         ColumnPtr column_nested = column_const.getDataColumnPtr()->convertToFullColumnIfLowCardinality();
 
         if (!typeid_cast<const ColumnUInt8 *>(column_nested.get()))

dbms/src/Columns/ReverseIndex.h

@@ -5,6 +5,7 @@
 #include <Common/HashTable/HashTableAllocator.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnsNumber.h>
+#include <Common/assert_cast.h>
 #include <ext/range.h>
 #include <common/unaligned.h>
 

dbms/src/Columns/getLeastSuperColumn.cpp

@@ -1,6 +1,7 @@
 #include <Columns/getLeastSuperColumn.h>
 #include <Columns/IColumn.h>
 #include <Columns/ColumnConst.h>
+#include <Common/assert_cast.h>
 #include <DataTypes/getLeastSupertype.h>
 
 
@@ -14,7 +15,7 @@ namespace ErrorCodes
 
 static bool sameConstants(const IColumn & a, const IColumn & b)
 {
-    return static_cast<const ColumnConst &>(a).getField() == static_cast<const ColumnConst &>(b).getField();
+    return assert_cast<const ColumnConst &>(a).getField() == assert_cast<const ColumnConst &>(b).getField();
 }
 
 ColumnWithTypeAndName getLeastSuperColumn(std::vector<const ColumnWithTypeAndName *> columns)
@@ -57,7 +58,7 @@ ColumnWithTypeAndName getLeastSuperColumn(std::vector<const ColumnWithTypeAndNam
     }
 
     if (save_constness)
-        result.column = result.type->createColumnConst(0, static_cast<const ColumnConst &>(*columns[0]->column).getField());
+        result.column = result.type->createColumnConst(0, assert_cast<const ColumnConst &>(*columns[0]->column).getField());
     else
         result.column = result.type->createColumn();
 

dbms/src/Common/ColumnsHashing.h

@@ -4,6 +4,7 @@
 #include <Common/ColumnsHashingImpl.h>
 #include <Common/Arena.h>
 #include <Common/LRUCache.h>
+#include <Common/assert_cast.h>
 #include <common/unaligned.h>
 
 #include <Columns/ColumnString.h>
@@ -80,7 +81,7 @@ struct HashMethodString
     HashMethodString(const ColumnRawPtrs & key_columns, const Sizes & /*key_sizes*/, const HashMethodContextPtr &)
     {
         const IColumn & column = *key_columns[0];
-        const ColumnString & column_string = static_cast<const ColumnString &>(column);
+        const ColumnString & column_string = assert_cast<const ColumnString &>(column);
         offsets = column_string.getOffsets().data();
         chars = column_string.getChars().data();
     }
@@ -120,7 +121,7 @@ struct HashMethodFixedString
     HashMethodFixedString(const ColumnRawPtrs & key_columns, const Sizes & /*key_sizes*/, const HashMethodContextPtr &)
     {
         const IColumn & column = *key_columns[0];
-        const ColumnFixedString & column_string = static_cast<const ColumnFixedString &>(column);
+        const ColumnFixedString & column_string = assert_cast<const ColumnFixedString &>(column);
         n = column_string.getN();
         chars = &column_string.getChars();
     }
@@ -307,10 +308,10 @@ struct HashMethodSingleLowCardinalityColumn : public SingleColumnMethod
     {
         switch (size_of_index_type)
         {
-            case sizeof(UInt8): return static_cast<const ColumnUInt8 *>(positions)->getElement(row);
+            case sizeof(UInt8): return assert_cast<const ColumnUInt8 *>(positions)->getElement(row);
-            case sizeof(UInt16): return static_cast<const ColumnUInt16 *>(positions)->getElement(row);
+            case sizeof(UInt16): return assert_cast<const ColumnUInt16 *>(positions)->getElement(row);
-            case sizeof(UInt32): return static_cast<const ColumnUInt32 *>(positions)->getElement(row);
+            case sizeof(UInt32): return assert_cast<const ColumnUInt32 *>(positions)->getElement(row);
-            case sizeof(UInt64): return static_cast<const ColumnUInt64 *>(positions)->getElement(row);
+            case sizeof(UInt64): return assert_cast<const ColumnUInt64 *>(positions)->getElement(row);
             default: throw Exception("Unexpected size of index type for low cardinality column.", ErrorCodes::LOGICAL_ERROR);
         }
     }

dbms/src/Common/ColumnsHashingImpl.h

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <Columns/IColumn.h>
+#include <Common/assert_cast.h>
 #include <Interpreters/AggregationCommon.h>
 
+
 namespace DB
 {
 
@@ -310,7 +312,7 @@ protected:
         {
             if (null_maps[k] != nullptr)
             {
-                const auto & null_map = static_cast<const ColumnUInt8 &>(*null_maps[k]).getData();
+                const auto & null_map = assert_cast<const ColumnUInt8 &>(*null_maps[k]).getData();
                 if (null_map[row] == 1)
                 {
                     size_t bucket = k / 8;

dbms/src/Common/CurrentMetrics.cpp

@@ -49,6 +49,7 @@
     M(GlobalThreadActive, "Number of threads in global thread pool running a task.") \
     M(LocalThread, "Number of threads in local thread pools. Should be similar to GlobalThreadActive.") \
     M(LocalThreadActive, "Number of threads in local thread pools running a task.") \
+    M(DistributedFilesToInsert, "Number of pending files to process for asynchronous insertion into Distributed tables. Number of files for every shard is summed.") \
 
 
 namespace CurrentMetrics

dbms/src/Common/ErrorCodes.cpp

@@ -443,7 +443,8 @@ namespace ErrorCodes
     extern const int INSECURE_PATH = 466;
     extern const int CANNOT_PARSE_BOOL = 467;
     extern const int CANNOT_PTHREAD_ATTR = 468;
-    extern const int QUERY_IS_NOT_SUPPORTED_IN_LIVE_VIEW = 469;
+    extern const int VIOLATED_CONSTRAINT = 469;
+    extern const int QUERY_IS_NOT_SUPPORTED_IN_LIVE_VIEW = 470;
 
     extern const int KEEPER_EXCEPTION = 999;
     extern const int POCO_EXCEPTION = 1000;

dbms/src/Common/SymbolIndex.cpp

@@ -10,6 +10,49 @@
 //#include <iostream>
 #include <filesystem>
 
+/**
+
+ELF object can contain three different places with symbol names and addresses:
+
+1. Symbol table in section headers. It is used for static linking and usually left in executable.
+It is not loaded in memory and they are not necessary for program to run.
+It does not relate to debug info and present regardless to -g flag.
+You can use strip to get rid of this symbol table.
+If you have this symbol table in your binary, you can manually read it and get symbol names, even for symbols from anonymous namespaces.
+
+2. Hashes in program headers such as DT_HASH and DT_GNU_HASH.
+It is necessary for dynamic object (.so libraries and any dynamically linked executable that depend on .so libraries)
+because it is used for dynamic linking that happens in runtime and performed by dynamic loader.
+Only exported symbols will be presented in that hash tables. Symbols from anonymous namespaces are not.
+This part of executable binary is loaded in memory and accessible via 'dl_iterate_phdr', 'dladdr' and 'backtrace_symbols' functions from libc.
+ClickHouse versions prior to 19.13 has used just these symbol names to symbolize stack traces
+and stack traces may be incomplete due to lack of symbols with internal linkage.
+But because ClickHouse is linked with most of the symbols exported (-rdynamic flag) it can still provide good enough stack traces.
+
+3. DWARF debug info. It contains the most detailed information about symbols and everything else.
+It allows to get source file names and line numbers from addresses. Only available if you use -g option for compiler.
+It is also used by default for ClickHouse builds, but because of its weight (about two gigabytes)
+it is splitted to separate binary and provided in clickhouse-common-static-dbg package.
+This separate binary is placed in /usr/lib/debug/usr/bin/clickhouse and is loaded automatically by tools like gdb, addr2line.
+When you build ClickHouse by yourself, debug info is not splitted and present in a single huge binary.
+
+What ClickHouse is using to provide good stack traces?
+
+In versions prior to 19.13, only "program headers" (2) was used.
+
+In version 19.13, ClickHouse will read program headers (2) and cache them,
+also it will read itself as ELF binary and extract symbol tables from section headers (1)
+to also symbolize functions that are not exported for dynamic linking.
+And finally, it will read DWARF info (3) if available to display file names and line numbers.
+
+What detail can you obtain depending on your binary?
+
+If you have debug info (you build ClickHouse by yourself or install clickhouse-common-static-dbg package), you will get source file names and line numbers.
+Otherwise you will get only symbol names. If your binary contains symbol table in section headers (the default, unless stripped), you will get all symbol names.
+Otherwise you will get only exported symbols from program headers.
+
+*/
+
 
 namespace DB
 {
@@ -64,13 +107,14 @@ void collectSymbolsFromProgramHeaders(dl_phdr_info * info,
         size_t sym_cnt = 0;
         for (auto it = dyn_begin; it->d_tag != DT_NULL; ++it)
         {
-            if (it->d_tag == DT_HASH)
+            // TODO: this branch leads to invalid address of the hash table. Need further investigation.
-            {
+            // if (it->d_tag == DT_HASH)
-                const ElfW(Word) * hash = reinterpret_cast<const ElfW(Word) *>(correct_address(info->dlpi_addr, it->d_un.d_ptr));
+            // {
-                sym_cnt = hash[1];
+            //     const ElfW(Word) * hash = reinterpret_cast<const ElfW(Word) *>(correct_address(info->dlpi_addr, it->d_un.d_ptr));
-                break;
+            //     sym_cnt = hash[1];
-            }
+            //     break;
-            else if (it->d_tag == DT_GNU_HASH)
+            // }
+            if (it->d_tag == DT_GNU_HASH)
             {
                 /// This code based on Musl-libc.
 

dbms/src/Common/assert_cast.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <type_traits>
+#include <typeinfo>
+#include <typeindex>
+#include <string>
+
+#include <Common/Exception.h>
+#include <common/demangle.h>
+
+
+namespace DB
+{
+    namespace ErrorCodes
+    {
+        extern const int BAD_CAST;
+    }
+}
+
+
+/** Perform static_cast in release build.
+  * Checks type by comparing typeid and throw an exception in debug build.
+  * The exact match of the type is checked. That is, cast to the ancestor will be unsuccessful.
+  */
+template <typename To, typename From>
+To assert_cast(From && from)
+{
+#ifndef NDEBUG
+    try
+    {
+        if constexpr (std::is_pointer_v<To>)
+        {
+            if (typeid(*from) == typeid(std::remove_pointer_t<To>))
+                return static_cast<To>(from);
+        }
+        else
+        {
+            if (typeid(from) == typeid(To))
+                return static_cast<To>(from);
+        }
+    }
+    catch (const std::exception & e)
+    {
+        throw DB::Exception(e.what(), DB::ErrorCodes::BAD_CAST);
+    }
+
+    throw DB::Exception("Bad cast from type " + demangle(typeid(from).name()) + " to " + demangle(typeid(To).name()),
+                        DB::ErrorCodes::BAD_CAST);
+#else
+    return static_cast<To>(from);
+#endif
+}

dbms/src/Core/Block.cpp

@@ -5,7 +5,9 @@
 
 #include <IO/WriteBufferFromString.h>
 #include <IO/Operators.h>
+
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 #include <Columns/ColumnConst.h>
 
@@ -484,8 +486,8 @@ static ReturnType checkBlockStructure(const Block & lhs, const Block & rhs, cons
 
         if (isColumnConst(*actual.column) && isColumnConst(*expected.column))
         {
-            Field actual_value = static_cast<const ColumnConst &>(*actual.column).getField();
+            Field actual_value = assert_cast<const ColumnConst &>(*actual.column).getField();
-            Field expected_value = static_cast<const ColumnConst &>(*expected.column).getField();
+            Field expected_value = assert_cast<const ColumnConst &>(*expected.column).getField();
 
             if (actual_value != expected_value)
                 return on_error("Block structure mismatch in " + context_description + " stream: different values of constants, actual: "

dbms/src/Core/Defines.h

@@ -33,8 +33,6 @@
 #define DEFAULT_MERGE_BLOCK_SIZE 8192
 
 #define DEFAULT_TEMPORARY_LIVE_VIEW_TIMEOUT_SEC 5
-#define DEFAULT_TEMPORARY_LIVE_CHANNEL_TIMEOUT_SEC 15
-#define DEFAULT_ALTER_LIVE_CHANNEL_WAIT_MS 10000
 #define SHOW_CHARS_ON_SYNTAX_ERROR ptrdiff_t(160)
 #define DEFAULT_LIVE_VIEW_HEARTBEAT_INTERVAL_SEC 15
 #define DBMS_DEFAULT_DISTRIBUTED_CONNECTIONS_POOL_SIZE 1024

dbms/src/Core/Settings.h

@@ -333,7 +333,7 @@ struct Settings : public SettingsCollection<Settings>
     M(SettingBool, external_table_functions_use_nulls, true, "If it is set to true, external table functions will implicitly use Nullable type if needed. Otherwise NULLs will be substituted with default values. Currently supported only for 'mysql' table function.") \
     M(SettingBool, allow_experimental_data_skipping_indices, false, "If it is set to true, data skipping indices can be used in CREATE TABLE/ALTER TABLE queries.") \
     \
-    M(SettingBool, experimental_use_processors, false, "Use processors pipeline.") \
+    M(SettingBool, experimental_use_processors, true, "Use processors pipeline.") \
     \
     M(SettingBool, allow_hyperscan, true, "Allow functions that use Hyperscan library. Disable to avoid potentially long compilation times and excessive resource usage.") \
     M(SettingBool, allow_simdjson, true, "Allow using simdjson library in 'JSON*' functions if AVX2 instructions are available. If disabled rapidjson will be used.") \
@@ -341,16 +341,16 @@ struct Settings : public SettingsCollection<Settings>
     \
     M(SettingUInt64, max_partitions_per_insert_block, 100, "Limit maximum number of partitions in single INSERTed block. Zero means unlimited. Throw exception if the block contains too many partitions. This setting is a safety threshold, because using large number of partitions is a common misconception.") \
     M(SettingBool, check_query_single_value_result, true, "Return check query result as single 1/0 value") \
+    M(SettingBool, allow_drop_detached, false, "Allow ALTER TABLE ... DROP DETACHED PART[ITION] ... queries") \
+    \
+    M(SettingBool, allow_experimental_live_view, false, "Enable LIVE VIEW. Not mature enough.") \
+    M(SettingSeconds, live_view_heartbeat_interval, DEFAULT_LIVE_VIEW_HEARTBEAT_INTERVAL_SEC, "The heartbeat interval in seconds to indicate live query is alive.") \
+    M(SettingSeconds, temporary_live_view_timeout, DEFAULT_TEMPORARY_LIVE_VIEW_TIMEOUT_SEC, "Timeout after which temporary live view is deleted.") \
+    M(SettingUInt64, max_live_view_insert_blocks_before_refresh, 64, "Limit maximum number of inserted blocks after which mergeable blocks are dropped and query is re-executed.") \
     \
     /** Obsolete settings that do nothing but left for compatibility reasons. Remove each one after half a year of obsolescence. */ \
     \
     M(SettingBool, allow_experimental_low_cardinality_type, true, "Obsolete setting, does nothing. Will be removed after 2019-08-13") \
-    \
-    M(SettingSeconds, live_view_heartbeat_interval, DEFAULT_LIVE_VIEW_HEARTBEAT_INTERVAL_SEC, "The heartbeat interval in seconds to indicate live query is alive.") \
-    M(SettingSeconds, temporary_live_view_timeout, DEFAULT_TEMPORARY_LIVE_VIEW_TIMEOUT_SEC, "Timeout after which temporary live view is deleted.") \
-    M(SettingSeconds, temporary_live_channel_timeout, DEFAULT_TEMPORARY_LIVE_CHANNEL_TIMEOUT_SEC, "Timeout after which temporary live channel is deleted.") \
-    M(SettingMilliseconds, alter_channel_wait_ms, DEFAULT_ALTER_LIVE_CHANNEL_WAIT_MS, "The wait time for alter channel request.") \
-    M(SettingUInt64, max_live_view_insert_blocks_before_refresh, 64, "Limit maximum number of inserted blocks after which mergeable blocks are dropped and query is re-executed.") \
 
     DECLARE_SETTINGS_COLLECTION(LIST_OF_SETTINGS)
 

dbms/src/Core/SortCursor.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Core/SortDescription.h>
 #include <Core/Block.h>
 #include <Core/ColumnNumbers.h>
@@ -167,7 +168,7 @@ struct SortCursorWithCollation
             int res;
             if (impl->need_collation[i])
             {
-                const ColumnString & column_string = static_cast<const ColumnString &>(*impl->sort_columns[i]);
+                const ColumnString & column_string = assert_cast<const ColumnString &>(*impl->sort_columns[i]);
                 res = column_string.compareAtWithCollation(lhs_pos, rhs_pos, *(rhs.impl->sort_columns[i]), *impl->desc[i].collator);
             }
             else

dbms/src/DataStreams/CheckConstraintsBlockOutputStream.cpp

@@ -0,0 +1,79 @@
+#include <DataStreams/CheckConstraintsBlockOutputStream.h>
+#include <Functions/FunctionHelpers.h>
+#include <common/find_symbols.h>
+#include <Parsers/formatAST.h>
+#include <Columns/ColumnsCommon.h>
+
+namespace DB
+{
+
+void CheckConstraintsBlockOutputStream::write(const Block & block)
+{
+    for (size_t i = 0; i < expressions.size(); ++i)
+    {
+        Block res = block;
+        auto constraint_expr = expressions[i];
+        auto res_column_uint8 = executeOnBlock(res, constraint_expr);
+        if (!memoryIsByte(res_column_uint8->getRawDataBegin<1>(), res_column_uint8->byteSize(), 0x1))
+        {
+            auto indices_wrong = findAllWrong(res_column_uint8->getRawDataBegin<1>(), res_column_uint8->byteSize());
+            std::string indices_str = "{";
+            for (size_t j = 0; j < indices_wrong.size(); ++j)
+            {
+                indices_str += std::to_string(indices_wrong[j]);
+                indices_str += (j != indices_wrong.size() - 1) ? ", " : "}";
+            }
+
+            throw Exception{"Violated constraint " + constraints.constraints[i]->name +
+                            " in table " + table + " at indices " + indices_str + ", constraint expression: " +
+                            serializeAST(*(constraints.constraints[i]->expr), true), ErrorCodes::VIOLATED_CONSTRAINT};
+        }
+    }
+    output->write(block);
+    rows_written += block.rows();
+}
+
+void CheckConstraintsBlockOutputStream::flush()
+{
+    output->flush();
+}
+
+void CheckConstraintsBlockOutputStream::writePrefix()
+{
+    output->writePrefix();
+}
+
+void CheckConstraintsBlockOutputStream::writeSuffix()
+{
+    output->writeSuffix();
+}
+
+const ColumnUInt8 *CheckConstraintsBlockOutputStream::executeOnBlock(
+        Block & block,
+        const ExpressionActionsPtr & constraint)
+{
+    constraint->execute(block);
+    ColumnWithTypeAndName res_column = block.safeGetByPosition(block.columns() - 1);
+    return checkAndGetColumn<ColumnUInt8>(res_column.column.get());
+}
+
+std::vector<size_t> CheckConstraintsBlockOutputStream::findAllWrong(const void *data, size_t size)
+{
+    std::vector<size_t> res;
+
+    if (size == 0)
+        return res;
+
+    auto ptr = reinterpret_cast<const uint8_t *>(data);
+
+    for (size_t i = 0; i < size; ++i)
+    {
+        if (*(ptr + i) == 0x0)
+        {
+            res.push_back(i);
+        }
+    }
+
+    return res;
+}
+}

dbms/src/DataStreams/CheckConstraintsBlockOutputStream.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <DataStreams/IBlockOutputStream.h>
+#include <Storages/ConstraintsDescription.h>
+#include <DataStreams/OneBlockInputStream.h>
+#include <DataStreams/ExpressionBlockInputStream.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int VIOLATED_CONSTRAINT;
+}
+
+class CheckConstraintsBlockOutputStream : public IBlockOutputStream
+{
+public:
+    CheckConstraintsBlockOutputStream(
+            const String & table_,
+            const BlockOutputStreamPtr & output_,
+            const Block & header_,
+            const ConstraintsDescription & constraints_,
+            const Context & context_)
+            : table(table_),
+              output(output_),
+              header(header_),
+              constraints(constraints_),
+              expressions(constraints_.getExpressions(context_, header.getNamesAndTypesList())),
+              rows_written(0)
+    { }
+
+    Block getHeader() const override { return header; }
+    void write(const Block & block) override;
+
+    void flush() override;
+
+    void writePrefix() override;
+    void writeSuffix() override;
+
+private:
+    const ColumnUInt8* executeOnBlock(Block & block, const ExpressionActionsPtr & constraint);
+    std::vector<size_t> findAllWrong(const void *data, size_t size);
+
+    String table;
+    BlockOutputStreamPtr output;
+    Block header;
+    const ConstraintsDescription constraints;
+    const ConstraintsExpressions expressions;
+    size_t rows_written;
+};
+}

dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp

@@ -1,4 +1,5 @@
 #include <Common/FieldVisitors.h>
+#include <Common/assert_cast.h>
 #include <DataStreams/CollapsingSortedBlockInputStream.h>
 #include <Columns/ColumnsNumber.h>
 
@@ -118,7 +119,7 @@ void CollapsingSortedBlockInputStream::merge(MutableColumns & merged_columns, st
         if (current_key.empty())
             setPrimaryKeyRef(current_key, current);
 
-        Int8 sign = static_cast<const ColumnInt8 &>(*current->all_columns[sign_column_number]).getData()[current->pos];
+        Int8 sign = assert_cast<const ColumnInt8 &>(*current->all_columns[sign_column_number]).getData()[current->pos];
         setPrimaryKeyRef(next_key, current);
 
         bool key_differs = next_key != current_key;

dbms/src/DataStreams/ConvertingBlockInputStream.cpp

@@ -1,6 +1,7 @@
 #include <DataStreams/ConvertingBlockInputStream.h>
 #include <Interpreters/castColumn.h>
 #include <Columns/ColumnConst.h>
+#include <Common/assert_cast.h>
 #include <Parsers/IAST.h>
 
 
@@ -75,7 +76,7 @@ ConvertingBlockInputStream::ConvertingBlockInputStream(
                 throw Exception("Cannot convert column " + backQuoteIfNeed(res_elem.name)
                     + " because it is non constant in source stream but must be constant in result",
                     ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
-            else if (static_cast<const ColumnConst &>(*src_elem.column).getField() != static_cast<const ColumnConst &>(*res_elem.column).getField())
+            else if (assert_cast<const ColumnConst &>(*src_elem.column).getField() != assert_cast<const ColumnConst &>(*res_elem.column).getField())
                 throw Exception("Cannot convert column " + backQuoteIfNeed(res_elem.name)
                     + " because it is constant but values of constants are different in source and result",
                     ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);

dbms/src/DataStreams/PushingToViewsBlockOutputStream.cpp

@@ -12,7 +12,7 @@
 #include <Common/ThreadPool.h>
 #include <Storages/MergeTree/ReplicatedMergeTreeBlockOutputStream.h>
 #include <Storages/StorageValues.h>
-#include <Storages/StorageLiveView.h>
+#include <Storages/LiveView/StorageLiveView.h>
 
 namespace DB
 {
@@ -106,8 +106,7 @@ void PushingToViewsBlockOutputStream::write(const Block & block)
 
     if (auto * live_view = dynamic_cast<StorageLiveView *>(storage.get()))
     {
-        BlockOutputStreamPtr output_ = std::make_shared<LiveViewBlockOutputStream>(*live_view);
+        StorageLiveView::writeIntoLiveView(*live_view, block, context);
-        StorageLiveView::writeIntoLiveView(*live_view, block, context, output_);
     }
     else
     {

dbms/src/DataStreams/PushingToViewsBlockOutputStream.h

@@ -5,7 +5,6 @@
 #include <DataStreams/OneBlockInputStream.h>
 #include <DataStreams/MaterializingBlockInputStream.h>
 #include <Storages/StorageMaterializedView.h>
-#include <Storages/StorageLiveView.h>
 
 namespace DB
 {

dbms/src/DataStreams/SummingSortedBlockInputStream.cpp

@@ -10,6 +10,7 @@
 #include <Common/FieldVisitors.h>
 #include <common/logger_useful.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 #include <AggregateFunctions/AggregateFunctionFactory.h>
 #include <Functions/FunctionFactory.h>
@@ -297,7 +298,7 @@ Block SummingSortedBlockInputStream::readImpl()
             /// Unpack tuple into block.
             size_t tuple_size = desc.column_numbers.size();
             for (size_t i = 0; i < tuple_size; ++i)
-                res.getByPosition(desc.column_numbers[i]).column = static_cast<const ColumnTuple &>(*desc.merged_column).getColumnPtr(i);
+                res.getByPosition(desc.column_numbers[i]).column = assert_cast<const ColumnTuple &>(*desc.merged_column).getColumnPtr(i);
         }
         else
             res.getByPosition(desc.column_numbers[0]).column = std::move(desc.merged_column);
@@ -491,7 +492,7 @@ void SummingSortedBlockInputStream::addRow(SortCursor & cursor)
         {
             // desc.state is not used for AggregateFunction types
             auto & col = cursor->all_columns[desc.column_numbers[0]];
-            static_cast<ColumnAggregateFunction &>(*desc.merged_column).insertMergeFrom(*col, cursor->pos);
+            assert_cast<ColumnAggregateFunction &>(*desc.merged_column).insertMergeFrom(*col, cursor->pos);
         }
         else
         {

dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp

@@ -5,6 +5,7 @@
 #include <Columns/ColumnAggregateFunction.h>
 #include <Columns/FilterDescription.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Common/Arena.h>
 
 
@@ -155,7 +156,7 @@ void TotalsHavingBlockInputStream::addToTotals(const Block & source_block, const
             continue;
         }
 
-        auto & totals_column = static_cast<ColumnAggregateFunction &>(*current_totals[i]);
+        auto & totals_column = assert_cast<ColumnAggregateFunction &>(*current_totals[i]);
         assert(totals_column.size() == 1);
 
         /// Accumulate all aggregate states from a column of a source block into

dbms/src/DataStreams/VersionedCollapsingSortedBlockInputStream.cpp

@@ -1,4 +1,5 @@
 #include <Common/FieldVisitors.h>
+#include <Common/assert_cast.h>
 #include <DataStreams/VersionedCollapsingSortedBlockInputStream.h>
 #include <Columns/ColumnsNumber.h>
 
@@ -112,7 +113,7 @@ void VersionedCollapsingSortedBlockInputStream::merge(MutableColumns & merged_co
 
         RowRef next_key;
 
-        Int8 sign = static_cast<const ColumnInt8 &>(*current->all_columns[sign_column_number]).getData()[current->pos];
+        Int8 sign = assert_cast<const ColumnInt8 &>(*current->all_columns[sign_column_number]).getData()[current->pos];
 
         setPrimaryKeyRef(next_key, current);
 

dbms/src/DataTypes/DataTypeAggregateFunction.cpp

@@ -6,6 +6,7 @@
 #include <Columns/ColumnAggregateFunction.h>
 
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Common/AlignedBuffer.h>
 
 #include <Formats/FormatSettings.h>
@@ -77,12 +78,12 @@ void DataTypeAggregateFunction::deserializeBinary(Field & field, ReadBuffer & is
 
 void DataTypeAggregateFunction::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    function->serialize(static_cast<const ColumnAggregateFunction &>(column).getData()[row_num], ostr);
+    function->serialize(assert_cast<const ColumnAggregateFunction &>(column).getData()[row_num], ostr);
 }
 
 void DataTypeAggregateFunction::deserializeBinary(IColumn & column, ReadBuffer & istr) const
 {
-    ColumnAggregateFunction & column_concrete = static_cast<ColumnAggregateFunction &>(column);
+    ColumnAggregateFunction & column_concrete = assert_cast<ColumnAggregateFunction &>(column);
 
     Arena & arena = column_concrete.createOrGetArena();
     size_t size_of_state = function->sizeOfData();
@@ -155,13 +156,13 @@ void DataTypeAggregateFunction::deserializeBinaryBulk(IColumn & column, ReadBuff
 static String serializeToString(const AggregateFunctionPtr & function, const IColumn & column, size_t row_num)
 {
     WriteBufferFromOwnString buffer;
-    function->serialize(static_cast<const ColumnAggregateFunction &>(column).getData()[row_num], buffer);
+    function->serialize(assert_cast<const ColumnAggregateFunction &>(column).getData()[row_num], buffer);
     return buffer.str();
 }
 
 static void deserializeFromString(const AggregateFunctionPtr & function, IColumn & column, const String & s)
 {
-    ColumnAggregateFunction & column_concrete = static_cast<ColumnAggregateFunction &>(column);
+    ColumnAggregateFunction & column_concrete = assert_cast<ColumnAggregateFunction &>(column);
 
     Arena & arena = column_concrete.createOrGetArena();
     size_t size_of_state = function->sizeOfData();
@@ -262,13 +263,13 @@ void DataTypeAggregateFunction::serializeProtobuf(const IColumn & column, size_t
     if (value_index)
         return;
     value_index = static_cast<bool>(
-        protobuf.writeAggregateFunction(function, static_cast<const ColumnAggregateFunction &>(column).getData()[row_num]));
+        protobuf.writeAggregateFunction(function, assert_cast<const ColumnAggregateFunction &>(column).getData()[row_num]));
 }
 
 void DataTypeAggregateFunction::deserializeProtobuf(IColumn & column, ProtobufReader & protobuf, bool allow_add_row, bool & row_added) const
 {
     row_added = false;
-    ColumnAggregateFunction & column_concrete = static_cast<ColumnAggregateFunction &>(column);
+    ColumnAggregateFunction & column_concrete = assert_cast<ColumnAggregateFunction &>(column);
     Arena & arena = column_concrete.createOrGetArena();
     size_t size_of_state = function->sizeOfData();
     AggregateDataPtr place = arena.alignedAlloc(size_of_state, function->alignOfData());

dbms/src/DataTypes/DataTypeArray.cpp

@@ -14,6 +14,7 @@
 #include <Parsers/IAST.h>
 
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -57,7 +58,7 @@ void DataTypeArray::deserializeBinary(Field & field, ReadBuffer & istr) const
 
 void DataTypeArray::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    const ColumnArray & column_array = static_cast<const ColumnArray &>(column);
+    const ColumnArray & column_array = assert_cast<const ColumnArray &>(column);
     const ColumnArray::Offsets & offsets = column_array.getOffsets();
 
     size_t offset = offsets[row_num - 1];
@@ -74,7 +75,7 @@ void DataTypeArray::serializeBinary(const IColumn & column, size_t row_num, Writ
 
 void DataTypeArray::deserializeBinary(IColumn & column, ReadBuffer & istr) const
 {
-    ColumnArray & column_array = static_cast<ColumnArray &>(column);
+    ColumnArray & column_array = assert_cast<ColumnArray &>(column);
     ColumnArray::Offsets & offsets = column_array.getOffsets();
 
     size_t size;
@@ -278,7 +279,7 @@ void DataTypeArray::deserializeBinaryBulkWithMultipleStreams(
 template <typename Writer>
 static void serializeTextImpl(const IColumn & column, size_t row_num, WriteBuffer & ostr, Writer && write_nested)
 {
-    const ColumnArray & column_array = static_cast<const ColumnArray &>(column);
+    const ColumnArray & column_array = assert_cast<const ColumnArray &>(column);
     const ColumnArray::Offsets & offsets = column_array.getOffsets();
 
     size_t offset = offsets[row_num - 1];
@@ -300,7 +301,7 @@ static void serializeTextImpl(const IColumn & column, size_t row_num, WriteBuffe
 template <typename Reader>
 static void deserializeTextImpl(IColumn & column, ReadBuffer & istr, Reader && read_nested)
 {
-    ColumnArray & column_array = static_cast<ColumnArray &>(column);
+    ColumnArray & column_array = assert_cast<ColumnArray &>(column);
     ColumnArray::Offsets & offsets = column_array.getOffsets();
 
     IColumn & nested_column = column_array.getData();
@@ -367,7 +368,7 @@ void DataTypeArray::deserializeText(IColumn & column, ReadBuffer & istr, const F
 
 void DataTypeArray::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    const ColumnArray & column_array = static_cast<const ColumnArray &>(column);
+    const ColumnArray & column_array = assert_cast<const ColumnArray &>(column);
     const ColumnArray::Offsets & offsets = column_array.getOffsets();
 
     size_t offset = offsets[row_num - 1];
@@ -394,7 +395,7 @@ void DataTypeArray::deserializeTextJSON(IColumn & column, ReadBuffer & istr, con
 
 void DataTypeArray::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    const ColumnArray & column_array = static_cast<const ColumnArray &>(column);
+    const ColumnArray & column_array = assert_cast<const ColumnArray &>(column);
     const ColumnArray::Offsets & offsets = column_array.getOffsets();
 
     size_t offset = offsets[row_num - 1];
@@ -433,7 +434,7 @@ void DataTypeArray::deserializeTextCSV(IColumn & column, ReadBuffer & istr, cons
 
 void DataTypeArray::serializeProtobuf(const IColumn & column, size_t row_num, ProtobufWriter & protobuf, size_t & value_index) const
 {
-    const ColumnArray & column_array = static_cast<const ColumnArray &>(column);
+    const ColumnArray & column_array = assert_cast<const ColumnArray &>(column);
     const ColumnArray::Offsets & offsets = column_array.getOffsets();
     size_t offset = offsets[row_num - 1] + value_index;
     size_t next_offset = offsets[row_num];
@@ -453,7 +454,7 @@ void DataTypeArray::serializeProtobuf(const IColumn & column, size_t row_num, Pr
 void DataTypeArray::deserializeProtobuf(IColumn & column, ProtobufReader & protobuf, bool allow_add_row, bool & row_added) const
 {
     row_added = false;
-    ColumnArray & column_array = static_cast<ColumnArray &>(column);
+    ColumnArray & column_array = assert_cast<ColumnArray &>(column);
     IColumn & nested_column = column_array.getData();
     ColumnArray::Offsets & offsets = column_array.getOffsets();
     size_t old_size = offsets.size();

dbms/src/DataTypes/DataTypeDate.cpp

@@ -7,13 +7,15 @@
 #include <Formats/ProtobufReader.h>
 #include <Formats/ProtobufWriter.h>
 
+#include <Common/assert_cast.h>
+
 
 namespace DB
 {
 
 void DataTypeDate::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeDateText(DayNum(static_cast<const ColumnUInt16 &>(column).getData()[row_num]), ostr);
+    writeDateText(DayNum(assert_cast<const ColumnUInt16 &>(column).getData()[row_num]), ostr);
 }
 
 void DataTypeDate::deserializeWholeText(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const
@@ -25,7 +27,7 @@ void DataTypeDate::deserializeTextEscaped(IColumn & column, ReadBuffer & istr, c
 {
     DayNum x;
     readDateText(x, istr);
-    static_cast<ColumnUInt16 &>(column).getData().push_back(x);
+    assert_cast<ColumnUInt16 &>(column).getData().push_back(x);
 }
 
 void DataTypeDate::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -46,7 +48,7 @@ void DataTypeDate::deserializeTextQuoted(IColumn & column, ReadBuffer & istr, co
     assertChar('\'', istr);
     readDateText(x, istr);
     assertChar('\'', istr);
-    static_cast<ColumnUInt16 &>(column).getData().push_back(x);    /// It's important to do this at the end - for exception safety.
+    assert_cast<ColumnUInt16 &>(column).getData().push_back(x);    /// It's important to do this at the end - for exception safety.
 }
 
 void DataTypeDate::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -62,7 +64,7 @@ void DataTypeDate::deserializeTextJSON(IColumn & column, ReadBuffer & istr, cons
     assertChar('"', istr);
     readDateText(x, istr);
     assertChar('"', istr);
-    static_cast<ColumnUInt16 &>(column).getData().push_back(x);
+    assert_cast<ColumnUInt16 &>(column).getData().push_back(x);
 }
 
 void DataTypeDate::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -76,14 +78,14 @@ void DataTypeDate::deserializeTextCSV(IColumn & column, ReadBuffer & istr, const
 {
     LocalDate value;
     readCSV(value, istr);
-    static_cast<ColumnUInt16 &>(column).getData().push_back(value.getDayNum());
+    assert_cast<ColumnUInt16 &>(column).getData().push_back(value.getDayNum());
 }
 
 void DataTypeDate::serializeProtobuf(const IColumn & column, size_t row_num, ProtobufWriter & protobuf, size_t & value_index) const
 {
     if (value_index)
         return;
-    value_index = static_cast<bool>(protobuf.writeDate(DayNum(static_cast<const ColumnUInt16 &>(column).getData()[row_num])));
+    value_index = static_cast<bool>(protobuf.writeDate(DayNum(assert_cast<const ColumnUInt16 &>(column).getData()[row_num])));
 }
 
 void DataTypeDate::deserializeProtobuf(IColumn & column, ProtobufReader & protobuf, bool allow_add_row, bool & row_added) const
@@ -93,7 +95,7 @@ void DataTypeDate::deserializeProtobuf(IColumn & column, ProtobufReader & protob
     if (!protobuf.readDate(d))
         return;
 
-    auto & container = static_cast<ColumnUInt16 &>(column).getData();
+    auto & container = assert_cast<ColumnUInt16 &>(column).getData();
     if (allow_add_row)
     {
         container.emplace_back(d);

dbms/src/DataTypes/DataTypeDateTime.cpp

@@ -4,6 +4,7 @@
 
 #include <common/DateLUT.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Columns/ColumnsNumber.h>
 #include <Formats/FormatSettings.h>
 #include <Formats/ProtobufReader.h>
@@ -39,7 +40,7 @@ std::string DataTypeDateTime::doGetName() const
 
 void DataTypeDateTime::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeDateTimeText(static_cast<const ColumnUInt32 &>(column).getData()[row_num], ostr, time_zone);
+    writeDateTimeText(assert_cast<const ColumnUInt32 &>(column).getData()[row_num], ostr, time_zone);
 }
 
 void DataTypeDateTime::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -71,7 +72,7 @@ void DataTypeDateTime::deserializeTextEscaped(IColumn & column, ReadBuffer & ist
 {
     time_t x;
     readText(x, istr, settings, time_zone, utc_time_zone);
-    static_cast<ColumnUInt32 &>(column).getData().push_back(x);
+    assert_cast<ColumnUInt32 &>(column).getData().push_back(x);
 }
 
 void DataTypeDateTime::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -93,7 +94,7 @@ void DataTypeDateTime::deserializeTextQuoted(IColumn & column, ReadBuffer & istr
     {
         readIntText(x, istr);
     }
-    static_cast<ColumnUInt32 &>(column).getData().push_back(x);    /// It's important to do this at the end - for exception safety.
+    assert_cast<ColumnUInt32 &>(column).getData().push_back(x);    /// It's important to do this at the end - for exception safety.
 }
 
 void DataTypeDateTime::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -115,7 +116,7 @@ void DataTypeDateTime::deserializeTextJSON(IColumn & column, ReadBuffer & istr,
     {
         readIntText(x, istr);
     }
-    static_cast<ColumnUInt32 &>(column).getData().push_back(x);
+    assert_cast<ColumnUInt32 &>(column).getData().push_back(x);
 }
 
 void DataTypeDateTime::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -142,14 +143,14 @@ void DataTypeDateTime::deserializeTextCSV(IColumn & column, ReadBuffer & istr, c
     if (maybe_quote == '\'' || maybe_quote == '\"')
         assertChar(maybe_quote, istr);
 
-    static_cast<ColumnUInt32 &>(column).getData().push_back(x);
+    assert_cast<ColumnUInt32 &>(column).getData().push_back(x);
 }
 
 void DataTypeDateTime::serializeProtobuf(const IColumn & column, size_t row_num, ProtobufWriter & protobuf, size_t & value_index) const
 {
     if (value_index)
         return;
-    value_index = static_cast<bool>(protobuf.writeDateTime(static_cast<const ColumnUInt32 &>(column).getData()[row_num]));
+    value_index = static_cast<bool>(protobuf.writeDateTime(assert_cast<const ColumnUInt32 &>(column).getData()[row_num]));
 }
 
 void DataTypeDateTime::deserializeProtobuf(IColumn & column, ProtobufReader & protobuf, bool allow_add_row, bool & row_added) const
@@ -159,7 +160,7 @@ void DataTypeDateTime::deserializeProtobuf(IColumn & column, ProtobufReader & pr
     if (!protobuf.readDateTime(t))
         return;
 
-    auto & container = static_cast<ColumnUInt32 &>(column).getData();
+    auto & container = assert_cast<ColumnUInt32 &>(column).getData();
     if (allow_add_row)
     {
         container.emplace_back(t);

dbms/src/DataTypes/DataTypeEnum.cpp

@@ -8,6 +8,7 @@
 #include <Parsers/ASTFunction.h>
 #include <Parsers/ASTLiteral.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Common/UTF8Helpers.h>
 #include <Poco/UTF8Encoding.h>
 
@@ -120,7 +121,7 @@ void DataTypeEnum<Type>::deserializeBinary(Field & field, ReadBuffer & istr) con
 template <typename Type>
 void DataTypeEnum<Type>::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    writeBinary(static_cast<const ColumnType &>(column).getData()[row_num], ostr);
+    writeBinary(assert_cast<const ColumnType &>(column).getData()[row_num], ostr);
 }
 
 template <typename Type>
@@ -128,19 +129,19 @@ void DataTypeEnum<Type>::deserializeBinary(IColumn & column, ReadBuffer & istr)
 {
     typename ColumnType::value_type x;
     readBinary(x, istr);
-    static_cast<ColumnType &>(column).getData().push_back(x);
+    assert_cast<ColumnType &>(column).getData().push_back(x);
 }
 
 template <typename Type>
 void DataTypeEnum<Type>::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeString(getNameForValue(static_cast<const ColumnType &>(column).getData()[row_num]), ostr);
+    writeString(getNameForValue(assert_cast<const ColumnType &>(column).getData()[row_num]), ostr);
 }
 
 template <typename Type>
 void DataTypeEnum<Type>::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeEscapedString(getNameForValue(static_cast<const ColumnType &>(column).getData()[row_num]), ostr);
+    writeEscapedString(getNameForValue(assert_cast<const ColumnType &>(column).getData()[row_num]), ostr);
 }
 
 template <typename Type>
@@ -149,13 +150,13 @@ void DataTypeEnum<Type>::deserializeTextEscaped(IColumn & column, ReadBuffer & i
     /// NOTE It would be nice to do without creating a temporary object - at least extract std::string out.
     std::string field_name;
     readEscapedString(field_name, istr);
-    static_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
+    assert_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
 }
 
 template <typename Type>
 void DataTypeEnum<Type>::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeQuotedString(getNameForValue(static_cast<const ColumnType &>(column).getData()[row_num]), ostr);
+    writeQuotedString(getNameForValue(assert_cast<const ColumnType &>(column).getData()[row_num]), ostr);
 }
 
 template <typename Type>
@@ -163,7 +164,7 @@ void DataTypeEnum<Type>::deserializeTextQuoted(IColumn & column, ReadBuffer & is
 {
     std::string field_name;
     readQuotedStringWithSQLStyle(field_name, istr);
-    static_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
+    assert_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
 }
 
 template <typename Type>
@@ -171,19 +172,19 @@ void DataTypeEnum<Type>::deserializeWholeText(IColumn & column, ReadBuffer & ist
 {
     std::string field_name;
     readString(field_name, istr);
-    static_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
+    assert_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
 }
 
 template <typename Type>
 void DataTypeEnum<Type>::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    writeJSONString(getNameForValue(static_cast<const ColumnType &>(column).getData()[row_num]), ostr, settings);
+    writeJSONString(getNameForValue(assert_cast<const ColumnType &>(column).getData()[row_num]), ostr, settings);
 }
 
 template <typename Type>
 void DataTypeEnum<Type>::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeXMLString(getNameForValue(static_cast<const ColumnType &>(column).getData()[row_num]), ostr);
+    writeXMLString(getNameForValue(assert_cast<const ColumnType &>(column).getData()[row_num]), ostr);
 }
 
 template <typename Type>
@@ -191,13 +192,13 @@ void DataTypeEnum<Type>::deserializeTextJSON(IColumn & column, ReadBuffer & istr
 {
     std::string field_name;
     readJSONString(field_name, istr);
-    static_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
+    assert_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
 }
 
 template <typename Type>
 void DataTypeEnum<Type>::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeCSVString(getNameForValue(static_cast<const ColumnType &>(column).getData()[row_num]), ostr);
+    writeCSVString(getNameForValue(assert_cast<const ColumnType &>(column).getData()[row_num]), ostr);
 }
 
 template <typename Type>
@@ -205,7 +206,7 @@ void DataTypeEnum<Type>::deserializeTextCSV(IColumn & column, ReadBuffer & istr,
 {
     std::string field_name;
     readCSVString(field_name, istr, settings.csv);
-    static_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
+    assert_cast<ColumnType &>(column).getData().push_back(getValue(StringRef(field_name)));
 }
 
 template <typename Type>
@@ -238,7 +239,7 @@ void DataTypeEnum<Type>::serializeProtobuf(const IColumn & column, size_t row_nu
     if (value_index)
         return;
     protobuf.prepareEnumMapping(values);
-    value_index = static_cast<bool>(protobuf.writeEnum(static_cast<const ColumnType &>(column).getData()[row_num]));
+    value_index = static_cast<bool>(protobuf.writeEnum(assert_cast<const ColumnType &>(column).getData()[row_num]));
 }
 
 template<typename Type>
@@ -250,7 +251,7 @@ void DataTypeEnum<Type>::deserializeProtobuf(IColumn & column, ProtobufReader &
     if (!protobuf.readEnum(value))
         return;
 
-    auto & container = static_cast<ColumnType &>(column).getData();
+    auto & container = assert_cast<ColumnType &>(column).getData();
     if (allow_add_row)
     {
         container.emplace_back(value);
@@ -269,7 +270,7 @@ Field DataTypeEnum<Type>::getDefault() const
 template <typename Type>
 void DataTypeEnum<Type>::insertDefaultInto(IColumn & column) const
 {
-    static_cast<ColumnType &>(column).getData().push_back(values.front().second);
+    assert_cast<ColumnType &>(column).getData().push_back(values.front().second);
 }
 
 template <typename Type>

dbms/src/DataTypes/DataTypeFixedString.cpp

@@ -17,6 +17,7 @@
 #include <Parsers/ASTLiteral.h>
 
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -58,13 +59,13 @@ void DataTypeFixedString::deserializeBinary(Field & field, ReadBuffer & istr) co
 
 void DataTypeFixedString::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    ostr.write(reinterpret_cast<const char *>(&static_cast<const ColumnFixedString &>(column).getChars()[n * row_num]), n);
+    ostr.write(reinterpret_cast<const char *>(&assert_cast<const ColumnFixedString &>(column).getChars()[n * row_num]), n);
 }
 
 
 void DataTypeFixedString::deserializeBinary(IColumn & column, ReadBuffer & istr) const
 {
-    ColumnFixedString::Chars & data = static_cast<ColumnFixedString &>(column).getChars();
+    ColumnFixedString::Chars & data = assert_cast<ColumnFixedString &>(column).getChars();
     size_t old_size = data.size();
     data.resize(old_size + n);
     try
@@ -112,13 +113,13 @@ void DataTypeFixedString::deserializeBinaryBulk(IColumn & column, ReadBuffer & i
 
 void DataTypeFixedString::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeString(reinterpret_cast<const char *>(&static_cast<const ColumnFixedString &>(column).getChars()[n * row_num]), n, ostr);
+    writeString(reinterpret_cast<const char *>(&assert_cast<const ColumnFixedString &>(column).getChars()[n * row_num]), n, ostr);
 }
 
 
 void DataTypeFixedString::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    const char * pos = reinterpret_cast<const char *>(&static_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
+    const char * pos = reinterpret_cast<const char *>(&assert_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
     writeAnyEscapedString<'\''>(pos, pos + n, ostr);
 }
 
@@ -165,7 +166,7 @@ void DataTypeFixedString::deserializeTextEscaped(IColumn & column, ReadBuffer &
 
 void DataTypeFixedString::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    const char * pos = reinterpret_cast<const char *>(&static_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
+    const char * pos = reinterpret_cast<const char *>(&assert_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
     writeAnyQuotedString<'\''>(pos, pos + n, ostr);
 }
 
@@ -184,7 +185,7 @@ void DataTypeFixedString::deserializeWholeText(IColumn & column, ReadBuffer & is
 
 void DataTypeFixedString::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    const char * pos = reinterpret_cast<const char *>(&static_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
+    const char * pos = reinterpret_cast<const char *>(&assert_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
     writeJSONString(pos, pos + n, ostr, settings);
 }
 
@@ -197,14 +198,14 @@ void DataTypeFixedString::deserializeTextJSON(IColumn & column, ReadBuffer & ist
 
 void DataTypeFixedString::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    const char * pos = reinterpret_cast<const char *>(&static_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
+    const char * pos = reinterpret_cast<const char *>(&assert_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
     writeXMLString(pos, pos + n, ostr);
 }
 
 
 void DataTypeFixedString::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    const char * pos = reinterpret_cast<const char *>(&static_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
+    const char * pos = reinterpret_cast<const char *>(&assert_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
     writeCSVString(pos, pos + n, ostr);
 }
 
@@ -219,7 +220,7 @@ void DataTypeFixedString::serializeProtobuf(const IColumn & column, size_t row_n
 {
     if (value_index)
         return;
-    const char * pos = reinterpret_cast<const char *>(&static_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
+    const char * pos = reinterpret_cast<const char *>(&assert_cast<const ColumnFixedString &>(column).getChars()[n * row_num]);
     value_index = static_cast<bool>(protobuf.writeString(StringRef(pos, n)));
 }
 
@@ -227,7 +228,7 @@ void DataTypeFixedString::serializeProtobuf(const IColumn & column, size_t row_n
 void DataTypeFixedString::deserializeProtobuf(IColumn & column, ProtobufReader & protobuf, bool allow_add_row, bool & row_added) const
 {
     row_added = false;
-    auto & column_string = static_cast<ColumnFixedString &>(column);
+    auto & column_string = assert_cast<ColumnFixedString &>(column);
     ColumnFixedString::Chars & data = column_string.getChars();
     size_t old_size = data.size();
     try

dbms/src/DataTypes/DataTypeLowCardinality.cpp

@@ -4,6 +4,7 @@
 #include <Columns/ColumnsCommon.h>
 #include <Common/HashTable/HashMap.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Core/TypeListNumber.h>
 #include <DataTypes/DataTypeFactory.h>
 #include <DataTypes/DataTypeLowCardinality.h>

dbms/src/DataTypes/DataTypeLowCardinalityHelpers.cpp

@@ -7,6 +7,9 @@
 #include <DataTypes/DataTypeArray.h>
 #include <DataTypes/DataTypeTuple.h>
 
+#include <Common/assert_cast.h>
+
+
 namespace DB
 {
 
@@ -110,7 +113,7 @@ ColumnPtr recursiveLowCardinalityConversion(const ColumnPtr & column, const Data
         if (from_type->equals(*low_cardinality_type->getDictionaryType()))
         {
             auto col = low_cardinality_type->createColumn();
-            static_cast<ColumnLowCardinality &>(*col).insertRangeFromFullColumn(*column, 0, column->size());
+            assert_cast<ColumnLowCardinality &>(*col).insertRangeFromFullColumn(*column, 0, column->size());
             return col;
         }
     }

dbms/src/DataTypes/DataTypeNullable.cpp

@@ -11,6 +11,7 @@
 #include <IO/ConcatReadBuffer.h>
 #include <Parsers/IAST.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -84,7 +85,7 @@ void DataTypeNullable::serializeBinaryBulkWithMultipleStreams(
     SerializeBinaryBulkSettings & settings,
     SerializeBinaryBulkStatePtr & state) const
 {
-    const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
+    const ColumnNullable & col = assert_cast<const ColumnNullable &>(column);
     col.checkConsistency();
 
     /// First serialize null map.
@@ -105,7 +106,7 @@ void DataTypeNullable::deserializeBinaryBulkWithMultipleStreams(
     DeserializeBinaryBulkSettings & settings,
     DeserializeBinaryBulkStatePtr & state) const
 {
-    ColumnNullable & col = static_cast<ColumnNullable &>(column);
+    ColumnNullable & col = assert_cast<ColumnNullable &>(column);
 
     settings.path.push_back(Substream::NullMap);
     if (auto stream = settings.getter(settings.path))
@@ -119,7 +120,7 @@ void DataTypeNullable::deserializeBinaryBulkWithMultipleStreams(
 
 void DataTypeNullable::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
+    const ColumnNullable & col = assert_cast<const ColumnNullable &>(column);
 
     bool is_null = col.isNullAt(row_num);
     writeBinary(is_null, ostr);
@@ -134,7 +135,7 @@ static void safeDeserialize(
     IColumn & column,
     CheckForNull && check_for_null, DeserializeNested && deserialize_nested)
 {
-    ColumnNullable & col = static_cast<ColumnNullable &>(column);
+    ColumnNullable & col = assert_cast<ColumnNullable &>(column);
 
     if (check_for_null())
     {
@@ -167,7 +168,7 @@ void DataTypeNullable::deserializeBinary(IColumn & column, ReadBuffer & istr) co
 
 void DataTypeNullable::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
+    const ColumnNullable & col = assert_cast<const ColumnNullable &>(column);
 
     if (col.isNullAt(row_num))
         writeCString("\\N", ostr);
@@ -235,7 +236,7 @@ void DataTypeNullable::deserializeTextEscaped(IColumn & column, ReadBuffer & ist
 
 void DataTypeNullable::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
+    const ColumnNullable & col = assert_cast<const ColumnNullable &>(column);
 
     if (col.isNullAt(row_num))
         writeCString("NULL", ostr);
@@ -262,7 +263,7 @@ void DataTypeNullable::deserializeWholeText(IColumn & column, ReadBuffer & istr,
 
 void DataTypeNullable::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
+    const ColumnNullable & col = assert_cast<const ColumnNullable &>(column);
 
     if (col.isNullAt(row_num))
         writeCString("\\N", ostr);
@@ -342,7 +343,7 @@ void DataTypeNullable::deserializeTextCSV(IColumn & column, ReadBuffer & istr, c
 
 void DataTypeNullable::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
+    const ColumnNullable & col = assert_cast<const ColumnNullable &>(column);
 
     /// In simple text format (like 'Pretty' format) (these formats are suitable only for output and cannot be parsed back),
     ///  data is printed without escaping.
@@ -358,7 +359,7 @@ void DataTypeNullable::serializeText(const IColumn & column, size_t row_num, Wri
 
 void DataTypeNullable::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
+    const ColumnNullable & col = assert_cast<const ColumnNullable &>(column);
 
     if (col.isNullAt(row_num))
         writeCString("null", ostr);
@@ -375,7 +376,7 @@ void DataTypeNullable::deserializeTextJSON(IColumn & column, ReadBuffer & istr,
 
 void DataTypeNullable::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
+    const ColumnNullable & col = assert_cast<const ColumnNullable &>(column);
 
     if (col.isNullAt(row_num))
         writeCString("\\N", ostr);
@@ -385,14 +386,14 @@ void DataTypeNullable::serializeTextXML(const IColumn & column, size_t row_num,
 
 void DataTypeNullable::serializeProtobuf(const IColumn & column, size_t row_num, ProtobufWriter & protobuf, size_t & value_index) const
 {
-    const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
+    const ColumnNullable & col = assert_cast<const ColumnNullable &>(column);
     if (!col.isNullAt(row_num))
         nested_data_type->serializeProtobuf(col.getNestedColumn(), row_num, protobuf, value_index);
 }
 
 void DataTypeNullable::deserializeProtobuf(IColumn & column, ProtobufReader & protobuf, bool allow_add_row, bool & row_added) const
 {
-    ColumnNullable & col = static_cast<ColumnNullable &>(column);
+    ColumnNullable & col = assert_cast<ColumnNullable &>(column);
     IColumn & nested_column = col.getNestedColumn();
     size_t old_size = nested_column.size();
     try

dbms/src/DataTypes/DataTypeNumberBase.cpp

@@ -6,6 +6,7 @@
 #include <IO/WriteHelpers.h>
 #include <Common/NaNUtils.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Formats/FormatSettings.h>
 #include <Formats/ProtobufReader.h>
 #include <Formats/ProtobufWriter.h>
@@ -17,7 +18,7 @@ namespace DB
 template <typename T>
 void DataTypeNumberBase<T>::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeText(static_cast<const ColumnVector<T> &>(column).getData()[row_num], ostr);
+    writeText(assert_cast<const ColumnVector<T> &>(column).getData()[row_num], ostr);
 }
 
 template <typename T>
@@ -30,7 +31,7 @@ void DataTypeNumberBase<T>::deserializeText(IColumn & column, ReadBuffer & istr,
     else
         readText(x, istr);
 
-    static_cast<ColumnVector<T> &>(column).getData().push_back(x);
+    assert_cast<ColumnVector<T> &>(column).getData().push_back(x);
 }
 
 template <typename T>
@@ -64,7 +65,7 @@ static inline void writeDenormalNumber(T x, WriteBuffer & ostr)
 template <typename T>
 void DataTypeNumberBase<T>::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    auto x = static_cast<const ColumnVector<T> &>(column).getData()[row_num];
+    auto x = assert_cast<const ColumnVector<T> &>(column).getData()[row_num];
     bool is_finite = isFinite(x);
 
     const bool need_quote = (std::is_integral_v<T> && (sizeof(T) == 8) && settings.json.quote_64bit_integers)
@@ -132,7 +133,7 @@ void DataTypeNumberBase<T>::deserializeTextJSON(IColumn & column, ReadBuffer & i
             assertChar('"', istr);
     }
 
-    static_cast<ColumnVector<T> &>(column).getData().push_back(x);
+    assert_cast<ColumnVector<T> &>(column).getData().push_back(x);
 }
 
 template <typename T>
@@ -140,7 +141,7 @@ void DataTypeNumberBase<T>::deserializeTextCSV(IColumn & column, ReadBuffer & is
 {
     FieldType x;
     readCSV(x, istr);
-    static_cast<ColumnVector<T> &>(column).getData().push_back(x);
+    assert_cast<ColumnVector<T> &>(column).getData().push_back(x);
 }
 
 template <typename T>
@@ -168,7 +169,7 @@ void DataTypeNumberBase<T>::deserializeBinary(Field & field, ReadBuffer & istr)
 template <typename T>
 void DataTypeNumberBase<T>::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    writeBinary(static_cast<const ColumnVector<T> &>(column).getData()[row_num], ostr);
+    writeBinary(assert_cast<const ColumnVector<T> &>(column).getData()[row_num], ostr);
 }
 
 template <typename T>
@@ -176,7 +177,7 @@ void DataTypeNumberBase<T>::deserializeBinary(IColumn & column, ReadBuffer & ist
 {
     typename ColumnVector<T>::value_type x;
     readBinary(x, istr);
-    static_cast<ColumnVector<T> &>(column).getData().push_back(x);
+    assert_cast<ColumnVector<T> &>(column).getData().push_back(x);
 }
 
 template <typename T>
@@ -209,7 +210,7 @@ void DataTypeNumberBase<T>::serializeProtobuf(const IColumn & column, size_t row
 {
     if (value_index)
         return;
-    value_index = static_cast<bool>(protobuf.writeNumber(static_cast<const ColumnVector<T> &>(column).getData()[row_num]));
+    value_index = static_cast<bool>(protobuf.writeNumber(assert_cast<const ColumnVector<T> &>(column).getData()[row_num]));
 }
 
 

dbms/src/DataTypes/DataTypeString.cpp

@@ -5,6 +5,7 @@
 #include <Columns/ColumnConst.h>
 
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 
 #include <Formats/FormatSettings.h>
 #include <Formats/ProtobufReader.h>
@@ -45,7 +46,7 @@ void DataTypeString::deserializeBinary(Field & field, ReadBuffer & istr) const
 
 void DataTypeString::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    const StringRef & s = static_cast<const ColumnString &>(column).getDataAt(row_num);
+    const StringRef & s = assert_cast<const ColumnString &>(column).getDataAt(row_num);
     writeVarUInt(s.size, ostr);
     writeString(s, ostr);
 }
@@ -53,7 +54,7 @@ void DataTypeString::serializeBinary(const IColumn & column, size_t row_num, Wri
 
 void DataTypeString::deserializeBinary(IColumn & column, ReadBuffer & istr) const
 {
-    ColumnString & column_string = static_cast<ColumnString &>(column);
+    ColumnString & column_string = assert_cast<ColumnString &>(column);
     ColumnString::Chars & data = column_string.getChars();
     ColumnString::Offsets & offsets = column_string.getOffsets();
 
@@ -211,20 +212,20 @@ void DataTypeString::deserializeBinaryBulk(IColumn & column, ReadBuffer & istr,
 
 void DataTypeString::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeString(static_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
+    writeString(assert_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
 }
 
 
 void DataTypeString::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeEscapedString(static_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
+    writeEscapedString(assert_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
 }
 
 
 template <typename Reader>
 static inline void read(IColumn & column, Reader && reader)
 {
-    ColumnString & column_string = static_cast<ColumnString &>(column);
+    ColumnString & column_string = assert_cast<ColumnString &>(column);
     ColumnString::Chars & data = column_string.getChars();
     ColumnString::Offsets & offsets = column_string.getOffsets();
     size_t old_chars_size = data.size();
@@ -258,7 +259,7 @@ void DataTypeString::deserializeTextEscaped(IColumn & column, ReadBuffer & istr,
 
 void DataTypeString::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeQuotedString(static_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
+    writeQuotedString(assert_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
 }
 
 
@@ -270,7 +271,7 @@ void DataTypeString::deserializeTextQuoted(IColumn & column, ReadBuffer & istr,
 
 void DataTypeString::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    writeJSONString(static_cast<const ColumnString &>(column).getDataAt(row_num), ostr, settings);
+    writeJSONString(assert_cast<const ColumnString &>(column).getDataAt(row_num), ostr, settings);
 }
 
 
@@ -282,13 +283,13 @@ void DataTypeString::deserializeTextJSON(IColumn & column, ReadBuffer & istr, co
 
 void DataTypeString::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeXMLString(static_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
+    writeXMLString(assert_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
 }
 
 
 void DataTypeString::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeCSVString<>(static_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
+    writeCSVString<>(assert_cast<const ColumnString &>(column).getDataAt(row_num), ostr);
 }
 
 
@@ -302,14 +303,14 @@ void DataTypeString::serializeProtobuf(const IColumn & column, size_t row_num, P
 {
     if (value_index)
         return;
-    value_index = static_cast<bool>(protobuf.writeString(static_cast<const ColumnString &>(column).getDataAt(row_num)));
+    value_index = static_cast<bool>(protobuf.writeString(assert_cast<const ColumnString &>(column).getDataAt(row_num)));
 }
 
 
 void DataTypeString::deserializeProtobuf(IColumn & column, ProtobufReader & protobuf, bool allow_add_row, bool & row_added) const
 {
     row_added = false;
-    auto & column_string = static_cast<ColumnString &>(column);
+    auto & column_string = assert_cast<ColumnString &>(column);
     ColumnString::Chars & data = column_string.getChars();
     ColumnString::Offsets & offsets = column_string.getOffsets();
     size_t old_size = offsets.size();

dbms/src/DataTypes/DataTypeTuple.cpp

@@ -7,6 +7,7 @@
 #include <Parsers/IAST.h>
 #include <Parsers/ASTNameTypePair.h>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <IO/WriteHelpers.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteBufferFromString.h>
@@ -88,12 +89,12 @@ std::string DataTypeTuple::doGetName() const
 
 static inline IColumn & extractElementColumn(IColumn & column, size_t idx)
 {
-    return static_cast<ColumnTuple &>(column).getColumn(idx);
+    return assert_cast<ColumnTuple &>(column).getColumn(idx);
 }
 
 static inline const IColumn & extractElementColumn(const IColumn & column, size_t idx)
 {
-    return static_cast<const ColumnTuple &>(column).getColumn(idx);
+    return assert_cast<const ColumnTuple &>(column).getColumn(idx);
 }
 
 

dbms/src/DataTypes/DataTypeUUID.cpp

@@ -5,6 +5,7 @@
 #include <Formats/ProtobufWriter.h>
 #include <IO/WriteHelpers.h>
 #include <IO/ReadHelpers.h>
+#include <Common/assert_cast.h>
 
 
 namespace DB
@@ -12,14 +13,14 @@ namespace DB
 
 void DataTypeUUID::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    writeText(UUID(static_cast<const ColumnUInt128 &>(column).getData()[row_num]), ostr);
+    writeText(UUID(assert_cast<const ColumnUInt128 &>(column).getData()[row_num]), ostr);
 }
 
 void DataTypeUUID::deserializeTextEscaped(IColumn & column, ReadBuffer & istr, const FormatSettings &) const
 {
     UUID x;
     readText(x, istr);
-    static_cast<ColumnUInt128 &>(column).getData().push_back(x);
+    assert_cast<ColumnUInt128 &>(column).getData().push_back(x);
 }
 
 void DataTypeUUID::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -40,7 +41,7 @@ void DataTypeUUID::deserializeTextQuoted(IColumn & column, ReadBuffer & istr, co
     assertChar('\'', istr);
     readText(x, istr);
     assertChar('\'', istr);
-    static_cast<ColumnUInt128 &>(column).getData().push_back(x);    /// It's important to do this at the end - for exception safety.
+    assert_cast<ColumnUInt128 &>(column).getData().push_back(x);    /// It's important to do this at the end - for exception safety.
 }
 
 void DataTypeUUID::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -56,7 +57,7 @@ void DataTypeUUID::deserializeTextJSON(IColumn & column, ReadBuffer & istr, cons
     assertChar('"', istr);
     readText(x, istr);
     assertChar('"', istr);
-    static_cast<ColumnUInt128 &>(column).getData().push_back(x);
+    assert_cast<ColumnUInt128 &>(column).getData().push_back(x);
 }
 
 void DataTypeUUID::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
@@ -70,14 +71,14 @@ void DataTypeUUID::deserializeTextCSV(IColumn & column, ReadBuffer & istr, const
 {
     UUID value;
     readCSV(value, istr);
-    static_cast<ColumnUInt128 &>(column).getData().push_back(value);
+    assert_cast<ColumnUInt128 &>(column).getData().push_back(value);
 }
 
 void DataTypeUUID::serializeProtobuf(const IColumn & column, size_t row_num, ProtobufWriter & protobuf, size_t & value_index) const
 {
     if (value_index)
         return;
-    value_index = static_cast<bool>(protobuf.writeUUID(UUID(static_cast<const ColumnUInt128 &>(column).getData()[row_num])));
+    value_index = static_cast<bool>(protobuf.writeUUID(UUID(assert_cast<const ColumnUInt128 &>(column).getData()[row_num])));
 }
 
 void DataTypeUUID::deserializeProtobuf(IColumn & column, ProtobufReader & protobuf, bool allow_add_row, bool & row_added) const
@@ -87,7 +88,7 @@ void DataTypeUUID::deserializeProtobuf(IColumn & column, ProtobufReader & protob
     if (!protobuf.readUUID(uuid))
         return;
 
-    auto & container = static_cast<ColumnUInt128 &>(column).getData();
+    auto & container = assert_cast<ColumnUInt128 &>(column).getData();
     if (allow_add_row)
     {
         container.emplace_back(uuid);

dbms/src/DataTypes/DataTypesDecimal.cpp

@@ -1,5 +1,6 @@
 #include <type_traits>
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <DataTypes/DataTypesDecimal.h>
 #include <DataTypes/DataTypeFactory.h>
 #include <Formats/ProtobufReader.h>
@@ -11,6 +12,7 @@
 #include <Parsers/ASTLiteral.h>
 #include <Interpreters/Context.h>
 
+
 namespace DB
 {
 
@@ -47,7 +49,7 @@ bool DataTypeDecimal<T>::equals(const IDataType & rhs) const
 template <typename T>
 void DataTypeDecimal<T>::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const
 {
-    T value = static_cast<const ColumnType &>(column).getData()[row_num];
+    T value = assert_cast<const ColumnType &>(column).getData()[row_num];
     writeText(value, scale, ostr);
 }
 
@@ -76,7 +78,7 @@ void DataTypeDecimal<T>::deserializeText(IColumn & column, ReadBuffer & istr, co
 {
     T x;
     readText(x, istr);
-    static_cast<ColumnType &>(column).getData().push_back(x);
+    assert_cast<ColumnType &>(column).getData().push_back(x);
 }
 
 template <typename T>
@@ -84,7 +86,7 @@ void DataTypeDecimal<T>::deserializeTextCSV(IColumn & column, ReadBuffer & istr,
 {
     T x;
     readText(x, istr, true);
-    static_cast<ColumnType &>(column).getData().push_back(x);
+    assert_cast<ColumnType &>(column).getData().push_back(x);
 }
 
 template <typename T>
@@ -109,7 +111,7 @@ void DataTypeDecimal<T>::serializeBinary(const Field & field, WriteBuffer & ostr
 template <typename T>
 void DataTypeDecimal<T>::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    const FieldType & x = static_cast<const ColumnType &>(column).getData()[row_num];
+    const FieldType & x = assert_cast<const ColumnType &>(column).getData()[row_num];
     writeBinary(x, ostr);
 }
 
@@ -140,7 +142,7 @@ void DataTypeDecimal<T>::deserializeBinary(IColumn & column, ReadBuffer & istr)
 {
     typename FieldType::NativeType x;
     readBinary(x, istr);
-    static_cast<ColumnType &>(column).getData().push_back(FieldType(x));
+    assert_cast<ColumnType &>(column).getData().push_back(FieldType(x));
 }
 
 template <typename T>
@@ -159,7 +161,7 @@ void DataTypeDecimal<T>::serializeProtobuf(const IColumn & column, size_t row_nu
 {
     if (value_index)
         return;
-    value_index = static_cast<bool>(protobuf.writeDecimal(static_cast<const ColumnType &>(column).getData()[row_num], scale));
+    value_index = static_cast<bool>(protobuf.writeDecimal(assert_cast<const ColumnType &>(column).getData()[row_num], scale));
 }
 
 
@@ -171,7 +173,7 @@ void DataTypeDecimal<T>::deserializeProtobuf(IColumn & column, ProtobufReader &
     if (!protobuf.readDecimal(decimal, precision, scale))
         return;
 
-    auto & container = static_cast<ColumnType &>(column).getData();
+    auto & container = assert_cast<ColumnType &>(column).getData();
     if (allow_add_row)
     {
         container.emplace_back(decimal);

dbms/src/DataTypes/NestedUtils.cpp

@@ -1,6 +1,7 @@
 #include <string.h>
 
 #include <Common/typeid_cast.h>
+#include <Common/assert_cast.h>
 #include <Common/StringUtils/StringUtils.h>
 
 #include <DataTypes/DataTypeArray.h>
@@ -94,7 +95,7 @@ Block flatten(const Block & block)
                 bool is_const = isColumnConst(*elem.column);
                 const ColumnArray * column_array;
                 if (is_const)
-                    column_array = typeid_cast<const ColumnArray *>(&static_cast<const ColumnConst &>(*elem.column).getDataColumn());
+                    column_array = typeid_cast<const ColumnArray *>(&assert_cast<const ColumnConst &>(*elem.column).getDataColumn());
                 else
                     column_array = typeid_cast<const ColumnArray *>(elem.column.get());
 
@@ -181,8 +182,8 @@ void validateArraySizes(const Block & block)
                 /// It's not the first column of Nested data structure.
                 if (!inserted)
                 {
-                    const ColumnArray & first_array_column = static_cast<const ColumnArray &>(*block.getByPosition(it->second).column);
+                    const ColumnArray & first_array_column = assert_cast<const ColumnArray &>(*block.getByPosition(it->second).column);
-                    const ColumnArray & another_array_column = static_cast<const ColumnArray &>(*elem.column);
+                    const ColumnArray & another_array_column = assert_cast<const ColumnArray &>(*elem.column);
 
                     if (!first_array_column.hasEqualOffsets(another_array_column))
                         throw Exception("Elements '" + block.getByPosition(it->second).name