diff --git a/mittest/mtlenv/storage/test_ls_migration_param.cpp b/mittest/mtlenv/storage/test_ls_migration_param.cpp
index be02dd492..8536dfec6 100644
--- a/mittest/mtlenv/storage/test_ls_migration_param.cpp
+++ b/mittest/mtlenv/storage/test_ls_migration_param.cpp
@@ -241,15 +241,14 @@ TEST_F(TestLSMigrationParam, test_migrate_tablet_param)
   ObCreateTabletSchema create_tablet_schema;
 
   ret = create_tablet_schema.init(schema_allocator, table_schema, lib::Worker::CompatMode::MYSQL,
-        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-        0/*tenant_data_version, default val*/, true/*need_create_empty_major*/);
+        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3);
   ASSERT_EQ(OB_SUCCESS, ret);
 
   ObTabletID empty_tablet_id;
   SCN scn;
   scn.convert_from_ts(ObTimeUtility::current_time());
   ret = src_handle.get_obj()->init_for_first_time_creation(allocator_, src_key.ls_id_, src_key.tablet_id_, src_key.tablet_id_,
-      scn, 2022, create_tablet_schema, ls_handle.get_ls()->get_freezer());
+      scn, 2022, create_tablet_schema, true/*need_create_empty_major_sstable*/, ls_handle.get_ls()->get_freezer());
   ASSERT_EQ(common::OB_SUCCESS, ret);
 
   ObMigrationTabletParam tablet_param;
@@ -307,15 +306,14 @@ TEST_F(TestLSMigrationParam, test_migration_param_compat)
   ObCreateTabletSchema create_tablet_schema;
 
   ret = create_tablet_schema.init(schema_allocator, table_schema, lib::Worker::CompatMode::MYSQL,
-        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-        0/*tenant_data_version, default val*/, true/*need_create_empty_major*/);
+        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3);
   ASSERT_EQ(OB_SUCCESS, ret);
 
   ObTabletID empty_tablet_id;
   SCN scn;
   scn.convert_from_ts(ObTimeUtility::current_time());
   ret = src_handle.get_obj()->init_for_first_time_creation(allocator_, src_key.ls_id_, src_key.tablet_id_, src_key.tablet_id_,
-      scn, 2022, create_tablet_schema, ls_handle.get_ls()->get_freezer());
+      scn, 2022, create_tablet_schema, true/*need_create_empty_major_sstable*/, ls_handle.get_ls()->get_freezer());
   ASSERT_EQ(common::OB_SUCCESS, ret);
 
   ObMigrationTabletParam tablet_param;
diff --git a/mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp b/mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp
index 7c348b50a..a0ea06b0b 100644
--- a/mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp
+++ b/mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp
@@ -158,15 +158,14 @@ void TestLSTabletInfoWR::fill_tablet_meta()
   ObCreateTabletSchema create_tablet_schema;
 
   ret = create_tablet_schema.init(schema_allocator, table_schema, lib::Worker::CompatMode::MYSQL,
-        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-        0/*tenant_data_version, default val*/, true/*need_create_empty_major*/);
+        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3);
   ASSERT_EQ(OB_SUCCESS, ret);
 
   ObTabletID empty_tablet_id;
   SCN scn;
   scn.convert_from_ts(ObTimeUtility::current_time());
   ret = src_handle.get_obj()->init_for_first_time_creation(arena_allocator_, src_key.ls_id_, src_key.tablet_id_, src_key.tablet_id_,
-      scn, 2022, create_tablet_schema, ls_handle.get_ls()->get_freezer());
+      scn, 2022, create_tablet_schema, true/*need_create_empty_major_sstable*/, ls_handle.get_ls()->get_freezer());
   ASSERT_EQ(common::OB_SUCCESS, ret);
 
   ObMigrationTabletParam tablet_param;
diff --git a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
index 311e82166..1b08b6a82 100644
--- a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
+++ b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
@@ -226,8 +226,7 @@ void TestTenantMetaMemMgr::prepare_data_schema(
   LOG_INFO("dump data table schema", LITERAL_K(TEST_ROWKEY_COLUMN_CNT), K(table_schema));
 
   ret = create_tablet_schema.init(allocator, table_schema, lib::Worker::CompatMode::MYSQL,
-        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-        0/*tenant_data_version, default val*/, true/*need_create_empty_major*/);
+        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3);
   ASSERT_EQ(OB_SUCCESS, ret);
 }
 
@@ -711,9 +710,8 @@ TEST_F(TestTenantMetaMemMgr, test_wash_tablet)
   create_scn.convert_from_ts(ObTimeUtility::fast_current_time());
 
   ObTabletID empty_tablet_id;
-  create_tablet_schema.set_need_create_empty_major(true);
   ret = tablet->init_for_first_time_creation(allocator_, ls_id_, tablet_id, tablet_id,
-      create_scn, create_scn.get_val_for_tx(), create_tablet_schema, &freezer);
+      create_scn, create_scn.get_val_for_tx(), create_tablet_schema, true/*need_create_empty_major_sstable*/, &freezer);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, tablet->get_ref());
   ObTabletPersister persister;
@@ -810,9 +808,9 @@ TEST_F(TestTenantMetaMemMgr, test_wash_inner_tablet)
 
   ObTabletID empty_tablet_id;
   bool make_empty_co_sstable = true;
-  create_tablet_schema.set_need_create_empty_major(make_empty_co_sstable);
   ret = tablet->init_for_first_time_creation(allocator_, ls_id_, tablet_id, tablet_id,
-      create_scn, create_scn.get_val_for_tx(), create_tablet_schema, &freezer);
+      create_scn, create_scn.get_val_for_tx(), create_tablet_schema,
+      make_empty_co_sstable/*need_create_empty_major_sstable*/, &freezer);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, tablet->get_ref());
 
@@ -920,9 +918,9 @@ TEST_F(TestTenantMetaMemMgr, test_wash_no_sstable_tablet)
 
   ObTabletID empty_tablet_id;
   bool make_empty_co_sstable = false;
-  create_tablet_schema.set_need_create_empty_major(make_empty_co_sstable);
   ret = tablet->init_for_first_time_creation(allocator_, ls_id_, tablet_id, tablet_id,
-      create_scn, create_scn.get_val_for_tx(), create_tablet_schema, &freezer);
+      create_scn, create_scn.get_val_for_tx(), create_tablet_schema,
+      make_empty_co_sstable/*need_create_empty_major_sstable*/, &freezer);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, tablet->get_ref());
 
