[refactor]Delete useless code check_set_nullable()

be/src/vec/columns/column_nullable.cpp

@@ -634,16 +634,4 @@ ColumnPtr remove_nullable(const ColumnPtr& column) {
     return column;
 }
 
-void check_set_nullable(ColumnPtr& argument_column, ColumnVector<UInt8>::MutablePtr& null_map,
-                        bool is_single) {
-    if (const auto* nullable = check_and_get_column<ColumnNullable>(*argument_column)) {
-        // Danger: Here must dispose the null map data first! Because
-        // argument_columns[i]=nullable->get_nested_column_ptr(); will release the mem
-        // of column nullable mem of null map
-        VectorizedUtils::update_null_map(null_map->get_data(), nullable->get_null_map_data(),
-                                         is_single);
-        argument_column = nullable->get_nested_column_ptr();
-    }
-}
-
 } // namespace doris::vectorized

be/src/vec/columns/column_nullable.h

@@ -479,8 +479,4 @@ class ColumnNullable final : public COWHelper<IColumn, ColumnNullable>, public N
 
 ColumnPtr make_nullable(const ColumnPtr& column, bool is_nullable = false);
 ColumnPtr remove_nullable(const ColumnPtr& column);
-// check if argument column is nullable. If so, extract its concrete column and set null_map.
-//TODO: use this to replace inner usages.
-// is_single: whether null_map is null map of a ColumnConst
-void check_set_nullable(ColumnPtr&, ColumnVector<UInt8>::MutablePtr& null_map, bool is_single);
 } // namespace doris::vectorized

be/src/vec/functions/array/function_array_contains_all.cpp

@@ -37,8 +37,6 @@ class FunctionArrayContainsAll : public IFunction {
 
     String get_name() const override { return name; }
 
-    bool use_default_implementation_for_nulls() const override { return true; }
-
     bool is_variadic() const override { return false; }
 
     size_t get_number_of_arguments() const override { return 2; }

be/src/vec/functions/array/function_array_enumerate.cpp

@@ -56,7 +56,6 @@ class FunctionArrayEnumerate : public IFunction {
     static constexpr auto name = "array_enumerate";
     static FunctionPtr create() { return std::make_shared<FunctionArrayEnumerate>(); }
     String get_name() const override { return name; }
-    bool use_default_implementation_for_nulls() const override { return true; }
     size_t get_number_of_arguments() const override { return 1; }
     DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
         const DataTypeArray* array_type =

be/src/vec/functions/array/function_array_range.cpp

@@ -65,8 +65,6 @@ class FunctionArrayRange : public IFunction {
 
     bool is_variadic() const override { return true; }
 
-    bool use_default_implementation_for_nulls() const override { return false; }
-
     size_t get_number_of_arguments() const override {
         return get_variadic_argument_types_impl().size();
     }
@@ -146,14 +144,6 @@ struct RangeImplUtil {
         for (int i = 0; i < 3; ++i) {
             argument_columns[i] =
                     block.get_by_position(arguments[i]).column->convert_to_full_column_if_const();
-            if (auto* nullable = check_and_get_column<ColumnNullable>(*argument_columns[i])) {
-                // Danger: Here must dispose the null map data first! Because
-                // argument_columns[i]=nullable->get_nested_column_ptr(); will release the mem
-                // of column nullable mem of null map
-                VectorizedUtils::update_null_map(args_null_map->get_data(),
-                                                 nullable->get_null_map_data());
-                argument_columns[i] = nullable->get_nested_column_ptr();
-            }
         }
         auto start_column =
                 assert_cast<const ColumnVector<SourceDataType>*>(argument_columns[0].get());

be/src/vec/functions/function_bitmap.cpp

@@ -349,8 +349,6 @@ class FunctionBitmapAlwaysNull : public IFunction {
 
     size_t get_number_of_arguments() const override { return 1; }
 
-    bool use_default_implementation_for_nulls() const override { return true; }
-
     Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
                         size_t result, size_t input_rows_count) const override {
         auto res_null_map = ColumnUInt8::create(input_rows_count, 0);
@@ -1148,8 +1146,6 @@ class FunctionBitmapSubs : public IFunction {
 
     size_t get_number_of_arguments() const override { return 3; }
 
-    bool use_default_implementation_for_nulls() const override { return false; }
-
     Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
                         size_t result, size_t input_rows_count) const override {
         DCHECK_EQ(arguments.size(), 3);
@@ -1168,10 +1164,6 @@ class FunctionBitmapSubs : public IFunction {
 
         default_preprocess_parameter_columns(argument_columns, col_const, {1, 2}, block, arguments);
 
-        for (int i = 0; i < 3; i++) {
-            check_set_nullable(argument_columns[i], res_null_map, col_const[i]);
-        }
-
         auto bitmap_column = assert_cast<const ColumnBitmap*>(argument_columns[0].get());
         auto offset_column = assert_cast<const ColumnVector<Int64>*>(argument_columns[1].get());
         auto limit_column = assert_cast<const ColumnVector<Int64>*>(argument_columns[2].get());
@@ -1207,8 +1199,6 @@ class FunctionBitmapToArray : public IFunction {
 
     size_t get_number_of_arguments() const override { return 1; }
 
-    bool use_default_implementation_for_nulls() const override { return true; }
-
     Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
                         size_t result, size_t input_rows_count) const override {
         auto return_nested_type = make_nullable(std::make_shared<DataTypeInt64>());

be/src/vec/functions/function_bitmap_min_or_max.h

@@ -55,14 +55,6 @@ class FunctionBitmapSingle : public IFunction {
         auto result_null_map_column = ColumnUInt8::create(input_rows_count, 0);
 
         ColumnPtr argument_column = block.get_by_position(arguments[0]).column;
-        if (auto* nullable = check_and_get_column<ColumnNullable>(*argument_column)) {
-            // Danger: Here must dispose the null map data first! Because
-            // argument_columns[i]=nullable->get_nested_column_ptr(); will release the mem
-            // of column nullable mem of null map
-            VectorizedUtils::update_null_map(result_null_map_column->get_data(),
-                                             nullable->get_null_map_data());
-            argument_column = nullable->get_nested_column_ptr();
-        }
 
         execute_straight(assert_cast<const ColumnBitmap*>(argument_column.get()),
                          assert_cast<ColumnInt64*>(result_column.get()),

be/src/vec/functions/function_conv.cpp

@@ -72,8 +72,6 @@ class FunctionConv : public IFunction {
         return get_variadic_argument_types_impl().size();
     }
 
-    bool use_default_implementation_for_nulls() const override { return false; }
-
     Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
                         size_t result, size_t input_rows_count) const override {
         auto result_column = ColumnString::create();
@@ -91,10 +89,6 @@ class FunctionConv : public IFunction {
 
         default_preprocess_parameter_columns(argument_columns, col_const, {1, 2}, block, arguments);
 
-        for (int i = 0; i < 3; i++) {
-            check_set_nullable(argument_columns[i], result_null_map_column, col_const[i]);
-        }
-
         if (col_const[1] && col_const[2]) {
             execute_scalar_args(
                     context,

be/src/vec/functions/function_date_or_datetime_to_string.h

@@ -65,7 +65,6 @@ class FunctionDateOrDateTimeToString : public IFunction {
     String get_name() const override { return name; }
 
     size_t get_number_of_arguments() const override { return 1; }
-    bool use_default_implementation_for_nulls() const override { return false; }
 
     DataTypePtr get_return_type_impl(const ColumnsWithTypeAndName& arguments) const override {
         RETURN_REAL_TYPE_FOR_DATEV2_FUNCTION(DataTypeString);
@@ -95,14 +94,6 @@ class FunctionDateOrDateTimeToString : public IFunction {
                 TransformerToStringOneArgument<Transform>::vector(
                         context, sources->get_data(), col_res->get_chars(), col_res->get_offsets(),
                         null_map->get_data());
-                if (const auto* nullable_col =
-                            check_and_get_column<ColumnNullable>(source_col.get())) {
-                    NullMap& result_null_map = assert_cast<ColumnUInt8&>(*null_map).get_data();
-                    const NullMap& src_null_map =
-                            assert_cast<const ColumnUInt8&>(nullable_col->get_null_map_column())
-                                    .get_data();
-                    VectorizedUtils::update_null_map(result_null_map, src_null_map);
-                }
                 block.replace_by_position(
                         result, ColumnNullable::create(std::move(col_res), std::move(null_map)));
             } else {

be/src/vec/functions/function_encryption.cpp

@@ -110,8 +110,6 @@ class FunctionEncryptionAndDecrypt : public IFunction {
         return get_variadic_argument_types_impl().size();
     }
 
-    bool use_default_implementation_for_nulls() const override { return false; }
-
     Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
                         size_t result, size_t input_rows_count) const override {
         return Impl::execute_impl_inner(context, block, arguments, result, input_rows_count);
@@ -207,9 +205,6 @@ struct EncryptionAndDecryptTwoImpl {
 
         default_preprocess_parameter_columns(argument_columns, col_const, {1, 2}, block, arguments);
 
-        for (int i = 0; i < argument_size; i++) {
-            check_set_nullable(argument_columns[i], result_null_map_column, col_const[i]);
-        }
         auto& result_data = result_column->get_chars();
         auto& result_offset = result_column->get_offsets();
         result_offset.resize(input_rows_count);
@@ -327,9 +322,6 @@ struct EncryptionAndDecryptMultiImpl {
                                                  arguments);
         }
 
-        for (int i = 0; i < argument_size; i++) {
-            check_set_nullable(argument_columns[i], result_null_map_column, col_const[i]);
-        }
         auto& result_data = result_column->get_chars();
         auto& result_offset = result_column->get_offsets();
         result_offset.resize(input_rows_count);

be/src/vec/functions/function_jsonb.cpp

@@ -1350,7 +1350,6 @@ class FunctionJsonbLength : public IFunction {
     }
 
     bool use_default_implementation_for_nulls() const override { return false; }
-
     Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
                         size_t result, size_t input_rows_count) const override {
         return Impl::execute_impl(context, block, arguments, result, input_rows_count);

be/src/vec/functions/function_regexp.cpp

@@ -391,8 +391,6 @@ class FunctionRegexp : public IFunction {
 
     String get_name() const override { return name; }
 
-    bool use_default_implementation_for_nulls() const override { return false; }
-
     size_t get_number_of_arguments() const override {
         if constexpr (std::is_same_v<Impl, RegexpExtractAllImpl>) {
             return 2;
@@ -455,9 +453,6 @@ class FunctionRegexp : public IFunction {
             default_preprocess_parameter_columns(argument_columns, col_const, {1, 2}, block,
                                                  arguments);
         }
-        for (int i = 0; i < argument_size; i++) {
-            check_set_nullable(argument_columns[i], result_null_map, col_const[i]);
-        }
 
         if constexpr (std::is_same_v<Impl, RegexpExtractAllImpl>) {
             if (col_const[1]) {

be/src/vec/functions/function_timestamp.cpp

@@ -115,12 +115,9 @@ struct StrToDate {
         ColumnPtr argument_columns[2] = {
                 col_const[0] ? static_cast<const ColumnConst&>(*col0).convert_to_full_column()
                              : col0};
-        check_set_nullable(argument_columns[0], null_map, col_const[0]);
-        //TODO: when we set default implementation for nullable, the check_set_nullable for arguments is useless. consider to remove it.
 
         std::tie(argument_columns[1], col_const[1]) =
                 unpack_if_const(block.get_by_position(arguments[1]).column);
-        check_set_nullable(argument_columns[1], null_map, col_const[1]);
 
         auto specific_str_column = assert_cast<const ColumnString*>(argument_columns[0].get());
         auto specific_char_column = assert_cast<const ColumnString*>(argument_columns[1].get());
@@ -265,11 +262,9 @@ struct MakeDateImpl {
         ColumnPtr argument_columns[2] = {
                 col_const[0] ? static_cast<const ColumnConst&>(*col0).convert_to_full_column()
                              : col0};
-        check_set_nullable(argument_columns[0], null_map, col_const[0]);
 
         std::tie(argument_columns[1], col_const[1]) =
                 unpack_if_const(block.get_by_position(arguments[1]).column);
-        check_set_nullable(argument_columns[1], null_map, col_const[1]);
 
         ColumnPtr res = nullptr;
         WhichDataType which(remove_nullable(block.get_by_position(result).type));
@@ -502,8 +497,6 @@ class FromDays : public IFunction {
 
     size_t get_number_of_arguments() const override { return 1; }
 
-    bool use_default_implementation_for_nulls() const override { return true; }
-
     DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
         return make_nullable(std::make_shared<DataTypeDate>());
     }
@@ -713,9 +706,6 @@ struct UnixTimeStampStrImpl {
         auto& col_result_data = col_result->get_data();
         auto& null_map_data = null_map->get_data();
 
-        check_set_nullable(col_left, null_map, source_const);
-        check_set_nullable(col_right, null_map, format_const);
-
         const auto* col_source = assert_cast<const ColumnString*>(col_left.get());
         const auto* col_format = assert_cast<const ColumnString*>(col_right.get());
         for (int i = 0; i < input_rows_count; i++) {
@@ -772,10 +762,6 @@ class FunctionUnixTimestamp : public IFunction {
         return Impl::get_variadic_argument_types();
     }
 
-    bool use_default_implementation_for_nulls() const override {
-        return !static_cast<bool>(std::is_same_v<Impl, UnixTimeStampStrImpl>);
-    }
-
     Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
                         size_t result, size_t input_rows_count) const override {
         return Impl::execute_impl(context, block, arguments, result, input_rows_count);
@@ -849,8 +835,6 @@ class FunctionDateOrDateTimeToDate : public IFunction {
 
     String get_name() const override { return name; }
 
-    bool use_default_implementation_for_nulls() const override { return false; }
-
     size_t get_number_of_arguments() const override { return 1; }
 
     bool is_variadic() const override { return true; }
@@ -907,14 +891,6 @@ struct LastDayImpl {
                     input_rows_count, null_map->get_data(), data_col->get_data(),
                     static_cast<ResultColumnType*>(res_column->assume_mutable().get())->get_data());
 
-            if (const auto* nullable_col = check_and_get_column<ColumnNullable>(
-                        block.get_by_position(arguments[0]).column.get())) {
-                NullMap& result_null_map = assert_cast<ColumnUInt8&>(*null_map).get_data();
-                const NullMap& src_null_map =
-                        assert_cast<const ColumnUInt8&>(nullable_col->get_null_map_column())
-                                .get_data();
-                VectorizedUtils::update_null_map(result_null_map, src_null_map);
-            }
             block.replace_by_position(result,
                                       ColumnNullable::create(res_column, std::move(null_map)));
         } else {
@@ -1019,14 +995,6 @@ struct MondayImpl {
                     input_rows_count, null_map->get_data(), data_col->get_data(),
                     static_cast<ResultColumnType*>(res_column->assume_mutable().get())->get_data());
 
-            if (const auto* nullable_col = check_and_get_column<ColumnNullable>(
-                        block.get_by_position(arguments[0]).column.get())) {
-                NullMap& result_null_map = assert_cast<ColumnUInt8&>(*null_map).get_data();
-                const NullMap& src_null_map =
-                        assert_cast<const ColumnUInt8&>(nullable_col->get_null_map_column())
-                                .get_data();
-                VectorizedUtils::update_null_map(result_null_map, src_null_map);
-            }
             block.replace_by_position(result,
                                       ColumnNullable::create(res_column, std::move(null_map)));
         } else {

be/src/vec/functions/function_totype.h

@@ -322,7 +322,6 @@ class FunctionBinaryToNullType : public IFunction {
         for (int i = 0; i < 2; ++i) {
             std::tie(argument_columns[i], col_const[i]) =
                     unpack_if_const(block.get_by_position(arguments[i]).column);
-            check_set_nullable(argument_columns[i], null_map, col_const[i]);
         }
 
         using ResultDataType = typename Impl<LeftDataType, RightDataType, ResultDateType,
@@ -401,7 +400,6 @@ class FunctionBinaryStringOperateToNullType : public IFunction {
         for (int i = 0; i < 2; ++i) {
             std::tie(argument_columns[i], col_const[i]) =
                     unpack_if_const(block.get_by_position(arguments[i]).column);
-            check_set_nullable(argument_columns[i], null_map, col_const[i]);
         }
 
         auto res = Impl::ColumnType::create();