{

int ret = OB_SUCCESS;

if (OB_FAIL(map_.create(count, ObModIds::OB_SQL_PX))) {

SQL_LOG(WARN, "Failed to create hash table", K(count));

}

return ret;

const TabletIdArray &tablet_id_array,

const DASTabletLocIArray &dst_locations, bool asc)

{

int ret = OB_SUCCESS;

void *buf = nullptr;

ObTMArray<int64_t> *base_order = nullptr;

if (OB_ISNULL(buf = reinterpret_cast<ObTMArray<int64_t> *>(

allocator_.alloc(sizeof(ObTMArray<int64_t>))))) {

ret = OB_ALLOCATE_MEMORY_FAILED;

LOG_WARN("failed to allocate memory");

} else if (FALSE_IT(base_order = new(buf) ObTMArray<int64_t>())) {

} else if (OB_FAIL(base_order->reserve(dst_locations.count()))) {

LOG_WARN("fail reserve base order", K(ret), K(dst_locations.count()));

} else if (OB_FAIL(map_.set_refactored(pwj_group_id, std::make_pair(base_order, asc)))) {

base_order->destroy();

LOG_WARN("failed to set", K(pwj_group_id));

} else {

for (int i = 0; i < dst_locations.count() && OB_SUCC(ret); ++i) {

for (int j = 0; j < tablet_id_array.count() && OB_SUCC(ret); ++j) {

if (dst_locations.at(i)->tablet_id_.id() == tablet_id_array.at(j)) {

if (OB_FAIL(base_order->push_back(j))) {

LOG_WARN("fail to push idx into base order", K(ret));

}

break;

}

}

}

}

return ret;

const TabletIdArray &tablet_id_array,

DASTabletLocIArray &dst_locations)

{

int ret = OB_SUCCESS;

std::pair<ObIArray<int64_t> *, bool> base_order;

ObIArray<int64_t> *base_order_arr = nullptr;

if (OB_FAIL(map_.get_refactored(pwj_group_id, base_order))) {

LOG_WARN("hash not found", K(pwj_group_id));

} else if (FALSE_IT(base_order_arr = base_order.first)) {

} else {

int index = 0;

for (int i = 0; i < base_order_arr->count() && OB_SUCC(ret); ++i) {

for (int j = 0; j < dst_locations.count() && OB_SUCC(ret); ++j) {

if (dst_locations.at(j)->tablet_id_.id() == tablet_id_array.at(base_order_arr->at(i))) {

std::swap(dst_locations.at(j), dst_locations.at(index++));

break;

}

}

}

}

return ret;

ObExecContext &ctx,

ObDfo &dfo)

{

int ret = OB_SUCCESS;

if (nullptr != dfo.get_root_op_spec()) {

if (OB_FAIL(alloc_by_data_distribution_inner(table_locations, ctx, dfo))) {

LOG_WARN("failed to alloc data distribution", K(ret));

}

} else {

ret = OB_INVALID_ARGUMENT;

LOG_WARN("invalid argument", K(ret));

}

return ret;

const ObIArray<ObTableLocation> *table_locations, ObDfo &dfo)

{

int ret = OB_SUCCESS;

uint64_t table_location_key = OB_INVALID_INDEX;

for (int i = 0; i < scan_ops.count() && OB_SUCC(ret); ++i) {

if (OB_ISNULL(scan_ops.at(i))) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("scan ops is null", K(ret));

} else {

table_location_key = scan_ops.at(i)->get_table_loc_id();

for (int j = 0; j < table_locations->count() && OB_SUCC(ret); ++j) {

if (table_location_key == table_locations->at(j).get_table_id()) {

ObIArray<ObPxSqcMeta> &sqcs = dfo.get_sqcs();

for (int k = 0; k < sqcs.count() && OB_SUCC(ret); ++k) {

if (OB_FAIL(sqcs.at(k).get_pruning_table_locations().push_back(table_locations->at(j)))) {

LOG_WARN("fail to push back pruning table locations", K(ret));

}

}

}

}

}

}

return ret;

ObIArray<ObExternalFileInfo> &files,

ObIArray<ObAddr> &dst_addrs)

{

int ret = OB_SUCCESS;

ObAddr pre_addr;

if (OB_SUCC(ret)) {

auto addrcmp = [](const ObExternalFileInfo &l, const ObExternalFileInfo &r) -> bool {

return l.file_addr_ < r.file_addr_;

};

lib::ob_sort(files.get_data(), files.get_data() + files.count(), addrcmp);

}

for (int64_t i = 0; OB_SUCC(ret) && i < files.count(); i++) {

ObAddr &cur_addr = files.at(i).file_addr_;

if (cur_addr != pre_addr) {

pre_addr = cur_addr;

OZ (dst_addrs.push_back(files.at(i).file_addr_));

}

}

return ret;

ObExecContext &ctx,

uint64_t table_id,

uint64_t ref_table_id,

const ObQueryRangeProvider &pre_query_range,

ObDfo &dfo,

ObDASTableLoc *&table_loc)