@@ -1017,9 +1015,9 @@ TEST_F(TestTenantMetaMemMgr, test_get_tablet_with_allocator)
 
   ObTabletID empty_tablet_id;
   bool make_empty_co_sstable = true;
-  create_tablet_schema.set_need_create_empty_major(make_empty_co_sstable);
   ret = tablet->init_for_first_time_creation(allocator_, ls_id_, tablet_id, tablet_id,
-      create_scn, create_scn.get_val_for_tx(), create_tablet_schema, &freezer);
+      create_scn, create_scn.get_val_for_tx(), create_tablet_schema,
+      make_empty_co_sstable/*need_create_empty_major_sstable*/, &freezer);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, tablet->get_ref());
 
@@ -1145,9 +1143,9 @@ TEST_F(TestTenantMetaMemMgr, test_wash_mem_tablet)
 
   ObTabletID empty_tablet_id;
   bool make_empty_co_sstable = false;
-  create_tablet_schema.set_need_create_empty_major(make_empty_co_sstable);
   ret = tablet->init_for_first_time_creation(allocator_, ls_id_, tablet_id, tablet_id,
-      create_scn, create_scn.get_val_for_tx(), create_tablet_schema, &freezer);
+      create_scn, create_scn.get_val_for_tx(), create_tablet_schema,
+      make_empty_co_sstable/*need_create_empty_major_sstable*/, &freezer);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, tablet->get_ref());
 
diff --git a/src/rootserver/ob_tablet_creator.cpp b/src/rootserver/ob_tablet_creator.cpp
index 41767573f..6888e6815 100644
--- a/src/rootserver/ob_tablet_creator.cpp
+++ b/src/rootserver/ob_tablet_creator.cpp
@@ -205,16 +205,20 @@ int ObBatchCreateTabletHelper::add_table_schema_(
     index = batch_arg_.create_tablet_schemas_.count();
     ObCreateTabletSchema *create_tablet_schema = NULL;
     void *create_tablet_schema_ptr = batch_arg_.allocator_.alloc(sizeof(ObCreateTabletSchema));
+    obrpc::ObCreateTabletExtraInfo create_tablet_extr_info;
     if (OB_ISNULL(create_tablet_schema_ptr)) {
       ret = OB_ALLOCATE_MEMORY_FAILED;
       LOG_WARN("failed to allocate storage schema", KR(ret), K(table_schema));
     } else if (FALSE_IT(create_tablet_schema = new (create_tablet_schema_ptr)ObCreateTabletSchema())) {
     } else if (OB_FAIL(create_tablet_schema->init(batch_arg_.allocator_, table_schema, compat_mode,
-         false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-         tenant_data_version, need_create_empty_major))) {
+         false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3))) {
       LOG_WARN("failed to init storage schema", KR(ret), K(table_schema));
     } else if (OB_FAIL(batch_arg_.create_tablet_schemas_.push_back(create_tablet_schema))) {
       LOG_WARN("failed to push back table schema", KR(ret), K(table_schema));
+    } else if (OB_FAIL(create_tablet_extr_info.init(tenant_data_version, need_create_empty_major))) {
+      LOG_WARN("init create table extra info failed", K(ret), K(tenant_data_version), K(need_create_empty_major), K(table_schema));
+    } else if (OB_FAIL(batch_arg_.tablet_extra_infos_.push_back(create_tablet_extr_info))) {
+      LOG_WARN("failed to push back tablet extra infos", K(ret), K(create_tablet_extr_info));
     }
   }
   return ret;
diff --git a/src/share/ob_rpc_struct.cpp b/src/share/ob_rpc_struct.cpp
index b59a23d3b..9395b1abf 100755
--- a/src/share/ob_rpc_struct.cpp
+++ b/src/share/ob_rpc_struct.cpp
@@ -8731,6 +8731,37 @@ DEF_TO_STRING(ObCreateTabletInfo)
 
 OB_SERIALIZE_MEMBER(ObCreateTabletInfo, tablet_ids_, data_tablet_id_, table_schema_index_, compat_mode_, is_create_bind_hidden_tablets_);
 
+int ObCreateTabletExtraInfo::init(
+    const uint64_t tenant_data_version,
+    const bool need_create_empty_major)
+{
+  int ret = OB_SUCCESS;
+  if (OB_UNLIKELY(tenant_data_version <= 0)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid arg", K(ret), K(tenant_data_version), K(need_create_empty_major));
+  } else {
+    tenant_data_version_ = tenant_data_version;
+    need_create_empty_major_ = need_create_empty_major;
+  }
+  return ret;
+}
+
+void ObCreateTabletExtraInfo::reset()
+{
+  need_create_empty_major_ = true;
+  tenant_data_version_ = 0;
+}
+
+int ObCreateTabletExtraInfo::assign(const ObCreateTabletExtraInfo &other)
+{
+  int ret = OB_SUCCESS;
+  tenant_data_version_ = other.tenant_data_version_;
+  need_create_empty_major_ = other.need_create_empty_major_;
+  return ret;
+}
+
+OB_SERIALIZE_MEMBER(ObCreateTabletExtraInfo, tenant_data_version_, need_create_empty_major_);
+
 bool ObBatchCreateTabletArg::is_inited() const
 {
   return id_.is_valid() && major_frozen_scn_.is_valid();
@@ -8773,6 +8804,7 @@ void ObBatchCreateTabletArg::reset()
   }
   create_tablet_schemas_.reset();
   allocator_.reset();
+  tablet_extra_infos_.reset();
 }
 
 int ObBatchCreateTabletArg::assign(const ObBatchCreateTabletArg &arg)
