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

fix debug log core

Browse Source
This commit is contained in:
lx0
2022-01-19 15:20:49 +08:00
committed by LINxiansheng
parent c4c7998540
commit de61adfe46
3 changed files with 39 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/storage/blocksstable/ob_micro_block_row_scanner.cpp
View File

@ -767,9 +767,9 @@ int ObMultiVersionMicroBlockRowScanner::inner_get_next_row_impl(const ObStoreRow
} }
} }
if (OB_NOT_NULL(ret_row) && !ret_row->is_valid()) { if (OB_NOT_NULL(ret_row) && !ret_row->is_valid()) {
STORAGE_LOG(ERROR, "row is invalid", K(*ret_row)); STORAGE_LOG(ERROR, "row is invalid", KPC(ret_row));
} else { } else {
STORAGE_LOG(DEBUG, "row is valid", K(*ret_row)); STORAGE_LOG(DEBUG, "row is valid", KPC(ret_row));
} }
return ret; return ret;
} }
@ -1656,7 +1656,7 @@ int ObMultiVersionMicroBlockMinorMergeRowScanner::get_row_from_row_queue(const s
} else if (OB_FAIL(row_queue_.get_next_row(row))) { } else if (OB_FAIL(row_queue_.get_next_row(row))) {
STORAGE_LOG(WARN, "failed to get next row from prepared row queue", K(ret), KPC(this)); STORAGE_LOG(WARN, "failed to get next row from prepared row queue", K(ret), KPC(this));
} else { } else {
STORAGE_LOG(DEBUG, "get row from row queue", K(ret), KPC(this), K(*row)); STORAGE_LOG(DEBUG, "get row from row queue", K(ret), KPC(this), KPC(row));
} }
return ret; return ret;
} }
@ -1978,7 +1978,7 @@ int ObMultiVersionMicroBlockMinorMergeRowScanner::compact_trans_row_to_one()
"add one row for another trans", "add one row for another trans",
K(row_queue_.count()), K(row_queue_.count()),
K(committed_trans_version_), K(committed_trans_version_),
K(*row_queue_.get_last())); KPC(row_queue_.get_last()));
} }
} }
if (OB_SUCC(ret) && OB_NOT_NULL(row_queue_.get_last())) { if (OB_SUCC(ret) && OB_NOT_NULL(row_queue_.get_last())) {

20
src/storage/ob_partition_merge_task.cpp
View File

@ -94,7 +94,7 @@ int ObMacroBlockMergeTask::generate_next_task(ObITask*& next_task)
ret = OB_ITER_END; ret = OB_ITER_END;
} else if (!is_merge_dag(dag_->get_type())) { } else if (!is_merge_dag(dag_->get_type())) {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("dag type not match", K(ret), K(*dag_)); LOG_ERROR("dag type not match", K(ret), KPC(dag_));
} else { } else {
ObMacroBlockMergeTask* merge_task = NULL; ObMacroBlockMergeTask* merge_task = NULL;
ObSSTableMergeDag* merge_dag = static_cast<ObSSTableMergeDag*>(dag_); ObSSTableMergeDag* merge_dag = static_cast<ObSSTableMergeDag*>(dag_);
@ -313,9 +313,9 @@ int ObSSTableMergeContext::add_lob_macro_blocks(const int64_t idx, blocksstable:
} else if (OB_FAIL(new_block_write_ctx(lob_block_ctxs_[idx]))) { } else if (OB_FAIL(new_block_write_ctx(lob_block_ctxs_[idx]))) {
LOG_WARN("failed to new block write ctx", K(ret)); LOG_WARN("failed to new block write ctx", K(ret));
} else if (OB_FAIL(lob_block_ctxs_[idx]->set(*blocks_ctx))) { } else if (OB_FAIL(lob_block_ctxs_[idx]->set(*blocks_ctx))) {
LOG_WARN("failed to transfer lob marco blocks ctx", K(ret), K(*blocks_ctx)); LOG_WARN("failed to transfer lob marco blocks ctx", K(ret), KPC(blocks_ctx));
} else { } else {
STORAGE_LOG(DEBUG, "[LOB] sstable merge context add lob macro blocks", K(idx), K(*blocks_ctx), K(ret)); STORAGE_LOG(DEBUG, "[LOB] sstable merge context add lob macro blocks", K(idx), KPC(blocks_ctx), K(ret));
} }
return ret; return ret;
} }
@ -992,7 +992,7 @@ int ObSSTableMergePrepareTask::init()
LOG_WARN("dag must not null", K(ret)); LOG_WARN("dag must not null", K(ret));
} else if (!is_merge_dag(dag_->get_type())) { } else if (!is_merge_dag(dag_->get_type())) {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("dag type not match", K(ret), K(*dag_)); LOG_ERROR("dag type not match", K(ret), KPC(dag_));
} else { } else {
merge_dag_ = static_cast<ObSSTableMergeDag*>(dag_); merge_dag_ = static_cast<ObSSTableMergeDag*>(dag_);
if (OB_UNLIKELY(!merge_dag_->get_ctx().param_.is_valid())) { if (OB_UNLIKELY(!merge_dag_->get_ctx().param_.is_valid())) {
@ -1167,7 +1167,7 @@ int ObSSTableMergePrepareTask::create_sstable_for_large_snapshot(ObSSTableMergeC
} else if (OB_FAIL(ctx.merged_table_handle_.get_sstable(new_sstable))) { } else if (OB_FAIL(ctx.merged_table_handle_.get_sstable(new_sstable))) {
LOG_WARN("fail to get merged sstable", K(ret)); LOG_WARN("fail to get merged sstable", K(ret));
} else { } else {
FLOG_INFO("success to create sstable for larger snapshot version than major ts", K(*new_sstable)); FLOG_INFO("success to create sstable for larger snapshot version than major ts", KPC(new_sstable));
} }
} }
} }
@ -1193,7 +1193,7 @@ int ObSSTableMergeFinishTask::init()
LOG_WARN("dag must not null", K(ret)); LOG_WARN("dag must not null", K(ret));
} else if (!is_merge_dag(dag_->get_type())) { } else if (!is_merge_dag(dag_->get_type())) {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("dag type not match", K(ret), K(*dag_)); LOG_ERROR("dag type not match", K(ret), KPC(dag_));
} else { } else {
merge_dag_ = static_cast<ObSSTableMergeDag*>(dag_); merge_dag_ = static_cast<ObSSTableMergeDag*>(dag_);
if (OB_UNLIKELY(!merge_dag_->get_ctx().is_valid())) { if (OB_UNLIKELY(!merge_dag_->get_ctx().is_valid())) {
@ -1460,7 +1460,7 @@ int ObWriteCheckpointTask::init(int64_t frozen_version)
LOG_WARN("dag must not null", K(ret)); LOG_WARN("dag must not null", K(ret));
} else if (ObIDag::DAG_TYPE_MAJOR_MERGE_FINISH != dag_->get_type()) { } else if (ObIDag::DAG_TYPE_MAJOR_MERGE_FINISH != dag_->get_type()) {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("dag type not match", K(ret), K(*dag_)); LOG_ERROR("dag type not match", K(ret), KPC(dag_));
} else { } else {
frozen_version_ = frozen_version; frozen_version_ = frozen_version;
is_inited_ = true; is_inited_ = true;
@ -1958,11 +1958,11 @@ int ObTransTableMergeTask::merge_remote_with_local(blocksstable::ObMacroBlockWri
pos1 = 0; pos1 = 0;
if (OB_FAIL(local_trans_id.deserialize( if (OB_FAIL(local_trans_id.deserialize(
local_row->row_val_.cells_[0].get_string_ptr(), local_row->row_val_.cells_[0].val_len_, pos))) { local_row->row_val_.cells_[0].get_string_ptr(), local_row->row_val_.cells_[0].val_len_, pos))) {
STORAGE_LOG(WARN, "failed to deserialize trans_id", K(ret), K(*local_row)); STORAGE_LOG(WARN, "failed to deserialize trans_id", K(ret), KPC(local_row));
} else if (OB_FAIL(remote_trans_id.deserialize(remote_row->row_val_.cells_[0].get_string_ptr(), } else if (OB_FAIL(remote_trans_id.deserialize(remote_row->row_val_.cells_[0].get_string_ptr(),
remote_row->row_val_.cells_[0].val_len_, remote_row->row_val_.cells_[0].val_len_,
pos1))) { pos1))) {
STORAGE_LOG(WARN, "failed to deserialize trans_id", K(ret), K(*remote_row)); STORAGE_LOG(WARN, "failed to deserialize trans_id", K(ret), KPC(remote_row));
} else { } else {
ObTransKey local_trans_key(pg_key_, local_trans_id); ObTransKey local_trans_key(pg_key_, local_trans_id);
ObTransKey remote_trans_key(pg_key_, remote_trans_id); ObTransKey remote_trans_key(pg_key_, remote_trans_id);
@ -2035,7 +2035,7 @@ int ObTransTableMergeTask::merge_remote_with_local(blocksstable::ObMacroBlockWri
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
if (NULL != target_row) { if (NULL != target_row) {
if (OB_FAIL(writer.append_row(*target_row))) { if (OB_FAIL(writer.append_row(*target_row))) {
STORAGE_LOG(WARN, "failed to append row", K(ret), K(*target_row)); STORAGE_LOG(WARN, "failed to append row", K(ret), KPC(target_row));
} }
} }
} }

50
src/storage/ob_table_store.cpp
View File

@ -229,7 +229,7 @@ int ObTableStore::get_read_tables(const int64_t snapshot_version, ObTablesHandle
} else if (OB_FAIL(get_minor_sstables(handle))) { } else if (OB_FAIL(get_minor_sstables(handle))) {
STORAGE_LOG(WARN, "Failed to get all minor sstables", K(ret)); STORAGE_LOG(WARN, "Failed to get all minor sstables", K(ret));
} else if (OB_NOT_NULL(complement_minor_sstable_) && OB_FAIL(handle.add_table(complement_minor_sstable_))) { } else if (OB_NOT_NULL(complement_minor_sstable_) && OB_FAIL(handle.add_table(complement_minor_sstable_))) {
LOG_WARN("failed to add complement table", K(ret), K(handle), K(*complement_minor_sstable_)); LOG_WARN("failed to add complement table", K(ret), K(handle), KPC(complement_minor_sstable_));
} else if (OB_FAIL(get_memtables(true /*include_active_memtable*/, handle))) { } else if (OB_FAIL(get_memtables(true /*include_active_memtable*/, handle))) {
LOG_WARN("Failed to get memtables", K(ret), K(PRETTY_TS(*this))); LOG_WARN("Failed to get memtables", K(ret), K(PRETTY_TS(*this)));
} }
@ -302,7 +302,7 @@ int ObTableStore::get_inc_read_tables(
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
// add complement sstable // add complement sstable
if (OB_NOT_NULL(complement_minor_sstable_) && OB_FAIL(handle.add_table(complement_minor_sstable_))) { if (OB_NOT_NULL(complement_minor_sstable_) && OB_FAIL(handle.add_table(complement_minor_sstable_))) {
LOG_WARN("failed to add complement table", K(ret), K(handle), K(*complement_minor_sstable_)); LOG_WARN("failed to add complement table", K(ret), K(handle), KPC(complement_minor_sstable_));
} else { } else {
// add memtable // add memtable
const int64_t sstable_count = handle.get_count(); const int64_t sstable_count = handle.get_count();
@ -333,7 +333,7 @@ int ObTableStore::get_inc_read_tables(
ret = OB_SNAPSHOT_DISCARDED; ret = OB_SNAPSHOT_DISCARDED;
LOG_WARN("no table found for specified version", K(ret), K(handle), K(snapshot_version)); LOG_WARN("no table found for specified version", K(ret), K(handle), K(snapshot_version));
} else { } else {
LOG_DEBUG("get_inc_read_tables", K(*base_table), K(handle)); LOG_DEBUG("get_inc_read_tables", KPC(base_table), K(handle));
} }
} }
} }
@ -638,7 +638,7 @@ int ObTableStore::add_major_sstable(ObSSTable *new_table, ObArray<ObITable *> &m
LOG_DEBUG("add major sstables", K(table->get_key()), K(new_table->get_key())); LOG_DEBUG("add major sstables", K(table->get_key()), K(new_table->get_key()));
if (table->get_key() != new_table->get_key()) { if (table->get_key() != new_table->get_key()) {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("major version same but table key not match", K(ret), K(*table), K(*new_table)); LOG_ERROR("major version same but table key not match", K(ret), KPC(table), KPC(new_table));
} }
need_add = false; need_add = false;
break; break;
@ -667,7 +667,7 @@ int ObTableStore::add_minor_sstable(const bool need_safe_check, ObIArray<ObITabl
LOG_WARN("failed to check_need_add_minor_sstable", K(ret), K(inc_tables)); LOG_WARN("failed to check_need_add_minor_sstable", K(ret), K(inc_tables));
} else if (need_safe_check && tmp_tables.count() == inc_tables.count()) { } else if (need_safe_check && tmp_tables.count() == inc_tables.count()) {
ret = OB_MINOR_MERGE_NOT_ALLOW; ret = OB_MINOR_MERGE_NOT_ALLOW;
LOG_WARN("too many sstables, no pos for fresh new minor sstable", K(ret), K(*new_table), K(PRETTY_TS(*this))); LOG_WARN("too many sstables, no pos for fresh new minor sstable", K(ret), KPC(new_table), K(PRETTY_TS(*this)));
} else if (OB_FAIL(tmp_tables.push_back(new_table))) { } else if (OB_FAIL(tmp_tables.push_back(new_table))) {
LOG_WARN("failed to add merged table", K(ret)); LOG_WARN("failed to add merged table", K(ret));
} else if (OB_FAIL(sort_minor_tables(tmp_tables))) { } else if (OB_FAIL(sort_minor_tables(tmp_tables))) {
@ -720,13 +720,13 @@ int ObTableStore::check_need_add_minor_sstable(
LOG_WARN("Unexpected memtable in inc tables", K(ret), KPC(table), K(i), K(inc_tables)); LOG_WARN("Unexpected memtable in inc tables", K(ret), KPC(table), K(i), K(inc_tables));
} else if (check_include_by_log_ts_range(*new_table, *table)) { } else if (check_include_by_log_ts_range(*new_table, *table)) {
// existing table contained by new table // existing table contained by new table
LOG_DEBUG("table purged", K(*new_table), K(*table)); LOG_DEBUG("table purged", KPC(new_table), KPC(table));
} else if (check_include_by_log_ts_range(*table, *new_table)) { } else if (check_include_by_log_ts_range(*table, *new_table)) {
ret = OB_MINOR_SSTABLE_RANGE_CROSS; ret = OB_MINOR_SSTABLE_RANGE_CROSS;
LOG_WARN("new_table is contained by existing table", K(ret), KPC(new_table), KPC(table)); LOG_WARN("new_table is contained by existing table", K(ret), KPC(new_table), KPC(table));
} else if (check_intersect_by_log_ts_range(*table, *new_table)) { } else if (check_intersect_by_log_ts_range(*table, *new_table)) {
ret = OB_MINOR_SSTABLE_RANGE_CROSS; ret = OB_MINOR_SSTABLE_RANGE_CROSS;
LOG_WARN("new table's log_ts range is crossed with existing table", K(*new_table), K(*table)); LOG_WARN("new table's log_ts range is crossed with existing table", KPC(new_table), KPC(table));
} else if (OB_FAIL(tmp_tables.push_back(table))) { } else if (OB_FAIL(tmp_tables.push_back(table))) {
LOG_WARN("failed to add table", K(ret)); LOG_WARN("failed to add table", K(ret));
} }
@ -870,7 +870,7 @@ int ObTableStore::check_ready_for_read()
LOG_ERROR("Unexpected null table", K(ret), KP(table), K(i), K(PRETTY_TS(*this))); LOG_ERROR("Unexpected null table", K(ret), KP(table), K(i), K(PRETTY_TS(*this)));
} else if (!table->is_minor_sstable()) { } else if (!table->is_minor_sstable()) {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("table type not valid", K(ret), K(i), K(*table), K(PRETTY_TS(*this))); LOG_ERROR("table type not valid", K(ret), K(i), KPC(table), K(PRETTY_TS(*this)));
} else if (OB_ISNULL(last_table)) { } else if (OB_ISNULL(last_table)) {
} else if (table->get_start_log_ts() > last_table->get_end_log_ts()) { } else if (table->get_start_log_ts() > last_table->get_end_log_ts()) {
is_ready_for_read_ = false; is_ready_for_read_ = false;
@ -1001,7 +1001,7 @@ int ObTableStore::get_major_merge_tables(const ObGetMergeTablesParam &param, ObG
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
LOG_WARN("sstable with snapshot_version larger than next_major_freeze_ts should be empty", LOG_WARN("sstable with snapshot_version larger than next_major_freeze_ts should be empty",
K(ret), K(ret),
K(*base_table), KPC(base_table),
K(next_major_freeze_ts)); K(next_major_freeze_ts));
} else { } else {
result.create_sstable_for_large_snapshot_ = true; result.create_sstable_for_large_snapshot_ = true;
@ -1104,7 +1104,7 @@ int ObTableStore::add_minor_merge_result(ObITable *table, ObGetMergeTablesResult
result.log_ts_range_.end_log_ts_ = table->get_end_log_ts(); result.log_ts_range_.end_log_ts_ = table->get_end_log_ts();
result.log_ts_range_.max_log_ts_ = std::max(table->get_end_log_ts(), table->get_max_log_ts()); result.log_ts_range_.max_log_ts_ = std::max(table->get_end_log_ts(), table->get_max_log_ts());
if (OB_FAIL(result.handle_.add_table(table))) { if (OB_FAIL(result.handle_.add_table(table))) {
LOG_WARN("Failed to add table", K(*table), K(ret)); LOG_WARN("Failed to add table", KPC(table), K(ret));
} else { } else {
result.dump_memtable_timestamp_ = MAX(result.dump_memtable_timestamp_, table->get_timestamp()); result.dump_memtable_timestamp_ = MAX(result.dump_memtable_timestamp_, table->get_timestamp());
} }
@ -1134,7 +1134,7 @@ int ObTableStore::refine_mini_minor_merge_result(ObGetMergeTablesResult &result)
LOG_ERROR("Unexpected null table", KP(table), K(ret)); LOG_ERROR("Unexpected null table", KP(table), K(ret));
} else if (table->is_memtable() || table->is_major_sstable()) { } else if (table->is_memtable() || table->is_major_sstable()) {
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("Unexpected table type", K(*table), K(ret)); LOG_ERROR("Unexpected table type", KPC(table), K(ret));
} else if (FALSE_IT(sstable = reinterpret_cast<ObSSTable *>(table))) { } else if (FALSE_IT(sstable = reinterpret_cast<ObSSTable *>(table))) {
} else if (table->is_mini_minor_sstable()) { } else if (table->is_mini_minor_sstable()) {
mini_sstable_size += sstable->get_total_row_count(); mini_sstable_size += sstable->get_total_row_count();
@ -1724,7 +1724,7 @@ int ObTableStore::find_mini_minor_merge_tables(const ObGetMergeTablesParam &para
K(i), K(i),
"last_end_log_ts", "last_end_log_ts",
result.log_ts_range_.end_log_ts_, result.log_ts_range_.end_log_ts_,
K(*table)); KPC(table));
result.handle_.reset(); result.handle_.reset();
result.version_range_.reset(); result.version_range_.reset();
result.log_ts_range_.reset(); result.log_ts_range_.reset();
@ -1738,11 +1738,11 @@ int ObTableStore::find_mini_minor_merge_tables(const ObGetMergeTablesParam &para
K(i), K(i),
K(merge_type), K(merge_type),
K(max_snapshot_version), K(max_snapshot_version),
K(*table)); KPC(table));
break; break;
} }
} }
LOG_INFO("add candidate table", K(*table)); LOG_INFO("add candidate table", KPC(table));
if (OB_FAIL(add_minor_merge_result(table, result))) { if (OB_FAIL(add_minor_merge_result(table, result))) {
LOG_WARN("Failed to add table to minor merge result", K(ret)); LOG_WARN("Failed to add table to minor merge result", K(ret));
} }
@ -1848,9 +1848,9 @@ int ObTableStore::add_complement_to_mini_merge_result(ObGetMergeTablesResult &re
// the complement_minor_sstable is replayed sstable, skip data // the complement_minor_sstable is replayed sstable, skip data
FLOG_INFO("Ignore data of complement sstable during replay stage", KPC(complement_minor_sstable_)); FLOG_INFO("Ignore data of complement sstable during replay stage", KPC(complement_minor_sstable_));
} else if (OB_FAIL(tmp_handle.add_table(complement_minor_sstable_))) { } else if (OB_FAIL(tmp_handle.add_table(complement_minor_sstable_))) {
LOG_WARN("failed to add table", K(ret), K(result), K(*complement_minor_sstable_)); LOG_WARN("failed to add table", K(ret), K(result), KPC(complement_minor_sstable_));
} else if (OB_FAIL(tmp_handle.add_tables(result.handle_))) { } else if (OB_FAIL(tmp_handle.add_tables(result.handle_))) {
LOG_WARN("failed to add table", K(ret), K(result), K(*complement_minor_sstable_)); LOG_WARN("failed to add table", K(ret), K(result), KPC(complement_minor_sstable_));
} else if (OB_FAIL(result.handle_.assign(tmp_handle))) { } else if (OB_FAIL(result.handle_.assign(tmp_handle))) {
LOG_WARN("failed to assign result handle", K(ret), K(tmp_handle)); LOG_WARN("failed to assign result handle", K(ret), K(tmp_handle));
} }
@ -1884,7 +1884,7 @@ int ObTableStore::get_minor_schema_version(int64_t &schema_version)
ret = OB_SUCCESS; ret = OB_SUCCESS;
if (table_id_ == pkey_.get_table_id() && if (table_id_ == pkey_.get_table_id() &&
static_cast<ObSSTable *>(table)->get_meta().create_snapshot_version_ == table->get_snapshot_version()) { static_cast<ObSSTable *>(table)->get_meta().create_snapshot_version_ == table->get_snapshot_version()) {
LOG_INFO("skip global index major sstable", K(*table)); LOG_INFO("skip global index major sstable", KPC(table));
continue; continue;
} }
} }
@ -1893,7 +1893,7 @@ int ObTableStore::get_minor_schema_version(int64_t &schema_version)
} }
if (OB_SUCC(ret) && tmp_schema_version > schema_version) { if (OB_SUCC(ret) && tmp_schema_version > schema_version) {
schema_version = tmp_schema_version; schema_version = tmp_schema_version;
LOG_INFO("update minor schema_version", K(schema_version), K(*table)); LOG_INFO("update minor schema_version", K(schema_version), KPC(table));
} }
} }
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
@ -1930,7 +1930,7 @@ int ObTableStore::find_need_major_sstable(const common::ObIArray<ObITable *> &ma
if (major_tables.at(i)->get_snapshot_version() <= multi_version_start) { if (major_tables.at(i)->get_snapshot_version() <= multi_version_start) {
major_pos = i; major_pos = i;
major_table = major_tables.at(i); major_table = major_tables.at(i);
LOG_INFO("found first need major table", K(major_pos), K(multi_version_start), K(i), K(*major_table)); LOG_INFO("found first need major table", K(major_pos), K(multi_version_start), K(i), KPC(major_table));
break; break;
} }
} }
@ -1942,7 +1942,7 @@ int ObTableStore::find_need_major_sstable(const common::ObIArray<ObITable *> &ma
LOG_WARN("cannot find need major table, use oldest major table", LOG_WARN("cannot find need major table, use oldest major table",
K(major_pos), K(major_pos),
K(multi_version_start), K(multi_version_start),
K(*major_table)); KPC(major_table));
} }
} }
return ret; return ret;
@ -2015,7 +2015,7 @@ int ObTableStore::cal_mini_merge_inc_base_version(int64_t &inc_base_version)
K(inc_base_version), K(inc_base_version),
"new_inc_base_version", "new_inc_base_version",
first_memtable->get_base_version(), first_memtable->get_base_version(),
K(*first_memtable)); KPC(first_memtable));
inc_base_version = first_memtable->get_base_version(); inc_base_version = first_memtable->get_base_version();
} else if (first_memtable->get_snapshot_version() > inc_base_version) { } else if (first_memtable->get_snapshot_version() > inc_base_version) {
// use inc_base_version // use inc_base_version
@ -2023,7 +2023,7 @@ int ObTableStore::cal_mini_merge_inc_base_version(int64_t &inc_base_version)
LOG_INFO("Unexpected empty vertion range memtable", LOG_INFO("Unexpected empty vertion range memtable",
K(ret), K(ret),
K(inc_base_version), K(inc_base_version),
K(*first_memtable), KPC(first_memtable),
K(PRETTY_TS(*this))); K(PRETTY_TS(*this)));
} }
} }
@ -2261,7 +2261,7 @@ bool ObTableStore::ObITableLogTsRangeCompare::operator()(const ObITable *ltable,
} else { } else {
bret = false; bret = false;
tmp_ret = OB_ERR_UNEXPECTED; tmp_ret = OB_ERR_UNEXPECTED;
LOG_ERROR("table type not expected", K(tmp_ret), K(*ltable), K(*rtable)); LOG_ERROR("table type not expected", K(tmp_ret), KPC(ltable), KPC(rtable));
} }
} else { } else {
bret = ltable->get_snapshot_version() < rtable->get_snapshot_version(); bret = ltable->get_snapshot_version() < rtable->get_snapshot_version();
@ -2349,7 +2349,7 @@ int ObTableStore::need_remove_old_table(const ObVersion &kept_min_version, const
if (real_kept_major_num <= 0) { if (real_kept_major_num <= 0) {
real_kept_major_num = 1; real_kept_major_num = 1;
} }
LOG_INFO("need remove old table", K(real_kept_major_num), K(kept_min_version), K(*latest_major_sstable)); LOG_INFO("need remove old table", K(real_kept_major_num), K(kept_min_version), KPC(latest_major_sstable));
} }
} }
@ -2417,7 +2417,7 @@ int ObTableStore::update_replay_tables()
ret = OB_ERR_SYS; ret = OB_ERR_SYS;
LOG_ERROR("Unexpected memtable in table store", K(ret), K(i), KPC(table)); LOG_ERROR("Unexpected memtable in table store", K(ret), K(i), KPC(table));
} else if (OB_FAIL(replay_tables_.push_back(table->get_key()))) { } else if (OB_FAIL(replay_tables_.push_back(table->get_key()))) {
LOG_WARN("Failed to add table key", K(ret), K(*table)); LOG_WARN("Failed to add table key", K(ret), KPC(table));
} }
} }
} }