{

int ret = OB_SUCCESS;

ObDASTableLoc *local_loc = NULL;

uint64_t tenant_id = OB_INVALID_ID;

bool is_external_files_on_disk = false;

ObIArray<ObExternalFileInfo> &ext_file_urls = dfo.get_external_table_files();

ObSEArray<ObAddr, 16> all_locations;

ObQueryRangeArray ranges;

if (OB_ISNULL(local_loc = DAS_CTX(ctx).get_table_loc_by_id(table_id, ref_table_id))) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("fail to get table loc", K(ret), K(table_id), K(ref_table_id));

} else if (OB_ISNULL(ctx.get_my_session())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("session is null", K(ret));

} else if (OB_ISNULL(GCTX.location_service_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected null location service", K(ret));

} else {

tenant_id = ctx.get_my_session()->get_effective_tenant_id();

is_external_files_on_disk = local_loc->loc_meta_->is_external_files_on_disk_;

if (OB_FAIL(GCTX.location_service_->external_table_get(tenant_id, ref_table_id, all_locations))) {

LOG_WARN("fail to get external table location", K(ret));

}

}

if (OB_SUCC(ret) && ext_file_urls.empty()) {

// TODO EXTARNAL TABLE

// if (pre_query_range.has_exec_param() || 0 == pre_query_range.get_column_count()) {

// ret = OB_NOT_SUPPORTED;

// LOG_WARN("Has dynamic params in external table or empty range is not supported", K(ret),

// K(pre_query_range.has_exec_param()), K(pre_query_range.get_column_count()));

ObSEArray<int64_t, 16> part_ids;

for (DASTabletLocListIter iter = table_loc->tablet_locs_begin(); OB_SUCC(ret)

&& iter != table_loc->tablet_locs_end(); ++iter) {

ret = part_ids.push_back((*iter)->partition_id_);

}

OZ (ObSQLUtils::extract_pre_query_range(pre_query_range, ctx.get_allocator(), ctx, ranges,

ObBasicSessionInfo::create_dtc_params(ctx.get_my_session())));

if (is_external_object_id(ref_table_id)) {

ObSEArray<const ObTableScanSpec *, 2> scan_ops;

const ObOpSpec *root_op = NULL;

dfo.get_root(root_op);

if (OB_ISNULL(root_op)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected null ptr", K(ret));

} else if (OB_FAIL(ObTaskSpliter::find_scan_ops(scan_ops, *root_op))) {

LOG_WARN("failed to find scan_ops", K(ret), KP(root_op));

} else if (scan_ops.count() == 0) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("empty scan_ops", K(ret));

} else if (OB_FAIL(ObExternalTableFileManager::get_instance().get_mocked_external_table_files(

tenant_id, part_ids, ctx,

scan_ops.at(0)->tsc_ctdef_.scan_ctdef_,

ext_file_urls))) {

LOG_WARN("fail to get mocked external table files", K(ret));

}

} else {

OZ (ObExternalTableFileManager::get_instance().get_external_files_by_part_ids(tenant_id,

ref_table_id,

part_ids,

is_external_files_on_disk,

ctx.get_allocator(),

ext_file_urls,

ranges.empty() ? NULL : &ranges));

}

if (is_external_files_on_disk) {

OZ (ObExternalTableUtils::filter_files_in_locations(ext_file_urls, all_locations));

}

if (OB_SUCC(ret) && ext_file_urls.empty()) {

const char* dummy_file_name = "#######DUMMY_FILE#######";

ObExternalFileInfo dummy_file;

dummy_file.file_url_ = dummy_file_name;

dummy_file.file_id_ = INT64_MAX;

dummy_file.part_id_ = ref_table_id;

if (is_external_files_on_disk) {

dummy_file.file_addr_ = GCTX.self_addr();

}

OZ (dfo.get_external_table_files().push_back(dummy_file));

}

}

if (OB_SUCC(ret)

&& NULL == (table_loc = DAS_CTX(ctx).get_external_table_loc_by_id(table_id, ref_table_id))) {

//generate locations

ObSEArray<ObAddr, 16> target_locations;

if (is_external_files_on_disk) {

// locations are the collection of file's ip

if (OB_FAIL(sort_and_collect_local_file_distribution(dfo.get_external_table_files(),

target_locations))) {

LOG_WARN("fail to collect local file distribution", K(ret));

}

for (int i = 0; OB_SUCC(ret) && i < target_locations.count(); ++i) {

if (OB_UNLIKELY(ObPxCheckAlive::is_in_blacklist(

target_locations.at(i), ctx.get_my_session()->get_process_query_time()))) {

ret = OB_SERVER_NOT_ALIVE;

LOG_WARN("observer is not alive", K(target_locations.at(i)));

}

}

} else {

bool is_odps_external_table = false;

ObSEArray<const ObTableScanSpec *, 2> scan_ops;

const ObTableScanSpec *scan_op = nullptr;

const ObOpSpec *root_op = NULL;

int64_t expected_location_cnt = 0;

dfo.get_root(root_op);

if (OB_ISNULL(root_op)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected null ptr", K(ret));

} else if (OB_FAIL(ObTaskSpliter::find_scan_ops(scan_ops, *root_op))) {

LOG_WARN("failed to find scan_ops", K(ret), KP(root_op));

} else if (scan_ops.count() == 0) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("empty scan_ops", K(ret));

} else if (OB_FAIL(ObSQLUtils::is_odps_external_table(scan_ops.at(0)->tsc_ctdef_.scan_ctdef_.external_file_format_str_.str_,

is_odps_external_table))) {

LOG_WARN("failed to check is odps external table or not", K(ret));

} else if (FALSE_IT(expected_location_cnt = std::min(dfo.get_dop(),

((!ext_file_urls.empty() && is_odps_external_table) ?

all_locations.count() : dfo.get_external_table_files().count())))) {

} else if (1 == expected_location_cnt) {

if (OB_FAIL(target_locations.push_back(GCTX.self_addr()))) {

LOG_WARN("fail to push push back", K(ret));

}

} else if (expected_location_cnt >= all_locations.count() ?

OB_FAIL(target_locations.assign(all_locations))

: OB_FAIL(ObPXServerAddrUtil::do_random_dfo_distribution(all_locations,

expected_location_cnt,

target_locations))) {

LOG_WARN("fail to calc random dfo distribution", K(ret), K(all_locations), K(expected_location_cnt));

}

}

