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

add column for tablet_replica_checksum and tablet_compaction_history

Browse Source
This commit is contained in:
obdev 2024-09-18 08:17:06 +00:00 committed by ob-robot
parent 7dfea265d1
commit f00f696510
39 changed files with 695 additions and 650 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
deps/oblib/src/lib/ob_define.h vendored
View File

@ -1499,6 +1499,7 @@ const int64_t OB_MERGE_COMMENT_INNER_STR_LENGTH = 800;
const int64_t OB_CKM_ERROR_INFO_STR_LENGTH = 1024;
const int64_t OB_COMPACTION_STATUS_STR_LENGTH = 256;
const int64_t OB_STORAGE_PATH_STR_LENGTH = 256;
const int64_t OB_MERGE_REASON_STR_LENGTH = 32;
// for erasure code
const int64_t OB_MAX_EC_STRIPE_COUNT = 32;

30
src/observer/virtual_table/ob_all_virtual_tablet_compaction_history.cpp
View File

@ -245,6 +245,36 @@ int ObAllVirtualTabletCompactionHistory::process_curr_tenant(ObNewRow *&row)
}
cells[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
break;
case IS_FULL_MERGE:
cells[i].set_bool(static_info.is_full_merge_);
break;
case IO_COST_TIME_PERCENTAGE:
cells[i].set_int(running_info.io_percentage_);
break;
case MERGE_REASON:
if (ObAdaptiveMergePolicy::is_valid_merge_reason(static_info.merge_reason_)) {
cells[i].set_varchar(ObAdaptiveMergePolicy::merge_reason_to_str(static_info.merge_reason_));
} else {
cells[i].set_varchar("");
}
cells[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
break;
case BASE_MAJOR_STATUS:
if (is_valid_co_major_sstable_status(static_info.base_major_status_)) {
cells[i].set_varchar(co_major_sstable_status_to_str(static_info.base_major_status_));
} else {
cells[i].set_varchar("");
}
cells[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
break;
case CO_MERGE_TYPE:
if (ObCOMajorMergePolicy::is_valid_major_merge_type(static_info.co_major_merge_type_)) {
cells[i].set_varchar(ObCOMajorMergePolicy::co_major_merge_type_to_str(static_info.co_major_merge_type_));
} else {
cells[i].set_varchar("");
}
cells[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
break;
default:
ret = OB_ERR_UNEXPECTED;
SERVER_LOG(WARN, "invalid column id", K(ret), K(col_id));

7
src/observer/virtual_table/ob_all_virtual_tablet_compaction_history.h
View File

@ -59,7 +59,12 @@ public:
END_CG_ID,
KEPT_SNAPSHOT,
MERGE_LEVEL,
EXEC_MODE
EXEC_MODE,
IS_FULL_MERGE,
IO_COST_TIME_PERCENTAGE,
MERGE_REASON,
BASE_MAJOR_STATUS,
CO_MERGE_TYPE
};
ObAllVirtualTabletCompactionHistory();
virtual ~ObAllVirtualTabletCompactionHistory();

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

@ -427,8 +427,7 @@ int ObChecksumValidator::verify_tablet_replica_checksum()
if (OB_UNLIKELY(replica_ckm_items_.empty())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(replica_ckm_items_));
} else if (OB_FAIL(ObMediumCompactionScheduleFunc::check_replica_checksum_items(
replica_ckm_items_, ls_locality_cache_.get_cs_replica_cache(), false /*is_medium_checker*/))) {
} else if (OB_FAIL(ObMediumCompactionScheduleFunc::check_replica_checksum_items(replica_ckm_items_, false /*is_medium_checker*/))) {
LOG_WARN("failed to verify tablet replica checksum", K(ret));
}
return ret;

347
src/share/compaction/ob_compaction_locality_cache.cpp
View File

@ -23,347 +23,12 @@ namespace oceanbase
namespace share
{
/****************************** ObLSReplicaUniItem ******************************/
ObLSReplicaUniItem::ObLSReplicaUniItem()
: ls_id_(),
server_()
{}
ObLSReplicaUniItem::ObLSReplicaUniItem(const ObLSID &ls_id, const common::ObAddr &server)
: ls_id_(ls_id),
server_(server)
{}
ObLSReplicaUniItem::~ObLSReplicaUniItem()
{
reset();
}
void ObLSReplicaUniItem::reset() {
ls_id_.reset();
server_.reset();
}
uint64_t ObLSReplicaUniItem::hash() const
{
uint64_t hash_val = 0;
hash_val += ls_id_.hash();
hash_val += server_.hash();
return hash_val;
}
int ObLSReplicaUniItem::hash(uint64_t &hash_val) const
{
hash_val = hash();
return OB_SUCCESS;
}
bool ObLSReplicaUniItem::is_valid() const
{
return ls_id_.is_valid() && server_.is_valid();
}
bool ObLSReplicaUniItem::operator == (const ObLSReplicaUniItem &other) const
{
bool bret = true;
if (this == &other) {
} else if (ls_id_ != other.ls_id_ || server_ != other.server_) {
bret = false;
}
return bret;
}
bool ObLSReplicaUniItem::operator != (const ObLSReplicaUniItem &other) const
{
return !(*this == other);
}
/****************************** ObLSColumnReplicaCache ******************************/
ObLSColumnReplicaCache::ObLSColumnReplicaCache()
: is_inited_(false),
ls_id_set_(),
ls_replica_set_(),
ls_infos_()
{}
ObLSColumnReplicaCache::~ObLSColumnReplicaCache()
{
destroy();
}
// init
int ObLSColumnReplicaCache::init()
{
int ret = OB_SUCCESS;
if (IS_INIT) {
ret = OB_INIT_TWICE;
LOG_WARN("init twice", K(ret));
} else if (OB_FAIL(ls_id_set_.create(BUCKET_NUM_OF_LS_ID_SET, ObMemAttr(MTL_ID(), "LSIDsForCkm")))) {
LOG_WARN("fail to create ls id set", K(ret));
} else if (OB_FAIL(ls_replica_set_.create(BUCKET_NUM_OF_LS_REPLICA_SET, ObMemAttr(MTL_ID(), "LSReplTypes")))) {
LOG_WARN("fail to create ls replica type map", K(ret));
} else {
is_inited_ = true;
}
return ret;
}
void ObLSColumnReplicaCache::destroy()
{
int ret = OB_SUCCESS; // only for log
if (ls_replica_set_.created() && OB_FAIL(ls_replica_set_.destroy())) {
LOG_WARN("fail to destroy ls replica set", K(ret));
}
if (ls_id_set_.created() && OB_FAIL(ls_id_set_.destroy())) {
LOG_WARN("fail to destroy ls replica set", K(ret));
}
ls_infos_.reset();
is_inited_ = false;
}
void ObLSColumnReplicaCache::reuse()
{
ls_id_set_.reuse();
ls_replica_set_.reuse();
ls_infos_.reuse();
}
int ObLSColumnReplicaCache::check_contains_ls(const ObLSID &ls_id, bool &contained) const
{
int ret = OB_SUCCESS;
contained = false;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret));
} else if (OB_FAIL(ls_id_set_.exist_refactored(ls_id))) {
if (OB_HASH_EXIST == ret || OB_HASH_NOT_EXIST == ret) {
contained = (OB_HASH_EXIST == ret);
ret = OB_SUCCESS;
} else {
LOG_WARN("fail to check contains ls", K(ret), K(ls_id), KPC(this));
}
}
return ret;
}
int ObLSColumnReplicaCache::mark_ls_finished(const ObLSID &ls_id)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret));
} else if (OB_FAIL(ls_id_set_.set_refactored(ls_id))) {
if (OB_HASH_EXIST == ret) {
ret = OB_SUCCESS;
} else {
LOG_WARN("fail to mark ls finish", K(ret), K(ls_id), KPC(this));
}
}
return ret;
}
int ObLSColumnReplicaCache::add_cs_replica(const ObLSReplicaUniItem &ls_item)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret));
} else if (OB_FAIL(ls_replica_set_.set_refactored(ls_item))) {
LOG_WARN("fail to add col replica", K(ret), K(ls_item), KPC(this));
}
return ret;
}
int ObLSColumnReplicaCache::assign(const ObLSColumnReplicaCache &other)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret));
} else if (OB_FAIL(other.deep_fetch(ls_id_set_, ls_replica_set_, ls_infos_))) {
LOG_WARN("fail to assign", K(ret), K(other));
}
return ret;
}
int ObLSColumnReplicaCache::deep_fetch(
hash::ObHashSet<ObLSID> &target_ls_id_set,
hash::ObHashSet<ObLSReplicaUniItem> &target_ls_replica_set,
common::ObIArray<ObLSInfo> &target_ls_infos) const
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret));
} else {
target_ls_id_set.reuse();
target_ls_replica_set.reuse();
target_ls_infos.reuse();
for (hash::ObHashSet<ObLSID>::const_iterator it = ls_id_set_.begin(); OB_SUCC(ret) && it != ls_id_set_.end(); ++it) {
if (OB_FAIL(target_ls_id_set.set_refactored(it->first))) {
LOG_WARN("fail to add ls id", K(ret));
}
}
for (hash::ObHashSet<ObLSReplicaUniItem>::const_iterator it = ls_replica_set_.begin(); OB_SUCC(ret) && it != ls_replica_set_.end(); ++it) {
if (OB_FAIL(target_ls_replica_set.set_refactored(it->first))) {
LOG_WARN("fail to add ls replica", K(ret));
}
}
for (int64_t idx = 0; OB_SUCC(ret) && idx < ls_infos_.count(); ++idx) {
if (OB_FAIL(target_ls_infos.push_back(ls_infos_.at(idx)))) {
LOG_WARN("fail to push back ls info", K(ret), K(idx), K_(ls_infos));
}
}
}
return ret;
}
int ObLSColumnReplicaCache::update(const ObLSID &ls_id)
{
int ret = OB_SUCCESS;
const int64_t cluster_id = GCONF.cluster_id;
bool is_contained = false;
ObLSInfo ls_info;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret));
} else if (OB_FAIL(check_contains_ls(ls_id, is_contained))) {
LOG_WARN("fail to check exist for ls", K(ls_id), KPC(this));
} else if (is_contained) {
// do nothing
} else if (OB_ISNULL(GCTX.lst_operator_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("lst operator is null", K(ret));
} else if (OB_FAIL(GCTX.lst_operator_->get(cluster_id, MTL_ID(), ls_id, ObLSTable::DEFAULT_MODE, ls_info))) {
LOG_WARN("fail to get ls info", K(ret), K(ls_id), K(cluster_id), K(MTL_ID()));
} else if (OB_FAIL(update_with_ls_info(ls_info))) {
LOG_WARN("failed to try add cs replica info", K(ret), K(ls_id), K(ls_info));
}
return ret;
}
int ObLSColumnReplicaCache::update_with_ls_info(const ObLSInfo &ls_info)
{
int ret = OB_SUCCESS;
const ObLSID &ls_id = ls_info.get_ls_id();
bool replica_has_leader = false;
for (int64_t idx = 0; OB_SUCC(ret) && idx < ls_info.get_replicas().count(); ++idx) {
const ObLSReplica &replica = ls_info.get_replicas().at(idx);
if (ObRole::LEADER == replica.get_role()) {
replica_has_leader = true;
}
if (!replica.is_column_replica()) {
// do nothing
} else if (OB_FAIL(add_cs_replica(ObLSReplicaUniItem(ls_id, replica.get_server())))) {
LOG_WARN("failed to add cs replica", K(ret), K(ls_id), K(replica), K(ls_info));
} else {
LOG_INFO("success to add cs replica", K(ls_id), K(replica), K(ls_info));
}
}
if (OB_FAIL(ret)) {
} else if (!replica_has_leader) {
ret = OB_LEADER_NOT_EXIST;
LOG_WARN("ls has no leader, ls column replica cache cannot read", K(ret), K(ls_id));
} else if (OB_FAIL(mark_ls_finished(ls_id))) {
LOG_WARN("fail to make ls finished", K(ret));
} else if (OB_FAIL(ls_infos_.push_back(ls_info))) {
LOG_WARN("failed to add ls info", K(ret), K(ls_info));
} else {
LOG_INFO("success to update with ls info", KPC(this)); // debug log, remove later
}
return ret;
}
int ObLSColumnReplicaCache::check_can_skip(
const ObLSReplicaUniItem &ls_item,
bool &can_skip) const
{
int ret = OB_SUCCESS;
can_skip = false;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret), KPC(this));
} else if (OB_UNLIKELY(!ls_item.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(ls_item));
} else {
const ObLSInfo *ls_info = nullptr;
for (int64_t idx = 0; OB_SUCC(ret) && idx < ls_infos_.count(); ++idx) {
if (ls_item.ls_id_ == ls_infos_.at(idx).get_ls_id()) {
ls_info = &ls_infos_.at(idx);
break;
}
}
if (OB_ISNULL(ls_info)) {
ret = OB_ENTRY_NOT_EXIST;
LOG_WARN("ls info not found", K(ret), K(ls_item), K(ls_infos_));
} else {
const ObLSInfo::ReplicaArray &replicas = ls_info->get_replicas();
for (int64_t idx = 0; OB_SUCC(ret) && idx < replicas.count(); ++idx) {
const ObLSReplica &curr_replica = replicas.at(idx);
ObMember learner;
if (ObRole::LEADER != curr_replica.get_role()) {
continue; // follower replica, do nothing
} else if (curr_replica.server_is_in_member_list(curr_replica.get_member_list(), ls_item.server_)) {
// item is in member list, need to check
} else if (OB_FAIL(curr_replica.get_learner_list().get_learner_by_addr(ls_item.server_, learner))) {
if (OB_ENTRY_NOT_EXIST == ret) {
ret = OB_SUCCESS;
can_skip = true; // item not in member list && not in learner list, skip to check
} else {
LOG_WARN("faile to get learner", K(ret), K(ls_item), KPC(this));
}
} else {
// both R replica and CS replica need to check
}
break; // found leader replica, stop checking another replica
}
}
}
return ret;
}
int ObLSColumnReplicaCache::check_is_cs_replica(const ObLSReplicaUniItem &ls_item, bool &is_cs_replica) const
{
int ret = OB_SUCCESS;
is_cs_replica = false;
bool is_contained = false;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret));
} else if (OB_FAIL(check_contains_ls(ls_item.ls_id_, is_contained))) {
LOG_WARN("fail to check exist for ls", K(ls_item), KPC(this));
} else if (OB_UNLIKELY(!is_contained)) {
ret = OB_LEADER_NOT_EXIST;
LOG_WARN("ls has no leader, ls column replica cache cannot read", K(ret));
} else if (OB_FAIL(ls_replica_set_.exist_refactored(ls_item))) {
if (OB_HASH_EXIST == ret || OB_HASH_NOT_EXIST == ret) {
is_cs_replica = (OB_HASH_EXIST == ret);
ret = OB_SUCCESS;
} else {
LOG_WARN("fail to check contains ls", K(ret), K(ls_item), KPC(this));
}
}
LOG_TRACE("[CS-Replica] check current ls is cs replica", K(ret), K(ls_item), K(is_cs_replica), KPC(this));
return ret;
}
/****************************** ObCompactionLocalityCache ******************************/
ObCompactionLocalityCache::ObCompactionLocalityCache()
: is_inited_(false),
tenant_id_(OB_INVALID_TENANT_ID),
merge_info_mgr_(nullptr),
ls_infos_map_(),
ls_cs_replica_cache_()
ls_infos_map_()
{}
ObCompactionLocalityCache::~ObCompactionLocalityCache()
@ -382,8 +47,6 @@ int ObCompactionLocalityCache::init(const uint64_t tenant_id, rootserver::ObMajo
LOG_WARN("invalid argument", K(ret), K(tenant_id));
} else if (OB_FAIL(ls_infos_map_.create(OB_MAX_LS_NUM_PER_TENANT_PER_SERVER, "CaLsInfoMap", "CaLsInfoNode", tenant_id))) {
LOG_WARN("fail to create ls info map", K(ret));
} else if (OB_FAIL(ls_cs_replica_cache_.init())) {
LOG_WARN("fail to init col replica cache", K(ret));
}
if (OB_FAIL(ret)) {
destroy();
@ -435,13 +98,11 @@ int ObCompactionLocalityCache::inner_refresh_ls_locality()
if (OB_FAIL(ret)) {
} else if (OB_UNLIKELY(zone_list.empty())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("zone list is empty, skip get ls locality", K(ret), K_(tenant_id));
LOG_INFO("zone list is empty, skip get ls locality", K(ret), K_(tenant_id));
MTL(compaction::ObDiagnoseTabletMgr *)->add_diagnose_tablet(UNKNOW_LS_ID, UNKNOW_TABLET_ID, ObDiagnoseTabletType::TYPE_MEDIUM_MERGE);
} else {
// 1. clear ls_infos cached in memory
ls_infos_map_.reuse();
ls_cs_replica_cache_.reuse();
// 2. load ls_infos from __all_ls_meta_table
ObArray<ObLSInfo> ls_infos;
ls_infos.set_attr(ObMemAttr(tenant_id_, "RefLSInfos"));
@ -575,10 +236,8 @@ int ObCompactionLocalityCache::refresh_by_zone(
}
if (FAILEDx(ls_infos_map_.set_refactored(ls_id, tmp_ls_info, 1/*overwrite*/))) {
LOG_WARN("fail to set refactored", KR(ret), K(ls_id), K(tmp_ls_info));
} else if (OB_FAIL(ls_cs_replica_cache_.update_with_ls_info(tmp_ls_info))) {
LOG_WARN("failed to update with ls info", K(ret), K(tmp_ls_info));
} else {
FLOG_INFO("success to refresh cached ls_info", K(ret), K(tmp_ls_info), K(zone_list), K_(ls_cs_replica_cache));
FLOG_INFO("success to refresh cached ls_info", K(ret), K(tmp_ls_info), K(zone_list));
}
}
return ret;

51
src/share/compaction/ob_compaction_locality_cache.h
View File

@ -29,55 +29,6 @@ class ObMySQLResult;
namespace share
{
struct ObLSReplicaUniItem
{
ObLSReplicaUniItem();
ObLSReplicaUniItem(const ObLSID &ls_id, const common::ObAddr &server);
~ObLSReplicaUniItem();
void reset();
uint64_t hash() const;
int hash(uint64_t &hash_val) const;
bool is_valid() const;
bool operator == (const ObLSReplicaUniItem &other) const;
bool operator != (const ObLSReplicaUniItem &other) const;
TO_STRING_KV(K_(ls_id), K_(server));
share::ObLSID ls_id_;
common::ObAddr server_;
};
class ObLSColumnReplicaCache
{
public:
ObLSColumnReplicaCache();
~ObLSColumnReplicaCache();
int init();
void destroy();
void reuse();
int assign(const ObLSColumnReplicaCache &other);
int deep_fetch(
hash::ObHashSet<ObLSID> &target_ls_id_set,
hash::ObHashSet<ObLSReplicaUniItem> &target_ls_replica_set,
common::ObIArray<ObLSInfo> &target_ls_infos) const;
int update(const ObLSID &ls_id);
int update_with_ls_info(const ObLSInfo &ls_info);
int check_is_cs_replica(const ObLSReplicaUniItem &ls_item, bool &is_cs_replica) const;
int check_can_skip(const ObLSReplicaUniItem &ls_item, bool &can_skip) const;
TO_STRING_KV(K_(is_inited), K_(ls_id_set), K_(ls_replica_set), K_(ls_infos));
private:
int check_contains_ls(const ObLSID &ls_id, bool &contained) const;
int mark_ls_finished(const ObLSID &ls_id);
int add_cs_replica(const ObLSReplicaUniItem &ls_item);
private:
const static int64_t BUCKET_NUM_OF_LS_ID_SET = 15;
const static int64_t BUCKET_NUM_OF_LS_REPLICA_SET = 31;
private:
bool is_inited_;
hash::ObHashSet<ObLSID> ls_id_set_; // record looped ls id
hash::ObHashSet<ObLSReplicaUniItem> ls_replica_set_; // cs-prelica ls
common::ObSEArray<ObLSInfo, 4> ls_infos_; // used for check member list and learner list
};
class ObCompactionLocalityCache
{
public:
@ -88,7 +39,6 @@ public:
bool empty() const { return ls_infos_map_.empty(); }
int refresh_ls_locality(const bool force_refresh);
int get_ls_info(const share::ObLSID &ls_id, share::ObLSInfo &ls_info);
const share::ObLSColumnReplicaCache& get_cs_replica_cache() const { return ls_cs_replica_cache_; }
TO_STRING_KV(K_(is_inited), K_(tenant_id));
private:
const int64_t CHECK_LS_LOCALITY_INTERVAL = 5 * 60 * 1000 * 1000L; // 5 mins
@ -111,7 +61,6 @@ private:
uint64_t tenant_id_;
rootserver::ObMajorMergeInfoManager *merge_info_mgr_;
common::hash::ObHashMap<share::ObLSID, share::ObLSInfo> ls_infos_map_;
share::ObLSColumnReplicaCache ls_cs_replica_cache_;
};
struct ObMemberListInfo

75
src/share/inner_table/ob_inner_table_schema.11101_11150.cpp
View File

@ -2772,6 +2772,81 @@ int ObInnerTableSchema::all_virtual_tablet_compaction_history_schema(ObTableSche
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("is_full_merge", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObTinyIntType, //column_type
CS_TYPE_INVALID, //column_collation_type
1, //column_length
-1, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("io_cost_time_percentage", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObIntType, //column_type
CS_TYPE_INVALID, //column_collation_type
sizeof(int64_t), //column_length
-1, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("merge_reason", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_INVALID, //column_collation_type
OB_MERGE_REASON_STR_LENGTH, //column_length
-1, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("base_major_status", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_INVALID, //column_collation_type
OB_MERGE_TYPE_STR_LENGTH, //column_length
-1, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("co_merge_type", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_INVALID, //column_collation_type
OB_MERGE_TYPE_STR_LENGTH, //column_length
-1, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
table_schema.get_part_option().set_part_num(1);
table_schema.set_part_level(PARTITION_LEVEL_ONE);

19
src/share/inner_table/ob_inner_table_schema.12251_12300.cpp
View File

@ -2267,6 +2267,25 @@ int ObInnerTableSchema::all_virtual_tablet_replica_checksum_schema(ObTableSchema
true, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ObObj data_checksum_type_default;
data_checksum_type_default.set_int(0);
ADD_COLUMN_SCHEMA_T("data_checksum_type", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObIntType, //column_type
CS_TYPE_INVALID, //column_collation_type
sizeof(int64_t), //column_length
-1, //column_precision
-1, //column_scale
false, //is_nullable
false, //is_autoincrement
data_checksum_type_default,
data_checksum_type_default); //default_value
}
table_schema.set_index_using_type(USING_BTREE);
table_schema.set_row_store_type(ENCODING_ROW_STORE);
table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL);

75
src/share/inner_table/ob_inner_table_schema.15201_15250.cpp
View File

@ -4523,6 +4523,81 @@ int ObInnerTableSchema::all_virtual_tablet_compaction_history_ora_schema(ObTable
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("IS_FULL_MERGE", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("IO_COST_TIME_PERCENTAGE", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("MERGE_REASON", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_UTF8MB4_BIN, //column_collation_type
OB_MERGE_REASON_STR_LENGTH, //column_length
2, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("BASE_MAJOR_STATUS", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_UTF8MB4_BIN, //column_collation_type
OB_MERGE_TYPE_STR_LENGTH, //column_length
2, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("CO_MERGE_TYPE", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_UTF8MB4_BIN, //column_collation_type
OB_MERGE_TYPE_STR_LENGTH, //column_length
2, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
table_schema.get_part_option().set_part_num(1);
table_schema.set_part_level(PARTITION_LEVEL_ONE);

240
src/share/inner_table/ob_inner_table_schema.15451_15500.cpp
View File

@ -2463,126 +2463,6 @@ int ObInnerTableSchema::all_virtual_vector_index_info_ora_schema(ObTableSchema &
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("FILE_PTR", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_UTF8MB4_BIN, //column_collation_type
20, //column_length
2, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("FILE_LABEL", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_UTF8MB4_BIN, //column_collation_type
16, //column_length
2, //column_precision
-1, //column_scale
true, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("META_TREE_EPOCH", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("META_TREE_LEVELS", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("META_BYTES", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("CACHED_META_PAGE_NUM", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("WRITE_BACK_META_PAGE_NUM", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("PAGE_FLUSH_CNT", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
table_schema.get_part_option().set_part_num(1);
table_schema.set_part_level(PARTITION_LEVEL_ONE);
@ -3173,6 +3053,126 @@ int ObInnerTableSchema::all_virtual_temp_file_ora_schema(ObTableSchema &table_sc
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("FILE_PTR", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_UTF8MB4_BIN, //column_collation_type
20, //column_length
2, //column_precision
-1, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("FILE_LABEL", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_UTF8MB4_BIN, //column_collation_type
16, //column_length
2, //column_precision
-1, //column_scale
true, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("META_TREE_EPOCH", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("META_TREE_LEVELS", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("META_BYTES", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("CACHED_META_PAGE_NUM", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("WRITE_BACK_META_PAGE_NUM", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("PAGE_FLUSH_CNT", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObNumberType, //column_type
CS_TYPE_INVALID, //column_collation_type
38, //column_length
38, //column_precision
0, //column_scale
false, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
table_schema.get_part_option().set_part_num(1);
table_schema.set_part_level(PARTITION_LEVEL_ONE);

4
src/share/inner_table/ob_inner_table_schema.21201_21250.cpp
View File

@ -1590,7 +1590,7 @@ int ObInnerTableSchema::gv_ob_tablet_compaction_history_schema(ObTableSchema &ta
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
if (OB_SUCC(ret)) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, LS_ID, TABLET_ID, TYPE, COMPACTION_SCN, START_TIME, FINISH_TIME, TASK_ID, OCCUPY_SIZE, MACRO_BLOCK_COUNT, MULTIPLEXED_MACRO_BLOCK_COUNT, NEW_MICRO_COUNT_IN_NEW_MACRO, MULTIPLEXED_MICRO_COUNT_IN_NEW_MACRO, TOTAL_ROW_COUNT, INCREMENTAL_ROW_COUNT, COMPRESSION_RATIO, NEW_FLUSH_DATA_RATE, PROGRESSIVE_COMPACTION_ROUND, PROGRESSIVE_COMPACTION_NUM, PARALLEL_DEGREE, PARALLEL_INFO, PARTICIPANT_TABLE, MACRO_ID_LIST, COMMENTS, START_CG_ID, END_CG_ID, KEPT_SNAPSHOT, MERGE_LEVEL, EXEC_MODE FROM oceanbase.__all_virtual_tablet_compaction_history )__"))) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, LS_ID, TABLET_ID, TYPE, COMPACTION_SCN, START_TIME, FINISH_TIME, TASK_ID, OCCUPY_SIZE, MACRO_BLOCK_COUNT, MULTIPLEXED_MACRO_BLOCK_COUNT, NEW_MICRO_COUNT_IN_NEW_MACRO, MULTIPLEXED_MICRO_COUNT_IN_NEW_MACRO, TOTAL_ROW_COUNT, INCREMENTAL_ROW_COUNT, COMPRESSION_RATIO, NEW_FLUSH_DATA_RATE, PROGRESSIVE_COMPACTION_ROUND, PROGRESSIVE_COMPACTION_NUM, PARALLEL_DEGREE, PARALLEL_INFO, PARTICIPANT_TABLE, MACRO_ID_LIST, COMMENTS, START_CG_ID, END_CG_ID, KEPT_SNAPSHOT, MERGE_LEVEL, EXEC_MODE, (CASE IS_FULL_MERGE WHEN false THEN "FALSE" ELSE "TRUE" END) AS IS_FULL_MERGE, IO_COST_TIME_PERCENTAGE, MERGE_REASON, BASE_MAJOR_STATUS, CO_MERGE_TYPE FROM oceanbase.__all_virtual_tablet_compaction_history )__"))) {
LOG_ERROR("fail to set view_definition", K(ret));
}
}
@ -1641,7 +1641,7 @@ int ObInnerTableSchema::v_ob_tablet_compaction_history_schema(ObTableSchema &tab
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
if (OB_SUCC(ret)) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, LS_ID, TABLET_ID, TYPE, COMPACTION_SCN, START_TIME, FINISH_TIME, TASK_ID, OCCUPY_SIZE, MACRO_BLOCK_COUNT, MULTIPLEXED_MACRO_BLOCK_COUNT, NEW_MICRO_COUNT_IN_NEW_MACRO, MULTIPLEXED_MICRO_COUNT_IN_NEW_MACRO, TOTAL_ROW_COUNT, INCREMENTAL_ROW_COUNT, COMPRESSION_RATIO, NEW_FLUSH_DATA_RATE, PROGRESSIVE_COMPACTION_ROUND, PROGRESSIVE_COMPACTION_NUM, PARALLEL_DEGREE, PARALLEL_INFO, PARTICIPANT_TABLE, MACRO_ID_LIST, COMMENTS, START_CG_ID, END_CG_ID, KEPT_SNAPSHOT, MERGE_LEVEL, EXEC_MODE FROM oceanbase.GV$OB_TABLET_COMPACTION_HISTORY WHERE SVR_IP=HOST_IP() AND SVR_PORT=RPC_PORT() )__"))) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, LS_ID, TABLET_ID, TYPE, COMPACTION_SCN, START_TIME, FINISH_TIME, TASK_ID, OCCUPY_SIZE, MACRO_BLOCK_COUNT, MULTIPLEXED_MACRO_BLOCK_COUNT, NEW_MICRO_COUNT_IN_NEW_MACRO, MULTIPLEXED_MICRO_COUNT_IN_NEW_MACRO, TOTAL_ROW_COUNT, INCREMENTAL_ROW_COUNT, COMPRESSION_RATIO, NEW_FLUSH_DATA_RATE, PROGRESSIVE_COMPACTION_ROUND, PROGRESSIVE_COMPACTION_NUM, PARALLEL_DEGREE, PARALLEL_INFO, PARTICIPANT_TABLE, MACRO_ID_LIST, COMMENTS, START_CG_ID, END_CG_ID, KEPT_SNAPSHOT, MERGE_LEVEL, EXEC_MODE, IS_FULL_MERGE, IO_COST_TIME_PERCENTAGE, MERGE_REASON, BASE_MAJOR_STATUS, CO_MERGE_TYPE FROM oceanbase.GV$OB_TABLET_COMPACTION_HISTORY WHERE SVR_IP=HOST_IP() AND SVR_PORT=RPC_PORT() )__"))) {
LOG_ERROR("fail to set view_definition", K(ret));
}
}

4
src/share/inner_table/ob_inner_table_schema.28101_28150.cpp
View File

@ -1488,7 +1488,7 @@ int ObInnerTableSchema::gv_ob_tablet_compaction_history_ora_schema(ObTableSchema
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
if (OB_SUCC(ret)) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, LS_ID, TABLET_ID, TYPE, COMPACTION_SCN, START_TIME, FINISH_TIME, TASK_ID, OCCUPY_SIZE, MACRO_BLOCK_COUNT, MULTIPLEXED_MACRO_BLOCK_COUNT, NEW_MICRO_COUNT_IN_NEW_MACRO, MULTIPLEXED_MICRO_COUNT_IN_NEW_MACRO, TOTAL_ROW_COUNT, INCREMENTAL_ROW_COUNT, COMPRESSION_RATIO, NEW_FLUSH_DATA_RATE, PROGRESSIVE_COMPACTION_ROUND, PROGRESSIVE_COMPACTION_NUM, PARALLEL_DEGREE, PARALLEL_INFO, PARTICIPANT_TABLE, MACRO_ID_LIST, COMMENTS, START_CG_ID, END_CG_ID, KEPT_SNAPSHOT, MERGE_LEVEL, EXEC_MODE FROM SYS.ALL_VIRTUAL_TABLET_COMPACTION_HISTORY )__"))) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, LS_ID, TABLET_ID, TYPE, COMPACTION_SCN, START_TIME, FINISH_TIME, TASK_ID, OCCUPY_SIZE, MACRO_BLOCK_COUNT, MULTIPLEXED_MACRO_BLOCK_COUNT, NEW_MICRO_COUNT_IN_NEW_MACRO, MULTIPLEXED_MICRO_COUNT_IN_NEW_MACRO, TOTAL_ROW_COUNT, INCREMENTAL_ROW_COUNT, COMPRESSION_RATIO, NEW_FLUSH_DATA_RATE, PROGRESSIVE_COMPACTION_ROUND, PROGRESSIVE_COMPACTION_NUM, PARALLEL_DEGREE, PARALLEL_INFO, PARTICIPANT_TABLE, MACRO_ID_LIST, COMMENTS, START_CG_ID, END_CG_ID, KEPT_SNAPSHOT, MERGE_LEVEL, EXEC_MODE, CASE WHEN IS_FULL_MERGE = 0 THEN 'FALSE' ELSE 'TRUE' END AS IS_FULL_MERGE, IO_COST_TIME_PERCENTAGE, MERGE_REASON, BASE_MAJOR_STATUS, CO_MERGE_TYPE FROM SYS.ALL_VIRTUAL_TABLET_COMPACTION_HISTORY )__"))) {
LOG_ERROR("fail to set view_definition", K(ret));
}
}
@ -1539,7 +1539,7 @@ int ObInnerTableSchema::v_ob_tablet_compaction_history_ora_schema(ObTableSchema
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
if (OB_SUCC(ret)) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, LS_ID, TABLET_ID, TYPE, COMPACTION_SCN, START_TIME, FINISH_TIME, TASK_ID, OCCUPY_SIZE, MACRO_BLOCK_COUNT, MULTIPLEXED_MACRO_BLOCK_COUNT, NEW_MICRO_COUNT_IN_NEW_MACRO, MULTIPLEXED_MICRO_COUNT_IN_NEW_MACRO, TOTAL_ROW_COUNT, INCREMENTAL_ROW_COUNT, COMPRESSION_RATIO, NEW_FLUSH_DATA_RATE, PROGRESSIVE_COMPACTION_ROUND, PROGRESSIVE_COMPACTION_NUM, PARALLEL_DEGREE, PARALLEL_INFO, PARTICIPANT_TABLE, MACRO_ID_LIST, COMMENTS, START_CG_ID, END_CG_ID, KEPT_SNAPSHOT, MERGE_LEVEL, EXEC_MODE FROM SYS.GV$OB_TABLET_COMPACTION_HISTORY WHERE SVR_IP=HOST_IP() AND SVR_PORT=RPC_PORT() )__"))) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT SVR_IP, SVR_PORT, TENANT_ID, LS_ID, TABLET_ID, TYPE, COMPACTION_SCN, START_TIME, FINISH_TIME, TASK_ID, OCCUPY_SIZE, MACRO_BLOCK_COUNT, MULTIPLEXED_MACRO_BLOCK_COUNT, NEW_MICRO_COUNT_IN_NEW_MACRO, MULTIPLEXED_MICRO_COUNT_IN_NEW_MACRO, TOTAL_ROW_COUNT, INCREMENTAL_ROW_COUNT, COMPRESSION_RATIO, NEW_FLUSH_DATA_RATE, PROGRESSIVE_COMPACTION_ROUND, PROGRESSIVE_COMPACTION_NUM, PARALLEL_DEGREE, PARALLEL_INFO, PARTICIPANT_TABLE, MACRO_ID_LIST, COMMENTS, START_CG_ID, END_CG_ID, KEPT_SNAPSHOT, MERGE_LEVEL, EXEC_MODE, IS_FULL_MERGE, IO_COST_TIME_PERCENTAGE, MERGE_REASON, BASE_MAJOR_STATUS, CO_MERGE_TYPE FROM SYS.GV$OB_TABLET_COMPACTION_HISTORY WHERE SVR_IP=HOST_IP() AND SVR_PORT=RPC_PORT() )__"))) {
LOG_ERROR("fail to set view_definition", K(ret));
}
}

19
src/share/inner_table/ob_inner_table_schema.351_400.cpp
View File

@ -7132,6 +7132,25 @@ int ObInnerTableSchema::all_tablet_replica_checksum_schema(ObTableSchema &table_
true, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ObObj data_checksum_type_default;
data_checksum_type_default.set_int(0);
ADD_COLUMN_SCHEMA_T("data_checksum_type", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObIntType, //column_type
CS_TYPE_INVALID, //column_collation_type
sizeof(int64_t), //column_length
-1, //column_precision
-1, //column_scale
false, //is_nullable
false, //is_autoincrement
data_checksum_type_default,
data_checksum_type_default); //default_value
}
table_schema.set_index_using_type(USING_BTREE);
table_schema.set_row_store_type(ENCODING_ROW_STORE);
table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL);

38
src/share/inner_table/ob_inner_table_schema_def.py
View File

@ -4272,6 +4272,7 @@ def_table_schema(
('data_checksum', 'int'),
('column_checksums', 'longtext', 'true'),
('b_column_checksums', 'varbinary:OB_MAX_VARBINARY_LENGTH', 'true'),
('data_checksum_type', 'int', 'false', 0)
],
)
@ -10058,7 +10059,12 @@ def_table_schema(
('end_cg_id', 'int'),
('kept_snapshot', 'varchar:OB_COMPACTION_INFO_LENGTH'),
('merge_level', 'varchar:OB_MERGE_LEVEL_STR_LENGTH'),
('exec_mode', 'varchar:OB_MERGE_TYPE_STR_LENGTH')
('exec_mode', 'varchar:OB_MERGE_TYPE_STR_LENGTH'),
('is_full_merge', 'bool'),
('io_cost_time_percentage', 'int'),
('merge_reason', 'varchar:OB_MERGE_REASON_STR_LENGTH'),
('base_major_status', 'varchar:OB_MERGE_TYPE_STR_LENGTH'),
('co_merge_type', 'varchar:OB_MERGE_TYPE_STR_LENGTH')
],
partition_columns = ['svr_ip', 'svr_port'],
vtable_route_policy = 'distributed',
@ -24962,7 +24968,14 @@ def_table_schema(
END_CG_ID,
KEPT_SNAPSHOT,
MERGE_LEVEL,
EXEC_MODE
EXEC_MODE,
(CASE IS_FULL_MERGE
WHEN false THEN "FALSE"
ELSE "TRUE" END) AS IS_FULL_MERGE,
IO_COST_TIME_PERCENTAGE,
MERGE_REASON,
BASE_MAJOR_STATUS,
CO_MERGE_TYPE
FROM oceanbase.__all_virtual_tablet_compaction_history
""".replace("\n", " ")
)
@ -25007,7 +25020,12 @@ def_table_schema(
END_CG_ID,
KEPT_SNAPSHOT,
MERGE_LEVEL,
EXEC_MODE
EXEC_MODE,
IS_FULL_MERGE,
IO_COST_TIME_PERCENTAGE,
MERGE_REASON,
BASE_MAJOR_STATUS,
CO_MERGE_TYPE
FROM oceanbase.GV$OB_TABLET_COMPACTION_HISTORY
WHERE
SVR_IP=HOST_IP()
@ -62877,7 +62895,12 @@ def_table_schema(
END_CG_ID,
KEPT_SNAPSHOT,
MERGE_LEVEL,
EXEC_MODE
EXEC_MODE,
CASE WHEN IS_FULL_MERGE = 0 THEN 'FALSE' ELSE 'TRUE' END AS IS_FULL_MERGE,
IO_COST_TIME_PERCENTAGE,
MERGE_REASON,
BASE_MAJOR_STATUS,
CO_MERGE_TYPE
FROM SYS.ALL_VIRTUAL_TABLET_COMPACTION_HISTORY
""".replace("\n", " ")
)
@ -62924,7 +62947,12 @@ def_table_schema(
END_CG_ID,
KEPT_SNAPSHOT,
MERGE_LEVEL,
EXEC_MODE
EXEC_MODE,
IS_FULL_MERGE,
IO_COST_TIME_PERCENTAGE,
MERGE_REASON,
BASE_MAJOR_STATUS,
CO_MERGE_TYPE
FROM SYS.GV$OB_TABLET_COMPACTION_HISTORY
WHERE
SVR_IP=HOST_IP()

88
src/share/ob_tablet_replica_checksum_operator.cpp
View File

@ -258,7 +258,8 @@ ObTabletReplicaChecksumItem::ObTabletReplicaChecksumItem()
row_count_(0),
compaction_scn_(),
data_checksum_(0),
column_meta_()
column_meta_(),
data_checksum_type_(ObDataChecksumType::DATA_CHECKSUM_MAX)
{}
void ObTabletReplicaChecksumItem::reset()
@ -271,6 +272,7 @@ void ObTabletReplicaChecksumItem::reset()
compaction_scn_.reset();
data_checksum_ = 0;
column_meta_.reset();
data_checksum_type_ = ObDataChecksumType::DATA_CHECKSUM_MAX;
}
bool ObTabletReplicaChecksumItem::is_key_valid() const
@ -289,7 +291,9 @@ bool ObTabletReplicaChecksumItem::is_key_valid() const
bool ObTabletReplicaChecksumItem::is_valid() const
{
return is_key_valid() && column_meta_.is_valid();
return is_key_valid()
&& column_meta_.is_valid()
&& is_valid_data_checksum_type(data_checksum_type_);
}
bool ObTabletReplicaChecksumItem::is_same_tablet(const ObTabletReplicaChecksumItem &other) const
@ -301,6 +305,19 @@ bool ObTabletReplicaChecksumItem::is_same_tablet(const ObTabletReplicaChecksumIt
&& tablet_id_ == other.tablet_id_;
}
int ObTabletReplicaChecksumItem::check_data_checksum_type(bool &is_cs_replica) const
{
int ret = OB_SUCCESS;
is_cs_replica = false;
if (OB_UNLIKELY(!is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid checksum item", K(ret), KPC(this));
} else if (ObDataChecksumType::DATA_CHECKSUM_COLUMN_STORE == data_checksum_type_) {
is_cs_replica = true;
}
return ret;
}
int ObTabletReplicaChecksumItem::verify_checksum(const ObTabletReplicaChecksumItem &other) const
{
int ret = OB_SUCCESS;
@ -364,6 +381,7 @@ int ObTabletReplicaChecksumItem::assign(const ObTabletReplicaChecksumItem &other
row_count_ = other.row_count_;
compaction_scn_ = other.compaction_scn_;
data_checksum_ = other.data_checksum_;
data_checksum_type_ = other.data_checksum_type_;
}
}
return ret;
@ -683,6 +701,9 @@ int ObTabletReplicaChecksumOperator::construct_tablet_replica_checksum_item_(
int64_t port = OB_INVALID_INDEX;
int64_t ls_id = OB_INVALID_ID;
uint64_t compaction_scn_val = 0;
uint64_t min_data_version = 0;
const int64_t tenant_id = MTL_ID();
int64_t data_checksum_type = 0;
ObString column_meta_hex_str;
(void)GET_COL_IGNORE_NULL(res.get_int, "tenant_id", int_tenant_id);
@ -695,6 +716,20 @@ int ObTabletReplicaChecksumOperator::construct_tablet_replica_checksum_item_(
(void)GET_COL_IGNORE_NULL(res.get_int, "data_checksum", item.data_checksum_);
(void)GET_COL_IGNORE_NULL(res.get_varchar, "b_column_checksums", column_meta_hex_str);
if (OB_FAIL(GET_MIN_DATA_VERSION(tenant_id, min_data_version))) {
LOG_WARN("get tenant data version failed", K(ret), K(tenant_id));
} else if (min_data_version < DATA_VERSION_4_3_3_0) {
item.data_checksum_type_ = ObDataChecksumType::DATA_CHECKSUM_NORMAL;
} else {
(void)GET_COL_IGNORE_NULL(res.get_int, "data_checksum_type", data_checksum_type);
if (is_valid_data_checksum_type(data_checksum_type)) {
item.data_checksum_type_ = static_cast<ObDataChecksumType>(data_checksum_type);
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid data checksum type", KR(ret), K(data_checksum_type));
}
}
if (FAILEDx(item.compaction_scn_.convert_for_inner_table_field(compaction_scn_val))) {
LOG_WARN("fail to convert val to SCN", KR(ret), K(compaction_scn_val));
} else if (OB_FAIL(item.set_tenant_id((uint64_t)int_tenant_id))) {
@ -760,11 +795,11 @@ int ObTabletReplicaChecksumOperator::inner_batch_insert_or_update_by_sql_(
} else {
int64_t affected_rows = 0;
ObSqlString sql;
ObDMLSqlSplicer dml_splicer;
uint64_t min_data_version = 0;
if (OB_FAIL(sql.assign_fmt("INSERT INTO %s (tenant_id, tablet_id, ls_id, svr_ip, svr_port, row_count, "
"compaction_scn, data_checksum, column_checksums, b_column_checksums, gmt_modified, gmt_create) VALUES",
OB_ALL_TABLET_REPLICA_CHECKSUM_TNAME))) {
LOG_WARN("fail to assign sql", KR(ret), K(tenant_id));
if (OB_FAIL(GET_MIN_DATA_VERSION(tenant_id, min_data_version))) {
LOG_WARN("get tenant data version failed", K(ret), K(tenant_id));
} else {
ObArenaAllocator allocator;
char ip[OB_MAX_SERVER_ADDR_SIZE] = "";
@ -784,24 +819,28 @@ int ObTabletReplicaChecksumOperator::inner_batch_insert_or_update_by_sql_(
LOG_WARN("fail to get visible column meta str", KR(ret));
} else if (OB_FAIL(get_hex_column_meta(cur_item.column_meta_, allocator, hex_column_meta))) {
LOG_WARN("fail to get hex column meta str", KR(ret));
} else if (OB_FAIL(sql.append_fmt("('%lu', '%lu', %ld, '%s', %d, %ld, %lu, %ld, "
"'%.*s', '%.*s', now(6), now(6))%s", cur_item.tenant_id_, cur_item.tablet_id_.id(),
cur_item.ls_id_.id(), ip, port, cur_item.row_count_,
compaction_scn_val, cur_item.data_checksum_, visible_column_meta.length(),
visible_column_meta.ptr(), hex_column_meta.length(), hex_column_meta.ptr(),
((idx == end_idx - 1) ? " " : ", ")))) {
LOG_WARN("fail to assign sql", KR(ret), K(idx), K(end_idx), K(cur_item));
} else if (OB_FAIL(dml_splicer.add_gmt_modified())
|| OB_FAIL(dml_splicer.add_gmt_create())
|| OB_FAIL(dml_splicer.add_pk_column("tenant_id", cur_item.tenant_id_))
|| OB_FAIL(dml_splicer.add_pk_column("tablet_id", cur_item.tablet_id_.id()))
|| OB_FAIL(dml_splicer.add_pk_column("svr_ip", ip))
|| OB_FAIL(dml_splicer.add_pk_column("svr_port", port))
|| OB_FAIL(dml_splicer.add_pk_column("ls_id", cur_item.ls_id_.id()))
|| OB_FAIL(dml_splicer.add_column("compaction_scn", compaction_scn_val))
|| OB_FAIL(dml_splicer.add_column("row_count", cur_item.row_count_))
|| OB_FAIL(dml_splicer.add_column("data_checksum", cur_item.data_checksum_))
|| OB_FAIL(dml_splicer.add_column("column_checksums", visible_column_meta))
|| OB_FAIL(dml_splicer.add_column("b_column_checksums", hex_column_meta))
|| (min_data_version >= DATA_VERSION_4_3_3_0 && OB_FAIL(dml_splicer.add_column("data_checksum_type", cur_item.data_checksum_type_)))
) {
LOG_WARN("fail to fill dml splicer", KR(ret), K(min_data_version), K(idx), K(end_idx), K(cur_item));
} else if (OB_FAIL(dml_splicer.finish_row())) {
LOG_WARN("fail to finish row", KR(ret), K(idx), K(end_idx), K(cur_item));
}
}
if (FAILEDx(sql.append_fmt(" ON DUPLICATE KEY UPDATE "))) {
LOG_WARN("fail to append sql string", KR(ret), K(sql));
} else if (OB_FAIL(sql.append(" row_count = values(row_count)"))
|| OB_FAIL(sql.append(", compaction_scn = values(compaction_scn)"))
|| OB_FAIL(sql.append(", data_checksum = values(data_checksum)"))
|| OB_FAIL(sql.append(", column_checksums = values(column_checksums)"))
|| OB_FAIL(sql.append(", b_column_checksums = values(b_column_checksums)"))) {
LOG_WARN("fail to append sql string", KR(ret), K(sql));
if (FAILEDx(dml_splicer.splice_batch_insert_update_sql(OB_ALL_TABLET_REPLICA_CHECKSUM_TNAME, sql))) {
LOG_WARN("fail to splice batch insert update sql", KR(ret), K(sql));
}
}
@ -1406,10 +1445,13 @@ void ObTabletDataChecksumChecker::reset()
cs_replica_ckm_item_ = nullptr;
}
int ObTabletDataChecksumChecker::check_data_checksum(const ObTabletReplicaChecksumItem& curr_item, bool is_cs_replica)
int ObTabletDataChecksumChecker::check_data_checksum(const ObTabletReplicaChecksumItem& curr_item)
{
int ret = OB_SUCCESS;
if (is_cs_replica) {
bool is_cs_replica = false;
if (OB_FAIL(curr_item.check_data_checksum_type(is_cs_replica))) {
LOG_WARN("fail to check data checksum type", KR(ret), K(curr_item));
} else if (is_cs_replica) {
if (OB_ISNULL(cs_replica_ckm_item_)) {
cs_replica_ckm_item_ = &curr_item;
} else if (cs_replica_ckm_item_->compaction_scn_ != curr_item.compaction_scn_) {

7
src/share/ob_tablet_replica_checksum_operator.h
View File

@ -88,10 +88,11 @@ public:
int assign_key(const ObTabletReplicaChecksumItem &other);
int assign(const ObTabletReplicaChecksumItem &other);
int set_tenant_id(const uint64_t tenant_id);
int check_data_checksum_type(bool &is_cs_replica) const;
common::ObTabletID get_tablet_id() const { return tablet_id_; }
TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(tablet_id), K_(server), K_(row_count),
K_(compaction_scn), K_(data_checksum), K_(column_meta));
K_(compaction_scn), K_(data_checksum), K_(column_meta), K_(data_checksum_type));
public:
uint64_t tenant_id_;
@ -102,6 +103,7 @@ public:
SCN compaction_scn_;
int64_t data_checksum_;
ObTabletReplicaReportColumnMeta column_meta_;
ObDataChecksumType data_checksum_type_;
};
typedef ObArrayWithMap<share::ObTabletReplicaChecksumItem> ObReplicaCkmArray;
// Operator for __all_tablet_replica_checksum
@ -146,7 +148,6 @@ public:
static int set_column_meta_with_hex_str(
const ObString &hex_str,
ObTabletReplicaReportColumnMeta &column_meta);
static int get_visible_column_meta(
const ObTabletReplicaReportColumnMeta &column_meta,
common::ObIAllocator &allocator,
@ -349,7 +350,7 @@ public:
ObTabletDataChecksumChecker();
~ObTabletDataChecksumChecker();
void reset();
int check_data_checksum(const ObTabletReplicaChecksumItem& curr_item, bool is_cs_replica);
int check_data_checksum(const ObTabletReplicaChecksumItem& curr_item);
TO_STRING_KV(KPC_(normal_ckm_item), KPC_(cs_replica_ckm_item));
private:
const ObTabletReplicaChecksumItem *normal_ckm_item_;

18
src/share/tablet/ob_tablet_info.cpp
View File

@ -21,6 +21,24 @@ namespace oceanbase
{
namespace share
{
const static char * ObDataChecksumTypeStr[] = {
"NORMAL",
"COLUMNSTORE",
};
const char *data_check_checksum_type_to_str(const ObDataChecksumType type)
{
STATIC_ASSERT(static_cast<uint8_t>(ObDataChecksumType::DATA_CHECKSUM_MAX) == ARRAYSIZEOF(ObDataChecksumTypeStr), "checksum type len is mismatch");
const char *str = "";
if (is_valid_data_checksum_type(type)) {
str = ObDataChecksumTypeStr[static_cast<uint8_t>(type)];
} else {
str = "INVALI_DATACHECKSUM_TYPE";
}
return str;
}
ObTabletReplica::ObTabletReplica()
: tenant_id_(OB_INVALID_TENANT_ID),
tablet_id_(),

20
src/share/tablet/ob_tablet_info.h
View File

@ -24,6 +24,26 @@ namespace share
{
class ObTabletReplicaFilter;
enum ObDataChecksumType : uint8_t
{
DATA_CHECKSUM_NORMAL = 0,
DATA_CHECKSUM_COLUMN_STORE = 1, // for column store replica data checksum
DATA_CHECKSUM_MAX
};
inline bool is_valid_data_checksum_type(const int64_t &type)
{
return type >= ObDataChecksumType::DATA_CHECKSUM_NORMAL
&& type < ObDataChecksumType::DATA_CHECKSUM_MAX;
}
inline bool is_valid_data_checksum_type(const ObDataChecksumType &type)
{
return is_valid_data_checksum_type(static_cast<int64_t>(type));
}
const char *data_check_checksum_type_to_str(const ObDataChecksumType type);
class ObTabletReplica
{
public:

2
src/storage/blocksstable/ob_major_checksum_info.cpp
View File

@ -150,7 +150,7 @@ int ObMajorChecksumInfo::init_from_sstable(
tmp_col_ckm_array.set_attr(ObMemAttr(MTL_ID(), "MajorCkmInfo"));
if (sstable.is_co_sstable()) {
const ObCOSSTableV2 &co_sstable = static_cast<const ObCOSSTableV2 &>(sstable);
if (OB_FAIL(co_sstable.fill_column_ckm_array(storage_schema, tmp_col_ckm_array))) {
if (OB_FAIL(co_sstable.fill_column_ckm_array(storage_schema, tmp_col_ckm_array, false /*need_process_cs_replica*/))) {
LOG_WARN("fail to fill column checksum array", K(ret), KPC(this), K(sstable));
}
} else if (OB_FAIL(sstable.fill_column_ckm_array(tmp_col_ckm_array))) {

8
src/storage/column_store/ob_co_merge_ctx.cpp
View File

@ -230,6 +230,10 @@ int ObCOTabletMergeCtx::prepare_schema()
LOG_INFO("[CS-Replica] finish prepare schema for co merge", K(ret),
"is_cs_replica", static_param_.is_cs_replica_, KPC(this));
}
if (FAILEDx(prepare_row_store_cg_schema())) {
LOG_WARN("failed to init major sstable status", K(ret));
}
return ret;
}
@ -239,8 +243,6 @@ int ObCOTabletMergeCtx::build_ctx(bool &finish_flag)
// finish_flag in this function is useless, just for virtual function definition.
if (OB_FAIL(ObBasicTabletMergeCtx::build_ctx(finish_flag))) {
LOG_WARN("failed to build basic ctx", KR(ret), "param", get_dag_param(), KPC(this));
} else if (OB_FAIL(init_major_sstable_status())) {
LOG_WARN("failed to init major sstable status", K(ret));
} else if (is_major_merge_type(get_merge_type())) {
// meta major merge not support row col switch now
if (is_build_row_store_from_rowkey_cg() && OB_FAIL(mock_row_store_table_read_info())) {
@ -755,7 +757,7 @@ int ObCOTabletMergeCtx::get_cg_schema_for_merge(const int64_t idx, const ObStora
return ret;
}
int ObCOTabletMergeCtx::init_major_sstable_status()
int ObCOTabletMergeCtx::prepare_row_store_cg_schema()
{
int ret = OB_SUCCESS;
ObSSTable *sstable = static_cast<ObSSTable *>(get_tables_handle().get_table(0));

2
src/storage/column_store/ob_co_merge_ctx.h
View File

@ -129,7 +129,7 @@ struct ObCOTabletMergeCtx : public ObBasicTabletMergeCtx
const uint32_t start_cg_idx,
const uint32_t end_cg_idx,
const bool check_info_ready) const;
int init_major_sstable_status();
int prepare_row_store_cg_schema();
int construct_column_param(
const uint64_t column_id,
const ObStorageColumnSchema *column_schema,

27
src/storage/column_store/ob_column_oriented_sstable.cpp
View File

@ -215,6 +215,27 @@ int ObCOSSTableMeta::deserialize(const char *buf, const int64_t data_len, int64_
return ret;
}
/************************************* ObCOMajorSSTableStatus *************************************/
const char* ObCOMajorSSTableStatusStr[] = {
"INVALID_STATUS",
"COL_WITH_ALL",
"COL_ONLY_ALL",
"PURE_COL",
"PURE_COL_ONLY_ALL",
"COL_REPLICA_MAJOR"
};
const char* co_major_sstable_status_to_str(const ObCOMajorSSTableStatus& major_sstable_status)
{
STATIC_ASSERT(static_cast<int64_t>(MAX_CO_MAJOR_SSTABLE_STATUS) == ARRAYSIZEOF(ObCOMajorSSTableStatusStr), "co major sstable str len is mismatch");
const char *str = "";
if (is_valid_co_major_sstable_status(major_sstable_status)) {
str = ObCOMajorSSTableStatusStr[major_sstable_status];
} else {
str = "invalid_co_major_status";
}
return str;
}
/************************************* ObCOSSTableV2 *************************************/
ObCOSSTableV2::ObCOSSTableV2()
@ -899,10 +920,12 @@ int ObCOSSTableV2::multi_get(
int ObCOSSTableV2::fill_column_ckm_array(
const ObStorageSchema &storage_schema,
ObIArray<int64_t> &column_checksums) const
ObIArray<int64_t> &column_checksums,
bool need_process_cs_replica) const
{
int ret = OB_SUCCESS;
if (is_cgs_empty_co_table()) {
// for cgs emtpy co table, only report rowkey cg/all cgs column checksum. but need report all columns for cs replica
if (is_cgs_empty_co_table() && !need_process_cs_replica) {
ret = ObSSTable::fill_column_ckm_array(column_checksums);
} else {
const common::ObIArray<ObStorageColumnGroupSchema> &column_groups = storage_schema.get_column_groups();

6
src/storage/column_store/ob_column_oriented_sstable.h
View File

@ -141,6 +141,7 @@ inline bool is_major_sstable_match_schema(const ObCOMajorSSTableStatus& major_ss
return major_sstable_status == COL_WITH_ALL || major_sstable_status == PURE_COL;
}
const char* co_major_sstable_status_to_str(const ObCOMajorSSTableStatus& major_sstable_status);
/*
* The base part of ObCOSSTable maybe
*/
@ -223,7 +224,10 @@ public:
ObTableAccessContext &context,
const common::ObIArray<blocksstable::ObDatumRowkey> &rowkeys,
ObStoreRowIterator *&row_iter) override;
int fill_column_ckm_array(const ObStorageSchema &storage_schema, ObIArray<int64_t> &column_checksums) const;
int fill_column_ckm_array(
const ObStorageSchema &storage_schema,
ObIArray<int64_t> &column_checksums,
bool need_process_cs_replica) const;
INHERIT_TO_STRING_KV("ObSSTable", ObSSTable, KP(this), K_(cs_meta),
K_(base_type), K_(is_cgs_empty_co), K_(valid_for_cs_reading));
private:

16
src/storage/compaction/ob_basic_tablet_merge_ctx.cpp
View File

@ -733,17 +733,6 @@ void ObBasicTabletMergeCtx::add_sstable_merge_info(
#define ADD_COMMENT(...) \
ADD_COMPACTION_INFO_PARAM(running_info.comment_, sizeof(running_info.comment_), __VA_ARGS__)
if (get_is_full_merge()) {
ADD_COMMENT("is_full_merge", true);
}
if (ObAdaptiveMergePolicy::AdaptiveMergeReason::NONE != static_param_.merge_reason_) {
ADD_COMMENT("merge_reason", ObAdaptiveMergePolicy::merge_reason_to_str(static_param_.merge_reason_));
}
if (is_major_merge_type(get_merge_type())
&& ObCOMajorMergePolicy::INVALID_CO_MAJOR_MERGE_TYPE != static_param_.co_major_merge_type_) {
ADD_COMMENT("major", static_param_.major_sstable_status_);
ADD_COMMENT("co", ObCOMajorMergePolicy::co_major_merge_type_to_str(static_param_.co_major_merge_type_));
}
// calc flush macro speed
uint32_t exe_ts = time_guard.get_specified_cost_time(ObStorageCompactionTimeGuard::EXECUTE);
if (exe_ts > 0 && block_info.new_micro_info_.get_data_micro_size() > 0) {
@ -751,7 +740,7 @@ void ObBasicTabletMergeCtx::add_sstable_merge_info(
int64_t io_percentage = block_info.block_io_us_ * 100 / (float)exe_ts;
ADD_COMMENT("block_io_us", block_info.block_io_us_);
if (io_percentage > 0) {
ADD_COMMENT("io_percent", io_percentage);
running_info.io_percentage_ = io_percentage;
}
}
int64_t mem_peak_mb = mem_ctx_.get_total_mem_peak() >> 20;
@ -1317,6 +1306,9 @@ int ObBasicTabletMergeCtx::init_sstable_merge_history()
static_history_.is_full_merge_ = static_param_.is_full_merge_;
static_history_.merge_level_ = static_param_.merge_level_;
static_history_.exec_mode_ = get_exec_mode();
static_history_.merge_reason_ = static_param_.merge_reason_;
static_history_.base_major_status_ = static_param_.major_sstable_status_;
static_history_.co_major_merge_type_ = static_param_.co_major_merge_type_;
if (!static_history_.is_valid()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("static info is invalid", KR(ret), K_(static_history));

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

@ -1267,7 +1267,6 @@ int ObMediumCompactionScheduleFunc::init_tablet_filters(share::ObTabletReplicaFi
int ObMediumCompactionScheduleFunc::check_tablet_checksum(
const ObReplicaCkmArray &checksum_items,
const ObLSColumnReplicaCache &ls_cs_replica_cache,
const int64_t start_idx,
const int64_t end_idx,
const bool is_medium_checker,
@ -1287,35 +1286,16 @@ int ObMediumCompactionScheduleFunc::check_tablet_checksum(
ObLSID prev_error_ls_id;
for (int64_t idx = start_idx; OB_SUCC(ret) && idx < end_idx; ++idx) {
const ObTabletReplicaChecksumItem &curr_item = checksum_items.at(idx);
bool is_cs_replica = false;
ObLSReplicaUniItem ls_item(curr_item.ls_id_, curr_item.server_);
const ObLSReplica *replica = nullptr;
bool can_skip = false;
if (OB_FAIL(ls_cs_replica_cache.check_can_skip(ls_item, can_skip))) {
LOG_WARN("failed to check item can skip", K(ret), K(ls_item), K(ls_cs_replica_cache));
} else if (can_skip) {
LOG_INFO("curr ls item should skip check", K(ls_item), K(ls_cs_replica_cache));
continue;
} else if (OB_FAIL(ls_cs_replica_cache.check_is_cs_replica(ls_item, is_cs_replica))) {
LOG_WARN("fail to check is column replica", K(ret), K(ls_item), K(ls_cs_replica_cache));
} else if (OB_ISNULL(prev_item)) {
if (OB_ISNULL(prev_item)) {
} else if (!curr_item.is_same_tablet(*prev_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("not continuous same tablet id", K(ret), K(curr_item), KPC(prev_item));
} else if (OB_TMP_FAIL(data_checksum_checker.check_data_checksum(curr_item, is_cs_replica))
} else if (OB_TMP_FAIL(data_checksum_checker.check_data_checksum(curr_item))
|| OB_TMP_FAIL(curr_item.verify_column_checksum(*prev_item))) {
if (OB_CHECKSUM_ERROR == tmp_ret) {
ObLSColumnReplicaCache dump_cache;
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(dump_cache.init())) {
LOG_WARN_RET(tmp_ret, "failed to init dump cache", K(MTL_ID()));
} else if (OB_TMP_FAIL(dump_cache.update(curr_item.ls_id_))) {
LOG_WARN_RET(tmp_ret, "failed to force refresh ls locality", K(curr_item));
}
LOG_DBA_ERROR(OB_CHECKSUM_ERROR, "msg", "checksum error in tablet replica checksum", KR(tmp_ret),
K(curr_item), KPC(prev_item), K(ls_cs_replica_cache), K(is_cs_replica), K(dump_cache), K(data_checksum_checker));
K(curr_item), KPC(prev_item), K(data_checksum_checker));
check_ret = OB_CHECKSUM_ERROR;
if (curr_item.ls_id_ != prev_error_ls_id) {
prev_error_ls_id = curr_item.ls_id_;
@ -1353,7 +1333,6 @@ int ObMediumCompactionScheduleFunc::check_tablet_checksum(
int ObMediumCompactionScheduleFunc::check_replica_checksum_items(
const ObReplicaCkmArray &checksum_items,
const ObLSColumnReplicaCache &ls_cs_replica_cache,
const bool is_medium_checker)
{
int ret = OB_SUCCESS;
@ -1375,8 +1354,8 @@ int ObMediumCompactionScheduleFunc::check_replica_checksum_items(
while (end_idx < count && tablet_id == checksum_items.at(end_idx).tablet_id_) {
end_idx++;
}
if (OB_FAIL(check_tablet_checksum(checksum_items, ls_cs_replica_cache, start_idx, end_idx, true /*is_medium_checker*/, error_pairs, check_ret))) {
LOG_WARN("failed to check tablet checksum", KR(ret), K(checksum_items), K(ls_cs_replica_cache), K(start_idx), K(end_idx), K(error_pairs));
if (OB_FAIL(check_tablet_checksum(checksum_items, start_idx, end_idx, true /*is_medium_checker*/, error_pairs, check_ret))) {
LOG_WARN("failed to check tablet checksum", KR(ret), K(checksum_items), K(start_idx), K(end_idx), K(error_pairs));
} else {
// update medium compaction info
if (is_medium_checker && OB_SUCCESS == check_ret) {
@ -1425,8 +1404,7 @@ int ObMediumCompactionScheduleFunc::batch_check_medium_finish(
const hash::ObHashMap<ObLSID, share::ObLSInfo> &ls_info_map,
ObIArray<ObTabletCheckInfo> &finish_tablet_ls_infos,
const ObIArray<ObTabletCheckInfo> &tablet_ls_infos,
ObCompactionTimeGuard &time_guard,
const share::ObLSColumnReplicaCache &ls_cs_replica_cache)
ObCompactionTimeGuard &time_guard)
{
int ret = OB_SUCCESS;
if (tablet_ls_infos.empty()) {
@ -1442,7 +1420,7 @@ int ObMediumCompactionScheduleFunc::batch_check_medium_finish(
MTL_ID(), finish_tablet_ls_infos, checksum_items))) {
LOG_WARN("failed to get tablet checksum", K(ret));
} else if (FALSE_IT(time_guard.click(ObCompactionScheduleTimeGuard::SEARCH_CHECKSUM))) {
} else if (OB_FAIL(check_replica_checksum_items(checksum_items, ls_cs_replica_cache, true /*is_medium_checker*/))) {
} else if (OB_FAIL(check_replica_checksum_items(checksum_items, true /*is_medium_checker*/))) {
LOG_WARN("fail to check replica checksum items for medium checker", K(ret));
} else if (FALSE_IT(time_guard.click(ObCompactionScheduleTimeGuard::CHECK_CHECKSUM))) {
}

5
src/storage/compaction/ob_medium_compaction_func.h
View File

@ -93,11 +93,9 @@ public:
const hash::ObHashMap<ObLSID, share::ObLSInfo> &ls_info_map,
ObIArray<ObTabletCheckInfo> &finish_tablet_ls_infos,
const ObIArray<ObTabletCheckInfo> &tablet_ls_infos,
ObCompactionTimeGuard &time_guard,
const share::ObLSColumnReplicaCache &ls_cs_replica_cache);
ObCompactionTimeGuard &time_guard);
static int check_replica_checksum_items(
const ObReplicaCkmArray &checksum_items,
const ObLSColumnReplicaCache &ls_cs_replica_cache,
const bool is_medium_checker);
static int check_need_merge_and_schedule(
ObLS &ls,
@ -166,7 +164,6 @@ protected:
static int init_tablet_filters(share::ObTabletReplicaFilterHolder &filters);
static int check_tablet_checksum(
const share::ObReplicaCkmArray &checksum_items,
const ObLSColumnReplicaCache &ls_cs_replica_cache,
const int64_t start_idx,
const int64_t end_idx,
const bool is_medium_checker,

12
src/storage/compaction/ob_sstable_merge_history.cpp
View File

@ -120,6 +120,9 @@ ObMergeStaticInfo::ObMergeStaticInfo()
participant_table_info_(),
merge_level_(MERGE_LEVEL_MAX),
exec_mode_(ObExecMode::EXEC_MODE_MAX),
merge_reason_(ObAdaptiveMergePolicy::NONE),
base_major_status_(ObCOMajorSSTableStatus::INVALID_CO_MAJOR_SSTABLE_STATUS),
co_major_merge_type_(ObCOMajorMergePolicy::INVALID_CO_MAJOR_MERGE_TYPE),
is_full_merge_(false),
is_fake_(false)
{}
@ -145,6 +148,9 @@ void ObMergeStaticInfo::reset()
participant_table_info_.reset();
merge_level_ = MERGE_LEVEL_MAX;
exec_mode_ = ObExecMode::EXEC_MODE_MAX;
merge_reason_ = ObAdaptiveMergePolicy::NONE;
base_major_status_ = ObCOMajorSSTableStatus::INVALID_CO_MAJOR_SSTABLE_STATUS;
co_major_merge_type_ = ObCOMajorMergePolicy::INVALID_CO_MAJOR_MERGE_TYPE;
is_full_merge_ = false;
}
@ -161,6 +167,9 @@ void ObMergeStaticInfo::shallow_copy(const ObMergeStaticInfo &other)
participant_table_info_ = other.participant_table_info_;
merge_level_ = other.merge_level_;
exec_mode_ = other.exec_mode_;
merge_reason_ = other.merge_reason_;
base_major_status_ = other.base_major_status_;
co_major_merge_type_ = other.co_major_merge_type_;
is_full_merge_ = other.is_full_merge_;
}
/**
@ -171,6 +180,7 @@ ObMergeRunningInfo::ObMergeRunningInfo()
merge_finish_time_(0),
start_cg_idx_(0),
end_cg_idx_(0),
io_percentage_(0),
dag_id_(),
parallel_merge_info_(),
comment_("\0")
@ -182,6 +192,7 @@ void ObMergeRunningInfo::reset()
merge_finish_time_ = 0;
start_cg_idx_ = 0;
end_cg_idx_ = 0;
io_percentage_ = 0;
dag_id_.reset();
parallel_merge_info_.reset();
MEMSET(comment_, '\0', sizeof(comment_));
@ -198,6 +209,7 @@ void ObMergeRunningInfo::shallow_copy(const ObMergeRunningInfo &other)
merge_finish_time_ = other.merge_finish_time_;
start_cg_idx_ = other.start_cg_idx_;
end_cg_idx_ = other.end_cg_idx_;
io_percentage_ = other.io_percentage_;
dag_id_ = other.dag_id_;
parallel_merge_info_ = other.parallel_merge_info_;
MEMSET(comment_, '\0', sizeof(comment_));

12
src/storage/compaction/ob_sstable_merge_history.h
View File

@ -111,7 +111,11 @@ struct ObMergeStaticInfo
TO_STRING_KV(K_(ls_id), K_(tablet_id), "merge_type", merge_type_to_str(merge_type_),
K_(compaction_scn), K_(is_full_merge), K_(concurrent_cnt),
"merge_level", merge_level_to_str(merge_level_),
"exec_mode", exec_mode_to_str(exec_mode_), K_(kept_snapshot_info), K_(participant_table_info),
"exec_mode", exec_mode_to_str(exec_mode_),
"merge_reason", ObAdaptiveMergePolicy::merge_reason_to_str(merge_reason_),
"base_major_status", co_major_sstable_status_to_str(base_major_status_),
"co_major_merge_type", ObCOMajorMergePolicy::co_major_merge_type_to_str(co_major_merge_type_),
K_(kept_snapshot_info), K_(participant_table_info),
K_(progressive_merge_round), K_(progressive_merge_num), K_(is_fake));
share::ObLSID ls_id_;
@ -125,6 +129,9 @@ struct ObMergeStaticInfo
PartTableInfo participant_table_info_;
ObMergeLevel merge_level_;
ObExecMode exec_mode_;
ObAdaptiveMergePolicy::AdaptiveMergeReason merge_reason_;
ObCOMajorSSTableStatus base_major_status_;
ObCOMajorMergePolicy::ObCOMajorMergeType co_major_merge_type_;
bool is_full_merge_;
bool is_fake_;
};
@ -140,12 +147,13 @@ struct ObMergeRunningInfo
static const int64_t MERGE_INFO_COMMENT_LENGTH = 256;
TO_STRING_KV(K_(merge_start_time), K_(merge_finish_time), K_(dag_id),
"merge_cost_time", merge_finish_time_ - merge_start_time_,
K_(start_cg_idx), K_(end_cg_idx), K_(parallel_merge_info));
K_(start_cg_idx), K_(end_cg_idx), K_(io_percentage), K_(parallel_merge_info));
int64_t merge_start_time_;
int64_t merge_finish_time_;
int64_t start_cg_idx_;
int64_t end_cg_idx_;
int64_t io_percentage_;
common::ObCurTraceId::TraceId dag_id_;
ObParalleMergeInfo parallel_merge_info_;
char comment_[MERGE_INFO_COMMENT_LENGTH];

12
src/storage/compaction/ob_tenant_medium_checker.cpp
View File

@ -219,20 +219,15 @@ int ObTenantMediumChecker::check_medium_finish_schedule()
{
int ret = OB_SUCCESS;
int tmp_ret = OB_SUCCESS;
ObLSColumnReplicaCache cs_replica_cache; // a copy one from ls_locality_cache_
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("ObTenantMediumChecker is not inited", K(ret));
} else if (OB_FAIL(cs_replica_cache.init())) {
LOG_WARN("failed to init cs_replica_cache", K(ret));
} else {
lib::ObMutexGuard guard(lock_);
if (OB_FAIL(ls_locality_cache_.refresh_ls_locality(false /*force_refresh*/))) {
LOG_WARN("failed to refresh ls locality");
ADD_COMMON_SUSPECT_INFO(MEDIUM_MERGE, share::ObDiagnoseTabletType::TYPE_MEDIUM_MERGE,
SUSPECT_FAILED_TO_REFRESH_LS_LOCALITY, ret);
} else if (OB_FAIL(cs_replica_cache.assign(ls_locality_cache_.get_cs_replica_cache()))) {
LOG_WARN("failed to assign cs_replica_cache", K(ret));
}
}
@ -275,7 +270,7 @@ int ObTenantMediumChecker::check_medium_finish_schedule()
int64_t cost_ts = ObTimeUtility::fast_current_time();
ObBatchFinishCheckStat stat;
while (start_idx < end_idx) {
if (OB_TMP_FAIL(check_medium_finish(tablet_ls_infos, start_idx, end_idx, batch_tablet_ls_infos, finish_tablet_ls_infos, stat, cs_replica_cache))) {
if (OB_TMP_FAIL(check_medium_finish(tablet_ls_infos, start_idx, end_idx, batch_tablet_ls_infos, finish_tablet_ls_infos, stat))) {
LOG_WARN("failed to check medium finish", K(tmp_ret));
}
start_idx = end_idx;
@ -298,8 +293,7 @@ int ObTenantMediumChecker::check_medium_finish(
int64_t end_idx,
ObIArray<ObTabletCheckInfo> &check_tablet_ls_infos,
ObIArray<ObTabletCheckInfo> &finish_tablet_ls_infos,
ObBatchFinishCheckStat &stat,
const share::ObLSColumnReplicaCache &ls_cs_replica_cache)
ObBatchFinishCheckStat &stat)
{
int ret = OB_SUCCESS;
int tmp_ret = OB_SUCCESS;
@ -329,7 +323,7 @@ int ObTenantMediumChecker::check_medium_finish(
ObCompactionScheduleTimeGuard time_guard;
stat.filter_cnt_ += (end_idx - start_idx - check_tablet_ls_infos.count());
if (FAILEDx(ObMediumCompactionScheduleFunc::batch_check_medium_finish(
ls_info_map_, finish_tablet_ls_infos, check_tablet_ls_infos, time_guard, ls_cs_replica_cache))) {
ls_info_map_, finish_tablet_ls_infos, check_tablet_ls_infos, time_guard))) {
LOG_WARN("failed to batch check medium finish", K(ret), K(tablet_ls_infos.count()), K(check_tablet_ls_infos.count()),
K(tablet_ls_infos), K(check_tablet_ls_infos));
stat.fail_cnt_ += check_tablet_ls_infos.count();

3
src/storage/compaction/ob_tenant_medium_checker.h
View File

@ -95,8 +95,7 @@ public:
int64_t end_idx,
ObIArray<ObTabletCheckInfo> &check_tablet_ls_infos,
ObIArray<ObTabletCheckInfo> &finish_tablet_ls_infos,
ObBatchFinishCheckStat &stat,
const share::ObLSColumnReplicaCache &ls_cs_replica_cache);
ObBatchFinishCheckStat &stat);
int add_tablet_ls(const ObTabletID &tablet_id, const share::ObLSID &ls_id, const int64_t medium_scn);
bool locality_cache_empty();
TO_STRING_KV(K_(is_inited), K_(ls_locality_cache));

30
src/storage/high_availability/ob_storage_ha_utils.cpp
View File

@ -210,7 +210,6 @@ int ObStorageHAUtils::check_tablet_replica_checksum_(const uint64_t tenant_id, c
LOG_WARN("failed to batch get replica checksum item", K(ret), K(tenant_id), K(pairs), K(compaction_scn));
} else {
ObArray<share::ObTabletReplicaChecksumItem> filter_items;
ObLSColumnReplicaCache ls_cs_replica_cache;
ObTabletDataChecksumChecker data_checksum_checker;
for (int64_t i = 0; OB_SUCC(ret) && i < items.count(); ++i) {
const ObTabletReplicaChecksumItem &item = items.at(i);
@ -221,38 +220,15 @@ int ObStorageHAUtils::check_tablet_replica_checksum_(const uint64_t tenant_id, c
}
}
if (FAILEDx(ls_cs_replica_cache.init())) {
LOG_WARN("failed to init ls column replica cache", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < filter_items.count(); ++i) {
const ObTabletReplicaChecksumItem &item = filter_items.at(i);
if (OB_FAIL(ls_cs_replica_cache.update(item.ls_id_))) {
LOG_WARN("fail to update ls replica status", K(ret), K(item));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < filter_items.count(); ++i) {
const ObTabletReplicaChecksumItem &first_item = filter_items.at(0);
const ObTabletReplicaChecksumItem &item = filter_items.at(i);
const ObLSReplicaUniItem ls_item(item.ls_id_, item.server_);
bool is_cs_replica = false;
bool can_skip = false;
const ObLSReplica *replica = nullptr;
if (OB_FAIL(ls_cs_replica_cache.check_can_skip(ls_item, can_skip))) {
LOG_WARN("failed to get ls replica", K(ret), K(ls_item), K(ls_cs_replica_cache));
} else if (can_skip) {
LOG_INFO("cur ls item can be skip", K(ret), K(ls_item), K(ls_cs_replica_cache));
continue;
} else if (OB_FAIL(ls_cs_replica_cache.check_is_cs_replica(ls_item, is_cs_replica))) {
LOG_WARN("fail to check is cs replica", K(ret), K(ls_item), K(ls_cs_replica_cache));
} else if (OB_FAIL(data_checksum_checker.check_data_checksum(item, is_cs_replica))) {
if (OB_FAIL(data_checksum_checker.check_data_checksum(item))) {
LOG_ERROR("failed to verify data checksum", K(ret), K(tenant_id), K(tablet_id),
K(ls_id), K(compaction_scn), K(item), K(filter_items), K(is_cs_replica), K(ls_cs_replica_cache));
K(ls_id), K(compaction_scn), K(item), K(filter_items));
} else if (OB_FAIL(item.verify_column_checksum(first_item))) {
LOG_ERROR("failed to verify column checksum", K(ret), K(tenant_id), K(tablet_id),
K(ls_id), K(compaction_scn), K(first_item), K(item), K(filter_items), K(is_cs_replica), K(ls_cs_replica_cache));
K(ls_id), K(compaction_scn), K(first_item), K(item), K(filter_items));
}
}
}

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

@ -5740,7 +5740,7 @@ int ObTablet::update_tablet_autoinc_seq(const uint64_t autoinc_seq)
return ret;
}
int ObTablet::check_cs_replica_compat_schema(bool &is_cs_replica_compat)
int ObTablet::check_cs_replica_compat_schema(bool &is_cs_replica_compat) const
{
int ret = OB_SUCCESS;
is_cs_replica_compat = false;
@ -6150,6 +6150,7 @@ int ObTablet::get_tablet_report_info_by_sstable(
ObArray<int64_t> column_checksums;
column_checksums.set_attr(ObMemAttr(MTL_ID(), "tmpCkmArr"));
ObSSTable *table = nullptr;
bool is_cs_replica_compat = false;
if (OB_UNLIKELY(nullptr == main_major || report_major_snapshot != main_major->get_snapshot_version())) {
if (GCTX.is_shared_storage_mode()) {
ret = OB_EAGAIN;
@ -6193,6 +6194,8 @@ int ObTablet::get_tablet_report_info_by_sstable(
LOG_WARN("fail to init a tablet replica", KR(ret), "tablet_id", get_tablet_id(), K(tablet_replica));
} else if (!need_checksums) {
// do nothing
} else if (OB_FAIL(check_cs_replica_compat_schema(is_cs_replica_compat))) {
LOG_WARN("fail to check cs replica compat", K(ret), K(is_cs_replica_compat));
} else if (OB_FAIL(get_sstable_column_checksum(*main_major, column_checksums))) {
LOG_WARN("fail to get sstable column checksum", K(ret), KPC(main_major));
} else if (OB_FAIL(tablet_checksum.set_tenant_id(MTL_ID()))) {
@ -6207,6 +6210,7 @@ int ObTablet::get_tablet_report_info_by_sstable(
tablet_checksum.server_ = addr;
tablet_checksum.row_count_ = get_tablet_meta().report_status_.row_count_;
tablet_checksum.data_checksum_ = get_tablet_meta().report_status_.data_checksum_;
tablet_checksum.data_checksum_type_ = is_cs_replica_compat ? ObDataChecksumType::DATA_CHECKSUM_COLUMN_STORE : ObDataChecksumType::DATA_CHECKSUM_NORMAL;
LOG_INFO("success to get tablet report info", KR(ret), "tablet_id", get_tablet_id(), "report_status",
tablet_meta_.report_status_, K(tablet_checksum));
}
@ -7905,7 +7909,7 @@ int ObTablet::get_sstable_column_checksum(
ObArenaAllocator allocator;
if (OB_FAIL(load_storage_schema(allocator, storage_schema))) {
LOG_WARN("fail to load storage schema", K(ret));
} else if (OB_FAIL(static_cast<const ObCOSSTableV2 *>(&sstable)->fill_column_ckm_array(*storage_schema, column_checksums))) {
} else if (OB_FAIL(static_cast<const ObCOSSTableV2 *>(&sstable)->fill_column_ckm_array(*storage_schema, column_checksums, storage_schema->is_cs_replica_compat()))) {
LOG_WARN("fail to fill_column_ckm_array", K(ret), K(sstable));
}
ObTabletObjLoadHelper::free(allocator, storage_schema);

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

@ -467,7 +467,7 @@ public:
int get_migration_sstable_size(int64_t &data_size);
// column store replica
int check_cs_replica_compat_schema(bool &is_cs_replica_compat);
int check_cs_replica_compat_schema(bool &is_cs_replica_compat) const;
int pre_process_cs_replica(ObTabletDirectLoadInsertParam &direct_load_param);
// other

10
tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_mysql.result
View File

@ -2951,6 +2951,11 @@ END_CG_ID bigint(20) NO NULL
KEPT_SNAPSHOT varchar(128) NO NULL
MERGE_LEVEL varchar(64) NO NULL
EXEC_MODE varchar(64) NO NULL
IS_FULL_MERGE varchar(5) NO NULL
IO_COST_TIME_PERCENTAGE bigint(20) NO NULL
MERGE_REASON varchar(32) NO NULL
BASE_MAJOR_STATUS varchar(64) NO NULL
CO_MERGE_TYPE varchar(64) NO NULL
select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.GV$OB_TABLET_COMPACTION_HISTORY limit 1);
cnt
1
@ -2987,6 +2992,11 @@ END_CG_ID bigint(20) NO
KEPT_SNAPSHOT varchar(128) NO
MERGE_LEVEL varchar(64) NO
EXEC_MODE varchar(64) NO
IS_FULL_MERGE varchar(5) NO
IO_COST_TIME_PERCENTAGE bigint(20) NO
MERGE_REASON varchar(32) NO
BASE_MAJOR_STATUS varchar(64) NO
CO_MERGE_TYPE varchar(64) NO
select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.V$OB_TABLET_COMPACTION_HISTORY limit 1);
cnt
1

10
tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_sys.result
View File

@ -4237,6 +4237,11 @@ END_CG_ID bigint(20) NO NULL
KEPT_SNAPSHOT varchar(128) NO NULL
MERGE_LEVEL varchar(64) NO NULL
EXEC_MODE varchar(64) NO NULL
IS_FULL_MERGE varchar(5) NO NULL
IO_COST_TIME_PERCENTAGE bigint(20) NO NULL
MERGE_REASON varchar(32) NO NULL
BASE_MAJOR_STATUS varchar(64) NO NULL
CO_MERGE_TYPE varchar(64) NO NULL
select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.GV$OB_TABLET_COMPACTION_HISTORY limit 1);
cnt
1
@ -4273,6 +4278,11 @@ END_CG_ID bigint(20) NO
KEPT_SNAPSHOT varchar(128) NO
MERGE_LEVEL varchar(64) NO
EXEC_MODE varchar(64) NO
IS_FULL_MERGE varchar(5) NO
IO_COST_TIME_PERCENTAGE bigint(20) NO
MERGE_REASON varchar(32) NO
BASE_MAJOR_STATUS varchar(64) NO
CO_MERGE_TYPE varchar(64) NO
select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.V$OB_TABLET_COMPACTION_HISTORY limit 1);
cnt
1

5
tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_mysql.result
View File

@ -1438,6 +1438,11 @@ end_cg_id bigint(20) NO NULL
kept_snapshot varchar(128) NO NULL
merge_level varchar(64) NO NULL
exec_mode varchar(64) NO NULL
is_full_merge tinyint(4) NO NULL
io_cost_time_percentage bigint(20) NO NULL
merge_reason varchar(32) NO NULL
base_major_status varchar(64) NO NULL
co_merge_type varchar(64) NO NULL
select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_tablet_compaction_history;
IF(count(*) >= 0, 1, 0)
1

6
tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_sys.result
View File

@ -1862,6 +1862,11 @@ end_cg_id bigint(20) NO NULL
kept_snapshot varchar(128) NO NULL
merge_level varchar(64) NO NULL
exec_mode varchar(64) NO NULL
is_full_merge tinyint(4) NO NULL
io_cost_time_percentage bigint(20) NO NULL
merge_reason varchar(32) NO NULL
base_major_status varchar(64) NO NULL
co_merge_type varchar(64) NO NULL
select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_tablet_compaction_history;
IF(count(*) >= 0, 1, 0)
1
@ -5946,6 +5951,7 @@ row_count bigint(20) NO NULL
data_checksum bigint(20) NO NULL
column_checksums longtext YES NULL
b_column_checksums varbinary(65536) YES NULL
data_checksum_type bigint(20) NO 0
select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_tablet_replica_checksum;
IF(count(*) >= 0, 1, 0)
1

3
unittest/share/compaction/CMakeLists.txt
View File

@ -1 +1,2 @@
storage_unittest(test_compaction_time_guard)
storage_unittest(test_compaction_time_guard)
storage_unittest(test_checksum_operator)

84
unittest/share/compaction/test_checksum_operator.cpp Normal file
View File

@ -0,0 +1,84 @@
/**
* Copyright (c) 2024 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#include "share/ob_dml_sql_splicer.h"
#include <gtest/gtest.h>
#define USING_LOG_PREFIX STORAGE
#define protected public
#define private public
namespace oceanbase
{
namespace unittest
{
TEST(ObPTSqlSplicer, batch) {
int ret = OB_SUCCESS;
share::ObDMLSqlSplicer splicer;
ObSqlString sql;
ObString result("INSERT INTO tname (gmt_modified, gmt_create, tenant_id, tablet_id, svr_ip, svr_port, ls_id, compaction_scn, row_count, data_checksum, column_checksums, b_column_checksums) VALUES "
"(now(6),now(6),1004,200001,'127.0.0.1',1001,1001,1234567890,100,1234567,'column_checksums-01','b_column_checksums-01'), "
"(now(6),now(6),1004,200001,'127.0.0.2',1002,1001,1234567890,100,1234567,'column_checksums-02','b_column_checksums-02'), "
"(now(6),now(6),1004,200001,'127.0.0.3',1003,1001,1234567890,100,1234567,'column_checksums-03','b_column_checksums-03') "
"ON DUPLICATE KEY UPDATE "
"gmt_modified=VALUES(gmt_modified),"
"gmt_create=VALUES(gmt_create),"
"tenant_id=VALUES(tenant_id),"
"tablet_id=VALUES(tablet_id),"
"svr_ip=VALUES(svr_ip),"
"svr_port=VALUES(svr_port),"
"ls_id=VALUES(ls_id),"
"compaction_scn=VALUES(compaction_scn),"
"row_count=VALUES(row_count),"
"data_checksum=VALUES(data_checksum),"
"column_checksums=VALUES(column_checksums),"
"b_column_checksums=VALUES(b_column_checksums)");
ObAddr ips[3];
ObString column_checksums[3] = {"column_checksums-01", "column_checksums-02", "column_checksums-03"};
ObString b_column_checksums[3] = {"b_column_checksums-01", "b_column_checksums-02", "b_column_checksums-03"};
ASSERT_TRUE(ips[0].set_ip_addr("127.0.0.1", 1001));
ASSERT_TRUE(ips[1].set_ip_addr("127.0.0.2", 1002));
ASSERT_TRUE(ips[2].set_ip_addr("127.0.0.3", 1003));
char ip[OB_MAX_SERVER_ADDR_SIZE] = "";
for (int64_t i = 0; i < 3; i++) {
ASSERT_TRUE(ips[i].ip_to_string(ip, sizeof(ip)));
ASSERT_EQ(OB_SUCCESS, splicer.add_gmt_modified());
ASSERT_EQ(OB_SUCCESS, splicer.add_gmt_create());
ASSERT_EQ(OB_SUCCESS, splicer.add_pk_column("tenant_id", 1004));
ASSERT_EQ(OB_SUCCESS, splicer.add_pk_column("tablet_id", 200001));
ASSERT_EQ(OB_SUCCESS, splicer.add_pk_column("svr_ip", ip));
ASSERT_EQ(OB_SUCCESS, splicer.add_pk_column("svr_port", ips[i].get_port()));
ASSERT_EQ(OB_SUCCESS, splicer.add_pk_column("ls_id", 1001));
ASSERT_EQ(OB_SUCCESS, splicer.add_column("compaction_scn", 1234567890));
ASSERT_EQ(OB_SUCCESS, splicer.add_column("row_count", 100));
ASSERT_EQ(OB_SUCCESS, splicer.add_column("data_checksum", 1234567));
ASSERT_EQ(OB_SUCCESS, splicer.add_column("column_checksums", column_checksums[i]));
ASSERT_EQ(OB_SUCCESS, splicer.add_column("b_column_checksums", b_column_checksums[i]));
ASSERT_EQ(OB_SUCCESS, splicer.finish_row());
}
ASSERT_EQ(OB_SUCCESS, splicer.splice_batch_insert_update_sql("tname", sql));
LOG_INFO("finish splice batch insert update sql", K(ret), K(sql), K(result));
ASSERT_EQ(0, result.compare(sql.string()));
}
} // end unittest
} // end namespace oceanbase
int main(int argc, char **argv)
{
oceanbase::common::ObLogger::get_logger().set_log_level("INFO");
OB_LOGGER.set_log_level("INFO");
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}