[bugfix] add latest_row_store_type in sstable meta to calculate merge type for compaction

deps/oblib/src/common/ob_store_format.h

@@ -27,7 +27,8 @@ enum ObRowStoreType : uint8_t
   FLAT_ROW_STORE = 0,
   ENCODING_ROW_STORE = 1,
   SELECTIVE_ENCODING_ROW_STORE = 2,
-  MAX_ROW_STORE
+  MAX_ROW_STORE,
+  DUMMY_ROW_STORE = UINT8_MAX, // invalid dummy row store type for compatibility
 };
 
 enum ObStoreFormatType

mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h

@@ -489,6 +489,7 @@ void TestIndexBlockDataPrepare::prepare_data()
   param.max_merged_trans_version_ = res.max_merged_trans_version_;
   param.row_count_ = res.row_count_;
   param.root_row_store_type_ = root_row_store_type;
+  param.latest_row_store_type_ = table_schema_.get_row_store_type();
   param.data_index_tree_height_ = root_desc.height_;
   param.index_blocks_cnt_ = res.index_blocks_cnt_;
   param.data_blocks_cnt_ = res.data_blocks_cnt_;

mittest/mtlenv/storage/test_ls_migration_param.cpp

@@ -118,7 +118,8 @@ void TestLSMigrationParam::SetUp()
   sstable_meta_.basic_meta_.filled_tx_scn_.set_min();
   sstable_meta_.basic_meta_.contain_uncommitted_row_ = 0;
   sstable_meta_.data_root_info_.addr_ = addr;
-  sstable_meta_.basic_meta_.row_store_type_ = ObRowStoreType::ENCODING_ROW_STORE;
+  sstable_meta_.basic_meta_.root_row_store_type_ = ObRowStoreType::ENCODING_ROW_STORE;
+  sstable_meta_.basic_meta_.latest_row_store_type_ = ObRowStoreType::ENCODING_ROW_STORE;
   sstable_meta_.basic_meta_.data_index_tree_height_ = 0;
   sstable_meta_.macro_info_.macro_meta_info_.addr_ = addr;
 
@@ -181,7 +182,8 @@ TEST_F(TestLSMigrationParam, test_migrate_sstable_param)
   sstable_param.basic_meta_.max_merged_trans_version_      = sstable_meta_.basic_meta_.max_merged_trans_version_;
   sstable_param.basic_meta_.table_mode_                    = sstable_meta_.basic_meta_.table_mode_;
   sstable_param.basic_meta_.contain_uncommitted_row_       = sstable_meta_.basic_meta_.contain_uncommitted_row_;
-  sstable_param.basic_meta_.row_store_type_                = sstable_meta_.basic_meta_.row_store_type_;
+  sstable_param.basic_meta_.root_row_store_type_           = sstable_meta_.basic_meta_.root_row_store_type_;
+  sstable_param.basic_meta_.latest_row_store_type_         = sstable_meta_.basic_meta_.latest_row_store_type_;
   sstable_param.table_key_                     = key;
   sstable_param.basic_meta_.compressor_type_               = sstable_meta_.basic_meta_.compressor_type_;
   sstable_param.basic_meta_.encrypt_id_                    = sstable_meta_.basic_meta_.encrypt_id_;

mittest/mtlenv/storage/test_physical_copy_task.cpp

@@ -246,6 +246,7 @@ void TestSSTableMeta::prepare_create_sstable_param()
   param_.root_block_addr_.set_none_addr();
   param_.data_block_macro_meta_addr_.set_none_addr();
   param_.root_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
+  param_.latest_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
   param_.data_index_tree_height_ = 0;
   param_.index_blocks_cnt_ = 0;
   param_.data_blocks_cnt_ = 0;

mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp

@@ -958,6 +958,7 @@ TEST_F(TestTenantMetaMemMgr, test_get_tablet_with_allocator)
   param.root_block_addr_.set_none_addr();
   param.data_block_macro_meta_addr_.set_none_addr();
   param.root_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
+  param.latest_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
   param.data_index_tree_height_ = 0;
   param.index_blocks_cnt_ = 0;
   param.data_blocks_cnt_ = 0;