LOG_TRACE("calc external table location", K(target_locations));

if (OB_SUCC(ret)) {

if (OB_FAIL(DAS_CTX(ctx).build_external_table_location(table_id, ref_table_id, target_locations))) {

LOG_WARN("fail to build external table locations", K(ret));

} else if (OB_ISNULL(table_loc = DAS_CTX(ctx).get_external_table_loc_by_id(table_id, ref_table_id))) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected location", K(ret));

}

}

}

return ret;

ObDfo &dfo,

ObExecContext &exec_ctx,

bool is_file_on_disk,

ObIArray<ObPxSqcMeta> &sqcs,

int64_t parallel)

{

int ret = OB_SUCCESS;

const common::ObIArray<share::ObExternalFileInfo> &files = dfo.get_external_table_files();

if (is_file_on_disk) {

ObAddr pre_addr;

ObPxSqcMeta *target_sqc = NULL;

for (int i = 0; OB_SUCC(ret) && i < files.count(); ++i) {

if (pre_addr != files.at(i).file_addr_) {

// TODO [External Table] OPT this

target_sqc = NULL;

for (int j = 0; j < sqcs.count(); j++) {

if (sqcs.at(j).get_exec_addr() == files.at(i).file_addr_) {

target_sqc = &sqcs.at(j);

break;

}

}

pre_addr = files.at(i).file_addr_;

}

if (OB_ISNULL(target_sqc)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("fail to find sqc", K(files.at(i).file_addr_));

} else if (OB_FAIL(target_sqc->get_access_external_table_files().push_back(files.at(i)))) {

LOG_WARN("fail to push back", K(ret));

}

}

} else {

bool is_odps_external_table = false;

ObODPSGeneralFormat::ApiMode odps_api_mode;

ObSEArray<const ObTableScanSpec *, 2> scan_ops;

const ObTableScanSpec *scan_op = nullptr;

const ObOpSpec *root_op = NULL;

dfo.get_root(root_op);

if (OB_ISNULL(root_op)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected null ptr", K(ret));

} else if (OB_FAIL(ObTaskSpliter::find_scan_ops(scan_ops, *root_op))) {

LOG_WARN("failed to find scan_ops", K(ret), KP(root_op));

} else if (scan_ops.count() == 0) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("empty scan_ops", K(ret));

} else if (OB_FAIL(ObSQLUtils::get_odps_api_mode(scan_ops.at(0)->tsc_ctdef_.scan_ctdef_.external_file_format_str_.str_,

is_odps_external_table,

odps_api_mode))) {

LOG_WARN("failed to check is odps external table or not", K(ret));

} else if (is_odps_external_table) {

if (OB_FAIL(ObExternalTableUtils::assign_odps_file_to_sqcs(

dfo, exec_ctx, sqcs, parallel, odps_api_mode))) {

LOG_WARN("failed to assisn odps file to sqcs", K(files), K(ret));

}

} else {

ObArray<int64_t> file_assigned_sqc_ids;

OZ (ObExternalTableUtils::calc_assigned_files_to_sqcs(files, file_assigned_sqc_ids, sqcs.count()));

if (OB_SUCC(ret) && file_assigned_sqc_ids.count() != files.count()) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("invalid result of assigned sqc", K(file_assigned_sqc_ids.count()), K(files.count()));

}

for (int i = 0; OB_SUCC(ret) && i < file_assigned_sqc_ids.count(); i++) {

int64_t assign_sqc_idx = file_assigned_sqc_ids.at(i);

if (OB_UNLIKELY(assign_sqc_idx >= sqcs.count() || assign_sqc_idx < 0)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected file idx", K(file_assigned_sqc_ids.at(i)));

} else {

OZ (sqcs.at(assign_sqc_idx).get_access_external_table_files().push_back(files.at(i)));

}

}

}

}

LOG_TRACE("check dfo external files", K(files));

for (int64_t i = 0; i < sqcs.count(); ++i) {

LOG_TRACE("check sqc external files", K(sqcs.at(i).get_access_external_table_files()));

}

return ret;

const ObIArray<ObTableLocation> *table_locations,

ObExecContext &ctx,

ObDfo &dfo)

