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

bugfix: pass tablet from get_table_param to get corresponding version of ddlkv

Browse Source
This commit is contained in:
renju96 2024-01-02 09:12:48 +00:00 committed by ob-robot
parent 5954384755
commit cba9180f18
9 changed files with 51 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h
View File

@ -137,6 +137,8 @@ protected:
int64_t mirco_blocks_per_macro_block_;
bool is_cg_data_;
bool is_ddl_merge_data_;
ObGetTableParam get_table_param_;
};
ObArenaAllocator TestIndexBlockDataPrepare::allocator_;
@ -297,6 +299,8 @@ void TestIndexBlockDataPrepare::SetUp()
ASSERT_EQ(OB_SUCCESS, TestTabletHelper::create_tablet(ls_handle, tablet_id, table_schema_, allocator_));
ASSERT_EQ(OB_SUCCESS, ls_handle.get_ls()->get_tablet(tablet_id, tablet_handle_));
get_table_param_.tablet_iter_.set_tablet_handle(tablet_handle_);
iter_param_.set_table_param(&get_table_param_);
sstable_.key_.table_type_ = ObITable::TableType::COLUMN_ORIENTED_SSTABLE;
if (is_cg_data_ && is_ddl_merge_data_) {

2
src/storage/access/ob_index_sstable_estimator.cpp
View File

@ -90,8 +90,6 @@ int ObIndexBlockScanEstimator::estimate_row_count(ObPartitionEst &part_est)
STORAGE_LOG(WARN, "Failed to get index tree root", K(ret));
} else if (context_.sstable_.is_ddl_merge_sstable()) {
index_block_row_scanner_.set_iter_param(&context_.sstable_,
context_.tablet_handle_.get_obj()->get_ls_id(),
context_.tablet_handle_.get_obj()->get_tablet_id(),
context_.tablet_handle_.get_obj());
}
if (OB_FAIL(ret)) {

22
src/storage/access/ob_index_tree_prefetcher.cpp
View File

@ -119,7 +119,13 @@ int ObIndexTreePrefetcher::init_basic_info(
index_tree_height_ = sstable_meta_handle_.get_sstable_meta().get_index_tree_height(sstable.is_ddl_merge_sstable() && is_normal_query);
if (index_scanner_.is_valid()) {
index_scanner_.switch_context(sstable, *datum_utils_, *access_ctx_);
if (OB_ISNULL(iter_param_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid iter param", K(ret), KPC(iter_param_), K(lbt()));
} else {
const ObTablet *cur_tablet = OB_ISNULL(iter_param_->get_table_param_) ? nullptr : iter_param_->get_table_param_->tablet_iter_.get_tablet();
index_scanner_.switch_context(sstable, cur_tablet, *datum_utils_, *access_ctx_);
}
} else if (OB_FAIL(init_index_scanner(index_scanner_))) {
LOG_WARN("Fail to init index_scanner", K(ret));
}
@ -269,8 +275,12 @@ int ObIndexTreePrefetcher::init_index_scanner(ObIndexBlockRowScanner &index_scan
sstable_->get_macro_offset(),
sstable_->is_normal_cg_sstable()))) {
LOG_WARN("init index scanner fail", K(ret), KPC(sstable_), KP(sstable_));
} else if (OB_ISNULL(iter_param_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid iter param", K(ret), KPC(iter_param_), K(lbt()));
} else {
index_scanner.set_iter_param(sstable_, access_ctx_->ls_id_, access_ctx_->tablet_id_);
const ObTablet *cur_tablet = OB_ISNULL(iter_param_->get_table_param_) ? nullptr : iter_param_->get_table_param_->tablet_iter_.get_tablet();
index_scanner.set_iter_param(sstable_, cur_tablet);
}
return ret;
}
@ -775,7 +785,13 @@ int ObIndexTreeMultiPassPrefetcher<DATA_PREFETCH_DEPTH, INDEX_PREFETCH_DEPTH>::s
if (OB_SUCC(ret)) {
for (int64_t level = 0; OB_SUCC(ret) && level < index_tree_height_; level++) {
if (tree_handles_[level].index_scanner_.is_valid()) {
tree_handles_[level].index_scanner_.switch_context(sstable, *datum_utils_, *access_ctx_);
if (OB_ISNULL(iter_param_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid iter param", K(ret), KPC(iter_param_), K(lbt()));
} else {
const ObTablet *cur_tablet = OB_ISNULL(iter_param_->get_table_param_) ? nullptr : iter_param_->get_table_param_->tablet_iter_.get_tablet();
tree_handles_[level].index_scanner_.switch_context(sstable, cur_tablet, *datum_utils_, *access_ctx_);
}
} else if (OB_FAIL(init_index_scanner(tree_handles_[level].index_scanner_))) {
LOG_WARN("Fail to init index_scanner", K(ret), K(level));
}

2
src/storage/access/ob_multiple_merge.cpp
View File

@ -139,6 +139,7 @@ int ObMultipleMerge::init(
}
unprojected_row_.count_ = 0;
get_table_param_ = &get_table_param;
access_param_->iter_param_.set_table_param(get_table_param_);
const ObITableReadInfo *read_info = access_param_->iter_param_.get_read_info();
if (OB_SUCC(ret)) {
if (OB_ISNULL(read_info)) {
@ -180,6 +181,7 @@ int ObMultipleMerge::switch_param(
access_param_ = &param;
access_ctx_ = &context;
get_table_param_ = &get_table_param;
access_param_->iter_param_.set_table_param(get_table_param_);
if (OB_FAIL(prepare_read_tables())) {
STORAGE_LOG(WARN, "Failed to prepare read tables", K(ret), K(*this));

2
src/storage/access/ob_table_access_param.cpp
View File

@ -31,6 +31,7 @@ ObTableIterParam::ObTableIterParam()
tablet_id_(),
read_info_(nullptr),
rowkey_read_info_(nullptr),
get_table_param_(nullptr),
cg_read_info_handle_(),
out_cols_project_(NULL),
agg_cols_project_(NULL),
@ -65,6 +66,7 @@ void ObTableIterParam::reset()
tablet_id_.reset();
read_info_ = nullptr;
rowkey_read_info_ = nullptr;
get_table_param_ = nullptr;
cg_read_info_handle_.reset();
out_cols_project_ = NULL;
agg_cols_project_ = NULL;

3
src/storage/access/ob_table_access_param.h
View File

@ -141,6 +141,8 @@ public:
{ return pd_storage_flag_.set_use_column_store(true); }
OB_INLINE void set_not_use_column_store()
{ return pd_storage_flag_.set_use_column_store(false); }
OB_INLINE void set_table_param(const ObGetTableParam *get_table_param)
{ get_table_param_ = get_table_param; }
OB_INLINE bool use_uniform_format() const
{
return op_->enable_rich_format_ &&
@ -159,6 +161,7 @@ public:
uint32_t cg_idx_;
const ObITableReadInfo *read_info_;
const ObITableReadInfo *rowkey_read_info_;
const ObGetTableParam *get_table_param_;
ObCGReadInfoHandle cg_read_info_handle_;
//TODO(huronghui.hrh):temp solution
const ObColumnParam *cg_col_param_;

67
src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.cpp
View File

@ -250,7 +250,7 @@ int ObDDLIndexBlockRowIterator::find_rowkeys_belong_to_same_idx_row(ObMicroIndex
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid rows info", K(ret));
} else {
const ObDatumRowkey *cur_rowkey = cur_rowkey = cur_tree_value_->rowkey_;;
const ObDatumRowkey *cur_rowkey = cur_tree_value_->rowkey_;
bool is_decided = false;
for (; OB_SUCC(ret) && rowkey_begin_idx < rowkey_end_idx; ++rowkey_begin_idx) {
if (rows_info->is_row_skipped(rowkey_begin_idx)) {
@ -518,42 +518,21 @@ int ObDDLSStableAllRangeIterator::init(const ObMicroBlockData &idx_block_data,
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguement", K(ret), KPC(datum_utils), K(iter_param));
} else {
ObTablet *cur_tablet = nullptr;
ObTabletHandle tmp_tablet_handle;
if (OB_ISNULL(iter_param.tablet_)) {
//get tablet handle from ls
ObLSService *ls_service = MTL(ObLSService *);
ObLSHandle ls_handle;
if (OB_FAIL(ls_service->get_ls(iter_param.ls_id_, ls_handle, ObLSGetMod::DDL_MOD))) {
LOG_WARN("get ls failed", K(ret), K(iter_param.ls_id_));
} else if (OB_FAIL(ObDDLUtil::ddl_get_tablet(ls_handle,
iter_param.tablet_id_,
tmp_tablet_handle,
ObMDSGetTabletMode::READ_ALL_COMMITED))) {
LOG_WARN("get tablet failed", K(ret), K(iter_param));
} else {
cur_tablet = tmp_tablet_handle.get_obj();
ObTablet *cur_tablet = const_cast<ObTablet *>(iter_param.tablet_);
if (iter_param.sstable_->is_normal_cg_sstable()) {
if (OB_FAIL(MTL(ObTenantCGReadInfoMgr *)->get_index_read_info(rowkey_read_info_))) {
LOG_WARN("failed to get index read info from ObTenantCGReadInfoMgr", K(ret));
}
} else {
cur_tablet = const_cast<ObTablet *>(iter_param.tablet_);
rowkey_read_info_ = &cur_tablet->get_rowkey_read_info();
}
if (OB_SUCC(ret)) {
if (iter_param.sstable_->is_normal_cg_sstable()) {
if (OB_FAIL(MTL(ObTenantCGReadInfoMgr *)->get_index_read_info(rowkey_read_info_))) {
LOG_WARN("failed to get index read info from ObTenantCGReadInfoMgr", K(ret));
}
} else {
rowkey_read_info_ = &cur_tablet->get_rowkey_read_info();
}
if (OB_SUCC(ret)) {
iter_param_ = iter_param;
iter_param_ = iter_param;
is_reverse_scan_ = is_reverse_scan;
iter_step_ = is_reverse_scan_ ? -1 : 1;
datum_utils_ = datum_utils;
is_inited_ = true;
}
is_reverse_scan_ = is_reverse_scan;
iter_step_ = is_reverse_scan_ ? -1 : 1;
datum_utils_ = datum_utils;
is_inited_ = true;
}
}
return ret;
@ -1179,33 +1158,13 @@ int ObDDLMergeBlockRowIterator::get_readable_ddl_kvs(const ObIndexBlockIterParam
{
int ret = OB_SUCCESS;
// todo qilu :get DDLKV from ls or from tablet_handle now, opt this get DDLKV from MTL() after refactor ddl_kv_mgr
ObTablet *cur_tablet = nullptr;
ddl_memtables.reset();
ObTabletHandle tmp_tablet_handle;
if (OB_UNLIKELY(!iter_param.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid iter param", K(ret), K(iter_param));
LOG_WARN("invalid iter param", K(ret), K(iter_param), K(lbt()));
} else {
if (OB_ISNULL(iter_param.tablet_)) {
//get tablet handle from ls
ObLSService *ls_service = MTL(ObLSService *);
ObLSHandle ls_handle;
if (OB_FAIL(ls_service->get_ls(iter_param.ls_id_, ls_handle, ObLSGetMod::DDL_MOD))) {
LOG_WARN("get ls failed", K(ret), K(iter_param.ls_id_));
} else if (OB_FAIL(ObDDLUtil::ddl_get_tablet(ls_handle,
iter_param.tablet_id_,
tmp_tablet_handle,
ObMDSGetTabletMode::READ_ALL_COMMITED))) {
LOG_WARN("get tablet failed", K(ret), K(iter_param));
} else {
cur_tablet = tmp_tablet_handle.get_obj();
}
} else {
cur_tablet = const_cast<ObTablet *>(iter_param.tablet_);
}
}
if (OB_SUCC(ret)) {
ObTablet *cur_tablet = const_cast<ObTablet *>(iter_param.tablet_);
const uint16_t sstable_cg_idx = iter_param.sstable_->get_key().get_column_group_id();
ObDDLKvMgrHandle ddl_kv_mgr_handle;
ObArray<ObDDLKVHandle> ddl_kvs_handle;

21
src/storage/blocksstable/index_block/ob_index_block_row_scanner.cpp
View File

@ -294,9 +294,7 @@ int ObIndexBlockDataTransformer::get_reader(
/****************** ObIndexBlockIterParam **********************/
ObIndexBlockIterParam::ObIndexBlockIterParam()
: sstable_(nullptr),
tablet_(nullptr),
ls_id_(),
tablet_id_()
tablet_(nullptr)
{
}
@ -309,8 +307,6 @@ ObIndexBlockIterParam &ObIndexBlockIterParam::operator=(const ObIndexBlockIterPa
{
sstable_ = other.sstable_;
tablet_ = other.tablet_;
ls_id_ = other.ls_id_;
tablet_id_ = other.tablet_id_;
return *this;
}
@ -319,8 +315,6 @@ int ObIndexBlockIterParam::assign(const ObIndexBlockIterParam &other)
int ret = OB_SUCCESS;
sstable_ = other.sstable_;
tablet_ = other.tablet_;
ls_id_ = other.ls_id_;
tablet_id_ = other.tablet_id_;
return ret;
}
@ -328,13 +322,11 @@ void ObIndexBlockIterParam::reset()
{
sstable_ = nullptr;
tablet_ = nullptr;
ls_id_.reset();
tablet_id_.reset();
}
bool ObIndexBlockIterParam::is_valid() const
{
return OB_NOT_NULL(sstable_) && ((ls_id_.is_valid() && tablet_id_.is_valid()) || OB_NOT_NULL(tablet_));
return OB_NOT_NULL(sstable_) && OB_NOT_NULL(tablet_);
}
/****************** ObIndexBlockRowIterator **********************/
@ -1564,13 +1556,9 @@ int ObIndexBlockRowScanner::get_next(
}
void ObIndexBlockRowScanner::set_iter_param(const blocksstable::ObSSTable *sstable,
const share::ObLSID &ls_id,
const common::ObTabletID &tablet_id,
const ObTablet *tablet)
{
iter_param_.sstable_ = sstable;
iter_param_.ls_id_ = ls_id;
iter_param_.tablet_id_ = tablet_id;
iter_param_.tablet_ = tablet;
}
@ -1806,6 +1794,7 @@ const ObDatumRowkey &ObIndexBlockRowScanner::get_end_key() const
}
void ObIndexBlockRowScanner::switch_context(const ObSSTable &sstable,
const ObTablet *tablet,
const ObStorageDatumUtils &datum_utils,
ObTableAccessContext &access_ctx)
{
@ -1815,9 +1804,7 @@ void ObIndexBlockRowScanner::switch_context(const ObSSTable &sstable,
is_reverse_scan_ = access_ctx.query_flag_.is_reverse_scan();
is_normal_query_ = !access_ctx.query_flag_.is_daily_merge() && !access_ctx.query_flag_.is_multi_version_minor_merge();
iter_param_.sstable_ = &sstable;
iter_param_.ls_id_ = access_ctx.ls_id_;
iter_param_.tablet_id_ = access_ctx.tablet_id_;
iter_param_.tablet_ = nullptr;
iter_param_.tablet_ = tablet;
int ret = OB_SUCCESS;
if (OB_NOT_NULL(iter_)) {
ObStorageDatumUtils *switch_datum_utils = const_cast<ObStorageDatumUtils *>(datum_utils_);

12
src/storage/blocksstable/index_block/ob_index_block_row_scanner.h
View File

@ -117,14 +117,11 @@ public:
int assign(const ObIndexBlockIterParam &other);
void reset();
bool is_valid() const;
TO_STRING_KV(KP(sstable_), KP(tablet_), K(ls_id_), K(tablet_id_));
TO_STRING_KV(KP(sstable_), KP(tablet_));
public:
const ObSSTable *sstable_;
// pass ls_id + table_id or directly pass tablet
const ObTablet *tablet_;
share::ObLSID ls_id_;
common::ObTabletID tablet_id_;
};
class ObIndexBlockRowIterator
@ -189,7 +186,7 @@ public:
return OB_SUCCESS;
}
bool is_inited() { return is_inited_; }
VIRTUAL_TO_STRING_KV(K(is_inited_), K(is_reverse_scan_), K(iter_step_), K(idx_row_parser_), KPC(datum_utils_));
VIRTUAL_TO_STRING_KV(K(is_inited_), K(is_reverse_scan_), K(iter_step_), KPC(datum_utils_));
protected:
bool is_inited_;
@ -351,9 +348,7 @@ public:
ObMicroIndexInfo &idx_block_row,
const bool is_multi_check = false);
void set_iter_param(const ObSSTable *sstable,
const share::ObLSID &ls_id,
const common::ObTabletID &tablet_id,
const ObTablet *tablet = nullptr);
const ObTablet *tablet);
bool end_of_block() const;
bool is_ddl_merge_type() const;
int get_index_row_count(int64_t &index_row_count) const;
@ -376,6 +371,7 @@ public:
OB_INLINE bool is_valid() const { return is_inited_; }
OB_INLINE bool is_ddl_merge_scan() const { return index_format_ == ObIndexFormat::DDL_MERGE; }
void switch_context(const ObSSTable &sstable,
const ObTablet *tablet,
const ObStorageDatumUtils &datum_utils,
ObTableAccessContext &access_ctx);
TO_STRING_KV(K_(index_format), KP_(raw_iter), KP_(transformed_iter), KP_(ddl_iter), KP_(ddl_merge_iter),