@@ -1077,6 +1078,7 @@ TEST_F(TestTenantMetaMemMgr, test_wash_mem_tablet)
   param.root_block_addr_.set_none_addr();
   param.data_block_macro_meta_addr_.set_none_addr();
   param.root_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
+  param.latest_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
   param.data_index_tree_height_ = 0;
   param.index_blocks_cnt_ = 0;
   param.data_blocks_cnt_ = 0;

src/storage/blocksstable/ob_index_block_tree_cursor.cpp

@@ -303,7 +303,7 @@ int ObIndexBlockTreeCursor::init(
     tenant_id_ = MTL_ID();
     const ObSSTableMeta &sstable_meta = sstable.get_meta();
     ObRowStoreType root_row_store_type
-        = static_cast<ObRowStoreType>(sstable_meta.get_basic_meta().row_store_type_);
+        = static_cast<ObRowStoreType>(sstable_meta.get_basic_meta().root_row_store_type_);
     curr_path_item_->row_store_type_ = root_row_store_type;
     read_info_ = read_info;
     rowkey_column_cnt_ = read_info_->get_rowkey_count();
@@ -429,7 +429,7 @@ int ObIndexBlockTreeCursor::drill_down(
         } else {
           curr_path_item_->is_root_micro_block_ = true;
           curr_path_item_->row_store_type_
-              = static_cast<ObRowStoreType>(sstable_meta.get_basic_meta().row_store_type_);
+              = static_cast<ObRowStoreType>(sstable_meta.get_basic_meta().root_row_store_type_);
         }
 
         if (OB_FAIL(ret)) {
@@ -459,7 +459,7 @@ int ObIndexBlockTreeCursor::drill_down(
         } else {
           curr_path_item_->is_root_micro_block_ = true;
           curr_path_item_->row_store_type_
-              = static_cast<ObRowStoreType>(sstable_meta.get_basic_meta().row_store_type_);
+              = static_cast<ObRowStoreType>(sstable_meta.get_basic_meta().root_row_store_type_);
         }
 
         while (OB_SUCC(ret) && !reach_target_depth) {

src/storage/blocksstable/ob_shared_macro_block_manager.cpp

@@ -610,6 +610,7 @@ int ObSharedMacroBlockMgr::create_new_sstable(
   param.progressive_merge_step_ = basic_meta.progressive_merge_step_;
   param.rowkey_column_cnt_ = basic_meta.rowkey_column_count_;
   param.recycle_version_ = basic_meta.recycle_version_;
+  param.latest_row_store_type_ = basic_meta.latest_row_store_type_;
   param.is_ready_for_read_ = true;
 
   ObSSTableMergeRes::fill_addr_and_data(res.root_desc_,
@@ -675,11 +676,11 @@ int ObSharedMacroBlockMgr::prepare_data_desc(
   } else {
     // overwrite the encryption related memberships, otherwise these memberships of new sstable may differ
     // from that of old sstable, since the encryption method of one tablet may change before defragmentation
-    data_desc.row_store_type_ = basic_meta.row_store_type_;
+    data_desc.row_store_type_ = basic_meta.root_row_store_type_;
     data_desc.compressor_type_ = basic_meta.compressor_type_;
     data_desc.master_key_id_ = basic_meta.master_key_id_;
     data_desc.encrypt_id_ = basic_meta.encrypt_id_;
-    data_desc.encoder_opt_.set_store_type(basic_meta.row_store_type_);
+    data_desc.encoder_opt_.set_store_type(basic_meta.root_row_store_type_);
     MEMCPY(data_desc.encrypt_key_, basic_meta.encrypt_key_, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
     data_desc.row_column_count_ = data_desc.rowkey_column_count_ + 1;
     data_desc.col_desc_array_.reset();

src/storage/blocksstable/ob_sstable_meta.cpp

@@ -57,11 +57,12 @@ ObSSTableBasicMeta::ObSSTableBasicMeta()
     table_mode_(),
     status_(0),
     contain_uncommitted_row_(false),
-    row_store_type_(ObRowStoreType::MAX_ROW_STORE),
+    root_row_store_type_(ObRowStoreType::MAX_ROW_STORE),
     compressor_type_(ObCompressorType::INVALID_COMPRESSOR),
     encrypt_id_(0),
     master_key_id_(0),
-    sstable_logic_seq_(0)
+    sstable_logic_seq_(0),
+    latest_row_store_type_(ObRowStoreType::MAX_ROW_STORE)
 {
   MEMSET(encrypt_key_, 0, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
 }
@@ -100,11 +101,12 @@ bool ObSSTableBasicMeta::operator==(const ObSSTableBasicMeta &other) const
       && table_mode_ == other.table_mode_
       && status_ == other.status_
       && contain_uncommitted_row_ == other.contain_uncommitted_row_
-      && row_store_type_ == other.row_store_type_
+      && root_row_store_type_ == other.root_row_store_type_
       && compressor_type_ == other.compressor_type_
       && encrypt_id_ == other.encrypt_id_
       && master_key_id_ == other.master_key_id_
-      && 0 == MEMCMP(encrypt_key_, other.encrypt_key_, sizeof(encrypt_key_));
+      && 0 == MEMCMP(encrypt_key_, other.encrypt_key_, sizeof(encrypt_key_))
+      && latest_row_store_type_ == other.latest_row_store_type_;
 }
 
 
@@ -131,7 +133,8 @@ bool ObSSTableBasicMeta::is_valid() const
            && filled_tx_scn_.is_valid()
            && data_index_tree_height_ >= 0
            && sstable_logic_seq_ >= 0
-           && row_store_type_ < ObRowStoreType::MAX_ROW_STORE);
+           && root_row_store_type_ < ObRowStoreType::MAX_ROW_STORE
+           && is_latest_row_store_type_valid());
   return ret;
 }
 
@@ -164,12 +167,13 @@ void ObSSTableBasicMeta::reset()
   table_mode_.reset();
   status_ = SSTABLE_NOT_INIT;
   contain_uncommitted_row_ = false;
-  row_store_type_ = ObRowStoreType::MAX_ROW_STORE;
+  root_row_store_type_ = ObRowStoreType::MAX_ROW_STORE;
   compressor_type_ = ObCompressorType::INVALID_COMPRESSOR;
   encrypt_id_ = 0;
   master_key_id_ = 0;
   sstable_logic_seq_ = 0;
   MEMSET(encrypt_key_, 0, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
+  latest_row_store_type_ = ObRowStoreType::MAX_ROW_STORE;
 }
 
 DEFINE_SERIALIZE(ObSSTableBasicMeta)
@@ -220,11 +224,12 @@ DEFINE_SERIALIZE(ObSSTableBasicMeta)
                   table_mode_,
                   status_,
                   contain_uncommitted_row_,
-                  row_store_type_,
+                  root_row_store_type_,
                   compressor_type_,
                   encrypt_id_,
                   master_key_id_,
-                  sstable_logic_seq_);
+                  sstable_logic_seq_,
+                  latest_row_store_type_);
       if (OB_FAIL(ret)) {
       } else if (OB_UNLIKELY(length_ != pos - start_pos)) {
         ret = OB_ERR_UNEXPECTED;
@@ -269,6 +274,8 @@ DEFINE_DESERIALIZE(ObSSTableBasicMeta)
 int ObSSTableBasicMeta::decode_for_compat(const char *buf, const int64_t data_len, int64_t &pos)
 {
   int ret = OB_SUCCESS;
+  // set latest_row_store_type to invalid on deserialize for compatibility
+  latest_row_store_type_ = ObRowStoreType::DUMMY_ROW_STORE;
   MEMCPY(encrypt_key_, buf + pos, sizeof(encrypt_key_));
   pos += sizeof(encrypt_key_);
   LST_DO_CODE(OB_UNIS_DECODE,
@@ -297,11 +304,12 @@ int ObSSTableBasicMeta::decode_for_compat(const char *buf, const int64_t data_le
               table_mode_,
               status_,
               contain_uncommitted_row_,
-              row_store_type_,
+              root_row_store_type_,
               compressor_type_,
               encrypt_id_,
               master_key_id_,
-              sstable_logic_seq_);
+              sstable_logic_seq_,
+              latest_row_store_type_);
   return ret;
 }
 
@@ -337,11 +345,12 @@ DEFINE_GET_SERIALIZE_SIZE(ObSSTableBasicMeta)
               table_mode_,
               status_,
               contain_uncommitted_row_,
-              row_store_type_,
+              root_row_store_type_,
               compressor_type_,
               encrypt_id_,
               master_key_id_,
-              sstable_logic_seq_);
+              sstable_logic_seq_,
+              latest_row_store_type_);
   return len;
 }
 
@@ -474,7 +483,8 @@ int ObSSTableMeta::init_base_meta(
     basic_meta_.filled_tx_scn_ = param.filled_tx_scn_;
     basic_meta_.data_index_tree_height_ = param.data_index_tree_height_;
     basic_meta_.sstable_logic_seq_ = param.sstable_logic_seq_;
-    basic_meta_.row_store_type_ = param.root_row_store_type_;
+    basic_meta_.root_row_store_type_ = param.root_row_store_type_;
+    basic_meta_.latest_row_store_type_ = param.latest_row_store_type_;
     basic_meta_.compressor_type_ = param.compressor_type_;
     basic_meta_.encrypt_id_ = param.encrypt_id_;
     basic_meta_.master_key_id_ = param.master_key_id_;

src/storage/blocksstable/ob_sstable_meta.h

@@ -68,6 +68,15 @@ public:
   int serialize(char *buf, const int64_t buf_len, int64_t &pos) const;
   int deserialize(const char *buf, const int64_t data_len, int64_t& pos);
   int64_t get_serialize_size() const;
+private:
+  OB_INLINE bool is_latest_row_store_type_valid() const
+  {
+    // Before version 4.0, latest_row_store_type was not serialized in sstable meta, but it is
+    // required and added in version 4.1. For compatibility, when deserialize from older version
+    // data, latest_row_store_type_ is filled with DUMMY_ROW_STORE
+    return latest_row_store_type_ < ObRowStoreType::MAX_ROW_STORE
+        || ObRowStoreType::DUMMY_ROW_STORE == latest_row_store_type_;
+  }
 public:
   TO_STRING_KV(K_(version), K_(length), K(row_count_), K(occupy_size_), K(original_size_),
       K(data_checksum_), K(index_type_), K(rowkey_column_count_), K(column_cnt_),
@@ -77,8 +86,9 @@ public:
       K(progressive_merge_step_), K(data_index_tree_height_), K(table_mode_),
       K(upper_trans_version_), K(max_merged_trans_version_), K_(recycle_version),
       K(ddl_scn_), K(filled_tx_scn_),
-      K(contain_uncommitted_row_), K(status_), K_(row_store_type), K_(compressor_type),
-      K_(encrypt_id), K_(master_key_id), K_(sstable_logic_seq), KPHEX_(encrypt_key, sizeof(encrypt_key_)));
+      K(contain_uncommitted_row_), K(status_), K_(root_row_store_type), K_(compressor_type),
+      K_(encrypt_id), K_(master_key_id), K_(sstable_logic_seq), KPHEX_(encrypt_key, sizeof(encrypt_key_)),
+      K_(latest_row_store_type));
 
 public:
   int32_t version_;