{

int ret = OB_SUCCESS;

ObSEArray<const ObTableScanSpec *, 2> scan_ops;

ObSEArray<const ObTableModifySpec *, 1> dml_ops;

// INSERT, REPLACE operator

const ObTableModifySpec *dml_op = nullptr;

const ObTableScanSpec *scan_op = nullptr;

const ObOpSpec *root_op = NULL;

dfo.get_root(root_op);

// The logic of PDML will be removed

if (OB_ISNULL(root_op)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("NULL ptr or sqc is not empty", K(ret), K(dfo));

} else if (0 != dfo.get_sqcs_count()) {

/**

LOG_TRACE("this dfo has been built", K(dfo.get_dfo_id()));

} else if (OB_FAIL(ObTaskSpliter::find_scan_ops(scan_ops, *root_op))) {

LOG_WARN("fail find scan ops in dfo", K(dfo), K(ret));

} else if (OB_FAIL(ObPXServerAddrUtil::find_dml_ops(dml_ops, *root_op))) {

LOG_WARN("failed find insert op in dfo", K(ret), K(dfo));

} else if (1 < dml_ops.count()) { // Currently, there is at most one DML operator in one DFO

ret = OB_ERR_UNEXPECTED;

LOG_WARN("the count of insert ops is not right", K(ret), K(dml_ops.count()));

} else if (0 == scan_ops.count() && 0 == dml_ops.count()) {

/**

if (OB_FAIL(alloc_by_local_distribution(ctx, dfo))) {

LOG_WARN("alloc SQC on local failed", K(ret));

}

} else {

ObDASTableLoc *table_loc = NULL;

ObDASTableLoc *dml_full_loc = NULL;

uint64_t table_location_key = OB_INVALID_INDEX;

uint64_t ref_table_id = OB_INVALID_ID;

if (scan_ops.count() > 0) {

scan_op = scan_ops.at(0);

table_location_key = scan_op->get_table_loc_id();

ref_table_id = scan_op->get_loc_ref_table_id();

}

if (OB_SUCC(ret)) {

if (dml_ops.count() > 0) {

dml_op = dml_ops.at(0);

if (OB_FAIL(dml_op->get_single_table_loc_id(table_location_key, ref_table_id))) {

LOG_WARN("get single table loc id failed", K(ret));

}

}

}

if (OB_FAIL(ret)) {

//do nothing

} else if (dml_op && dml_op->is_table_location_uncertain()) {

// Need to get FULL TABLE LOCATION. FIX ME YISHEN.

CK(OB_NOT_NULL(ctx.get_my_session()));

OZ(ObTableLocation::get_full_leader_table_loc(DAS_CTX(ctx).get_location_router(),

ctx.get_allocator(),

ctx.get_my_session()->get_effective_tenant_id(),

table_location_key,

ref_table_id,

table_loc));

if (OB_SUCC(ret)) {

dml_full_loc = table_loc;

}

} else {

// Obtain the location information of the partition corresponding to the current DFO through TSC or DML

// Subsequently use location information to construct the corresponding SQC meta

if (OB_ISNULL(table_loc = DAS_CTX(ctx).get_table_loc_by_id(table_location_key, ref_table_id))) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("fail to get table loc", K(ret), K(table_location_key), K(ref_table_id), K(DAS_CTX(ctx).get_table_loc_list()));

} else if (OB_NOT_NULL(scan_op) && scan_op->is_external_table_) {

// create new table loc for a random dfo distribution for external table

OZ (get_external_table_loc(ctx, table_location_key, ref_table_id, scan_op->get_query_range_provider(), dfo, table_loc));

}

}

if (OB_FAIL(ret)) {

// bypass

} else if (OB_ISNULL(table_loc)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("fail to get phy table location", K(ret));

} else {

const DASTabletLocList &locations = table_loc->get_tablet_locs();

if (locations.size() <= 0) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("the location array is empty", K(locations.size()), K(ret));

} else if (OB_FAIL(build_dfo_sqc(ctx, locations, dfo))) {

LOG_WARN("fail fill dfo with sqc infos", K(dfo), K(ret));

} else if (OB_FAIL(set_dfo_accessed_location(ctx, table_location_key, dfo, scan_ops, dml_op, dml_full_loc))) {

LOG_WARN("fail to set all table partition for tsc", K(ret), K(scan_ops.count()), K(dml_op),

K(table_location_key), K(ref_table_id), K(locations));

} else if (OB_NOT_NULL(table_locations) && !table_locations->empty() &&

OB_FAIL(build_dynamic_partition_table_location(scan_ops, table_locations, dfo))) {

LOG_WARN("fail to build dynamic partition pruning table", K(ret));

}

LOG_TRACE("allocate sqc by data distribution", K(dfo), K(locations));

}

}

return ret;

const ObOpSpec &op)

{

return find_dml_ops_inner(insert_ops, op);

{

bool b_ret = false;

if (static_cast<const ObTableModifySpec &>(op).use_dist_das()

&& PHY_INSERT_ON_DUP != op.get_type()) {

// px no need schedule das except merge

} else if (PHY_LOCK == op.get_type()) {

// no need lock op

} else {

b_ret = true;

}

return b_ret;

const ObOpSpec &op)

{

int ret = OB_SUCCESS;

if (IS_DML(op.get_type())) {

if (!check_build_dfo_with_dml(op)) {

} else if (OB_FAIL(insert_ops.push_back(static_cast<const ObTableModifySpec *>(&op)))) {

LOG_WARN("fail to push back table insert op", K(ret));

}

}

if (OB_SUCC(ret) && !IS_RECEIVE(op.get_type())) {

for (int32_t i = 0; OB_SUCC(ret) && i < op.get_child_num(); ++i) {

const ObOpSpec *child_op = op.get_child(i);

if (OB_ISNULL(child_op)) {

ret = OB_ERR_UNEXPECTED;

} else if (OB_FAIL(find_dml_ops(insert_ops, *child_op))) {

LOG_WARN("fail to find child insert ops",

K(ret), K(i), "op_id", op.get_id(), "child_id", child_op->get_id());

}

}

}

return ret;

{

int ret = OB_SUCCESS;

ObP2PDhMapInfo &p2p_map_info = dfo.get_p2p_dh_map_info();

if (OB_ISNULL(dfo.get_coord_info_ptr())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected coord info ptr", K(ret));

} else if (!dfo.get_p2p_dh_ids().empty() && p2p_map_info.is_empty()) {

ObP2PDfoMapNode node;

for (int i = 0; i < dfo.get_p2p_dh_ids().count() && OB_SUCC(ret); ++i) {

node.reset();

if (OB_FAIL(dfo.get_coord_info_ptr()->p2p_dfo_map_.get_refactored(

dfo.get_p2p_dh_ids().at(i), node))) {

LOG_WARN("fail to get target dfo id", K(ret));

} else if (node.addrs_.empty()) {

ObDfo *target_dfo_ptr = nullptr;

if (OB_FAIL(dfo.get_coord_info_ptr()->dfo_mgr_.find_dfo_edge(

node.target_dfo_id_, target_dfo_ptr))) {

LOG_WARN("fail to find dfo edge", K(ret));

} else if (target_dfo_ptr->get_p2p_dh_addrs().empty()) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("fail to get p2p dh addrs", K(ret), K(dfo.get_p2p_dh_ids().at(i)));

} else if (OB_FAIL(node.addrs_.assign(target_dfo_ptr->get_p2p_dh_addrs()))) {

LOG_WARN("fail to assign p2p dh addrs", K(ret));

} else if (OB_FAIL(dfo.get_coord_info_ptr()->p2p_dfo_map_.set_refactored(

dfo.get_p2p_dh_ids().at(i), node, 1/*over_write*/))) {

LOG_WARN("fail to set p2p dh addrs", K(ret));

}

}

