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

[BUGFIX] fix lob bugs

Browse Source
This commit is contained in:
obdev
2023-02-24 17:11:48 +08:00
committed by ob-robot
parent 642798b78e
commit 46c6a9bfce
7 changed files with 92 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/share/ob_lob_access_utils.cpp
View File

@ -1133,7 +1133,7 @@ int ObTextStringResult::fill(int64_t pos, int c, int64_t len)
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Lob: append content length too long", K(this), K(pos), K(len), K(ret));
} else {
MEMSET(buffer_ + pos, c, len);
MEMSET(buffer_ + pos_ + pos, c, len);
}
} else {
ret = OB_NOT_IMPLEMENT;

4
src/sql/engine/expr/ob_expr_instr.cpp
View File

@ -148,7 +148,9 @@ static int calc_oracle_instr_text(ObTextStringIter &haystack_iter,
LOG_WARN("get needle data failed ", K(ret), K(needle_iter));
} else if (OB_FAIL(needle_iter.get_char_len(needle_char_len))) {
LOG_WARN("get needle char len failed ", K(ret), K(needle_iter));
} else if (haystack_char_len - abs_pos_int < needle_char_len) {
} else if ((needle_char_len < 1) ||
(haystack_char_len - abs_pos_int + 1 < needle_char_len)) {
// pattern is empty string, just return zero
// pattern length is bigger than content, just return zero
idx = 0;
} else {

20
src/storage/lob/ob_lob_manager.cpp
View File

@ -2298,9 +2298,9 @@ int ObLobManager::write_outrow_inner(ObLobAccessParam& param, ObLobQueryIter *it
// prepare write iter
ObLobMetaWriteIter write_iter(read_buf, param.allocator_, ObLobMetaUtil::LOB_OPER_PIECE_DATA_SIZE);
if (OB_FAIL(write_iter.open(param, iter, read_buf, padding_size, post_data, remain_buf, seq_id_st, seq_id_ed))) {
LOG_WARN("failed to open meta writer", K(ret));
LOG_WARN("failed to open meta writer", K(ret), K(write_iter), K(meta_iter), K(found_begin), K(found_end));
} else if (OB_FAIL(write_outrow_result(param, write_iter))) {
LOG_WARN("failed to write outrow result", K(ret));
LOG_WARN("failed to write outrow result", K(ret), K(write_iter), K(meta_iter), K(found_begin), K(found_end));
}
write_iter.close();
}
@ -2810,7 +2810,11 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
ObLobMetaInfo new_meta_row = result.meta_result_.info_;
char* tmp_buf = tmp_buff.ptr();
ObString read_data;
if (param.is_fill_zero_) {
read_data.assign_buffer(tmp_buf, result.meta_result_.info_.byte_len_);
} else {
read_data = result.meta_result_.info_.lob_data_;
}
// save variable
uint32_t tmp_st = result.meta_result_.st_;
@ -2822,7 +2826,7 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
if (OB_ISNULL(tmp_buf)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("tmp buffer is null.", K(ret), K(tmp_buff));
} else if (OB_FAIL(get_real_data(param, result, read_data))) {
} else if (param.is_fill_zero_ && OB_FAIL(get_real_data(param, result, read_data))) {
LOG_WARN("failed to write data to read buf.", K(ret), K(result));
} else {
result.meta_result_.st_ = tmp_st;
@ -2875,12 +2879,17 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
fill_zero(read_data.ptr(), read_data.length(), is_char, by_len, by_st, fill_char_len);
read_data.set_length(read_data.length() - by_len + fill_char_len);
new_meta_row.byte_len_ = read_data.length();
} else {
read_data.assign_buffer(tmp_buf, result.meta_result_.info_.byte_len_);
if (OB_FAIL(get_real_data(param, result, read_data))) {
LOG_WARN("failed to write data to read buf.", K(ret), K(result));
} else {
new_meta_row.byte_len_ -= (by_len);
new_meta_row.char_len_ -= (local_end - local_begin);
MEMMOVE(read_data.ptr() + by_st, read_data.ptr() + (by_st + by_len), piece_byte_len - (by_st + by_len));
read_data.assign_ptr(read_data.ptr(), read_data.length() - by_len);
}
}
} else {
del_piece = true;
}
@ -2927,6 +2936,10 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
fill_zero(read_data.ptr(), read_data.length(), is_char, by_len, 0, fill_char_len);
read_data.set_length(fill_char_len + read_data.length() - by_len);
new_meta_row.byte_len_ = read_data.length();
} else {
read_data.assign_buffer(tmp_buf, result.meta_result_.info_.byte_len_);
if (OB_FAIL(get_real_data(param, result, read_data))) {
LOG_WARN("failed to write data to read buf.", K(ret), K(result));
} else {
new_meta_row.char_len_ = piece_char_len - local_end;
new_meta_row.byte_len_ = read_data.length() - by_len;
@ -2935,6 +2948,7 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
}
}
}
}
if (OB_FAIL(ret)) {
} else if (del_piece) {

8
src/storage/lob/ob_lob_meta.cpp
View File

@ -306,8 +306,8 @@ int ObLobMetaWriteIter::open(ObLobAccessParam &param,
int ObLobMetaWriteIter::open(ObLobAccessParam &param, ObILobApator* adatper)
{
int ret = OB_SUCCESS;
if (OB_FAIL(scan_iter_.open(param, adatper))) {
bool is_empty_lob = (param.byte_size_ == 0);
if (!is_empty_lob && OB_FAIL(scan_iter_.open(param, adatper))) {
LOG_WARN("failed open scan meta open iter.", K(ret));
} else {
coll_type_ = param.coll_type_;
@ -315,9 +315,10 @@ int ObLobMetaWriteIter::open(ObLobAccessParam &param, ObILobApator* adatper)
piece_id_ = ObLobMetaUtil::LOB_META_INLINE_PIECE_ID;
padding_size_ = 0;
inner_buffer_.assign_ptr(nullptr, 0);
ObLobMetaScanResult scan_res;
// locate first piece
if (!is_empty_lob) {
ObLobMetaScanResult scan_res;
ret = scan_iter_.get_next_row(scan_res);
if (OB_FAIL(ret)) {
if (ret == OB_ITER_END) {
@ -331,6 +332,7 @@ int ObLobMetaWriteIter::open(ObLobAccessParam &param, ObILobApator* adatper)
seq_id_.set_seq_id(scan_res.info_.seq_id_);
}
}
}
return ret;
}

3
src/storage/lob/ob_lob_meta.h
View File

@ -68,6 +68,7 @@ public:
bool is_range_begin(const ObLobMetaInfo& info);
bool is_range_end(const ObLobMetaInfo& info);
bool is_range_over(const ObLobMetaInfo& info);
TO_STRING_KV(K_(cur_pos), K_(cur_info));
private:
bool is_in_range(const ObLobMetaInfo& info);
private:
@ -108,6 +109,8 @@ public:
ObString &seq_id_end);
int get_next_row(ObLobMetaWriteResult &row);
int close();
TO_STRING_KV(K_(seq_id), K_(offset), K_(lob_id), K_(piece_id), K_(coll_type), K_(piece_block_size),
K_(scan_iter), K_(padding_size), K_(seq_id_end), K_(last_info));
private:
int try_fill_data(
ObLobMetaWriteResult& row,

43
src/storage/lob/ob_lob_seq.cpp
View File

@ -14,6 +14,7 @@
#include "ob_lob_seq.h"
#include <netinet/in.h>
#include "deps/oblib/src/lib/utility/ob_print_utils.h"
namespace oceanbase
{
@ -400,5 +401,47 @@ int ObLobSeqId::parse()
return ret;
}
int64_t ObLobSeqId::to_string(char* buf, const int64_t buf_len) const
{
int64_t pos = 0;
J_OBJ_START();
ObString tmp_seq = seq_id_;
size_t len = tmp_seq.length();
uint32_t ori_len = static_cast<uint32_t>(len / sizeof(uint32_t)); //TODO(yuanzhi.zy): check is len int32 enough
uint32_t cur_pos = 0;
common::databuff_printf(buf, buf_len, pos, "seq_id:[");
while (cur_pos < ori_len && tmp_seq.ptr() != nullptr) {
uint32_t val = ObLobSeqId::load32be(tmp_seq.ptr() + sizeof(uint32_t) * cur_pos);
common::databuff_printf(buf, buf_len, pos, "%u.", val);
cur_pos++;
} // end while
common::databuff_printf(buf, buf_len, pos, "], ");
oceanbase::common::databuff_print_kv(buf, buf_len, pos, K_(read_only), K_(parsed));
common::databuff_printf(buf, buf_len, pos, ", seq_id_in_buff:[");
ori_len = static_cast<uint32_t>(len_ / sizeof(uint32_t));
cur_pos = 0;
while (cur_pos < ori_len && buf_ != nullptr) {
uint32_t val = ObLobSeqId::load32be(buf_ + sizeof(uint32_t) * cur_pos);
common::databuff_printf(buf, buf_len, pos, "%u.", val);
cur_pos++;
} // end while
common::databuff_printf(buf, buf_len, pos, "], ");
oceanbase::common::databuff_print_kv(buf, buf_len, pos, K_(len), K_(cap));
common::databuff_printf(buf, buf_len, pos, ", seq_id_in_digits:[");
ori_len = dig_len_;
cur_pos = 0;
while (cur_pos < ori_len && digits_ != nullptr) {
common::databuff_printf(buf, buf_len, pos, "%u.", digits_[cur_pos]);
cur_pos++;
} // end while
common::databuff_printf(buf, buf_len, pos, "], ");
oceanbase::common::databuff_print_kv(buf, buf_len, pos, K_(dig_len), K_(dig_cap));
J_OBJ_END();
return pos;
}
} // storage
} // oceanbase

1
src/storage/lob/ob_lob_seq.h
View File

@ -43,6 +43,7 @@ public:
void reset();
static char* store32be(char *ptr, uint32_t val);
static uint32_t load32be(const char *ptr);
int64_t to_string(char* buf, const int64_t buf_len) const;
private:
int init_digits();
int init_seq_buf();