@@ -8786,6 +8818,8 @@ int ObBatchCreateTabletArg::assign(const ObBatchCreateTabletArg &arg)
     LOG_WARN("failed to assign tablets", KR(ret), K(arg));
   } else if (OB_FAIL(table_schemas_.assign(arg.table_schemas_))) {
     LOG_WARN("failed to assign table schema", KR(ret), K(arg));
+  } else if (OB_FAIL(tablet_extra_infos_.assign(arg.tablet_extra_infos_))) {
+    LOG_WARN("failed to assign tablet extra infos", K(ret), K(arg));
   } else if (OB_FAIL(create_tablet_schemas_.reserve(create_tablet_schemas.count()))) {
     STORAGE_LOG(WARN, "Fail to reserve schema array", K(ret), K(create_tablet_schemas.count()));
   } else {
@@ -9010,7 +9044,7 @@ int ObBatchCreateTabletArg::is_old_mds(const char *buf,
 DEF_TO_STRING(ObBatchCreateTabletArg)
 {
   int64_t pos = 0;
-  J_KV(K_(id), K_(major_frozen_scn), K_(need_check_tablet_cnt), K_(is_old_mds), K_(tablets));
+  J_KV(K_(id), K_(major_frozen_scn), K_(need_check_tablet_cnt), K_(is_old_mds), K_(tablets), K_(tablet_extra_infos));
   return pos;
 }
 
@@ -9021,6 +9055,8 @@ OB_DEF_SERIALIZE(ObBatchCreateTabletArg)
   if (OB_FAIL(ret)) {
   } else if (OB_FAIL(serialize_for_create_tablet_schemas(buf, buf_len, pos))) {
     LOG_WARN("failed to serialize_for_create_tablet_schemas", KR(ret), KPC(this));
+  } else {
+    OB_UNIS_ENCODE_ARRAY(tablet_extra_infos_, tablet_extra_infos_.count());
   }
   return ret;
 }
@@ -9030,6 +9066,7 @@ OB_DEF_SERIALIZE_SIZE(ObBatchCreateTabletArg)
   int len = 0;
   LST_DO_CODE(OB_UNIS_ADD_LEN, id_, major_frozen_scn_, tablets_, table_schemas_, need_check_tablet_cnt_, is_old_mds_);
   len += get_serialize_size_for_create_tablet_schemas();
+  OB_UNIS_ADD_LEN_ARRAY(tablet_extra_infos_, tablet_extra_infos_.count());
   return len;
 }
 
@@ -9046,6 +9083,14 @@ OB_DEF_DESERIALIZE(ObBatchCreateTabletArg)
       } else if (pos == data_len) {
       } else if (OB_FAIL(deserialize_create_tablet_schemas(buf, data_len, pos))) {
         LOG_WARN("failed to deserialize_for_create_tablet_schemas", KR(ret));
+      } else {
+        int64_t tablet_extra_infos_count = 0;
+        OB_UNIS_DECODE(tablet_extra_infos_count);
+        if (tablet_extra_infos_count > 0 && OB_FAIL(tablet_extra_infos_.prepare_allocate(tablet_extra_infos_count))) {
+          LOG_WARN("prepare allocate failed", K(ret), K(tablet_extra_infos_count));
+        } else {
+          OB_UNIS_DECODE_ARRAY(tablet_extra_infos_, tablet_extra_infos_count);
+        }
       }
     }
   }
diff --git a/src/share/ob_rpc_struct.h b/src/share/ob_rpc_struct.h
index 37d346bc0..a820e5f04 100755
--- a/src/share/ob_rpc_struct.h
+++ b/src/share/ob_rpc_struct.h
@@ -3819,6 +3819,21 @@ private:
   DISALLOW_COPY_AND_ASSIGN(ObCreateTabletInfo);
 };
 
+struct ObCreateTabletExtraInfo final
+{
+  OB_UNIS_VERSION(1);
+public:
+  ObCreateTabletExtraInfo() { reset(); }
+  ~ObCreateTabletExtraInfo() { reset(); }
+  int init(const uint64_t tenant_data_version, const bool need_create_empty_major);
+  void reset();
+  int assign(const ObCreateTabletExtraInfo &other);
+public:
+  uint64_t tenant_data_version_;
+  bool need_create_empty_major_;
+  TO_STRING_KV(K_(tenant_data_version), K_(need_create_empty_major));
+};
+
 struct ObBatchCreateTabletArg
 {
   OB_UNIS_VERSION(1);
@@ -3858,6 +3873,7 @@ public:
   bool is_old_mds_;
   common::ObSArray<storage::ObCreateTabletSchema*> create_tablet_schemas_;
   ObArenaAllocator allocator_;
+  common::ObSArray<ObCreateTabletExtraInfo> tablet_extra_infos_;
 };
 
 struct ObBatchRemoveTabletArg
diff --git a/src/storage/ls/ob_ls_tablet_service.cpp b/src/storage/ls/ob_ls_tablet_service.cpp
index 6882352f5..d0e0dd428 100644
--- a/src/storage/ls/ob_ls_tablet_service.cpp
+++ b/src/storage/ls/ob_ls_tablet_service.cpp
@@ -2011,6 +2011,7 @@ int ObLSTabletService::create_tablet(
     const int64_t snapshot_version,
     const ObCreateTabletSchema &create_tablet_schema,
     const lib::Worker::CompatMode &compat_mode,
+    const bool need_create_empty_major_sstable,
     ObTabletHandle &tablet_handle)
 {
   int ret = OB_SUCCESS;
@@ -2034,7 +2035,7 @@ int ObLSTabletService::create_tablet(
       ret = OB_ERR_UNEXPECTED;
       LOG_ERROR("new tablet is null", K(ret), KP(tablet), KP(allocator), K(tablet_handle));
     } else if (OB_FAIL(tablet->init_for_first_time_creation(*allocator, ls_id, tablet_id, data_tablet_id,
-        create_scn, snapshot_version, create_tablet_schema, freezer))) {
+        create_scn, snapshot_version, create_tablet_schema, need_create_empty_major_sstable, freezer))) {
       LOG_WARN("failed to init tablet", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id),
           K(create_scn), K(snapshot_version), K(create_tablet_schema));
     } else if (OB_FAIL(tablet->get_updating_tablet_pointer_param(param))) {
@@ -2087,7 +2088,7 @@ int ObLSTabletService::create_inner_tablet(
     LOG_ERROR("new tablet is null", K(ret), KPC(tmp_tablet), K(tmp_tablet_hdl));
   } else if (FALSE_IT(time_guard.click("CreateTablet"))) {
   } else if (OB_FAIL(tmp_tablet->init_for_first_time_creation(allocator, ls_id, tablet_id, data_tablet_id,
-      create_scn, snapshot_version, create_tablet_schema, freezer))) {
+      create_scn, snapshot_version, create_tablet_schema, true/*need_create_empty_major_sstable*/, freezer))) {
     LOG_WARN("failed to init tablet", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id),
         K(create_scn), K(snapshot_version), K(create_tablet_schema));
   } else if (FALSE_IT(time_guard.click("InitTablet"))) {
diff --git a/src/storage/ls/ob_ls_tablet_service.h b/src/storage/ls/ob_ls_tablet_service.h
index dd7dbd3b6..0892caebf 100644
--- a/src/storage/ls/ob_ls_tablet_service.h
+++ b/src/storage/ls/ob_ls_tablet_service.h
@@ -188,6 +188,7 @@ public:
       const int64_t snapshot_version,
       const ObCreateTabletSchema &create_tablet_schema,
       const lib::Worker::CompatMode &compat_mode,
+      const bool need_create_empty_major_sstable,
       ObTabletHandle &tablet_handle);
   int create_transfer_in_tablet(
       const share::ObLSID &ls_id,
diff --git a/src/storage/ob_storage_schema.cpp b/src/storage/ob_storage_schema.cpp
index 4f55fc6fa..28bf33512 100644
--- a/src/storage/ob_storage_schema.cpp
+++ b/src/storage/ob_storage_schema.cpp
@@ -1620,9 +1620,7 @@ int ObCreateTabletSchema::serialize(char *buf, const int64_t buf_len, int64_t &p
   LST_DO_CODE(OB_UNIS_ENCODE,
               table_id_,
               index_status_,
-              truncate_version_,
-              tenant_data_version_,
-              need_create_empty_major_);
+              truncate_version_);
   return ret;
 }
 
