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

fix flt tag local variable err

Browse Source
This commit is contained in:
obdev 2023-07-14 02:12:33 +00:00 committed by ob-robot
parent 6ccb87449f
commit ffd0270234
50 changed files with 111 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
deps/oblib/src/lib/trace/ob_trace.h vendored
View File

@ -23,8 +23,8 @@
#define FLT_BEGIN_TRACE() (OBTRACE->begin())
#define FLT_END_TRACE() (OBTRACE->end())
#define FLT_BEGIN_SPAN(span_type) FLT_BEGIN_CHILD_SPAN(span_type)
#define FLT_BEGIN_CHILD_SPAN(span_type) (OBTRACE->begin_span(::oceanbase::trace::ObSpanType::span_type, GET_SPANLEVEL(::oceanbase::trace::ObSpanType::span_type), false))
#define FLT_BEGIN_FOLLOW_SPAN(span_type) (OBTRACE->begin_span(::oceanbase::trace::ObSpanType::span_type, GET_SPANLEVEL(::oceanbase::trace::ObSpanType::span_type), true))
#define FLT_BEGIN_CHILD_SPAN(span_type) (OBTRACE->begin_span(::oceanbase::trace::ObSpanType::flt_##span_type, GET_SPANLEVEL(::oceanbase::trace::ObSpanType::flt_##span_type), false))
#define FLT_BEGIN_FOLLOW_SPAN(span_type) (OBTRACE->begin_span(::oceanbase::trace::ObSpanType::flt_##span_type, GET_SPANLEVEL(::oceanbase::trace::ObSpanType::flt_##span_type), true))
#define FLT_END_SPAN(span) \
if (OB_NOT_NULL(span)) { \
OBTRACE->end_span(span); \
@ -34,18 +34,29 @@ if (OB_NOT_NULL(span)) { \
}
#define FLT_RESET_SPAN() (OBTRACE->reset_span())
#define FLT_END_CURRENT_SPAN() FLT_END_SPAN(OBTRACE->last_active_span_)
#define FLT_SET_TAG(...) (OBTRACE->set_tag(__VA_ARGS__))
#define FLT_SET_TAG2(key, value) OBTRACE->set_tag(flt_##key, value)
#define FLT_SET_TAG4(key, value, ...) OBTRACE->set_tag(flt_##key, value); FLT_SET_TAG2(__VA_ARGS__)
#define FLT_SET_TAG6(key, value, ...) OBTRACE->set_tag(flt_##key, value); FLT_SET_TAG4(__VA_ARGS__)
#define FLT_SET_TAG8(key, value, ...) OBTRACE->set_tag(flt_##key, value); FLT_SET_TAG6(__VA_ARGS__)
#define FLT_SET_TAG10(key, value, ...) OBTRACE->set_tag(flt_##key, value); FLT_SET_TAG8(__VA_ARGS__)
#define FLT_SET_TAG12(key, value, ...) OBTRACE->set_tag(flt_##key, value); FLT_SET_TAG10(__VA_ARGS__)
#define FLT_SET_TAG14(key, value, ...) OBTRACE->set_tag(flt_##key, value); FLT_SET_TAG12(__VA_ARGS__)
#define FLT_SET_TAG16(key, value, ...) OBTRACE->set_tag(flt_##key, value); FLT_SET_TAG14(__VA_ARGS__)
#define FLT_SET_TAG18(key, value, ...) OBTRACE->set_tag(flt_##key, value); FLT_SET_TAG16(__VA_ARGS__)
#define FLT_SET_TAG20(key, value, ...) OBTRACE->set_tag(flt_##key, value); FLT_SET_TAG18(__VA_ARGS__)
#define FLT_SET_TAG(...) CONCAT(FLT_SET_TAG, ARGS_NUM(__VA_ARGS__))(__VA_ARGS__)
#define FLT_SET_LOG()
#define FLT_SET_TRACE_LEVEL(level) (OBTRACE->set_level(level))
#define FLT_SET_AUTO_FLUSH(value) (OBTRACE->set_auto_flush(value))
#define FLT_RESTORE_DDL_TRACE_CTX(flt_ctx) (OBTRACE->init(flt_ctx))
#define FLT_RESTORE_DDL_SPAN(span_type, span_id, start_ts) (OBTRACE->begin_span_by_id(::oceanbase::trace::ObSpanType::span_type, GET_SPANLEVEL(::oceanbase::trace::ObSpanType::span_type), false, span_id, start_ts))
#define FLT_RESTORE_DDL_SPAN(span_type, span_id, start_ts) (OBTRACE->begin_span_by_id(::oceanbase::trace::ObSpanType::flt_##span_type, GET_SPANLEVEL(::oceanbase::trace::ObSpanType::flt_##span_type), false, span_id, start_ts))
#define FLT_RELEASE_DDL_SPAN(span) (OBTRACE->release_span(span))
#define FLUSH_TRACE() ::oceanbase::trace::flush_trace();
#define FLTSpanGuard(span_type) ::oceanbase::trace::__ObFLTSpanGuard __##span_type##__LINE__(::oceanbase::trace::ObSpanType::span_type, GET_SPANLEVEL(::oceanbase::trace::ObSpanType::span_type))
#define FLTSpanGuard(span_type) ::oceanbase::trace::__ObFLTSpanGuard __##span_type##__LINE__(::oceanbase::trace::ObSpanType::flt_##span_type, GET_SPANLEVEL(::oceanbase::trace::ObSpanType::flt_##span_type))
#define OBTRACE ::oceanbase::trace::ObTrace::get_instance()
@ -252,7 +263,7 @@ struct ObTrace
void end_span(ObSpanCtx* span_id);
void reset_span();
template <typename T, typename... Targs>
void set_tag(ObTagType tag_type, const T& value, Targs... Fargs)
void set_tag(ObTagType tag_type, const T& value)
{
if (trace_id_.is_inited()
&& OB_NOT_NULL(last_active_span_)
@ -261,7 +272,6 @@ struct ObTrace
FLUSH_TRACE();
IGNORE_RETURN append_tag(tag_type, value);
}
set_tag(std::forward<Targs>(Fargs)...);
}
}
int serialize(char* buf, const int64_t buf_len, int64_t& pos) const;

10
deps/oblib/src/lib/trace/ob_trace_def.h vendored
View File

@ -238,7 +238,7 @@ FLT_DEF_TAG(column_id, "place holder")
enum ObTagType
{
#define FLT_DEF_TAG(name, comment) name,
#define FLT_DEF_TAG(name, comment) flt_##name,
#define __HIGH_LEVEL_TAG
#define __MIDDLE_LEVEL_TAG
#define __LOW_LEVEL_TAG
@ -261,7 +261,7 @@ enum ObSpanType
#define __HIGH_LEVEL_SPAN
#define __MIDDLE_LEVEL_SPAN
#define __LOW_LEVEL_SPAN
#define FLT_DEF_SPAN(name, comment) name,
#define FLT_DEF_SPAN(name, comment) flt_##name,
#include "lib/trace/ob_trace_def.h"
#undef FLT_DEF_SPAN
#undef __LOW_LEVEL_SPAN
@ -306,7 +306,7 @@ class __SpanIdMapper {};
#define FLT_DEF_SPAN(ID, comment) \
template <> \
class __SpanIdMapper<ObSpanType::ID> \
class __SpanIdMapper<ObSpanType::flt_##ID> \
{ \
public: \
static constexpr uint8_t level = 1; \
@ -318,7 +318,7 @@ public: \
#define FLT_DEF_SPAN(ID, comment) \
template <> \
class __SpanIdMapper<ObSpanType::ID> \
class __SpanIdMapper<ObSpanType::flt_##ID> \
{ \
public: \
static constexpr uint8_t level = 2; \
@ -330,7 +330,7 @@ public: \
#define FLT_DEF_SPAN(ID, comment) \
template <> \
class __SpanIdMapper<ObSpanType::ID> \
class __SpanIdMapper<ObSpanType::flt_##ID> \
{ \
public: \
static constexpr uint8_t level = 3; \

4
deps/oblib/src/rpc/obrpc/ob_rpc_proxy.ipp vendored
View File

@ -49,7 +49,7 @@ int SSHandle<pcodeStruct>::get_more(typename pcodeStruct::Response &result)
ObReqTransport::Result r;
if (OB_ISNULL(transport_)) {
RPC_OBRPC_LOG(INFO, "transport_ is NULL, use poc_rpc", K(sess_id), K(has_more_));
RPC_OBRPC_LOG(INFO, "transport_ is NULL, use poc_rpc", K(has_more_));
const int64_t start_ts = common::ObTimeUtility::current_time();
int64_t src_tenant_id = ob_get_tenant_id();
auto &set = obrpc::ObRpcPacketSet::instance();
@ -186,7 +186,7 @@ int SSHandle<pcodeStruct>::abort()
ObReqTransport::Result r;
if (OB_ISNULL(transport_)) {
RPC_OBRPC_LOG(INFO, "transport_ is NULL, use poc_rpc", K(sess_id), K(has_more_));
RPC_OBRPC_LOG(INFO, "transport_ is NULL, use poc_rpc", K(has_more_));
const int64_t start_ts = common::ObTimeUtility::current_time();
int64_t src_tenant_id = ob_get_tenant_id();
auto &set = obrpc::ObRpcPacketSet::instance();

2
mittest/logservice/test_ob_simple_log_flashback.cpp
View File

@ -90,7 +90,7 @@ int ObLogFlashbackService::BaseLSOperator::update_leader_()
log_service = MTL(logservice::ObLogService*);
palf::PalfHandleGuard palf_handle;
if (OB_FAIL(log_service->open_palf(ls_id_, palf_handle))) {
CLOG_LOG(ERROR, "open_palf failed", K(ret), K(ls_id));
CLOG_LOG(ERROR, "open_palf failed", K(ret), K_(ls_id));
} else {
palf::PalfHandleImpl *palf_handle_impl = dynamic_cast<palf::PalfHandleImpl*>(palf_handle.palf_handle_.palf_handle_impl_);
leader_ = palf_handle_impl->state_mgr_.get_leader();

2
mittest/logservice/test_ob_simple_log_flashback_arb.cpp
View File

@ -90,7 +90,7 @@ int ObLogFlashbackService::BaseLSOperator::update_leader_()
log_service = MTL(logservice::ObLogService*);
palf::PalfHandleGuard palf_handle;
if (OB_FAIL(log_service->open_palf(ls_id_, palf_handle))) {
CLOG_LOG(ERROR, "open_palf failed", K(ret), K(ls_id));
CLOG_LOG(ERROR, "open_palf failed", K(ret), K_(ls_id));
} else {
palf::PalfHandleImpl *palf_handle_impl = dynamic_cast<palf::PalfHandleImpl*>(palf_handle.palf_handle_.palf_handle_impl_);
leader_ = palf_handle_impl->state_mgr_.get_leader();

4
mittest/mtlenv/storage/test_tablet_status_cache.cpp
View File

@ -141,7 +141,7 @@ int TestTabletStatusCache::create_tablet(
LOG_WARN("failed to build table schema");
} else if (OB_FAIL(TestTabletHelper::create_tablet(ls_handle, tablet_id, table_schema, allocator_,
ObTabletStatus::Status::NORMAL, create_commit_scn))) {
LOG_WARN("failed to create tablet", K(ret), K(ls_id), K(tablet_id), K(create_commit_scn));
LOG_WARN("failed to create tablet", K(ret), K(ls->get_ls_id()), K(tablet_id), K(create_commit_scn));
} else if (OB_FAIL(ls->get_tablet(tablet_id, tablet_handle))) {
LOG_WARN("failed to get tablet", K(ret));
} else if (OB_FAIL(tablet_handle.get_obj()->inner_get_mds_table(mds_table, true/*not_exist_create*/))) {
@ -547,7 +547,7 @@ TEST_F(TestTabletStatusCache, get_empty_result_tablet)
LOG_WARN("failed to build table schema");
} else if (OB_FAIL(TestTabletHelper::create_tablet(ls_handle, tablet_id, table_schema, allocator_,
ObTabletStatus::Status::MAX, share::SCN::min_scn()))) {
LOG_WARN("failed to create tablet", K(ret), K(ls_id), K(tablet_id));
LOG_WARN("failed to create tablet", K(ret), K(ls->get_ls_id()), K(tablet_id));
}
ASSERT_EQ(OB_SUCCESS, ret);

1
mittest/simple_server/test_arbitration_service_replica_task_table_operator.cpp
View File

@ -248,6 +248,7 @@ TEST_F(TestArbitrationServiceReplicaTaskTableOperator, test_operator)
ObString comment("generated for arbitraiton service");
bool lock_line = true;
bool equal = false;
int64_t task_id = 1;
ObArbitrationServiceReplicaTaskInfo arbitration_service_replica_task_info;
ret = arbitration_service_replica_task_info.build(
create_time_us, sys_tenant_id, sys_ls_id, task_id, task_type, trace_id,

6
src/logservice/libobcdc/src/ob_log_committer.cpp
View File

@ -1136,9 +1136,9 @@ int ObLogCommitter::update_tenant_trans_commit_version_(const PartTransTask &par
if (OB_UNLIKELY(! tls_id.is_valid())) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("invalid tenant_ls_id for checkpoint_task", KR(ret), K(participants));
} else if (OB_UNLIKELY(OB_INVALID_VERSION == commit_version)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("invalid commit_version", KR(ret), K(participants));
// } else if (OB_UNLIKELY(OB_INVALID_VERSION == commit_version)) {
// ret = OB_ERR_UNEXPECTED;
// LOG_ERROR("invalid commit_version", KR(ret), K(participants));
} else {
ObLogTenantGuard guard;
ObLogTenant *tenant = NULL;

2
src/logservice/libobcdc/src/ob_log_formatter.cpp
View File

@ -1220,7 +1220,7 @@ int ObLogFormatter::group_udt_column_values_(
*obj2str_helper_,
ob_ctx_cols,
cv))) {
LOG_ERROR("build udt value failed", KR(ret), K(column_id), K(column_schema_info));
LOG_ERROR("build udt value failed", KR(ret), K(column_schema_info.get_column_id()), K(column_schema_info));
}
return ret;
}

2
src/logservice/libobcdc/src/ob_log_schema_cache_info.cpp
View File

@ -797,7 +797,7 @@ int TableSchemaInfo::get_column_schema_info(
LOG_ERROR("invalid argument", KR(ret), K(column_idx), K(column_stored_idx), K(is_column_stored_idx), KPC(this));
} else if (OB_ISNULL(column_schema_info = &column_schema_array_[column_stored_idx])) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("column_schema_info is null", KR(ret), K(column_id), K(column_stored_idx), K(is_column_stored_idx), KPC(this));
LOG_ERROR("column_schema_info is null", KR(ret), K(column_idx), K(column_stored_idx), K(is_column_stored_idx), KPC(this));
} else {
}

3
src/logservice/ob_garbage_collector.cpp
View File

@ -656,6 +656,7 @@ int ObGCHandler::try_check_and_set_wait_gc_when_log_archive_is_off_(
const uint64_t tenant_id = MTL_ID();
int tmp_ret = OB_SUCCESS;
bool is_tenant_dropping_or_dropped = false;
ObLSID ls_id = ls_->get_ls_id();
if (OB_SUCCESS != (tmp_ret = check_if_tenant_is_dropping_or_dropped_(tenant_id, is_tenant_dropping_or_dropped))) {
CLOG_LOG(WARN, "check_if_tenant_has_been_dropped_ failed", K(tmp_ret), K(tenant_id), K(ls_id));
@ -981,7 +982,7 @@ int ObGCHandler::diagnose(GCDiagnoseInfo &diagnose_info) const
} else {
RLockGuard wlock_guard(rwlock_);
if (OB_FAIL(ls_->get_gc_state(diagnose_info.gc_state_))) {
CLOG_LOG(WARN, "get_gc_state failed", K(ls_id));
CLOG_LOG(WARN, "get_gc_state failed", K(ls_->get_ls_id()));
} else {
diagnose_info.gc_start_ts_ = gc_start_ts_;
}

12
src/logservice/ob_log_flashback_service.cpp
View File

@ -178,12 +178,12 @@ int ObLogFlashbackService::wait_all_ls_replicas_log_sync_(
int tmp_ret = OB_SUCCESS;
if (OB_SUCCESS == op.ret_) {
} else if (OB_SUCCESS != (tmp_ret = failed_ls_ops.push_back(op))) {
CLOG_LOG(WARN, "push_back failed", K(ret), K_(self), K(ls_id));
CLOG_LOG(WARN, "push_back failed", K(ret), K_(self), K(op));
}
}
LOG_USER_ERROR(OB_OP_NOT_ALLOW, "logs of some replicas may be not sync, check these replicas");
CLOG_LOG(WARN, "logs of some replicas may be not sync, check these replicas", K(ret),
K_(self), K(ls_id), K(failed_ls_ops));
K_(self), K(failed_ls_ops));
}
}
#undef COMMON_LOG_INFO
@ -271,12 +271,12 @@ int ObLogFlashbackService::do_flashback_(
int tmp_ret = OB_SUCCESS;
if (OB_SUCCESS == op.ret_) {
} else if (OB_SUCCESS != (tmp_ret = failed_ls_ops.push_back(op))) {
CLOG_LOG(WARN, "push_back failed", K(ret), K_(self), K(ls_id));
CLOG_LOG(WARN, "push_back failed", K(ret), K_(self), K(op));
}
}
LOG_USER_ERROR(OB_OP_NOT_ALLOW, "logs of some replicas may have not been flashbacked, check these replicas");
CLOG_LOG(WARN, "logs of some replicas may have not been flashbacked, check these replicas",
K(ret), K_(self), K(ls_id), K(failed_ls_ops));
K(ret), K_(self), K(failed_ls_ops));
}
}
#undef COMMON_LOG_INFO
@ -319,9 +319,9 @@ int ObLogFlashbackService::cast_ls_operator_list_(
DST_T op(src_array.at(i));
if (false == op.is_valid()) {
ret = OB_ERR_UNEXPECTED;
CLOG_LOG(WARN, "FlashbackService Operator invalid", K(ret), K_(self), K(ls_id), K(op));
CLOG_LOG(WARN, "FlashbackService Operator invalid", K(ret), K_(self), K(op));
} else if (OB_FAIL(dst_array.push_back(op))) {
CLOG_LOG(WARN, "push_back failed", K(ret), K_(self), K(ls_id));
CLOG_LOG(WARN, "push_back failed", K(ret), K_(self));
}
}
return ret;

2
src/observer/table_load/ob_table_load_partition_location.cpp
View File

@ -228,7 +228,7 @@ int ObTableLoadPartitionLocation::init_all_partition_location(
{
int ret = OB_SUCCESS;
if (OB_FAIL(fetch_ls_locations(tenant_id, partition_ids))) {
LOG_WARN("fail to fetch locations", KR(ret), K(tenant_id), K(table_id));
LOG_WARN("fail to fetch locations", KR(ret), K(tenant_id));
}
return ret;
}

2
src/observer/virtual_table/ob_all_virtual_tx_lock_stat.cpp
View File

@ -77,7 +77,7 @@ int ObGVTxLockStat::get_next_tx_lock_stat_(ObTxLockStat &tx_lock_stat)
} else {
tx_lock_stat_iter_.reset();
if (OB_FAIL(txs_->iterate_tx_lock_stat(ls_id_, tx_lock_stat_iter_))) {
TRANS_LOG(WARN, "iterate_tx_lock_stat error", K(ret), K(ls_id));
TRANS_LOG(WARN, "iterate_tx_lock_stat error", K(ret), K(ls_id_));
} else if (OB_FAIL(tx_lock_stat_iter_.set_ready())) {
TRANS_LOG(WARN, "iterate_tx_lock_stat set ready error", KR(ret));
}

2
src/rootserver/ddl_task/ob_ddl_scheduler.cpp
View File

@ -449,7 +449,7 @@ int ObRedefCallback::modify_info(ObTableRedefinitionTask &redef_task,
if (OB_ENTRY_NOT_EXIST == ret) {
bool exist = false;
if (OB_FAIL(ObDDLTaskRecordOperator::check_task_id_exist(*GCTX.sql_proxy_, redef_task.get_tenant_id(), redef_task.get_task_id(), exist))) {
LOG_WARN("check task id exist fail", K(ret), K(redef_task.get_tenant_id()), K(task_id));
LOG_WARN("check task id exist fail", K(ret), K(redef_task.get_tenant_id()));
} else {
if (exist) {
ret = OB_EAGAIN;

2
src/rootserver/freeze/ob_checksum_validator.cpp
View File

@ -393,7 +393,7 @@ int ObTabletChecksumValidator::check_table_compaction_info(
} else if ((tablet_status != ObTabletCompactionStatus::COMPACTED)
&& (tablet_status != ObTabletCompactionStatus::CAN_SKIP_VERIFYING)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected tablet status", KR(ret), K(tablet_status), K(table_id));
LOG_WARN("unexpected tablet status", KR(ret), K(tablet_status), K(tablet_ids.at(idx)));
} else if (tablet_status == ObTabletCompactionStatus::CAN_SKIP_VERIFYING) {
exist_skip_verifying_tablet = true;
}

6
src/rootserver/ob_ddl_service.cpp
View File

@ -16915,7 +16915,7 @@ int ObDDLService::new_truncate_table_in_trans(const ObIArray<const ObTableSchema
if (OB_INVALID_ID != task_id) {
int tmp_ret = schema_service_->get_ddl_trans_controller().remove_task(task_id);
if (OB_SUCCESS != tmp_ret) {
LOG_WARN("remove_task fail", KR(ret), KR(tmp_ret), K(tenant_id), K(table_id), K(task_id));
LOG_WARN("remove_task fail", KR(ret), KR(tmp_ret), K(tenant_id), K(task_id));
}
}
int64_t trans_end = ObTimeUtility::current_time();
@ -32076,7 +32076,7 @@ int ObDDLSQLTransaction::lock_all_ddl_operation(
if (OB_FAIL(ObInnerConnectionLockUtil::lock_obj(tenant_id,
lock_arg,
conn))) {
LOG_WARN("lock table failed", KR(ret), K(table_id), K(tenant_id));
LOG_WARN("lock table failed", KR(ret), K(tenant_id));
}
} else {
uint64_t compat_version = 0;
@ -32097,7 +32097,7 @@ int ObDDLSQLTransaction::lock_all_ddl_operation(
if (OB_FAIL(ObInnerConnectionLockUtil::lock_obj(tenant_id,
lock_arg,
conn))) {
LOG_WARN("lock table failed", KR(ret), K(table_id), K(tenant_id));
LOG_WARN("lock table failed", KR(ret), K(tenant_id));
} else if (OB_FAIL(schema_service_->get_ddl_trans_controller().set_enable_ddl_trans_new_lock(tenant_id))) {
LOG_WARN("set enable_ddl_lock_obj failed", K(ret), K(tenant_id));
}

2
src/rootserver/ob_ls_balance_helper.cpp
View File

@ -841,7 +841,7 @@ int ObLSBalanceTaskHelper::construct_ls_merge_task_(
dest_ls_id,
part_list))) {
LOG_WARN("failed to init task", KR(ret), K(tenant_id_), K(job_),
K(task_id), K(task_type), K(ls_id), K(part_list));
K(task_id), K(task_type), K(dest_ls_id), K(src_ls_id), K(part_list));
} else if (OB_FAIL(task_array_.push_back(task))) {
LOG_WARN("failed to push back task", KR(ret), K(task));
}

4
src/rootserver/ob_ls_recovery_stat_handler.cpp
View File

@ -158,7 +158,7 @@ int ObLSRecoveryStatHandler::get_ls_level_recovery_stat(ObLSRecoveryStat &ls_rec
ret = OB_INVALID_ARGUMENT;
LOG_WARN("pointer is null", KR(ret), KP(ls_svr));
} else if (OB_FAIL(ls_svr->get_palf_role(ls_->get_ls_id(), role, first_proposal_id))) {
LOG_WARN("failed to get first role", KR(ret), K(ls_id), KPC_(ls));
LOG_WARN("failed to get first role", KR(ret), K(ls_->get_ls_id()), KPC_(ls));
} else if (!is_strong_leader(role)) {
ret = OB_NOT_MASTER;
LOG_TRACE("not leader", KR(ret), K(role), KPC_(ls));
@ -499,7 +499,7 @@ int ObLSRecoveryStatHandler::calc_majority_min_readable_scn_(
majority_min_readable_scn = readable_scn_list.at(i);
}
}
LOG_TRACE("calculate majority min readable_scn finished", KR(ret), K(leader_readable_scn), K(ls_id),
LOG_TRACE("calculate majority min readable_scn finished", KR(ret), K(leader_readable_scn),
K(majority_min_readable_scn), K(readable_scn_list), K(majority_cnt), K(return_code_array));
}
}

2
src/rootserver/ob_ls_service_helper.cpp
View File

@ -252,7 +252,7 @@ int ObLSServiceHelper::construct_ls_status_machine(
status_info.status_, OB_LS_OP_TENANT_DROP, SCN::base_scn()))) {
LOG_WARN("failed to mock ls info", KR(ret), K(status_info));
} else if (OB_FAIL(status_machine.init(SYS_LS, status_info, ls_info))) {
LOG_WARN("failed to init status machine", KR(ret), K(ls_id), K(status_info), K(ls_info));
LOG_WARN("failed to init status machine", KR(ret), K(ls_info.get_ls_id()), K(status_info), K(ls_info));
} else if (OB_FAIL(status_machine_array.push_back(status_machine))) {
LOG_WARN("failed to push back status machine", KR(ret), K(status_machine));
}

4
src/share/ob_global_autoinc_service.cpp
View File

@ -206,13 +206,13 @@ int ObGlobalAutoIncService::handle_next_autoinc_request(
request.base_value_, desired_count, request.max_value_)))) {
OZ(fetch_next_node_(request, cache_node));
} else if (OB_UNLIKELY(request_version > cache_node.autoinc_version_)) {
LOG_INFO("start to reset old global table node", K(tenant_id), K(table_id),
LOG_INFO("start to reset old global table node", K(tenant_id), K(key.table_id_),
K(request_version), K(cache_node.autoinc_version_));
cache_node.reset();
OZ(fetch_next_node_(request, cache_node));
} else if (OB_UNLIKELY(request_version < cache_node.autoinc_version_)) {
ret = OB_AUTOINC_CACHE_NOT_EQUAL;
LOG_WARN("request autoinc_version is less than autoinc_version_ in table_node, it should retry", KR(ret), K(tenant_id), K(table_id),
LOG_WARN("request autoinc_version is less than autoinc_version_ in table_node, it should retry", KR(ret), K(tenant_id), K(key.table_id_),
K(request_version), K(cache_node.autoinc_version_));
}
if (OB_SUCC(ret)) {

1
src/share/schema/ob_schema_retrieve_utils.ipp
View File

@ -4348,6 +4348,7 @@ int ObSchemaRetrieveUtils::fill_base_part_info(
// bugfix: issue/48579037
// In 4.x, tablegroup_id/table_id is in the same scope, so we can distinguish table and tablegroup based on object_id.
bool is_oracle_mode = false;
const uint64_t table_id = partition.get_table_id();
if (is_sys_tablegroup_id(table_id)) {
is_oracle_mode = false;
} else if (OB_FAIL(ObCompatModeGetter::check_is_oracle_mode_with_table_id(

2
src/share/schema/ob_schema_service_sql_impl.cpp
View File

@ -3051,7 +3051,7 @@ int ObSchemaServiceSQLImpl::sql_append_ids_and_truncate_version(
for (int64_t i = 0; OB_SUCC(ret) && i < ids_size; ++i) {
if (ids[i].truncate_version_ > schema_version) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("truncate version can not bigger than schema version", KR(ret), K(table_id), K(ids[i].truncate_version_), K(schema_version));
LOG_WARN("truncate version can not bigger than schema version", KR(ret), K(ids[i].table_id_), K(ids[i].truncate_version_), K(schema_version));
} else if (OB_FAIL(sql.append_fmt("%s(table_id = %lu AND schema_version >= %ld)", 0 == i ? "" : "OR ",
fill_extract_schema_id(schema_status, ids[i].table_id_),
ids[i].truncate_version_))) {

2
src/sql/engine/cmd/ob_ddl_executor_util.cpp
View File

@ -128,7 +128,7 @@ int ObDDLExecutorUtil::wait_build_index_finish(const uint64_t tenant_id, const i
THIS_WORKER.set_timeout_ts(ObTimeUtility::current_time() + OB_MAX_USER_SPECIFIED_TIMEOUT);
share::ObDDLErrorMessageTableOperator::ObBuildDDLErrorMessage error_message;
is_finish = false;
LOG_INFO("wait build index finish", K(table_id), K(task_id));
LOG_INFO("wait build index finish", K(task_id));
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || task_id <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(ret), K(tenant_id), K(task_id));

2
src/sql/optimizer/ob_access_path_estimation.cpp
View File

@ -1259,7 +1259,7 @@ int ObAccessPathEstimation::gen_agent_vt_table_convert_info(const uint64_t vt_ta
const ObColumnSchemaV2 *col_schema = real_index_schema->get_column_schema_by_idx(j);
if (OB_ISNULL(col_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("column schema is null", K(ret), K(column_id));
LOG_WARN("column schema is null", K(ret), K(j));
} else if (0 == col_schema->get_column_name_str().case_compare(vt_col_schema->get_column_name_str())) {
find_it = true;
ObObjMeta obj_meta;

4
src/sql/optimizer/ob_dynamic_sampling.h
View File

@ -36,7 +36,7 @@ struct ObDSFailTabInfo
uint64_t table_id_;
ObSEArray<int64_t, 1, common::ModulePageAllocator, true> part_ids_;
TO_STRING_KV(K(table_id_),
K(partition_id));
K(part_ids_));
};
struct ObDSTableParam
@ -428,4 +428,4 @@ private:
} // end of namespace common
} // end of namespace oceanbase
#endif /* _OB_DYNAMIC_SAMPLING_H_ */
#endif /* _OB_DYNAMIC_SAMPLING_H_ */

2
src/sql/optimizer/ob_log_plan.cpp
View File

@ -13811,7 +13811,7 @@ int ObLogPlan::perform_gather_stat_replace(ObLogicalOperator *op)
if (NULL != (table_scan = dynamic_cast<ObLogTableScan *>(op))) {
ObOpPseudoColumnRawExpr *partition_id_expr = nullptr;
if (OB_FAIL(table_scan->generate_pseudo_partition_id_expr(partition_id_expr))) {
LOG_WARN("fail allocate part id expr", K(table_id), K(ret));
LOG_WARN("fail allocate part id expr", K(ret));
} else {
stat_partition_id_expr_ = partition_id_expr;
stat_table_scan_ = table_scan;

2
src/storage/backup/ob_backup_extern_info_mgr.cpp
View File

@ -724,7 +724,7 @@ int ObExternBackupInfoIdGetter::init(const share::ObBackupDest &backup_set_dest)
LOG_WARN("ls meta info id getter init twice", K(ret));
} else if (!backup_set_dest.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(backup_set_dest), K(ls_id));
LOG_WARN("invalid argument", K(ret), K(backup_set_dest));
} else if (OB_FAIL(backup_set_dest_.deep_copy(backup_set_dest))) {
LOG_WARN("failed to deep copy backup set dest", K(ret));
} else {

10
src/storage/backup/ob_backup_operator.cpp
View File

@ -282,7 +282,7 @@ int ObLSBackupOperator::get_all_backup_ls_id(const uint64_t tenant_id, const int
ObSqlString sql;
if (OB_INVALID_ID == tenant_id || task_id < 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get invalid args", K(ret), K(task_id), K(tenant_id), K(ls_id));
LOG_WARN("get invalid args", K(ret), K(task_id), K(tenant_id));
} else if (OB_FAIL(construct_query_backup_sql_(tenant_id, task_id, sql))) {
LOG_WARN("failed to construct query backup sql", K(ret), K(tenant_id), K(task_id));
} else if (OB_FAIL(get_distinct_ls_id_(tenant_id, sql, ls_array, sql_client))) {
@ -299,9 +299,9 @@ int ObLSBackupOperator::get_all_archive_ls_id(const uint64_t tenant_id, const in
ObSqlString sql;
int64_t start_piece_id = 0;
int64_t end_piece_id = 0;
if (OB_INVALID_ID == tenant_id || task_id < 0) {
if (OB_INVALID_ID == tenant_id || dest_id < 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get invalid args", K(ret), K(task_id), K(tenant_id), K(ls_id));
LOG_WARN("get invalid args", K(ret), K(tenant_id));
} else if (OB_FAIL(get_start_piece_id_(tenant_id, dest_id, start_scn, sql_client, start_piece_id))) {
LOG_WARN("failed to get start piece id", K(ret), K(tenant_id), K(dest_id), K(start_scn));
} else if (OB_FAIL(get_end_piece_id_(tenant_id, dest_id, end_scn, sql_client, end_piece_id))) {
@ -529,7 +529,7 @@ int ObLSBackupOperator::get_start_piece_id_(const uint64_t tenant_id, const uint
"AND start_scn <= %ld ORDER BY piece_id DESC LIMIT 1";
if (OB_INVALID_ID == tenant_id || dest_id < 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get invalid args", K(ret), K(dest_id), K(tenant_id), K(ls_id));
LOG_WARN("get invalid args", K(ret), K(dest_id), K(tenant_id));
} else if (OB_FAIL(sql.append_fmt(sql_str, OB_ALL_LS_LOG_ARCHIVE_PROGRESS_TNAME,
tenant_id, dest_id, start_scn.get_val_for_inner_table_field()))) {
LOG_WARN("failed to append sql", K(ret), K(sql_str), K(tenant_id), K(dest_id));
@ -550,7 +550,7 @@ int ObLSBackupOperator::get_end_piece_id_(const uint64_t tenant_id, const uint64
"AND checkpoint_scn >= %ld ORDER BY piece_id ASC LIMIT 1";
if (OB_INVALID_ID == tenant_id || dest_id < 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get invalid args", K(ret), K(dest_id), K(tenant_id), K(ls_id));
LOG_WARN("get invalid args", K(ret), K(dest_id), K(tenant_id));
} else if (OB_FAIL(sql.append_fmt(sql_str, OB_ALL_LS_LOG_ARCHIVE_PROGRESS_TNAME,
tenant_id, dest_id, checkpoint_scn.get_val_for_inner_table_field()))) {
LOG_WARN("failed to append sql", K(ret), K(sql_str), K(tenant_id), K(dest_id));

2
src/storage/backup/ob_backup_task.cpp
View File

@ -2399,7 +2399,7 @@ int ObPrefetchBackupInfoTask::generate_next_prefetch_dag_()
LOG_WARN("may exist same dag", K(ret));
}
} else {
LOG_INFO("success to alloc next prefetch dag", K(ret), K(task_id), K_(param));
LOG_INFO("success to alloc next prefetch dag", K(ret), K(prefetch_task_id), K_(param));
}
if (OB_FAIL(ret) && OB_NOT_NULL(scheduler) && OB_NOT_NULL(child_dag)) {
scheduler->free_dag(*child_dag);

2
src/storage/compaction/ob_medium_compaction_func.cpp
View File

@ -343,7 +343,7 @@ int ObMediumCompactionScheduleFunc::get_max_reserved_snapshot(int64_t &max_reser
} else if (FALSE_IT(max_merged_snapshot = wrapper.get_member()->get_major_sstables().get_boundary_table(true/*last*/)->get_snapshot_version())) {
} else if (OB_FAIL(MTL(ObTenantFreezeInfoMgr*)->get_min_reserved_snapshot(
tablet->get_tablet_meta().tablet_id_, max_merged_snapshot, min_reserved_snapshot))) {
LOG_WARN("failed to get multi version from freeze info mgr", K(ret), K(table_id));
LOG_WARN("failed to get multi version from freeze info mgr", K(ret), K(tablet->get_tablet_meta().tablet_id_));
} else {
max_reserved_snapshot = MAX(ls_.get_min_reserved_snapshot(), min_reserved_snapshot);
}

2
src/storage/high_availability/ob_storage_ha_src_provider.cpp
View File

@ -43,7 +43,7 @@ int ObStorageHASrcProvider::init(const uint64_t tenant_id, const ObMigrationOpTy
} else if (OB_INVALID_ID == tenant_id || OB_ISNULL(storage_rpc)
|| type < ObMigrationOpType::ADD_LS_OP || type >= ObMigrationOpType::MAX_LS_OP) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("get invalid argument", K(ret), K(tenant_id), K(ls_id), K(type), KP(storage_rpc));
LOG_WARN("get invalid argument", K(ret), K(tenant_id), K(type), KP(storage_rpc));
} else {
tenant_id_ = tenant_id;
type_ = type;

6
src/storage/lob/ob_lob_locator.cpp
View File

@ -305,13 +305,13 @@ int ObLobLocatorHelper::fuse_mem_lob_header(ObObj &def_obj, uint64_t col_id, boo
payload_size,
0,
false))) {
STORAGE_LOG(WARN, "Lob: init locator in build_lob_locatorv2", K(ret), K(column_id));
STORAGE_LOG(WARN, "Lob: init locator in build_lob_locatorv2", K(ret), K(col_id));
} else if (OB_FAIL(locator.set_payload_data(&lob_common, def_obj.get_string()))) {
} else if (has_extern) {
ObMemLobTxInfo tx_info(snapshot_version_, tx_id_, scn_);
ObMemLobLocationInfo location_info(tablet_id_, ls_id_, def_obj.get_collation_type());
if (OB_FAIL(locator.set_table_info(table_id_, column_id))) { // ToDo: @gehao should be column idx
STORAGE_LOG(WARN, "Lob: set table info failed", K(ret), K(table_id_), K(column_id));
if (OB_FAIL(locator.set_table_info(table_id_, col_id))) { // ToDo: @gehao should be column idx
STORAGE_LOG(WARN, "Lob: set table info failed", K(ret), K(table_id_), K(col_id));
} else if (extern_flags.has_tx_info_ && OB_FAIL(locator.set_tx_info(tx_info))) {
STORAGE_LOG(WARN, "Lob: set transaction info failed", K(ret), K(tx_info));
} else if (extern_flags.has_location_info_ && OB_FAIL(locator.set_location_info(location_info))) {

24
src/storage/ls/ob_freezer.cpp
View File

@ -555,7 +555,7 @@ void ObFreezer::submit_checkpoint_task()
do {
if (OB_FAIL(get_ls_data_checkpoint()->ls_freeze(SCN::max_scn()))) {
TRANS_LOG(WARN, "[Freezer] data_checkpoint freeze failed", K(ret), K(ls_id));
TRANS_LOG(WARN, "[Freezer] data_checkpoint freeze failed", K(ret));
stat_.add_diagnose_info("data_checkpoint freeze failed");
ob_usleep(100);
}
@ -872,10 +872,10 @@ int ObFreezer::try_wait_memtable_ready_for_flush_with_ls_lock(memtable::ObMemtab
if (TC_REACH_TIME_INTERVAL(5 * 1000 * 1000)) {
if (need_resubmit_log()) {
submit_log_for_freeze();
TRANS_LOG(INFO, "[Freezer] resubmit log", K(ls_id), K(cost_time));
TRANS_LOG(INFO, "[Freezer] resubmit log", K(cost_time));
}
TRANS_LOG(WARN, "[Freezer] ready_for_flush costs too much time",
K(ls_id), K(cost_time), KPC(memtable));
K(cost_time), KPC(memtable));
stat_.add_diagnose_info("ready_for_flush costs too much time");
}
}
@ -1053,27 +1053,27 @@ int ObFreezer::batch_tablet_freeze_(const ObIArray<ObTabletID> &tablet_ids, ObFu
handle,
ObTabletCommon::DEFAULT_GET_TABLET_NO_WAIT,
ObMDSGetTabletMode::READ_WITHOUT_CHECK))) {
TRANS_LOG(WARN, "[Freezer] fail to get tablet", K(ret), K(ls_id), K(tablet_id));
TRANS_LOG(WARN, "[Freezer] fail to get tablet", K(ret), K(tablet_id));
stat_.add_diagnose_info("fail to get tablet");
} else if (FALSE_IT(tablet = handle.get_obj())) {
} else if (OB_ISNULL(memtable_mgr = static_cast<ObTabletMemtableMgr*>(tablet->get_memtable_mgr()))) {
TRANS_LOG(WARN, "[Freezer] tablet_memtable_mgr is null", K(ret), K(ls_id), K(tablet_id));
TRANS_LOG(WARN, "[Freezer] tablet_memtable_mgr is null", K(ret), K(tablet_id));
} else if (OB_FAIL(memtable_mgr->set_is_tablet_freeze_for_active_memtable(frozen_memtable_handle))) {
if (ret == OB_ENTRY_NOT_EXIST) {
ret = OB_SUCCESS;
TRANS_LOG(INFO, "[Freezer] no need to freeze since there is no active memtable", K(ret),
K(ls_id), K(tablet_id));
K(tablet_id));
stat_.add_diagnose_info("no need to freeze since there is no active memtable");
} else {
TRANS_LOG(WARN, "[Freezer] fail to set is_tablet_freeze", K(ret), K(ls_id), K(tablet_id));
TRANS_LOG(WARN, "[Freezer] fail to set is_tablet_freeze", K(ret), K(tablet_id));
stat_.add_diagnose_info("fail to set is_tablet_freeze");
}
} else if (!frozen_memtable_handle.is_valid()) {
ret = OB_ERR_UNEXPECTED;
TRANS_LOG(WARN, "[Freezer] frozen_memtable_handle is invalid", K(ret), K(ls_id), K(tablet_id));
TRANS_LOG(WARN, "[Freezer] frozen_memtable_handle is invalid", K(ret), K(tablet_id));
stat_.add_diagnose_info("frozen_memtable_handle is invalid");
} else if (OB_FAIL(memtable_handles.push_back(frozen_memtable_handle))) {
TRANS_LOG(WARN, "[Freezer] fail to push_back", K(ret), K(ls_id), K(tablet_id));
TRANS_LOG(WARN, "[Freezer] fail to push_back", K(ret), K(tablet_id));
stat_.add_diagnose_info("fail to push_back");
}
}
@ -1081,13 +1081,13 @@ int ObFreezer::batch_tablet_freeze_(const ObIArray<ObTabletID> &tablet_ids, ObFu
if (OB_FAIL(ret)) {
} else if (0 == memtable_handles.count()) {
need_freeze = false;
TRANS_LOG(INFO, "[Freezer] no need to freeze batch tablets", K(ret), K(ls_id), K(tablet_ids));
TRANS_LOG(INFO, "[Freezer] no need to freeze batch tablets", K(ret), K(tablet_ids));
stat_.add_diagnose_info("no need to freeze batch tablets");
} else if (FALSE_IT(submit_log_for_freeze())) {
} else if (OB_FAIL(submit_batch_tablet_freeze_task(memtable_handles, result))) {
TRANS_LOG(WARN, "[Freezer] fail to submit batch_tablet_freeze task", K(ret));
} else {
TRANS_LOG(INFO, "[Freezer] succeed to start batch_tablet_freeze task", K(ret), K(ls_id), K(tablet_ids));
TRANS_LOG(INFO, "[Freezer] succeed to start batch_tablet_freeze task", K(ret), K(tablet_ids));
}
return ret;
@ -1675,7 +1675,7 @@ void ObFreezer::print_freezer_statistics()
{
// print every 10s
if (REACH_TIME_INTERVAL(10 * 1000 * 1000)) {
TRANS_LOG(INFO, "[Freezer] empty table statistics: ", K(ls_id), K(get_empty_memtable_cnt()));
TRANS_LOG(INFO, "[Freezer] empty table statistics: ", K(get_ls_id()), K(get_empty_memtable_cnt()));
clear_empty_memtable_cnt();
}
}

4
src/storage/ls/ob_ls.cpp
View File

@ -1990,14 +1990,14 @@ int ObLS::try_update_uppder_trans_version()
while (OB_SUCC(ret)) {
if (OB_FAIL(tablet_iter.get_next_tablet(tablet_handle))) {
if (OB_ITER_END != ret) {
LOG_WARN("failed to get tablet", K(ret), K(ls_id), K(tablet_handle));
LOG_WARN("failed to get tablet", K(ret), K(ls_meta_.ls_id_), K(tablet_handle));
} else {
ret = OB_SUCCESS;
break;
}
} else if (OB_UNLIKELY(!tablet_handle.is_valid())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid tablet handle", K(ret), K(ls_id), K(tablet_handle));
LOG_WARN("invalid tablet handle", K(ret), K(ls_meta_.ls_id_), K(tablet_handle));
} else if (!tablet_handle.get_obj()->get_tablet_meta().ha_status_.is_data_status_complete()) {
//no need update upper trans version
} else if (OB_TMP_FAIL(tablet_handle.get_obj()->update_upper_trans_version(*this, is_updated))) {

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

@ -1378,7 +1378,7 @@ int ObLSTabletService::no_lock_update_tablet_to_empty_shell(
LOG_WARN("failed to init tablet", K(ret), KPC(old_tablet));
} else if (FALSE_IT(time_guard.click("InitNew"))) {
} else if (OB_FAIL(ObTabletSlogHelper::write_empty_shell_tablet_slog(new_tablet, disk_addr))) {
LOG_WARN("fail to write emtpy shell tablet slog", K(ret), K(ls_id), K(tablet_id), K(disk_addr));
LOG_WARN("fail to write emtpy shell tablet slog", K(ret), K(tablet_id), K(disk_addr));
} else if (FALSE_IT(new_tablet->tablet_addr_ = disk_addr)) {
} else if (FALSE_IT(time_guard.click("WrSlog"))) {
} else if (OB_FAIL(t3m->compare_and_swap_tablet(key, old_tablet_handle, new_tablet_handle))) {

10
src/storage/memtable/ob_memtable.cpp
View File

@ -601,7 +601,7 @@ int ObMemtable::exist(
is_exist = mtd->dml_flag_ != blocksstable::ObDmlFlag::DF_DELETE;
}
}
TRANS_LOG(DEBUG, "Check memtable exist rowkey, ", K(table_id), K(rowkey), K(is_exist),
TRANS_LOG(DEBUG, "Check memtable exist rowkey, ", K(rowkey), K(is_exist),
K(has_found));
}
//get_end(context.store_ctx_->mvcc_acc_ctx_, ret);
@ -1414,7 +1414,7 @@ int64_t ObMemtable::dec_write_ref()
void ObMemtable::inc_unsynced_cnt()
{
int64_t unsynced_cnt = inc_unsynced_cnt_();
TRANS_LOG(DEBUG, "inc_unsynced_cnt", K(ls_id), K(unsynced_cnt), KPC(this), K(lbt()));
TRANS_LOG(DEBUG, "inc_unsynced_cnt", K(ls_id_), K(unsynced_cnt), KPC(this), K(lbt()));
}
int ObMemtable::dec_unsynced_cnt()
@ -1454,7 +1454,7 @@ void ObMemtable::unset_logging_blocked_for_active_memtable()
if (OB_NOT_NULL(memtable_mgr)) {
do {
if (OB_FAIL(memtable_mgr->unset_logging_blocked_for_active_memtable(this))) {
TRANS_LOG(ERROR, "fail to unset logging blocked for active memtable", K(ret), K(ls_id), KPC(this));
TRANS_LOG(ERROR, "fail to unset logging blocked for active memtable", K(ret), K(ls_id_), KPC(this));
ob_usleep(100);
}
} while (OB_FAIL(ret));
@ -1471,7 +1471,7 @@ void ObMemtable::resolve_left_boundary_for_active_memtable()
if (OB_NOT_NULL(memtable_mgr)) {
do {
if (OB_FAIL(memtable_mgr->resolve_left_boundary_for_active_memtable(this, new_start_scn, get_snapshot_version_scn()))) {
TRANS_LOG(ERROR, "fail to set start log ts for active memtable", K(ret), K(ls_id), KPC(this));
TRANS_LOG(ERROR, "fail to set start log ts for active memtable", K(ret), K(ls_id_), KPC(this));
ob_usleep(100);
}
} while (OB_FAIL(ret));
@ -2548,7 +2548,7 @@ int ObMemtable::lock_(
rowkey.get_obj_cnt() /*column_cnt*/);
if (OB_FAIL(mvcc_write_(param, context, &mtk, arg, is_new_locked))) {
} else if (OB_UNLIKELY(!is_new_locked)) {
TRANS_LOG(DEBUG, "lock twice, no need to store lock trans node", K(table_id));
TRANS_LOG(DEBUG, "lock twice, no need to store lock trans node");
}
}

2
src/storage/ob_i_store.cpp
View File

@ -108,7 +108,7 @@ int ObStoreCtx::init_for_read(const ObLSHandle &ls_handle,
STORAGE_LOG(WARN, "get invalid arguments", K(ret), K(ls_handle), K(timeout), K(tx_lock_timeout), K(snapshot_version));
} else if (OB_ISNULL(ls = ls_handle.get_ls())) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "ls is null", K(ret), K(ls_id));
STORAGE_LOG(WARN, "ls is null", K(ret), K(ls_id_));
} else if (OB_FAIL(ls->get_tx_table_guard(tx_table_guard))) {
STORAGE_LOG(WARN, "get_tx_table_guard from log stream fail.", K(ret), K(*ls));
} else {

2
src/storage/ob_storage_rpc.cpp
View File

@ -3756,7 +3756,7 @@ int ObStorageRpc::wakeup_transfer_service(
STORAGE_LOG(WARN, "storage rpc is not inited", K(ret));
} else if (tenant_id == OB_INVALID_ID || !src_info.is_valid()) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "invalid argument", K(ret), K(tenant_id), K(src_info), K(ls_id));
STORAGE_LOG(WARN, "invalid argument", K(ret), K(tenant_id), K(src_info));
} else {
ObStorageWakeupTransferServiceArg arg;
arg.tenant_id_ = tenant_id;

2
src/storage/ob_storage_schema_recorder.cpp
View File

@ -321,7 +321,7 @@ int ObStorageSchemaRecorder::get_schema(
// The version is checked here, so there is no need to check whether it is full
int tmp_ret = ret;
ret = OB_SCHEMA_ERROR;
LOG_WARN("failed to get schema", KR(tmp_ret), KR(ret), K(table_id), K_(tablet_id),
LOG_WARN("failed to get schema", KR(tmp_ret), KR(ret), K(table_id_), K_(tablet_id),
K(tenant_schema_version), K(table_version), KPC(t_schema));
if (NULL != t_schema) {
LOG_WARN("current schema version", K(t_schema->get_schema_version()));

2
src/storage/restore/ob_ls_restore_task_mgr.cpp
View File

@ -213,7 +213,7 @@ int ObLSRestoreTaskMgr::remove_restored_tablets(ObIArray<common::ObTabletID> &re
}
if (FAILEDx(redo_failed_tablets_(high_pri_tablet_need_redo, wait_tablet_need_redo))) {
LOG_WARN("failed to redo failed tablets", K(ret), K(task_id));
LOG_WARN("failed to redo failed tablets", K(ret));
} else {
remove_finished_task_(finish_task);
LOG_INFO("succeed remove restored tablets", K_(ls_id), K(high_pri_tablet_need_redo), K(wait_tablet_need_redo), K(restored_tablets));

2
src/storage/tablelock/ob_table_lock_rpc_processor.cpp
View File

@ -67,7 +67,7 @@ int check_exist(const ObLockTaskBatchRequest &arg,
tablet_handle,
0,
ObMDSGetTabletMode::READ_WITHOUT_CHECK))) {
LOG_WARN("get tablet with timeout failed", K(ret), K(ls_id), K(tablet_id));
LOG_WARN("get tablet with timeout failed", K(ret), K(ls->get_ls_id()), K(tablet_id));
} else if (OB_FAIL(tablet_handle.get_obj()->ObITabletMdsInterface::get_latest_tablet_status(
data, is_commited))) {
LOG_WARN("failed to get CreateDeleteMdsUserData", KR(ret));

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

@ -3730,7 +3730,7 @@ int ObTablet::get_kept_multi_version_start(
} else if (FALSE_IT(multi_version_start = tablet.get_multi_version_start())) {
} else if (OB_FAIL(MTL(ObTenantFreezeInfoMgr*)->get_min_reserved_snapshot(
tablet_id, max_merged_snapshot, min_reserved_snapshot))) {
LOG_WARN("failed to get multi version from freeze info mgr", K(ret), K(table_id));
LOG_WARN("failed to get multi version from freeze info mgr", K(ret), K(tablet_id));
} else if (!tablet.is_ls_inner_tablet()) {
ObTabletMediumInfoReader medium_info_reader(tablet);
if (OB_FAIL(medium_info_reader.init(arena_allocator))) {
@ -5745,7 +5745,7 @@ int ObTablet::check_schema_version_with_cache(
} else if (OB_FAIL(check_schema_version(schema_version))) {
LOG_WARN("fail to check schema version", K(ret), K(ddl_data_cache_));
} else {
LOG_INFO("refresh ddl data cache", K(ret), K(ls_id), K(tablet_id), K(ddl_data_cache_),
LOG_INFO("refresh ddl data cache", K(ret), K(tablet_meta_.ls_id_), K(tablet_id), K(ddl_data_cache_),
K(schema_version), K(timeout), KP(this));
}
}
@ -5804,7 +5804,7 @@ int ObTablet::check_snapshot_readable_with_cache(
} else if (OB_FAIL(check_snapshot_readable(snapshot_version))) {
LOG_WARN("fail to check snapshot version", K(ret), K(ddl_data_cache_));
} else {
LOG_INFO("refresh ddl data cache", K(ret), K(ls_id), K(tablet_id), K(ddl_data_cache_),
LOG_INFO("refresh ddl data cache", K(ret), K(tablet_meta_.ls_id_), K(tablet_id), K(ddl_data_cache_),
K(snapshot_version), K(timeout), KP(this));
}
}

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

@ -144,7 +144,7 @@ int ObTabletDeleteMdsHelper::delete_tablets(
ObLSHandle ls_handle;
ObLS *ls = nullptr;
if (CLICK_FAIL(ls_service->get_ls(key.ls_id_, ls_handle, ObLSGetMod::MDS_TABLE_MOD))) {
LOG_WARN("failed to get ls", K(ret), K(ls_id));
LOG_WARN("failed to get ls", K(ret), K(key.ls_id_));
} else if (OB_ISNULL(ls = ls_handle.get_ls())) {
ret = OB_ERR_UNEXPECTED;
} else {

4
src/storage/tx/ob_trans_part_ctx.cpp
View File

@ -1902,7 +1902,7 @@ int ObPartTransCtx::on_dist_end_(const bool commit)
elr_handler_.reset_elr_state();
}
TRANS_LOG(DEBUG, "trans end", K(ret), K(trans_id_), K(commit), K(commit_version));
TRANS_LOG(DEBUG, "trans end", K(ret), K(trans_id_), K(commit));
return ret;
}
@ -7527,7 +7527,7 @@ int ObPartTransCtx::on_local_abort_tx_()
ObTxBufferNodeArray tmp_array;
if (OB_FAIL(tx_end_(false /*commit*/))) {
TRANS_LOG(WARN, "trans end error", KR(ret), K(commit_version), "context", *this);
TRANS_LOG(WARN, "trans end error", KR(ret), "context", *this);
} else if (OB_FAIL(trans_clear_())) {
TRANS_LOG(WARN, "local tx clear error", KR(ret), K(*this));
} else if (OB_FAIL(gen_total_mds_array_(tmp_array))) {

2
src/storage/tx/ob_trans_service_v4.cpp
View File

@ -3327,7 +3327,7 @@ int ObTransService::check_and_fill_state_info(const ObTransID &tx_id, ObStateInf
} else if (OB_ISNULL(ls = handle.get_ls())) {
ret = OB_TRANS_CTX_NOT_EXIST;
} else if (OB_FAIL(ls->get_ls_replica_readable_scn(version))) {
TRANS_LOG(WARN, "get ls replica readable scn fail", K(ret), K(ls_id));
TRANS_LOG(WARN, "get ls replica readable scn fail", K(ret), K(ls->get_ls_id()));
} else if (version >= state_info.snapshot_version_) {
state_info.state_ = ObTxState::UNKNOWN;
state_info.version_ = version;

2
src/storage/tx/ob_tx_free_route.cpp
View File

@ -341,7 +341,7 @@ int ObTransService::txn_free_route__handle_tx_exist_(const ObTransID &tx_id, ObT
// then continue with retry
auto assoc_sess_id = tmp_tx->assoc_sess_id_;
TRANS_LOG(WARN, "tx found associate with other session, will kill the session",
K(session_id), K(assoc_sess_id), K(tx_id));
K(assoc_sess_id), K(tx_id));
if (OB_FAIL(txn_free_route__kill_session_(assoc_sess_id))) {
TRANS_LOG(WARN, "kill old session failed", K(ret), K(assoc_sess_id));
} else if (OB_FAIL(release_tx(*tmp_tx))) {

2
src/storage/tx_storage/ob_empty_shell_task.cpp
View File

@ -181,7 +181,7 @@ int ObTabletEmptyShellHandler::update_tablets_to_empty_shell(ObLS *ls, const com
for (int64_t i = 0; OB_SUCC(ret) && i < tablet_ids.count(); ++i) {
const ObTabletID &tablet_id = tablet_ids.at(i);
if (OB_FAIL(ls->get_tablet_svr()->update_tablet_to_empty_shell(tablet_id))) {
STORAGE_LOG(WARN, "failed to update tablet to shell", K(ret), K(ls_id), K(tablet_id));
STORAGE_LOG(WARN, "failed to update tablet to shell", K(ret), K(ls->get_ls_id()), K(tablet_id));
} else {
#ifdef ERRSIM
const uint64_t tenant_id = MTL_ID();

2
src/storage/tx_storage/ob_ls_service.cpp
View File

@ -156,7 +156,7 @@ int ObLSService::stop()
} else if (OB_FAIL(ls->offline())) {
LOG_WARN("ls offline failed", K(ret), K(ls->get_ls_id()), KP(ls));
} else if (OB_FAIL(ls->stop())) {
LOG_WARN("stop ls failed", K(ret), KP(ls), K(ls_id));
LOG_WARN("stop ls failed", K(ret), KP(ls), K(ls->get_ls_id()));
} else if (FALSE_IT(ls->wait())) {
} else if (OB_FAIL(handle.set_ls(ls_map_, *ls, ObLSGetMod::TXSTORAGE_MOD))) {
LOG_WARN("get ls handle failed", K(ret), KPC(ls));

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

@ -744,9 +744,9 @@ int ObTxTable::check_tx_data_in_kv_cache_(ObReadTxDataArg &read_tx_data_arg, ObI
const ObTxData *tx_data = nullptr;
if (OB_ISNULL(cache_val)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(ERROR, "cache value is nullptr", KR(ret), K(read_tx_data_arg), K(ls_id), K(val_handle));
STORAGE_LOG(ERROR, "cache value is nullptr", KR(ret), K(read_tx_data_arg), K(ls_id_), K(val_handle));
} else if (OB_ISNULL(tx_data = cache_val->get_tx_data())) {
STORAGE_LOG(ERROR, "tx data in cache value is nullptr", KR(ret), K(read_tx_data_arg), K(ls_id), KPC(cache_val));
STORAGE_LOG(ERROR, "tx data in cache value is nullptr", KR(ret), K(read_tx_data_arg), K(ls_id_), KPC(cache_val));
} else {
EVENT_INC(ObStatEventIds::TX_DATA_HIT_KV_CACHE_COUNT);
ret = fn(*tx_data);