418 lines
21 KiB
C++
418 lines
21 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.
|
|
*/
|
|
|
|
#ifndef OCEANBASE_SRC_OB_STATIC_ENGINE_CG_H_
|
|
#define OCEANBASE_SRC_OB_STATIC_ENGINE_CG_H_
|
|
|
|
#include "sql/code_generator/ob_code_generator_impl.h"
|
|
#include "sql/engine/ob_operator.h"
|
|
#include "sql/engine/sort/ob_sort_basic_info.h"
|
|
|
|
namespace oceanbase {
|
|
namespace sql {
|
|
class ObExpr;
|
|
class ObLogLimit;
|
|
class ObLimitSpec;
|
|
class ObLogDistinct;
|
|
class ObMergeDistinctSpec;
|
|
class ObHashDistinctSpec;
|
|
class ObLogMaterial;
|
|
class ObMaterialSpec;
|
|
class ObLogSort;
|
|
class ObSortSpec;
|
|
class ObLogSet;
|
|
class ObMergeSetSpec;
|
|
class ObMergeUnionSpec;
|
|
class ObMergeIntersectSpec;
|
|
class ObMergeExceptSpec;
|
|
class ObRecursiveUnionAllSpec;
|
|
class ObHashSetSpec;
|
|
class ObHashUnionSpec;
|
|
class ObHashIntersectSpec;
|
|
class ObHashExceptSpec;
|
|
class ObCountSpec;
|
|
class ObExprValuesSpec;
|
|
class ObTableMergeSpec;
|
|
class ObTableInsertSpec;
|
|
class ObTableUpdateSpec;
|
|
class ObTableUpdateReturningSpec;
|
|
class ObTableLockSpec;
|
|
class ObMultiPartLockSpec;
|
|
class ObTableInsertUpSpec;
|
|
class ObMultiTableInsertUpSpec;
|
|
class ObTableModifySpec;
|
|
class ObValuesSpec;
|
|
class ObLogTableScan;
|
|
class ObTableScanSpec;
|
|
class ObFakeCTETableSpec;
|
|
class ObHashJoinSpec;
|
|
class ObNestedLoopJoinSpec;
|
|
class ObBasicNestedLoopJoinSpec;
|
|
class ObMergeJoinSpec;
|
|
class ObJoinSpec;
|
|
class ObMonitoringDumpSpec;
|
|
class ObLogSequence;
|
|
class ObSequenceSpec;
|
|
class ObNLConnectBySpecBase;
|
|
class ObNLConnectBySpec;
|
|
class ObNLConnectByWithIndexSpec;
|
|
class ObGranuleIteratorSpec;
|
|
class ObPxReceiveSpec;
|
|
class ObPxTransmitSpec;
|
|
class ObPxFifoReceiveSpec;
|
|
class ObPxMSReceiveSpec;
|
|
class ObPxDistTransmitSpec;
|
|
class ObPxDistTransmitOp;
|
|
class ObPxRepartTransmitSpec;
|
|
class ObPxReduceTransmitSpec;
|
|
class ObPxFifoCoordSpec;
|
|
class ObPxMSCoordSpec;
|
|
class ObLogSubPlanFilter;
|
|
class ObSubPlanFilterSpec;
|
|
class ObLogSubPlanScan;
|
|
class ObSubPlanScanSpec;
|
|
class ObGroupBySpec;
|
|
class ObScalarAggregateSpec;
|
|
class ObMergeGroupBySpec;
|
|
class ObHashGroupBySpec;
|
|
class ObAggregateProcessor;
|
|
class ObAggrInfo;
|
|
class ObWindowFunctionSpec;
|
|
class WinFuncInfo;
|
|
template <int TYPE>
|
|
struct GenSpecHelper;
|
|
class ObTableLookupSpec;
|
|
class ObMultiPartTableScanSpec;
|
|
class ObMultiPartInsertSpec;
|
|
class ObMultiPartDeleteSpec;
|
|
class ObAppendSpec;
|
|
class ObTableRowStoreSpec;
|
|
class ObMultiPartUpdateSpec;
|
|
class ObMultiTableReplaceSpec;
|
|
class ObMultiTableMergeSpec;
|
|
class ObTableConflictRowFetcherSpec;
|
|
class ObRowSampleScanSpec;
|
|
class ObBlockSampleScanSpec;
|
|
class ObDirectReceiveSpec;
|
|
class ObDirectTransmitSpec;
|
|
class ObTableScanWithIndexBackSpec;
|
|
class ObPxMultiPartDeleteSpec;
|
|
class ObPxMultiPartInsertSpec;
|
|
class ObPxMultiPartUpdateSpec;
|
|
class ObTempTableAccessOpSpec;
|
|
class ObTempTableInsertOpSpec;
|
|
class ObTempTableTransformationOpSpec;
|
|
|
|
//
|
|
// code generator for static typing engine.
|
|
//
|
|
class ObStaticEngineCG : public ObCodeGeneratorImpl {
|
|
public:
|
|
using ObCodeGeneratorImpl::ObCodeGeneratorImpl;
|
|
template <int TYPE>
|
|
friend class GenSpecHelper;
|
|
|
|
ObStaticEngineCG(uint64_t min_cluster_version) : ObCodeGeneratorImpl(min_cluster_version)
|
|
{}
|
|
// generate physical plan
|
|
int generate(const ObLogPlan& log_plan, ObPhysicalPlan& phy_plan) override;
|
|
|
|
// Dangerous: there is a dragon!!!
|
|
int generate_rt_expr(const ObRawExpr& raw_expr, ObExpr*& rt_expr);
|
|
int generate_rt_exprs(const common::ObIArray<ObRawExpr*>& src, common::ObIArray<ObExpr*>& dst);
|
|
|
|
private:
|
|
bool enable_pushdown_filter_to_storage(const ObLogTableScan& op);
|
|
// Post order visit logic plan and generate operator specification.
|
|
// %in_root_job indicate that the operator is executed in main execution thread,
|
|
// not scheduled by distributed/remote execution or PX execution.
|
|
int postorder_generate_op(
|
|
ObLogicalOperator& op, ObOpSpec*& spec, const bool in_root_job, const bool is_subplan, bool& check_eval_once);
|
|
int clear_all_exprs_specific_flag(const ObIArray<ObRawExpr*>& exprs, ObExprInfoFlag flag);
|
|
int mark_expr_self_produced(ObRawExpr* expr);
|
|
int mark_expr_self_produced(const ObIArray<ObRawExpr*>& exprs);
|
|
int mark_expr_self_produced(const ObIArray<ObColumnRefRawExpr*>& exprs);
|
|
int set_specific_flag_to_exprs(const ObIArray<ObRawExpr*>& exprs, ObExprInfoFlag flag);
|
|
int check_expr_columnlized(const ObRawExpr* expr);
|
|
int check_exprs_columnlized(ObLogicalOperator& op);
|
|
|
|
// generate basic attributes (attributes of ObOpSpec class),
|
|
int generate_spec_basic(ObLogicalOperator& op, ObOpSpec& spec, const bool check_eval_once);
|
|
|
|
// Invoked after generate_spec() and generate_spec_basic(),
|
|
// some operator need this phase to do some special generation.
|
|
int generate_spec_final(ObLogicalOperator& op, ObOpSpec& spec);
|
|
|
|
int generate_calc_exprs(const common::ObIArray<ObRawExpr*>& dep_exprs, const common::ObIArray<ObRawExpr*>& cur_exprs,
|
|
common::ObIArray<ObExpr*>& calc_exprs, bool check_eval_once);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Code generator interface for all operator spec. When XXX operator is added,
|
|
// you should implement the interface:
|
|
//
|
|
// int generate_spec(ObLogXXX &op, ObXXXSepc &spec, const bool in_root_job);
|
|
//
|
|
// generate_spec() is called after generate_spec_basic() which generate attributes
|
|
// of ObOpSpec class.
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int generate_spec(ObLogLimit& op, ObLimitSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogDistinct& op, ObMergeDistinctSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogDistinct& op, ObHashDistinctSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogSet& op, ObHashUnionSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogSet& op, ObHashIntersectSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogSet& op, ObHashExceptSpec& spec, const bool in_root_job);
|
|
int generate_hash_set_spec(ObLogSet& op, ObHashSetSpec& spec);
|
|
|
|
int generate_spec(ObLogSet& op, ObMergeUnionSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogSet& op, ObMergeIntersectSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogSet& op, ObMergeExceptSpec& spec, const bool in_root_job);
|
|
int generate_cte_pseudo_column_row_desc(ObLogSet& op, ObRecursiveUnionAllSpec& phy_set_op);
|
|
int generate_spec(ObLogSet& op, ObRecursiveUnionAllSpec& spec, const bool in_root_job);
|
|
int generate_merge_set_spec(ObLogSet& op, ObMergeSetSpec& spec);
|
|
int generate_recursive_union_all_spec(ObLogSet& op, ObRecursiveUnionAllSpec& spec);
|
|
|
|
int generate_spec(ObLogMaterial& op, ObMaterialSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogSort& op, ObSortSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogCount& op, ObCountSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogValues& op, ObValuesSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogSubPlanFilter& op, ObSubPlanFilterSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogSubPlanScan& op, ObSubPlanScanSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogTableScan& op, ObTableScanSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogTableScan& op, ObFakeCTETableSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogTempTableAccess& op, ObTempTableAccessOpSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogTempTableInsert& op, ObTempTableInsertOpSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogTempTableTransformation& op, ObTempTableTransformationOpSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogGroupBy& op, ObScalarAggregateSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogGroupBy& op, ObMergeGroupBySpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogGroupBy& op, ObHashGroupBySpec& spec, const bool in_root_job);
|
|
|
|
// generate normal table scan
|
|
int generate_normal_tsc(ObLogTableScan& op, ObTableScanSpec& spec);
|
|
int generate_real_virtual_table(ObLogTableScan& op, ObTableScanSpec& spec);
|
|
int convert_table_param(ObLogTableScan& op, ObTableScanSpec& spec, const uint64_t table_id, const uint64_t index_id);
|
|
int generate_tsc_filter(const ObLogTableScan& op, ObTableScanSpec& spec);
|
|
|
|
int need_prior_exprs(
|
|
common::ObIArray<ObExpr*>& self_output, common::ObIArray<ObExpr*>& left_output, bool& need_prior);
|
|
int generate_param_spec(ObLogJoin& op, const common::ObIArray<std::pair<int64_t, ObRawExpr*>>& param_raw_exprs,
|
|
ObFixedArray<ObDynamicParamSetter, ObIAllocator>& param_setter);
|
|
int generate_pseudo_column_expr(ObLogJoin& op, ObNLConnectBySpecBase& spec);
|
|
int generate_pump_exprs(ObLogJoin& op, ObNLConnectBySpecBase& spec);
|
|
int get_connect_by_copy_expr(ObRawExpr& left_expr, ObRawExpr*& right_expr, common::ObIArray<ObRawExpr*>& right_exprs);
|
|
int generate_spec(ObLogJoin& op, ObNLConnectByWithIndexSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogJoin& op, ObNLConnectBySpec& spec, const bool in_root_job);
|
|
|
|
int generate_cte_table_spec(ObLogTableScan& op, ObFakeCTETableSpec& spec);
|
|
|
|
int generate_spec(ObLogJoin& op, ObHashJoinSpec& spec, const bool in_root_job);
|
|
// generate nested loop join
|
|
int generate_spec(ObLogJoin& op, ObNestedLoopJoinSpec& spec, const bool in_root_job);
|
|
// generate merge join
|
|
int generate_spec(ObLogJoin& op, ObMergeJoinSpec& spec, const bool in_root_job);
|
|
|
|
int generate_join_spec(ObLogJoin& op, ObJoinSpec& spec);
|
|
|
|
int set_optimization_info(ObLogTableScan& op, ObTableScanSpec& spec);
|
|
int set_partition_range_info(ObLogTableScan& op, ObTableScanSpec& spec);
|
|
|
|
int generate_spec(ObLogExprValues& op, ObExprValuesSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogMerge& op, ObTableMergeSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogMerge& op, ObMultiTableMergeSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogInsert& op, ObTableInsertSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogInsert& op, ObTableInsertReturningSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogInsert& op, ObMultiPartInsertSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogicalOperator& op, ObAppendSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogicalOperator& op, ObTableRowStoreSpec& spec, const bool in_root_job);
|
|
|
|
// for update && update returning.
|
|
int generate_update(ObLogUpdate& op, ObTableUpdateSpec& spec);
|
|
|
|
int generate_spec(ObLogUpdate& op, ObTableUpdateSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogUpdate& op, ObTableUpdateReturningSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogForUpdate& op, ObTableLockSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogForUpdate& op, ObMultiPartLockSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogInsert& op, ObTableInsertUpSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogInsert& op, ObMultiTableInsertUpSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogDelete& op, ObTableDeleteSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogDelete& op, ObTableDeleteReturningSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogDelete& op, ObMultiPartDeleteSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogInsert& op, ObTableReplaceSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogInsert& op, ObMultiTableReplaceSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogConflictRowFetcher& op, ObTableConflictRowFetcherSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogUpdate& op, ObMultiPartUpdateSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogTopk& op, ObTopKSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogSequence& op, ObSequenceSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogMonitoringDump& op, ObMonitoringDumpSpec& spec, const bool in_root_job);
|
|
|
|
// px code gen
|
|
int generate_spec(ObLogGranuleIterator& op, ObGranuleIteratorSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogExchange& op, ObPxFifoReceiveSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogExchange& op, ObPxMSReceiveSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogExchange& op, ObPxDistTransmitSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogExchange& op, ObPxRepartTransmitSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogExchange& op, ObPxReduceTransmitSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogExchange& op, ObPxFifoCoordSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogExchange& op, ObPxMSCoordSpec& spec, const bool in_root_job);
|
|
|
|
// for remote execute
|
|
int generate_spec(ObLogExchange& op, ObDirectTransmitSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogExchange& op, ObDirectReceiveSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogTableLookup& op, ObTableLookupSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogTableScan& op, ObMultiPartTableScanSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogWindowFunction& op, ObWindowFunctionSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogTableScan& op, ObRowSampleScanSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogTableScan& op, ObBlockSampleScanSpec& spec, const bool in_root_job);
|
|
|
|
int generate_spec(ObLogTableScan& op, ObTableScanWithIndexBackSpec& spec, const bool in_root_job);
|
|
// pdml code gen
|
|
int generate_spec(ObLogDelete& op, ObPxMultiPartDeleteSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogInsert& op, ObPxMultiPartInsertSpec& spec, const bool in_root_job);
|
|
int generate_spec(ObLogUpdate& op, ObPxMultiPartUpdateSpec& spec, const bool in_root_job);
|
|
|
|
private:
|
|
int convert_global_index_merge_info(ObLogMerge& op, const TableColumns& table_columns,
|
|
common::ObIArray<ObOpSpec*>& subplan_roots, ObTableDMLInfo& table_dml_info);
|
|
int generate_merge_subplan_access_exprs(const bool has_update_clause, const ObAssignments& assigns,
|
|
const ObIArray<ObColumnRefRawExpr*>& index_exprs, common::ObIArray<ObExpr*>& delete_access_exprs,
|
|
common::ObIArray<ObExpr*>& update_insert_access_exprs);
|
|
int generate_subplan_calc_exprs(const common::ObIArray<ObColumnRefRawExpr*>* table_columns,
|
|
const IndexDMLInfo& index_dml_info, ObGlobalIndexDMLInfo& phy_dml_info);
|
|
int convert_multi_table_insert_up_info(ObLogInsert& op, ObMultiTableInsertUpSpec& phy_op);
|
|
int convert_duplicate_key_scan_info(ObLogicalOperator* log_scan_op,
|
|
const common::ObIArray<ObRawExpr*>& table_column_exprs, ObRawExpr* calc_part_expr,
|
|
ObUniqueIndexScanInfo& scan_info);
|
|
int convert_duplicate_key_checker(ObLogDupKeyChecker& log_dupkey_checker, ObDuplicatedKeyChecker& phy_dupkey_checker);
|
|
int convert_multi_table_replace_info(ObLogInsert& op, ObMultiTableReplaceSpec& phy_op);
|
|
int convert_global_index_update_info(ObLogUpdate& op, const TableColumns& table_columns,
|
|
common::ObIArray<ObOpSpec*>& subplan_roots, ObTableDMLInfo& table_dml_info);
|
|
int convert_update_subplan(ObLogDelUpd& op, const IndexDMLInfo& index_dml_info, SeDMLSubPlan& dml_subplan);
|
|
int convert_for_update_subplan(
|
|
ObLogForUpdate& op, const uint64_t table_id, ObOpSpec*& subplan_root, ObTableDMLInfo& table_dml_info);
|
|
int generate_basic_transmit_spec(ObLogExchange& op, ObPxTransmitSpec& spec, const bool in_root_job);
|
|
int generate_basic_receive_spec(ObLogExchange& op, ObPxReceiveSpec& spec, const bool in_root_job);
|
|
int calc_equal_cond_opposite(const ObLogJoin& op, const ObRawExpr& raw_expr, bool& is_opposite);
|
|
int fill_sort_info(const ObIArray<OrderItem>& sort_keys, ObSortCollations& collations, ObIArray<ObExpr*>& sort_exprs);
|
|
int fill_sort_funcs(const ObSortCollations& collations, ObSortFuncs& sort_funcs, const ObIArray<ObExpr*>& sort_exprs);
|
|
int add_column_infos(
|
|
ObLogicalOperator& log_op, ObTableModifySpec& phy_op, const common::ObIArray<ObColumnRefRawExpr*>& columns);
|
|
int recursive_get_column_expr(const ObColumnRefRawExpr*& column, const TableItem& table_item);
|
|
int add_column_conv_infos(ObTableModifySpec& phy_op, const common::ObIArray<ObColumnRefRawExpr*>& columns,
|
|
const common::ObIArray<ObRawExpr*>& column_convert_exprs);
|
|
int add_table_column_ids(ObLogicalOperator& op, ObTableModifySpec* phy_op,
|
|
const common::ObIArray<ObColumnRefRawExpr*>& columns_ids, int64_t rowkey_cnt = 0);
|
|
|
|
template <typename T>
|
|
int convert_update_assignments(
|
|
const common::ObIArray<ObColumnRefRawExpr*>& all_columns, const ObAssignments& assigns, T& spec);
|
|
// build scan column ids for insert on duplicate update or merge into.
|
|
// they need fetch row from storage if row need to update.
|
|
// same with the build_update_source_row_desc
|
|
template <typename OP_SPEC>
|
|
int build_scan_column_ids(
|
|
ObLogicalOperator& op, const common::ObIArray<ObColumnRefRawExpr*>& all_columns, OP_SPEC& spec);
|
|
|
|
int convert_check_constraint(ObLogDelUpd& log_op, ObTableModifySpec& spec);
|
|
|
|
int convert_foreign_keys(ObLogDelUpd& log_op, ObTableModifySpec& spec);
|
|
int add_fk_arg_to_phy_op(ObForeignKeyArg& fk_arg, uint64_t name_table_id,
|
|
const common::ObIArray<uint64_t>& name_column_ids, const common::ObIArray<uint64_t>& value_column_ids,
|
|
share::schema::ObSchemaGetterGuard& schema_guard, ObTableModifySpec& spec);
|
|
int convert_table_dml_param(ObLogDelUpd& log_op, ObTableModifySpec& phy_op);
|
|
int fill_table_dml_param(
|
|
share::schema::ObSchemaGetterGuard* guard, const uint64_t table_id, ObTableModifySpec& phy_op);
|
|
int need_foreign_key_handle(const ObForeignKeyArg& fk_arg, const common::ObIArray<uint64_t>& value_column_ids,
|
|
const ObTableModifySpec& spec, bool& need_handle);
|
|
int fill_aggr_infos(ObLogGroupBy& op, ObGroupBySpec& spec, common::ObIArray<ObExpr*>* group_exprs = NULL,
|
|
common::ObIArray<ObExpr*>* rollup_exprs = NULL);
|
|
int fill_aggr_info(ObAggFunRawExpr& raw_expr, ObExpr& expr, ObAggrInfo& aggr_info);
|
|
int extract_non_aggr_expr(ObExpr* input, const ObRawExpr* raw_input, common::ObIArray<ObExpr*>& exist_in_child,
|
|
common::ObIArray<ObExpr*>& not_exist_in_aggr, common::ObIArray<ObExpr*>* not_exist_in_groupby,
|
|
common::ObIArray<ObExpr*>* not_exist_in_rollup, common::ObIArray<ObExpr*>& output) const;
|
|
|
|
int convert_insert_index_info(ObLogInsert& op, ObMultiPartInsertSpec& spec);
|
|
int convert_global_index_delete_info(ObLogDelUpd& op, const TableColumns& table_columns,
|
|
common::ObIArray<ObOpSpec*>& subplan_roots, ObTableDMLInfo& table_dml_info);
|
|
int convert_insert_subplan(ObLogDelUpd& op, const IndexDMLInfo& index_dml_info, SeDMLSubPlan& dml_subplan);
|
|
int convert_delete_subplan(ObLogDelUpd& op, const IndexDMLInfo& index_dml_info, SeDMLSubPlan& dml_subplan);
|
|
int convert_common_dml_subplan(ObLogDelUpd& op, ObPhyOperatorType phy_op_type, ObIArray<ObExpr*>& access_columns,
|
|
const IndexDMLInfo& index_dml_info, SeDMLSubPlan& dml_subplan);
|
|
int generate_exprs_replace_spk(const ObIArray<ObColumnRefRawExpr*>& index_exprs, ObIArray<ObExpr*>& access_exprs);
|
|
|
|
int generate_insert_subplan_access_exprs(const ObIArray<ObColumnRefRawExpr*>& index_exprs,
|
|
const ObIArray<ObColumnRefRawExpr*>& base_table_columns, const ObIArray<ObRawExpr*>& conv_columns,
|
|
ObIArray<ObExpr*>& access_exprs);
|
|
int generate_pdml_insert_exprs(const ObIArray<ObColumnRefRawExpr*>& index_exprs,
|
|
const ObIArray<ObRawExpr*>& index_dml_conv_columns, ObIArray<ObExpr*>& pdml_insert_exprs);
|
|
int generate_pdml_update_exprs(
|
|
const ObIArray<ObColumnRefRawExpr*>& index_exprs, const ObAssignments& assigns, ObPxMultiPartUpdateSpec& spec);
|
|
int convert_index_values(uint64_t table_id, ObIArray<ObExpr*>& output_exprs, ObOpSpec*& trs_spec);
|
|
|
|
int generate_delete_spec_common(ObLogDelete& op, ObTableDeleteSpec& spec, const bool in_root_job);
|
|
|
|
int fill_wf_info(ObIArray<ObExpr*>& all_expr, ObWinFunRawExpr& win_expr, WinFuncInfo& wf_info);
|
|
int fil_sort_info(const ObIArray<OrderItem>& sort_keys, ObIArray<ObExpr*>& all_exprs, ObIArray<ObExpr*>* sort_exprs,
|
|
ObSortCollations& sort_collations, ObSortFuncs& sort_cmp_funcs);
|
|
int get_pdml_partition_id_column_idx(const ObIArray<ObExpr*>& dml_exprs, int64_t& idx);
|
|
|
|
int do_gi_partition_pruning(ObLogJoin& op, ObBasicNestedLoopJoinSpec& spec);
|
|
|
|
int generate_hash_func_exprs(const common::ObIArray<ObExchangeInfo::HashExpr>& hash_dist_exprs,
|
|
ExprFixedArray& dist_exprs, common::ObHashFuncs& dist_hash_funcs);
|
|
|
|
private:
|
|
// all exprs of current operator
|
|
ObSEArray<ObRawExpr*, 8> cur_op_exprs_;
|
|
// all self_produced exprs of current operator
|
|
ObSEArray<ObRawExpr*, 8> cur_op_self_produced_exprs_;
|
|
common::ObSEArray<uint64_t, 10> fake_cte_tables_;
|
|
};
|
|
|
|
} // end namespace sql
|
|
} // end namespace oceanbase
|
|
|
|
#endif // OCEANBASE_SRC_OB_STATIC_ENGINE_CG_H_
|