@@ -1635,9 +1633,7 @@ int ObCreateTabletSchema::deserialize(common::ObIAllocator &allocator, const cha
     LST_DO_CODE(OB_UNIS_DECODE,
                 table_id_,
                 index_status_,
-                truncate_version_,
-                tenant_data_version_,
-                need_create_empty_major_);
+                truncate_version_);
   }
   return ret;
 }
@@ -1648,9 +1644,7 @@ int64_t ObCreateTabletSchema::get_serialize_size() const
   LST_DO_CODE(OB_UNIS_ADD_LEN,
               table_id_,
               index_status_,
-              truncate_version_,
-              tenant_data_version_,
-              need_create_empty_major_);
+              truncate_version_);
   return len;
 }
 
@@ -1659,9 +1653,7 @@ int ObCreateTabletSchema::init(
     const share::schema::ObTableSchema &input_schema,
     const lib::Worker::CompatMode compat_mode,
     const bool skip_column_info,
-    const int64_t compat_version,
-    const uint64_t tenant_data_version,
-    const bool need_create_empty_major)
+    const int64_t compat_version)
 {
   int ret = OB_SUCCESS;
   if (OB_FAIL(ObStorageSchema::init(allocator, input_schema, compat_mode, skip_column_info, compat_version))) {
@@ -1670,8 +1662,6 @@ int ObCreateTabletSchema::init(
     table_id_ = input_schema.get_table_id();
     index_status_ = input_schema.get_index_status();
     truncate_version_ = input_schema.get_truncate_version();
-    tenant_data_version_ = tenant_data_version;
-    need_create_empty_major_ = need_create_empty_major;
   }
   return ret;
 }
@@ -1687,8 +1677,6 @@ int ObCreateTabletSchema::init(
     table_id_ = old_schema.get_table_id();
     index_status_ = old_schema.get_index_status();
     truncate_version_ = old_schema.get_truncate_version();
-    tenant_data_version_ = old_schema.get_tenant_data_version();
-    need_create_empty_major_ = old_schema.get_need_create_empty_major();
   }
   return ret;
 }
diff --git a/src/storage/ob_storage_schema.h b/src/storage/ob_storage_schema.h
index 7499e8b98..d8b5ba04d 100644
--- a/src/storage/ob_storage_schema.h
+++ b/src/storage/ob_storage_schema.h
@@ -365,9 +365,7 @@ public:
     : ObStorageSchema(),
       table_id_(common::OB_INVALID_ID),
       index_status_(share::schema::ObIndexStatus::INDEX_STATUS_UNAVAILABLE),
-      truncate_version_(OB_INVALID_VERSION),
-      tenant_data_version_(0),
-      need_create_empty_major_(true)
+      truncate_version_(OB_INVALID_VERSION)
       {}
 
   int serialize(char *buf, const int64_t buf_len, int64_t &pos) const;
@@ -380,12 +378,6 @@ public:
   { return table_id_; }
   int64_t get_truncate_version() const
   { return truncate_version_; }
-  uint64_t get_tenant_data_version() const
-  { return tenant_data_version_; }
-  bool get_need_create_empty_major () const
-  { return need_create_empty_major_; }
-  void set_need_create_empty_major(const bool need_create_empty_major)
-  { need_create_empty_major_ = need_create_empty_major; }
   bool is_valid() const
   {
     return ObStorageSchema::is_valid() && common::OB_INVALID_ID != table_id_;
@@ -394,13 +386,10 @@ public:
       const share::schema::ObTableSchema &input_schema,
       const lib::Worker::CompatMode compat_mode,
       const bool skip_column_info,
-      const int64_t compat_version,
-      const uint64_t tenant_data_version,
-      const bool need_create_empty_major);
+      const int64_t compat_version);
   int init(common::ObIAllocator &allocator,
       const ObCreateTabletSchema &old_schema);
-  INHERIT_TO_STRING_KV("ObStorageSchema", ObStorageSchema, K_(table_id), K_(index_status), K_(truncate_version),
-      K_(tenant_data_version), K_(need_create_empty_major));
+  INHERIT_TO_STRING_KV("ObStorageSchema", ObStorageSchema, K_(table_id), K_(index_status), K_(truncate_version));
 private:
   // for cdc
   uint64_t table_id_;
@@ -408,8 +397,6 @@ private:
   share::schema::ObIndexStatus index_status_;
   // for tablet throttling
   int64_t truncate_version_;
-  uint64_t tenant_data_version_;
-  bool need_create_empty_major_;
 };
 
 template <typename T>
