138 lines
4.3 KiB
C++
138 lines
4.3 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_CG
|
|
|
|
#include "sql/code_generator/ob_code_generator.h"
|
|
#include "sql/code_generator/ob_code_generator_impl.h"
|
|
#include "sql/code_generator/ob_static_engine_expr_cg.h"
|
|
#include "sql/code_generator/ob_static_engine_cg.h"
|
|
|
|
namespace oceanbase {
|
|
namespace sql {
|
|
|
|
int ObCodeGenerator::generate(const ObLogPlan& log_plan, ObPhysicalPlan& phy_plan)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (!use_static_typing_engine_) {
|
|
if (OB_FAIL(generate_old_plan(log_plan, phy_plan))) {
|
|
LOG_WARN("fail to generate old plan", K(ret));
|
|
}
|
|
} else {
|
|
if (OB_FAIL(generate_exprs(log_plan, phy_plan))) {
|
|
LOG_WARN("fail to get all raw exprs", K(ret));
|
|
} else if (OB_FAIL(generate_operators(log_plan, phy_plan))) {
|
|
LOG_WARN("fail to generate plan", K(ret));
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObCodeGenerator::generate_old_plan(const ObLogPlan& log_plan, ObPhysicalPlan& phy_plan)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObCodeGeneratorImpl code_generator(min_cluster_version_);
|
|
if (OB_FAIL(code_generator.generate(log_plan, phy_plan))) {
|
|
LOG_WARN("fail to code generate", K(ret));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObCodeGenerator::generate_exprs(const ObLogPlan& log_plan, ObPhysicalPlan& phy_plan)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStaticEngineExprCG expr_cg(phy_plan.get_allocator(), param_store_);
|
|
// init ctx for operator cg
|
|
expr_cg.init_operator_cg_ctx(log_plan.get_optimizer_context().get_exec_ctx());
|
|
ObRawExprUniqueSet all_raw_exprs(phy_plan.get_allocator());
|
|
if (OB_FAIL(all_raw_exprs.init())) {
|
|
LOG_WARN("fail to create hash set", K(ret));
|
|
} else if (OB_FAIL(get_plan_all_exprs(log_plan, all_raw_exprs))) {
|
|
LOG_WARN("get all exprs failed", K(ret));
|
|
} else if (OB_FAIL(expr_cg.generate(all_raw_exprs, phy_plan.get_expr_frame_info()))) {
|
|
LOG_WARN("fail to generate expr", K(ret));
|
|
} else {
|
|
phy_plan.get_next_expr_id() = phy_plan.get_expr_frame_info().need_ctx_cnt_;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObCodeGenerator::generate_operators(const ObLogPlan& log_plan, ObPhysicalPlan& phy_plan)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStaticEngineCG static_engin_cg(min_cluster_version_);
|
|
if (OB_FAIL(static_engin_cg.generate(log_plan, phy_plan))) {
|
|
LOG_WARN("fail to code generate", K(ret));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObCodeGenerator::get_plan_all_exprs(const ObLogPlan& plan, ObRawExprUniqueSet& exprs)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObSEArray<const ObLogPlan*, 16> plans;
|
|
OZ(get_all_log_plan(&plan, plans));
|
|
FOREACH_CNT_X(p, plans, OB_SUCC(ret))
|
|
{
|
|
if (NULL != *p) {
|
|
OZ(exprs.append((*p)->get_all_exprs().get_expr_array()));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObCodeGenerator::get_all_log_plan(const ObLogPlan* root, ObIArray<const ObLogPlan*>& plans)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
OZ(check_stack_overflow());
|
|
const int64_t by_op_start = plans.count();
|
|
if (NULL != root) {
|
|
OZ(get_all_log_plan(root->get_plan_root(), plans));
|
|
}
|
|
const int64_t by_op_end = plans.count();
|
|
for (int64_t i = by_op_start; OB_SUCC(ret) && i < by_op_end; i++) {
|
|
FOREACH_CNT_X(sub, plans.at(i)->get_subplans(), OB_SUCC(ret))
|
|
{
|
|
if (NULL != *sub && NULL != (*sub)->subplan_) {
|
|
OZ(add_var_to_array_no_dup(plans, const_cast<const ObLogPlan*>((*sub)->subplan_)));
|
|
}
|
|
}
|
|
}
|
|
const int64_t by_subplan_info_end = plans.count();
|
|
for (int64_t i = by_op_end; OB_SUCC(ret) && i < by_subplan_info_end; i++) {
|
|
OZ(get_all_log_plan(plans.at(i), plans));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObCodeGenerator::get_all_log_plan(const ObLogicalOperator* op, ObIArray<const ObLogPlan*>& plans)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (NULL != op) {
|
|
OZ(check_stack_overflow());
|
|
if (NULL != op->get_plan()) {
|
|
OZ(add_var_to_array_no_dup(plans, op->get_plan()));
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < op->get_num_of_child(); i++) {
|
|
OZ(get_all_log_plan(op->get_child(i), plans));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
} // end namespace sql
|
|
} // end namespace oceanbase
|