if (OB_SUCC(ret)) {

if (OB_FAIL(p2p_map_info.p2p_sequence_ids_.push_back(dfo.get_p2p_dh_ids().at(i)))) {

LOG_WARN("fail to push back p2p map info", K(ret));

} else if (OB_FAIL(p2p_map_info.target_addrs_.push_back(node.addrs_))) {

LOG_WARN("fail to push back addrs", K(ret));

}

}

}

}

return ret;

const DASTabletLocList &locations,

ObDfo &dfo)

{

int ret = OB_SUCCESS;

ObArray<ObAddr> addrs;

const ObPhysicalPlanCtx *phy_plan_ctx = GET_PHY_PLAN_CTX(ctx);

const ObPhysicalPlan *phy_plan = NULL;

ObArray<int64_t> sqc_max_task_count;

ObArray<int64_t> sqc_part_count;

int64_t parallel = 0;

if (OB_ISNULL(phy_plan_ctx) ||

OB_ISNULL(phy_plan = phy_plan_ctx->get_phy_plan())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("NULL phy plan ptr", K(ret));

} else if (OB_FAIL(get_location_addrs<DASTabletLocList>(locations, addrs))) {

LOG_WARN("fail get location addrs", K(ret));

} else if (OB_FAIL(sqc_part_count.prepare_allocate(addrs.count()))) {

LOG_WARN("Failed to pre allocate sqc part count");

} else {

parallel = dfo.get_assigned_worker_count();

if (0 >= parallel) {

parallel = 1;

LOG_TRACE("parallel not set in query hint. set default to 1");

}

}

// generate dh map info

if (OB_SUCC(ret)) {

if (OB_FAIL(generate_dh_map_info(dfo))) {

LOG_WARN("fail to generate dh map info", K(ret));

}

}

if (OB_SUCC(ret) && addrs.count() > 0) {

ObIArray<ObPxSqcMeta> &sqcs = dfo.get_sqcs();

int64_t total_part_cnt = 0;

DASTabletLocSEArray sqc_locations;

for (int64_t i = 0; OB_SUCC(ret) && i < addrs.count(); ++i) {

SMART_VAR(ObPxSqcMeta, sqc) {

sqc_locations.reuse();

sqc.set_dfo_id(dfo.get_dfo_id());

sqc.set_sqc_id(i);

sqc.set_exec_addr(addrs.at(i));

sqc.set_qc_addr(GCTX.self_addr());

sqc.set_execution_id(dfo.get_execution_id());

sqc.set_px_sequence_id(dfo.get_px_sequence_id());

sqc.set_qc_id(dfo.get_qc_id());

sqc.set_interrupt_id(dfo.get_interrupt_id());

sqc.set_fulltree(dfo.is_fulltree());

sqc.set_qc_server_id(dfo.get_qc_server_id());

sqc.set_parent_dfo_id(dfo.get_parent_dfo_id());

sqc.set_single_tsc_leaf_dfo(dfo.is_single_tsc_leaf_dfo());

sqc.get_monitoring_info().init(dfo);

sqc.set_partition_random_affinitize(dfo.partition_random_affinitize());

if (OB_SUCC(ret)) {

if (!dfo.get_p2p_dh_map_info().is_empty()) {

if (OB_FAIL(sqc.get_p2p_dh_map_info().assign(dfo.get_p2p_dh_map_info()))) {

LOG_WARN("fail to assign p2p dh map info", K(ret));

}

}

}

for (auto iter = locations.begin(); OB_SUCC(ret) && iter != locations.end(); ++iter) {

if (addrs.at(i) == (*iter)->server_) {

if (OB_FAIL(sqc_locations.push_back(*iter))) {

LOG_WARN("fail add location to sqc", K(ret));

}

}

}

total_part_cnt += sqc_locations.count();

sqc_part_count.at(i) = sqc_locations.count();

if (OB_SUCC(ret)) {

if (OB_FAIL(dfo.add_sqc(sqc))) {

LOG_WARN("Failed to add sqc", K(ret), K(sqc));

}

}

}

}

if (OB_SUCC(ret)) {

if (OB_FAIL(split_parallel_into_task(parallel, sqc_part_count, sqc_max_task_count))) {

LOG_WARN("Failed to get sqc max task count", K(ret));

} else if (sqcs.count() != sqc_max_task_count.count()) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("Unexpected sqcs count and sqc max task count", K(ret), K(sqcs.count()), K(sqc_max_task_count.count()));

}

}

int64_t total_task_count = 0;

for (int64_t i = 0; OB_SUCC(ret) && i < sqc_max_task_count.count(); ++i) {

sqcs.at(i).set_min_task_count(1);

sqcs.at(i).set_max_task_count(sqc_max_task_count.at(i));

total_task_count += sqc_max_task_count.at(i);

}

for (int64_t i = 0; OB_SUCC(ret) && i < sqc_max_task_count.count(); ++i) {

sqcs.at(i).set_total_task_count(total_task_count);

sqcs.at(i).set_total_part_count(total_part_cnt);

}

if (OB_SUCC(ret) && !locations.empty()

&& (*locations.begin())->loc_meta_->is_external_table_) {

if (OB_FAIL(assign_external_files_to_sqc(dfo, ctx,

(*locations.begin())->loc_meta_->is_external_files_on_disk_, sqcs, parallel))) {

LOG_WARN("fail to assign external files to sqc", K(ret));

}

}

}

