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

[scn] fix failure of mittest after refresh feature scn

Browse Source
This commit is contained in:
obdev
2022-11-28 01:46:42 +00:00
committed by ob-robot
parent 49a02f3304
commit 54b64a7263
1898 changed files with 255804 additions and 280809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
src/storage/compaction/ob_tablet_merge_task.cpp
View File

@ -32,10 +32,8 @@
namespace oceanbase
{
using namespace common;
using namespace storage;
using namespace memtable;
using namespace blocksstable;
using namespace storage;
namespace compaction
{
@ -61,7 +59,7 @@ ObMergeParameter::ObMergeParameter()
merge_schema_(nullptr),
merge_range_(),
version_range_(),
log_ts_range_(),
scn_range_(),
full_read_info_(nullptr),
is_full_merge_(false),
is_sstable_cut_(false)
@ -105,7 +103,7 @@ void ObMergeParameter::reset()
merge_schema_ = nullptr;
merge_range_.reset();
version_range_.reset();
log_ts_range_.reset();
scn_range_.reset();
is_full_merge_ = false;
is_sstable_cut_ = false;
}
@ -142,7 +140,7 @@ int ObMergeParameter::init(compaction::ObTabletMergeCtx &merge_ctx, const int64_
version_range_.base_version_ = 0;
version_range_.snapshot_version_ = INT64_MAX - 2;
}
log_ts_range_ = merge_ctx.log_ts_range_;
scn_range_ = merge_ctx.scn_range_;
is_full_merge_ = merge_ctx.is_full_merge_;
full_read_info_ = &(merge_ctx.tablet_handle_.get_obj()->get_full_read_info());
is_sstable_cut_ = false;
@ -250,7 +248,7 @@ int64_t ObBasicTabletMergeDag::to_string(char* buf, const int64_t buf_len) const
} else if (OB_NOT_NULL(ctx_)) {
if (OB_FAIL(ctx_->sstable_version_range_.to_string(buf, buf_len))) {
LOG_WARN("failed to call to version range", K(ret), K(buf_len));
} else if (OB_FAIL(ctx_->log_ts_range_.to_string(buf, buf_len))) {
} else if (OB_FAIL(ctx_->scn_range_.to_string(buf, buf_len))) {
LOG_WARN("failed to call to log ts range", K(ret), K(buf_len));
}
}
@ -604,9 +602,6 @@ int ObTabletMergePrepareTask::process()
&& !MTL(ObTenantTabletScheduler *)->could_major_merge_start())) {
ret = OB_CANCELED;
LOG_INFO("Merge has been paused", K(ret), K(ctx));
} else if (ctx->ls_handle_.get_ls()->is_offline()) {
ret = OB_CANCELED;
LOG_INFO("ls offline, skip merge", K(ret), K(ctx));
} else if (FALSE_IT(ctx->time_guard_.click(ObCompactionTimeGuard::DAG_WAIT_TO_SCHEDULE))) {
} else if (OB_FAIL(ctx->ls_handle_.get_ls()->get_tablet(ctx->param_.tablet_id_,
ctx->tablet_handle_,
@ -618,11 +613,11 @@ int ObTabletMergePrepareTask::process()
LOG_WARN("failed to build merge ctx", K(ret), K(ctx->param_));
}
} else if (!skip_rest_operation && ctx->param_.is_multi_version_minor_merge()) {
if (ctx->log_ts_range_.is_empty()) {
if (ctx->scn_range_.is_empty()) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("Unexcepted empty log ts range in minor merge", K(ret), K(ctx->log_ts_range_));
LOG_ERROR("Unexcepted empty log ts range in minor merge", K(ret), K(ctx->scn_range_));
} else {
ctx->merge_log_ts_ = ctx->log_ts_range_.end_log_ts_;
ctx->merge_scn_ = ctx->scn_range_.end_scn_.get_val_for_inner_table_field();
}
}
@ -884,7 +879,9 @@ int ObTabletMergeFinishTask::process()
}
if (OB_SUCC(ret) && ctx.param_.is_major_merge() && NULL != ctx.param_.report_) {
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(ctx.param_.report_->submit_tablet_update_task(MTL_ID(), ctx.param_.ls_id_, tablet_id))) {
if (OB_TMP_FAIL(ctx.param_.report_->submit_tablet_checksums_task(MTL_ID(), ctx.param_.ls_id_, tablet_id))) {
LOG_WARN("failed to submit tablet checksums task to report", K(tmp_ret), K(MTL_ID()), K(ctx.param_.ls_id_), K(tablet_id));
} else if (OB_TMP_FAIL(ctx.param_.report_->submit_tablet_update_task(MTL_ID(), ctx.param_.ls_id_, tablet_id))) {
LOG_WARN("failed to submit tablet update task to report", K(tmp_ret), K(MTL_ID()), K(ctx.param_.ls_id_), K(tablet_id));
} else if (OB_TMP_FAIL(ctx.ls_handle_.get_ls()->get_tablet_svr()->update_tablet_report_status(tablet_id))) {
LOG_WARN("failed to update tablet report status", K(tmp_ret), K(MTL_ID()), K(tablet_id));
@ -893,10 +890,6 @@ int ObTabletMergeFinishTask::process()
if (OB_SUCC(ret) && OB_NOT_NULL(ctx.merge_progress_)) {
int tmp_ret = OB_SUCCESS;
// update merge info
if (OB_TMP_FAIL(ctx.merge_progress_->update_merge_info(ctx.merge_info_.get_sstable_merge_info()))) {
STORAGE_LOG(WARN, "fail to update update merge info", K(tmp_ret));
}
if (OB_TMP_FAIL(compaction::ObCompactionSuggestionMgr::get_instance().analyze_merge_info(
ctx.merge_info_,
*ctx.merge_progress_))) {
@ -970,30 +963,28 @@ int ObTabletMergeFinishTask::add_sstable_for_merge(ObTabletMergeCtx &ctx)
}
if (OB_SUCC(ret)) {
int64_t clog_checkpoint_ts = ctx.param_.is_mini_merge() ? ctx.merged_table_handle_.get_table()->get_end_log_ts() : 0;
palf::SCN clog_checkpoint_scn = ctx.param_.is_mini_merge() ? ctx.merged_table_handle_.get_table()->get_end_scn() : palf::SCN::min_scn();
ObUpdateTableStoreParam param(ctx.merged_table_handle_,
ctx.sstable_version_range_.snapshot_version_,
ctx.sstable_version_range_.multi_version_start_,
update_storage_schema,
ctx.rebuild_seq_,
ctx.param_.is_major_merge(),
clog_checkpoint_ts,
clog_checkpoint_scn.get_val_for_inner_table_field(),
ctx.param_.is_mini_minor_merge());
ObTablet *old_tablet = ctx.tablet_handle_.get_obj();
ObTabletHandle new_tablet_handle;
if (ctx.param_.tablet_id_.is_special_merge_tablet()) {
param.multi_version_start_ = 1;
}
// for mini merge, read all msd from frozen memtable
if (ctx.param_.is_mini_merge() && OB_FAIL(read_msd_from_memtable(ctx, param))) {
LOG_WARN("failed to read msd from memtable", K(ret), K(ctx));
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ctx.ls_handle_.get_ls()->update_tablet_table_store(
ctx.param_.tablet_id_, param, new_tablet_handle))) {
LOG_WARN("failed to update tablet table store", K(ret), K(param));
} else if (FALSE_IT(ctx.time_guard_.click(ObCompactionTimeGuard::UPDATE_TABLET))) {
} else if (ctx.param_.is_mini_merge()) {
if (OB_FAIL(new_tablet_handle.get_obj()->release_memtables(ctx.log_ts_range_.end_log_ts_))) {
LOG_WARN("failed to release memtable", K(ret), "end_log_ts", ctx.log_ts_range_.end_log_ts_);
if (OB_FAIL(new_tablet_handle.get_obj()->release_memtables(ctx.scn_range_.end_scn_))) {
LOG_WARN("failed to release memtable", K(ret), "end_scn", ctx.scn_range_.end_scn_);
} else {
ctx.time_guard_.click(ObCompactionTimeGuard::RELEASE_MEMTABLE);
}
@ -1020,69 +1011,6 @@ int ObTabletMergeFinishTask::add_sstable_for_merge(ObTabletMergeCtx &ctx)
return ret;
}
int ObTabletMergeFinishTask::read_msd_from_memtable(ObTabletMergeCtx &ctx, ObUpdateTableStoreParam &param)
{
int ret = OB_SUCCESS;
if (OB_FAIL(traverse_all_memtables(ctx, &param.tx_data_, MultiSourceDataUnitType::TABLET_TX_DATA))) {
LOG_WARN("failed to read tx data from memtables", K(ret));
} else if (OB_FAIL(traverse_all_memtables(ctx, &param.binding_info_, MultiSourceDataUnitType::TABLET_BINDING_INFO))) {
LOG_WARN("failed to read tx data from memtables", K(ret));
} else if (OB_FAIL(traverse_all_memtables(ctx, &param.auto_inc_seq_, MultiSourceDataUnitType::TABLET_SEQ))) {
LOG_WARN("failed to read tx data from memtables", K(ret));
} else {
LOG_INFO("succeeded to read msd from memtable", K(ret),
"ls_id", ctx.param_.ls_id_,
"tablet_id", ctx.param_.tablet_id_,
"tx_data", param.tx_data_,
"binding_info", param.binding_info_,
"auto_inc_seq", param.auto_inc_seq_);
}
return ret;
}
int ObTabletMergeFinishTask::traverse_all_memtables(
ObTabletMergeCtx &ctx,
ObIMultiSourceDataUnit *msd,
const MultiSourceDataUnitType &type)
{
int ret = OB_SUCCESS;
ObIArray<ObITable*> &tables = ctx.tables_handle_.get_tables();
ObITable *table = nullptr;
ObMemtable *memtable = nullptr;
if (OB_ISNULL(msd)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret));
}
for (int64_t i = tables.count() - 1; OB_SUCC(ret) && i >= 0; --i) {
if (OB_ISNULL(table = tables.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table is null", K(ret), K(tables), KP(table));
} else if (OB_UNLIKELY(!table->is_memtable())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table is not memtable", K(ret), K(tables), KPC(table));
} else if (OB_UNLIKELY(!table->is_frozen_memtable())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table is not frozen memtable", K(ret), K(tables), KPC(table));
} else if (table->is_data_memtable()) {
memtable = static_cast<ObMemtable*>(table);
if (memtable->has_multi_source_data_unit(type)) {
if (OB_FAIL(memtable->get_multi_source_data_unit(msd, nullptr/*allocator*/))) {
LOG_WARN("failed to get msd from memtable", K(ret), K(type));
} else {
// succeeded to get msd, just break
break;
}
}
}
}
return ret;
}
int ObTabletMergeFinishTask::try_schedule_compaction_after_mini(
ObTabletMergeCtx &ctx,
ObTabletHandle &tablet_handle)