diff --git a/src/share/schema/ob_table_param.cpp b/src/share/schema/ob_table_param.cpp index 4aafc1eefc..6fd7dd4e9f 100644 --- a/src/share/schema/ob_table_param.cpp +++ b/src/share/schema/ob_table_param.cpp @@ -621,7 +621,8 @@ ObTableParam::ObTableParam(ObIAllocator &allocator) rowid_version_(ObURowIDData::INVALID_ROWID_VERSION), rowid_projector_(allocator), enable_lob_locator_v2_(false), - is_spatial_index_(false) + is_spatial_index_(false), + is_fts_index_(false) { reset(); } @@ -645,6 +646,7 @@ void ObTableParam::reset() main_read_info_.reset(); enable_lob_locator_v2_ = false; is_spatial_index_ = false; + is_fts_index_ = false; } OB_DEF_SERIALIZE(ObTableParam) @@ -664,7 +666,8 @@ OB_DEF_SERIALIZE(ObTableParam) main_read_info_, enable_lob_locator_v2_, is_spatial_index_, - group_by_projector_); + group_by_projector_, + is_fts_index_); return ret; } @@ -697,6 +700,9 @@ OB_DEF_DESERIALIZE(ObTableParam) LOG_WARN("Fail to deserialize group by projector", K(ret)); } } + if (OB_SUCC(ret)) { + LST_DO_CODE(OB_UNIS_DECODE, is_fts_index_); + } return ret; } @@ -718,7 +724,8 @@ OB_DEF_SERIALIZE_SIZE(ObTableParam) main_read_info_, enable_lob_locator_v2_, is_spatial_index_, - group_by_projector_); + group_by_projector_, + is_fts_index_); return len; } diff --git a/src/share/schema/ob_table_param.h b/src/share/schema/ob_table_param.h index 87c64ad80d..0e6577c0ee 100644 --- a/src/share/schema/ob_table_param.h +++ b/src/share/schema/ob_table_param.h @@ -390,6 +390,7 @@ private: // use enable_lob_locator_v2_ to avoid locator type sudden change while table scan is running bool enable_lob_locator_v2_; bool is_spatial_index_; + bool is_fts_index_; }; } //namespace schema } //namespace share diff --git a/src/sql/CMakeLists.txt b/src/sql/CMakeLists.txt index 9a9a6b522d..111015c50f 100644 --- a/src/sql/CMakeLists.txt +++ b/src/sql/CMakeLists.txt @@ -68,6 +68,7 @@ ob_set_subtarget(ob_sql das das/ob_das_spatial_index_lookup_op.cpp das/ob_das_retry_ctrl.cpp das/ob_das_simple_op.cpp + das/ob_text_retrieval_op.cpp ) ob_set_subtarget(ob_sql dtl diff --git a/src/sql/das/ob_das_define.h b/src/sql/das/ob_das_define.h index 360fe36c40..b18035d7fd 100644 --- a/src/sql/das/ob_das_define.h +++ b/src/sql/das/ob_das_define.h @@ -399,6 +399,16 @@ OB_INLINE ObDuplicateType loc_meta_to_duplicate_type(const ObDASTableLocMeta &lo } return dup_type; } + +enum ObTSCIRScanType : uint8_t +{ + OB_NOT_A_SPEC_SCAN = 0, + OB_IR_DOC_ID_IDX_AGG, + OB_IR_INV_IDX_AGG, + OB_IR_INV_IDX_SCAN, + OB_IR_FWD_IDX_AGG, +}; + } // namespace sql } // namespace oceanbase #endif /* OBDEV_SRC_SQL_DAS_OB_DAS_DEFINE_H_ */ diff --git a/src/sql/das/ob_das_scan_op.cpp b/src/sql/das/ob_das_scan_op.cpp index d38e1f9b74..e5f2967afa 100644 --- a/src/sql/das/ob_das_scan_op.cpp +++ b/src/sql/das/ob_das_scan_op.cpp @@ -58,7 +58,8 @@ OB_SERIALIZE_MEMBER(ObDASScanCtDef, external_files_, external_file_format_str_, trans_info_expr_, - group_by_column_ids_); + group_by_column_ids_, + ir_scan_type_); OB_DEF_SERIALIZE(ObDASScanRtDef) { @@ -169,7 +170,8 @@ ObDASScanOp::ObDASScanOp(ObIAllocator &op_alloc) scan_rtdef_(nullptr), result_(nullptr), remain_row_cnt_(0), - retry_alloc_(nullptr) + retry_alloc_(nullptr), + ir_param_(op_alloc) { } @@ -739,7 +741,72 @@ OB_SERIALIZE_MEMBER((ObDASScanOp, ObIDASTaskOp), scan_param_.key_ranges_, scan_ctdef_, scan_rtdef_, - scan_param_.ss_key_ranges_); + scan_param_.ss_key_ranges_, + ir_param_); + +OB_DEF_SERIALIZE(ObDASIRParam) +{ + int ret = OB_SUCCESS; + const bool ir_scan = is_ir_scan(); + LST_DO_CODE(OB_UNIS_ENCODE, ir_scan); + if (OB_SUCC(ret) && ir_scan) { + if (OB_ISNULL(ctdef_) || OB_ISNULL(rtdef_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("unexpected nullptr", K(ret)); + } else { + LST_DO_CODE(OB_UNIS_ENCODE, + *ctdef_, + *rtdef_, + ls_id_, + inv_idx_tablet_id_, + doc_id_idx_tablet_id_); + } + } + return ret; +} + +OB_DEF_DESERIALIZE(ObDASIRParam) +{ + int ret = OB_SUCCESS; + bool ir_scan = false; + LST_DO_CODE(OB_UNIS_DECODE, ir_scan); + if (OB_SUCC(ret) && ir_scan) { + if (OB_ISNULL(ctdef_ = OB_NEWx(ObDASIRCtDef, &allocator_, allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for ir ctdef", K(ret)); + } else if (OB_ISNULL(rtdef_ = OB_NEWx(ObDASIRRtDef, &allocator_, allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for ir rtdef", K(ret)); + } else { + LST_DO_CODE(OB_UNIS_DECODE, + *ctdef_, + *rtdef_, + ls_id_, + inv_idx_tablet_id_, + doc_id_idx_tablet_id_); + } + } + return ret; +} + +OB_DEF_SERIALIZE_SIZE(ObDASIRParam) +{ + int64_t len = 0; + const bool ir_scan = is_ir_scan(); + LST_DO_CODE(OB_UNIS_ADD_LEN, ir_scan); + if (ir_scan) { + if (nullptr != ctdef_ && nullptr != rtdef_) { + LST_DO_CODE(OB_UNIS_ADD_LEN, + *ctdef_, + *rtdef_); + } + LST_DO_CODE(OB_UNIS_ADD_LEN, + ls_id_, + inv_idx_tablet_id_, + doc_id_idx_tablet_id_); + } + return len; +} ObDASScanResult::ObDASScanResult() : ObIDASTaskResult(), diff --git a/src/sql/das/ob_das_scan_op.h b/src/sql/das/ob_das_scan_op.h index 04009b1904..96597c4cfe 100644 --- a/src/sql/das/ob_das_scan_op.h +++ b/src/sql/das/ob_das_scan_op.h @@ -22,6 +22,8 @@ namespace sql { class ObDASExtraData; class ObLocalIndexLookupOp; +struct ObDASIRCtDef; +struct ObDASIRRtDef; struct ObDASScanCtDef : ObDASBaseCtDef { @@ -44,7 +46,8 @@ public: external_file_location_(alloc), external_files_(alloc), external_file_format_str_(alloc), - trans_info_expr_(nullptr) + trans_info_expr_(nullptr), + ir_scan_type_(ObTSCIRScanType::OB_NOT_A_SPEC_SCAN) { } //in das scan op, column described with column expr virtual bool has_expr() const override { return true; } @@ -77,7 +80,8 @@ public: K_(external_files), K_(external_file_format_str), K_(external_file_location), - KPC_(trans_info_expr)); + KPC_(trans_info_expr), + K_(ir_scan_type)); common::ObTableID ref_table_id_; UIntFixedArray access_column_ids_; int64_t schema_version_; @@ -97,6 +101,7 @@ public: ExternalFileNameArray external_files_; //for external table scan TODO jim.wjh remove ObExternalFileFormat::StringData external_file_format_str_; ObExpr *trans_info_expr_; // transaction information pseudo-column + ObTSCIRScanType ir_scan_type_; // specify retrieval scan type }; struct ObDASScanRtDef : ObDASBaseRtDef @@ -168,6 +173,32 @@ private: }; }; +struct ObDASIRParam +{ + OB_UNIS_VERSION(1); +public: + ObDASIRParam(ObIAllocator &alloc) + : allocator_(alloc), + ctdef_(nullptr), + rtdef_(nullptr), + ls_id_(OB_INVALID_ID), + inv_idx_tablet_id_(), + fwd_idx_tablet_id_(), + doc_id_idx_tablet_id_() {} + virtual ~ObDASIRParam() {} + inline bool is_ir_scan() const { return false; } // always false on master + + TO_STRING_KV(K_(ls_id), K_(inv_idx_tablet_id), K_(fwd_idx_tablet_id), + K_(doc_id_idx_tablet_id), KP_(ctdef), KP_(rtdef)); + ObIAllocator &allocator_; + ObDASIRCtDef *ctdef_; + ObDASIRRtDef *rtdef_; + share::ObLSID ls_id_; + ObTabletID inv_idx_tablet_id_; + ObTabletID fwd_idx_tablet_id_; + ObTabletID doc_id_idx_tablet_id_; +}; + class ObDASScanOp : public ObIDASTaskOp { friend class DASOpResultIter; @@ -253,6 +284,7 @@ protected: union { common::ObArenaAllocator retry_alloc_buf_; }; + ObDASIRParam ir_param_; }; class ObDASScanResult : public ObIDASTaskResult, public common::ObNewRowIterator diff --git a/src/sql/das/ob_text_retrieval_op.cpp b/src/sql/das/ob_text_retrieval_op.cpp new file mode 100644 index 0000000000..937da52292 --- /dev/null +++ b/src/sql/das/ob_text_retrieval_op.cpp @@ -0,0 +1,168 @@ +/** + * 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. + */ + +#define USING_LOG_PREFIX SQL_DAS +#include "sql/das/ob_text_retrieval_op.h" + +namespace oceanbase +{ +namespace sql +{ + +OB_DEF_SERIALIZE_SIZE(ObDASIRCtDef) +{ + int64_t len = 0; + LST_DO_CODE(OB_UNIS_ADD_LEN, + inv_idx_scan_ctdef_, + search_text_, + inv_scan_doc_id_col_, + match_filter_, + need_relevance_); + if (need_relevance_) { + if (OB_NOT_NULL(inv_idx_agg_ctdef_) + && OB_NOT_NULL(fwd_idx_scan_ctdef_) + && OB_NOT_NULL(doc_id_idx_whole_agg_ctdef_)) { + LST_DO_CODE(OB_UNIS_ADD_LEN, + relevance_expr_, + relevance_proj_col_, + *inv_idx_agg_ctdef_, + *doc_id_idx_whole_agg_ctdef_, + *fwd_idx_scan_ctdef_); + } + } + return len; +} + +OB_DEF_SERIALIZE(ObDASIRCtDef) +{ + int ret = OB_SUCCESS; + LST_DO_CODE(OB_UNIS_ENCODE, + inv_idx_scan_ctdef_, + search_text_, + inv_scan_doc_id_col_, + match_filter_, + need_relevance_); + if (OB_SUCC(ret) && need_relevance_) { + if (OB_ISNULL(inv_idx_agg_ctdef_) + || OB_ISNULL(fwd_idx_scan_ctdef_) + || OB_ISNULL(doc_id_idx_whole_agg_ctdef_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("unexpected", K(ret), KP_(inv_idx_agg_ctdef), KP_(fwd_idx_scan_ctdef), KP_(doc_id_idx_whole_agg_ctdef)); + } else { + LST_DO_CODE(OB_UNIS_ENCODE, + relevance_expr_, + relevance_proj_col_, + *inv_idx_agg_ctdef_, + *doc_id_idx_whole_agg_ctdef_, + *fwd_idx_scan_ctdef_); + } + } + return ret; +} + +OB_DEF_DESERIALIZE(ObDASIRCtDef) +{ + int ret = OB_SUCCESS; + need_relevance_ = false; + LST_DO_CODE(OB_UNIS_DECODE, + inv_idx_scan_ctdef_, + search_text_, + inv_scan_doc_id_col_, + match_filter_, + need_relevance_); + if (OB_SUCC(ret) && need_relevance_) { + if (OB_ISNULL(inv_idx_agg_ctdef_ = OB_NEWx(ObDASScanCtDef, &allocator_, allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for ctdef", K(ret)); + } else if (OB_ISNULL(fwd_idx_scan_ctdef_ = OB_NEWx(ObDASScanCtDef, &allocator_, allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for ctdef", K(ret)); + } else if (OB_ISNULL(doc_id_idx_whole_agg_ctdef_ = OB_NEWx(ObDASScanCtDef, &allocator_, allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for ctdef", K(ret)); + } else { + LST_DO_CODE(OB_UNIS_DECODE, + relevance_expr_, + relevance_proj_col_, + *inv_idx_agg_ctdef_, + *doc_id_idx_whole_agg_ctdef_, + *fwd_idx_scan_ctdef_); + } + } + return ret; +} + +OB_DEF_SERIALIZE_SIZE(ObDASIRRtDef) +{ + int64_t len = 0; + LST_DO_CODE(OB_UNIS_ADD_LEN, + inv_idx_scan_rtdef_, + need_relevance_); + if (need_relevance_) { + if (OB_NOT_NULL(inv_idx_agg_rtdef_) && OB_NOT_NULL(doc_id_idx_whole_agg_rtdef_) && OB_NOT_NULL(fwd_idx_rtdef_)) { + LST_DO_CODE(OB_UNIS_ADD_LEN, + *inv_idx_agg_rtdef_, + *doc_id_idx_whole_agg_rtdef_, + *fwd_idx_rtdef_); + } + } + return len; +} + +OB_DEF_SERIALIZE(ObDASIRRtDef) +{ + int ret = OB_SUCCESS; + LST_DO_CODE(OB_UNIS_ENCODE, + inv_idx_scan_rtdef_, + need_relevance_); + if (OB_SUCC(ret) && need_relevance_) { + if (OB_ISNULL(inv_idx_agg_rtdef_) || OB_ISNULL(doc_id_idx_whole_agg_rtdef_) || OB_ISNULL(fwd_idx_rtdef_)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("unexpected null rtdef", K(ret), KP_(inv_idx_agg_rtdef), KP_(fwd_idx_rtdef), KP_(doc_id_idx_whole_agg_rtdef)); + } else { + LST_DO_CODE(OB_UNIS_ENCODE, + *inv_idx_agg_rtdef_, + *doc_id_idx_whole_agg_rtdef_, + *fwd_idx_rtdef_); + } + } + return ret; +} + +OB_DEF_DESERIALIZE(ObDASIRRtDef) +{ + int ret = OB_SUCCESS; + LST_DO_CODE(OB_UNIS_DECODE, + inv_idx_scan_rtdef_, + need_relevance_); + if (OB_SUCC(ret) && need_relevance_) { + if (OB_ISNULL(inv_idx_agg_rtdef_ = OB_NEWx(ObDASScanRtDef, &allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for rtdef", K(ret)); + } else if (OB_ISNULL(fwd_idx_rtdef_ = OB_NEWx(ObDASScanRtDef, &allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for rtdef", K(ret)); + } else if (OB_ISNULL(doc_id_idx_whole_agg_rtdef_ = OB_NEWx(ObDASScanRtDef, &allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for rtdef", K(ret)); + } else { + LST_DO_CODE(OB_UNIS_DECODE, + *inv_idx_agg_rtdef_, + *doc_id_idx_whole_agg_rtdef_, + *fwd_idx_rtdef_); + } + } + return ret; +} + +} // namespace sql +} // namespace oceanbase diff --git a/src/sql/das/ob_text_retrieval_op.h b/src/sql/das/ob_text_retrieval_op.h new file mode 100644 index 0000000000..7f8fe2b597 --- /dev/null +++ b/src/sql/das/ob_text_retrieval_op.h @@ -0,0 +1,107 @@ +/** + * 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. + */ + +#ifndef OBDEV_SRC_SQL_DAS_OB_TEXT_RETRIEVAL_OP_H_ +#define OBDEV_SRC_SQL_DAS_OB_TEXT_RETRIEVAL_OP_H_ + +#include "sql/das/ob_das_task.h" +#include "sql/das/ob_das_scan_op.h" + +namespace oceanbase +{ +namespace sql +{ +static const int64_t OB_MAX_TEXT_RETRIEVAL_TOKEN_CNT = 64; + +// Lots of meta data in ctdef / rtdef for inverted index / forward index scan are redundant here +// Should we make constant meta datas shared between iterators ? +struct ObDASIRCtDef +{ + OB_UNIS_VERSION(1); +public: + ObDASIRCtDef(common::ObIAllocator &alloc) + : allocator_(alloc), + search_text_(nullptr), + inv_scan_doc_id_col_(nullptr), + relevance_expr_(nullptr), + match_filter_(nullptr), + relevance_proj_col_(nullptr), + inv_idx_scan_ctdef_(alloc), + inv_idx_loc_meta_(alloc), + inv_idx_agg_ctdef_(nullptr), + doc_id_idx_whole_agg_ctdef_(nullptr), + fwd_idx_scan_ctdef_(nullptr), + fwd_idx_loc_meta_(nullptr), + need_relevance_(false) {} + virtual ~ObDASIRCtDef() {} + ObExpr *get_inv_scan_doc_id() const { return inv_scan_doc_id_col_; } + ObExpr *get_relevance_expr() const { return relevance_expr_; } + ObExpr *get_relevance_proj_expr() const { return relevance_proj_col_; } + bool need_proj_relevance_score() const { return nullptr != relevance_proj_col_; } + TO_STRING_KV( + KPC_(search_text), + KPC_(inv_scan_doc_id_col), + KPC_(relevance_expr), + KPC_(match_filter), + KPC_(relevance_proj_col), + K_(inv_idx_scan_ctdef), + K_(inv_idx_loc_meta), + KPC_(inv_idx_agg_ctdef), + KPC_(doc_id_idx_whole_agg_ctdef), + KPC_(fwd_idx_scan_ctdef), + KPC_(fwd_idx_loc_meta), + K_(need_relevance)); + + common::ObIAllocator &allocator_; + ObExpr *search_text_; + ObExpr *inv_scan_doc_id_col_; + ObExpr *relevance_expr_; + ObExpr *match_filter_; + ObExpr *relevance_proj_col_; + ObDASScanCtDef inv_idx_scan_ctdef_; + ObDASTableLocMeta inv_idx_loc_meta_; + ObDASScanCtDef *inv_idx_agg_ctdef_; + ObDASScanCtDef *doc_id_idx_whole_agg_ctdef_; // aggregate on inverted index with whole range + ObDASScanCtDef *fwd_idx_scan_ctdef_; + ObDASTableLocMeta *fwd_idx_loc_meta_; + bool need_relevance_; +}; + +struct ObDASIRRtDef +{ + OB_UNIS_VERSION(1); +public: + ObDASIRRtDef(common::ObIAllocator &alloc) + : allocator_(alloc), + inv_idx_scan_rtdef_(), + inv_idx_agg_rtdef_(nullptr), + doc_id_idx_whole_agg_rtdef_(nullptr), + fwd_idx_rtdef_(nullptr), + eval_ctx_(nullptr), + need_relevance_(false) {} + virtual ~ObDASIRRtDef() {} + + TO_STRING_KV(K_(inv_idx_scan_rtdef), KPC_(inv_idx_agg_rtdef), KPC_(doc_id_idx_whole_agg_rtdef), + KPC_(fwd_idx_rtdef), KPC_(eval_ctx), K_(need_relevance)); + common::ObIAllocator &allocator_; + ObDASScanRtDef inv_idx_scan_rtdef_; + ObDASScanRtDef *inv_idx_agg_rtdef_; + ObDASScanRtDef *doc_id_idx_whole_agg_rtdef_; + ObDASScanRtDef *fwd_idx_rtdef_; + ObEvalCtx *eval_ctx_; + bool need_relevance_; +}; + +} // namespace sql +} // namespace oceanbase + +#endif diff --git a/src/sql/engine/table/ob_table_scan_op.cpp b/src/sql/engine/table/ob_table_scan_op.cpp index 3bcf93fb5a..3b1f8cdd80 100644 --- a/src/sql/engine/table/ob_table_scan_op.cpp +++ b/src/sql/engine/table/ob_table_scan_op.cpp @@ -127,6 +127,18 @@ OB_DEF_SERIALIZE(ObTableScanCtDef) OB_UNIS_ENCODE(calc_part_id_expr_); OB_UNIS_ENCODE(global_index_rowkey_exprs_); OB_UNIS_ENCODE(flashback_item_.fq_read_tx_uncommitted_); + bool has_aux_lookup = false; + OB_UNIS_ENCODE(has_aux_lookup); + if (OB_SUCC(ret) && has_aux_lookup) { + OB_UNIS_ENCODE(*aux_lookup_ctdef_); + OB_UNIS_ENCODE(*aux_lookup_loc_meta_); + } + + bool has_text_ir = false; + OB_UNIS_ENCODE(has_text_ir); + if (OB_SUCC(ret) && has_text_ir) { + OB_UNIS_ENCODE(*text_ir_ctdef_); + } return ret; } @@ -154,6 +166,17 @@ OB_DEF_SERIALIZE_SIZE(ObTableScanCtDef) OB_UNIS_ADD_LEN(calc_part_id_expr_); OB_UNIS_ADD_LEN(global_index_rowkey_exprs_); OB_UNIS_ADD_LEN(flashback_item_.fq_read_tx_uncommitted_); + bool has_aux_lookup = false; + OB_UNIS_ADD_LEN(has_aux_lookup); + if (has_aux_lookup) { + OB_UNIS_ADD_LEN(*aux_lookup_ctdef_); + OB_UNIS_ADD_LEN(*aux_lookup_loc_meta_); + } + bool has_text_ir = false; + OB_UNIS_ADD_LEN(has_text_ir); + if (has_text_ir) { + OB_UNIS_ADD_LEN(*text_ir_ctdef_); + } return len; } @@ -198,6 +221,30 @@ OB_DEF_DESERIALIZE(ObTableScanCtDef) OB_UNIS_DECODE(calc_part_id_expr_); OB_UNIS_DECODE(global_index_rowkey_exprs_); OB_UNIS_DECODE(flashback_item_.fq_read_tx_uncommitted_); + bool has_aux_lookup = false; + OB_UNIS_DECODE(has_aux_lookup); + if (OB_SUCC(ret) && has_aux_lookup) { + if (OB_ISNULL(aux_lookup_ctdef_ = OB_NEWx(ObDASScanCtDef, &allocator_, allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for aux lookup ctdef", K(ret)); + } else if (OB_ISNULL(aux_lookup_loc_meta_ = OB_NEWx(ObDASTableLocMeta, &allocator_, allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for aux lookup table location meta", K(ret)); + } else { + OB_UNIS_DECODE(*aux_lookup_ctdef_); + OB_UNIS_DECODE(*aux_lookup_loc_meta_); + } + } + bool has_text_ir = false; + OB_UNIS_DECODE(has_text_ir); + if (OB_SUCC(ret) && has_text_ir) { + if (OB_ISNULL(text_ir_ctdef_ = OB_NEWx(ObDASIRCtDef, &allocator_, allocator_))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_WARN("failed to allocate memory for text ir ctdef", K(ret)); + } else { + OB_UNIS_DECODE(*text_ir_ctdef_); + } + } return ret; } diff --git a/src/sql/engine/table/ob_table_scan_op.h b/src/sql/engine/table/ob_table_scan_op.h index b1dd1c0a92..740fea5ea2 100644 --- a/src/sql/engine/table/ob_table_scan_op.h +++ b/src/sql/engine/table/ob_table_scan_op.h @@ -24,6 +24,7 @@ #include "sql/das/ob_das_ref.h" #include "sql/das/ob_data_access_service.h" #include "sql/das/ob_das_scan_op.h" +#include "sql/das/ob_text_retrieval_op.h" #include "sql/engine/basic/ob_pushdown_filter.h" #include "sql/engine/table/ob_index_lookup_op_impl.h" namespace oceanbase @@ -139,7 +140,10 @@ public: das_dppr_tbl_(nullptr), allocator_(allocator), calc_part_id_expr_(NULL), - global_index_rowkey_exprs_(allocator) + global_index_rowkey_exprs_(allocator), + aux_lookup_ctdef_(nullptr), + aux_lookup_loc_meta_(nullptr), + text_ir_ctdef_(nullptr) { } const ExprFixedArray &get_das_output_exprs() const { @@ -161,7 +165,10 @@ public: KPC_(lookup_loc_meta), KPC_(das_dppr_tbl), KPC_(calc_part_id_expr), - K_(global_index_rowkey_exprs)); + K_(global_index_rowkey_exprs), + KPC_(aux_lookup_ctdef), + KPC_(aux_lookup_loc_meta), + KPC_(text_ir_ctdef)); //the query range of index scan/table scan ObQueryRange pre_query_range_; FlashBackItem flashback_item_; @@ -188,6 +195,11 @@ public: ObExpr *calc_part_id_expr_; ExprFixedArray global_index_rowkey_exprs_; // end for Global Index Lookup + // domain doc_id aux lookup + ObDASScanCtDef *aux_lookup_ctdef_; + ObDASTableLocMeta *aux_lookup_loc_meta_; + // text retrieval + ObDASIRCtDef *text_ir_ctdef_; }; struct ObTableScanRtDef