hcq/oceanbase
hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

fix tenant_data_version & need_create_empty_major compatible.

Browse Source
This commit is contained in:
obdev 2024-01-26 10:47:27 +00:00 committed by ob-robot
parent 253185fc54
commit e993318693
20 changed files with 154 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
mittest/mtlenv/storage/test_ls_migration_param.cpp
View File

@ -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;

5
mittest/mtlenv/storage/test_ls_tablet_info_writer_and_reader.cpp
View File

@ -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;

22
mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
View File

@ -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());

8
src/rootserver/ob_tablet_creator.cpp
View File

@ -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;

47
src/share/ob_rpc_struct.cpp
View File

@ -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);
}
}
}
}

16
src/share/ob_rpc_struct.h
View File

@ -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

5
src/storage/ls/ob_ls_tablet_service.cpp
View File

@ -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"))) {

1
src/storage/ls/ob_ls_tablet_service.h
View File

@ -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,

20
src/storage/ob_storage_schema.cpp
View File

@ -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;
}

19
src/storage/ob_storage_schema.h
View File

@ -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>

3
src/storage/tablelock/ob_lock_table.cpp
View File

@ -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,

2
src/storage/tablet/ob_tablet.cpp
View File

@ -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;

1
src/storage/tablet/ob_tablet.h
View File

@ -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(

60
src/storage/tablet/ob_tablet_create_mds_helper.cpp
View File

@ -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));
}

5
src/storage/tablet/ob_tablet_create_mds_helper.h
View File

@ -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

19
src/storage/tx_table/ob_tx_table.cpp
View File

@ -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,

6
src/storage/tx_table/ob_tx_table.h
View File

@ -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,

5
unittest/storage/test_compaction_policy.cpp
View File

@ -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 {

3
unittest/storage/test_lob_common.h
View File

@ -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*/))) {

7
unittest/storage/test_tablet_helper.h
View File

@ -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;