[BugFix] Adjust NULL_TYPE hack processing(2) (#17483)

Signed-off-by: liuyehcf <1559500551@qq.com>

be/src/column/array_column.cpp

@@ -35,6 +35,7 @@ void ArrayColumn::check_or_die() const {
 
 ArrayColumn::ArrayColumn(ColumnPtr elements, UInt32Column::Ptr offsets)
         : _elements(std::move(elements)), _offsets(std::move(offsets)) {
+    DCHECK(_elements->is_nullable());
     if (_offsets->empty()) {
         _offsets->append(0);
     }

be/src/column/array_column.h

@@ -189,7 +189,7 @@ class ArrayColumn final : public ColumnFactory<Column, ArrayColumn> {
     Status unfold_const_children(const starrocks::TypeDescriptor& type) override;
 
 private:
-    // _elements must be NullableColumn
+    // Elements must be NullableColumn to facilitate handling nested types.
     ColumnPtr _elements;
     // Offsets column will store the start position of every array element.
     // Offsets store more one data to indicate the end position.

be/src/column/map_column.cpp

@@ -39,6 +39,8 @@ void MapColumn::check_or_die() const {
 
 MapColumn::MapColumn(ColumnPtr keys, ColumnPtr values, UInt32Column::Ptr offsets)
         : _keys(std::move(keys)), _values(std::move(values)), _offsets(std::move(offsets)) {
+    DCHECK(_keys->is_nullable());
+    DCHECK(_values->is_nullable());
     if (_offsets->empty()) {
         _offsets->append(0);
     }

be/src/column/map_column.h

@@ -187,9 +187,9 @@ class MapColumn final : public ColumnFactory<Column, MapColumn> {
     Status unfold_const_children(const starrocks::TypeDescriptor& type) override;
 
 private:
-    // keys must be NullableColumn
+    // Keys must be NullableColumn to facilitate handling nested types.
     ColumnPtr _keys;
-    // values must be NullableColumn
+    // Values must be NullableColumn to facilitate handling nested types.
     ColumnPtr _values;
     // Offsets column will store the start position of every map element.
     // Offsets store more one data to indicate the end position.

be/src/column/nullable_column.h

@@ -33,6 +33,14 @@ class NullableColumn final : public ColumnFactory<Column, NullableColumn> {
     friend class ColumnFactory<Column, NullableColumn>;
 
 public:
+    inline static ColumnPtr wrap_if_necessary(ColumnPtr column) {
+        if (column->is_nullable()) {
+            return column;
+        }
+        auto null = NullColumn::create(column->size(), 0);
+        return NullableColumn::create(std::move(column), std::move(null));
+    }
+
     NullableColumn(MutableColumnPtr&& data_column, MutableColumnPtr&& null_column);
     NullableColumn(ColumnPtr data_column, NullColumnPtr null_column);
 
@@ -272,7 +280,7 @@ class NullableColumn final : public ColumnFactory<Column, NullableColumn> {
     }
 
     std::string debug_item(size_t idx) const override {
-        DCHECK(_null_column->size() == _data_column->size());
+        DCHECK_EQ(_null_column->size(), _data_column->size());
         std::stringstream ss;
         if (_null_column->get_data()[idx]) {
             ss << "NULL";
@@ -283,7 +291,7 @@ class NullableColumn final : public ColumnFactory<Column, NullableColumn> {
     }
 
     std::string debug_string() const override {
-        DCHECK(_null_column->size() == _data_column->size());
+        DCHECK_EQ(_null_column->size(), _data_column->size());
         std::stringstream ss;
         ss << "[";
         size_t size = _data_column->size();

be/src/exprs/cast_nested.cpp

@@ -39,6 +39,7 @@ StatusOr<ColumnPtr> CastMapExpr::evaluate_checked(ExprContext* context, Chunk* p
     } else {
         casted_key_column = map_column->keys_column()->clone_shared();
     }
+    casted_key_column = NullableColumn::wrap_if_necessary(casted_key_column);
 
     // cast value column
     if (_value_cast != nullptr) {
@@ -48,6 +49,7 @@ StatusOr<ColumnPtr> CastMapExpr::evaluate_checked(ExprContext* context, Chunk* p
     } else {
         casted_value_column = map_column->values_column()->clone_shared();
     }
+    casted_value_column = NullableColumn::wrap_if_necessary(casted_value_column);
     auto casted_map =
             MapColumn::create(std::move(casted_key_column), std::move(casted_value_column),
                               ColumnHelper::as_column<UInt32Column>(map_column->offsets_column()->clone_shared()));
@@ -109,6 +111,7 @@ StatusOr<ColumnPtr> CastArrayExpr::evaluate_checked(ExprContext* context, Chunk*
     } else {
         casted_element_column = array_column->elements_column()->clone_shared();
     }
+    casted_element_column = NullableColumn::wrap_if_necessary(casted_element_column);
 
     auto casted_array =
             ArrayColumn::create(std::move(casted_element_column),

be/src/exprs/split.cpp

@@ -176,7 +176,8 @@ StatusOr<ColumnPtr> StringFunctions::split(FunctionContext* context, const starr
     } else {
         array_binary_column->reserve(row_nums * 5, haystack_columns->get_bytes().size() * sizeof(uint8_t));
 
-        auto result_array = ArrayColumn::create(BinaryColumn::create(), UInt32Column::create());
+        auto result_array = ArrayColumn::create(NullableColumn::create(BinaryColumn::create(), NullColumn::create()),
+                                                UInt32Column::create());
         NullColumnPtr null_array = NullColumn::create();
         for (int row = 0; row < row_nums; ++row) {
             array_offsets->append(offset);

be/src/storage/chunk_helper.cpp

@@ -217,23 +217,23 @@ template <bool force>
 struct ColumnPtrBuilder {
     template <LogicalType ftype>
     ColumnPtr operator()(size_t chunk_size, const Field& field, int precision, int scale) {
-        auto nullable = [&](ColumnPtr c) -> ColumnPtr {
+        auto NullableIfNeed = [&](ColumnPtr c) -> ColumnPtr {
             return field.is_nullable()
                            ? NullableColumn::create(std::move(c), get_column_ptr<NullColumn, force>(chunk_size))
                            : c;
         };
 
         if constexpr (ftype == TYPE_ARRAY) {
-            auto elements = field.sub_field(0).create_column();
+            auto elements = NullableColumn::wrap_if_necessary(field.sub_field(0).create_column());
             auto offsets = get_column_ptr<UInt32Column, force>(chunk_size);
             auto array = ArrayColumn::create(std::move(elements), offsets);
-            return nullable(array);
+            return NullableIfNeed(array);
         } else if constexpr (ftype == TYPE_MAP) {
-            auto keys = field.sub_field(0).create_column();
-            auto values = field.sub_field(1).create_column();
+            auto keys = NullableColumn::wrap_if_necessary(field.sub_field(0).create_column());
+            auto values = NullableColumn::wrap_if_necessary(field.sub_field(1).create_column());
             auto offsets = get_column_ptr<UInt32Column, force>(chunk_size);
             auto map = MapColumn::create(std::move(keys), std::move(values), offsets);
-            return nullable(map);
+            return NullableIfNeed(map);
         } else if constexpr (ftype == TYPE_STRUCT) {
             std::vector<std::string> names;
             std::vector<ColumnPtr> fields;
@@ -242,17 +242,17 @@ struct ColumnPtrBuilder {
                 fields.template emplace_back(sub_field.create_column());
             }
             auto struct_column = StructColumn::create(std::move(fields), std::move(names));
-            return nullable(struct_column);
+            return NullableIfNeed(struct_column);
         } else {
             switch (ftype) {
             case TYPE_DECIMAL32:
-                return nullable(get_decimal_column_ptr<Decimal32Column, force>(precision, scale, chunk_size));
+                return NullableIfNeed(get_decimal_column_ptr<Decimal32Column, force>(precision, scale, chunk_size));
             case TYPE_DECIMAL64:
-                return nullable(get_decimal_column_ptr<Decimal64Column, force>(precision, scale, chunk_size));
+                return NullableIfNeed(get_decimal_column_ptr<Decimal64Column, force>(precision, scale, chunk_size));
             case TYPE_DECIMAL128:
-                return nullable(get_decimal_column_ptr<Decimal128Column, force>(precision, scale, chunk_size));
+                return NullableIfNeed(get_decimal_column_ptr<Decimal128Column, force>(precision, scale, chunk_size));
             default: {
-                return nullable(get_column_ptr<typename CppColumnTraits<ftype>::ColumnType, force>(chunk_size));
+                return NullableIfNeed(get_column_ptr<typename CppColumnTraits<ftype>::ColumnType, force>(chunk_size));
             }
             }
         }