diff --git a/src/storage/tablelock/ob_lock_table.cpp b/src/storage/tablelock/ob_lock_table.cpp
index a14f215b4..c344f875a 100644
--- a/src/storage/tablelock/ob_lock_table.cpp
+++ b/src/storage/tablelock/ob_lock_table.cpp
@@ -333,8 +333,7 @@ int ObLockTable::create_tablet(const lib::Worker::CompatMode compat_mode, const
   } else if (OB_FAIL(get_table_schema_(tenant_id, table_schema))) {
     LOG_WARN("get lock table schema failed", K(ret));
   } else if (OB_FAIL(create_tablet_schema.init(arena_allocator, table_schema, compat_mode,
-        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-        tenant_data_version, true/*need_create_empty_major*/))) {
+        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3))) {
     LOG_WARN("failed to init storage schema", KR(ret), K(table_schema));
   } else if (OB_FAIL(parent_->create_ls_inner_tablet(ls_id,
                                                      LS_LOCK_TABLET,
diff --git a/src/storage/tablet/ob_tablet.cpp b/src/storage/tablet/ob_tablet.cpp
index 821091b3a..02b439bac 100644
--- a/src/storage/tablet/ob_tablet.cpp
+++ b/src/storage/tablet/ob_tablet.cpp
@@ -288,11 +288,11 @@ int ObTablet::init_for_first_time_creation(
     const share::SCN &create_scn,
     const int64_t snapshot_version,
     const ObCreateTabletSchema &storage_schema,
+    const bool need_create_empty_major_sstable,
     ObFreezer *freezer)
 {
   int ret = OB_SUCCESS;
   const lib::Worker::CompatMode compat_mode = storage_schema.get_compat_mode();
-  const bool need_create_empty_major_sstable = storage_schema.get_need_create_empty_major();
   const int64_t default_max_sync_medium_scn = 0;
   ObTableHandleV2 table_handle;
   bool is_table_row_store = false;
diff --git a/src/storage/tablet/ob_tablet.h b/src/storage/tablet/ob_tablet.h
index 77a0cfdce..ae9c7a459 100644
--- a/src/storage/tablet/ob_tablet.h
+++ b/src/storage/tablet/ob_tablet.h
@@ -192,6 +192,7 @@ public:
       const share::SCN &create_scn,
       const int64_t snapshot_version,
       const ObCreateTabletSchema &storage_schema,
+      const bool need_create_empty_major_sstable,
       ObFreezer *freezer);
   // dump/merge build new multi version tablet
   int init_for_merge(
diff --git a/src/storage/tablet/ob_tablet_create_mds_helper.cpp b/src/storage/tablet/ob_tablet_create_mds_helper.cpp
index 1fb73b09e..b3d896385 100644
--- a/src/storage/tablet/ob_tablet_create_mds_helper.cpp
+++ b/src/storage/tablet/ob_tablet_create_mds_helper.cpp
@@ -570,24 +570,7 @@ int ObTabletCreateMdsHelper::convert_schemas(
     obrpc::ObBatchCreateTabletArg &arg)
 {
   int ret = OB_SUCCESS;
-  // For tenant data version belongs to (, DATA_VERSION_4_3_0_0),
-  // use the schema status to decide whether to create major sstable or not when creating tablet.
-  // For tenant data version belongs to [DATA_VERSION_4_3_0_0, ),
-  // use the original `need_create_empty_major_` in ObCreateTabletSchema to decide it.
   if (arg.create_tablet_schemas_.count() > 0) {
-    const uint64_t tenant_data_version = arg.create_tablet_schemas_[0]->get_tenant_data_version();
-    for (int64_t i = 0; OB_SUCC(ret) && tenant_data_version < DATA_VERSION_4_3_0_0
-        && i < arg.table_schemas_.count(); ++i) {
-      ObCreateTabletSchema *create_tablet_schema = nullptr;
-      if (OB_ISNULL(create_tablet_schema = arg.create_tablet_schemas_[i])) {
-        ret = OB_ERR_UNEXPECTED;
-        LOG_WARN("unexpected error", K(ret), K(i), K(arg));
-      } else {
-        const bool need_create_empty_major =
-          !(create_tablet_schema->is_user_hidden_table() || (create_tablet_schema->is_index_table() && !create_tablet_schema->can_read_index()));
-        create_tablet_schema->set_need_create_empty_major(need_create_empty_major);
-      }
-    }
   }
   // compatibility with DATA_VERSION_4_1_0_0
   else if (arg.tablets_.count() <= 0) {
@@ -599,24 +582,38 @@ int ObTabletCreateMdsHelper::convert_schemas(
       ObTableSchema &table_schema = arg.table_schemas_[i];
       ObCreateTabletSchema *create_tablet_schema = NULL;
       void *create_tablet_schema_ptr = arg.allocator_.alloc(sizeof(ObCreateTabletSchema));
-      const bool need_create_empty_major =
-        !(table_schema.is_user_hidden_table() || (table_schema.is_index_table() && !table_schema.can_read_index()));
+      obrpc::ObCreateTabletExtraInfo create_tablet_extra_info; // placeholder.
       if (OB_ISNULL(create_tablet_schema_ptr)) {
         ret = OB_ALLOCATE_MEMORY_FAILED;
         LOG_WARN("failed to allocate storage schema", KR(ret), K(table_schema));
       } else if (FALSE_IT(create_tablet_schema = new (create_tablet_schema_ptr)ObCreateTabletSchema())) {
       } else if (OB_FAIL(create_tablet_schema->init(arg.allocator_, table_schema, compat_mode,
-           false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-           0/*tenant_data_version, default val*/, need_create_empty_major))) {
+           false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3))) {
         LOG_WARN("failed to init storage schema", KR(ret), K(table_schema));
       } else if (OB_FAIL(arg.create_tablet_schemas_.push_back(create_tablet_schema))) {
         LOG_WARN("failed to push back table schema", KR(ret), K(create_tablet_schema));
+      } else if (OB_FAIL(arg.tablet_extra_infos_.push_back(create_tablet_extra_info))) {
+        LOG_WARN("failed to push back create tablet extra info", K(ret));
       }
     }
   }
   return ret;
 }
 
+bool ObTabletCreateMdsHelper::check_need_create_empty_major_sstable(
+    const ObCreateTabletSchema &create_tablet_schema,
+    const obrpc::ObCreateTabletExtraInfo &create_tablet_extra_info)
+{
+  bool need_create_empty_major_sstable = true;
+  if (DATA_VERSION_4_3_0_0 <= create_tablet_extra_info.tenant_data_version_) {
+    need_create_empty_major_sstable = create_tablet_extra_info.need_create_empty_major_;
+  } else {
+    need_create_empty_major_sstable =
+      !(create_tablet_schema.is_user_hidden_table() || (create_tablet_schema.is_index_table() && !create_tablet_schema.can_read_index()));
+  }
+  return need_create_empty_major_sstable;
+}
+
 int ObTabletCreateMdsHelper::build_pure_data_tablet(
     const obrpc::ObBatchCreateTabletArg &arg,
     const obrpc::ObCreateTabletInfo &info,
@@ -630,6 +627,7 @@ int ObTabletCreateMdsHelper::build_pure_data_tablet(
   const ObLSID &ls_id = arg.id_;
   const ObTabletID &data_tablet_id = info.data_tablet_id_;
   const ObSArray<ObCreateTabletSchema*> &create_tablet_schemas = arg.create_tablet_schemas_;
+  const ObSArray<obrpc::ObCreateTabletExtraInfo> &create_tablet_extra_infos = arg.tablet_extra_infos_;
   const lib::Worker::CompatMode &compat_mode = info.compat_mode_;
   const int64_t snapshot_version = arg.major_frozen_scn_.get_val_for_tx();
   ObTabletHandle tablet_handle;
@@ -673,6 +671,8 @@ int ObTabletCreateMdsHelper::build_pure_data_tablet(
     LOG_WARN("invalid args", K(ret), K(info), K(arg));
   } else if (CLICK_FAIL(ls->get_tablet_svr()->create_tablet(ls_id, data_tablet_id, data_tablet_id,
       scn, snapshot_version, *create_tablet_schemas[info.table_schema_index_[index]], compat_mode,
+      check_need_create_empty_major_sstable(*create_tablet_schemas[info.table_schema_index_[index]],
+          create_tablet_extra_infos[info.table_schema_index_[index]]),
       tablet_handle))) {
     LOG_WARN("failed to do create tablet", K(ret), K(ls_id), K(data_tablet_id), "arg", PRETTY_ARG(arg));
   }
@@ -700,6 +700,7 @@ int ObTabletCreateMdsHelper::build_mixed_tablets(
   const ObSArray<ObTabletID> &tablet_ids = info.tablet_ids_;
   const ObSArray<ObCreateTabletSchema*> &create_tablet_schemas = arg.create_tablet_schemas_;
   const lib::Worker::CompatMode &compat_mode = info.compat_mode_;
+  const ObSArray<obrpc::ObCreateTabletExtraInfo> &create_tablet_extra_infos = arg.tablet_extra_infos_;
   const int64_t snapshot_version = arg.major_frozen_scn_.get_val_for_tx();
   ObTabletHandle data_tablet_handle;
   ObTabletHandle tablet_handle;
@@ -721,6 +722,7 @@ int ObTabletCreateMdsHelper::build_mixed_tablets(
     exist = false;
     const ObTabletID &tablet_id = tablet_ids[i];
     const ObCreateTabletSchema *create_tablet_schema = create_tablet_schemas[info.table_schema_index_[i]];
+    const obrpc::ObCreateTabletExtraInfo &create_tablet_extra_info = create_tablet_extra_infos[info.table_schema_index_[i]];
     if (OB_ISNULL(create_tablet_schema)) {
       ret = OB_INVALID_ARGUMENT;
       LOG_WARN("invalid args", K(ret), K(info), K(i));
@@ -752,7 +754,9 @@ int ObTabletCreateMdsHelper::build_mixed_tablets(
     } else if (CLICK_FAIL(tablet_id_array.push_back(tablet_id))) {
       LOG_WARN("failed to push back tablet id", K(ret), K(ls_id), K(tablet_id));
     } else if (CLICK_FAIL(ls->get_tablet_svr()->create_tablet(ls_id, tablet_id, data_tablet_id,
-        scn, snapshot_version, *create_tablet_schema, compat_mode, tablet_handle))) {
+        scn, snapshot_version, *create_tablet_schema, compat_mode,
+        check_need_create_empty_major_sstable(*create_tablet_schema, create_tablet_extra_info),
+        tablet_handle))) {
       LOG_WARN("failed to do create tablet", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id), "arg", PRETTY_ARG(arg));
     }
 
@@ -797,6 +801,7 @@ int ObTabletCreateMdsHelper::build_pure_aux_tablets(
   const ObSArray<ObTabletID> &tablet_ids = info.tablet_ids_;
   const ObSArray<ObCreateTabletSchema*> &create_tablet_schemas = arg.create_tablet_schemas_;
   const lib::Worker::CompatMode &compat_mode = info.compat_mode_;
+  const ObSArray<obrpc::ObCreateTabletExtraInfo> &create_tablet_extra_infos = arg.tablet_extra_infos_;
   const int64_t snapshot_version = arg.major_frozen_scn_.get_val_for_tx();
   ObTabletHandle tablet_handle;
   bool exist = false;
@@ -815,6 +820,7 @@ int ObTabletCreateMdsHelper::build_pure_aux_tablets(
     exist = false;
     const ObTabletID &tablet_id = tablet_ids[i];
     const ObCreateTabletSchema *create_tablet_schema = create_tablet_schemas[info.table_schema_index_[i]];
+    const obrpc::ObCreateTabletExtraInfo &create_tablet_extra_info = create_tablet_extra_infos[info.table_schema_index_[i]];
 
     if (for_replay) {
       const ObTabletMapKey key(ls_id, tablet_id);
@@ -840,7 +846,9 @@ int ObTabletCreateMdsHelper::build_pure_aux_tablets(
       ret = OB_INVALID_ARGUMENT;
       LOG_WARN("invalid args", K(ret), K(info), K(i));
     } else if (CLICK_FAIL(ls->get_tablet_svr()->create_tablet(ls_id, tablet_id, data_tablet_id,
-        scn, snapshot_version, *create_tablet_schema, compat_mode, tablet_handle))) {
+        scn, snapshot_version, *create_tablet_schema, compat_mode,
+        check_need_create_empty_major_sstable(*create_tablet_schema, create_tablet_extra_info),
+        tablet_handle))) {
       LOG_WARN("failed to do create tablet", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id), "arg", PRETTY_ARG(arg));
     }
 
@@ -870,6 +878,7 @@ int ObTabletCreateMdsHelper::build_bind_hidden_tablets(
   const ObSArray<ObTabletID> &tablet_ids = info.tablet_ids_;
   const ObSArray<ObCreateTabletSchema*> &create_tablet_schemas = arg.create_tablet_schemas_;
   const lib::Worker::CompatMode &compat_mode = info.compat_mode_;
+  const ObSArray<obrpc::ObCreateTabletExtraInfo> &create_tablet_extra_infos = arg.tablet_extra_infos_;
   const int64_t snapshot_version = arg.major_frozen_scn_.get_val_for_tx();
   ObTabletHandle tablet_handle;
   int64_t aux_info_idx = -1;
@@ -893,6 +902,7 @@ int ObTabletCreateMdsHelper::build_bind_hidden_tablets(
     lob_piece_tablet_id.reset();
     const ObTabletID &tablet_id = tablet_ids[i];
     const ObCreateTabletSchema *create_tablet_schema = create_tablet_schemas[info.table_schema_index_[i]];
+    const obrpc::ObCreateTabletExtraInfo &create_tablet_extra_info = create_tablet_extra_infos[info.table_schema_index_[i]];
     bool has_related_aux_info = find_aux_info_for_hidden_tablets(arg, tablet_id, aux_info_idx);
     if (OB_ISNULL(create_tablet_schema)) {
       ret = OB_INVALID_ARGUMENT;
@@ -935,7 +945,9 @@ int ObTabletCreateMdsHelper::build_bind_hidden_tablets(
     } else if (CLICK_FAIL(tablet_id_array.push_back(tablet_id))) {
       LOG_WARN("failed to push back tablet id", K(ret), K(ls_id), K(tablet_id));
     } else if (CLICK_FAIL(ls->get_tablet_svr()->create_tablet(ls_id, tablet_id, tablet_id,
-        scn, snapshot_version, *create_tablet_schema, compat_mode, tablet_handle))) {
+        scn, snapshot_version, *create_tablet_schema, compat_mode,
+        check_need_create_empty_major_sstable(*create_tablet_schema, create_tablet_extra_info),
+        tablet_handle))) {
       LOG_WARN("failed to do create tablet", K(ret), K(ls_id), K(tablet_id), K(orig_tablet_id), "arg", PRETTY_ARG(arg));
     }
 
diff --git a/src/storage/tablet/ob_tablet_create_mds_helper.h b/src/storage/tablet/ob_tablet_create_mds_helper.h
index df01d3179..74ee53db2 100644
--- a/src/storage/tablet/ob_tablet_create_mds_helper.h
+++ b/src/storage/tablet/ob_tablet_create_mds_helper.h
@@ -17,6 +17,7 @@
 #include "lib/worker.h"
 #include "lib/container/ob_iarray.h"
 #include "storage/tx/ob_trans_define.h"
+#include "storage/ob_storage_schema.h"
 
 namespace oceanbase
 {
@@ -40,6 +41,7 @@ namespace obrpc
 {
 struct ObBatchCreateTabletArg;
 struct ObCreateTabletInfo;
+struct ObCreateTabletExtraInfo;
 }
 
 namespace storage
@@ -156,6 +158,9 @@ private:
       const bool for_old_mds);
   static void handle_ret_for_replay(int &ret);
   static int convert_schemas(obrpc::ObBatchCreateTabletArg &arg);
+  static bool check_need_create_empty_major_sstable(
+      const ObCreateTabletSchema &create_tablet_schema,
+      const obrpc::ObCreateTabletExtraInfo &create_tablet_extra_info);
 };
 } // namespace storage
 } // namespace oceanbase
diff --git a/src/storage/tx_table/ob_tx_table.cpp b/src/storage/tx_table/ob_tx_table.cpp
index 8511cd9d0..5e7f35755 100644
--- a/src/storage/tx_table/ob_tx_table.cpp
+++ b/src/storage/tx_table/ob_tx_table.cpp
@@ -197,12 +197,9 @@ int ObTxTable::create_tablet(const lib::Worker::CompatMode compat_mode, const SC
   } else {
     const uint64_t tenant_id = ls_->get_tenant_id();
     const share::ObLSID &ls_id = ls_->get_ls_id();
-    uint64_t tenant_data_version = 0;
-    if (OB_FAIL(GET_MIN_DATA_VERSION(tenant_id, tenant_data_version))) {
-      LOG_WARN("get min data version failed", K(ret), K(tenant_id));
-    } else if (OB_FAIL(create_data_tablet_(tenant_id, ls_id, compat_mode, create_scn, tenant_data_version))) {
+    if (OB_FAIL(create_data_tablet_(tenant_id, ls_id, compat_mode, create_scn))) {
       LOG_WARN("create data tablet failed", K(ret));
-    } else if (OB_FAIL(create_ctx_tablet_(tenant_id, ls_id, compat_mode, create_scn, tenant_data_version))) {
+    } else if (OB_FAIL(create_ctx_tablet_(tenant_id, ls_id, compat_mode, create_scn))) {
       LOG_WARN("create ctx tablet failed", K(ret));
     }
     if (OB_FAIL(ret)) {
@@ -283,8 +280,7 @@ int ObTxTable::create_ctx_tablet_(
     const uint64_t tenant_id,
     const ObLSID ls_id,
     const lib::Worker::CompatMode compat_mode,
-    const share::SCN &create_scn,
-    const uint64_t tenant_data_version)
+    const share::SCN &create_scn)
 {
   int ret = OB_SUCCESS;
   share::schema::ObTableSchema table_schema;
@@ -293,8 +289,7 @@ int ObTxTable::create_ctx_tablet_(
   if (OB_FAIL(get_ctx_table_schema_(tenant_id, table_schema))) {
     LOG_WARN("get ctx table schema failed", K(ret));
   } else if (OB_FAIL(create_tablet_schema.init(arena_allocator, table_schema, compat_mode,
-        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-        tenant_data_version, true/*need_create_empty_major_sstable*/))) {
+        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3))) {
     LOG_WARN("failed to init storage schema", KR(ret), K(table_schema));
   } else if (OB_FAIL(ls_->create_ls_inner_tablet(ls_id,
                                                  LS_TX_CTX_TABLET,
@@ -410,8 +405,7 @@ int ObTxTable::get_data_table_schema_(const uint64_t tenant_id, share::schema::O
 int ObTxTable::create_data_tablet_(const uint64_t tenant_id,
                                    const ObLSID ls_id,
                                    const lib::Worker::CompatMode compat_mode,
-                                   const share::SCN &create_scn,
-                                   const uint64_t tenant_data_version)
+                                   const share::SCN &create_scn)
 {
   int ret = OB_SUCCESS;
   share::schema::ObTableSchema table_schema;
@@ -420,8 +414,7 @@ int ObTxTable::create_data_tablet_(const uint64_t tenant_id,
   if (OB_FAIL(get_data_table_schema_(tenant_id, table_schema))) {
     LOG_WARN("get data table schema failed", K(ret));
   } else if (OB_FAIL(create_tablet_schema.init(arena_allocator, table_schema, compat_mode,
-        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-        tenant_data_version, true/*need_create_empty_major*/))) {
+        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3))) {
     LOG_WARN("failed to init storage schema", KR(ret), K(table_schema));
   } else if (OB_FAIL(ls_->create_ls_inner_tablet(ls_id,
                                                  LS_TX_DATA_TABLET,
diff --git a/src/storage/tx_table/ob_tx_table.h b/src/storage/tx_table/ob_tx_table.h
index eafd7ff35..d004f41ec 100644
--- a/src/storage/tx_table/ob_tx_table.h
+++ b/src/storage/tx_table/ob_tx_table.h
@@ -290,14 +290,12 @@ private:
       const uint64_t tenant_id,
       const share::ObLSID ls_id,
       const lib::Worker::CompatMode compat_mode,
-      const share::SCN &create_scn,
-      const uint64_t tenant_data_version);
+      const share::SCN &create_scn);
   int create_ctx_tablet_(
       const uint64_t tenant_id,
       const share::ObLSID ls_id,
       const lib::Worker::CompatMode compat_mode,
-      const share::SCN &create_scn,
-      const uint64_t tenant_data_version);
+      const share::SCN &create_scn);
   int remove_tablet_(const common::ObTabletID &tablet_id);
   int get_data_table_schema_(
       const uint64_t tenant_id,
diff --git a/unittest/storage/test_compaction_policy.cpp b/unittest/storage/test_compaction_policy.cpp
index f9c21ad5f..165a1dcbf 100644
--- a/unittest/storage/test_compaction_policy.cpp
+++ b/unittest/storage/test_compaction_policy.cpp
@@ -416,11 +416,10 @@ int TestCompactionPolicy::mock_tablet(
     LOG_WARN("failed to acquire tablet", K(ret), K(key));
   } else if (FALSE_IT(tablet = tablet_handle.get_obj())) {
   } else if (OB_FAIL(create_tablet_schema.init(arena_allocator, table_schema, compat_mode,
-         false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-         0/*tenant_data_version, default val*/, need_empty_major_table/*need_create_empty_major*/))) {
+         false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3))) {
     LOG_WARN("failed to init storage schema", KR(ret), K(table_schema));
   } else if (OB_FAIL(tablet->init_for_first_time_creation(allocator, ls_id, tablet_id, tablet_id,
-      SCN::min_scn(), snapshot_version, create_tablet_schema, ls_handle.get_ls()->get_freezer()))) {
+      SCN::min_scn(), snapshot_version, create_tablet_schema, need_empty_major_table, ls_handle.get_ls()->get_freezer()))) {
     LOG_WARN("failed to init tablet", K(ret), K(ls_id), K(tablet_id), K(snapshot_version),
               K(table_schema), K(compat_mode));
   } else {
diff --git a/unittest/storage/test_lob_common.h b/unittest/storage/test_lob_common.h
index 12dba97e6..d7f709ce8 100644
--- a/unittest/storage/test_lob_common.h
+++ b/unittest/storage/test_lob_common.h
@@ -332,8 +332,7 @@ int TestLobCommon::build_lob_tablet_arg(
   } else if (OB_FAIL(tablet_schema_index_array.push_back(2))) {
     STORAGE_LOG(WARN, "failed to push index into array", K(ret));
   } else if (OB_FAIL(tablet_info.init(tablet_id_array, data_tablet_id, tablet_schema_index_array,
-      lib::get_compat_mode(), false/*is_create_bind_hidden_tablets*/,
-      true /*need_create_empty_major_sstable*/))) {
+      lib::get_compat_mode(), false/*is_create_bind_hidden_tablets*/))) {
     STORAGE_LOG(WARN, "failed to init tablet info", K(ret), K(tablet_id_array),
         K(data_tablet_id), K(tablet_schema_index_array));
   } else if (OB_FAIL(arg.init_create_tablet(ls_id, share::SCN::min_scn(), false/*need_check_tablet_cnt*/))) {
diff --git a/unittest/storage/test_tablet_helper.h b/unittest/storage/test_tablet_helper.h
index a759ab204..124eacaf2 100644
--- a/unittest/storage/test_tablet_helper.h
+++ b/unittest/storage/test_tablet_helper.h
@@ -118,8 +118,7 @@ inline int TestTabletHelper::create_tablet(
   prepare_sstable_param(tablet_id, table_schema, param);
   void *buff = nullptr;
   if (OB_FAIL(create_tablet_schema.init(schema_allocator, table_schema, compat_mode,
-        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3,
-        0/*tenant_data_version, default val*/, true/*need_create_empty_major*/))) {
+        false/*skip_column_info*/, ObCreateTabletSchema::STORAGE_SCHEMA_VERSION_V3))) {
     STORAGE_LOG(WARN, "failed to init storage schema", KR(ret), K(table_schema));
   } else if (OB_FAIL(ObSSTableMergeRes::fill_column_checksum_for_empty_major(param.column_cnt_, param.column_checksums_))) {
     STORAGE_LOG(WARN, "fill column checksum failed", K(ret), K(param));
@@ -129,12 +128,14 @@ inline int TestTabletHelper::create_tablet(
     ObFreezer *freezer = ls_handle.get_ls()->get_freezer();
     ObTabletHandle tablet_handle;
     const ObTabletMapKey key(ls_id, tablet_id);
+    const bool need_create_empty_major_sstable =
+      !(create_tablet_schema.is_user_hidden_table() || (create_tablet_schema.is_index_table() && !create_tablet_schema.can_read_index()));
     if (OB_FAIL(t3m->create_msd_tablet(WashTabletPriority::WTP_HIGH, key, ls_handle, tablet_handle))) {
       STORAGE_LOG(WARN, "t3m acquire tablet failed", K(ret), K(ls_id), K(tablet_id));
     } else if (OB_FAIL(tablet_handle.get_obj()->init_for_first_time_creation(
         *tablet_handle.get_allocator(),
         ls_id, tablet_id, tablet_id, share::SCN::base_scn(),
-        snapshot_version, create_tablet_schema, freezer))){
+        snapshot_version, create_tablet_schema, need_create_empty_major_sstable, freezer))){
       STORAGE_LOG(WARN, "failed to init tablet", K(ret), K(ls_id), K(tablet_id));
     } else if (ObTabletStatus::Status::MAX != tablet_status) {
       ObTabletCreateDeleteMdsUserData data;