hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
4efdd918355d33c27d58f14f6964f10529eef9ca
oceanbase/src/sql/engine/table/ob_lookup_task_builder.cpp
oceanbase-admin cea7de1475 init push
2021-05-31 22:56:52 +08:00

554 lines
23 KiB
C++
Raw Blame History

/**
* 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 "sql/engine/table/ob_lookup_task_builder.h"
#include "sql/engine/table/ob_table_scan.h"
#include "share/partition_table/ob_partition_location.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/engine/ob_operator.h"
namespace oceanbase {
namespace sql {
int ObLookupTaskBuilder::init(const ObLookupInfo& info, const ObPhysicalPlan* my_plan, const ObJobID& ob_job_id,
ObExecContext* exec_ctx, ObPhyOperator* root_op, ObOpSpec* root_spec /*= NULL*/)
{
int ret = OB_SUCCESS;
const ObPhysicalPlanCtx* phy_plan_ctx = nullptr;
ObConsistencyLevel consistency = ObConsistencyLevel::INVALID_CONSISTENCY;
root_op_ = root_op;
root_spec_ = root_spec;
if (OB_ISNULL(exec_ctx_ = exec_ctx)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("the exec context can not be null", K(ret));
} else if (OB_ISNULL(my_plan_ = my_plan)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("the plan can not be null", K(ret));
} else if (OB_ISNULL(phy_plan_ctx = GET_PHY_PLAN_CTX(*exec_ctx))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("the plan ctx can not be null", K(ret));
} else if (ObConsistencyLevel::INVALID_CONSISTENCY == (consistency = phy_plan_ctx->get_consistency_level())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("the consistency is invalid", K(ret));
} else if ((OB_ISNULL(root_op_) && OB_ISNULL(root_spec_)) || ((OB_NOT_NULL(root_op_) && OB_NOT_NULL(root_spec_)))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KP(root_op_), KP(root_spec_), K(ret));
} else if ((NULL != root_op) && OB_FAIL(create_op_input(*exec_ctx, *root_op))) {
LOG_WARN("create op input failed", K(ret));
} else if ((NULL != root_spec) && OB_FAIL(root_spec->create_op_input(*exec_ctx))) {
LOG_WARN("create op input failed", K(ret));
} else if (OB_FAIL(lookup_info_.assign(info))) {
LOG_WARN("lookup init failed", K(ret));
} else {
ob_job_id_ = ob_job_id;
weak_read_ = (common::ObConsistencyLevel::WEAK == consistency || common::ObConsistencyLevel::FROZEN == consistency);
}
return ret;
}
int ObLookupTaskBuilder::build_lookup_tasks(
ObExecContext& ctx, ObMultiPartitionsRangesWarpper& partitions_ranges, uint64_t table_id, uint64_t ref_table_id)
{
int ret = OB_SUCCESS;
// set local task to pos at 0
ObMiniTask local_task;
ObTaskInfo* empty_task_info = NULL;
ObSQLSessionInfo* my_session = ctx.get_my_session();
// partition should be add to transaction.
ObSEArray<int64_t, OB_PARTITION_COUNT_PRE_SQL> partition_ids;
if (0 != lookup_task_list_.count() || 0 != lookup_taskinfo_list_.count()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("the mem should be clean after last execution",
K(ret),
K(lookup_task_list_.count()),
K(lookup_taskinfo_list_.count()));
} else if (OB_ISNULL(exec_ctx_) || OB_ISNULL(my_session)) {
ret = OB_NOT_INIT;
LOG_WARN("the exec context can not be null", K(ret));
} else {
if (NULL != root_op_) {
local_task.set_serialize_param(*exec_ctx_, *root_op_, *my_plan_);
} else if (NULL != root_spec_) {
local_task.set_serialize_param(exec_ctx_, root_spec_, my_plan_);
}
local_task.set_ctrl_server(exec_ctx_->get_addr());
local_task.set_runner_server(exec_ctx_->get_addr());
ObTaskID task_id;
task_id.set_ob_job_id(ob_job_id_);
task_id.set_task_id(new_task_id_++);
local_task.set_ob_task_id(task_id);
if (OB_FAIL(lookup_task_list_.push_back(local_task))) {
LOG_WARN("push back local task failed", K(ret));
} else if (OB_FAIL(lookup_taskinfo_list_.push_back(empty_task_info))) {
LOG_WARN("push back local task info failed", K(ret));
} else {
ObAddr run_server;
ObPartitionScanRanges* partition_ranges = nullptr;
// find the partition which still not in this transaction.
for (int64_t i = 0; i < partitions_ranges.count() && OB_SUCC(ret); ++i) {
// add new partition
if (OB_FAIL(partitions_ranges.get_partition_ranges_by_idx(i, partition_ranges))) {
LOG_WARN("Failed to get partition range", K(ret));
} else if (partition_ranges->partition_id_ == -1 || partition_ranges->ranges_.count() == 0) {
// do nothing
} else if (OB_FAIL(partition_ids.push_back(partition_ranges->partition_id_))) {
LOG_WARN("fail to push back to partition_ids", K(ret));
}
}
// add the partitions to transaction and location.
if (OB_SUCC(ret) && !partition_ids.empty()) {
if (OB_FAIL(ObSQLUtils::extend_checker_stmt(ctx, table_id, ref_table_id, partition_ids, weak_read_))) {
LOG_WARN("fail to extend stmt", K(ret));
}
TransResult& trans_result = my_session->get_trans_result();
ObPartitionKey pkey;
ObPartitionArray pkeys;
for (int64_t i = 0; i < partition_ids.count() && OB_SUCC(ret); ++i) {
if (OB_FAIL(pkey.init(lookup_info_.ref_table_id_, partition_ids.at(i), lookup_info_.partition_cnt_))) {
LOG_WARN("failed to init partition key", K(ret));
} else if (OB_FAIL(pkeys.push_back(pkey))) {
LOG_WARN("failed to push back", K(ret));
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(trans_result.merge_total_partitions(pkeys))) {
LOG_WARN("fail to merge partitions", K(ret), K(pkeys));
}
}
// find the partition's server.
for (int64_t i = 0; i < partitions_ranges.count() && OB_SUCC(ret); ++i) {
run_server.reset();
if (OB_FAIL(partitions_ranges.get_partition_ranges_by_idx(i, partition_ranges))) {
LOG_WARN("Failed to get partition range", K(ret));
} else if (partition_ranges->partition_id_ == -1 || partition_ranges->ranges_.count() == 0) {
LOG_DEBUG("Empty partition ranges, just skip", K(ret));
} else if (OB_FAIL(get_partition_server(partition_ranges->partition_id_, run_server))) {
LOG_WARN("failed to get partition server", K(ret));
} else if (OB_FAIL(
add_range_to_taskinfo(partition_ranges->partition_id_, partition_ranges->ranges_, run_server))) {
LOG_WARN("add ranges to task info failed", K(ret));
} else {
LOG_DEBUG("Success to add range",
K(ret),
K(partition_ranges->partition_id_),
K(partition_ranges->ranges_),
K(run_server));
}
}
}
}
return ret;
}
int ObLookupTaskBuilder::get_partition_server(int64_t part_id, ObAddr& runner_server)
{
int ret = OB_SUCCESS;
const ObPhyTableLocation* phy_location = NULL;
const share::ObPartitionReplicaLocation* part_replica = NULL;
if (OB_ISNULL(exec_ctx_)) {
ret = OB_NOT_INIT;
LOG_WARN("exec_ctx is null", K(ret));
} else if (OB_FAIL(ObTaskExecutorCtxUtil::get_phy_table_location(
*exec_ctx_, lookup_info_.table_id_, lookup_info_.ref_table_id_, phy_location))) {
LOG_WARN("get physical table location failed", K(ret));
} else if (OB_ISNULL(phy_location)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("phy table location is null", K(ret), K(lookup_info_.ref_table_id_));
} else if (OB_ISNULL(part_replica = phy_location->get_part_replic_by_part_id(part_id))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("phy part replica is null", K(ret), K(part_id));
} else {
runner_server = part_replica->get_replica_location().server_;
}
return ret;
}
int ObLookupTaskBuilder::add_range_to_taskinfo(
int64_t partition_id, ObIArray<ObNewRange>& ranges, const ObAddr& run_server)
{
int ret = OB_SUCCESS;
bool add_ranges = false;
int64_t pos = OB_INVALID_INDEX_INT64;
char* buf = NULL;
for (int64_t i = 0; i < lookup_task_list_.count() && OB_SUCC(ret); ++i) {
if (lookup_task_list_.at(i).get_runner_server() == run_server) {
if (OB_ISNULL(lookup_taskinfo_list_.at(i))) {
pos = i;
} else {
ObTaskInfo::ObPartLoc part_loc;
if (OB_FAIL(
part_loc.partition_key_.init(lookup_info_.ref_table_id_, partition_id, lookup_info_.partition_cnt_))) {
LOG_WARN("init the partition key failed", K(ret));
} else if (OB_FAIL(part_loc.scan_ranges_.assign(ranges))) {
LOG_WARN("assign ranges to loc ranges failed", K(ret));
} else if (OB_FAIL(lookup_taskinfo_list_.at(i)->get_range_location().part_locs_.push_back(part_loc))) {
LOG_WARN("push back range location failed", K(ret));
} else if (OB_FAIL(lookup_task_list_.at(i).add_partition_key(part_loc.partition_key_))) {
LOG_WARN("add pkey failed", K(ret));
}
add_ranges = true;
LOG_TRACE("Range added", K(i), K(partition_id), K(part_loc.partition_key_), K(ranges), K(run_server));
}
break;
}
}
if (OB_SUCC(ret) && (pos != LOCAL_TASK_POS && pos != OB_INVALID_INDEX_INT64)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected status", K(ret), K(pos));
}
if (OB_SUCC(ret) && !add_ranges) {
// add new task
if (pos != LOCAL_TASK_POS) {
// new remote task
ObMiniTask new_task;
new_task.set_runner_server(run_server);
new_task.set_ctrl_server(exec_ctx_->get_addr());
if (NULL != root_op_) {
new_task.set_serialize_param(*exec_ctx_, *root_op_, *my_plan_);
} else if (NULL != root_spec_) {
new_task.set_serialize_param(exec_ctx_, root_spec_, my_plan_);
}
new_task.set_location_idx(partition_id);
ObTaskID task_id;
task_id.set_ob_job_id(ob_job_id_);
task_id.set_task_id(new_task_id_++);
// task_id.set_task_id(lookup_task_list_.count());
new_task.set_ob_task_id(task_id);
common::ObPartitionKey pkey;
if (OB_FAIL(pkey.init(lookup_info_.ref_table_id_, partition_id, lookup_info_.partition_cnt_))) {
LOG_WARN("init partition key failed", K(ret));
} else if (OB_FAIL(new_task.add_partition_key(pkey))) {
LOG_WARN("push back pkey failed", K(ret));
} else if (OB_FAIL(lookup_task_list_.push_back(new_task))) {
LOG_WARN("push back new taks failed", K(ret));
} else {
LOG_TRACE(
"Remote range added", K(lookup_task_list_.count()), K(partition_id), K(pkey), K(ranges), K(run_server));
}
} else {
// local task
// pos must be 0
common::ObPartitionKey pkey;
if (OB_FAIL(pkey.init(lookup_info_.ref_table_id_, partition_id, lookup_info_.partition_cnt_))) {
LOG_WARN("init partition key failed", K(ret));
} else if (OB_FAIL(lookup_task_list_.at(LOCAL_TASK_POS).add_partition_key(pkey))) {
LOG_WARN("push back pkey failed", K(ret));
} else {
LOG_TRACE(
"Local range added", K(lookup_task_list_.count()), K(partition_id), K(pkey), K(ranges), K(run_server));
}
}
// add new task info
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_ISNULL(buf = static_cast<char*>(allocator_.alloc(sizeof(ObTaskInfo))))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate mem failed", K(ret));
} else {
ObTaskInfo* task_info = new (buf) ObTaskInfo(allocator_);
ObTaskInfo::ObPartLoc part_loc;
if (OB_FAIL(
part_loc.partition_key_.init(lookup_info_.ref_table_id_, partition_id, lookup_info_.partition_cnt_))) {
LOG_WARN("init partition key failed", K(ret));
} else if (OB_FAIL(part_loc.scan_ranges_.assign(ranges))) {
LOG_WARN("assign ranges to loc ranges failed", K(ret));
} else if (OB_FAIL(task_info->get_range_location().part_locs_.init(lookup_info_.partition_num_))) {
LOG_WARN("init fixed array failed", K(ret));
} else if (OB_FAIL(task_info->get_range_location().part_locs_.push_back(part_loc))) {
LOG_WARN("push back range location failed", K(ret));
} else if (LOCAL_TASK_POS == pos) {
lookup_taskinfo_list_.at(LOCAL_TASK_POS) = task_info;
LOG_TRACE("Local task_info added", K(lookup_task_list_.count()), K(partition_id), K(part_loc.partition_key_));
} else if (OB_FAIL(lookup_taskinfo_list_.push_back(task_info))) {
LOG_WARN("push back task info failed", K(ret));
} else {
LOG_TRACE("Remote task_info added",
K(lookup_task_list_.count()),
K(partition_id),
K(part_loc.partition_key_),
K(ranges),
K(run_server));
}
}
}
return ret;
}
void ObLookupTaskBuilder::reset()
{
for (int64_t i = 0; i < lookup_taskinfo_list_.count(); ++i) {
ObTaskInfo* task_info = lookup_taskinfo_list_.at(i);
if (OB_ISNULL(task_info)) {
// do nothing
} else {
task_info->~ObTaskInfo();
allocator_.free(task_info);
task_info = NULL;
}
}
lookup_taskinfo_list_.reset();
lookup_task_list_.reset();
lookup_info_.reset();
partitions_already_in_trans_.reset();
// ob_job_id_.reset();
// new_task_id_ = 0;
}
int ObLookupTaskBuilder::create_op_input(ObExecContext& ctx, const ObPhyOperator& root_op)
{
int ret = OB_SUCCESS;
const ObPhyOperator* child_op = NULL;
ObIPhyOperatorInput* op_input = NULL;
if (OB_FAIL(root_op.create_operator_input(ctx))) {
LOG_WARN("create operator input failed", K(ret));
} else if (OB_ISNULL(op_input = GET_PHY_OP_INPUT(ObIPhyOperatorInput, ctx, root_op.get_id()))) {
LOG_WARN("the op input can not be null", K(ret), K(root_op.get_type()));
}
for (int32_t i = 0; OB_SUCC(ret) && i < root_op.get_child_num(); ++i) {
if (OB_ISNULL(child_op = root_op.get_child(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("child op is null", K(ret));
} else if (OB_FAIL(create_op_input(ctx, *child_op))) {
LOG_WARN("fail to build child op input", K(ret), K(child_op->get_id()));
}
}
return ret;
}
int ObLookupTaskBuilder::rebuild_overflow_task(const ObMiniTaskRetryInfo& retry_info)
{
int ret = OB_SUCCESS;
const ObIArray<std::pair<int64_t, int64_t> >& task_list = retry_info.get_task_list();
ObSEArray<ObMiniTask, 16> retry_lookup_task_list;
ObSEArray<ObTaskInfo*, 16> retry_lookup_taskinfo_list;
ObMiniTask empty_minitask;
int64_t task_id = 0;
int64_t succ_range_count = 0;
if (OB_FAIL(retry_lookup_task_list.push_back(empty_minitask))) {
LOG_WARN("Failed to push back empty minitask", K(ret));
} else if (OB_FAIL(retry_lookup_taskinfo_list.push_back(nullptr))) {
LOG_WARN("Failed to push back local task info", K(ret));
}
ARRAY_FOREACH(task_list, i)
{
task_id = task_list.at(i).first;
succ_range_count = task_list.at(i).second;
// task_id == task idx
ObMiniTask& mini_task = lookup_task_list_.at(task_id);
ObTaskInfo* task_info = lookup_taskinfo_list_.at(task_id);
if (OB_ISNULL(task_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Unexpected nullptr", K(ret));
} else if (retry_info.retry_by_single_range()) {
if (OB_FAIL(rebuild_task_by_single_range(
mini_task, *task_info, retry_lookup_task_list, retry_lookup_taskinfo_list))) {
LOG_WARN("Failed to rebuild task by single range", K(ret));
}
} else if (OB_FAIL(rebuild_task_by_all_failed_ranges(
mini_task, *task_info, succ_range_count, retry_lookup_task_list, retry_lookup_taskinfo_list))) {
LOG_WARN("Failed to rebuild task by all failed ranges", K(ret));
} else {
}
if (OB_SUCC(ret) && 0 != succ_range_count) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Unexpected succ range count value, it should be zero!", K(ret), K(succ_range_count));
}
}
for (int64_t i = 0; i < lookup_taskinfo_list_.count(); ++i) {
ObTaskInfo* task_info = lookup_taskinfo_list_.at(i);
if (OB_ISNULL(task_info)) {
// do nothing
} else {
task_info->~ObTaskInfo();
allocator_.free(task_info);
task_info = NULL;
}
}
lookup_taskinfo_list_.reset();
lookup_task_list_.reset();
if (OB_SUCC(ret)) {
if (OB_FAIL(lookup_task_list_.assign(retry_lookup_task_list))) {
LOG_WARN("Failed to assign retry lookup task list", K(ret));
} else if (OB_FAIL(lookup_taskinfo_list_.assign(retry_lookup_taskinfo_list))) {
LOG_WARN("Failed to assign retry lookup taskinto list", K(ret));
}
}
LOG_TRACE("Rebuild failed task",
K(ret),
K(retry_info.retry_by_single_range()),
K(lookup_task_list_.count()),
K(lookup_taskinfo_list_.count()));
return ret;
}
int ObLookupTaskBuilder::get_new_part_ranges(const common::ObIArray<ObTaskInfo::ObPartLoc>& parts_loc,
int64_t& succ_range_count, common::ObIArray<ObTaskInfo::ObPartLoc>& new_parts_loc, ObMiniTask& new_task)
{
int ret = OB_SUCCESS;
int64_t retry_range_count = 0;
ObTaskInfo::ObPartLoc new_part_loc;
ARRAY_FOREACH(parts_loc, j)
{
if (succ_range_count > parts_loc.at(j).scan_ranges_.count()) {
succ_range_count -= parts_loc.at(j).scan_ranges_.count();
} else {
const ObTaskInfo::ObPartLoc& part_loc = parts_loc.at(j);
new_part_loc = part_loc;
new_part_loc.scan_ranges_.reuse();
retry_range_count = 0;
ARRAY_FOREACH(part_loc.scan_ranges_, m)
{
if (succ_range_count > 0) {
--succ_range_count;
} else if (OB_FAIL(new_part_loc.scan_ranges_.push_back(part_loc.scan_ranges_.at(m)))) {
LOG_WARN("Failed to push back scan range", K(ret));
} else {
++retry_range_count;
}
}
if (OB_SUCC(ret) && !new_part_loc.scan_ranges_.empty()) {
if (OB_FAIL(new_parts_loc.push_back(new_part_loc))) {
LOG_WARN("Failed to push back retry part loc", K(ret));
} else if (OB_FAIL(new_task.add_partition_key(part_loc.partition_key_))) {
LOG_WARN("Failed to add partition key", K(ret));
}
}
LOG_TRACE("Retry range",
K(part_loc.scan_ranges_.count()),
K(part_loc.partition_key_),
K(succ_range_count),
K(retry_range_count));
}
}
return ret;
}
int ObLookupTaskBuilder::rebuild_task_by_all_failed_ranges(const ObMiniTask& failed_task,
const ObTaskInfo& failed_task_info, int64_t& succ_range_count, common::ObIArray<ObMiniTask>& retry_lookup_task_list,
common::ObIArray<ObTaskInfo*>& retry_lookup_taskinfo_list)
{
int ret = OB_SUCCESS;
ObMiniTask new_task;
ObTaskInfo* task_info = nullptr;
void* buf = nullptr;
const common::ObIArray<ObTaskInfo::ObPartLoc>& parts = failed_task_info.get_range_location().part_locs_;
common::ObSEArray<ObTaskInfo::ObPartLoc, 16> new_parts;
ObTaskID task_id;
task_id.set_ob_job_id(ob_job_id_);
task_id.set_task_id(new_task_id_++);
// task_id.set_task_id(retry_lookup_task_list.count());
new_task.set_runner_server(failed_task.get_runner_server());
new_task.set_ctrl_server(exec_ctx_->get_addr());
if (NULL != root_op_) {
new_task.set_serialize_param(*exec_ctx_, *root_op_, *my_plan_);
} else if (NULL != root_spec_) {
new_task.set_serialize_param(exec_ctx_, root_spec_, my_plan_);
}
new_task.set_ob_task_id(task_id);
LOG_TRACE(
"Rebuild lookup task", K(task_id), K(succ_range_count), K(failed_task.get_partition_keys()), K(parts.count()));
if (OB_FAIL(get_new_part_ranges(parts, succ_range_count, new_parts, new_task))) {
LOG_WARN("Failed to get new parts loc", K(ret));
} else if (new_parts.empty()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("No scan ranges need retry", K(ret));
} else if (OB_ISNULL(buf = static_cast<char*>(allocator_.alloc(sizeof(ObTaskInfo))))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("Failed to allocate mem", K(ret));
} else {
task_info = new (buf) ObTaskInfo(allocator_);
if (OB_FAIL(task_info->get_range_location().part_locs_.init(lookup_info_.partition_num_))) {
LOG_WARN("Init fixed array failed", K(ret));
} else if (OB_FAIL(task_info->get_range_location().part_locs_.assign(new_parts))) {
LOG_WARN("Failed to assign range location", K(ret));
} else if (OB_FAIL(retry_lookup_task_list.push_back(new_task))) {
LOG_WARN("Failed to push back minitask", K(ret));
} else if (OB_FAIL(retry_lookup_taskinfo_list.push_back(task_info))) {
LOG_WARN("Failed to push back taskinfo", K(ret));
} else {
LOG_TRACE("Remote task_info added",
K(retry_lookup_task_list.count()),
K(retry_lookup_taskinfo_list.count()),
K(new_parts.count()));
}
}
return ret;
}
int ObLookupTaskBuilder::rebuild_task_by_single_range(const ObMiniTask& failed_task, const ObTaskInfo& failed_task_info,
common::ObIArray<ObMiniTask>& retry_lookup_task_list, common::ObIArray<ObTaskInfo*>& retry_lookup_taskinfo_list)
{
int ret = OB_SUCCESS;
const common::ObIArray<ObTaskInfo::ObPartLoc>& parts = failed_task_info.get_range_location().part_locs_;
ARRAY_FOREACH(parts, j)
{
const ObTaskInfo::ObPartLoc& part_loc = parts.at(j);
ARRAY_FOREACH(part_loc.scan_ranges_, m)
{
void* buf = nullptr;
ObMiniTask new_task;
ObTaskID task_id;
task_id.set_ob_job_id(ob_job_id_);
task_id.set_task_id(new_task_id_++);
// task_id.set_task_id(retry_lookup_task_list.count());
new_task.set_runner_server(failed_task.get_runner_server());
new_task.set_ctrl_server(exec_ctx_->get_addr());
if (NULL != root_op_) {
new_task.set_serialize_param(*exec_ctx_, *root_op_, *my_plan_);
} else if (NULL != root_spec_) {
new_task.set_serialize_param(exec_ctx_, root_spec_, my_plan_);
}
new_task.set_ob_task_id(task_id);
if (OB_ISNULL(buf = static_cast<char*>(allocator_.alloc(sizeof(ObTaskInfo))))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("Failed to allocate mem", K(ret));
} else if (OB_FAIL(new_task.add_partition_key(part_loc.partition_key_))) {
LOG_WARN("Failed to add partition key", K(ret));
} else {
ObTaskInfo* task_info = new (buf) ObTaskInfo(allocator_);
ObTaskInfo::ObPartLoc new_part_loc = part_loc;
new_part_loc.scan_ranges_.reset();
if (OB_FAIL(task_info->get_range_location().part_locs_.init(lookup_info_.partition_num_))) {
LOG_WARN("Init fixed array failed", K(ret));
} else if (OB_FAIL(new_part_loc.scan_ranges_.push_back(part_loc.scan_ranges_.at(m)))) {
LOG_WARN("Failed to push back scan range", K(ret));
} else if (OB_FAIL(task_info->get_range_location().part_locs_.push_back(new_part_loc))) {
LOG_WARN("Failed to push back range location", K(ret));
} else if (OB_FAIL(retry_lookup_task_list.push_back(new_task))) {
LOG_WARN("Failed to push back minitask", K(ret));
} else if (OB_FAIL(retry_lookup_taskinfo_list.push_back(task_info))) {
LOG_WARN("Failed to push back task", K(ret));
} else {
}
}
}
LOG_TRACE("Remote task_info added",
K(part_loc.partition_key_),
K(retry_lookup_task_list.count()),
K(retry_lookup_taskinfo_list.count()));
}
return ret;
}
} // namespace sql
} // namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink