From 65c0d23efa30ccf3af276306737300737eb9f371 Mon Sep 17 00:00:00 2001 From: chertus Date: Wed, 26 Jun 2019 20:20:33 +0300 Subject: [PATCH] better casts to ColumnNullable --- dbms/src/Columns/ColumnNullable.cpp | 1 - dbms/src/Columns/ColumnNullable.h | 17 +++++++++++++++ dbms/src/Columns/ColumnUnique.h | 4 ++-- dbms/src/Columns/FilterDescription.cpp | 4 ++-- dbms/src/Common/ColumnsHashingImpl.h | 7 +++---- dbms/src/DataTypes/DataTypeLowCardinality.cpp | 2 +- dbms/src/Functions/FunctionHelpers.cpp | 16 ++++++-------- .../src/Functions/FunctionsExternalModels.cpp | 2 +- dbms/src/Functions/IFunction.cpp | 10 ++++----- dbms/src/Functions/array/arrayDistinct.cpp | 5 ++--- .../Functions/array/arrayEnumerateExtended.h | 8 +++---- dbms/src/Functions/array/arrayUniq.cpp | 8 +++---- .../Functions/array/emptyArrayToSingle.cpp | 13 ++++++------ dbms/src/Functions/assumeNotNull.cpp | 7 ++----- dbms/src/Functions/coalesce.cpp | 2 +- dbms/src/Functions/if.cpp | 21 +++++++++---------- dbms/src/Functions/isNotNull.cpp | 4 ++-- dbms/src/Functions/isNull.cpp | 4 ++-- dbms/src/Interpreters/Aggregator.h | 2 +- dbms/src/Interpreters/Join.cpp | 8 +++---- dbms/src/Interpreters/NullableUtils.cpp | 20 ++++++++---------- dbms/src/Interpreters/SetVariants.cpp | 5 ++--- dbms/src/Interpreters/SetVariants.h | 7 +++---- .../MergeTree/MergeTreeSetSkippingIndex.cpp | 2 +- 24 files changed, 88 insertions(+), 91 deletions(-) diff --git a/dbms/src/Columns/ColumnNullable.cpp b/dbms/src/Columns/ColumnNullable.cpp index 20511ec6bfc..bdfa04dfad0 100644 --- a/dbms/src/Columns/ColumnNullable.cpp +++ b/dbms/src/Columns/ColumnNullable.cpp @@ -3,7 +3,6 @@ #include #include #include -#include #include diff --git a/dbms/src/Columns/ColumnNullable.h b/dbms/src/Columns/ColumnNullable.h index 19246cd597d..ae8c372db6d 100644 --- a/dbms/src/Columns/ColumnNullable.h +++ b/dbms/src/Columns/ColumnNullable.h @@ -2,6 +2,7 @@ #include #include +#include #include @@ -145,4 +146,20 @@ private: ColumnPtr makeNullable(const ColumnPtr & column); +inline const ColumnNullable * getNullableColumn(const IColumn & column) +{ + const IColumn * ptr = &column; + if (auto * const_column = typeid_cast(ptr)) + ptr = &const_column->getDataColumn(); + + return typeid_cast(ptr); +} + +inline ColumnNullable & getNullableColumnRef(IColumn & column) +{ + if (auto * const_column = typeid_cast(&column)) + return static_cast(const_column->getDataColumn()); + return static_cast(column); +} + } diff --git a/dbms/src/Columns/ColumnUnique.h b/dbms/src/Columns/ColumnUnique.h index 11344a23a1f..38bd773a489 100644 --- a/dbms/src/Columns/ColumnUnique.h +++ b/dbms/src/Columns/ColumnUnique.h @@ -271,7 +271,7 @@ size_t ColumnUnique::uniqueInsertFrom(const IColumn & src, size_t n) if (is_nullable && src.isNullAt(n)) return getNullValueIndex(); - if (auto * nullable = typeid_cast(&src)) + if (auto * nullable = getNullableColumn(src)) return uniqueInsertFrom(nullable->getNestedColumn(), n); auto ref = src.getDataAt(n); @@ -430,7 +430,7 @@ MutableColumnPtr ColumnUnique::uniqueInsertRangeImpl( return nullptr; }; - if (auto nullable_column = typeid_cast(&src)) + if (auto * nullable_column = getNullableColumn(src)) { src_column = typeid_cast(&nullable_column->getNestedColumn()); null_map = &nullable_column->getNullMapData(); diff --git a/dbms/src/Columns/FilterDescription.cpp b/dbms/src/Columns/FilterDescription.cpp index 97b123e5ee2..a3817785d33 100644 --- a/dbms/src/Columns/FilterDescription.cpp +++ b/dbms/src/Columns/FilterDescription.cpp @@ -30,7 +30,7 @@ ConstantFilterDescription::ConstantFilterDescription(const IColumn & column) if (!typeid_cast(column_nested.get())) { - const ColumnNullable * column_nested_nullable = typeid_cast(column_nested.get()); + const ColumnNullable * column_nested_nullable = getNullableColumn(*column_nested); if (!column_nested_nullable || !typeid_cast(&column_nested_nullable->getNestedColumn())) { throw Exception("Illegal type " + column_nested->getName() + " of column for constant filter. Must be UInt8 or Nullable(UInt8).", @@ -60,7 +60,7 @@ FilterDescription::FilterDescription(const IColumn & column_) return; } - if (const ColumnNullable * nullable_column = typeid_cast(&column)) + if (auto * nullable_column = getNullableColumn(column)) { ColumnPtr nested_column = nullable_column->getNestedColumnPtr(); MutableColumnPtr mutable_holder = (*std::move(nested_column)).mutate(); diff --git a/dbms/src/Common/ColumnsHashingImpl.h b/dbms/src/Common/ColumnsHashingImpl.h index 1f826640899..3cfdfe23800 100644 --- a/dbms/src/Common/ColumnsHashingImpl.h +++ b/dbms/src/Common/ColumnsHashingImpl.h @@ -279,11 +279,10 @@ protected: for (const auto & col : key_columns) { - if (col->isColumnNullable()) + if (auto * nullable_col = getNullableColumn(*col)) { - const auto & nullable_col = static_cast(*col); - actual_columns.push_back(&nullable_col.getNestedColumn()); - null_maps.push_back(&nullable_col.getNullMapColumn()); + actual_columns.push_back(&nullable_col->getNestedColumn()); + null_maps.push_back(&nullable_col->getNullMapColumn()); } else { diff --git a/dbms/src/DataTypes/DataTypeLowCardinality.cpp b/dbms/src/DataTypes/DataTypeLowCardinality.cpp index e70223437f7..33ea5902d5d 100644 --- a/dbms/src/DataTypes/DataTypeLowCardinality.cpp +++ b/dbms/src/DataTypes/DataTypeLowCardinality.cpp @@ -544,7 +544,7 @@ void DataTypeLowCardinality::serializeBinaryBulkWithMultipleStreams( ErrorCodes::LOGICAL_ERROR); } - if (auto nullable_keys = typeid_cast(keys.get())) + if (auto * nullable_keys = getNullableColumn(*keys)) keys = nullable_keys->getNestedColumnPtr(); bool need_additional_keys = !keys->empty(); diff --git a/dbms/src/Functions/FunctionHelpers.cpp b/dbms/src/Functions/FunctionHelpers.cpp index 42fcebd5848..20ff75abe4f 100644 --- a/dbms/src/Functions/FunctionHelpers.cpp +++ b/dbms/src/Functions/FunctionHelpers.cpp @@ -64,18 +64,14 @@ static Block createBlockWithNestedColumnsImpl(const Block & block, const std::un { res.insert({nullptr, nested_type, col.name}); } - else if (col.column->isColumnNullable()) + else if (auto * nullable = getNullableColumn(*col.column)) { - const auto & nested_col = static_cast(*col.column).getNestedColumnPtr(); + const auto & nested_col = nullable->getNestedColumnPtr(); - res.insert({nested_col, nested_type, col.name}); - } - else if (col.column->isColumnConst()) - { - const auto & nested_col = static_cast( - static_cast(*col.column).getDataColumn()).getNestedColumnPtr(); - - res.insert({ ColumnConst::create(nested_col, col.column->size()), nested_type, col.name}); + if (col.column->isColumnConst()) + res.insert({ ColumnConst::create(nested_col, col.column->size()), nested_type, col.name}); + else + res.insert({nested_col, nested_type, col.name}); } else throw Exception("Illegal column for DataTypeNullable", ErrorCodes::ILLEGAL_COLUMN); diff --git a/dbms/src/Functions/FunctionsExternalModels.cpp b/dbms/src/Functions/FunctionsExternalModels.cpp index 6c11cb78bb5..8b6dcdc3b66 100644 --- a/dbms/src/Functions/FunctionsExternalModels.cpp +++ b/dbms/src/Functions/FunctionsExternalModels.cpp @@ -92,7 +92,7 @@ void FunctionModelEvaluate::executeImpl(Block & block, const ColumnNumbers & arg materialized_columns.push_back(full_column); columns.back() = full_column.get(); } - if (auto * col_nullable = typeid_cast(columns.back())) + if (auto * col_nullable = getNullableColumn(*columns.back())) { if (!null_map) null_map = col_nullable->getNullMapColumnPtr(); diff --git a/dbms/src/Functions/IFunction.cpp b/dbms/src/Functions/IFunction.cpp index f792c40f400..79e379bf1e6 100644 --- a/dbms/src/Functions/IFunction.cpp +++ b/dbms/src/Functions/IFunction.cpp @@ -111,10 +111,10 @@ ColumnPtr wrapInNullable(const ColumnPtr & src, const Block & block, const Colum if (src->onlyNull()) return src; - else if (src->isColumnNullable()) + else if (auto * nullable = getNullableColumn(*src)) { - src_not_nullable = static_cast(*src).getNestedColumnPtr(); - result_null_map_column = static_cast(*src).getNullMapColumnPtr(); + src_not_nullable = nullable->getNestedColumnPtr(); + result_null_map_column = nullable->getNullMapColumnPtr(); } for (const auto & arg : args) @@ -130,9 +130,9 @@ ColumnPtr wrapInNullable(const ColumnPtr & src, const Block & block, const Colum if (elem.column->isColumnConst()) continue; - if (elem.column->isColumnNullable()) + if (auto * nullable = getNullableColumn(*elem.column)) { - const ColumnPtr & null_map_column = static_cast(*elem.column).getNullMapColumnPtr(); + const ColumnPtr & null_map_column = nullable->getNullMapColumnPtr(); if (!result_null_map_column) { result_null_map_column = null_map_column; diff --git a/dbms/src/Functions/array/arrayDistinct.cpp b/dbms/src/Functions/array/arrayDistinct.cpp index 18dd7be850a..0d46bd62d18 100644 --- a/dbms/src/Functions/array/arrayDistinct.cpp +++ b/dbms/src/Functions/array/arrayDistinct.cpp @@ -100,13 +100,12 @@ void FunctionArrayDistinct::executeImpl(Block & block, const ColumnNumbers & arg IColumn & res_data = res.getData(); ColumnArray::Offsets & res_offsets = res.getOffsets(); - const ColumnNullable * nullable_col = nullptr; + const ColumnNullable * nullable_col = getNullableColumn(src_data); const IColumn * inner_col; - if (src_data.isColumnNullable()) + if (nullable_col) { - nullable_col = static_cast(&src_data); inner_col = &nullable_col->getNestedColumn(); } else diff --git a/dbms/src/Functions/array/arrayEnumerateExtended.h b/dbms/src/Functions/array/arrayEnumerateExtended.h index 72958574e83..6f3801deed1 100644 --- a/dbms/src/Functions/array/arrayEnumerateExtended.h +++ b/dbms/src/Functions/array/arrayEnumerateExtended.h @@ -157,14 +157,12 @@ void FunctionArrayEnumerateExtended::executeImpl(Block & block, const C for (size_t i = 0; i < num_arguments; ++i) { - if (data_columns[i]->isColumnNullable()) + if (auto * nullable_col = getNullableColumn(*data_columns[i])) { - const auto & nullable_col = static_cast(*data_columns[i]); - if (num_arguments == 1) - data_columns[i] = &nullable_col.getNestedColumn(); + data_columns[i] = &nullable_col->getNestedColumn(); - null_map = &nullable_col.getNullMapData(); + null_map = &nullable_col->getNullMapData(); break; } } diff --git a/dbms/src/Functions/array/arrayUniq.cpp b/dbms/src/Functions/array/arrayUniq.cpp index 29106cf235f..b2f7eb8b04c 100644 --- a/dbms/src/Functions/array/arrayUniq.cpp +++ b/dbms/src/Functions/array/arrayUniq.cpp @@ -154,14 +154,12 @@ void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & argumen for (size_t i = 0; i < num_arguments; ++i) { - if (data_columns[i]->isColumnNullable()) + if (auto * nullable_col = getNullableColumn(*data_columns[i])) { - const auto & nullable_col = static_cast(*data_columns[i]); - if (num_arguments == 1) - data_columns[i] = &nullable_col.getNestedColumn(); + data_columns[i] = &nullable_col->getNestedColumn(); - null_map = &nullable_col.getNullMapData(); + null_map = &nullable_col->getNullMapData(); break; } } diff --git a/dbms/src/Functions/array/emptyArrayToSingle.cpp b/dbms/src/Functions/array/emptyArrayToSingle.cpp index ae073935c27..0214e2b0f99 100644 --- a/dbms/src/Functions/array/emptyArrayToSingle.cpp +++ b/dbms/src/Functions/array/emptyArrayToSingle.cpp @@ -392,16 +392,15 @@ void FunctionEmptyArrayToSingle::executeImpl(Block & block, const ColumnNumbers const IColumn * inner_col; IColumn * inner_res_col; - bool nullable = src_data.isColumnNullable(); - if (nullable) + auto nullable_col = getNullableColumn(src_data); + if (nullable_col) { - auto nullable_col = static_cast(&src_data); inner_col = &nullable_col->getNestedColumn(); src_null_map = &nullable_col->getNullMapData(); - auto nullable_res_col = static_cast(&res_data); - inner_res_col = &nullable_res_col->getNestedColumn(); - res_null_map = &nullable_res_col->getNullMapData(); + auto & nullable_res_col = getNullableColumnRef(res_data); + inner_res_col = &nullable_res_col.getNestedColumn(); + res_null_map = &nullable_res_col.getNullMapData(); } else { @@ -409,7 +408,7 @@ void FunctionEmptyArrayToSingle::executeImpl(Block & block, const ColumnNumbers inner_res_col = &res_data; } - if (nullable) + if (nullable_col) FunctionEmptyArrayToSingleImpl::executeDispatch(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map); else FunctionEmptyArrayToSingleImpl::executeDispatch(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map); diff --git a/dbms/src/Functions/assumeNotNull.cpp b/dbms/src/Functions/assumeNotNull.cpp index 509cc84969f..5ea08c385b2 100644 --- a/dbms/src/Functions/assumeNotNull.cpp +++ b/dbms/src/Functions/assumeNotNull.cpp @@ -42,11 +42,8 @@ public: const ColumnPtr & col = block.getByPosition(arguments[0]).column; ColumnPtr & res_col = block.getByPosition(result).column; - if (col->isColumnNullable()) - { - const ColumnNullable & nullable_col = static_cast(*col); - res_col = nullable_col.getNestedColumnPtr(); - } + if (auto * nullable_col = getNullableColumn(*col)) + res_col = nullable_col->getNestedColumnPtr(); else res_col = col; } diff --git a/dbms/src/Functions/coalesce.cpp b/dbms/src/Functions/coalesce.cpp index cb65a019a31..c6154e1b014 100644 --- a/dbms/src/Functions/coalesce.cpp +++ b/dbms/src/Functions/coalesce.cpp @@ -151,7 +151,7 @@ public: /// if last argument is not nullable, result should be also not nullable if (!block.getByPosition(multi_if_args.back()).column->isColumnNullable() && res->isColumnNullable()) - res = static_cast(*res).getNestedColumnPtr(); + res = getNullableColumn(*res)->getNestedColumnPtr(); block.getByPosition(result).column = std::move(res); } diff --git a/dbms/src/Functions/if.cpp b/dbms/src/Functions/if.cpp index ff034848460..8c470103b3e 100644 --- a/dbms/src/Functions/if.cpp +++ b/dbms/src/Functions/if.cpp @@ -660,7 +660,6 @@ private: { const ColumnWithTypeAndName & arg_cond = block.getByPosition(arguments[0]); bool cond_is_null = arg_cond.column->onlyNull(); - bool cond_is_nullable = arg_cond.column->isColumnNullable(); if (cond_is_null) { @@ -668,11 +667,11 @@ private: return true; } - if (cond_is_nullable) + if (auto * nullable = getNullableColumn(*arg_cond.column)) { Block temporary_block { - { static_cast(*arg_cond.column).getNestedColumnPtr(), removeNullable(arg_cond.type), arg_cond.name }, + { nullable->getNestedColumnPtr(), removeNullable(arg_cond.type), arg_cond.name }, block.getByPosition(arguments[1]), block.getByPosition(arguments[2]), block.getByPosition(result) @@ -703,8 +702,8 @@ private: static ColumnPtr getNestedColumn(const ColumnPtr & column) { - if (column->isColumnNullable()) - return static_cast(*column).getNestedColumnPtr(); + if (auto * nullable = getNullableColumn(*column)) + return nullable->getNestedColumnPtr(); return column; } @@ -715,8 +714,8 @@ private: const ColumnWithTypeAndName & arg_then = block.getByPosition(arguments[1]); const ColumnWithTypeAndName & arg_else = block.getByPosition(arguments[2]); - bool then_is_nullable = typeid_cast(arg_then.column.get()); - bool else_is_nullable = typeid_cast(arg_else.column.get()); + auto * then_is_nullable = getNullableColumn(*arg_then.column); + auto * else_is_nullable = getNullableColumn(*arg_else.column); if (!then_is_nullable && !else_is_nullable) return false; @@ -731,14 +730,14 @@ private: arg_cond, { then_is_nullable - ? static_cast(arg_then.column.get())->getNullMapColumnPtr() + ? then_is_nullable->getNullMapColumnPtr() : DataTypeUInt8().createColumnConstWithDefaultValue(input_rows_count), std::make_shared(), "" }, { else_is_nullable - ? static_cast(arg_else.column.get())->getNullMapColumnPtr() + ? else_is_nullable->getNullMapColumnPtr() : DataTypeUInt8().createColumnConstWithDefaultValue(input_rows_count), std::make_shared(), "" @@ -818,7 +817,7 @@ private: { auto arg_else_column = arg_else.column; auto result_column = (*std::move(arg_else_column)).mutate(); - static_cast(*result_column).applyNullMap(static_cast(*arg_cond.column)); + getNullableColumnRef(*result_column).applyNullMap(static_cast(*arg_cond.column)); block.getByPosition(result).column = std::move(result_column); } else @@ -860,7 +859,7 @@ private: { auto arg_then_column = arg_then.column; auto result_column = (*std::move(arg_then_column)).mutate(); - static_cast(*result_column).applyNegatedNullMap(static_cast(*arg_cond.column)); + getNullableColumnRef(*result_column).applyNegatedNullMap(static_cast(*arg_cond.column)); block.getByPosition(result).column = std::move(result_column); } else diff --git a/dbms/src/Functions/isNotNull.cpp b/dbms/src/Functions/isNotNull.cpp index 019654053da..a006cae07fd 100644 --- a/dbms/src/Functions/isNotNull.cpp +++ b/dbms/src/Functions/isNotNull.cpp @@ -38,11 +38,11 @@ public: void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) override { const ColumnWithTypeAndName & elem = block.getByPosition(arguments[0]); - if (elem.column->isColumnNullable()) + if (auto * nullable = getNullableColumn(*elem.column)) { /// Return the negated null map. auto res_column = ColumnUInt8::create(input_rows_count); - const auto & src_data = static_cast(*elem.column).getNullMapData(); + const auto & src_data = nullable->getNullMapData(); auto & res_data = static_cast(*res_column).getData(); for (size_t i = 0; i < input_rows_count; ++i) diff --git a/dbms/src/Functions/isNull.cpp b/dbms/src/Functions/isNull.cpp index 9feb8a8afae..8ea2dc7e4e1 100644 --- a/dbms/src/Functions/isNull.cpp +++ b/dbms/src/Functions/isNull.cpp @@ -38,10 +38,10 @@ public: void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result, size_t) override { const ColumnWithTypeAndName & elem = block.getByPosition(arguments[0]); - if (elem.column->isColumnNullable()) + if (auto * nullable = getNullableColumn(*elem.column)) { /// Merely return the embedded null map. - block.getByPosition(result).column = static_cast(*elem.column).getNullMapColumnPtr(); + block.getByPosition(result).column = nullable->getNullMapColumnPtr(); } else { diff --git a/dbms/src/Interpreters/Aggregator.h b/dbms/src/Interpreters/Aggregator.h index 793179e060b..4db756aa2c6 100644 --- a/dbms/src/Interpreters/Aggregator.h +++ b/dbms/src/Interpreters/Aggregator.h @@ -310,7 +310,7 @@ struct AggregationMethodKeysFixed /// If we have a nullable column, get its nested column and its null map. if (has_nullable_keys && key_columns[i]->isColumnNullable()) { - ColumnNullable & nullable_col = static_cast(*key_columns[i]); + ColumnNullable & nullable_col = getNullableColumnRef(*key_columns[i]); observed_column = &nullable_col.getNestedColumn(); null_map = static_cast(&nullable_col.getNullMapColumn()); } diff --git a/dbms/src/Interpreters/Join.cpp b/dbms/src/Interpreters/Join.cpp index 84bfcf475bc..be6b69f005f 100644 --- a/dbms/src/Interpreters/Join.cpp +++ b/dbms/src/Interpreters/Join.cpp @@ -289,8 +289,8 @@ void Join::setSampleBlock(const Block & block) } /// We will join only keys, where all components are not NULL. - if (key_columns[i]->isColumnNullable()) - key_columns[i] = &static_cast(*key_columns[i]).getNestedColumn(); + if (auto * nullable = getNullableColumn(*key_columns[i])) + key_columns[i] = &nullable->getNestedColumn(); } if (strictness == ASTTableJoin::Strictness::Asof) @@ -1426,8 +1426,8 @@ private: if (changes_bitmap[i]) { ColumnPtr column = std::move(columns[i]); - if (column->isColumnNullable()) - column = static_cast(*column).getNestedColumnPtr(); + if (auto * nullable = getNullableColumn(*column)) + column = nullable->getNestedColumnPtr(); else column = makeNullable(column); diff --git a/dbms/src/Interpreters/NullableUtils.cpp b/dbms/src/Interpreters/NullableUtils.cpp index dcb0657aa9d..91ab3394359 100644 --- a/dbms/src/Interpreters/NullableUtils.cpp +++ b/dbms/src/Interpreters/NullableUtils.cpp @@ -9,32 +9,30 @@ void extractNestedColumnsAndNullMap(ColumnRawPtrs & key_columns, ColumnPtr & nul if (key_columns.size() == 1) { auto & column = key_columns[0]; - if (!column->isColumnNullable()) - return; - - const ColumnNullable & column_nullable = static_cast(*column); - null_map = &column_nullable.getNullMapData(); - column = &column_nullable.getNestedColumn(); + if (auto * column_nullable = getNullableColumn(*column)) + { + null_map = &column_nullable->getNullMapData(); + column = &column_nullable->getNestedColumn(); + } } else { for (auto & column : key_columns) { - if (column->isColumnNullable()) + if (auto * column_nullable = getNullableColumn(*column)) { - const ColumnNullable & column_nullable = static_cast(*column); - column = &column_nullable.getNestedColumn(); + column = &column_nullable->getNestedColumn(); if (!null_map_holder) { - null_map_holder = column_nullable.getNullMapColumnPtr(); + null_map_holder = column_nullable->getNullMapColumnPtr(); } else { MutableColumnPtr mutable_null_map_holder = (*std::move(null_map_holder)).mutate(); PaddedPODArray & mutable_null_map = static_cast(*mutable_null_map_holder).getData(); - const PaddedPODArray & other_null_map = column_nullable.getNullMapData(); + const PaddedPODArray & other_null_map = column_nullable->getNullMapData(); for (size_t i = 0, size = mutable_null_map.size(); i < size; ++i) mutable_null_map[i] |= other_null_map[i]; diff --git a/dbms/src/Interpreters/SetVariants.cpp b/dbms/src/Interpreters/SetVariants.cpp index 57d78d77526..e14be567b10 100644 --- a/dbms/src/Interpreters/SetVariants.cpp +++ b/dbms/src/Interpreters/SetVariants.cpp @@ -73,10 +73,9 @@ typename SetVariantsTemplate::Type SetVariantsTemplate::choose for (const auto & col : key_columns) { - if (col->isColumnNullable()) + if (auto * nullable = getNullableColumn(*col)) { - const ColumnNullable & nullable_col = static_cast(*col); - nested_key_columns.push_back(&nullable_col.getNestedColumn()); + nested_key_columns.push_back(&nullable->getNestedColumn()); has_nullable_key = true; } else diff --git a/dbms/src/Interpreters/SetVariants.h b/dbms/src/Interpreters/SetVariants.h index 8b74f3dd09a..49bb3c10386 100644 --- a/dbms/src/Interpreters/SetVariants.h +++ b/dbms/src/Interpreters/SetVariants.h @@ -78,11 +78,10 @@ protected: for (const auto & col : key_columns) { - if (col->isColumnNullable()) + if (auto * nullable = getNullableColumn(*col)) { - const auto & nullable_col = static_cast(*col); - actual_columns.push_back(&nullable_col.getNestedColumn()); - null_maps.push_back(&nullable_col.getNullMapColumn()); + actual_columns.push_back(&nullable->getNestedColumn()); + null_maps.push_back(&nullable->getNullMapColumn()); } else { diff --git a/dbms/src/Storages/MergeTree/MergeTreeSetSkippingIndex.cpp b/dbms/src/Storages/MergeTree/MergeTreeSetSkippingIndex.cpp index 5bf06a1ca6d..208930f1ed1 100644 --- a/dbms/src/Storages/MergeTree/MergeTreeSetSkippingIndex.cpp +++ b/dbms/src/Storages/MergeTree/MergeTreeSetSkippingIndex.cpp @@ -276,7 +276,7 @@ bool SetIndexCondition::mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx_granule) const NullMap * null_map = nullptr; - if (auto * col_nullable = typeid_cast(column.get())) + if (auto * col_nullable = getNullableColumn(*column)) { col_uint8 = typeid_cast(&col_nullable->getNestedColumn()); null_map = &col_nullable->getNullMapData();