fix compatibility problem

mittest/mtlenv/storage/blocksstable/test_index_tree.cpp

@@ -33,6 +33,7 @@
 #include "storage/blocksstable/ob_index_block_macro_iterator.h"
 #include "mtlenv/mock_tenant_module_env.h"
 #include "share/scn.h"
+#include "storage/blocksstable/ob_shared_macro_block_manager.h"
 
 namespace oceanbase
 {
@@ -83,12 +84,14 @@ protected:
   ObRowGenerate index_row_generate_;
   ObITable::TableKey table_key_;
   ObArenaAllocator allocator_;
+  ObSharedMacroBlockMgr *shared_blk_mgr_;
 };
 
 TestIndexTree::TestIndexTree()
     : tenant_id_(500),
     mgr_(nullptr),
-    tenant_base_(500)
+    tenant_base_(500),
+    shared_blk_mgr_(nullptr)
 {
   ObAddr self;
   rpc::frame::ObReqTransport req_transport(NULL, NULL);
@@ -107,6 +110,7 @@ TestIndexTree::~TestIndexTree()
 
 void TestIndexTree::SetUpTestCase()
 {
+  int ret = OB_SUCCESS;
   STORAGE_LOG(INFO, "SetUpTestCase");
   EXPECT_EQ(OB_SUCCESS, MockTenantModuleEnv::get_instance().init());
 }
@@ -120,12 +124,16 @@ void TestIndexTree::SetUp()
 {
   int ret = OB_SUCCESS;
   mgr_ = OB_NEW(ObTenantFreezeInfoMgr, ObModIds::TEST);
+  shared_blk_mgr_ = OB_NEW(ObSharedMacroBlockMgr, ObModIds::TEST);
+  tenant_base_.set(shared_blk_mgr_);
   tenant_base_.set(mgr_);
 
   share::ObTenantEnv::set_tenant(&tenant_base_);
   ASSERT_EQ(OB_SUCCESS, tenant_base_.init());
   ASSERT_EQ(OB_SUCCESS, mgr_->init(500, *GCTX.sql_proxy_));
+  ASSERT_EQ(OB_SUCCESS, shared_blk_mgr_->init());
   fake_freeze_info();
+  ASSERT_EQ(shared_blk_mgr_, MTL(ObSharedMacroBlockMgr *));
   ASSERT_EQ(mgr_, MTL(ObTenantFreezeInfoMgr *));
   int tmp_ret = OB_SUCCESS;
   ObTenantIOConfig io_config = ObTenantIOConfig::default_instance();
@@ -1134,6 +1142,21 @@ TEST_F(TestIndexTree, test_single_row_desc)
   OK(rebuilder.close());
   ObSSTableMergeRes res2;
   OK(sstable_builder2.close(res.data_column_cnt_, res2));
+
+  // test rebuild sstable by another append_macro_row
+  ObSSTableIndexBuilder sstable_builder3;
+  prepare_index_builder(index_desc, sstable_builder3);
+  sstable_builder3.index_store_desc_.major_working_cluster_version_ = DATA_VERSION_4_1_0_0;
+  sstable_builder3.container_store_desc_.major_working_cluster_version_ = DATA_VERSION_4_1_0_0;
+  ObIndexBlockRebuilder other_rebuilder;
+  OK(other_rebuilder.init(sstable_builder3));
+  ObDataMacroBlockMeta *macro_meta = nullptr;
+  OK(sstable_builder.roots_[0]->macro_metas_->at(0)->deep_copy(macro_meta, allocator_));
+  OK(other_rebuilder.append_macro_row(*macro_meta));
+  OK(other_rebuilder.close());
+  ObSSTableMergeRes res3;
+  sstable_builder3.optimization_mode_ = ObSSTableIndexBuilder::ObSpaceOptimizationMode::AUTO;
+  OK(sstable_builder3.close(res.data_column_cnt_, res3));
 }
 
 TEST_F(TestIndexTree, test_data_block_checksum)

src/storage/blocksstable/ob_index_block_builder.cpp

@@ -866,8 +866,7 @@ int ObSSTableIndexBuilder::close(const int64_t column_cnt, ObSSTableMergeRes &re
     STORAGE_LOG(DEBUG, "sstable has no data", K(ret));
   } else if (OB_FAIL(sort_roots())) {
     STORAGE_LOG(WARN, "fail to sort roots", K(ret));
-  } else if (!index_store_desc_.is_major_merge()
+  } else if (check_version_for_small_sstable(index_store_desc_)) {
-      || index_store_desc_.major_working_cluster_version_ >= DATA_VERSION_4_1_0_0) {
     const bool is_single_block = check_single_block();
     if (is_single_block) {
       switch (optimization_mode_) {
@@ -939,6 +938,12 @@ int ObSSTableIndexBuilder::close(const int64_t column_cnt, ObSSTableMergeRes &re
   return ret;
 }
 
+bool ObSSTableIndexBuilder::check_version_for_small_sstable(const ObDataStoreDesc &index_desc)
+{
+  return !index_desc.is_major_merge()
+      || index_desc.major_working_cluster_version_ >= DATA_VERSION_4_1_0_0;
+}
+
 int ObSSTableIndexBuilder::check_and_rewrite_sstable(ObSSTableMergeRes &res)
 {
   int ret = OB_SUCCESS;
@@ -2179,7 +2184,8 @@ int ObMetaIndexBlockBuilder::close(
     } else if (OB_FAIL(build_single_node_tree(*allocator_, micro_block_desc, block_desc))) {
       STORAGE_LOG(WARN, "fail to build single node tree of meta", K(ret));
     }
-  } else if (row_count_ <= 0 && 1 == micro_block_desc.row_count_) {
+  } else if (row_count_ <= 0 && 1 == micro_block_desc.row_count_
+      && ObSSTableIndexBuilder::check_version_for_small_sstable(*index_store_desc_)) {
     // this sstable only has one data block, but the size of meta data exceeds ROOT_BLOCK_SIZE_LIMIT,
     // so sstable's root points to the tail of its data block (macro meta row)
     if (OB_FAIL(build_single_macro_row_desc(roots))) {

src/storage/blocksstable/ob_index_block_builder.h

@@ -453,6 +453,8 @@ public:
   int close(const int64_t column_cnt, ObSSTableMergeRes &res);
   const ObDataStoreDesc &get_index_store_desc() const { return index_store_desc_; }
   TO_STRING_KV(K(roots_.count()));
+public:
+  static bool check_version_for_small_sstable(const ObDataStoreDesc &index_desc);
 private:
   int check_and_rewrite_sstable(ObSSTableMergeRes &res);
   int check_and_rewrite_sstable_without_size(ObSSTableMergeRes &res);