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

add defensive check for duplicate macro logic id in single sstable build parallel task

Browse Source
This commit is contained in:
saltonz 2023-04-13 07:36:22 +00:00 committed by ob-robot
parent 70ce469ab5
commit b299a5356f
7 changed files with 93 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/storage/blocksstable/ob_index_block_builder.cpp
View File

@ -668,15 +668,28 @@ int ObSSTableIndexBuilder::merge_index_tree(ObSSTableMergeRes &res)
} else if (OB_FAIL(data_desc.assign(index_store_desc_))) {
STORAGE_LOG(WARN, "fail to assign data desc", K(ret), K_(index_store_desc));
} else {
const int64_t curr_logical_version = index_store_desc_.get_logical_version();
ObIndexBlockRowDesc row_desc(data_desc);
for (int64_t i = 0; OB_SUCC(ret) && i < roots_.count(); ++i) {
ObMacroMetasArray *macro_metas = roots_[i]->macro_metas_;
int64_t prev_macro_seq = -1;
for (int64_t j = 0; OB_SUCC(ret) && j < macro_metas->count(); ++j) {
ObDataMacroBlockMeta *macro_meta = macro_metas->at(j);
if (OB_ISNULL(macro_meta)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "unexpected null macro meta", K(ret), K(j), KPC(roots_.at(i)));
} else if (OB_FAIL(index_builder_.append_row(*macro_meta, row_desc))) {
} else if (curr_logical_version == macro_meta->get_logic_id().logic_version_) {
// latest logical version, check whether data sequence is monotonically increasing
if (OB_UNLIKELY(macro_meta->get_logic_id().data_seq_ <= prev_macro_seq)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(ERROR, "unexpected duplicate macro block sequence in one single sstable build task",
K(ret), K(curr_logical_version), KPC(macro_meta), K(prev_macro_seq), K_(index_store_desc));
} else {
prev_macro_seq = macro_meta->get_logic_id().data_seq_;
}
}
if (FAILEDx(index_builder_.append_row(*macro_meta, row_desc))) {
STORAGE_LOG(WARN, "fail to append row", K(ret), KPC(macro_meta), K(j), KPC(roots_.at(i)));
}
}

12
src/storage/blocksstable/ob_macro_block_bare_iterator.cpp
View File

@ -216,7 +216,7 @@ int ObMicroBlockBareIterator::get_micro_block_count(int64_t &micro_block_count)
return ret;
}
int ObMicroBlockBareIterator::get_index_block(ObMicroBlockData &micro_block)
int ObMicroBlockBareIterator::get_index_block(ObMicroBlockData &micro_block, const bool is_macro_meta_block)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!macro_block_header_.is_valid())) {
@ -227,8 +227,10 @@ int ObMicroBlockBareIterator::get_index_block(ObMicroBlockData &micro_block)
LOG_WARN("Unexpected null index block", K(ret), K_(macro_block_header));
} else {
ObMicroBlockHeader header;
const int64_t index_block_offset = macro_block_header_.fixed_header_.idx_block_offset_;
int64_t micro_buf_size = macro_block_header_.fixed_header_.idx_block_size_;
const int64_t index_block_offset = is_macro_meta_block ? macro_block_header_.fixed_header_.meta_block_offset_
: macro_block_header_.fixed_header_.idx_block_offset_;
int64_t micro_buf_size = is_macro_meta_block ? macro_block_header_.fixed_header_.meta_block_size_
: macro_block_header_.fixed_header_.idx_block_size_;
const char *micro_buf = macro_block_buf_ + index_block_offset;
int64_t pos = 0;
bool is_compressed = false;
@ -443,7 +445,7 @@ int ObMacroBlockRowBareIterator::get_next_row(const ObDatumRow *&row)
return ret;
}
int ObMacroBlockRowBareIterator::open_leaf_index_micro_block()
int ObMacroBlockRowBareIterator::open_leaf_index_micro_block(const bool is_macro_meta)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
@ -453,7 +455,7 @@ int ObMacroBlockRowBareIterator::open_leaf_index_micro_block()
ret = OB_ITER_STOP;
LOG_WARN("Previous block iterate not finished",
K(ret), K_(curr_block_row_idx), K_(curr_block_row_cnt));
} else if (OB_FAIL(micro_iter_.get_index_block(curr_micro_block_data_))) {
} else if (OB_FAIL(micro_iter_.get_index_block(curr_micro_block_data_, is_macro_meta))) {
LOG_WARN("Fail to get leaf index block data", K(ret));
} else if (OB_UNLIKELY(!curr_micro_block_data_.is_valid())) {
ret = OB_ERR_UNEXPECTED;

5
src/storage/blocksstable/ob_macro_block_bare_iterator.h
View File

@ -48,7 +48,8 @@ public:
int get_next_micro_block_data(ObMicroBlockData &micro_block);
int get_macro_block_header(ObSSTableMacroBlockHeader &macro_header);
int get_micro_block_count(int64_t &micro_block_count);
int get_index_block(ObMicroBlockData &micro_block);
int get_index_block(ObMicroBlockData &micro_block, const bool is_macro_meta_block = false);
int get_macro_meta_block(ObMicroBlockData &micro_block);
bool is_left_border() const { return iter_idx_ == begin_idx_; }
bool is_right_border() const { return iter_idx_ == end_idx_; }
TO_STRING_KV(KP_(macro_block_buf), K_(macro_block_buf_size), K_(common_header),
@ -95,7 +96,7 @@ public:
const bool need_check_integrity = false);
int get_next_row(const ObDatumRow *&row);
// switch to iterate leaf index block in data macro block
int open_leaf_index_micro_block();
int open_leaf_index_micro_block(const bool is_macro_meta = false);
int open_next_micro_block();
int get_macro_block_header(ObSSTableMacroBlockHeader &macro_header);

30
src/storage/blocksstable/ob_macro_block_reader.cpp
View File

@ -551,6 +551,8 @@ int ObSSTableDataBlockReader::dump_sstable_macro_block(const bool is_index_block
LOG_WARN("Fail to open leaf index micro block", K(ret));
} else if (OB_FAIL(dump_sstable_micro_block(0, true, macro_iter))) {
LOG_WARN("Fail to dump leaf index micro block", K(ret));
} else if (OB_FAIL(dump_macro_block_meta_block(macro_iter))) {
LOG_WARN("Fail to dump macro meta block in macro block", K(ret));
}
}
}
@ -689,6 +691,34 @@ int ObSSTableDataBlockReader::dump_sstable_micro_data(
return ret;
}
int ObSSTableDataBlockReader::dump_macro_block_meta_block(ObMacroBlockRowBareIterator &macro_iter)
{
int ret = OB_SUCCESS;
const ObMicroBlockData *micro_data = nullptr;
const ObDatumRow *row = nullptr;
ObDataMacroBlockMeta macro_meta;
ObSSTablePrinter::print_title("Macro Meta Micro Block");
if (OB_FAIL(macro_iter.open_leaf_index_micro_block(true /*macro meta*/))) {
LOG_WARN("Fail to open macro meta block in macro block", K(ret));
} else if (OB_FAIL(macro_iter.get_curr_micro_block_data(micro_data))) {
LOG_WARN("Fail to get curr micro block data", K(ret));
} else if (OB_ISNULL(micro_data) || OB_UNLIKELY(!micro_data->is_valid())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Unexpected invalid micro block data", K(ret), KPC(micro_data));
} else if (OB_FAIL(dump_sstable_micro_header(*micro_data, 0, true))) {
LOG_WARN("Failed to dump sstble micro block header", K(ret));
} else if (OB_FAIL(macro_iter.get_next_row(row))) {
LOG_WARN("Failed to get next meta block row", K(ret));
} else if (OB_FAIL(macro_meta.parse_row(*const_cast<ObDatumRow *>(row)))) {
LOG_WARN("Failed to parse macro block meta", K(ret));
} else {
ObSSTablePrinter::print_store_row(
row, column_types_, micro_data->get_micro_header()->rowkey_column_count_, true, is_trans_sstable_);
ObSSTablePrinter::print_macro_meta(&macro_meta);
}
return ret;
}
int ObSSTableDataBlockReader::dump_bloom_filter_data_block()
{
int ret = OB_SUCCESS;

1
src/storage/blocksstable/ob_macro_block_reader.h
View File

@ -120,6 +120,7 @@ private:
const int64_t micro_idx,
const bool is_index_block,
ObMacroBlockRowBareIterator &macro_bare_iter);
int dump_macro_block_meta_block(ObMacroBlockRowBareIterator &macro_bare_iter);
int dump_sstable_micro_header(
const ObMicroBlockData &micro_data,
const int64_t micro_idx,

37
src/storage/blocksstable/ob_sstable_printer.cpp
View File

@ -358,6 +358,43 @@ void ObSSTablePrinter::print_index_minor_meta(const ObIndexBlockRowMinorMetaInfo
}
}
void ObSSTablePrinter::print_macro_meta(const ObDataMacroBlockMeta *macro_meta)
{
print_title("Data Macro Block Meta");
print_line("version", macro_meta->val_.version_);
print_line("length", macro_meta->val_.length_);
print_line("data_checksum", macro_meta->val_.data_checksum_);
print_line("rowkey_count", macro_meta->val_.rowkey_count_);
print_line("column_count", macro_meta->val_.column_count_);
print_line("micro_block_count", macro_meta->val_.micro_block_count_);
print_line("occupy_size", macro_meta->val_.occupy_size_);
print_line("data_size", macro_meta->val_.data_size_);
print_line("data_zsize", macro_meta->val_.data_zsize_);
print_line("original_size", macro_meta->val_.original_size_);
print_line("progressive_merge_round", macro_meta->val_.progressive_merge_round_);
print_line("block_offset", macro_meta->val_.block_offset_);
print_line("block_size", macro_meta->val_.block_size_);
print_line("row_count", macro_meta->val_.row_count_);
print_line("row_count_delta", macro_meta->val_.row_count_delta_);
print_line("max_merged_trans_version", macro_meta->val_.max_merged_trans_version_);
print_line("is_encrypted", macro_meta->val_.is_encrypted_);
print_line("is_deleted", macro_meta->val_.is_deleted_);
print_line("contain_uncommitted_row", macro_meta->val_.contain_uncommitted_row_);
print_line("is_last_row_last_flag", macro_meta->val_.is_last_row_last_flag_);
print_line("compressor_type", macro_meta->val_.compressor_type_);
print_line("master_key_id", macro_meta->val_.master_key_id_);
print_line("encrypt_id", macro_meta->val_.encrypt_id_);
print_line("row_store_type", macro_meta->val_.row_store_type_);
print_line("schema_version", macro_meta->val_.schema_version_);
print_line("snapshot_version", macro_meta->val_.snapshot_version_);
print_line("logic_id: data_seq", macro_meta->val_.logic_id_.data_seq_);
print_line("logic_id: logic_version", macro_meta->val_.logic_id_.logic_version_);
print_line("logic_id: tablet_id", macro_meta->val_.logic_id_.tablet_id_);
print_line("has_string_out_row", macro_meta->val_.has_string_out_row_);
print_line("all_lob_in_row", macro_meta->val_.all_lob_in_row_);
print_end_line();
}
void ObSSTablePrinter::print_micro_header(const ObMicroBlockHeader *micro_block_header)
{
print_title("Micro Header");

1
src/storage/blocksstable/ob_sstable_printer.h
View File

@ -64,6 +64,7 @@ public:
static void print_macro_block_header(const storage::ObLinkedMacroBlockHeader *linked_macro_header);
static void print_index_row_header(const ObIndexBlockRowHeader *idx_row_header);
static void print_index_minor_meta(const ObIndexBlockRowMinorMetaInfo *minor_meta);
static void print_macro_meta(const ObDataMacroBlockMeta *macro_meta);
static void print_store_row(
const blocksstable::ObDatumRow *row,
const ObObjMeta *obj_metas,