hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
ab743ff0d39a0bf1ca14488d178b6545e4736a6b
oceanbase/src/storage/ob_row_fuse.cpp
obdev 94816acd47 patch code from 3_1_x_release
2021-07-15 11:39:13 +08:00

402 lines
15 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 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 "storage/ob_row_fuse.h"
namespace oceanbase {
using namespace oceanbase::common;
namespace storage {
int ObNopPos::init(ObIAllocator& allocator, const int64_t capacity)
{
int ret = OB_SUCCESS;
if (capacity <= 0) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "invalid argument", K(ret), K(capacity));
} else {
if (capacity <= capacity_) {
} else {
free();
if (NULL == (nops_ = static_cast<int16_t*>(allocator.alloc(sizeof(int16_t) * capacity)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(ERROR, "no memory", K(ret), K(capacity));
} else {
allocator_ = &allocator;
capacity_ = capacity;
}
}
}
return ret;
}
void ObNopPos::free()
{
if (nullptr != nops_ && nullptr != allocator_) {
allocator_->free(nops_);
nops_ = nullptr;
}
capacity_ = 0;
count_ = 0;
}
void ObNopPos::destroy()
{
free();
allocator_ = NULL;
}
int ObNopPos::get_nop_pos(const int64_t idx, int64_t& pos)
{
int ret = OB_SUCCESS;
if (idx < 0 || idx >= count_) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "invalid argument", K(ret));
} else {
pos = nops_[idx];
}
return ret;
}
int ObNopPos::set_count(const int64_t count)
{
int ret = OB_SUCCESS;
if (capacity_ <= 0 || count < 0 || count > capacity_) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "wrong nop count", K(ret), K(count), K_(capacity));
} else {
count_ = count;
}
return ret;
}
int ObNopPos::set_nop_pos(const int64_t idx, const int64_t pos)
{
int ret = OB_SUCCESS;
if (capacity_ <= 0 || idx < 0 || idx >= capacity_ || pos < 0) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "wrong nop count", K(ret), K(idx), K_(capacity), K(pos));
} else {
nops_[idx] = static_cast<int16_t>(pos);
}
return ret;
}
ObObjShallowCopy ObRowFuse::shallow_copy_;
template <typename T>
OB_INLINE static int complex_fuse_row(const ObStoreRow& former, ObStoreRow& result, ObNopPos& nop_pos,
bool& final_result, const common::ObIArray<int32_t>* col_idxs, bool* column_changed, const int64_t column_count,
T& obj_copy)
{
int ret = common::OB_SUCCESS;
if (OB_UNLIKELY(!former.is_valid()) || OB_ISNULL(result.row_val_.cells_) || !nop_pos.is_valid()) {
ret = common::OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid arguments, ", K(former), K(result), K(nop_pos.count()), K(ret));
} else if (common::ObActionFlag::OP_DEL_ROW != result.flag_) {
final_result = false;
bool first_val = (0 == result.row_val_.count_ || common::ObActionFlag::OP_ROW_DOES_NOT_EXIST == result.flag_);
int64_t cnt = 0;
if (first_val) {
nop_pos.reset();
result.flag_ = former.flag_;
result.from_base_ = former.from_base_;
cnt = (NULL == col_idxs) ? former.row_val_.count_ : col_idxs->count();
} else {
cnt = nop_pos.count_;
}
if (cnt > column_count && NULL != column_changed) {
ret = common::OB_ERR_SYS;
STORAGE_LOG(ERROR, "column count not match", K(ret), K(cnt), K(column_count));
} else if (common::ObActionFlag::OP_ROW_DOES_NOT_EXIST == former.flag_) {
// skip, do nothing
} else if (common::ObActionFlag::OP_DEL_ROW == former.flag_) {
final_result = true;
} else if (common::ObActionFlag::OP_ROW_EXIST == former.flag_) {
if (OB_UNLIKELY(common::ObActionFlag::OP_ROW_EXIST == result.flag_ && result.row_val_.is_valid() &&
nop_pos.count() > result.row_val_.count_ &&
(NULL == col_idxs && result.row_val_.count_ != former.row_val_.count_)) &&
(NULL != col_idxs && result.row_val_.count_ != col_idxs->count())) {
ret = common::OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid arguments", K(ret), K(former), K(result), K(nop_pos.count()), K(*col_idxs));
} else {
int64_t column_cnt = (NULL == col_idxs) ? former.row_val_.count_ : col_idxs->count();
int64_t idx = -1;
int64_t left_cnt = 0;
int64_t former_idx = -1;
bool is_former_nop = true;
for (int64_t i = 0; OB_SUCC(ret) && i < cnt; i++) {
idx = first_val ? i : nop_pos.nops_[i];
former_idx = (NULL == col_idxs) ? idx : col_idxs->at(idx);
if (former_idx == -1) {
// skip the not exist column
continue;
}
is_former_nop = former.row_val_.cells_[former_idx].is_nop_value();
if (first_val) {
if (OB_FAIL(obj_copy(former.row_val_.cells_[former_idx], result.row_val_.cells_[idx]))) {
STORAGE_LOG(WARN, "failed to copy obj", K(ret), K(former_idx), K(idx));
} else {
if (is_former_nop) {
nop_pos.nops_[left_cnt++] = static_cast<int16_t>(idx);
} else if (NULL != column_changed && !former.from_base_) {
column_changed[idx] = true;
}
}
} else {
if (is_former_nop) {
nop_pos.nops_[left_cnt++] = static_cast<int16_t>(idx);
} else {
if (OB_FAIL(obj_copy(former.row_val_.cells_[former_idx], result.row_val_.cells_[idx]))) {
STORAGE_LOG(WARN, "failed to copy obj", K(ret), K(former_idx), K(idx));
} else {
if (NULL != column_changed && !former.from_base_) {
column_changed[idx] = true;
}
}
}
}
}
final_result = (0 == left_cnt);
result.row_val_.count_ = column_cnt;
nop_pos.count_ = left_cnt;
}
} else {
ret = common::OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "wrong row flag", K(ret));
}
}
return ret;
}
template <typename T>
OB_INLINE static int simple_fuse_row(
const ObStoreRow& former, ObStoreRow& result, ObNopPos& nop_pos, bool& final_result, T& obj_copy)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!former.is_valid()) || OB_ISNULL(result.row_val_.cells_) || !nop_pos.is_valid()) {
ret = common::OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN,
"Invalid arguments, ",
K(former),
K(former.is_valid()),
KP(result.row_val_.cells_),
K(nop_pos.count()),
K(nop_pos.capacity()),
K(ret));
} else if (common::ObActionFlag::OP_DEL_ROW == result.flag_ ||
common::ObActionFlag::OP_ROW_DOES_NOT_EXIST == former.flag_) {
// do nothing
} else {
final_result = false;
bool first_val = (0 == result.row_val_.count_ || common::ObActionFlag::OP_ROW_DOES_NOT_EXIST == result.flag_);
int64_t column_cnt = 0;
if (first_val) {
nop_pos.reset();
result.flag_ = former.flag_;
result.from_base_ = former.from_base_;
result.dml_ = former.dml_;
column_cnt = former.row_val_.count_;
} else {
column_cnt = nop_pos.count_;
}
if (common::ObActionFlag::OP_DEL_ROW == former.flag_) {
final_result = true;
if (first_val) { // copy rowkey
result.row_val_.count_ = former.row_val_.count_;
for (int i = 0; OB_SUCC(ret) && i < former.row_val_.count_; ++i) {
if (OB_FAIL(obj_copy(former.row_val_.cells_[i], result.row_val_.cells_[i]))) {
STORAGE_LOG(WARN, "failed to copy obj", K(ret), K(i), K(former.row_val_.cells_[i]));
}
}
}
} else if (common::ObActionFlag::OP_ROW_EXIST == former.flag_) {
if (OB_UNLIKELY(common::ObActionFlag::OP_ROW_EXIST == result.flag_ && result.row_val_.is_valid() &&
nop_pos.count() > result.row_val_.count_ && result.row_val_.count_ != former.row_val_.count_)) {
ret = common::OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid arguments", K(ret), K(former), K(result), K(nop_pos.count()));
} else {
STORAGE_LOG(DEBUG, "start to fuse", K(former), K(result), K(nop_pos.count()));
int64_t idx = -1;
int64_t left_cnt = 0;
bool is_former_nop = true;
for (int64_t i = 0; OB_SUCC(ret) && i < column_cnt; i++) {
idx = first_val ? i : nop_pos.nops_[i];
is_former_nop = former.row_val_.cells_[idx].is_nop_value();
if (is_former_nop) {
nop_pos.nops_[left_cnt++] = static_cast<int16_t>(idx);
}
if (is_former_nop && !first_val) {
// do nothing
} else if (OB_FAIL(obj_copy(former.row_val_.cells_[idx], result.row_val_.cells_[idx]))) {
STORAGE_LOG(WARN, "failed to copy obj", K(ret), K(idx), K(former.row_val_.cells_[idx]));
}
}
final_result = (0 == left_cnt);
result.row_val_.count_ = former.row_val_.count_;
nop_pos.count_ = left_cnt;
}
} else {
ret = common::OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "wrong row flag", K(ret));
}
}
return ret;
}
int ObRowFuse::fuse_row(const ObStoreRow& former, ObStoreRow& result, ObNopPos& nop_pos, bool& final_result,
const common::ObIArray<int32_t>* col_idxs, bool* column_changed, const int64_t column_count,
ObObjDeepCopy* obj_copy)
{
int ret = OB_SUCCESS;
if (nullptr == obj_copy) {
if (OB_FAIL(complex_fuse_row(
former, result, nop_pos, final_result, col_idxs, column_changed, column_count, shallow_copy_))) {
STORAGE_LOG(WARN,
"fail to fuse complex row with shallow copy",
K(ret),
K(former),
K(result),
KP(col_idxs),
KP(column_changed),
K(column_count));
}
} else {
if (OB_FAIL(complex_fuse_row(
former, result, nop_pos, final_result, col_idxs, column_changed, column_count, *obj_copy))) {
STORAGE_LOG(WARN,
"fail to fuse complex row with deep copy",
K(ret),
K(former),
K(result),
KP(col_idxs),
KP(column_changed),
K(column_count));
}
}
return ret;
}
int ObRowFuse::fuse_row(
const ObStoreRow& former, ObStoreRow& result, ObNopPos& nop_pos, bool& final_result, ObObjDeepCopy* obj_copy)
{
int ret = OB_SUCCESS;
if (nullptr == obj_copy) {
if (OB_FAIL(simple_fuse_row(former, result, nop_pos, final_result, shallow_copy_))) {
STORAGE_LOG(WARN, "fail to fuse simple row with shallow copy", K(ret), K(former), K(result));
}
} else {
if (OB_FAIL(simple_fuse_row(former, result, nop_pos, final_result, *obj_copy))) {
STORAGE_LOG(WARN, "fail to fuse simple row with deep copy", K(ret), K(former), K(result));
}
}
return ret;
}
template <typename T>
OB_INLINE static int simple_fuse_sparse_row(const ObStoreRow& former, ObStoreRow& result,
ObFixedBitSet<OB_ALL_MAX_COLUMN_ID>& bit_set, bool& final_result, T& obj_copy)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!former.is_valid()) || OB_ISNULL(result.row_val_.cells_) || OB_ISNULL(result.column_ids_)) {
ret = common::OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid arguments, ", K(former), K(former.is_valid()), K(result), K(ret));
} else if (common::ObActionFlag::OP_DEL_ROW == result.flag_ ||
common::ObActionFlag::OP_ROW_DOES_NOT_EXIST == former.flag_) {
// do nothing
} else {
result.is_sparse_row_ = true; // set sparse row flag
if (0 == result.row_val_.count_ || common::ObActionFlag::OP_ROW_DOES_NOT_EXIST == result.flag_) {
result.flag_ = former.flag_;
result.from_base_ = former.from_base_;
bit_set.reset();
}
if (common::ObActionFlag::OP_DEL_ROW == former.flag_) {
final_result = true;
if (0 == result.row_val_.count_) { // copy rowkey
for (int i = 0; OB_SUCC(ret) && i < former.row_val_.count_; ++i) {
if (OB_FAIL(obj_copy(former.row_val_.cells_[i], result.row_val_.cells_[i]))) {
STORAGE_LOG(WARN, "failed to copy obj", K(ret), K(i), K(former.row_val_.cells_[i]));
} else {
result.column_ids_[i] = former.column_ids_[i];
}
}
if (OB_SUCC(ret)) {
result.row_val_.count_ = former.row_val_.count_;
}
}
} else {
int index_cnt = result.row_val_.count_; // next write index in result row
bool found = true;
for (int64_t i = 0; OB_SUCC(ret) && i < former.row_val_.count_; i++) { // loop former row
found = bit_set.has_member(former.column_ids_[i]);
if (!found) { // not found in result row
if (index_cnt > result.capacity_) {
ret = OB_BUF_NOT_ENOUGH;
STORAGE_LOG(WARN,
"input row count is not enough",
K(ret),
K(index_cnt),
K(result.row_val_.count_),
K(result.capacity_));
} else if (OB_FAIL(obj_copy(former.row_val_.cells_[i], result.row_val_.cells_[index_cnt]))) {
STORAGE_LOG(WARN, "failed to copy obj", K(ret), K(i), K(index_cnt));
} else if (OB_FAIL(bit_set.add_member(former.column_ids_[i]))) { // add column id into set
STORAGE_LOG(WARN, "add column id into set failed", K(ret), K(i), K(former.column_ids_[i]));
} else {
result.column_ids_[index_cnt] = former.column_ids_[i];
STORAGE_LOG(DEBUG,
"add col",
K(index_cnt),
K(result.column_ids_[index_cnt]),
K(result.column_ids_[index_cnt]),
K(former.row_val_.cells_[i]),
K(result.row_val_.cells_[index_cnt]));
index_cnt++; // move forward
}
} else { // found in result row
STORAGE_LOG(DEBUG, "already had col", K(former.column_ids_[i]), K(i));
}
}
if (OB_SUCC(ret)) { // set result row count
result.row_val_.count_ = index_cnt;
}
}
}
return ret;
}
int ObRowFuse::fuse_sparse_row(const ObStoreRow& former, ObStoreRow& result,
ObFixedBitSet<OB_ALL_MAX_COLUMN_ID>& bit_set, bool& final_result, ObObjDeepCopy* obj_copy)
{
int ret = OB_SUCCESS;
if (nullptr == obj_copy) {
if (OB_FAIL(simple_fuse_sparse_row(former, result, bit_set, final_result, shallow_copy_))) {
STORAGE_LOG(WARN, "fail to fuse simple row with shallow copy", K(ret), K(former), K(result));
}
} else {
if (OB_FAIL(simple_fuse_sparse_row(former, result, bit_set, final_result, *obj_copy))) {
STORAGE_LOG(WARN, "fail to fuse simple row with deep copy", K(ret), K(former), K(result));
}
}
return ret;
}
} // namespace storage
} // namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink