[fix](variant)fix core in column_object when sort from empty block

be/src/vec/columns/column_object.cpp

@@ -1102,7 +1102,7 @@ void ColumnObject::insert_range_from(const IColumn& src, size_t start, size_t le
 }
 
 ColumnPtr ColumnObject::replicate(const Offsets& offsets) const {
-    if (subcolumns.empty()) {
+    if (num_rows == 0 || subcolumns.empty()) {
         // Add an emtpy column with offsets.back rows
         auto res = ColumnObject::create(true, false);
         res->set_num_rows(offsets.back());
@@ -1112,7 +1112,7 @@ ColumnPtr ColumnObject::replicate(const Offsets& offsets) const {
 }
 
 ColumnPtr ColumnObject::permute(const Permutation& perm, size_t limit) const {
-    if (subcolumns.empty()) {
+    if (num_rows == 0 || subcolumns.empty()) {
         if (limit == 0) {
             limit = num_rows;
         } else {
@@ -1747,7 +1747,7 @@ ColumnPtr ColumnObject::filter(const Filter& filter, ssize_t count) const {
         auto& finalized_object = assert_cast<ColumnObject&>(*finalized);
         return finalized_object.filter(filter, count);
     }
-    if (subcolumns.empty()) {
+    if (num_rows == 0 || subcolumns.empty()) {
         // Add an emtpy column with filtered rows
         auto res = ColumnObject::create(true, false);
         res->set_num_rows(count_bytes_in_filter(filter));
@@ -1766,7 +1766,7 @@ Status ColumnObject::filter_by_selector(const uint16_t* sel, size_t sel_size, IC
     if (!is_finalized()) {
         finalize();
     }
-    if (subcolumns.empty()) {
+    if (num_rows == 0 || subcolumns.empty()) {
         assert_cast<ColumnObject*>(col_ptr)->insert_many_defaults(sel_size);
         return Status::OK();
     }

be/test/vec/columns/column_object_test.cpp

@@ -21,10 +21,47 @@
 #include <gtest/gtest-test-part.h>
 #include <gtest/gtest.h>
 
+#include "vec/columns/common_column_test.h"
+
 namespace doris::vectorized {
 
 class ColumnObjectTest : public ::testing::Test {};
 
+auto construct_dst_varint_column() {
+    // 1. create an empty variant column
+    vectorized::ColumnObject::Subcolumns dynamic_subcolumns;
+    dynamic_subcolumns.create_root(vectorized::ColumnObject::Subcolumn(0, true, true /*root*/));
+    dynamic_subcolumns.add(vectorized::PathInData("v.f"),
+                           vectorized::ColumnObject::Subcolumn {0, true});
+    dynamic_subcolumns.add(vectorized::PathInData("v.e"),
+                           vectorized::ColumnObject::Subcolumn {0, true});
+    dynamic_subcolumns.add(vectorized::PathInData("v.b"),
+                           vectorized::ColumnObject::Subcolumn {0, true});
+    dynamic_subcolumns.add(vectorized::PathInData("v.b.d"),
+                           vectorized::ColumnObject::Subcolumn {0, true});
+    dynamic_subcolumns.add(vectorized::PathInData("v.c.d"),
+                           vectorized::ColumnObject::Subcolumn {0, true});
+    return ColumnObject::create(std::move(dynamic_subcolumns), true);
+}
+
+TEST_F(ColumnObjectTest, permute) {
+    auto column_variant = construct_dst_varint_column();
+    {
+        // test empty column and limit == 0
+        IColumn::Permutation permutation(0);
+        auto col = column_variant->clone_empty();
+        col->permute(permutation, 0);
+        EXPECT_EQ(col->size(), 0);
+    }
+
+    MutableColumns columns;
+    columns.push_back(column_variant->get_ptr());
+    assert_column_vector_permute(columns, 0);
+    assert_column_vector_permute(columns, 1);
+    assert_column_vector_permute(columns, column_variant->size());
+    assert_column_vector_permute(columns, UINT64_MAX);
+}
+
 // TEST
 TEST_F(ColumnObjectTest, test_pop_back) {
     ColumnObject::Subcolumn subcolumn(0, true /* is_nullable */, false /* is_root */);

be/test/vec/columns/common_column_test.h

@@ -2346,8 +2346,20 @@ auto check_permute = [](const IColumn& column, const IColumn::Permutation& permu
                         size_t limit, size_t expected_size) {
     auto res_col = column.permute(permutation, limit);
     EXPECT_EQ(res_col->size(), expected_size);
-    for (size_t j = 0; j < expected_size; ++j) {
-        EXPECT_EQ(res_col->compare_at(j, permutation[j], column, -1), 0);
+    try {
+        for (size_t j = 0; j < expected_size; ++j) {
+            EXPECT_EQ(res_col->compare_at(j, permutation[j], column, -1), 0);
+        }
+    } catch (doris::Exception& e) {
+        LOG(ERROR) << "Exception: " << e.what();
+        // using field check
+        for (size_t j = 0; j < expected_size; ++j) {
+            Field r;
+            Field l;
+            column.get(permutation[j], r);
+            res_col->get(j, l);
+            EXPECT_EQ(r, l);
+        }
     }
 };
 auto assert_column_vector_permute = [](MutableColumns& cols, size_t num_rows) {