upd

Author: Mryange

be/src/vec/columns/column.cpp

@@ -43,6 +43,25 @@ std::string IColumn::dump_structure() const {
     return res.str();
 }
 
+int IColumn::count_const_column() const {
+    int count = is_column_const(*this) ? 1 : 0;
+    ColumnCallback callback = [&](ColumnPtr& subcolumn) {
+        count += subcolumn->count_const_column();
+    };
+    // simply read using for_each_subcolumn without modification; const_cast can be used.
+    const_cast<IColumn*>(this)->for_each_subcolumn(callback);
+    return count;
+}
+
+bool IColumn::const_nested_check() const {
+    auto const_cnt = count_const_column();
+    if (const_cnt == 0) {
+        return true;
+    }
+    // A const column is not allowed to be nested; it may only appear as the outermost (top-level) column.
+    return const_cnt == 1 && is_column_const(*this);
+}
+
 void IColumn::insert_from(const IColumn& src, size_t n) {
     insert(src[n]);
 }

be/src/vec/columns/column.h

@@ -647,6 +647,13 @@ class IColumn : public COW<IColumn> {
       */
     String dump_structure() const;
 
+    // count how many const column including self
+    int count_const_column() const;
+
+    // const column nested check, eg. const(nullable(...)) is allowed
+    //  const(array(const(...))) is not allowed
+    bool const_nested_check() const;
+
     // only used in agg value replace for column which is not variable length, eg.BlockReader::_copy_value_data
     // usage: self_column.replace_column_data(other_column, other_column's row index, self_column's row index)
     virtual void replace_column_data(const IColumn&, size_t row, size_t self_row = 0) = 0;

be/src/vec/core/block.cpp

@@ -399,6 +399,12 @@ Status Block::check_type_and_column() const {
         const auto& type = elem.type;
         const auto& column = elem.column;
 
+        if (!column->const_nested_check()) {
+            return Status::InternalError(
+                    "Column {} in block failed const check, data type :{} , column structure",
+                    elem.name, type->get_name(), column->dump_structure());
+        }
+
         auto st = type->check_column(*column);
         if (!st.ok()) {
             return Status::InternalError(

be/test/vec/columns/column_const_check_test.cpp

@@ -0,0 +1,76 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <gtest/gtest.h>
+
+#include "runtime/primitive_type.h"
+#include "testutil/column_helper.h"
+#include "vec/columns/column.h"
+#include "vec/columns/column_array.h"
+#include "vec/columns/column_const.h"
+#include "vec/data_types/data_type_number.h"
+#include "vec/functions/function.h"
+#include "vec/functions/simple_function_factory.h"
+
+namespace doris::vectorized {
+
+TEST(ColumnConstCheckTest, test1) {
+    {
+        ColumnPtr col = ColumnHelper::create_column<DataTypeInt32>({1, 2, 3});
+        EXPECT_EQ(col->const_nested_check(), true);
+    }
+
+    {
+        ColumnPtr col = ColumnHelper::create_column<DataTypeInt32>({1});
+        ColumnPtr const_col = ColumnConst::create(col, 3);
+        EXPECT_EQ(const_col->const_nested_check(), true);
+    }
+
+    {
+        ColumnPtr col = ColumnHelper::create_column<DataTypeInt32>({});
+
+        auto array_const_col = ColumnArray::create(col);
+
+        array_const_col->data = ColumnConst::create(col, 3, true);
+
+        auto const_array = ColumnConst::create(std::move(array_const_col), 2, true);
+
+        std::cout << const_array->dump_structure() << std::endl;
+
+        std::cout << const_array->count_const_column() << std::endl;
+
+        EXPECT_EQ(const_array->const_nested_check(), false);
+    }
+
+    {
+        ColumnPtr col = ColumnHelper::create_column<DataTypeInt32>({});
+
+        auto array_const_col = ColumnArray::create(col);
+
+        array_const_col->data = ColumnConst::create(col, 3, true);
+
+        auto const_array = ColumnConst::create(std::move(array_const_col), 2, true);
+
+        Block block;
+        block.insert({std::move(const_array),
+                      std::make_shared<DataTypeArray>(std::make_shared<DataTypeInt32>()),
+                      "array_col"});
+
+        EXPECT_FALSE(block.check_type_and_column());
+    }
+}
+} // namespace doris::vectorized