3304 lines
134 KiB
C++
3304 lines
134 KiB
C++
/**
|
|
* 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.
|
|
*/
|
|
|
|
#define USING_LOG_PREFIX SQL_ENG
|
|
|
|
#include <random>
|
|
#include <chrono>
|
|
|
|
#include "ob_table_scan_op.h"
|
|
#include "sql/engine/ob_exec_context.h"
|
|
#include "sql/executor/ob_task_spliter.h"
|
|
#include "sql/das/ob_das_define.h"
|
|
#include "sql/das/ob_das_utils.h"
|
|
#include "lib/profile/ob_perf_event.h"
|
|
#include "lib/geo/ob_s2adapter.h"
|
|
#include "lib/geo/ob_geo_utils.h"
|
|
#include "share/ob_ddl_common.h"
|
|
#include "share/ob_ddl_checksum.h"
|
|
#include "storage/access/ob_table_scan_iterator.h"
|
|
#include "observer/ob_server_struct.h"
|
|
#include "observer/ob_server.h"
|
|
#include "observer/virtual_table/ob_virtual_data_access_service.h"
|
|
#include "sql/engine/expr/ob_expr_lob_utils.h"
|
|
#include "observer/omt/ob_tenant_srs.h"
|
|
#include "share/external_table/ob_external_table_file_mgr.h"
|
|
#include "share/external_table/ob_external_table_utils.h"
|
|
#include "lib/container/ob_array_wrap.h"
|
|
#include "sql/das/iter/ob_das_iter_utils.h"
|
|
#include "share/index_usage/ob_index_usage_info_mgr.h"
|
|
|
|
namespace oceanbase
|
|
{
|
|
using namespace common;
|
|
using namespace storage;
|
|
using namespace share;
|
|
using namespace share::schema;
|
|
namespace sql
|
|
{
|
|
#define MY_CTDEF (MY_SPEC.tsc_ctdef_)
|
|
|
|
int FlashBackItem::set_flashback_query_info(ObEvalCtx &eval_ctx, ObDASScanRtDef &scan_rtdef) const
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObDatum *datum = NULL;
|
|
const ObExpr *expr = flashback_query_expr_;
|
|
scan_rtdef.need_scn_ = need_scn_;
|
|
if (TableItem::NOT_USING == flashback_query_type_) {
|
|
// do nothing
|
|
} else if (OB_ISNULL(expr)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("flash back query expr is NULL", K(ret));
|
|
} else if (OB_FAIL(expr->eval(eval_ctx, datum))) {
|
|
LOG_WARN("expr evaluate failed", K(ret));
|
|
} else if (datum->is_null()) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("NULL value", K(ret));
|
|
} else {
|
|
scan_rtdef.fb_read_tx_uncommitted_ = fq_read_tx_uncommitted_;
|
|
if (TableItem::USING_TIMESTAMP == flashback_query_type_) {
|
|
if (ObTimestampTZType != expr->datum_meta_.type_) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("type not match", K(ret));
|
|
} else if (OB_FAIL(scan_rtdef.fb_snapshot_.convert_from_ts(datum->get_otimestamp_tz().time_us_))) {
|
|
LOG_WARN("failed to convert from ts", K(ret));
|
|
} else {
|
|
LOG_TRACE("fb_snapshot_ result", K(scan_rtdef.fb_snapshot_), K(*datum));
|
|
}
|
|
} else if (TableItem::USING_SCN == flashback_query_type_) {
|
|
if (ObUInt64Type != expr->datum_meta_.type_) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("type not match", K(ret));
|
|
} else if (OB_FAIL(scan_rtdef.fb_snapshot_.convert_for_sql(datum->get_int()))) {
|
|
LOG_WARN("failed to convert for gts", K(ret));
|
|
} else {
|
|
LOG_TRACE("fb_snapshot_ result", K(scan_rtdef.fb_snapshot_), K(*datum));
|
|
}
|
|
}
|
|
}
|
|
|
|
//对于同时存在hint指定的frozen_version和flashback query指定了snapshot version的情况下, 选择保留
|
|
//flashback query指定的snapshot version, 忽略hint指定的frozen_version
|
|
if (OB_SUCC(ret)) {
|
|
if (scan_rtdef.fb_snapshot_.is_valid()) {
|
|
scan_rtdef.frozen_version_ = transaction::ObTransVersion::INVALID_TRANS_VERSION;
|
|
} else {
|
|
/*do nothing*/
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
OB_SERIALIZE_MEMBER(AgentVtAccessMeta,
|
|
vt_table_id_,
|
|
access_exprs_,
|
|
access_column_ids_,
|
|
access_row_types_,
|
|
key_types_);
|
|
|
|
OB_DEF_SERIALIZE(ObTableScanCtDef)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
bool has_lookup = (lookup_ctdef_ != nullptr);
|
|
OB_UNIS_ENCODE(pre_query_range_);
|
|
OB_UNIS_ENCODE(flashback_item_.need_scn_);
|
|
OB_UNIS_ENCODE(flashback_item_.flashback_query_expr_);
|
|
OB_UNIS_ENCODE(flashback_item_.flashback_query_type_);
|
|
OB_UNIS_ENCODE(bnlj_param_idxs_);
|
|
OB_UNIS_ENCODE(scan_flags_);
|
|
OB_UNIS_ENCODE(scan_ctdef_);
|
|
OB_UNIS_ENCODE(has_lookup);
|
|
if (OB_SUCC(ret) && has_lookup) {
|
|
OB_UNIS_ENCODE(*lookup_ctdef_);
|
|
OB_UNIS_ENCODE(*lookup_loc_meta_);
|
|
}
|
|
bool has_dppr_tbl = (das_dppr_tbl_ != nullptr);
|
|
OB_UNIS_ENCODE(has_dppr_tbl);
|
|
if (OB_SUCC(ret) && has_dppr_tbl) {
|
|
OB_UNIS_ENCODE(*das_dppr_tbl_);
|
|
}
|
|
OB_UNIS_ENCODE(calc_part_id_expr_);
|
|
OB_UNIS_ENCODE(global_index_rowkey_exprs_);
|
|
OB_UNIS_ENCODE(flashback_item_.fq_read_tx_uncommitted_);
|
|
// abandoned fields, please remove me at next barrier version
|
|
bool abandoned_always_false_aux_lookup = false;
|
|
bool abandoned_always_false_text_ir = false;
|
|
OB_UNIS_ENCODE(abandoned_always_false_aux_lookup);
|
|
OB_UNIS_ENCODE(abandoned_always_false_text_ir);
|
|
OB_UNIS_ENCODE(attach_spec_);
|
|
return ret;
|
|
}
|
|
|
|
OB_DEF_SERIALIZE_SIZE(ObTableScanCtDef)
|
|
{
|
|
int64_t len = 0;
|
|
bool has_lookup = (lookup_ctdef_ != nullptr);
|
|
OB_UNIS_ADD_LEN(pre_query_range_);
|
|
OB_UNIS_ADD_LEN(flashback_item_.need_scn_);
|
|
OB_UNIS_ADD_LEN(flashback_item_.flashback_query_expr_);
|
|
OB_UNIS_ADD_LEN(flashback_item_.flashback_query_type_);
|
|
OB_UNIS_ADD_LEN(bnlj_param_idxs_);
|
|
OB_UNIS_ADD_LEN(scan_flags_);
|
|
OB_UNIS_ADD_LEN(scan_ctdef_);
|
|
OB_UNIS_ADD_LEN(has_lookup);
|
|
if (has_lookup) {
|
|
OB_UNIS_ADD_LEN(*lookup_ctdef_);
|
|
OB_UNIS_ADD_LEN(*lookup_loc_meta_);
|
|
}
|
|
bool has_dppr_tbl = (das_dppr_tbl_ != nullptr);
|
|
OB_UNIS_ADD_LEN(has_dppr_tbl);
|
|
if (has_dppr_tbl) {
|
|
OB_UNIS_ADD_LEN(*das_dppr_tbl_);
|
|
}
|
|
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_);
|
|
// abandoned fields, please remove me at next barrier version
|
|
bool abandoned_always_false_aux_lookup = false;
|
|
bool abandoned_always_false_text_ir = false;
|
|
OB_UNIS_ADD_LEN(abandoned_always_false_aux_lookup);
|
|
OB_UNIS_ADD_LEN(abandoned_always_false_text_ir);
|
|
OB_UNIS_ADD_LEN(attach_spec_);
|
|
return len;
|
|
}
|
|
|
|
OB_DEF_DESERIALIZE(ObTableScanCtDef)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
bool has_lookup = false;
|
|
OB_UNIS_DECODE(pre_query_range_);
|
|
OB_UNIS_DECODE(flashback_item_.need_scn_);
|
|
OB_UNIS_DECODE(flashback_item_.flashback_query_expr_);
|
|
OB_UNIS_DECODE(flashback_item_.flashback_query_type_);
|
|
OB_UNIS_DECODE(bnlj_param_idxs_);
|
|
OB_UNIS_DECODE(scan_flags_);
|
|
OB_UNIS_DECODE(scan_ctdef_);
|
|
OB_UNIS_DECODE(has_lookup);
|
|
if (OB_SUCC(ret) && has_lookup) {
|
|
void *ctdef_buf = allocator_.alloc(sizeof(ObDASScanCtDef));
|
|
if (OB_ISNULL(ctdef_buf)) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate das scan ctdef buffer failed", K(ret), K(sizeof(ObDASScanCtDef)));
|
|
} else {
|
|
lookup_ctdef_ = new(ctdef_buf) ObDASScanCtDef(allocator_);
|
|
OB_UNIS_DECODE(*lookup_ctdef_);
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
void *loc_meta_buf = allocator_.alloc(sizeof(ObDASTableLocMeta));
|
|
if (OB_ISNULL(loc_meta_buf)) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate table loc meta failed", K(ret));
|
|
} else {
|
|
lookup_loc_meta_ = new(loc_meta_buf) ObDASTableLocMeta(allocator_);
|
|
OB_UNIS_DECODE(*lookup_loc_meta_);
|
|
}
|
|
}
|
|
}
|
|
bool has_dppr_tbl = (das_dppr_tbl_ != nullptr);
|
|
OB_UNIS_DECODE(has_dppr_tbl);
|
|
if (OB_SUCC(ret) && has_dppr_tbl) {
|
|
OZ(allocate_dppr_table_loc());
|
|
OB_UNIS_DECODE(*das_dppr_tbl_);
|
|
}
|
|
OB_UNIS_DECODE(calc_part_id_expr_);
|
|
OB_UNIS_DECODE(global_index_rowkey_exprs_);
|
|
OB_UNIS_DECODE(flashback_item_.fq_read_tx_uncommitted_);
|
|
// abandoned fields, please remove me at next barrier version
|
|
bool abandoned_always_false_aux_lookup = false;
|
|
bool abandoned_always_false_text_ir = false;
|
|
OB_UNIS_DECODE(abandoned_always_false_aux_lookup);
|
|
OB_UNIS_DECODE(abandoned_always_false_text_ir);
|
|
OB_UNIS_DECODE(attach_spec_);
|
|
return ret;
|
|
}
|
|
|
|
ObDASScanCtDef *ObTableScanCtDef::get_lookup_ctdef()
|
|
{
|
|
ObDASScanCtDef *lookup_ctdef = nullptr;
|
|
if (nullptr == attach_spec_.attach_ctdef_) {
|
|
lookup_ctdef = lookup_ctdef_;
|
|
} else {
|
|
ObDASTableLookupCtDef *table_lookup_ctdef = nullptr;
|
|
if (DAS_OP_TABLE_LOOKUP == attach_spec_.attach_ctdef_->op_type_) {
|
|
OB_ASSERT(2 == attach_spec_.attach_ctdef_->children_cnt_ &&
|
|
attach_spec_.attach_ctdef_->children_ != nullptr);
|
|
if (DAS_OP_TABLE_SCAN == attach_spec_.attach_ctdef_->children_[1]->op_type_) {
|
|
lookup_ctdef = static_cast<ObDASScanCtDef*>(attach_spec_.attach_ctdef_->children_[1]);
|
|
}
|
|
}
|
|
}
|
|
return lookup_ctdef;
|
|
}
|
|
|
|
int ObTableScanCtDef::allocate_dppr_table_loc()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
void *buf = allocator_.alloc(sizeof(ObTableLocation));
|
|
if (OB_ISNULL(buf)) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate table location buffer failed", K(ret));
|
|
} else {
|
|
das_dppr_tbl_ = new(buf) ObTableLocation(allocator_);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
OB_INLINE void ObTableScanRtDef::prepare_multi_part_limit_param()
|
|
{
|
|
/* for multi-partition scanning, */
|
|
/* the limit operation pushed down to the partition TSC needs to be adjusted */
|
|
/* its rule: */
|
|
/* TSC(limit m, n) */
|
|
/* / \ */
|
|
/* / \ */
|
|
/* DAS Scan(p0) DAS Scan(p1) */
|
|
/* (p0, limit m+n) (p1, limit m+n) */
|
|
/* each partition scans limit m+n rows of data, */
|
|
/* and TSC operator selects the offset (m) limit (n) rows in the final result */
|
|
int64_t offset = scan_rtdef_.limit_param_.offset_;
|
|
int64_t limit = scan_rtdef_.limit_param_.limit_;
|
|
scan_rtdef_.limit_param_.limit_ = offset + limit;
|
|
scan_rtdef_.limit_param_.offset_ = 0;
|
|
if (lookup_rtdef_ != nullptr) {
|
|
offset = lookup_rtdef_->limit_param_.offset_;
|
|
limit = lookup_rtdef_->limit_param_.limit_;
|
|
lookup_rtdef_->limit_param_.limit_ = offset + limit;
|
|
lookup_rtdef_->limit_param_.offset_ = 0;
|
|
}
|
|
}
|
|
|
|
ObTableScanOpInput::ObTableScanOpInput(ObExecContext &ctx, const ObOpSpec &spec)
|
|
: ObOpInput(ctx, spec),
|
|
tablet_loc_(nullptr),
|
|
not_need_extract_query_range_(false)
|
|
{
|
|
}
|
|
|
|
ObTableScanOpInput::~ObTableScanOpInput()
|
|
{
|
|
}
|
|
|
|
void ObTableScanOpInput::reset()
|
|
{
|
|
tablet_loc_ = nullptr;
|
|
key_ranges_.reset();
|
|
ss_key_ranges_.reset();
|
|
mbr_filters_.reset();
|
|
range_array_pos_.reset();
|
|
not_need_extract_query_range_ = false;
|
|
}
|
|
|
|
OB_DEF_SERIALIZE_SIZE(ObTableScanOpInput)
|
|
{
|
|
int len = 0;
|
|
LST_DO_CODE(OB_UNIS_ADD_LEN,
|
|
key_ranges_,
|
|
not_need_extract_query_range_,
|
|
ss_key_ranges_);
|
|
return len;
|
|
}
|
|
|
|
OB_DEF_SERIALIZE(ObTableScanOpInput)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
LST_DO_CODE(OB_UNIS_ENCODE,
|
|
key_ranges_,
|
|
not_need_extract_query_range_,
|
|
ss_key_ranges_);
|
|
return ret;
|
|
}
|
|
|
|
OB_DEF_DESERIALIZE(ObTableScanOpInput)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
int64_t cnt = 0;
|
|
if (OB_FAIL(serialization::decode_vi64(buf, data_len, pos, &cnt))) {
|
|
LOG_WARN("decode failed", K(ret));
|
|
} else if (OB_FAIL(key_ranges_.prepare_allocate(cnt))) {
|
|
LOG_WARN("array prepare allocate failed", K(ret));
|
|
} else {
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < cnt; i++) {
|
|
if (OB_FAIL(key_ranges_.at(i).deserialize(
|
|
exec_ctx_.get_allocator(), buf, data_len, pos))) {
|
|
LOG_WARN("range deserialize failed", K(ret));
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
} else if (OB_FAIL(serialization::decode_vi64(buf, data_len, pos, &cnt))) {
|
|
LOG_WARN("decode failed", K(ret));
|
|
} else if (OB_FAIL(ss_key_ranges_.prepare_allocate(cnt))) {
|
|
LOG_WARN("array prepare allocate failed", K(ret));
|
|
}
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < cnt; i++) {
|
|
if (OB_FAIL(ss_key_ranges_.at(i).deserialize(exec_ctx_.get_allocator(),
|
|
buf, data_len, pos))) {
|
|
LOG_WARN("range deserialize failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
LST_DO_CODE(OB_UNIS_DECODE, not_need_extract_query_range_);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOpInput::init(ObTaskInfo &task_info)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (PHY_FAKE_CTE_TABLE == MY_SPEC.type_) {
|
|
LOG_DEBUG("CTE TABLE do not need init", K(ret));
|
|
} else if (ObTaskSpliter::INVALID_SPLIT == task_info.get_task_split_type()) {
|
|
ret = OB_NOT_INIT;
|
|
LOG_WARN("exec type is INVALID_SPLIT", K(ret));
|
|
} else {
|
|
if (1 == task_info.get_range_location().part_locs_.count() // only one table
|
|
&& 0 < task_info.get_range_location().part_locs_.at(0).scan_ranges_.count()) {
|
|
// multi-range
|
|
ret = key_ranges_.assign(task_info.get_range_location().part_locs_.at(0).scan_ranges_);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
OB_INLINE int ObTableScanOp::reuse_table_rescan_allocator()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_ISNULL(table_rescan_allocator_)) {
|
|
ObSQLSessionInfo *my_session = GET_MY_SESSION(ctx_);
|
|
lib::ContextParam param;
|
|
ObMemAttr attr(my_session->get_effective_tenant_id(),
|
|
"TableRescanCtx", ObCtxIds::DEFAULT_CTX_ID);
|
|
param.set_mem_attr(SET_IGNORE_MEM_VERSION(attr))
|
|
.set_properties(lib::USE_TL_PAGE_OPTIONAL)
|
|
.set_ablock_size(lib::INTACT_MIDDLE_AOBJECT_SIZE);
|
|
lib::MemoryContext mem_context;
|
|
if (OB_FAIL(CURRENT_CONTEXT->CREATE_CONTEXT(mem_context, param))) {
|
|
LOG_WARN("fail to create entity", K(ret));
|
|
} else if (OB_ISNULL(mem_context)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("fail to create entity ", K(ret));
|
|
} else {
|
|
table_rescan_allocator_ = &mem_context->get_arena_allocator();
|
|
}
|
|
} else {
|
|
table_rescan_allocator_->reuse();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
ObTableScanSpec::ObTableScanSpec(ObIAllocator &alloc, const ObPhyOperatorType type)
|
|
: ObOpSpec(alloc, type),
|
|
table_loc_id_(OB_INVALID_ID),
|
|
ref_table_id_(OB_INVALID_ID),
|
|
limit_(NULL),
|
|
offset_(NULL),
|
|
frozen_version_(-1),
|
|
part_level_(ObPartitionLevel::PARTITION_LEVEL_MAX),
|
|
part_type_(ObPartitionFuncType::PARTITION_FUNC_TYPE_MAX),
|
|
subpart_type_(ObPartitionFuncType::PARTITION_FUNC_TYPE_MAX),
|
|
part_expr_(NULL),
|
|
subpart_expr_(NULL),
|
|
part_range_pos_(alloc),
|
|
subpart_range_pos_(alloc),
|
|
part_dep_cols_(alloc),
|
|
subpart_dep_cols_(alloc),
|
|
table_row_count_(0),
|
|
output_row_count_(0),
|
|
phy_query_range_row_count_(0),
|
|
query_range_row_count_(0),
|
|
index_back_row_count_(0),
|
|
estimate_method_(INVALID_METHOD),
|
|
est_records_(alloc),
|
|
available_index_name_(alloc),
|
|
pruned_index_name_(alloc),
|
|
unstable_index_name_(alloc),
|
|
ddl_output_cids_(alloc),
|
|
tsc_ctdef_(alloc),
|
|
pdml_partition_id_(NULL),
|
|
agent_vt_meta_(alloc),
|
|
flags_(0),
|
|
tenant_id_col_idx_(0),
|
|
partition_id_calc_type_(0)
|
|
{
|
|
}
|
|
|
|
OB_SERIALIZE_MEMBER((ObTableScanSpec, ObOpSpec),
|
|
table_loc_id_,
|
|
ref_table_id_,
|
|
flags_,
|
|
limit_,
|
|
offset_,
|
|
frozen_version_,
|
|
part_level_,
|
|
part_type_,
|
|
subpart_type_,
|
|
part_expr_,
|
|
subpart_expr_,
|
|
part_range_pos_,
|
|
subpart_range_pos_,
|
|
part_dep_cols_,
|
|
subpart_dep_cols_,
|
|
tsc_ctdef_,
|
|
pdml_partition_id_,
|
|
agent_vt_meta_,
|
|
ddl_output_cids_,
|
|
tenant_id_col_idx_,
|
|
partition_id_calc_type_);
|
|
|
|
DEF_TO_STRING(ObTableScanSpec)
|
|
{
|
|
int64_t pos = 0;
|
|
J_OBJ_START();
|
|
J_NAME("op_spec");
|
|
J_COLON();
|
|
pos += ObOpSpec::to_string(buf + pos, buf_len - pos);
|
|
J_COMMA();
|
|
J_KV(K(table_loc_id_),
|
|
K(ref_table_id_),
|
|
K(is_index_global_),
|
|
K(limit_),
|
|
K(offset_),
|
|
K(frozen_version_),
|
|
K(force_refresh_lc_),
|
|
K(is_top_table_scan_),
|
|
K(gi_above_),
|
|
K(batch_scan_flag_),
|
|
K(use_dist_das_),
|
|
K(tsc_ctdef_),
|
|
K(report_col_checksum_),
|
|
K_(agent_vt_meta),
|
|
K_(ddl_output_cids),
|
|
K_(tenant_id_col_idx));
|
|
J_OBJ_END();
|
|
return pos;
|
|
}
|
|
|
|
int ObTableScanSpec::set_est_row_count_record(const ObIArray<ObEstRowCountRecord> &est_records)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
OZ(est_records_.init(est_records.count()));
|
|
OZ(append(est_records_, est_records));
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanSpec::set_available_index_name(const ObIArray<ObString> &idx_name,
|
|
ObIAllocator &phy_alloc)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
OZ(available_index_name_.init(idx_name.count()));
|
|
FOREACH_CNT_X(n, idx_name, OB_SUCC(ret)) {
|
|
ObString name;
|
|
OZ(ob_write_string(phy_alloc, *n, name));
|
|
OZ(available_index_name_.push_back(name));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanSpec::set_unstable_index_name(const ObIArray<ObString> &idx_name,
|
|
ObIAllocator &phy_alloc)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
OZ(unstable_index_name_.init(idx_name.count()));
|
|
FOREACH_CNT_X(n, idx_name, OB_SUCC(ret)) {
|
|
ObString name;
|
|
OZ(ob_write_string(phy_alloc, *n, name));
|
|
OZ(unstable_index_name_.push_back(name));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanSpec::set_pruned_index_name(const ObIArray<ObString> &idx_name,
|
|
ObIAllocator &phy_alloc)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
OZ(pruned_index_name_.init(idx_name.count()));
|
|
FOREACH_CNT_X(n, idx_name, OB_SUCC(ret)) {
|
|
ObString name;
|
|
OZ(ob_write_string(phy_alloc, *n, name));
|
|
OZ(pruned_index_name_.push_back(name));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanSpec::explain_index_selection_info(
|
|
char *buf, int64_t buf_len, int64_t &pos) const
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_FAIL(BUF_PRINTF(
|
|
"table_rows:%ld, physical_range_rows:%ld, logical_range_rows:%ld, "
|
|
"index_back_rows:%ld, output_rows:%ld",
|
|
table_row_count_, phy_query_range_row_count_, query_range_row_count_,
|
|
index_back_row_count_, output_row_count_))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
}
|
|
if (OB_SUCC(ret) && available_index_name_.count() > 0) {
|
|
// print available index id
|
|
if (OB_FAIL(BUF_PRINTF(", avaiable_index_name["))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
}
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < available_index_name_.count(); ++i) {
|
|
if (OB_FAIL(BUF_PRINTF("%.*s", available_index_name_.at(i).length(),
|
|
available_index_name_.at(i).ptr()))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
} else if (i != available_index_name_.count() - 1) {
|
|
if (OB_FAIL(BUF_PRINTF(","))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
} else { /* do nothing*/ }
|
|
} else { /* do nothing*/ }
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(BUF_PRINTF("]"))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
} else { /* Do nothing */ }
|
|
} else { /* Do nothing */ }
|
|
}
|
|
|
|
if (OB_SUCC(ret) && pruned_index_name_.count() > 0) {
|
|
if (OB_FAIL(BUF_PRINTF(", pruned_index_name["))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
}
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < pruned_index_name_.count(); ++i) {
|
|
if (OB_FAIL(BUF_PRINTF("%.*s", pruned_index_name_.at(i).length(),
|
|
pruned_index_name_.at(i).ptr()))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
} else if (i != pruned_index_name_.count() - 1) {
|
|
if (OB_FAIL(BUF_PRINTF(","))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
} else { /* do nothing*/ }
|
|
} else { /* do nothing*/ }
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(BUF_PRINTF("]"))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
} else { /* Do nothing */ }
|
|
} else { /* Do nothing */ }
|
|
}
|
|
|
|
if (OB_SUCC(ret) && unstable_index_name_.count() > 0) {
|
|
if (OB_FAIL(BUF_PRINTF(", unstable_index_name["))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
}
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < unstable_index_name_.count(); ++i) {
|
|
if (OB_FAIL(BUF_PRINTF("%.*s", unstable_index_name_.at(i).length(),
|
|
unstable_index_name_.at(i).ptr()))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
} else if (i != unstable_index_name_.count() - 1) {
|
|
if (OB_FAIL(BUF_PRINTF(","))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
} else { /* do nothing*/ }
|
|
} else { /* do nothing*/ }
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(BUF_PRINTF("]"))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
} else { /* Do nothing */ }
|
|
} else { /* Do nothing */ }
|
|
}
|
|
|
|
if (OB_SUCC(ret) && est_records_.count() > 0) {
|
|
// print est row count infos
|
|
if (OB_FAIL(BUF_PRINTF(", estimation info[table_id:%ld,", est_records_.at(0).table_id_))) {
|
|
LOG_WARN("BUF_PRINTF fails", K(ret));
|
|
}
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < est_records_.count(); ++i) {
|
|
const ObEstRowCountRecord &record = est_records_.at(i);
|
|
if (OB_FAIL(BUF_PRINTF(
|
|
" (table_type:%ld, version:%ld-%ld-%ld, logical_rc:%ld, physical_rc:%ld)%c",
|
|
record.table_type_,
|
|
record.version_range_.base_version_,
|
|
record.version_range_.multi_version_start_,
|
|
record.version_range_.snapshot_version_,
|
|
record.logical_row_count_,
|
|
record.physical_row_count_,
|
|
i == est_records_.count() - 1 ? ']' : ','))) {
|
|
LOG_WARN("BUF PRINTF fails", K(ret));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
ObTableScanOp::ObTableScanOp(ObExecContext &exec_ctx, const ObOpSpec &spec, ObOpInput *input)
|
|
: ObOperator(exec_ctx, spec, input),
|
|
tsc_rtdef_(exec_ctx.get_allocator()),
|
|
need_final_limit_(false),
|
|
table_rescan_allocator_(NULL),
|
|
input_row_cnt_(0),
|
|
output_row_cnt_(0),
|
|
iter_end_(false),
|
|
iterated_rows_(0),
|
|
got_feedback_(false),
|
|
vt_result_converter_(nullptr),
|
|
cur_trace_id_(nullptr),
|
|
col_need_reshape_(),
|
|
column_checksum_(),
|
|
scan_task_id_(0),
|
|
report_checksum_(false),
|
|
in_rescan_(false),
|
|
spat_index_(),
|
|
output_ (nullptr),
|
|
fold_iter_(nullptr),
|
|
iter_tree_(nullptr),
|
|
scan_iter_(nullptr),
|
|
group_rescan_cnt_(0),
|
|
group_id_(0)
|
|
{
|
|
}
|
|
|
|
ObTableScanOp::~ObTableScanOp()
|
|
{
|
|
}
|
|
|
|
OB_INLINE int ObTableScanOp::create_one_das_task(ObDASTabletLoc *tablet_loc)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObDASScanOp *scan_op = nullptr;
|
|
bool reuse_das_op = false;
|
|
if (OB_ISNULL(scan_iter_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected nullptr scan iter", K(ret));
|
|
} else if (OB_FAIL(scan_iter_->create_das_task(tablet_loc, scan_op, reuse_das_op))) {
|
|
LOG_WARN("prepare das task failed", K(ret));
|
|
} else if (!reuse_das_op) {
|
|
scan_op->set_scan_ctdef(&MY_CTDEF.scan_ctdef_);
|
|
scan_op->set_scan_rtdef(&tsc_rtdef_.scan_rtdef_);
|
|
scan_op->set_can_part_retry(nullptr == tsc_rtdef_.scan_rtdef_.sample_info_
|
|
&& can_partition_retry());
|
|
scan_op->set_inner_rescan(in_rescan_);
|
|
tsc_rtdef_.scan_rtdef_.table_loc_->is_reading_ = true;
|
|
if (!MY_SPEC.is_index_global_ && MY_CTDEF.lookup_ctdef_ != nullptr) {
|
|
if (OB_FAIL(pushdown_normal_lookup_to_das(*scan_op))) {
|
|
LOG_WARN("pushdown normal lookup to das failed", K(ret));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && MY_CTDEF.attach_spec_.attach_ctdef_ != nullptr) {
|
|
if (OB_FAIL(pushdown_attach_task_to_das(*scan_op))) {
|
|
LOG_WARN("pushdown attach task to das failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(cherry_pick_range_by_tablet_id(scan_op))) {
|
|
LOG_WARN("prune query range by partition id failed", K(ret), KPC(tablet_loc));
|
|
} else if (OB_NOT_NULL(DAS_GROUP_SCAN_OP(scan_op))) {
|
|
static_cast<ObDASGroupScanOp*>(scan_op)->init_group_range(0, tsc_rtdef_.group_size_);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::pushdown_normal_lookup_to_das(ObDASScanOp &target_op)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
//is local index lookup, need to set the lookup ctdef to the das scan op
|
|
ObDASTableLoc *lookup_table_loc = tsc_rtdef_.lookup_rtdef_->table_loc_;
|
|
ObDASTabletLoc *lookup_tablet_loc = ObDASUtils::get_related_tablet_loc(
|
|
*target_op.get_tablet_loc(), lookup_table_loc->loc_meta_->ref_table_id_);
|
|
if (OB_ISNULL(lookup_tablet_loc)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("lookup tablet loc is nullptr", K(ret), KPC(target_op.get_tablet_loc()), KPC(lookup_table_loc->loc_meta_));
|
|
} else if (OB_FAIL(target_op.reserve_related_buffer(1))) {
|
|
LOG_WARN("reserve related buffer failed", K(ret));
|
|
} else if (OB_FAIL(target_op.set_related_task_info(MY_CTDEF.lookup_ctdef_,
|
|
tsc_rtdef_.lookup_rtdef_,
|
|
lookup_tablet_loc->tablet_id_))) {
|
|
LOG_WARN("set lookup info failed", K(ret));
|
|
} else {
|
|
lookup_table_loc->is_reading_ = true;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::pushdown_attach_task_to_das(ObDASScanOp &target_op)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObDASAttachRtInfo *attach_rtinfo = tsc_rtdef_.attach_rtinfo_;
|
|
if (OB_FAIL(target_op.reserve_related_buffer(attach_rtinfo->related_scan_cnt_))) {
|
|
LOG_WARN("reserve related buffer failed", K(ret), K(attach_rtinfo->related_scan_cnt_));
|
|
} else if (OB_FAIL(attach_related_taskinfo(target_op, attach_rtinfo->attach_rtdef_))) {
|
|
LOG_WARN("attach related task info failed", K(ret));
|
|
} else {
|
|
target_op.set_attach_ctdef(MY_CTDEF.attach_spec_.attach_ctdef_);
|
|
target_op.set_attach_rtdef(tsc_rtdef_.attach_rtinfo_->attach_rtdef_);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::attach_related_taskinfo(ObDASScanOp &target_op, ObDASBaseRtDef *attach_rtdef)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_ISNULL(attach_rtdef) || OB_ISNULL(attach_rtdef->ctdef_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("attach rtdef is invalid", K(ret), KP(attach_rtdef));
|
|
} else if (attach_rtdef->op_type_ == DAS_OP_TABLE_SCAN) {
|
|
const ObDASScanCtDef *scan_ctdef = static_cast<const ObDASScanCtDef*>(attach_rtdef->ctdef_);
|
|
ObDASScanRtDef *scan_rtdef = static_cast<ObDASScanRtDef*>(attach_rtdef);
|
|
ObDASTableLoc *table_loc = scan_rtdef->table_loc_;
|
|
ObDASTabletLoc *tablet_loc = ObDASUtils::get_related_tablet_loc(
|
|
*target_op.get_tablet_loc(), table_loc->loc_meta_->ref_table_id_);
|
|
if (OB_ISNULL(tablet_loc)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("related tablet loc is not found", K(ret),
|
|
KPC(target_op.get_tablet_loc()),
|
|
KPC(table_loc->loc_meta_));
|
|
} else if (OB_FAIL(target_op.set_related_task_info(scan_ctdef,
|
|
scan_rtdef,
|
|
tablet_loc->tablet_id_))) {
|
|
LOG_WARN("set attach task info failed", K(ret), KPC(tablet_loc));
|
|
} else {
|
|
table_loc->is_reading_ = true;
|
|
}
|
|
} else {
|
|
for (int i = 0; OB_SUCC(ret) && i < attach_rtdef->children_cnt_; ++i) {
|
|
if (OB_FAIL(attach_related_taskinfo(target_op, attach_rtdef->children_[i]))) {
|
|
LOG_WARN("recursive attach related task info failed", K(ret), K(i));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::prepare_pushdown_limit_param()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (!limit_param_.is_valid()) {
|
|
//ignore, do nothing
|
|
} else if (in_batch_rescan_subplan() || nullptr != tsc_rtdef_.attach_rtinfo_) {
|
|
//batch scan can not pushdown limit param to storage
|
|
// do final limit for TSC op with attached ops for now
|
|
need_final_limit_ = true;
|
|
tsc_rtdef_.scan_rtdef_.limit_param_.offset_ = 0;
|
|
tsc_rtdef_.scan_rtdef_.limit_param_.limit_ = -1;
|
|
|
|
if (nullptr != MY_CTDEF.lookup_ctdef_) {
|
|
OB_ASSERT(nullptr != tsc_rtdef_.lookup_rtdef_);
|
|
tsc_rtdef_.lookup_rtdef_->limit_param_.offset_ = 0;
|
|
tsc_rtdef_.lookup_rtdef_->limit_param_.limit_ = -1;
|
|
}
|
|
} else if (tsc_rtdef_.has_lookup_limit() || (OB_NOT_NULL(scan_iter_) && scan_iter_->get_das_task_cnt() > 1)) {
|
|
//for index back, need to final limit output rows in TableScan operator,
|
|
//please see me for the reason:
|
|
/* for multi-partition scanning, */
|
|
/* the limit operation pushed down to the partition TSC needs to be adjusted */
|
|
/* its rule: */
|
|
/* TSC(limit m, n) */
|
|
/* / \ */
|
|
/* / \ */
|
|
/* DAS Scan(p0) DAS Scan(p1) */
|
|
/* (p0, limit m+n) (p1, limit m+n) */
|
|
/* each partition scans limit m+n rows of data, */
|
|
/* and TSC operator selects the offset (m) limit (n) rows in the final result */
|
|
need_final_limit_ = true;
|
|
tsc_rtdef_.prepare_multi_part_limit_param();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::prepare_das_task()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObTaskExecutorCtx &task_exec_ctx = ctx_.get_task_exec_ctx();
|
|
if (OB_LIKELY(!MY_SPEC.use_dist_das_)) {
|
|
if (OB_FAIL(create_one_das_task(MY_INPUT.tablet_loc_))) {
|
|
LOG_WARN("create one das task failed", K(ret));
|
|
}
|
|
} else if (OB_LIKELY(nullptr == MY_CTDEF.das_dppr_tbl_)) {
|
|
ObDASTableLoc *table_loc = tsc_rtdef_.scan_rtdef_.table_loc_;
|
|
for (DASTabletLocListIter node = table_loc->tablet_locs_begin();
|
|
OB_SUCC(ret) && node != table_loc->tablet_locs_end(); ++node) {
|
|
ObDASTabletLoc *tablet_loc = *node;
|
|
if (OB_FAIL(create_one_das_task(tablet_loc))) {
|
|
LOG_WARN("create one das task failed", K(ret));
|
|
}
|
|
}
|
|
} else {
|
|
// dynamic partitions
|
|
ObPhysicalPlanCtx *plan_ctx = ctx_.get_physical_plan_ctx();
|
|
ObDataTypeCastParams dtc_params = ObBasicSessionInfo::create_dtc_params(ctx_.get_my_session());
|
|
const ObTableLocation &das_location = *MY_CTDEF.das_dppr_tbl_;
|
|
ObSEArray<ObTabletID, 1> tablet_ids;
|
|
ObSEArray<ObObjectID, 1> partition_ids;
|
|
ObSEArray<ObObjectID, 1> first_level_part_ids;
|
|
if (OB_FAIL(das_location.calculate_tablet_ids(ctx_,
|
|
plan_ctx->get_param_store(),
|
|
tablet_ids,
|
|
partition_ids,
|
|
first_level_part_ids,
|
|
dtc_params))) {
|
|
LOG_WARN("calculate dynamic partitions failed", K(ret));
|
|
} else {
|
|
LOG_TRACE("dynamic partitions", K(tablet_ids), K(partition_ids), K(first_level_part_ids));
|
|
}
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < tablet_ids.count(); ++i) {
|
|
ObDASTabletLoc *tablet_loc = nullptr;
|
|
if (OB_FAIL(DAS_CTX(ctx_).extended_tablet_loc(*tsc_rtdef_.scan_rtdef_.table_loc_,
|
|
tablet_ids.at(i),
|
|
tablet_loc))) {
|
|
LOG_WARN("extended tablet loc failed", K(ret));
|
|
} else if (OB_FAIL(create_one_das_task(tablet_loc))) {
|
|
LOG_WARN("create one das task failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
int ObTableScanOp::prepare_all_das_tasks()
|
|
{
|
|
// get grop size of batch rescan
|
|
int ret = OB_SUCCESS;
|
|
if (need_perform_real_batch_rescan()) {
|
|
tsc_rtdef_.group_size_ = tsc_rtdef_.bnlj_params_.at(0).gr_param_->count_;
|
|
if (OB_UNLIKELY(tsc_rtdef_.group_size_ > tsc_rtdef_.max_group_size_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("The amount of data exceeds the pre allocated memory", K(ret));
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
if (MY_SPEC.gi_above_ && !MY_INPUT.key_ranges_.empty()) {
|
|
if (OB_FAIL(prepare_das_task())) {
|
|
LOG_WARN("prepare das task failed", K(ret));
|
|
}
|
|
} else {
|
|
int64_t group_size = (output_ == iter_tree_) ? 1: tsc_rtdef_.group_size_;
|
|
GroupRescanParamGuard grp_guard(tsc_rtdef_, GET_PHY_PLAN_CTX(ctx_)->get_param_store_for_update());
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < group_size; ++i) {
|
|
if (need_perform_real_batch_rescan()) {
|
|
grp_guard.switch_group_rescan_param(i);
|
|
}
|
|
if (OB_FAIL(prepare_single_scan_range(i))) {
|
|
LOG_WARN("prepare single scan range failed", K(ret));
|
|
} else if (OB_FAIL(prepare_das_task())) {
|
|
LOG_WARN("prepare das task failed", K(ret));
|
|
} else {
|
|
MY_INPUT.key_ranges_.reuse();
|
|
MY_INPUT.ss_key_ranges_.reuse();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::init_attach_scan_rtdef(const ObDASBaseCtDef *attach_ctdef,
|
|
ObDASBaseRtDef *&attach_rtdef)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObDASTaskFactory &das_factory = DAS_CTX(ctx_).get_das_factory();
|
|
if (OB_ISNULL(attach_ctdef)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("attach ctdef is nullptr", K(ret));
|
|
} else if (OB_FAIL(das_factory.create_das_rtdef(attach_ctdef->op_type_, attach_rtdef))) {
|
|
LOG_WARN("create das rtdef failed", K(ret), K(attach_ctdef->op_type_));
|
|
} else if (ObDASTaskFactory::is_attached(attach_ctdef->op_type_)) {
|
|
attach_rtdef->ctdef_ = attach_ctdef;
|
|
attach_rtdef->children_cnt_ = attach_ctdef->children_cnt_;
|
|
attach_rtdef->eval_ctx_ = &eval_ctx_;
|
|
if (attach_ctdef->children_cnt_ > 0) {
|
|
if (OB_ISNULL(attach_rtdef->children_ = OB_NEW_ARRAY(ObDASBaseRtDef*,
|
|
&ctx_.get_allocator(),
|
|
attach_ctdef->children_cnt_))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate child buf failed", K(ret), K(attach_ctdef->children_cnt_));
|
|
}
|
|
for (int i = 0; OB_SUCC(ret) && i < attach_ctdef->children_cnt_; ++i) {
|
|
if (OB_FAIL(init_attach_scan_rtdef(attach_ctdef->children_[i], attach_rtdef->children_[i]))) {
|
|
LOG_WARN("init attach scan rtdef failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
tsc_rtdef_.attach_rtinfo_->related_scan_cnt_++;
|
|
if (attach_ctdef == &MY_CTDEF.scan_ctdef_) {
|
|
attach_rtdef = &tsc_rtdef_.scan_rtdef_;
|
|
} else if (attach_ctdef->op_type_ != DAS_OP_TABLE_SCAN) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("attach ctdef type is invalid", K(ret), K(attach_ctdef->op_type_));
|
|
} else {
|
|
const ObDASScanCtDef *attach_scan_ctdef = static_cast<const ObDASScanCtDef*>(attach_ctdef);
|
|
const ObDASTableLocMeta *attach_loc_meta = MY_CTDEF.attach_spec_.get_attach_loc_meta(
|
|
MY_SPEC.table_loc_id_, attach_scan_ctdef->ref_table_id_);
|
|
ObDASScanRtDef *attach_scan_rtdef = static_cast<ObDASScanRtDef*>(attach_rtdef);
|
|
if (OB_FAIL(init_das_scan_rtdef(*attach_scan_ctdef, *attach_scan_rtdef, attach_loc_meta))) {
|
|
LOG_WARN("init das scan rtdef failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::init_table_scan_rtdef()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObPhysicalPlanCtx *plan_ctx = GET_PHY_PLAN_CTX(ctx_);
|
|
ObSQLSessionInfo *my_session = GET_MY_SESSION(ctx_);
|
|
ObDASTaskFactory &das_factory = DAS_CTX(ctx_).get_das_factory();
|
|
set_cache_stat(plan_ctx->get_phy_plan()->stat_);
|
|
bool is_null_value = false;
|
|
if (OB_SUCC(ret) && NULL != MY_SPEC.limit_) {
|
|
if (OB_FAIL(calc_expr_int_value(*MY_SPEC.limit_, limit_param_.limit_, is_null_value))) {
|
|
LOG_WARN("fail get val", K(ret));
|
|
} else if (limit_param_.limit_ < 0) {
|
|
limit_param_.limit_ = 0;
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret) && NULL != MY_SPEC.offset_ && !is_null_value) {
|
|
if (OB_FAIL(calc_expr_int_value(*MY_SPEC.offset_, limit_param_.offset_, is_null_value))) {
|
|
LOG_WARN("fail get val", K(ret));
|
|
} else if (limit_param_.offset_ < 0) {
|
|
limit_param_.offset_ = 0;
|
|
} else if (is_null_value) {
|
|
limit_param_.limit_ = 0;
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
const ObDASScanCtDef &scan_ctdef = MY_CTDEF.scan_ctdef_;
|
|
ObDASScanRtDef &scan_rtdef = tsc_rtdef_.scan_rtdef_;
|
|
const ObDASTableLocMeta *loc_meta = MY_CTDEF.das_dppr_tbl_ != nullptr ?
|
|
&MY_CTDEF.das_dppr_tbl_->get_loc_meta() : nullptr;
|
|
if (OB_FAIL(init_das_scan_rtdef(scan_ctdef, scan_rtdef, loc_meta))) {
|
|
LOG_WARN("init das scan rtdef failed", K(ret));
|
|
} else if (!MY_SPEC.use_dist_das_ && !MY_SPEC.gi_above_ && !scan_rtdef.table_loc_->empty()) {
|
|
MY_INPUT.tablet_loc_ = scan_rtdef.table_loc_->get_first_tablet_loc();
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && MY_CTDEF.lookup_ctdef_ != nullptr) {
|
|
const ObDASScanCtDef &lookup_ctdef = *MY_CTDEF.lookup_ctdef_;
|
|
ObDASBaseRtDef *das_rtdef = nullptr;
|
|
if (OB_FAIL(das_factory.create_das_rtdef(DAS_OP_TABLE_SCAN, das_rtdef))) {
|
|
LOG_WARN("create das rtdef failed", K(ret));
|
|
} else {
|
|
tsc_rtdef_.lookup_rtdef_ = static_cast<ObDASScanRtDef*>(das_rtdef);
|
|
if (OB_FAIL(init_das_scan_rtdef(lookup_ctdef,
|
|
*tsc_rtdef_.lookup_rtdef_,
|
|
MY_CTDEF.lookup_loc_meta_))) {
|
|
LOG_WARN("init das scan rtdef failed", K(ret), K(lookup_ctdef));
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && MY_CTDEF.attach_spec_.attach_ctdef_ != nullptr) {
|
|
if (OB_ISNULL(tsc_rtdef_.attach_rtinfo_ = OB_NEWx(ObDASAttachRtInfo, &ctx_.get_allocator()))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate attach rtinfo failed", K(ret));
|
|
} else if (OB_FAIL(init_attach_scan_rtdef(MY_CTDEF.attach_spec_.attach_ctdef_,
|
|
tsc_rtdef_.attach_rtinfo_->attach_rtdef_))) {
|
|
LOG_WARN("init attach scan rtdef failed", K(ret));
|
|
} else if (tsc_rtdef_.attach_rtinfo_->pushdown_tasks_.empty()) {
|
|
//has no pushdown task, means all attach task can be pushdown
|
|
if (OB_FAIL(tsc_rtdef_.attach_rtinfo_->pushdown_tasks_.push_back(
|
|
tsc_rtdef_.attach_rtinfo_->attach_rtdef_))) {
|
|
LOG_WARN("store pushdown das rtdef failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
OB_INLINE int ObTableScanOp::init_das_scan_rtdef(const ObDASScanCtDef &das_ctdef,
|
|
ObDASScanRtDef &das_rtdef,
|
|
const ObDASTableLocMeta *loc_meta)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const ObTableScanCtDef &tsc_ctdef = MY_CTDEF;
|
|
bool is_lookup = (&das_ctdef == MY_CTDEF.lookup_ctdef_);
|
|
bool is_lookup_limit = MY_SPEC.is_index_back() &&
|
|
!MY_CTDEF.lookup_ctdef_->pd_expr_spec_.pushdown_filters_.empty();
|
|
ObPhysicalPlanCtx *plan_ctx = GET_PHY_PLAN_CTX(ctx_);
|
|
ObSQLSessionInfo *my_session = GET_MY_SESSION(ctx_);
|
|
ObTaskExecutorCtx &task_exec_ctx = ctx_.get_task_exec_ctx();
|
|
das_rtdef.ctdef_ = &das_ctdef;
|
|
das_rtdef.timeout_ts_ = plan_ctx->get_ps_timeout_timestamp();
|
|
das_rtdef.tx_lock_timeout_ = my_session->get_trx_lock_timeout();
|
|
das_rtdef.scan_flag_ = MY_CTDEF.scan_flags_;
|
|
LOG_DEBUG("scan flag", K(MY_CTDEF.scan_flags_));
|
|
das_rtdef.scan_flag_.is_show_seed_ = plan_ctx->get_show_seed();
|
|
if(is_foreign_check_nested_session()) {
|
|
das_rtdef.is_for_foreign_check_ = true;
|
|
if (plan_ctx->get_phy_plan()->has_for_update() && ObSQLUtils::is_iter_uncommitted_row(&ctx_)) {
|
|
das_rtdef.scan_flag_.set_iter_uncommitted_row();
|
|
}
|
|
}
|
|
if (MY_SPEC.batch_scan_flag_) {
|
|
// if tsc enable batch rescan, the output order of tsc is determined by group id
|
|
if (das_rtdef.scan_flag_.scan_order_ == ObQueryFlag::Reverse) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("Scan order is not supported in batch rescan", K(ret), K(das_rtdef.scan_flag_.scan_order_));
|
|
} else {
|
|
das_rtdef.scan_flag_.scan_order_ = ObQueryFlag::KeepOrder;
|
|
}
|
|
}
|
|
|
|
if (is_lookup) {
|
|
das_rtdef.scan_flag_.scan_order_ = ObQueryFlag::KeepOrder;
|
|
}
|
|
das_rtdef.scan_flag_.is_lookup_for_4377_ = is_lookup;
|
|
das_rtdef.need_check_output_datum_ = MY_SPEC.need_check_output_datum_;
|
|
das_rtdef.sql_mode_ = my_session->get_sql_mode();
|
|
das_rtdef.stmt_allocator_.set_alloc(&ctx_.get_allocator());
|
|
das_rtdef.scan_allocator_.set_alloc(&ctx_.get_allocator());
|
|
das_rtdef.eval_ctx_ = &get_eval_ctx();
|
|
if (nullptr != tsc_ctdef.attach_spec_.attach_ctdef_) {
|
|
// disable limit pushdown to das iter for table scan with attached pushdown ops
|
|
} else if ((is_lookup_limit && is_lookup) || (!is_lookup_limit && !is_lookup)) {
|
|
//when is_lookup_limit = true means that the limit param should pushdown to the lookup rtdef
|
|
//so is_lookup = true means that the das_rtdef is the lookup rtdef
|
|
//when is_lookup_limit = false means that the limit param should pushdown to the scan rtdef
|
|
//so is_lookup = false means that the das_rtdef is the scan rtdef
|
|
das_rtdef.limit_param_ = limit_param_;
|
|
}
|
|
das_rtdef.frozen_version_ = MY_SPEC.frozen_version_;
|
|
das_rtdef.force_refresh_lc_ = MY_SPEC.force_refresh_lc_;
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(das_rtdef.init_pd_op(ctx_, das_ctdef))) {
|
|
LOG_WARN("init pushdown storage filter failed", K(ret));
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
int64_t schema_version = task_exec_ctx.get_query_tenant_begin_schema_version();
|
|
das_rtdef.tenant_schema_version_ = schema_version;
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(tsc_ctdef.flashback_item_.set_flashback_query_info(eval_ctx_, das_rtdef))) {
|
|
LOG_WARN("failed to set flashback query snapshot version", K(ret));
|
|
} else if (share::is_oracle_mapping_real_virtual_table(MY_SPEC.ref_table_id_)
|
|
&& das_ctdef.ref_table_id_ < OB_MIN_SYS_TABLE_INDEX_ID) {
|
|
//not index scan, keep need_scn_
|
|
} else if (MY_SPEC.ref_table_id_ != das_ctdef.ref_table_id_) {
|
|
//only data table scan need to set row scn flag
|
|
das_rtdef.need_scn_ = false;
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
ObTableID table_loc_id = MY_SPEC.get_table_loc_id();
|
|
das_rtdef.table_loc_ = DAS_CTX(ctx_).get_table_loc_by_id(table_loc_id, das_ctdef.ref_table_id_);
|
|
if (OB_ISNULL(das_rtdef.table_loc_)) {
|
|
if (OB_ISNULL(loc_meta)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("get table loc by id failed", K(ret), K(table_loc_id), K(das_ctdef.ref_table_id_),
|
|
K(DAS_CTX(ctx_).get_table_loc_list()));
|
|
} else if (OB_FAIL(DAS_CTX(ctx_).extended_table_loc(*loc_meta, das_rtdef.table_loc_))) {
|
|
LOG_WARN("extended table location failed", K(ret), KPC(loc_meta));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && OB_NOT_NULL(das_rtdef.table_loc_) && OB_NOT_NULL(das_rtdef.table_loc_->loc_meta_)) {
|
|
if (das_rtdef.table_loc_->loc_meta_->select_leader_ == 0) {
|
|
das_rtdef.scan_flag_.set_is_select_follower();
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::update_output_tablet_id()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (NULL != MY_SPEC.pdml_partition_id_) {
|
|
const ObDASTabletLoc *data_tablet_loc = nullptr;
|
|
int64_t output_id = OB_INVALID_ID;
|
|
if (MY_SPEC.partition_id_calc_type_ > 0) {
|
|
// partition id for gather statistics, index scan should output index partition id
|
|
data_tablet_loc = scan_result_.get_tablet_loc();
|
|
} else if (MY_SPEC.should_scan_index()) {
|
|
data_tablet_loc = ObDASUtils::get_related_tablet_loc(*scan_result_.get_tablet_loc(), MY_SPEC.ref_table_id_);
|
|
} else {
|
|
data_tablet_loc = scan_result_.get_tablet_loc();
|
|
}
|
|
if (OB_ISNULL(data_tablet_loc)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("data tablet loc is null, value of pdml partition id will not be set", K(ret),
|
|
K(MY_SPEC.should_scan_index()), K(MY_SPEC.ref_table_id_));
|
|
} else {
|
|
if (MY_SPEC.partition_id_calc_type_ == 0) {
|
|
output_id = data_tablet_loc->tablet_id_.id();
|
|
} else if (MY_SPEC.partition_id_calc_type_ == 1) {
|
|
output_id = data_tablet_loc->first_level_part_id_ != OB_INVALID_ID ?
|
|
data_tablet_loc->first_level_part_id_ : data_tablet_loc->partition_id_;
|
|
} else if (MY_SPEC.partition_id_calc_type_ == 2) {
|
|
output_id = data_tablet_loc->partition_id_;
|
|
} else {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("get invalid partition id cacl type", K(ret));
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
} else if (is_vectorized()) {
|
|
const int64_t batch_size = MY_SPEC.max_batch_size_;
|
|
ObExpr *expr = MY_SPEC.pdml_partition_id_;
|
|
ObDatum *datums = expr->locate_datums_for_update(eval_ctx_, batch_size);
|
|
for (int64_t i = 0; i < batch_size; i++) {
|
|
datums[i].set_int(output_id);
|
|
}
|
|
expr->set_evaluated_projected(eval_ctx_);
|
|
LOG_TRACE("find the partition id expr in pdml table scan", K(ret), KPC(expr), KPC(data_tablet_loc), K(output_id));
|
|
} else {
|
|
// handle PDML partition id:
|
|
// if partition id expr in TSC output_exprs,
|
|
// set the TSC partition id to the corresponding expr frame
|
|
ObExpr *expr = MY_SPEC.pdml_partition_id_;
|
|
expr->locate_datum_for_write(eval_ctx_).set_int(output_id);
|
|
expr->set_evaluated_projected(eval_ctx_);
|
|
LOG_TRACE("find the partition id expr in pdml table scan", K(ret), KPC(data_tablet_loc), K(output_id));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::prepare_scan_range()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (!need_perform_real_batch_rescan()) {
|
|
ret = prepare_single_scan_range();
|
|
} else {
|
|
ret = prepare_batch_scan_range();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::prepare_batch_scan_range()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObPhysicalPlanCtx *plan_ctx = GET_PHY_PLAN_CTX(ctx_);
|
|
int64_t batch_size = 0;
|
|
if (OB_SUCC(ret)) {
|
|
if (!tsc_rtdef_.bnlj_params_.empty()) {
|
|
tsc_rtdef_.group_size_ = tsc_rtdef_.bnlj_params_.at(0).gr_param_->count_;
|
|
if (OB_UNLIKELY(tsc_rtdef_.group_size_ > tsc_rtdef_.max_group_size_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("The amount of data exceeds the pre allocated memory", K(ret));
|
|
}
|
|
} else {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("batch nlj params is empry", K(ret));
|
|
}
|
|
}
|
|
GroupRescanParamGuard grp_guard(tsc_rtdef_, GET_PHY_PLAN_CTX(ctx_)->get_param_store_for_update());
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < tsc_rtdef_.group_size_; ++i) {
|
|
//replace real param to param store to extract scan range
|
|
grp_guard.switch_group_rescan_param(i);
|
|
LOG_DEBUG("replace bnlj param to extract range", K(plan_ctx->get_param_store()));
|
|
if (OB_FAIL(prepare_single_scan_range(i))) {
|
|
LOG_WARN("prepare single scan range failed", K(ret));
|
|
}
|
|
}
|
|
LOG_DEBUG("after prepare batch scan range", K(MY_INPUT.key_ranges_), K(MY_INPUT.ss_key_ranges_));
|
|
return ret;
|
|
}
|
|
int ObTableScanOp::build_bnlj_params()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const GroupParamArray* group_params_above = nullptr;
|
|
if (OB_ISNULL(group_params_above = ctx_.get_das_ctx().get_group_params())) {
|
|
// do nothing
|
|
} else if (tsc_rtdef_.bnlj_params_.empty()) {
|
|
tsc_rtdef_.bnlj_params_.set_capacity(MY_CTDEF.bnlj_param_idxs_.count());
|
|
LOG_TRACE("prepare batch scan range",K(MY_CTDEF.bnlj_param_idxs_), KPC(group_params_above));
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < MY_CTDEF.bnlj_param_idxs_.count(); ++i) {
|
|
int64_t param_idx = MY_CTDEF.bnlj_param_idxs_.at(i);
|
|
uint64_t array_idx = OB_INVALID_ID;
|
|
bool exist = false;
|
|
if (OB_FAIL(ctx_.get_das_ctx().find_group_param_by_param_idx(param_idx, exist, array_idx))) {
|
|
LOG_WARN("failed to find group param by param idx", K(ret), K(i), K(param_idx));
|
|
} else if (!exist) {
|
|
// ret = OB_ERR_UNEXPECTED;
|
|
// LOG_WARN("failed to find group param", K(ret), K(exist), K(i), K(array_idx));
|
|
LOG_TRACE("bnlj params is not a array", K(i), K(param_idx));
|
|
} else {
|
|
const GroupRescanParam &group_param = group_params_above->at(array_idx);
|
|
OZ(tsc_rtdef_.bnlj_params_.push_back(GroupRescanParamInfo(param_idx, group_param.gr_param_)));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && tsc_rtdef_.bnlj_params_.empty()) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("batch param is empty in batch rescan", K(ret),
|
|
K(MY_CTDEF.bnlj_param_idxs_), KPC(group_params_above));
|
|
}
|
|
if (OB_SUCC(ret) && (OB_ISNULL(fold_iter_))) {
|
|
if (OB_FAIL(ObDASIterUtils::create_group_fold_iter(MY_CTDEF,
|
|
tsc_rtdef_,
|
|
eval_ctx_,
|
|
ctx_,
|
|
eval_infos_,
|
|
MY_SPEC,
|
|
iter_tree_,
|
|
fold_iter_))) {
|
|
LOG_WARN("failed to create group fold iter", K(ret));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::prepare_single_scan_range(int64_t group_idx)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObQueryRangeArray key_ranges;
|
|
ObQueryRangeArray ss_key_ranges;
|
|
ObPhysicalPlanCtx *plan_ctx = GET_PHY_PLAN_CTX(ctx_);
|
|
ObIAllocator &range_allocator = (table_rescan_allocator_ != nullptr ?
|
|
*table_rescan_allocator_ : ctx_.get_allocator());
|
|
bool is_same_type = true; // use for extract equal pre_query_range
|
|
if (OB_FAIL(single_equal_scan_check_type(plan_ctx->get_param_store(), is_same_type))) {
|
|
LOG_WARN("failed to check type about single equal scan", K(ret));
|
|
} else if (is_same_type && MY_CTDEF.pre_query_range_.get_is_equal_and()) {
|
|
int64_t column_count = MY_CTDEF.pre_query_range_.get_column_count();
|
|
size_t range_size = sizeof(ObNewRange) + sizeof(ObObj) * column_count * 2;
|
|
void *range_buffers = static_cast<char*>(tsc_rtdef_.range_buffers_) + tsc_rtdef_.range_buffer_idx_ * range_size;
|
|
if (tsc_rtdef_.range_buffer_idx_ < 0 || tsc_rtdef_.range_buffer_idx_ >= tsc_rtdef_.max_group_size_) {
|
|
ret = OB_ERROR_OUT_OF_RANGE;
|
|
LOG_WARN("get wrong offset of range_buffers_", K(ret));
|
|
} else if (OB_FAIL(ObSQLUtils::extract_equal_pre_query_range(
|
|
MY_CTDEF.pre_query_range_,
|
|
range_buffers,
|
|
plan_ctx->get_param_store(),
|
|
key_ranges))) {
|
|
LOG_WARN("failed to extract equal pre query ranges", K(ret));
|
|
}
|
|
} else {
|
|
if (OB_UNLIKELY(!need_extract_range())) {
|
|
// virtual table, do nothing
|
|
} else if (MY_CTDEF.pre_query_range_.is_contain_geo_filters() &&
|
|
OB_FAIL(ObSQLUtils::extract_geo_query_range(
|
|
MY_CTDEF.pre_query_range_,
|
|
range_allocator,
|
|
ctx_,
|
|
key_ranges,
|
|
MY_INPUT.mbr_filters_,
|
|
ObBasicSessionInfo::create_dtc_params(ctx_.get_my_session())))) {
|
|
LOG_WARN("failed to extract pre query ranges", K(ret));
|
|
} else if (!MY_CTDEF.pre_query_range_.is_contain_geo_filters() &&
|
|
OB_FAIL(ObSQLUtils::extract_pre_query_range(
|
|
MY_CTDEF.pre_query_range_,
|
|
range_allocator,
|
|
ctx_,
|
|
key_ranges,
|
|
ObBasicSessionInfo::create_dtc_params(ctx_.get_my_session())))) {
|
|
LOG_WARN("failed to extract pre query ranges", K(ret));
|
|
} else if (MY_CTDEF.scan_ctdef_.is_external_table_) {
|
|
uint64_t table_loc_id = MY_SPEC.get_table_loc_id();
|
|
ObDASTableLoc *tab_loc = DAS_CTX(ctx_).get_table_loc_by_id(table_loc_id, MY_CTDEF.scan_ctdef_.ref_table_id_);
|
|
ObArray<int64_t> partition_ids;
|
|
if (OB_ISNULL(tab_loc)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("table lock is null", K(ret));
|
|
} else {
|
|
for (DASTabletLocListIter iter = tab_loc->tablet_locs_begin(); OB_SUCC(ret)
|
|
&& iter != tab_loc->tablet_locs_end(); ++iter) {
|
|
ret = partition_ids.push_back((*iter)->partition_id_);
|
|
}
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
} else if (OB_FAIL(ObExternalTableUtils::prepare_single_scan_range(
|
|
ctx_.get_my_session()->get_effective_tenant_id(),
|
|
MY_CTDEF.scan_ctdef_.ref_table_id_,
|
|
partition_ids,
|
|
key_ranges,
|
|
range_allocator,
|
|
key_ranges,
|
|
tab_loc->loc_meta_->is_external_files_on_disk_))) {
|
|
LOG_WARN("failed to prepare single scan range for external table", K(ret));
|
|
}
|
|
} else if (OB_FAIL(MY_CTDEF.pre_query_range_.get_ss_tablet_ranges(range_allocator,
|
|
ctx_,
|
|
ss_key_ranges,
|
|
ObBasicSessionInfo::create_dtc_params(ctx_.get_my_session())))) {
|
|
LOG_WARN("failed to final extract index skip query range", K(ret));
|
|
}
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
} else if (!ss_key_ranges.empty()) {
|
|
// index skip scan, ranges from extract_pre_query_range/get_ss_tablet_ranges,
|
|
// prefix range and postfix range is single range
|
|
if (1 != ss_key_ranges.count() || 1 != key_ranges.count()) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected index skip scan range", K(ret), K(key_ranges), K(ss_key_ranges));
|
|
} else {
|
|
key_ranges.at(0)->table_id_ = MY_CTDEF.scan_ctdef_.ref_table_id_;
|
|
key_ranges.at(0)->group_idx_ = group_idx;
|
|
ss_key_ranges.at(0)->table_id_ = MY_CTDEF.scan_ctdef_.ref_table_id_;
|
|
ss_key_ranges.at(0)->group_idx_ = group_idx;
|
|
if (OB_FAIL(MY_INPUT.key_ranges_.push_back(*key_ranges.at(0)))
|
|
|| OB_FAIL(MY_INPUT.ss_key_ranges_.push_back(*ss_key_ranges.at(0)))) {
|
|
LOG_WARN("store key range in TSC input failed", K(ret));
|
|
}
|
|
}
|
|
} else {
|
|
ObNewRange whole_range;
|
|
ObNewRange *key_range = NULL;
|
|
whole_range.set_whole_range();
|
|
whole_range.table_id_ = MY_CTDEF.scan_ctdef_.ref_table_id_;
|
|
whole_range.group_idx_ = group_idx;
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < key_ranges.count(); ++i) {
|
|
key_range = key_ranges.at(i);
|
|
key_range->table_id_ = MY_CTDEF.scan_ctdef_.ref_table_id_;
|
|
key_range->group_idx_ = group_idx;
|
|
if (OB_FAIL(MY_INPUT.key_ranges_.push_back(*key_range))
|
|
|| OB_FAIL(MY_INPUT.ss_key_ranges_.push_back(whole_range))) {
|
|
LOG_WARN("store key range in TSC input failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && MY_SPEC.is_vt_mapping_) {
|
|
OZ(vt_result_converter_->convert_key_ranges(MY_INPUT.key_ranges_));
|
|
}
|
|
LOG_DEBUG("prepare single scan range", K(ret), K(key_ranges), K(MY_INPUT.key_ranges_),
|
|
K(MY_INPUT.ss_key_ranges_), K(spec_.id_));
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::single_equal_scan_check_type(const ParamStore ¶m_store, bool& is_same_type)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
is_same_type = true;
|
|
const ObIArray<ObQueryRange::ObEqualOff>& equal_offs =
|
|
MY_CTDEF.pre_query_range_.get_raw_equal_offs();
|
|
for (int64_t i = 0; OB_SUCC(ret) && is_same_type && i < equal_offs.count(); ++i) {
|
|
int64_t param_idx = equal_offs.at(i).param_idx_;
|
|
if (equal_offs.at(i).only_pos_) {
|
|
// do nothing
|
|
} else if (OB_UNLIKELY(param_idx < 0 || param_idx >= param_store.count())) {
|
|
ret = OB_ERROR_OUT_OF_RANGE;
|
|
LOG_WARN("out of param store", K(ret), K(param_idx), K(param_store.count()));
|
|
} else if (equal_offs.at(i).pos_type_ != param_store.at(param_idx).get_type()
|
|
&& !param_store.at(param_idx).is_null()) {
|
|
is_same_type = false;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::init_converter()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (MY_SPEC.is_vt_mapping_) {
|
|
ObSqlCtx *sql_ctx = NULL;
|
|
if (MY_SPEC.is_index_global_) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("table id is not match", K(ret), K(MY_CTDEF), K(MY_SPEC.is_index_global_));
|
|
} else if (OB_ISNULL(sql_ctx = ctx_.get_sql_ctx())
|
|
|| OB_ISNULL(sql_ctx->schema_guard_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected status: sql ctx or schema guard is null", K(ret));
|
|
} else {
|
|
if (OB_NOT_NULL(vt_result_converter_)) {
|
|
vt_result_converter_->destroy();
|
|
vt_result_converter_->~ObVirtualTableResultConverter();
|
|
vt_result_converter_ = nullptr;
|
|
}
|
|
const ObTableSchema *org_table_schema = NULL;
|
|
const AgentVtAccessMeta &agent_vt_meta = MY_SPEC.agent_vt_meta_;
|
|
void *buf = ctx_.get_allocator().alloc(sizeof(ObVirtualTableResultConverter));
|
|
if (OB_ISNULL(buf)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("allocator", K(ret));
|
|
} else if (FALSE_IT(vt_result_converter_ = new (buf) ObVirtualTableResultConverter)) {
|
|
} else if (OB_FAIL(sql_ctx->schema_guard_->get_table_schema(
|
|
MTL_ID(),
|
|
agent_vt_meta.vt_table_id_, org_table_schema))) {
|
|
LOG_WARN("get table schema failed", K(agent_vt_meta.vt_table_id_), K(ret));
|
|
} else if (OB_ISNULL(org_table_schema)) {
|
|
ret = OB_SCHEMA_ERROR;
|
|
LOG_WARN("org table schema is null", K(MTL_ID()),
|
|
K(agent_vt_meta.vt_table_id_), K(sql_ctx->schema_guard_->get_tenant_id()), K(ret));
|
|
} else if (OB_FAIL(reuse_table_rescan_allocator())) {
|
|
LOG_WARN("get table allocator failed", K(ret));
|
|
} else if (OB_FAIL(vt_result_converter_->reset_and_init(
|
|
table_rescan_allocator_,
|
|
GET_MY_SESSION(ctx_),
|
|
&agent_vt_meta.access_row_types_,
|
|
&agent_vt_meta.key_types_,
|
|
&ctx_.get_allocator(),
|
|
org_table_schema,
|
|
&agent_vt_meta.access_column_ids_,
|
|
MY_SPEC.has_tenant_id_col_,
|
|
MY_SPEC.tenant_id_col_idx_
|
|
))) {
|
|
LOG_WARN("failed to init converter", K(ret));
|
|
}
|
|
}
|
|
LOG_TRACE("debug init converter", K(ret), K(MY_CTDEF));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::inner_open()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
DASTableLocList &table_locs = ctx_.get_das_ctx().get_table_loc_list();
|
|
ObSQLSessionInfo *my_session = NULL;
|
|
cur_trace_id_ = ObCurTraceId::get();
|
|
if (OB_ISNULL(my_session = GET_MY_SESSION(ctx_))) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("fail to get my session", K(ret));
|
|
} else if (OB_FAIL(ObDASUtils::check_nested_sql_mutating(MY_SPEC.ref_table_id_, ctx_, true))) {
|
|
LOG_WARN("failed to check stmt table", K(ret), K(MY_SPEC.ref_table_id_));
|
|
} else if (OB_FAIL(init_table_scan_rtdef())) {
|
|
LOG_WARN("prepare scan param failed", K(ret));
|
|
} else if (MY_SPEC.is_vt_mapping_ && OB_FAIL(init_converter())) {
|
|
LOG_WARN("failed to init converter", K(ret));
|
|
} else {
|
|
if (MY_SPEC.report_col_checksum_) {
|
|
if (PHY_TABLE_SCAN == MY_SPEC.get_type()) {
|
|
// heap table ddl doesn't have sample scan, report checksum directly
|
|
report_checksum_ = true;
|
|
} else if (PHY_BLOCK_SAMPLE_SCAN == MY_SPEC.get_type() || PHY_ROW_SAMPLE_SCAN == MY_SPEC.get_type()) {
|
|
// normal ddl need sample scan first, report_cheksum_ will be marked as true when rescan
|
|
report_checksum_ = false;
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(init_ddl_column_checksum())) {
|
|
LOG_WARN("init ddl column checksum", K(ret));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
// here need add plan batch_size, because in vectorized execution,
|
|
// left batch may greater than OB_MAX_BULK_JOIN_ROWS
|
|
tsc_rtdef_.max_group_size_ = OB_MAX_BULK_JOIN_ROWS + MY_SPEC.plan_->get_batch_size();
|
|
if (MY_CTDEF.pre_query_range_.get_is_equal_and()) {
|
|
int64_t column_count = MY_CTDEF.pre_query_range_.get_column_count();
|
|
size_t range_size = sizeof(ObNewRange) + sizeof(ObObj) * column_count * 2;
|
|
if (!MY_SPEC.batch_scan_flag_) {
|
|
tsc_rtdef_.range_buffers_ = ctx_.get_allocator().alloc(range_size);
|
|
} else {
|
|
tsc_rtdef_.range_buffers_ = ctx_.get_allocator().alloc(tsc_rtdef_.max_group_size_ * range_size);
|
|
}
|
|
if (OB_ISNULL(tsc_rtdef_.range_buffers_)) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate memory failed", K(ret), K(range_size), K(tsc_rtdef_.range_buffers_));
|
|
} else if (!MY_SPEC.batch_scan_flag_) {
|
|
ObNewRange *key_range = new(tsc_rtdef_.range_buffers_) ObNewRange();
|
|
} else {
|
|
for (int64_t i = 0; i < tsc_rtdef_.max_group_size_; ++i) {
|
|
char *range_buffers_off = static_cast<char*>(tsc_rtdef_.range_buffers_) + i * range_size;
|
|
ObNewRange *key_range = new(range_buffers_off) ObNewRange();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// create and init iter_tree_.
|
|
const ObTableScanSpec &spec = MY_SPEC;
|
|
if (OB_SUCC(ret)) {
|
|
if (spec.should_scan_index()) {
|
|
if (spec.is_global_index_back()) {
|
|
if (OB_FAIL(ObDASIterUtils::create_global_lookup_iter_tree(MY_CTDEF,
|
|
tsc_rtdef_,
|
|
eval_ctx_,
|
|
ctx_,
|
|
eval_infos_,
|
|
spec,
|
|
can_partition_retry(),
|
|
scan_iter_,
|
|
iter_tree_))) {
|
|
LOG_WARN("failed to create global lookup iter tree", K(ret));
|
|
}
|
|
} else if (OB_FAIL(ObDASIterUtils::create_local_lookup_iter_tree(MY_CTDEF,
|
|
tsc_rtdef_,
|
|
eval_ctx_,
|
|
ctx_,
|
|
eval_infos_,
|
|
spec,
|
|
scan_iter_,
|
|
iter_tree_))) {
|
|
LOG_WARN("failed to create local lookup iter tree", K(ret));
|
|
}
|
|
} else if (OB_FAIL(ObDASIterUtils::create_table_scan_iter_tree(MY_CTDEF,
|
|
tsc_rtdef_,
|
|
eval_ctx_,
|
|
ctx_,
|
|
eval_infos_,
|
|
spec,
|
|
scan_iter_,
|
|
iter_tree_))) {
|
|
LOG_WARN("failed to create table scan iter tree", K(ret));
|
|
}
|
|
}
|
|
output_ = iter_tree_;
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::inner_close()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_NOT_NULL(scan_iter_)) {
|
|
if (scan_iter_->has_task()) {
|
|
int tmp_ret = fill_storage_feedback_info();
|
|
if (OB_UNLIKELY(OB_SUCCESS != tmp_ret)) {
|
|
LOG_WARN("fill storage feedback info failed", KR(tmp_ret));
|
|
}
|
|
}
|
|
if (OB_FAIL(scan_iter_->reuse())) {
|
|
LOG_WARN("failed to reuse scan iter", K(ret));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
fill_sql_plan_monitor_info();
|
|
}
|
|
|
|
if (OB_SUCC(ret) && MY_SPEC.should_scan_index()) {
|
|
ObSQLSessionInfo *session = GET_MY_SESSION(ctx_);
|
|
if (OB_NOT_NULL(session)) {
|
|
uint64_t tenant_id = session->get_effective_tenant_id();
|
|
uint64_t index_id = MY_CTDEF.scan_ctdef_.ref_table_id_;
|
|
oceanbase::share::ObIndexUsageInfoMgr* mgr = MTL(oceanbase::share::ObIndexUsageInfoMgr*);
|
|
if (OB_NOT_NULL(mgr)) {
|
|
mgr->update(tenant_id, index_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
iter_end_ = false;
|
|
need_init_before_get_row_ = true;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObTableScanOp::fill_sql_plan_monitor_info()
|
|
{
|
|
oceanbase::common::ObDiagnoseSessionInfo *di = oceanbase::common::ObDiagnoseSessionInfo::get_local_diagnose_info();
|
|
if (OB_LIKELY(di)) {
|
|
// Hope to demostrate:
|
|
// 1. how many bytes read from io (IO_READ_BYTES)
|
|
// 2. how many bytes in total (DATA_BLOCK_READ_CNT + INDEX_BLOCK_READ_CNT) * 16K (approximately, many diff for each table)
|
|
// 3. how many rows processed before filtering (MEMSTORE_READ_ROW_COUNT + SSSTORE_READ_ROW_COUNT)
|
|
op_monitor_info_.otherstat_1_id_ = ObSqlMonitorStatIds::IO_READ_BYTES;
|
|
op_monitor_info_.otherstat_2_id_ = ObSqlMonitorStatIds::TOTAL_READ_BYTES;
|
|
op_monitor_info_.otherstat_3_id_ = ObSqlMonitorStatIds::TOTAL_READ_ROW_COUNT;
|
|
op_monitor_info_.otherstat_1_value_ = EVENT_GET(ObStatEventIds::IO_READ_BYTES, di);
|
|
// NOTE: this is not always accurate, as block size change be change from default 16K to any value
|
|
op_monitor_info_.otherstat_2_value_ = (EVENT_GET(ObStatEventIds::DATA_BLOCK_READ_CNT, di) + EVENT_GET(ObStatEventIds::INDEX_BLOCK_READ_CNT, di)) * 16 * 1024;
|
|
op_monitor_info_.otherstat_3_value_ = EVENT_GET(ObStatEventIds::MEMSTORE_READ_ROW_COUNT, di) + EVENT_GET(ObStatEventIds::SSSTORE_READ_ROW_COUNT, di);
|
|
}
|
|
}
|
|
|
|
int ObTableScanOp::do_init_before_get_row()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (need_init_before_get_row_) {
|
|
LOG_DEBUG("do init before get row", K(MY_SPEC.id_), K(MY_SPEC.use_dist_das_), K(MY_SPEC.gi_above_));
|
|
if (OB_UNLIKELY(iter_end_)) {
|
|
LOG_DEBUG("do init before get row meet iter end", K(MY_SPEC.id_));
|
|
} else {
|
|
if (MY_SPEC.gi_above_) {
|
|
ObGranuleTaskInfo info;
|
|
if (OB_FAIL(get_access_tablet_loc(info))) {
|
|
LOG_WARN("fail to get access partition failed", K(ret));
|
|
} else if (OB_FAIL(reassign_task_ranges(info))) {
|
|
LOG_WARN("assign task ranges failed", K(ret));
|
|
}
|
|
}
|
|
if (OB_FAIL(ret) || OB_UNLIKELY(iter_end_)) {
|
|
// do nothing
|
|
} else if (OB_FAIL(prepare_all_das_tasks())) {
|
|
LOG_WARN("prepare das task failed", K(ret));
|
|
} else if (OB_FAIL(do_table_scan())) {
|
|
if (OB_TRY_LOCK_ROW_CONFLICT != ret) {
|
|
LOG_WARN("fail to do table scan", K(ret));
|
|
}
|
|
} else {
|
|
if (in_batch_rescan_subplan()) {
|
|
// if the ancestor operator of TSC support batch rescan, update the group_id and batch rescan_cnt after perform a real-rescan
|
|
group_rescan_cnt_ = ctx_.get_das_ctx().get_group_rescan_cnt();
|
|
group_id_ = ctx_.get_das_ctx().get_skip_scan_group_id();
|
|
}
|
|
if (OB_FAIL(output_->set_merge_status(is_group_rescan() ? SORT_MERGE : SEQUENTIAL_MERGE))) {
|
|
LOG_WARN("failed to set merge status for das iter", K(ret));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObTableScanOp::destroy()
|
|
{
|
|
tsc_rtdef_.~ObTableScanRtDef();
|
|
ObOperator::destroy();
|
|
if (OB_NOT_NULL(vt_result_converter_)) {
|
|
vt_result_converter_->destroy();
|
|
vt_result_converter_->~ObVirtualTableResultConverter();
|
|
vt_result_converter_ = nullptr;
|
|
}
|
|
if (OB_NOT_NULL(iter_tree_)) {
|
|
iter_tree_->release();
|
|
iter_tree_ = nullptr;
|
|
}
|
|
if (OB_NOT_NULL(fold_iter_)) {
|
|
fold_iter_->release();
|
|
fold_iter_ = nullptr;
|
|
}
|
|
output_ = nullptr;
|
|
scan_iter_ = nullptr;
|
|
}
|
|
|
|
int ObTableScanOp::fill_storage_feedback_info()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
// fill storage feedback info for acs
|
|
ObDASScanOp *scan_op = DAS_SCAN_OP(*scan_iter_->begin_task_iter());
|
|
if (OB_ISNULL(scan_op)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected nullptr das scan op", K(ret));
|
|
} else {
|
|
ObTableScanParam &scan_param = scan_op->get_scan_param();
|
|
bool is_index_back = scan_param.scan_flag_.index_back_;
|
|
ObTableScanStat &table_scan_stat = GET_PHY_PLAN_CTX(ctx_)->get_table_scan_stat();
|
|
if (MY_SPEC.should_scan_index()) {
|
|
table_scan_stat.query_range_row_count_ = scan_param.idx_table_scan_stat_.access_row_cnt_;
|
|
if (is_index_back) {
|
|
table_scan_stat.indexback_row_count_ = scan_param.idx_table_scan_stat_.out_row_cnt_;
|
|
table_scan_stat.output_row_count_ = scan_param.main_table_scan_stat_.out_row_cnt_;
|
|
} else {
|
|
table_scan_stat.indexback_row_count_ = -1;
|
|
table_scan_stat.output_row_count_ = scan_param.idx_table_scan_stat_.out_row_cnt_;
|
|
}
|
|
LOG_DEBUG("index scan feedback info for acs",
|
|
K(scan_param.idx_table_scan_stat_), K(table_scan_stat));
|
|
} else {
|
|
table_scan_stat.query_range_row_count_ = scan_param.main_table_scan_stat_.access_row_cnt_;
|
|
table_scan_stat.indexback_row_count_ = -1;
|
|
table_scan_stat.output_row_count_ = scan_param.main_table_scan_stat_.out_row_cnt_;
|
|
LOG_DEBUG("table scan feedback info for acs", K(scan_param.main_table_scan_stat_), K(table_scan_stat));
|
|
}
|
|
|
|
// 填充计划淘汰策略所需要的反馈信息
|
|
ObIArray<ObTableRowCount> &table_row_count_list =
|
|
GET_PHY_PLAN_CTX(ctx_)->get_table_row_count_list();
|
|
//仅索引回表时，存储层会将执行扫描索引数据放在idx_table_scan_stat_中;
|
|
//对于仅扫描主表或索引表的情况, 存储层会将执行扫描索引数据放在main_table_scan_stat_中
|
|
if (!got_feedback_) {
|
|
got_feedback_ = true;
|
|
if (MY_SPEC.should_scan_index() && scan_param.scan_flag_.is_index_back()) {
|
|
if (scan_param.scan_flag_.is_need_feedback()) {
|
|
int tmp_ret = OB_SUCCESS;
|
|
if (OB_SUCCESS != (tmp_ret = table_row_count_list.push_back(ObTableRowCount(
|
|
MY_SPEC.id_, scan_param.idx_table_scan_stat_.access_row_cnt_)))) {
|
|
// 这里忽略插入失败时的错误码. OB的Array保证push_back失败的情况下count()仍是有效的
|
|
// 如果一张表的信息没有被插入成功，最多
|
|
// 只会导致后续判断计划能否淘汰时无法使用这张表的信息进行判断，从而
|
|
// 导致某些计划无法被淘汰，相当于回退到了没有这部分淘汰策略时的逻辑
|
|
// 这里不希望淘汰机制的错误码影响原有执行逻辑 @ banliu.zyd
|
|
LOG_WARN("push back table_id-row_count failed", K(tmp_ret), K(MY_SPEC.ref_table_id_),
|
|
"access row count", scan_param.idx_table_scan_stat_.access_row_cnt_);
|
|
}
|
|
}
|
|
} else {
|
|
if (scan_param.scan_flag_.is_need_feedback()) {
|
|
int tmp_ret = OB_SUCCESS;
|
|
if (OB_SUCCESS != (tmp_ret = table_row_count_list.push_back(ObTableRowCount(
|
|
MY_SPEC.id_, scan_param.main_table_scan_stat_.access_row_cnt_)))) {
|
|
LOG_WARN("push back table_id-row_count failed but we won't stop execution", K(tmp_ret));
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
LOG_DEBUG("table scan feed back info for buffer table",
|
|
K(MY_CTDEF.scan_ctdef_.ref_table_id_), K(MY_SPEC.should_scan_index()),
|
|
"is_need_feedback", scan_param.scan_flag_.is_need_feedback(),
|
|
"idx access row count", scan_param.idx_table_scan_stat_.access_row_cnt_,
|
|
"main access row count", scan_param.main_table_scan_stat_.access_row_cnt_);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::inner_rescan()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
in_rescan_ = true;
|
|
if (OB_FAIL(ObOperator::inner_rescan())) {
|
|
LOG_WARN("failed to exec inner rescan");
|
|
} else {
|
|
if (OB_FAIL(inner_rescan_for_tsc())) {
|
|
LOG_WARN("failed to get next row",K(ret));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
int ObTableScanOp::inner_rescan_for_tsc()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
input_row_cnt_ = 0;
|
|
output_row_cnt_ = 0;
|
|
iter_end_ = false;
|
|
MY_INPUT.key_ranges_.reuse();
|
|
MY_INPUT.ss_key_ranges_.reuse();
|
|
MY_INPUT.mbr_filters_.reuse();
|
|
bool need_real_rescan = false;
|
|
if (OB_FAIL(build_bnlj_params())) {
|
|
// At start of each round of batch rescan, NLJ will fill param_store with
|
|
// batch parameters. After each right operator rescan, NLJ will fill
|
|
// param_store with current rescan's parameters.
|
|
// Therefore, we need to get and save bnlj parameters here or they will be
|
|
// replaced by NLJ.
|
|
LOG_WARN("build batch nlj params failed", KR(ret));
|
|
} else if (OB_FAIL(check_need_real_rescan(need_real_rescan))) {
|
|
LOG_WARN("failed to check if tsc need real rescan", K(ret));
|
|
} else if (!need_real_rescan) {
|
|
LOG_TRACE("[group rescan] need switch iter", K(group_rescan_cnt_), K(ctx_.get_das_ctx().get_group_rescan_cnt()),
|
|
K(group_id_), K(ctx_.get_das_ctx().get_skip_scan_group_id()), K(spec_.id_));
|
|
if (OB_FAIL(set_batch_iter(ctx_.get_das_ctx().get_skip_scan_group_id()))) {
|
|
LOG_WARN("failed to switch batch iter", K(ret), K(ctx_.get_das_ctx().get_skip_scan_group_id()));
|
|
}
|
|
group_id_ = ctx_.get_das_ctx().get_skip_scan_group_id();
|
|
} else {
|
|
reset_iter_tree_for_rescan();
|
|
LOG_TRACE("[group rescan] need perform real rescan", K(group_rescan_cnt_), K(ctx_.get_das_ctx().get_group_rescan_cnt()),
|
|
K(group_id_), K(ctx_.get_das_ctx().get_skip_scan_group_id()), K(spec_.id_));
|
|
if (is_virtual_table(MY_SPEC.ref_table_id_)
|
|
|| (OB_NOT_NULL(scan_iter_) && !scan_iter_->is_all_local_task())
|
|
|| (MY_SPEC.use_dist_das_ && nullptr != MY_CTDEF.das_dppr_tbl_)) {
|
|
ret = close_and_reopen();
|
|
} else {
|
|
ret = local_iter_rescan();
|
|
}
|
|
if (OB_SUCC(ret) && need_perform_real_batch_rescan()) {
|
|
LOG_TRACE("[group rescan] need perform real batch rescan");
|
|
fold_iter_->init_group_range(0, tsc_rtdef_.bnlj_params_.at(0).gr_param_->count_);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::close_and_reopen()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
iter_end_ = false;
|
|
if (OB_ISNULL(scan_iter_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected nullptr scan iter", K(ret));
|
|
} else if (OB_FAIL(inner_close())) {
|
|
LOG_WARN("fail to close op", K(ret));
|
|
} else if (OB_FAIL(reuse_table_rescan_allocator())) {
|
|
LOG_WARN("reuse table rescan allocator failed", K(ret));
|
|
} else {
|
|
need_final_limit_ = false;
|
|
//in order to avoid memory expansion caused by repeatedly creating DAS Tasks,
|
|
//stmt allocator uses DAS allocator in the reopen process
|
|
tsc_rtdef_.scan_rtdef_.stmt_allocator_.set_alloc(scan_iter_->get_das_alloc());
|
|
tsc_rtdef_.scan_rtdef_.scan_allocator_.set_alloc(table_rescan_allocator_);
|
|
MY_INPUT.key_ranges_.reuse();
|
|
MY_INPUT.ss_key_ranges_.reuse();
|
|
MY_INPUT.mbr_filters_.reuse();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::local_iter_rescan()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObGranuleTaskInfo info;
|
|
if (OB_ISNULL(scan_iter_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected nullptr scan iter", K(ret));
|
|
} else if (OB_FAIL(get_access_tablet_loc(info))) {
|
|
LOG_WARN("fail to get access partition", K(ret));
|
|
} else if (OB_FAIL(local_iter_reuse())) {
|
|
LOG_WARN("failed to reset query range", K(ret));
|
|
} else if (OB_FAIL(reassign_task_ranges(info))) {
|
|
LOG_WARN("assign task ranges failed", K(ret));
|
|
} else if (OB_UNLIKELY(iter_end_)) {
|
|
//do nothing
|
|
} else if (MY_INPUT.key_ranges_.empty() &&
|
|
OB_FAIL(prepare_scan_range())) { // prepare scan input param
|
|
LOG_WARN("fail to prepare scan param", K(ret));
|
|
} else {
|
|
DASTaskIter task_iter = scan_iter_->begin_task_iter();
|
|
for (; OB_SUCC(ret) && !task_iter.is_end(); ++task_iter) {
|
|
ObDASScanOp *scan_op = DAS_SCAN_OP(*task_iter);
|
|
if (OB_ISNULL(scan_op)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected nullptr das scan op", K(ret));
|
|
} else if (MY_SPEC.gi_above_) {
|
|
if (!MY_SPEC.is_index_global_ && MY_CTDEF.lookup_ctdef_ != nullptr) {
|
|
//is local index lookup, need to set the lookup ctdef to the das scan op
|
|
if (OB_FAIL(pushdown_normal_lookup_to_das(*scan_op))) {
|
|
LOG_WARN("pushdown normal lookup to das failed", K(ret));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && MY_CTDEF.attach_spec_.attach_ctdef_ != nullptr) {
|
|
if (OB_FAIL(pushdown_attach_task_to_das(*scan_op))) {
|
|
LOG_WARN("pushdown attach task to das failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(cherry_pick_range_by_tablet_id(scan_op))) {
|
|
LOG_WARN("prune query range by partition id failed", K(ret));
|
|
} else if (OB_FAIL(scan_iter_->rescan_das_task(scan_op))) {
|
|
LOG_WARN("rescan das task failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
if (in_batch_rescan_subplan()) {
|
|
// if the ancestor operator of TSC support batch rescan, update the group_id and batch rescan_cnt after perform a real-rescan
|
|
group_rescan_cnt_ = ctx_.get_das_ctx().get_group_rescan_cnt();
|
|
group_id_ = ctx_.get_das_ctx().get_skip_scan_group_id();
|
|
}
|
|
if (OB_FAIL(output_->set_merge_status(is_group_rescan() ? SORT_MERGE : SEQUENTIAL_MERGE))) {
|
|
LOG_WARN("failed to set merge status for das iter", K(ret));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* the following three functions are used for blocked nested loop join
|
|
*/
|
|
int ObTableScanOp::local_iter_reuse()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
for (DASTaskIter task_iter = scan_iter_->begin_task_iter();
|
|
!task_iter.is_end(); ++task_iter) {
|
|
ObDASScanOp *scan_op = DAS_SCAN_OP(*task_iter);
|
|
if (OB_ISNULL(scan_op)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected nullptr das scan op", K(ret));
|
|
} else {
|
|
bool need_switch_param = (scan_op->get_tablet_loc() != MY_INPUT.tablet_loc_ &&
|
|
MY_INPUT.tablet_loc_ != nullptr);
|
|
if (MY_INPUT.tablet_loc_ != nullptr) {
|
|
scan_op->set_tablet_id(MY_INPUT.tablet_loc_->tablet_id_);
|
|
scan_op->set_ls_id(MY_INPUT.tablet_loc_->ls_id_);
|
|
scan_op->set_tablet_loc(MY_INPUT.tablet_loc_);
|
|
}
|
|
scan_op->reuse_iter();
|
|
}
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
} else if (OB_FAIL(reuse_table_rescan_allocator())) {
|
|
LOG_WARN("get table allocator", K(ret));
|
|
} else {
|
|
tsc_rtdef_.scan_rtdef_.scan_allocator_.set_alloc(table_rescan_allocator_);
|
|
MY_INPUT.key_ranges_.reuse();
|
|
MY_INPUT.ss_key_ranges_.reuse();
|
|
MY_INPUT.mbr_filters_.reuse();
|
|
}
|
|
return ret;
|
|
}
|
|
//TSC has its own switch iterator && bnl switch iterator
|
|
int ObTableScanOp::switch_iterator()
|
|
{
|
|
return OB_NOT_SUPPORTED;
|
|
}
|
|
|
|
int ObTableScanOp::check_need_real_rescan(bool &bret)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
bret = false;
|
|
const GroupParamArray* group_params_above = nullptr;
|
|
bool enable_group_rescan_test_mode = false;
|
|
enable_group_rescan_test_mode = (OB_SUCCESS != (OB_E(EventTable::EN_DAS_GROUP_RESCAN_TEST_MODE) OB_SUCCESS));
|
|
if (OB_ISNULL(group_params_above = ctx_.get_das_ctx().get_group_params())) {
|
|
bret = true;
|
|
} else if (tsc_rtdef_.bnlj_params_.empty()) {
|
|
//batch rescan not init, need to do real rescan
|
|
bret = true;
|
|
} else {
|
|
// the above operator of tsc support batch group rescan
|
|
if (group_rescan_cnt_ < ctx_.get_das_ctx().get_group_rescan_cnt()) {
|
|
// need perform batch rescan, the output of tsc is changed to fold_iter_
|
|
if (ctx_.get_das_ctx().get_skip_scan_group_id() > 0) {
|
|
output_ = iter_tree_;
|
|
LOG_TRACE("[group rescan] skip read is found");
|
|
} else {
|
|
output_ = fold_iter_;
|
|
}
|
|
bret = true;
|
|
} else if (group_rescan_cnt_ == ctx_.get_das_ctx().get_group_rescan_cnt()) {
|
|
if (group_id_ < ctx_.get_das_ctx().get_skip_scan_group_id()) {
|
|
if (output_ == fold_iter_) {
|
|
bret = false;
|
|
} else {
|
|
bret = true;
|
|
}
|
|
} else if (group_id_ == ctx_.get_das_ctx().get_skip_scan_group_id()) {
|
|
// the sql paln like this:
|
|
// spf
|
|
// / \
|
|
// tsc_1 px_partition_iterator
|
|
// \
|
|
// tsc_2
|
|
// if enable spf batch rescan in this paln, the rescan of tsc will called by px_partition_iterator, which need perform a real rescan
|
|
bret = true;
|
|
output_ = iter_tree_;
|
|
LOG_TRACE("[group rescan] gi rescan is supportted in batch rescan");
|
|
} else {
|
|
if (enable_group_rescan_test_mode) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("the group id of tsc exceeds the group id of above operator",
|
|
K(ret), K(group_rescan_cnt_), K(group_id_), K(ctx_.get_das_ctx().get_skip_scan_group_id()));
|
|
} else {
|
|
bret = true;
|
|
output_ = iter_tree_;
|
|
LOG_TRACE("[group rescan] found unexpected group id", K(group_rescan_cnt_), K(group_id_), K(ctx_.get_das_ctx().get_skip_scan_group_id()));
|
|
}
|
|
}
|
|
} else {
|
|
if (enable_group_rescan_test_mode) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("the batch rescan count of tsc exceeds the batch count of above operator",
|
|
K(ret), K(group_rescan_cnt_), K(ctx_.get_das_ctx().get_group_rescan_cnt()));
|
|
|
|
} else {
|
|
bret = true;
|
|
output_ = iter_tree_;
|
|
LOG_TRACE("[group rescan] found unexpected group rescan cnt", K(group_rescan_cnt_), K(ctx_.get_das_ctx().get_group_rescan_cnt()));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObTableScanOp::reset_iter_tree_for_rescan()
|
|
{
|
|
if (OB_NOT_NULL(fold_iter_)) {
|
|
fold_iter_->reuse();
|
|
}
|
|
if (iter_tree_->get_type() == DAS_ITER_LOOKUP) {
|
|
iter_tree_->reuse();
|
|
}
|
|
}
|
|
|
|
int ObTableScanOp::set_batch_iter(int64_t group_id)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (!is_group_rescan()) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("switch group with a null fold_iter", K(ret));
|
|
} else {
|
|
ret = fold_iter_->set_scan_group(group_id);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
|
|
int ObTableScanOp::get_next_row_with_das()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
bool got_row = false;
|
|
lib::CompatModeGuard g(MY_SPEC.is_vt_mapping_ ? lib::Worker::CompatMode::MYSQL : lib::get_compat_mode());
|
|
//it means multi-partition limit pushed down in DAS TSC
|
|
//need to calc final limit row
|
|
if (need_final_limit_ && limit_param_.limit_ > 0 && output_row_cnt_ >= limit_param_.limit_) {
|
|
ret = OB_ITER_END;
|
|
LOG_DEBUG("get next row with das iter end", K(ret), K_(limit_param), K_(output_row_cnt));
|
|
}
|
|
while (OB_SUCC(ret) && !got_row) {
|
|
clear_evaluated_flag();
|
|
if (OB_FAIL(output_->get_next_row())) {
|
|
if (OB_ITER_END == ret) {
|
|
// do nothing.
|
|
} else {
|
|
LOG_WARN("get next row from das result failed", K(ret));
|
|
}
|
|
} else {
|
|
// We need do filter first before do the limit.
|
|
// See the issue 47201028.
|
|
bool filtered = false;
|
|
if (need_final_limit_ && !MY_SPEC.filters_.empty()) {
|
|
if (OB_FAIL(filter_row(filtered))) {
|
|
LOG_WARN("das get_next_row filter row failed", K(ret));
|
|
} else {
|
|
if(filtered) {
|
|
//Do nothing
|
|
} else {
|
|
++input_row_cnt_;
|
|
}
|
|
}
|
|
} else {
|
|
++input_row_cnt_;
|
|
}
|
|
if (need_final_limit_ && input_row_cnt_ <= limit_param_.offset_) {
|
|
continue;
|
|
} else {
|
|
if (need_final_limit_ && !MY_SPEC.filters_.empty() && filtered) {
|
|
//Do nothing
|
|
} else {
|
|
++output_row_cnt_;
|
|
got_row = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::get_next_batch_with_das(int64_t &count, int64_t capacity)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
int64_t batch_size = capacity;
|
|
//it means multi-partition limit pushed down in DAS TSC
|
|
//need to calc final limit row
|
|
lib::CompatModeGuard g(MY_SPEC.is_vt_mapping_ ? lib::Worker::CompatMode::MYSQL : lib::get_compat_mode());
|
|
while (OB_SUCC(ret) && need_final_limit_ && input_row_cnt_ < limit_param_.offset_) {
|
|
if (input_row_cnt_ + batch_size > limit_param_.offset_) {
|
|
// adjust iterating count for last batch
|
|
batch_size = limit_param_.offset_ - input_row_cnt_;
|
|
}
|
|
clear_evaluated_flag();
|
|
// ObNewIterIterator::get_next_rows() may return rows too when got OB_ITER_END.
|
|
// It's hard to use, we split it into two calls here since get_next_rows() is reentrant
|
|
// when got OB_ITER_END.
|
|
ret = output_->get_next_rows(count, batch_size);
|
|
if (OB_ITER_END == ret && count > 0) {
|
|
ret = OB_SUCCESS;
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
if (OB_ITER_END != ret) {
|
|
LOG_WARN("get next batch from das result failed", K(ret));
|
|
}
|
|
} else {
|
|
// We need do filter first before do the limit.
|
|
// See the issue 47201028.
|
|
if (!MY_SPEC.filters_.empty() && count > 0) {
|
|
bool all_filtered = false;
|
|
if (OB_FAIL(filter_rows(MY_SPEC.filters_,
|
|
*brs_.skip_,
|
|
count,
|
|
all_filtered,
|
|
brs_.all_rows_active_))) {
|
|
LOG_WARN("filter batch failed in das get_next_batch", K(ret));
|
|
} else if (all_filtered) {
|
|
//Do nothing.
|
|
brs_.skip_->reset(count);
|
|
} else {
|
|
int64_t skipped_rows_count = brs_.skip_->accumulate_bit_cnt(count);
|
|
input_row_cnt_ += count - skipped_rows_count;
|
|
brs_.skip_->reset(count);
|
|
}
|
|
} else {
|
|
input_row_cnt_ += count;
|
|
}
|
|
}
|
|
} // while end
|
|
|
|
if (OB_SUCC(ret) && need_final_limit_) {
|
|
batch_size = capacity;
|
|
count = 0;
|
|
if (output_row_cnt_ >= limit_param_.limit_) {
|
|
ret = OB_ITER_END;
|
|
LOG_DEBUG("get next row with das iter end", K(ret), K_(limit_param), K_(output_row_cnt));
|
|
} else if (output_row_cnt_ + batch_size > limit_param_.limit_) {
|
|
batch_size = limit_param_.limit_ - output_row_cnt_;
|
|
}
|
|
}
|
|
bool got_batch = false;
|
|
while (OB_SUCC(ret) && !got_batch) {
|
|
clear_evaluated_flag();
|
|
// ObNewIterIterator::get_next_rows() may return rows too when got OB_ITER_END.
|
|
// It's hard to use, we split it into two calls here since get_next_rows() is reentrant
|
|
// when got OB_ITER_END.
|
|
ret = output_->get_next_rows(count, batch_size);
|
|
brs_.all_rows_active_ = true;
|
|
if (OB_ITER_END == ret && count > 0) {
|
|
ret = OB_SUCCESS;
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
if (OB_ITER_END != ret) {
|
|
LOG_WARN("get next batch from das result failed", K(ret));
|
|
}
|
|
} else {
|
|
// We need do filter first before do the limit.
|
|
// See the issue 47201028.
|
|
if (need_final_limit_ && !MY_SPEC.filters_.empty() && count > 0) {
|
|
bool all_filtered = false;
|
|
if (OB_FAIL(filter_rows(MY_SPEC.filters_,
|
|
*brs_.skip_,
|
|
count,
|
|
all_filtered,
|
|
brs_.all_rows_active_))) {
|
|
LOG_WARN("filter batch failed in das get_next_batch", K(ret));
|
|
} else if (all_filtered) {
|
|
//Do nothing.
|
|
brs_.skip_->reset(count);
|
|
} else {
|
|
int64_t skipped_rows_count = brs_.skip_->accumulate_bit_cnt(count);
|
|
got_batch = true;
|
|
output_row_cnt_ += (count - skipped_rows_count);
|
|
input_row_cnt_ += (count - skipped_rows_count);
|
|
}
|
|
} else {
|
|
got_batch = true;
|
|
output_row_cnt_ += count;
|
|
input_row_cnt_ += count;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::inner_get_next_row_implement()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_FAIL(inner_get_next_row_for_tsc())) {
|
|
if (OB_ITER_END != ret) {
|
|
LOG_WARN("failed to get next row", K(ret));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
int ObTableScanOp::inner_get_next_row_for_tsc()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_UNLIKELY(0 == limit_param_.limit_)) {
|
|
// 涉及的partition个数为0或者limit 0，直接返回iter end
|
|
ret = OB_ITER_END;
|
|
} else if (OB_FAIL(do_init_before_get_row())) {
|
|
LOG_WARN("failed to init before get row", K(ret));
|
|
} else if (iter_end_) {
|
|
// 保证没有数据的时候多次调用都能返回OB_ITER_END，或者空scan直接返回iter end
|
|
ret = OB_ITER_END;
|
|
LOG_DEBUG("inner get next row meet a iter end", K(MY_SPEC.id_), K(this), K(lbt()));
|
|
} else if (0 == (++iterated_rows_ % CHECK_STATUS_ROWS_INTERVAL)
|
|
&& OB_FAIL(ctx_.check_status())) {
|
|
LOG_WARN("check physical plan status failed", K(ret));
|
|
} else if (OB_FAIL(get_next_row_with_das())) {
|
|
if (OB_ITER_END != ret) {
|
|
LOG_WARN("fail to get next row from ObNewRowIterator", K(ret));
|
|
} else {
|
|
//set found_rows:当返回总行数不为0,且带有非0offset，才需要设置found_rows的值,
|
|
//来修正最终设置到session内部的found_rows
|
|
if (MY_SPEC.is_top_table_scan_ && limit_param_.offset_ > 0) {
|
|
if (output_row_cnt_ > 0) {
|
|
int64_t total_count = output_row_cnt_ + limit_param_.offset_;
|
|
ObPhysicalPlanCtx *plan_ctx = GET_PHY_PLAN_CTX(ctx_);
|
|
NG_TRACE_EXT(found_rows, OB_ID(total_count), total_count,
|
|
OB_ID(offset), limit_param_.offset_);
|
|
plan_ctx->set_found_rows(total_count);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
NG_TRACE_TIMES_WITH_TRACE_ID(1, cur_trace_id_, get_row);
|
|
if (MY_SPEC.is_vt_mapping_
|
|
&& OB_FAIL(vt_result_converter_->convert_output_row(eval_ctx_,
|
|
MY_CTDEF.get_das_output_exprs(),
|
|
MY_SPEC.agent_vt_meta_.access_exprs_))) {
|
|
LOG_WARN("failed to convert output row", K(ret));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
const ExprFixedArray &storage_output = MY_CTDEF.get_das_output_exprs();
|
|
if (!MY_SPEC.is_global_index_back()) {
|
|
LOG_DEBUG("storage output row", "row", ROWEXPR2STR(eval_ctx_, storage_output), K(MY_CTDEF.scan_ctdef_.ref_table_id_));
|
|
}
|
|
if (OB_FAIL(add_ddl_column_checksum())) {
|
|
LOG_WARN("add ddl column checksum failed", K(ret));
|
|
}
|
|
}
|
|
if (OB_UNLIKELY(OB_ITER_END == ret && OB_NOT_NULL(scan_iter_) && scan_iter_->has_task())) {
|
|
// ObIPartitionGroup *partition = NULL;
|
|
// ObIPartitionGroupGuard *guard = NULL;
|
|
// if (OB_ISNULL(guard)) {
|
|
// } else if (OB_ISNULL(partition = guard->get_partition_group())) {
|
|
// } else if (DAS_SCAN_OP->get_scan_param().main_table_scan_stat_.bf_access_cnt_ > 0) {
|
|
// partition->feedback_scan_access_stat(DAS_SCAN_OP->get_scan_param());
|
|
// }
|
|
ObDASScanOp *scan_op = DAS_SCAN_OP(*scan_iter_->begin_task_iter());
|
|
if (OB_ISNULL(scan_op)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected nullptr das scan op", K(ret));
|
|
} else {
|
|
ObTableScanParam &scan_param = scan_op->get_scan_param();
|
|
ObTableScanStat &table_scan_stat = GET_PHY_PLAN_CTX(ctx_)->get_table_scan_stat();
|
|
fill_table_scan_stat(scan_param.main_table_scan_stat_, table_scan_stat);
|
|
if (MY_SPEC.should_scan_index() && scan_param.scan_flag_.index_back_) {
|
|
fill_table_scan_stat(scan_param.idx_table_scan_stat_, table_scan_stat);
|
|
}
|
|
scan_param.main_table_scan_stat_.reset_cache_stat();
|
|
scan_param.idx_table_scan_stat_.reset_cache_stat();
|
|
iter_end_ = true;
|
|
if (OB_FAIL(report_ddl_column_checksum())) {
|
|
LOG_WARN("report checksum failed", K(ret));
|
|
} else {
|
|
ret = OB_ITER_END;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::inner_get_next_batch(const int64_t max_row_cnt)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
int tmp_ret = OB_E(EventTable::EN_ENABLE_RANDOM_TSC) OB_SUCCESS;
|
|
bool enable_random_output = (tmp_ret != OB_SUCCESS);
|
|
|
|
int64_t rand_row_cnt = max_row_cnt;
|
|
int64_t rand_append_bits = 0;
|
|
if (enable_random_output && max_row_cnt > 1) {
|
|
gen_rand_size_and_skip_bits(max_row_cnt, rand_row_cnt, rand_append_bits);
|
|
}
|
|
if (OB_FAIL(inner_get_next_batch_for_tsc(rand_row_cnt))) {
|
|
LOG_WARN("failed to get next batch", K(ret));
|
|
}
|
|
|
|
if (OB_SUCC(ret) && enable_random_output && !brs_.end_
|
|
&& brs_.skip_->accumulate_bit_cnt(brs_.size_) == 0) {
|
|
if (OB_UNLIKELY(brs_.size_ > max_row_cnt || rand_append_bits + brs_.size_ > max_row_cnt)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_ERROR("unexpected tsc output rows", K(brs_), K(rand_append_bits), K(max_row_cnt),
|
|
K(rand_row_cnt));
|
|
} else {
|
|
adjust_rand_output_brs(rand_append_bits);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::inner_get_next_batch_for_tsc(const int64_t max_row_cnt)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
clear_evaluated_flag();
|
|
int64_t batch_size = min(max_row_cnt, MY_SPEC.max_batch_size_);
|
|
if (OB_UNLIKELY(0 == limit_param_.limit_)) {
|
|
// 涉及的partition个数为0或者limit 0，直接返回iter end
|
|
brs_.size_ = 0;
|
|
brs_.end_ = true;
|
|
} else if (OB_FAIL(do_init_before_get_row())) {
|
|
LOG_WARN("failed to init before get row", K(ret));
|
|
} else if (iter_end_) {
|
|
// 保证没有数据的时候多次调用都能返回OB_ITER_END，或者空scan直接返回iter end
|
|
brs_.size_ = 0;
|
|
brs_.end_ = true;
|
|
LOG_DEBUG("inner get next row meet a iter end", K(MY_SPEC.id_), K(this), K(lbt()));
|
|
} else {
|
|
access_expr_sanity_check();
|
|
ObEvalCtx::BatchInfoScopeGuard batch_info_guard(eval_ctx_);
|
|
batch_info_guard.set_batch_idx(0);
|
|
batch_info_guard.set_batch_size(batch_size);
|
|
brs_.size_ = 0;
|
|
brs_.end_ = false;
|
|
if (0 == batch_size) {
|
|
brs_.end_ = true;
|
|
} else if (OB_FAIL(get_next_batch_with_das(brs_.size_, batch_size))) {
|
|
if (OB_ITER_END != ret) {
|
|
LOG_WARN("get next batch with mode failed", K(ret));
|
|
} else {
|
|
ret = OB_SUCCESS;
|
|
brs_.end_ = true;
|
|
}
|
|
}
|
|
access_expr_sanity_check();
|
|
// TODO bin.lb: for calc_exprs_ set ObEvalInfo::cnt_ to brs_.batch_size_ if evaluated
|
|
}
|
|
|
|
if (OB_SUCC(ret) && brs_.end_) {
|
|
//set found_rows:当返回总行数不为0,且带有非0offset，才需要设置found_rows的值,
|
|
//来修正最终设置到session内部的found_rows
|
|
iter_end_ = true;
|
|
if (MY_SPEC.is_top_table_scan_
|
|
&& (limit_param_.offset_ > 0)) {
|
|
if (output_row_cnt_ > 0) {
|
|
int64_t total_count = output_row_cnt_ + limit_param_.offset_;
|
|
ObPhysicalPlanCtx *plan_ctx = GET_PHY_PLAN_CTX(ctx_);
|
|
NG_TRACE_EXT(found_rows, OB_ID(total_count), total_count,
|
|
OB_ID(offset), limit_param_.offset_);
|
|
plan_ctx->set_found_rows(total_count);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
const ExprFixedArray &storage_output = MY_CTDEF.get_das_output_exprs();
|
|
if (!MY_SPEC.is_global_index_back()) {
|
|
ObEvalCtx::BatchInfoScopeGuard guard(eval_ctx_);
|
|
guard.set_batch_size(brs_.size_);
|
|
PRINT_VECTORIZED_ROWS(SQL, DEBUG, eval_ctx_, storage_output, brs_.size_, brs_.skip_,
|
|
K(MY_CTDEF.scan_ctdef_.ref_table_id_));
|
|
}
|
|
if (OB_FAIL(add_ddl_column_checksum_batch(brs_.size_))) {
|
|
LOG_WARN("add ddl column checksum failed", K(ret));
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret) && brs_.end_ && OB_NOT_NULL(scan_iter_) && scan_iter_->has_task()) {
|
|
// ObIPartitionGroup *partition = NULL;
|
|
// ObIPartitionGroupGuard *guard = NULL;
|
|
// if (OB_ISNULL(guard)) {
|
|
// } else if (OB_ISNULL(partition = guard->get_partition_group())) {
|
|
// } else if (DAS_SCAN_OP->get_scan_param().main_table_scan_stat_.bf_access_cnt_ > 0) {
|
|
// partition->feedback_scan_access_stat(DAS_SCAN_OP->get_scan_param());
|
|
// }
|
|
ObTableScanParam &scan_param = DAS_SCAN_OP(*scan_iter_->begin_task_iter())->get_scan_param();
|
|
ObTableScanStat &table_scan_stat = GET_PHY_PLAN_CTX(ctx_)->get_table_scan_stat();
|
|
fill_table_scan_stat(scan_param.main_table_scan_stat_, table_scan_stat);
|
|
if (MY_SPEC.should_scan_index() && scan_param.scan_flag_.index_back_) {
|
|
fill_table_scan_stat(scan_param.idx_table_scan_stat_, table_scan_stat);
|
|
}
|
|
scan_param.main_table_scan_stat_.reset_cache_stat();
|
|
scan_param.idx_table_scan_stat_.reset_cache_stat();
|
|
if (OB_FAIL(report_ddl_column_checksum())) {
|
|
LOG_WARN("report checksum failed", K(ret));
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::calc_expr_int_value(const ObExpr &expr, int64_t &retval, bool &is_null_value)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
is_null_value = false;
|
|
OB_ASSERT(ob_is_int_tc(expr.datum_meta_.type_));
|
|
ObDatum *datum = NULL;
|
|
if (OB_FAIL(expr.eval(eval_ctx_, datum))) {
|
|
LOG_WARN("expr evaluate failed", K(ret));
|
|
} else if (datum->null_) {
|
|
is_null_value = true;
|
|
retval = 0;
|
|
} else {
|
|
retval = *datum->int_;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
OB_INLINE int ObTableScanOp::do_table_scan()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
need_init_before_get_row_ = false;
|
|
lib::CompatModeGuard g(MY_SPEC.is_vt_mapping_ ? lib::Worker::CompatMode::MYSQL : lib::get_compat_mode());
|
|
if (OB_ISNULL(scan_iter_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected nullptr scan iter", K(ret));
|
|
} else if (scan_iter_->has_task()) {
|
|
//execute with das
|
|
LOG_DEBUG("do table scan with DAS", K(MY_SPEC.ref_table_id_), K(MY_SPEC.table_loc_id_));
|
|
if (OB_FAIL(prepare_pushdown_limit_param())) {
|
|
LOG_WARN("prepare pushdow limit param failed", K(ret));
|
|
} else if (OB_FAIL(scan_iter_->do_table_scan())) {
|
|
LOG_WARN("execute all das scan task failed", K(ret));
|
|
}
|
|
} else {
|
|
iter_end_ = true;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::cherry_pick_range_by_tablet_id(ObDASScanOp *scan_op)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObIArray<ObNewRange> &scan_ranges = scan_op->get_scan_param().key_ranges_;
|
|
ObIArray<ObNewRange> &ss_ranges = scan_op->get_scan_param().ss_key_ranges_;
|
|
ObIArray<ObSpatialMBR> &mbr_filters = scan_op->get_scan_param().mbr_filters_;
|
|
const ObIArray<ObNewRange> &input_ranges = MY_INPUT.key_ranges_;
|
|
const ObIArray<ObNewRange> &input_ss_ranges = MY_INPUT.ss_key_ranges_;
|
|
const ObIArray<ObSpatialMBR> &input_filters = MY_INPUT.mbr_filters_;
|
|
bool add_all = false;
|
|
bool prune_all = true;
|
|
if (!MY_SPEC.is_vt_mapping_ && OB_UNLIKELY(input_ranges.count() != input_ss_ranges.count())) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("ranges and skip scan postfix ranges mismatch", K(ret), K(input_ranges.count()),
|
|
K(input_ss_ranges.count()));
|
|
} else if (ObPartitionLevel::PARTITION_LEVEL_MAX == MY_SPEC.part_level_
|
|
|| ObPartitionLevel::PARTITION_LEVEL_ZERO == MY_SPEC.part_level_
|
|
|| (input_ranges.count() <= 1)) {
|
|
add_all = true;
|
|
} else if (MY_SPEC.part_range_pos_.count() == 0 ||
|
|
(ObPartitionLevel::PARTITION_LEVEL_TWO == MY_SPEC.part_level_
|
|
&& MY_SPEC.subpart_range_pos_.count() == 0)) {
|
|
add_all = true;
|
|
}
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < input_ranges.count(); ++i) {
|
|
clear_evaluated_flag();
|
|
bool can_prune = false;
|
|
if (!add_all && OB_FAIL(can_prune_by_tablet_id(scan_op->get_tablet_id(), input_ranges.at(i), can_prune))) {
|
|
LOG_WARN("failed to check whether can prune by tablet id", K(ret));
|
|
} else if (add_all || !can_prune) {
|
|
prune_all = false;
|
|
if (OB_FAIL(scan_ranges.push_back(input_ranges.at(i)))) {
|
|
LOG_WARN("store input range to scan param failed", K(ret));
|
|
} else if (OB_FAIL(ss_ranges.push_back(input_ss_ranges.at(i)))) {
|
|
LOG_WARN("store input skip scan range to scan param failed", K(ret));
|
|
} else if (!input_ranges.at(i).is_physical_rowid_range_) {
|
|
//do nothing
|
|
} else if (OB_UNLIKELY(MY_SPEC.get_columns_desc().count() < 1)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("get unexpected error", K(ret));
|
|
} else {
|
|
ObIAllocator &range_allocator = (table_rescan_allocator_ != nullptr ?
|
|
*table_rescan_allocator_ : ctx_.get_allocator());
|
|
ObNewRange &scan_range = scan_ranges.at(scan_ranges.count() - 1);
|
|
ObArrayWrap<ObColDesc> rowkey_descs(&MY_SPEC.get_columns_desc().at(0),
|
|
MY_SPEC.get_rowkey_cnt());
|
|
if (OB_FAIL(transform_physical_rowid(range_allocator,
|
|
scan_op->get_tablet_id(),
|
|
rowkey_descs,
|
|
scan_range))) {
|
|
LOG_WARN("transform physical rowid for range failed", K(ret), K(scan_range));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < input_filters.count(); ++i) {
|
|
if (OB_FAIL(mbr_filters.push_back(input_filters.at(i)))) {
|
|
LOG_WARN("store mbr_filters failed", K(ret));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && prune_all && !input_ranges.empty()) {
|
|
ObNewRange false_range;
|
|
ObNewRange whole_range;
|
|
false_range.set_false_range();
|
|
false_range.group_idx_ = input_ranges.at(0).group_idx_;
|
|
whole_range.set_whole_range();
|
|
if (OB_FAIL(scan_ranges.push_back(false_range))) {
|
|
LOG_WARN("store false range to scan ranges failed", K(ret));
|
|
} else if (OB_FAIL(ss_ranges.push_back(whole_range))) {
|
|
LOG_WARN("store whole range to skip scan ranges failed", K(ret));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
LOG_DEBUG("range after pruning", K(input_ranges), K(scan_ranges), K_(tsc_rtdef_.group_size),
|
|
"tablet_id", scan_op->get_tablet_id(),
|
|
K(input_ss_ranges), K(ss_ranges));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::can_prune_by_tablet_id(const ObTabletID &tablet_id,
|
|
const ObNewRange &scan_range,
|
|
bool &can_prune)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObArenaAllocator allocator;
|
|
ObNewRange partition_range;
|
|
ObNewRange subpartition_range;
|
|
ObDASTabletMapper tablet_mapper;
|
|
can_prune = true;
|
|
if (MY_SPEC.is_vt_mapping_) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("virtual table is not partition table", K(ret));
|
|
} else if (scan_range.is_physical_rowid_range_) {
|
|
//scan range with physical rowid range does not support pruning range by tablet_id
|
|
can_prune = false;
|
|
} else if (OB_FAIL(DAS_CTX(ctx_).get_das_tablet_mapper(MY_CTDEF.scan_ctdef_.ref_table_id_, tablet_mapper))) {
|
|
LOG_WARN("get das tablet mapper failed", K(ret), K(MY_CTDEF.scan_ctdef_.ref_table_id_));
|
|
} else if (OB_FAIL(construct_partition_range(
|
|
allocator, MY_SPEC.part_type_, MY_SPEC.part_range_pos_,
|
|
scan_range, MY_SPEC.part_expr_, MY_SPEC.part_dep_cols_,
|
|
can_prune, partition_range))) {
|
|
LOG_WARN("failed to construct partition range", K(ret));
|
|
} else if (can_prune && OB_FAIL(construct_partition_range(
|
|
allocator, MY_SPEC.subpart_type_, MY_SPEC.subpart_range_pos_,
|
|
scan_range, MY_SPEC.subpart_expr_, MY_SPEC.subpart_dep_cols_,
|
|
can_prune, subpartition_range))) {
|
|
LOG_WARN("failed to construct subpartition range", K(ret));
|
|
} else if (can_prune) {
|
|
ObSEArray<ObObjectID, 4> partition_ids;
|
|
ObSEArray<ObObjectID, 4> subpartition_ids;
|
|
ObSEArray<ObTabletID, 4> tablet_ids;
|
|
if (OB_FAIL(tablet_mapper.get_tablet_and_object_id(ObPartitionLevel::PARTITION_LEVEL_ONE,
|
|
OB_INVALID_INDEX,
|
|
partition_range,
|
|
tablet_ids,
|
|
partition_ids))) {
|
|
LOG_WARN("failed to get partition ids", K(ret));
|
|
} else if (partition_ids.count() == 0) {
|
|
/*do nothing*/
|
|
} else if (partition_ids.count() != 1) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("should have only one partition id", K(partition_ids), K(partition_range), K(ret));
|
|
} else if (ObPartitionLevel::PARTITION_LEVEL_ONE == MY_SPEC.part_level_) {
|
|
if (tablet_ids.at(0) == tablet_id) {
|
|
can_prune = false;
|
|
}
|
|
} else if (OB_FAIL(tablet_mapper.get_tablet_and_object_id(ObPartitionLevel::PARTITION_LEVEL_TWO,
|
|
partition_ids.at(0),
|
|
subpartition_range,
|
|
tablet_ids,
|
|
subpartition_ids))) {
|
|
LOG_WARN("failed to get subpartition ids", K(subpartition_range), K(ret));
|
|
} else if (subpartition_ids.count() == 0) {
|
|
/*do nothing*/
|
|
} else if (subpartition_ids.count() != 1) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("should have only one partition id", K(ret));
|
|
} else if (tablet_ids.at(0) == tablet_id) {
|
|
can_prune = false;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::construct_partition_range(ObArenaAllocator &allocator,
|
|
const ObPartitionFuncType part_type,
|
|
const ObIArray<int64_t> &part_range_pos,
|
|
const ObNewRange &scan_range,
|
|
const ObExpr *part_expr,
|
|
const ExprFixedArray &part_dep_cols,
|
|
bool &can_prune,
|
|
ObNewRange &part_range)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObEvalCtx::BatchInfoScopeGuard batch_info_guard(eval_ctx_);
|
|
if (is_vectorized()) {
|
|
// batch_size_ is needed for batch result expression evaluation.
|
|
batch_info_guard.set_batch_size(1);
|
|
batch_info_guard.set_batch_idx(0);
|
|
}
|
|
if (OB_ISNULL(scan_range.start_key_.get_obj_ptr()) || OB_ISNULL(scan_range.end_key_.get_obj_ptr())) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("null point error", K(scan_range.start_key_.get_obj_ptr()),
|
|
K(scan_range.end_key_.get_obj_ptr()), K(ret));
|
|
} else if (OB_UNLIKELY(scan_range.start_key_.is_min_row())
|
|
|| OB_UNLIKELY(scan_range.start_key_.is_max_row())
|
|
|| OB_UNLIKELY(scan_range.end_key_.is_min_row())
|
|
|| OB_UNLIKELY(scan_range.end_key_.is_max_row())) {
|
|
//the range contain min value or max value can not be pruned
|
|
can_prune = false;
|
|
} else if (OB_UNLIKELY(scan_range.start_key_.get_obj_cnt() != scan_range.end_key_.get_obj_cnt())) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("should have the same range key count", K(scan_range.start_key_.get_obj_cnt()),
|
|
K(scan_range.end_key_.get_obj_cnt()), K(ret));
|
|
} else if (part_range_pos.count() > 0) {
|
|
int64_t range_key_count = part_range_pos.count();
|
|
ObObj *start_row_key = NULL;
|
|
ObObj *end_row_key = NULL;
|
|
ObObj *function_obj = NULL;
|
|
if (OB_ISNULL(start_row_key = static_cast<ObObj*>(allocator.alloc(sizeof(ObObj) * range_key_count)))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate memory for start_obj failed", K(ret));
|
|
} else if (OB_ISNULL(end_row_key = static_cast<ObObj*>(allocator.alloc(sizeof(ObObj) * range_key_count)))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate memory for end_obj failed", K(ret));
|
|
} else if (OB_ISNULL(function_obj = static_cast<ObObj*>(allocator.alloc(sizeof(ObObj))))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate memory for function obj failed", K(ret));
|
|
} else {
|
|
for (int64_t i = 0; OB_SUCC(ret) && can_prune && i < range_key_count; i++) {
|
|
int64_t pos = part_range_pos.at(i);
|
|
if (OB_UNLIKELY(pos < 0) || OB_UNLIKELY(pos >= scan_range.start_key_.get_obj_cnt())) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("invalid array pos", K(pos), K(scan_range.start_key_.get_obj_cnt()), K(ret));
|
|
} else if (scan_range.start_key_.get_obj_ptr()[pos].is_max_value() ||
|
|
scan_range.start_key_.get_obj_ptr()[pos].is_min_value() ||
|
|
scan_range.end_key_.get_obj_ptr()[pos].is_max_value() ||
|
|
scan_range.end_key_.get_obj_ptr()[pos].is_min_value()) {
|
|
can_prune = false;
|
|
} else if (scan_range.start_key_.get_obj_ptr()[pos] != scan_range.end_key_.get_obj_ptr()[pos]) {
|
|
can_prune = false;
|
|
} else {
|
|
start_row_key[i] = scan_range.start_key_.get_obj_ptr()[pos];
|
|
end_row_key[i] = scan_range.end_key_.get_obj_ptr()[pos];
|
|
sql::ObExpr *expr = part_dep_cols.at(i);
|
|
sql::ObDatum &datum = expr->locate_datum_for_write(eval_ctx_);
|
|
if (get_spec().use_rich_format_) {
|
|
expr->init_vector_for_write(eval_ctx_, VEC_UNIFORM, 1);
|
|
}
|
|
if (OB_FAIL(datum.from_obj(start_row_key[i], expr->obj_datum_map_))) {
|
|
LOG_WARN("convert obj to datum failed", K(ret));
|
|
} else if (is_lob_storage(start_row_key[i].get_type()) &&
|
|
OB_FAIL(ob_adjust_lob_datum(start_row_key[i], expr->obj_meta_, expr->obj_datum_map_,
|
|
get_exec_ctx().get_allocator(), datum))) {
|
|
LOG_WARN("adjust lob datum failed", K(ret), K(i),
|
|
K(start_row_key[i].get_meta()), K(expr->obj_meta_));
|
|
}else {
|
|
expr->set_evaluated_projected(eval_ctx_);
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && can_prune) {
|
|
if (OB_FAIL(ObSQLUtils::get_partition_range(start_row_key,
|
|
end_row_key,
|
|
function_obj,
|
|
part_type,
|
|
part_expr,
|
|
range_key_count,
|
|
scan_range.table_id_,
|
|
eval_ctx_,
|
|
part_range,
|
|
allocator))) {
|
|
LOG_WARN("get partition real range failed", K(ret));
|
|
}
|
|
LOG_DEBUG("part range info", K(part_range), K(can_prune), K(ret));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::reassign_task_ranges(ObGranuleTaskInfo &info)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (MY_SPEC.gi_above_ && !iter_end_) {
|
|
if (OB_UNLIKELY(MY_SPEC.get_query_range().is_contain_geo_filters())) {
|
|
MY_INPUT.key_ranges_.reuse();
|
|
MY_INPUT.ss_key_ranges_.reuse();
|
|
MY_INPUT.mbr_filters_.reuse();
|
|
} else if (!MY_INPUT.get_need_extract_query_range()) {
|
|
if (OB_FAIL(MY_INPUT.key_ranges_.assign(info.ranges_)) ||
|
|
OB_FAIL(MY_INPUT.ss_key_ranges_.assign(info.ss_ranges_))) {
|
|
LOG_WARN("assign the range info failed", K(ret), K(info));
|
|
} else if (MY_SPEC.is_vt_mapping_) {
|
|
if (OB_FAIL(vt_result_converter_->convert_key_ranges(MY_INPUT.key_ranges_))) {
|
|
LOG_WARN("convert key ranges failed", K(ret));
|
|
}
|
|
}
|
|
} else {
|
|
// use prepare() to set key ranges if px do not extract query range
|
|
MY_INPUT.key_ranges_.reuse();
|
|
MY_INPUT.ss_key_ranges_.reuse();
|
|
MY_INPUT.mbr_filters_.reuse();
|
|
LOG_DEBUG("do prepare!!!");
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::get_access_tablet_loc(ObGranuleTaskInfo &info)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (MY_SPEC.gi_above_) {
|
|
GIPrepareTaskMap *gi_prepare_map = nullptr;
|
|
if (OB_FAIL(ctx_.get_gi_task_map(gi_prepare_map))) {
|
|
LOG_WARN("Failed to get gi task map", K(ret));
|
|
} else if (OB_FAIL(gi_prepare_map->get_refactored(MY_SPEC.id_, info))) {
|
|
if (ret != OB_HASH_NOT_EXIST) {
|
|
LOG_WARN("failed to get prepare gi task", K(ret), K(MY_SPEC.id_));
|
|
} else {
|
|
// OB_HASH_NOT_EXIST mean no more task for tsc.
|
|
LOG_DEBUG("no prepared task info, set table scan to end",
|
|
K(MY_SPEC.id_), K(this), K(lbt()));
|
|
iter_end_ = true;
|
|
ret = OB_SUCCESS;
|
|
}
|
|
} else if (OB_FAIL(tsc_rtdef_.scan_rtdef_.table_loc_->get_tablet_loc_by_id(info.tablet_loc_->tablet_id_,
|
|
MY_INPUT.tablet_loc_))) {
|
|
//need use `get_tablet_loc_by_id` to find my px work thread's tablet_loc,
|
|
//because the tablet_loc in SQC maybe shared with other px work thread,
|
|
//the tablet loc maybe modify in das partition retry
|
|
//otherwise it will get a unsafe result modified by other px work thread
|
|
LOG_WARN("get tablet loc by id failed", K(ret), KPC(info.tablet_loc_), KPC(tsc_rtdef_.scan_rtdef_.table_loc_));
|
|
} else {
|
|
LOG_DEBUG("TSC consume a task", K(info), KPC(MY_INPUT.tablet_loc_), K(MY_INPUT.tablet_loc_->loc_meta_));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
OB_INLINE void ObTableScanOp::fill_table_scan_stat(const ObTableScanStatistic &statistic,
|
|
ObTableScanStat &scan_stat) const
|
|
{
|
|
scan_stat.bf_filter_cnt_ += statistic.bf_filter_cnt_;
|
|
scan_stat.bf_access_cnt_ += statistic.bf_access_cnt_;
|
|
scan_stat.fuse_row_cache_hit_cnt_ += statistic.fuse_row_cache_hit_cnt_;
|
|
scan_stat.fuse_row_cache_miss_cnt_ += statistic.fuse_row_cache_miss_cnt_;
|
|
scan_stat.row_cache_hit_cnt_ += statistic.row_cache_hit_cnt_;
|
|
scan_stat.row_cache_miss_cnt_ += statistic.row_cache_miss_cnt_;
|
|
}
|
|
|
|
void ObTableScanOp::set_cache_stat(const ObPlanStat &plan_stat)
|
|
{
|
|
const int64_t TRY_USE_CACHE_INTERVAL = 15;
|
|
ObQueryFlag &query_flag = tsc_rtdef_.scan_rtdef_.scan_flag_;
|
|
bool try_use_cache = !(plan_stat.execute_times_ & TRY_USE_CACHE_INTERVAL);
|
|
if (try_use_cache) {
|
|
query_flag.set_use_row_cache();
|
|
query_flag.set_use_bloomfilter_cache();
|
|
} else {
|
|
if (plan_stat.enable_bf_cache_) {
|
|
query_flag.set_use_bloomfilter_cache();
|
|
} else {
|
|
query_flag.set_not_use_bloomfilter_cache();
|
|
}
|
|
if (plan_stat.enable_row_cache_) {
|
|
query_flag.set_use_row_cache();
|
|
} else {
|
|
query_flag.set_not_use_row_cache();
|
|
}
|
|
}
|
|
const int64_t fuse_row_cache_access_cnt =
|
|
plan_stat.fuse_row_cache_hit_cnt_ + plan_stat.fuse_row_cache_miss_cnt_;
|
|
if (fuse_row_cache_access_cnt > ObPlanStat::CACHE_ACCESS_THRESHOLD) {
|
|
if (100.0 * static_cast<double>(plan_stat.fuse_row_cache_hit_cnt_) / static_cast<double>(fuse_row_cache_access_cnt) > 5) {
|
|
query_flag.set_use_fuse_row_cache();
|
|
} else {
|
|
query_flag.set_not_use_fuse_row_cache();
|
|
}
|
|
} else {
|
|
query_flag.set_use_fuse_row_cache();
|
|
}
|
|
}
|
|
|
|
bool ObTableScanOp::need_init_checksum()
|
|
{
|
|
return MY_SPEC.report_col_checksum_;
|
|
}
|
|
|
|
int ObTableScanOp::init_ddl_column_checksum()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (need_init_checksum()) {
|
|
column_checksum_.set_allocator(&ctx_.get_allocator());
|
|
col_need_reshape_.set_allocator(&ctx_.get_allocator());
|
|
const ObSQLSessionInfo *session = nullptr;
|
|
const ObIArray<ObColumnParam *> *cols = MY_CTDEF.scan_ctdef_.table_param_.get_read_info().get_columns();
|
|
if (OB_ISNULL(session = ctx_.get_my_session())) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("invalid session", K(ret));
|
|
} else if (OB_ISNULL(cols)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("col param array is unexpected null", K(ret),KP(cols));
|
|
} else if (MY_SPEC.output_.count() != MY_SPEC.ddl_output_cids_.count()) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid arguments", K(ret), K(MY_SPEC.output_), K(MY_CTDEF.scan_ctdef_.table_param_), K(MY_SPEC.ddl_output_cids_));
|
|
} else if (OB_FAIL(column_checksum_.init(MY_SPEC.ddl_output_cids_.count()))) {
|
|
LOG_WARN("init column checksum array failed", K(ret));
|
|
} else if (OB_FAIL(col_need_reshape_.init(MY_SPEC.ddl_output_cids_.count()))) {
|
|
LOG_WARN("init column need reshape array failed", K(ret));
|
|
} else {
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < MY_SPEC.ddl_output_cids_.count(); ++i) {
|
|
if (OB_FAIL(column_checksum_.push_back(0))) {
|
|
LOG_WARN("push back column checksum failed", K(ret));
|
|
}
|
|
}
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < MY_SPEC.ddl_output_cids_.count(); ++i) {
|
|
bool found = false;
|
|
bool need_reshape = false;
|
|
for (int64_t j = 0; OB_SUCC(ret) && !found && j < cols->count(); ++j) {
|
|
const ObColumnParam *col_param = cols->at(j);
|
|
if (OB_ISNULL(col_param)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("invalid col param", K(ret));
|
|
} else if (MY_SPEC.ddl_output_cids_.at(i) == col_param->get_column_id()) {
|
|
found = true;
|
|
if (col_param->get_meta_type().is_lob_storage()) {
|
|
need_reshape = true;
|
|
} else if (is_pad_char_to_full_length(session->get_sql_mode())) {
|
|
need_reshape = col_param->get_meta_type().is_fixed_len_char_type();
|
|
}
|
|
}
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
} else if (!found) {
|
|
// if not found, the column is virtual generated column, in this scene,
|
|
// if is_fixed_len_char_type() is true, need reshape
|
|
uint64_t VIRTUAL_GEN_FIX_LEN_TAG = 1ULL << 63;
|
|
if ((MY_SPEC.ddl_output_cids_.at(i) & VIRTUAL_GEN_FIX_LEN_TAG) >> 63) {
|
|
need_reshape = true;
|
|
} else {
|
|
need_reshape = false;
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && OB_FAIL(col_need_reshape_.push_back(need_reshape))) {
|
|
LOG_WARN("failed to push back col need reshape", K(ret));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::corrupt_obj(ObObj &obj)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
int tmp_ret = OB_E(EventTable::EN_BUILD_GLOBAL_INDEX_WITH_CORRUPTED_DATA) OB_SUCCESS;
|
|
if (OB_SUCCESS != tmp_ret && obj.is_fixed_len_char_type()) {
|
|
char *ptr = obj.get_string().ptr();
|
|
int32_t len = obj.get_string_len();
|
|
ptr[len - 1] = ' ';
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::add_ddl_column_checksum()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (report_checksum_) {
|
|
const int64_t cnt = MY_SPEC.output_.count();
|
|
if (OB_UNLIKELY(col_need_reshape_.count() != cnt)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("error unexpected, column cnt mismatch", K(ret), K(cnt), K(col_need_reshape_.count()));
|
|
}
|
|
// convert datanum to obj
|
|
ObDatum store_datum;
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < MY_SPEC.output_.count(); ++i) {
|
|
ObDatum *datum = NULL;
|
|
const ObExpr *e = MY_SPEC.output_[i];
|
|
if (OB_ISNULL(e)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("error unexpected, expr is nullptr", K(ret));
|
|
} else if (OB_FAIL(e->eval(eval_ctx_, datum))) {
|
|
LOG_WARN("evaluate expression failed", K(ret));
|
|
} else if (FALSE_IT(store_datum = *datum)) {
|
|
#ifdef ERRSIM
|
|
// TODO@hanhui: fix this errsim later
|
|
// } else if (OB_FAIL(corrupt_obj(store_datum))) {
|
|
// LOG_WARN("failed to corrupt obj", K(ret));
|
|
#endif
|
|
} else if (col_need_reshape_[i] && OB_FAIL(ObDDLUtil::reshape_ddl_column_obj(store_datum, e->obj_meta_))) {
|
|
LOG_WARN("reshape ddl column obj failed", K(ret));
|
|
} else {
|
|
column_checksum_[i] += store_datum.checksum(0);
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
LOG_DEBUG("add ddl column checksum",
|
|
K(MY_CTDEF.get_das_output_exprs()),
|
|
K(MY_CTDEF.get_full_acccess_cids()),
|
|
K(MY_SPEC.output_));
|
|
}
|
|
clear_evaluated_flag();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::add_ddl_column_checksum_batch(const int64_t row_count)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (report_checksum_) {
|
|
const int64_t cnt = MY_SPEC.output_.count();
|
|
if (OB_UNLIKELY(col_need_reshape_.count() != cnt)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("error unexpected, column cnt mismatch", K(ret), K(cnt), K(col_need_reshape_.count()));
|
|
}
|
|
|
|
ObDatum store_datum;
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < MY_SPEC.output_.count(); ++i) {
|
|
const ObExpr *e = MY_SPEC.output_[i];
|
|
if (OB_ISNULL(e)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("error unexpected, expr is nullptr", K(ret));
|
|
} else if (OB_FAIL(e->eval_batch(eval_ctx_, *brs_.skip_, brs_.size_))) {
|
|
LOG_WARN("evaluate expression failed", K(ret));
|
|
} else {
|
|
ObDatumVector datum_array = e->locate_expr_datumvector(eval_ctx_);
|
|
for (int64_t j = 0; OB_SUCC(ret) && j < row_count; j++) {
|
|
if (brs_.skip_->at(j)) {
|
|
continue;
|
|
} else if (FALSE_IT(store_datum = *datum_array.at(j))) {
|
|
#ifdef ERRSIM
|
|
// TODO@hanhui: fix this errsim later
|
|
// } else if (OB_FAIL(corrupt_obj(store_datum))) {
|
|
// LOG_WARN("failed to corrupt obj", K(ret));
|
|
#endif
|
|
} else if (col_need_reshape_[i] && OB_FAIL(ObDDLUtil::reshape_ddl_column_obj(store_datum, e->obj_meta_))) {
|
|
LOG_WARN("reshape ddl column obj failed", K(ret));
|
|
} else {
|
|
column_checksum_[i] += store_datum.checksum(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
LOG_DEBUG("add ddl column checksum",
|
|
K(MY_CTDEF.get_das_output_exprs()),
|
|
K(MY_CTDEF.get_full_acccess_cids()),
|
|
K(MY_SPEC.output_));
|
|
}
|
|
clear_evaluated_flag();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::report_ddl_column_checksum()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (report_checksum_) {
|
|
ObArray<ObDDLChecksumItem> checksum_items;
|
|
const int64_t curr_scan_task_id = scan_task_id_++;
|
|
const ObTabletID &tablet_id = MY_INPUT.tablet_loc_->tablet_id_;
|
|
const uint64_t table_id = MY_CTDEF.scan_ctdef_.ref_table_id_;
|
|
uint64_t VIRTUAL_GEN_FIXED_LEN_MASK = ~(1ULL << 63);
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < MY_SPEC.ddl_output_cids_.count(); ++i) {
|
|
ObDDLChecksumItem item;
|
|
item.execution_id_ = MY_SPEC.plan_->get_ddl_execution_id();
|
|
item.tenant_id_ = MTL_ID();
|
|
item.table_id_ = table_id;
|
|
item.tablet_id_ = tablet_id.id();
|
|
item.ddl_task_id_ = MY_SPEC.plan_->get_ddl_task_id();
|
|
item.column_id_ = MY_SPEC.ddl_output_cids_.at(i) & VIRTUAL_GEN_FIXED_LEN_MASK;
|
|
item.task_id_ = ctx_.get_px_sqc_id() << ObDDLChecksumItem::PX_SQC_ID_OFFSET | ctx_.get_px_task_id() << ObDDLChecksumItem::PX_TASK_ID_OFFSET | curr_scan_task_id;
|
|
item.checksum_ = i < column_checksum_.count() ? column_checksum_[i] : 0;
|
|
#ifdef ERRSIM
|
|
if (OB_SUCC(ret)) {
|
|
ret = OB_E(EventTable::EN_DATA_CHECKSUM_DDL_TASK) OB_SUCCESS;
|
|
// set the checksum of the second column inconsistent with the report checksum of hidden table. (report_column_checksum(ObSSTable &sstable))
|
|
if (OB_FAIL(ret) && 17 == item.column_id_) {
|
|
item.checksum_ = i;
|
|
}
|
|
}
|
|
#endif
|
|
if (OB_FAIL(checksum_items.push_back(item))) {
|
|
LOG_WARN("fail to push back item", K(ret));
|
|
}
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
LOG_INFO("report ddl checksum table scan", K(tablet_id), K(checksum_items));
|
|
uint64_t data_format_version = 0;
|
|
int64_t snapshot_version = 0;
|
|
share::ObDDLTaskStatus unused_task_status = share::ObDDLTaskStatus::PREPARE;
|
|
if (OB_FAIL(ObDDLUtil::get_data_information(MTL_ID(), MY_SPEC.plan_->get_ddl_task_id(), data_format_version, snapshot_version, unused_task_status))) {
|
|
LOG_WARN("get ddl cluster version failed", K(ret));
|
|
} else if (OB_FAIL(ObDDLChecksumOperator::update_checksum(data_format_version, checksum_items, *GCTX.sql_proxy_))) {
|
|
LOG_WARN("fail to update checksum", K(ret));
|
|
} else {
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < MY_SPEC.ddl_output_cids_.count(); ++i) {
|
|
column_checksum_[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::transform_physical_rowid(ObIAllocator &allocator,
|
|
const ObTabletID &scan_tablet_id,
|
|
const ObArrayWrap<ObColDesc> &rowkey_descs,
|
|
ObNewRange &new_range)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
bool start_is_phy_rowid = false;
|
|
bool end_is_phy_rowid = false;
|
|
ObURowIDData start_urowid_data;
|
|
ObURowIDData end_urowid_data;
|
|
LOG_TRACE("begin to transform physical rowid", K(new_range));
|
|
if (OB_FAIL(check_is_physical_rowid(allocator,
|
|
new_range.start_key_,
|
|
start_is_phy_rowid,
|
|
start_urowid_data)) ||
|
|
OB_FAIL(check_is_physical_rowid(allocator,
|
|
new_range.end_key_,
|
|
end_is_phy_rowid,
|
|
end_urowid_data))) {
|
|
LOG_WARN("failed to check is physical rowid", K(ret));
|
|
} else if (start_is_phy_rowid || end_is_phy_rowid) {
|
|
bool is_transform_end = false;
|
|
if (start_is_phy_rowid &&
|
|
OB_FAIL(transform_physical_rowid_rowkey(allocator, start_urowid_data, scan_tablet_id,
|
|
rowkey_descs, true, new_range, is_transform_end))) {
|
|
LOG_WARN("failed to transform physical rowid rowkey", K(ret));
|
|
} else if (is_transform_end) {
|
|
/*do nothing*/
|
|
} else if (end_is_phy_rowid &&
|
|
OB_FAIL(transform_physical_rowid_rowkey(allocator, end_urowid_data,
|
|
scan_tablet_id, rowkey_descs, false,
|
|
new_range, is_transform_end))) {
|
|
LOG_WARN("failed to transform physical rowid rowkey", K(ret));
|
|
} else {/*do nothing*/}
|
|
} else {/*do nothing*/}
|
|
LOG_TRACE("end to transform physical rowid", K(new_range));
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::check_is_physical_rowid(ObIAllocator &allocator,
|
|
ObRowkey &row_key,
|
|
bool &is_physical_rowid,
|
|
ObURowIDData &urowid_data)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
is_physical_rowid = false;
|
|
ObObj *obj_buf = NULL;
|
|
if (OB_UNLIKELY(!row_key.is_valid() || row_key.get_obj_cnt() <= 0)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected rowkey", K(ret), K(row_key));
|
|
} else if (row_key.is_min_row() || row_key.is_max_row() || row_key.get_obj_ptr()[0].is_null()) {
|
|
/*do nothing*/
|
|
} else if (OB_ISNULL(row_key.get_obj_ptr()) || OB_UNLIKELY(row_key.get_obj_cnt() <= 0)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(ret), K(row_key.get_obj_ptr()), K(row_key.get_obj_cnt()));
|
|
} else if (OB_UNLIKELY(!ob_is_urowid(row_key.get_obj_ptr()[0].get_type()))) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("got invalid obj type", K(row_key.get_obj_ptr()[0]));
|
|
} else if (row_key.get_obj_ptr()[0].get_urowid().is_physical_rowid()) {
|
|
is_physical_rowid = true;
|
|
urowid_data = row_key.get_obj_ptr()[0].get_urowid();
|
|
//occur logical rowid, just convert min, because the phy rowid is max than logical rowid.
|
|
} else if (OB_ISNULL(obj_buf = (ObObj *)allocator.alloc(sizeof(ObObj) * row_key.get_obj_cnt()))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("failed to allocate memory", K(ret));
|
|
} else {
|
|
for (int i = 0; i < row_key.get_obj_cnt(); i++) {
|
|
new (obj_buf + i) ObObj();
|
|
obj_buf[i].set_min_value();
|
|
}
|
|
row_key.assign(obj_buf, row_key.get_obj_cnt());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::transform_physical_rowid_rowkey(ObIAllocator &allocator,
|
|
const ObURowIDData &urowid_data,
|
|
const ObTabletID &scan_tablet_id,
|
|
const ObArrayWrap<ObColDesc> &rowkey_descs,
|
|
const bool is_start_key,
|
|
ObNewRange &new_range,
|
|
bool &is_transform_end)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
is_transform_end = false;
|
|
ObTabletID tablet_id;
|
|
ObObj *obj_buf = NULL;
|
|
const int64_t rowkey_cnt = rowkey_descs.count();
|
|
if (OB_FAIL(urowid_data.get_tablet_id_for_heap_organized_table(tablet_id))) {
|
|
LOG_WARN("failed to get tablet id for heap organized table", K(ret));
|
|
} else if (scan_tablet_id == tablet_id) {
|
|
ObSEArray<ObObj, 1> pk_vals;
|
|
if (OB_FAIL(urowid_data.get_rowkey_for_heap_organized_table(pk_vals))) {
|
|
LOG_WARN("failed to get rowkey for heap organized table", K(ret));
|
|
} else if (OB_UNLIKELY(pk_vals.count() != rowkey_cnt)) {
|
|
ret = OB_INVALID_ROWID;
|
|
LOG_WARN("invalid rowid", K(ret), K(pk_vals), K(rowkey_descs));
|
|
} else if (OB_ISNULL(obj_buf = (ObObj *)allocator.alloc(sizeof(ObObj) * rowkey_cnt))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("failed to allocate memory", K(ret), K(obj_buf));
|
|
} else {
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < rowkey_cnt; i++) {
|
|
if (!pk_vals.at(i).meta_.is_null()
|
|
&& !ObSQLUtils::is_same_type_for_compare(pk_vals.at(i).meta_,
|
|
rowkey_descs.at(i).col_type_)) {
|
|
ret = OB_INVALID_ROWID;
|
|
LOG_WARN("invalid rowid", K(ret), K(pk_vals.at(i).meta_), K(rowkey_descs.at(i).col_type_));
|
|
} else {
|
|
obj_buf[i] = pk_vals.at(i);
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (is_start_key) {
|
|
new_range.start_key_.assign(obj_buf, rowkey_cnt);
|
|
} else {
|
|
new_range.end_key_.assign(obj_buf, rowkey_cnt);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (OB_ISNULL(obj_buf = (ObObj *)allocator.alloc(sizeof(ObObj) * rowkey_cnt))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("failed to allocate memory", K(ret));
|
|
} else {
|
|
for (int i = 0; i < rowkey_cnt; i++) {
|
|
new (obj_buf + i) ObObj();
|
|
if (is_start_key) {
|
|
obj_buf[i].set_min_value();
|
|
} else {
|
|
obj_buf[i].set_max_value();
|
|
}
|
|
}
|
|
if (is_start_key) {
|
|
new_range.start_key_.assign(obj_buf, rowkey_cnt);
|
|
if (scan_tablet_id < tablet_id) {
|
|
new_range.end_key_.assign(obj_buf, rowkey_cnt);
|
|
is_transform_end = true;
|
|
}
|
|
} else {
|
|
new_range.end_key_.assign(obj_buf, rowkey_cnt);
|
|
if (scan_tablet_id > tablet_id) {
|
|
new_range.start_key_.assign(obj_buf, rowkey_cnt);
|
|
is_transform_end = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
LOG_TRACE("transform physical rowid rowkey", K(tablet_id), K(scan_tablet_id), K(new_range));
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::inner_get_next_row()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_UNLIKELY(MY_SPEC.is_spatial_ddl())) {
|
|
if (OB_FAIL(inner_get_next_spatial_index_row())) {
|
|
if (ret != OB_ITER_END) {
|
|
LOG_WARN("spatial index ddl : get next spatial index row failed", K(ret));
|
|
}
|
|
}
|
|
} else if (OB_FAIL(inner_get_next_row_implement())) {
|
|
if (ret != OB_ITER_END) {
|
|
LOG_WARN("get next row failed", K(ret));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::inner_get_next_spatial_index_row()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
bool need_ignore_null = false;
|
|
if (OB_ISNULL(spat_index_.spat_rows_)) {
|
|
if (OB_FAIL(init_spatial_index_rows())) {
|
|
LOG_WARN("init spatial row store failed", K(ret));
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
if (spat_index_.spat_row_index_ >= spat_index_.spat_rows_->count()) {
|
|
if (OB_FAIL(ObTableScanOp::inner_get_next_row_implement())) {
|
|
if (OB_ITER_END != ret) {
|
|
LOG_WARN("get next row failed", K(ret), "op", op_name());
|
|
}
|
|
} else {
|
|
spat_index_.spat_rows_->reuse();
|
|
spat_index_.spat_row_index_ = 0;
|
|
const ObExprPtrIArray &exprs = MY_SPEC.output_;
|
|
ObExpr *expr = exprs.at(3);
|
|
ObDatum *in_datum = NULL;
|
|
ObString geo_wkb;
|
|
if (OB_FAIL(expr->eval(eval_ctx_, in_datum))) {
|
|
LOG_WARN("expression evaluate failed", K(ret));
|
|
} else if (OB_FALSE_IT(geo_wkb = in_datum->get_string())) {
|
|
} else if (geo_wkb.length() > 0) {
|
|
uint32_t srid = UINT32_MAX;
|
|
omt::ObSrsCacheGuard srs_guard;
|
|
const ObSrsItem *srs_item = NULL;
|
|
const ObSrsBoundsItem *srs_bound = NULL;
|
|
ObSQLSessionInfo *my_session = GET_MY_SESSION(ctx_);
|
|
uint64_t tenant_id = my_session->get_effective_tenant_id();
|
|
ObS2Cellids cellids;
|
|
ObString mbr_val(0, static_cast<char *>(spat_index_.mbr_buffer_));
|
|
|
|
ObArenaAllocator tmp_allocator(ObModIds::OB_LOB_ACCESS_BUFFER, OB_MALLOC_NORMAL_BLOCK_SIZE, MTL_ID());
|
|
if (OB_FAIL(ObTextStringHelper::read_real_string_data(tmp_allocator, *in_datum,
|
|
expr->datum_meta_, expr->obj_meta_.has_lob_header(), geo_wkb))) {
|
|
LOG_WARN("failed to get real geo data.", K(ret));
|
|
} else if (OB_FAIL(ObGeoTypeUtil::get_srid_from_wkb(geo_wkb, srid))) {
|
|
LOG_WARN("failed to get srid", K(ret), K(geo_wkb));
|
|
} else if (srid != 0 &&
|
|
OB_FAIL(OTSRS_MGR->get_tenant_srs_guard(srs_guard))) {
|
|
LOG_WARN("failed to get srs guard", K(ret), K(tenant_id), K(srid));
|
|
} else if (srid != 0 &&
|
|
OB_FAIL(srs_guard.get_srs_item(srid, srs_item))) {
|
|
LOG_WARN("failed to get srs item", K(ret), K(tenant_id), K(srid));
|
|
} else if (((srid == 0) || !(srs_item->is_geographical_srs())) &&
|
|
OB_FAIL(OTSRS_MGR->get_srs_bounds(srid, srs_item, srs_bound))) {
|
|
LOG_WARN("failed to get srs bound", K(ret), K(srid));
|
|
} else if (OB_FAIL(ObGeoTypeUtil::get_cellid_mbr_from_geom(geo_wkb, srs_item, srs_bound,
|
|
cellids, mbr_val))) {
|
|
LOG_WARN("failed to get cellid", K(ret));
|
|
} else if (cellids.size() > SAPTIAL_INDEX_DEFAULT_ROW_COUNT) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("cellid over size", K(ret), K(cellids.size()));
|
|
} else if (OB_ISNULL(spat_index_.obj_buffer_)) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("failed to alloc memory for spatial index row cells", K(ret));
|
|
} else {
|
|
ObObj *obj_arr = reinterpret_cast<ObObj *>(spat_index_.obj_buffer_);
|
|
uint64_t obj_idx = 0;
|
|
for (uint64_t i = 0; OB_SUCC(ret) && i < cellids.size(); i++) {
|
|
obj_arr[obj_idx].set_nop_value();
|
|
obj_arr[obj_idx].set_uint64(cellids.at(i));
|
|
obj_arr[obj_idx + 1].set_nop_value();
|
|
obj_arr[obj_idx + 1].set_varchar(mbr_val);
|
|
obj_arr[obj_idx + 1].set_collation_type(CS_TYPE_BINARY);
|
|
obj_arr[obj_idx + 1].set_collation_level(CS_LEVEL_IMPLICIT);
|
|
ObNewRow row;
|
|
row.cells_ = &obj_arr[obj_idx];
|
|
row.count_ = 2;
|
|
obj_idx += 2;
|
|
if (OB_FAIL(spat_index_.spat_rows_->push_back(row))) {
|
|
LOG_WARN("failed to push back spatial index row", K(ret), K(row));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
need_ignore_null = true;
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret) && !need_ignore_null) {
|
|
ObNewRow &row = (*(spat_index_.spat_rows_))[spat_index_.spat_row_index_++];
|
|
ObObj &cellid= row.get_cell(0);
|
|
ObObj &mbr = row.get_cell(1);
|
|
if (OB_FAIL(fill_generated_cellid_mbr(cellid, mbr))) {
|
|
LOG_WARN("fill cellid mbr failed", K(ret), K(cellid), K(mbr));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::init_spatial_index_rows()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
void *buf = ctx_.get_allocator().alloc(sizeof(ObDomainIndexRow));
|
|
void *mbr_buffer = ctx_.get_allocator().alloc(OB_DEFAULT_MBR_SIZE);
|
|
void *obj_buf = ctx_.get_allocator().alloc(sizeof(ObObj) * 2 * SAPTIAL_INDEX_DEFAULT_ROW_COUNT);
|
|
if (OB_ISNULL(buf) || OB_ISNULL(mbr_buffer) || OB_ISNULL(obj_buf)) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("allocate spatial row store failed", K(ret), K(buf), K(mbr_buffer));
|
|
} else {
|
|
spat_index_.spat_rows_ = new(buf) ObDomainIndexRow();
|
|
spat_index_.mbr_buffer_ = mbr_buffer;
|
|
spat_index_.obj_buffer_ = obj_buf;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObTableScanOp::fill_generated_cellid_mbr(const ObObj &cellid, const ObObj &mbr)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const ObExprPtrIArray &exprs = MY_SPEC.output_;
|
|
if (exprs.count() < 2) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("invalid exprs count", K(ret), K(exprs.count()));
|
|
} else {
|
|
for (uint8_t i = 0; i < 2 && OB_SUCC(ret); i++) {
|
|
ObObjDatumMapType type = i == 0 ? OBJ_DATUM_8BYTE_DATA : OBJ_DATUM_STRING;
|
|
const ObObj &value = i == 0 ? cellid : mbr;
|
|
ObExpr *expr = exprs.at(i);
|
|
ObDatum *datum = &expr->locate_datum_for_write(get_eval_ctx());
|
|
ObEvalInfo *eval_info = &expr->get_eval_info(get_eval_ctx());
|
|
if (OB_FAIL(datum->from_obj(value, type))) {
|
|
LOG_WARN("fill spatial index row failed", K(ret));
|
|
} else {
|
|
eval_info->evaluated_ = true;
|
|
eval_info->projected_ = true;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObTableScanOp::gen_rand_size_and_skip_bits(const int64_t batch_size, int64_t &rand_size,
|
|
int64_t &skip_bits)
|
|
{
|
|
rand_size = batch_size;
|
|
skip_bits = 0;
|
|
if (batch_size > 1) {
|
|
std::default_random_engine rd;
|
|
rd.seed(std::random_device()());
|
|
std::uniform_int_distribution<int64_t> irand(0, batch_size/2);
|
|
skip_bits = irand(rd);
|
|
if (skip_bits <= 0) {
|
|
skip_bits = 1;
|
|
}
|
|
rand_size = batch_size - skip_bits;
|
|
LOG_TRACE("random batch size", K(rand_size), K(skip_bits));
|
|
}
|
|
}
|
|
|
|
void ObTableScanOp::adjust_rand_output_brs(const int64_t rand_append_bits)
|
|
{
|
|
LOG_TRACE("random output", K(brs_.size_), K(rand_append_bits));
|
|
int64_t output_size = brs_.size_ + rand_append_bits;
|
|
brs_.skip_->set_all(brs_.size_, output_size);
|
|
brs_.size_ = output_size;
|
|
brs_.all_rows_active_ = false;
|
|
}
|
|
|
|
} // end namespace sql
|
|
} // end namespace oceanbase
|