return ret;

ObDfo &dfo)

{

int ret = OB_SUCCESS;

if (nullptr != dfo.get_root_op_spec()) {

if (OB_FAIL(alloc_by_temp_child_distribution_inner(exec_ctx, dfo))) {

LOG_WARN("failed to alloc temp child distribution", K(ret));

}

} else {

ret = OB_INVALID_ARGUMENT;

LOG_WARN("invalid argument", K(ret));

}

return ret;

ObDfo &child)

{

int ret = OB_SUCCESS;

ObSEArray<const ObTableScanSpec *, 2> scan_ops;

const ObTableScanSpec *scan_op = nullptr;

const ObOpSpec *root_op = NULL;

child.get_root(root_op);

ObIArray<ObSqlTempTableCtx>& temp_ctx = exec_ctx.get_temp_table_ctx();

ObSqlTempTableCtx *ctx = NULL;

int64_t parallel = child.get_assigned_worker_count();

if (0 >= parallel) {

parallel = 1;

LOG_TRACE("parallel not set in query hint. set default to 1");

}

for (int64_t i = 0; NULL == ctx && i < temp_ctx.count(); i++) {

if (child.get_temp_table_id() == temp_ctx.at(i).temp_table_id_) {

ctx = &temp_ctx.at(i);

}

}

if (OB_NOT_NULL(ctx) && !ctx->interm_result_infos_.empty()) {

ObIArray<ObTempTableResultInfo> &interm_result_infos = ctx->interm_result_infos_;

ObArray<int64_t> sqc_max_task_count;

ObArray<int64_t> sqc_result_count;

if (OB_FAIL(sqc_result_count.prepare_allocate(interm_result_infos.count()))) {

LOG_WARN("Failed to pre allocate sqc part count");

} else if (OB_FAIL(generate_dh_map_info(child))) {

LOG_WARN("fail to generate dh map info", K(ret));

}

for (int64_t j = 0; OB_SUCC(ret) && j < interm_result_infos.count(); j++) {

SMART_VAR(ObPxSqcMeta, sqc) {

ObTempTableResultInfo &info = interm_result_infos.at(j);

sqc.set_exec_addr(info.addr_);

sqc.set_qc_addr(GCTX.self_addr());

sqc.set_dfo_id(child.get_dfo_id());

sqc.set_sqc_id(j);

sqc.set_execution_id(child.get_execution_id());

sqc.set_px_sequence_id(child.get_px_sequence_id());

sqc.set_qc_id(child.get_qc_id());

sqc.set_interrupt_id(child.get_interrupt_id());

sqc.set_fulltree(child.is_fulltree());

sqc.set_qc_server_id(child.get_qc_server_id());

sqc.set_parent_dfo_id(child.get_parent_dfo_id());

sqc.get_monitoring_info().init(child);

sqc.set_partition_random_affinitize(child.partition_random_affinitize());

if (OB_SUCC(ret)) {

if (!child.get_p2p_dh_map_info().is_empty()) {

if (OB_FAIL(sqc.get_p2p_dh_map_info().assign(child.get_p2p_dh_map_info()))) {

LOG_WARN("fail to assign p2p dh map info", K(ret));

}

}

}

if (OB_FAIL(ret)) {

} else if (OB_FAIL(child.add_sqc(sqc))) {

LOG_WARN("fail add sqc", K(sqc), K(ret));

}

}

}

for (int64_t j = 0; OB_SUCC(ret) && j < interm_result_infos.count(); j++) {

sqc_result_count.at(j) = interm_result_infos.at(j).interm_result_ids_.count();

if (0 >= sqc_result_count.at(j)) {

sqc_result_count.at(j) = 1;

}

}

ObIArray<ObPxSqcMeta> &sqcs = child.get_sqcs();

if (OB_SUCC(ret)) {

if (OB_FAIL(split_parallel_into_task(parallel, sqc_result_count, sqc_max_task_count))) {

LOG_WARN("Failed to split parallel into task", K(ret));

} else if (OB_UNLIKELY(sqcs.count() != sqc_max_task_count.count())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("Unexpected sqcs count and sqc max task count", K(ret));

}

}

int64_t total_task_count = 0;

for (int64_t i = 0; OB_SUCC(ret) && i < sqc_max_task_count.count(); ++i) {

sqcs.at(i).set_min_task_count(1);

sqcs.at(i).set_max_task_count(sqc_max_task_count.at(i));

total_task_count += sqc_max_task_count.at(i);

}

for (int64_t i = 0; OB_SUCC(ret) && i < sqc_max_task_count.count(); ++i) {

sqcs.at(i).set_total_task_count(total_task_count);

}

} else if (OB_ISNULL(ctx)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("expect temp table in dfo", K(child.get_temp_table_id()), K(temp_ctx));

}

if (OB_SUCC(ret)) {

int64_t base_table_location_key = OB_INVALID_ID;

if (OB_ISNULL(root_op)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("NULL ptr or sqc is not empty", K(ret), K(child));

} else if (OB_FAIL(ObTaskSpliter::find_scan_ops(scan_ops, *root_op))) {

LOG_WARN("fail find scan ops in dfo", K(child), K(ret));

} else if (scan_ops.empty()) {

} else if (FALSE_IT(base_table_location_key = scan_ops.at(0)->get_table_loc_id())) {

} else if (OB_FAIL(set_dfo_accessed_location(exec_ctx,

base_table_location_key, child, scan_ops, NULL, NULL))) {

LOG_WARN("fail to set all table partition for tsc", K(ret));

}

}

return ret;

{

int ret = OB_SUCCESS;

const ObIArray<ObPxSqcMeta> &sqcs = child.get_sqcs();

if (OB_FAIL(generate_dh_map_info(parent))) {

LOG_WARN("fail to generate dh map info", K(ret));

} else {

for (int64_t i = 0; i < sqcs.count() && OB_SUCC(ret); ++i) {

const ObPxSqcMeta &child_sqc = sqcs.at(i);

SMART_VAR(ObPxSqcMeta, sqc) {

sqc.set_exec_addr(child_sqc.get_exec_addr());

sqc.set_qc_addr(GCTX.self_addr());

sqc.set_dfo_id(parent.get_dfo_id());

sqc.set_min_task_count(child_sqc.get_min_task_count());

sqc.set_max_task_count(child_sqc.get_max_task_count());

sqc.set_total_task_count(child_sqc.get_total_task_count());

sqc.set_total_part_count(child_sqc.get_total_part_count());

sqc.set_sqc_id(i);

sqc.set_execution_id(parent.get_execution_id());

sqc.set_px_sequence_id(parent.get_px_sequence_id());

sqc.set_qc_id(parent.get_qc_id());

sqc.set_interrupt_id(parent.get_interrupt_id());

sqc.set_fulltree(parent.is_fulltree());

sqc.set_qc_server_id(parent.get_qc_server_id());

sqc.set_parent_dfo_id(parent.get_parent_dfo_id());

sqc.get_monitoring_info().assign(child_sqc.get_monitoring_info());

sqc.set_partition_random_affinitize(child.partition_random_affinitize());

if (!parent.get_p2p_dh_map_info().is_empty()) {

if (OB_FAIL(sqc.get_p2p_dh_map_info().assign(parent.get_p2p_dh_map_info()))) {

LOG_WARN("fail to assign p2p dh map info", K(ret));

}

}

if (OB_FAIL(ret)) {

} else if (OB_FAIL(parent.add_sqc(sqc))) {

LOG_WARN("fail add sqc", K(sqc), K(ret));

}

}

}

LOG_TRACE("allocate by child distribution", K(sqcs));

}

return ret;

const ObDfo &child, ObDfo &parent, ObPxNodePool &px_node_pool)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(exec_ctx.get_physical_plan_ctx()) ||

OB_ISNULL(exec_ctx.get_physical_plan_ctx()->get_phy_plan())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("NULL phy plan ctx", K(ret), K(exec_ctx.get_physical_plan_ctx()));

} else if (0 != parent.get_sqcs_count()) {

/**

LOG_TRACE("this dfo has been built", K(parent.get_dfo_id()));

} else if (OB_FAIL(px_node_pool.init(exec_ctx))) {

LOG_WARN("Fail to init mpp node info", K(ret));

} else if (px_node_pool.data_node_empty()) {

// a defensive code, if this SQL does not have a location, still alloc by child

// this kind of plan is not common

if (OB_FAIL(alloc_by_child_distribution(child, parent))) {

LOG_WARN("fail to alloc by child distribution", K(ret));

}

} else {

const ObAddrFixedArray &px_candidate_node_pool = px_node_pool.get_candidate_node_pool();

sql::ObTMArray<ObAddr> addrs;

int64_t parallel = std::max(parent.get_assigned_worker_count(), (int64_t)(1));

ObTMArray<int64_t> sqc_max_task_counts;

ObTMArray<int64_t> sqc_part_counts;

int64_t total_task_count = 0;

ObPxNodeSelectionMode selection_mode = px_node_pool.get_px_node_selection_mode();

LOG_TRACE("px candidate node pool", K(parallel),

K(px_candidate_node_pool.count()), K(px_candidate_node_pool));

switch (selection_mode) {

case ObPxNodeSelectionMode::SPECIFY_NODE: {

if (OB_FAIL(addrs.assign(px_candidate_node_pool))) {

LOG_WARN("Fail to assign", K(ret));

}

break;

}

case ObPxNodeSelectionMode::SPECIFY_COUNT: {

int64_t actual_node_num = std::min(

exec_ctx.get_physical_plan_ctx()->get_phy_plan()->get_px_node_count(),

px_candidate_node_pool.count());

for (int i = 0; OB_SUCC(ret) && i < actual_node_num; ++i) {

if (OB_FAIL(addrs.push_back(px_candidate_node_pool.at(i)))) {

LOG_WARN("fail to push back", K(ret));

}

}

break;

}

case ObPxNodeSelectionMode::DEFAULT: {

int64_t actual_node_num = std::min(parallel, px_candidate_node_pool.count());

for (int i = 0; OB_SUCC(ret) && i < actual_node_num; ++i) {

if (OB_FAIL(addrs.push_back(px_candidate_node_pool.at(i)))) {

LOG_WARN("fail to push back", K(ret));

}

}

break;

}

default: {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected mpp node selection mode", K(selection_mode));

break;

}

}

for (int i = 0; i < addrs.count() && OB_SUCC(ret); ++i) {

if (OB_FAIL(sqc_part_counts.push_back(1))) {

LOG_WARN("fail to push back sqc part count", K(ret));

}

}

if (OB_FAIL(ret)) {

} else if (OB_FAIL(split_parallel_into_task(parallel, sqc_part_counts, sqc_max_task_counts))) {

LOG_WARN("fail to split parallel task", K(ret));

} else {

CK(sqc_max_task_counts.count() == addrs.count());

for (int i = 0; i < sqc_max_task_counts.count() && OB_SUCC(ret); ++i) {

total_task_count += sqc_max_task_counts.at(i);

}

LOG_TRACE("sqc task count", K(total_task_count),

K(addrs.count()), K(addrs), K(sqc_max_task_counts));

}

// generate dh map info

if (OB_SUCC(ret)) {

if (OB_FAIL(generate_dh_map_info(parent))) {

LOG_WARN("fail to generate dh map info", K(ret));

}

}

for (int64_t i = 0; i < addrs.count() && OB_SUCC(ret); ++i) {

SMART_VAR(ObPxSqcMeta, sqc) {

sqc.set_exec_addr(addrs.at(i));

sqc.set_qc_addr(GCTX.self_addr());

sqc.set_dfo_id(parent.get_dfo_id());

sqc.set_min_task_count(1);

sqc.set_max_task_count(sqc_max_task_counts.at(i));

sqc.set_total_task_count(total_task_count);

sqc.set_total_part_count(sqc_part_counts.count());

sqc.set_sqc_id(i);

sqc.set_execution_id(parent.get_execution_id());

sqc.set_px_sequence_id(parent.get_px_sequence_id());

sqc.set_qc_id(parent.get_qc_id());

sqc.set_interrupt_id(parent.get_interrupt_id());

sqc.set_fulltree(parent.is_fulltree());

sqc.set_qc_server_id(parent.get_qc_server_id());

sqc.set_parent_dfo_id(parent.get_parent_dfo_id());

sqc.get_monitoring_info().init(parent);

sqc.set_partition_random_affinitize(parent.partition_random_affinitize());

if (OB_SUCC(ret)) {

if (!parent.get_p2p_dh_map_info().is_empty()) {

if (OB_FAIL(sqc.get_p2p_dh_map_info().assign(parent.get_p2p_dh_map_info()))) {

LOG_WARN("fail to assign p2p dh map info", K(ret));

}

}

}

if (OB_FAIL(ret)) {

} else if (OB_FAIL(parent.add_sqc(sqc))) {

LOG_WARN("fail add sqc", K(sqc), K(ret));

}

}

}