array and map nullable assertion

Signed-off-by: liuyehcf <1559500551@qq.com>
StarRocks · Feb 9, 2023 · acf2c9e · acf2c9e
1 parent 4a1c6a6
commit acf2c9e
Show file tree

Hide file tree

Showing 16 changed files with 357 additions and 463 deletions.
diff --git a/be/src/column/array_column.cpp b/be/src/column/array_column.cpp
@@ -34,9 +34,8 @@ void ArrayColumn::check_or_die() const {
 }
 
 ArrayColumn::ArrayColumn(ColumnPtr elements, UInt32Column::Ptr offsets)
-        : _elements(elements->is_nullable() ? std::move(elements)
-                                            : NullableColumn::create(std::move(elements), NullColumn::create())),
-          _offsets(std::move(offsets)) {
+        : _elements(std::move(elements)), _offsets(std::move(offsets)) {
+    DCHECK(_elements->is_nullable());
     if (_offsets->empty()) {
         _offsets->append(0);
     }

diff --git a/be/src/column/array_column.h b/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.

diff --git a/be/src/column/map_column.cpp b/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);
     }

diff --git a/be/src/column/map_column.h b/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.

diff --git a/be/src/column/nullable_column.h b/be/src/column/nullable_column.h
@@ -272,7 +272,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 +283,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();

diff --git a/be/src/exprs/cast_nested.cpp b/be/src/exprs/cast_nested.cpp
@@ -39,6 +39,10 @@ StatusOr<ColumnPtr> CastMapExpr::evaluate_checked(ExprContext* context, Chunk* p
     } else {
         casted_key_column = map_column->keys_column()->clone_shared();
     }
+    if (!casted_key_column->is_nullable()) {
+        NullColumnPtr null_column = NullColumn::create(casted_key_column->size(), 0);
+        casted_key_column = NullableColumn::create(casted_key_column, null_column);
+    }
 
     // cast value column
     if (_value_cast != nullptr) {
@@ -48,6 +52,10 @@ StatusOr<ColumnPtr> CastMapExpr::evaluate_checked(ExprContext* context, Chunk* p
     } else {
         casted_value_column = map_column->values_column()->clone_shared();
     }
+    if (!casted_value_column->is_nullable()) {
+        NullColumnPtr null_column = NullColumn::create(casted_value_column->size(), 0);
+        casted_value_column = NullableColumn::create(casted_value_column, null_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 +117,10 @@ StatusOr<ColumnPtr> CastArrayExpr::evaluate_checked(ExprContext* context, Chunk*
     } else {
         casted_element_column = array_column->elements_column()->clone_shared();
     }
+    if (!casted_element_column->is_nullable()) {
+        NullColumnPtr null_column = NullColumn::create(casted_element_column->size(), 0);
+        casted_element_column = NullableColumn::create(casted_element_column, null_column);
+    }
 
     auto casted_array =
             ArrayColumn::create(std::move(casted_element_column),

diff --git a/be/src/exprs/split.cpp b/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);

diff --git a/be/src/storage/chunk_helper.cpp b/be/src/storage/chunk_helper.cpp
@@ -224,13 +224,13 @@ struct ColumnPtrBuilder {
         };
 
         if constexpr (ftype == TYPE_ARRAY) {
-            auto elements = field.sub_field(0).create_column();
+            auto elements = nullable(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);
         } else if constexpr (ftype == TYPE_MAP) {
-            auto keys = field.sub_field(0).create_column();
-            auto values = field.sub_field(1).create_column();
+            auto keys = nullable(field.sub_field(0).create_column());
+            auto values = nullable(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);