@@ -110,11 +120,12 @@ public:
   share::schema::ObTableMode table_mode_;
   uint8_t status_;
   bool contain_uncommitted_row_;
-  common::ObRowStoreType row_store_type_;
+  common::ObRowStoreType root_row_store_type_;
   common::ObCompressorType compressor_type_;
   int64_t encrypt_id_;
   int64_t master_key_id_;
   int16_t sstable_logic_seq_;
+  common::ObRowStoreType latest_row_store_type_;
   char encrypt_key_[share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH];
   //Add new variable need consider ObSSTableMetaChecker
 };

src/storage/blocksstable/ob_sstable_sec_meta_iterator.cpp

@@ -121,7 +121,7 @@ int ObSSTableSecMetaIterator::open(
       get_index_tree_type_map()[meta_type]))) {
     LOG_WARN("Fail to init index block tree cursor", K(ret), K(meta_type));
   } else if (OB_FAIL(init_micro_reader(
-      static_cast<ObRowStoreType>(sstable.get_meta().get_basic_meta().row_store_type_),
+      static_cast<ObRowStoreType>(sstable.get_meta().get_basic_meta().root_row_store_type_),
       allocator))) {
     LOG_WARN("Fail to get root row store type", K(ret), K(sstable));
   } else {

src/storage/compaction/ob_tablet_merge_ctx.cpp

@@ -203,6 +203,7 @@ int ObTabletMergeInfo::build_create_sstable_param(const ObTabletMergeCtx &ctx,
     param.index_type_ = ctx.get_schema()->get_index_type();
     param.rowkey_column_cnt_ = ctx.get_schema()->get_rowkey_column_num()
         + ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
+    param.latest_row_store_type_ = ctx.get_schema()->get_row_store_type();
     if (is_minor_merge_type(ctx.param_.merge_type_)) {
       param.recycle_version_ = ctx.sstable_version_range_.base_version_;
     } else {
@@ -957,7 +958,8 @@ int ObTabletMergeCtx::cal_major_merge_param(const ObGetMergeTablesResult &get_me
     const ObSSTableBasicMeta &base_meta = base_table->get_meta().get_basic_meta();
     if (base_table->get_meta().get_column_count() != get_schema()->get_column_count()
         || base_meta.compressor_type_ != get_schema()->get_compressor_type()
-        || base_meta.row_store_type_ != get_schema()->row_store_type_) {
+        || (ObRowStoreType::DUMMY_ROW_STORE != base_meta.latest_row_store_type_
+          && base_meta.latest_row_store_type_ != get_schema()->row_store_type_)) {
       is_schema_changed = true;
     }
 

src/storage/ddl/ob_ddl_merge_task.cpp

@@ -537,11 +537,11 @@ int ObTabletDDLUtil::prepare_index_data_desc(const share::ObLSID &ls_id,
     if (nullptr != first_ddl_sstable) {
       // use the param in first ddl sstable, which persist the param when ddl start
       const ObSSTableBasicMeta &basic_meta = first_ddl_sstable->get_meta().get_basic_meta();
-      data_desc.row_store_type_ = basic_meta.row_store_type_;
+      data_desc.row_store_type_ = basic_meta.root_row_store_type_;
       data_desc.compressor_type_ = basic_meta.compressor_type_;
       data_desc.master_key_id_ = basic_meta.master_key_id_;
       data_desc.encrypt_id_ = basic_meta.encrypt_id_;
-      data_desc.encoder_opt_.set_store_type(basic_meta.row_store_type_);
+      data_desc.encoder_opt_.set_store_type(basic_meta.root_row_store_type_);
       MEMCPY(data_desc.encrypt_key_, basic_meta.encrypt_key_, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
       data_desc.need_prebuild_bloomfilter_ = false;
     }
@@ -666,6 +666,7 @@ int ObTabletDDLUtil::create_ddl_sstable(ObSSTableIndexBuilder *sstable_index_bui
         param.index_type_ = storage_schema.get_index_type();
         param.rowkey_column_cnt_ = storage_schema.get_rowkey_column_num() + ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
         param.schema_version_ = storage_schema.get_schema_version();
+        param.latest_row_store_type_ = storage_schema.get_row_store_type();
         param.create_snapshot_version_ = ddl_param.snapshot_version_;
         param.ddl_scn_ = ddl_param.start_scn_;
         ObSSTableMergeRes::fill_addr_and_data(res.root_desc_,

src/storage/ddl/ob_tablet_ddl_kv.cpp

@@ -112,6 +112,7 @@ int ObDDLKV::init_sstable_param(const share::ObLSID &ls_id,
       sstable_param.index_type_ = storage_schema.get_index_type();
       sstable_param.rowkey_column_cnt_ = storage_schema.get_rowkey_column_num() + ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
       sstable_param.schema_version_ = storage_schema.get_schema_version();
+      sstable_param.latest_row_store_type_ = storage_schema.get_row_store_type();
       sstable_param.create_snapshot_version_ = table_key.get_snapshot_version();
       sstable_param.ddl_scn_ = ddl_start_scn;
       sstable_param.root_row_store_type_ = data_desc.row_store_type_;

src/storage/high_availability/ob_physical_copy_task.cpp

@@ -943,6 +943,7 @@ int ObPhysicalCopyFinishTask::build_create_sstable_param_(
     param.create_snapshot_version_ = sstable_param_->basic_meta_.create_snapshot_version_;
     param.progressive_merge_round_ = sstable_param_->basic_meta_.progressive_merge_round_;
     param.progressive_merge_step_ = sstable_param_->basic_meta_.progressive_merge_step_;
+    param.latest_row_store_type_ = sstable_param_->basic_meta_.latest_row_store_type_;
 
     ObSSTableMergeRes::fill_addr_and_data(res.root_desc_,
         param.root_block_addr_, param.root_block_data_);
@@ -1004,7 +1005,8 @@ int ObPhysicalCopyFinishTask::build_create_sstable_param_(
     param.progressive_merge_round_ = sstable_param_->basic_meta_.progressive_merge_round_;
     param.progressive_merge_step_ = sstable_param_->basic_meta_.progressive_merge_step_;
     param.is_ready_for_read_ = true;
-    param.root_row_store_type_ = sstable_param_->basic_meta_.row_store_type_;
+    param.root_row_store_type_ = sstable_param_->basic_meta_.root_row_store_type_;
+    param.latest_row_store_type_ = sstable_param_->basic_meta_.latest_row_store_type_;
     param.index_blocks_cnt_ = sstable_param_->basic_meta_.index_macro_block_count_;
     param.data_blocks_cnt_ = sstable_param_->basic_meta_.data_macro_block_count_;
     param.micro_block_cnt_ = sstable_param_->basic_meta_.data_micro_block_count_;

src/storage/high_availability/ob_storage_ha_tablet_builder.cpp

@@ -1036,6 +1036,7 @@ int ObStorageHATabletsBuilder::build_remote_logical_sstable_param_(
     param.root_block_addr_.set_none_addr();
     param.data_block_macro_meta_addr_.set_none_addr();
     param.root_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
+    param.latest_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
     param.data_index_tree_height_ = 0;
     param.index_blocks_cnt_ = 0;
     param.data_blocks_cnt_ = 0;

src/storage/ls/ob_ls_tablet_service.cpp

@@ -2184,7 +2184,8 @@ int ObLSTabletService::build_create_sstable_param_for_migration(
     param.table_mode_                    = mig_param.basic_meta_.table_mode_;
     param.index_type_                    = static_cast<share::schema::ObIndexType>(mig_param.basic_meta_.index_type_);
     param.rowkey_column_cnt_             = mig_param.basic_meta_.rowkey_column_count_;
-    param.root_row_store_type_           = mig_param.basic_meta_.row_store_type_;
+    param.root_row_store_type_           = mig_param.basic_meta_.root_row_store_type_;
+    param.latest_row_store_type_         = mig_param.basic_meta_.latest_row_store_type_;
     param.index_blocks_cnt_              = mig_param.basic_meta_.index_macro_block_count_;
     param.data_blocks_cnt_               = mig_param.basic_meta_.data_macro_block_count_;
     param.micro_block_cnt_               = mig_param.basic_meta_.data_micro_block_count_;

src/storage/tablet/ob_tablet_create_delete_helper.cpp

@@ -2323,6 +2323,7 @@ int ObTabletCreateDeleteHelper::build_create_sstable_param(
     param.root_block_addr_.set_none_addr();
     param.data_block_macro_meta_addr_.set_none_addr();
     param.root_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
+    param.latest_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
     param.data_index_tree_height_ = 0;
     param.index_blocks_cnt_ = 0;
     param.data_blocks_cnt_ = 0;

src/storage/tablet/ob_tablet_create_sstable_param.cpp

@@ -40,6 +40,7 @@ ObTabletCreateSSTableParam::ObTabletCreateSSTableParam()
     root_block_addr_(),
     root_block_data_(),
     root_row_store_type_(common::ObRowStoreType::MAX_ROW_STORE),
+    latest_row_store_type_(common::ObRowStoreType::MAX_ROW_STORE),
     data_index_tree_height_(0),
     data_block_macro_meta_addr_(),
     data_block_macro_meta_(),
@@ -84,6 +85,7 @@ bool ObTabletCreateSSTableParam::is_valid() const
                && create_snapshot_version_ >= 0
                && index_type_ < share::schema::ObIndexType::INDEX_TYPE_MAX
                && root_row_store_type_ < ObRowStoreType::MAX_ROW_STORE
+               && latest_row_store_type_ < ObRowStoreType::MAX_ROW_STORE
                && data_index_tree_height_ >= 0
                && index_blocks_cnt_ >= 0
                && data_blocks_cnt_ >= 0
@@ -99,7 +101,7 @@ bool ObTabletCreateSSTableParam::is_valid() const
                && recycle_version_ >= 0)) {
     ret = false;
     LOG_WARN("invalid basic params", K(schema_version_), K(create_snapshot_version_), K(index_type_),
-             K(root_row_store_type_), K(data_index_tree_height_), K(index_blocks_cnt_),
+             K(root_row_store_type_), K_(latest_row_store_type), K(data_index_tree_height_), K(index_blocks_cnt_),
              K(data_blocks_cnt_), K(micro_block_cnt_), K(use_old_macro_block_count_),
              K(row_count_), K(rowkey_column_cnt_), K(column_cnt_), K(occupy_size_),
              K(original_size_), K(ddl_scn_), K(filled_tx_scn_), K_(recycle_version));

src/storage/tablet/ob_tablet_create_sstable_param.h

@@ -49,6 +49,7 @@ public:
       K_(root_block_addr),
       K_(root_block_data),
       K_(root_row_store_type),
+      K_(latest_row_store_type),
       K_(data_index_tree_height),
       K_(data_block_macro_meta_addr),
       K_(data_block_macro_meta),
@@ -89,6 +90,7 @@ public:
   ObMetaDiskAddr root_block_addr_;
   blocksstable::ObMicroBlockData root_block_data_;
   common::ObRowStoreType root_row_store_type_;
+  common::ObRowStoreType latest_row_store_type_;
   int16_t data_index_tree_height_;
   ObMetaDiskAddr data_block_macro_meta_addr_;
   blocksstable::ObMicroBlockData data_block_macro_meta_;

unittest/storage/blocksstable/ob_multi_version_sstable_test.h

@@ -528,6 +528,7 @@ void ObMultiVersionSSTableTest::prepare_data_end(
   param.progressive_merge_step_ = 0;
   param.table_mode_ = table_schema_.get_table_mode_struct();
   param.index_type_ = table_schema_.get_index_type();
+  param.latest_row_store_type_ = table_schema_.get_row_store_type();
   param.rowkey_column_cnt_ = table_schema_.get_rowkey_column_num()
       + ObMultiVersionRowkeyHelpper::get_extra_rowkey_col_cnt();
 

unittest/storage/blocksstable/test_sstable_meta.cpp

@@ -246,6 +246,7 @@ void TestSSTableMeta::prepare_create_sstable_param()
   param_.root_block_addr_.set_none_addr();
   param_.data_block_macro_meta_addr_.set_none_addr();
   param_.root_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
+  param_.latest_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
   param_.data_index_tree_height_ = 0;
   param_.index_blocks_cnt_ = 0;
   param_.data_blocks_cnt_ = 0;
@@ -547,6 +548,7 @@ TEST_F(TestMigrationSSTableParam, test_migrate_sstable)
   src_sstable_param.root_block_addr_.set_none_addr();
   src_sstable_param.data_block_macro_meta_addr_.set_none_addr();
   src_sstable_param.root_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
+  src_sstable_param.latest_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
   src_sstable_param.data_index_tree_height_ = 0;
   src_sstable_param.index_blocks_cnt_ = 0;
   src_sstable_param.data_blocks_cnt_ = 0;

unittest/storage/test_sstable_log_ts_range_cut.cpp

@@ -46,7 +46,8 @@ public:
     sstable.key_.tablet_id_ = 1;
     sstable.key_.scn_range_.start_scn_.convert_for_gts(start_log_ts);
     sstable.key_.scn_range_.end_scn_.convert_for_gts(end_log_ts);
-    sstable.meta_.basic_meta_.row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
+    sstable.meta_.basic_meta_.root_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
+    sstable.meta_.basic_meta_.latest_row_store_type_ = ObRowStoreType::FLAT_ROW_STORE;
     sstable.valid_for_reading_ = true;
     sstable.meta_.basic_meta_.status_ = SSTABLE_WRITE_BUILDING;
     sstable.meta_.data_root_info_.addr_.set_none_addr();