database/openGauss-server
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d5337ceca74eebe7dacf8954039ce3dcceb0551d
openGauss-server/src/gausskernel/optimizer/path/allpaths.cpp
sqyyeah d5337ceca7 add materialized view feature to opengauss
2020-08-17 14:55:37 +08:00

3100 lines
114 KiB
C++
Executable File
Raw Blame History

/* -------------------------------------------------------------------------
*
* allpaths.cpp
* Routines to find possible search paths for processing a query
*
* Portions Copyright (c) 2020 Huawei Technologies Co.,Ltd.
* Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* src/gausskernel/optimizer/path/allpaths.cpp
*
* -------------------------------------------------------------------------
*/
#include "postgres.h"
#include "knl/knl_variable.h"
#include <math.h>
#include "catalog/pg_namespace.h"
#include "catalog/pg_class.h"
#include "catalog/pg_partition.h"
#include "catalog/pg_partition_fn.h"
#include "foreign/fdwapi.h"
#include "nodes/nodeFuncs.h"
#include "nodes/pg_list.h"
#ifdef OPTIMIZER_DEBUG
#include "nodes/print.h"
#endif
#include "optimizer/clauses.h"
#include "optimizer/cost.h"
#include "optimizer/dataskew.h"
#include "optimizer/geqo.h"
#include "optimizer/pathnode.h"
#include "optimizer/paths.h"
#include "optimizer/plancat.h"
#include "optimizer/planner.h"
#include "optimizer/prep.h"
#include "optimizer/pruning.h"
#include "optimizer/restrictinfo.h"
#include "optimizer/var.h"
#include "optimizer/streamplan.h"
#include "optimizer/optimizerdebug.h"
#include "optimizer/tlist.h"
#include "optimizer/bucketpruning.h"
#include "parser/parse_relation.h"
#include "parser/parse_clause.h"
#include "parser/parsetree.h"
#include "rewrite/rewriteManip.h"
#include "storage/bufmgr.h"
#include "utils/lsyscache.h"
#include "utils/selfuncs.h"
#include "pgxc/pgxc.h"
typedef struct IndexSizeInfo {
double pages;
double tuples;
} IndexSizeInfo;
static void set_base_rel_sizes(PlannerInfo* root);
static void set_base_rel_pathlists(PlannerInfo* root);
static void set_correlated_rel_pathlist(PlannerInfo* root, RelOptInfo* rel);
static void set_rel_pathlist(PlannerInfo* root, RelOptInfo* rel, Index rti, RangeTblEntry* rte);
static void set_plain_rel_size(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static void set_tablesample_rel_size(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static void set_plain_rel_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static void set_foreign_size(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static void set_foreign_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static void set_append_rel_size(PlannerInfo* root, RelOptInfo* rel, Index rti, RangeTblEntry* rte);
static void set_append_rel_pathlist(PlannerInfo* root, RelOptInfo* rel, Index rti, RangeTblEntry* rte);
static void generate_mergeappend_paths(
PlannerInfo* root, RelOptInfo* rel, List* live_childrels, List* all_child_pathkeys);
static List* accumulate_append_subpath(List* subpaths, Path* path);
static void set_dummy_rel_pathlist(RelOptInfo* rel);
static void set_subquery_pathlist(PlannerInfo* root, RelOptInfo* rel, Index rti, RangeTblEntry* rte);
static void set_function_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static void set_values_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static void set_cte_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static void set_worktable_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static RelOptInfo* make_rel_from_joinlist(PlannerInfo* root, List* joinlist);
static bool subquery_is_pushdown_safe(Query* subquery, Query* topquery, bool* unsafeColumns);
static bool recurse_pushdown_safe(Node* setOp, Query* topquery, bool* unsafeColumns);
static void check_output_expressions(Query* subquery, bool* unsafeColumns);
static void compare_tlist_datatypes(List* tlist, List* colTypes, bool* unsafeColumns);
static bool qual_is_pushdown_safe(Query* subquery, Index rti, Node* qual, const bool* unsafeColumns);
static void subquery_push_qual(Query* subquery, RangeTblEntry* rte, Index rti, Node* qual);
static void recurse_push_qual(Node* setOp, Query* topquery, RangeTblEntry* rte, Index rti, Node* qual);
static void try_add_partiterator(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte);
static void add_upperop_for_vecscan_expr(PlannerInfo* root, RelOptInfo* rel, List* quals);
static void passdown_itst_keys_to_rel(
PlannerInfo* root, RelOptInfo* brel, RangeTblEntry* rte, bool inherit_matching_key);
static void updateRelOptInfoMinSecurity(RelOptInfo* rel);
static void find_index_path(RelOptInfo* rel);
static void bitmap_path_walker(Path* path);
/*
* updateRelOptInfoMinSecurity:
* update baserestrict_min_security for RelOptInfo rel
* Paramters:
* @in rel: Per-relation information for planning/optimization
* @out void
*/
static void updateRelOptInfoMinSecurity(RelOptInfo* rel)
{
Assert(rel != NULL);
rel->baserestrict_min_security = UINT_MAX;
ListCell* lc = NULL;
RestrictInfo* info = NULL;
foreach (lc, rel->baserestrictinfo) {
info = (RestrictInfo*)lfirst(lc);
if (info->security_level < rel->baserestrict_min_security) {
rel->baserestrict_min_security = info->security_level;
}
}
}
/*
* make_one_rel
* Finds all possible access paths for executing a query, returning a
* single rel that represents the join of all base rels in the query.
*/
RelOptInfo* make_one_rel(PlannerInfo* root, List* joinlist)
{
RelOptInfo* rel = NULL;
int rti;
/* check if the parse only has one rel */
Relids rels = pull_varnos((Node*)root->dis_keys.matching_keys);
Index rtindex = 0;
int num_subq = 0;
bool has_nonjoin_op = root->parse->groupClause || root->parse->sortClause || root->parse->distinctClause;
if (bms_membership(rels) == BMS_SINGLETON)
rtindex = bms_first_member(rels);
bms_free_ext(rels);
/*
* Construct the all_baserels Relids set.
*/
root->all_baserels = NULL;
for (rti = 1; rti < root->simple_rel_array_size; rti++) {
RelOptInfo* brel = root->simple_rel_array[rti];
/* there may be empty slots corresponding to non-baserel RTEs */
if (brel == NULL)
continue;
AssertEreport(brel->relid == (uint)rti, MOD_OPT, ""); /* sanity check on array */
if (IS_STREAM_PLAN)
passdown_itst_keys_to_rel(root, brel, root->simple_rte_array[rti], ((Index)rti == rtindex));
/* ignore RTEs that are "other rels" */
if (brel->reloptkind != RELOPT_BASEREL)
continue;
root->all_baserels = bms_add_member(root->all_baserels, brel->relid);
/* Record how many subqueries in current query level */
if (root->glob->minopmem > 0 && root->simple_rte_array[rti]->rtekind == RTE_SUBQUERY)
num_subq++;
/* Add subplan clause to rel's subplan restriction list */
if (IS_STREAM_PLAN && root->is_correlated &&
(GetLocatorType(root->simple_rte_array[rti]->relid) != LOCATOR_TYPE_REPLICATED ||
ng_is_multiple_nodegroup_scenario())) {
ListCell* lc = NULL;
List *restrictinfo = brel->baserestrictinfo;
List *tmp_info = NIL;
foreach (lc, brel->baserestrictinfo) {
RestrictInfo* info = (RestrictInfo*)lfirst(lc);
/* if clause has subplan expr, keep it in subplan restrictinfo list */
if (check_param_clause((Node*)info->clause)) {
brel->subplanrestrictinfo = lappend(brel->subplanrestrictinfo, info->clause);
tmp_info = lappend(tmp_info, info);
}
}
/* remove subplan restrictinfo from orig list */
if (brel->subplanrestrictinfo != NIL) {
brel->baserestrictinfo = list_difference(brel->baserestrictinfo, tmp_info);
updateRelOptInfoMinSecurity(brel);
list_free_ext(restrictinfo);
list_free_ext(tmp_info);
}
}
}
/*
* Generate access paths for the base rels.
*/
int work_mem_orig = u_sess->opt_cxt.op_work_mem;
int esti_op_mem_orig = root->glob->estiopmem;
/* For subquery scan plan, we should adjust available work_mem */
if (root->glob->minopmem > 0) {
if (has_nonjoin_op && num_subq == 1) {
num_subq = 2;
}
root->glob->estiopmem = root->glob->estiopmem / (num_subq > 1 ? num_subq : 1);
root->glob->estiopmem = Max(root->glob->estiopmem, root->glob->minopmem);
u_sess->opt_cxt.op_work_mem = Min(root->glob->estiopmem, OPT_MAX_OP_MEM);
Assert(u_sess->opt_cxt.op_work_mem > 0);
}
set_base_rel_sizes(root);
/* For correlated subquery scan plan, we should adjust available work_mem */
u_sess->opt_cxt.op_work_mem = work_mem_orig;
root->glob->estiopmem = esti_op_mem_orig;
if (root->is_correlated && root->glob->minopmem > 0) {
int num_rel = bms_num_members(root->all_baserels);
if (num_rel <= 1) {
if (has_nonjoin_op) {
num_rel = 2;
} else {
num_rel = 1;
}
}
root->glob->estiopmem =
(int)Max((double)root->glob->minopmem, (double)root->glob->estiopmem / ceil(LOG2(num_rel + 1)));
u_sess->opt_cxt.op_work_mem = Min(root->glob->estiopmem, OPT_MAX_OP_MEM);
Assert(u_sess->opt_cxt.op_work_mem > 0);
}
set_base_rel_pathlists(root);
u_sess->opt_cxt.op_work_mem = work_mem_orig;
root->glob->estiopmem = esti_op_mem_orig;
/*
* Generate access paths for the entire join tree.
*/
rel = make_rel_from_joinlist(root, joinlist);
/*
* The result should join all and only the query's base rels.
*/
AssertEreport(bms_equal(rel->relids, root->all_baserels), MOD_OPT, "");
return rel;
}
/*
* set_base_rel_sizes
* Set the size estimates (rows and widths) for each base-relation entry.
*
* We do this in a separate pass over the base rels so that rowcount
* estimates are available for parameterized path generation.
*/
static void set_base_rel_sizes(PlannerInfo* root)
{
int rti;
for (rti = 1; rti < root->simple_rel_array_size; rti++) {
RelOptInfo* rel = root->simple_rel_array[rti];
/* there may be empty slots corresponding to non-baserel RTEs */
if (rel == NULL)
continue;
AssertEreport(rel->relid == (uint)rti, MOD_OPT, ""); /* sanity check on array */
/* ignore RTEs that are "other rels" */
if (rel->reloptkind != RELOPT_BASEREL)
continue;
set_rel_size(root, rel, (Index)rti, root->simple_rte_array[rti]);
/* Try inlist2join optimization */
inlist2join_qrw_optimization(root, rti);
}
}
/*
* set_correlated_rel_pathlist
* If current rel is correated with a recursive CTE, we need add broadcast operator
* to move all recursive relevant rels to one datanode, and recursive execution is
* processed there
*/
static void set_correlated_rel_pathlist(PlannerInfo* root, RelOptInfo* rel)
{
/* do nothing in case of none-stream plan for RecursiveUnion */
if (!STREAM_RECURSIVECTE_SUPPORTED) {
return;
}
Path* pathnode = NULL;
StreamPath* stream_path = NULL;
Distribution* target_distribution = NULL;
ListCell* lc = NULL;
ListCell* lc1 = NULL;
/* Loop each available pathnode to add stream(BroadCast) on top of it */
foreach (lc, rel->pathlist) {
pathnode = (Path*)lfirst(lc);
Assert(pathnode->dop <= 1);
/* no need to add stream(BroadCast) for replication table */
if (IsLocatorReplicated(pathnode->locator_type) || pathnode->param_info != NULL)
continue;
target_distribution = ng_get_correlated_subplan_group_distribution();
stream_path =
(StreamPath*)create_stream_path(root, rel, STREAM_BROADCAST, NIL, NIL, pathnode, 1.0, target_distribution);
/*
* Change the value of path in the pathlist file to avoid inconsistency
* between the values of chepeast_startup_path and cheepest_total_path.
*/
lfirst(lc) = stream_path;
/* Reset cheapeast total path */
foreach (lc1, rel->cheapest_total_path) {
if (pathnode == lfirst(lc1)) {
lfirst(lc1) = stream_path;
break;
}
}
/* Reset cheapeast startup path for current rel */
if (pathnode == rel->cheapest_startup_path) {
rel->cheapest_startup_path = (Path*)stream_path;
}
}
rel->cheapest_unique_path = NULL;
rel->cheapest_parameterized_paths = NIL;
return;
}
/*
* set_base_rel_pathlists
* Finds all paths available for scanning each base-relation entry.
* Sequential scan and any available indices are considered.
* Each useful path is attached to its relation's 'pathlist' field.
*/
static void set_base_rel_pathlists(PlannerInfo* root)
{
int rti;
for (rti = 1; rti < root->simple_rel_array_size; rti++) {
RelOptInfo* rel = root->simple_rel_array[rti];
RangeTblEntry* rte = root->simple_rte_array[rti];
/* there may be empty slots corresponding to non-baserel RTEs */
if (rel == NULL)
continue;
AssertEreport(rel->relid == (uint)rti, MOD_OPT, ""); /* sanity check on array */
/* ignore RTEs that are "other rels" */
if (rel->reloptkind != RELOPT_BASEREL)
continue;
set_rel_pathlist(root, rel, rti, root->simple_rte_array[rti]);
/*
* Set outer rel replicated in case of Recursive CTE is corerlated with an
* outer rel.
*/
if (STREAM_RECURSIVECTE_SUPPORTED && rte->correlated_with_recursive_cte && root->is_under_recursive_cte) {
root->has_recursive_correlated_rte = true;
set_correlated_rel_pathlist(root, rel);
}
/* For subplan, we should make the base table replicated, and add filter to the temporary result */
if (IS_STREAM_PLAN && root->is_correlated &&
(GetLocatorType(rte->relid) != LOCATOR_TYPE_REPLICATED || ng_is_multiple_nodegroup_scenario())) {
ListCell* lc = NULL;
ListCell* lc2 = NULL;
bool is_cheapest_startup = false;
Path* subpath = NULL;
foreach (lc, rel->pathlist) {
Path* path = (Path*)lfirst(lc);
if (path->param_info)
continue;
/* Save the path if it is cheapest startup path. */
if (path == rel->cheapest_startup_path)
is_cheapest_startup = true;
/* Save the path if it is cheapest total path. */
foreach (lc2, rel->cheapest_total_path) {
if (path == lfirst(lc2))
break;
}
Distribution* distribution = ng_get_dest_distribution(path);
Distribution* target_distribution = ng_get_correlated_subplan_group_distribution();
/*
* add broadcast node for subplan since it can be execute on each dn node
* we need to broadcast data to a "correlated subplan group",
* where we could definitely get a replicated data from subplan's user
* we need to add broadcast in two cases:
* (1) not a replicated path
* (2) path not located in the "correlated subplan group"
* but when the rel->subplan is single baseresult plan node, we no need do
* this.
*/
if ((!IsLocatorReplicated(path->locator_type) ||
!ng_is_same_group(distribution, target_distribution)) &&
(!is_single_baseresult_plan(rel->subplan))) {
Cost rescan_startup_cost;
Cost rescan_total_cost;
subpath = create_stream_path(root, rel, STREAM_BROADCAST, NIL, NIL, path, 1.0, target_distribution);
subpath = (Path*)create_material_path(subpath, true);
/* Record materialize mem info */
cost_rescan(
root, subpath, &rescan_startup_cost, &rescan_total_cost, &((MaterialPath*)subpath)->mem_info);
((MaterialPath*)subpath)->mem_info.regressCost *= DEFAULT_NUM_ROWS;
} else {
ContainStreamContext context;
bool need_material = false;
/*
* try to add material path if the path contains stream to
* avoid rescan stream operator. Cstore indexscan with delta
* doest not support rescan either.
*/
context.outer_relids = NULL;
context.only_check_stream = true;
context.under_materialize_all = false;
context.has_stream = false;
context.has_parameterized_path = false;
context.has_cstore_index_delta = false;
stream_path_walker(path, &context);
need_material = context.has_stream || context.has_cstore_index_delta;
if (need_material == false && rte->rtekind == RTE_CTE && /* just for rte */
rte->self_reference == false && rte->correlated_with_recursive_cte == false &&
check_param_clause((Node*)rel->subplanrestrictinfo)) {
/*
* try to add material path to avoid rescan CTE node if
* 1. RTE contains correlated restrictinfo
* 2. subquery under CTE is not correlated
*/
need_material = true;
}
subpath = path;
if (need_material) {
Cost rescan_startup_cost;
Cost rescan_total_cost;
subpath = (Path*)create_material_path(path, true);
/* Record materialize mem info */
cost_rescan(root,
subpath,
&rescan_startup_cost,
&rescan_total_cost,
&((MaterialPath*)subpath)->mem_info);
((MaterialPath*)subpath)->mem_info.regressCost *= DEFAULT_NUM_ROWS;
}
}
/* if there's subplan filter, add it above broadcast node */
if (rel->subplanrestrictinfo != NIL) {
subpath = (Path*)create_result_path(rel->subplanrestrictinfo, subpath);
}
if (subpath != path) {
if (lc2 != NULL)
lfirst(lc2) = subpath;
/* Set cheapest startup path as boardcast+material+path */
if (is_cheapest_startup)
rel->cheapest_startup_path = subpath;
lfirst(lc) = subpath;
}
is_cheapest_startup = false;
}
rel->cheapest_unique_path = NULL;
rel->cheapest_parameterized_paths = NIL;
}
}
}
/*
* set_rel_size
* Set size estimates for a base relation
*/
void set_rel_size(PlannerInfo* root, RelOptInfo* rel, Index rti, RangeTblEntry* rte)
{
if (rel->reloptkind == RELOPT_BASEREL && relation_excluded_by_constraints(root, rel, rte)) {
/*
* We proved we don't need to scan the rel via constraint exclusion,
* so set up a single dummy path for it. Here we only check this for
* regular baserels; if it's an otherrel, CE was already checked
* in set_append_rel_size().
*
* In this case, we go ahead and set up the relation's path right away
* instead of leaving it for set_rel_pathlist to do. This is because
* we don't have a convention for marking a rel as dummy except by
* assigning a dummy path to it.
*/
set_dummy_rel_pathlist(rel);
} else if (rte->inh) {
/* It's an "append relation", process accordingly */
set_append_rel_size(root, rel, rti, rte);
} else {
switch (rel->rtekind) {
case RTE_RELATION:
if (rte->relkind == RELKIND_FOREIGN_TABLE) {
/* Foreign table */
set_foreign_size(root, rel, rte);
} else {
/* Plain relation */
set_plain_rel_size(root, rel, rte);
}
break;
case RTE_SUBQUERY:
/*
* Subqueries don't support parameterized paths, so just go
* ahead and build their paths immediately.
*/
set_subquery_pathlist(root, rel, rti, rte);
break;
case RTE_FUNCTION:
set_function_size_estimates(root, rel);
break;
case RTE_VALUES:
set_values_size_estimates(root, rel);
break;
case RTE_CTE:
/*
* CTEs don't support parameterized paths, so just go ahead
* and build their paths immediately.
*/
if (rte->self_reference)
set_worktable_pathlist(root, rel, rte);
else
set_cte_pathlist(root, rel, rte);
break;
default:
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE),
(errmsg("unexpected rtekind: %d when set relation size", (int)rel->rtekind))));
break;
}
}
/* We already apply row hint of subquery before create path of subquery */
if (rel->rtekind != RTE_SUBQUERY)
adjust_rows_according_to_hint(root->parse->hintState, rel);
/*
* We insist that all non-dummy rels have a nonzero rowcount estimate.
*/
if (rel->base_rel != NULL) {
Assert(rel->base_rel->rows > 0 || IS_DUMMY_REL(rel->base_rel));
if (unlikely(!(rel->base_rel->rows > 0 || IS_DUMMY_REL(rel->base_rel))))
ereport(ERROR,
(errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
errmodule(MOD_OPT),
errmsg("failed on assertion in %s line %d : %s",
__FILE__,
__LINE__,
"the inlist2join's base relation is not dummy and the relation's rows is not greater than "
"0.")));
} else {
Assert(rel->rows > 0 || IS_DUMMY_REL(rel));
if (unlikely(!(rel->rows > 0 || IS_DUMMY_REL(rel))))
ereport(ERROR,
(errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
errmodule(MOD_OPT),
errmsg("failed on assertion in %s line %d : %s",
__FILE__,
__LINE__,
"the relation is not dummy and the relation's row is not greater than 0.")));
}
}
/*
* set_rel_pathlist
* Build access paths for a base relation
*/
static void set_rel_pathlist(PlannerInfo* root, RelOptInfo* rel, Index rti, RangeTblEntry* rte)
{
if (IS_DUMMY_REL(rel)) {
/* We already proved the relation empty, so nothing more to do */
} else if (rte->inh) {
/* It's an "append relation", process accordingly */
set_append_rel_pathlist(root, rel, rti, rte);
} else {
switch (rel->rtekind) {
case RTE_RELATION:
/*
* If the rel can apply inlist2join and the guc qrw_inlist2join_optmode=rule_base
* So we can just convert inlist to join, there is no need to genenate other paths
*/
if (rel->alternatives && u_sess->opt_cxt.qrw_inlist2join_optmode > QRW_INLIST2JOIN_CBO) {
set_cheapest(rel);
break;
}
if (rte->relkind == RELKIND_FOREIGN_TABLE) {
/* Foreign table */
set_foreign_pathlist(root, rel, rte);
} else {
/* Plain relation */
set_plain_rel_pathlist(root, rel, rte);
}
break;
case RTE_SUBQUERY:
/* Subquery --- fully handled during set_rel_size */
if (rel->alternatives != NIL) {
if (u_sess->opt_cxt.qrw_inlist2join_optmode > QRW_INLIST2JOIN_CBO) {
Path* pathnode = ((Path*)lsecond(rel->pathlist));
rel->pathlist = NIL;
/* no need to do add_path, because do it in set_subquery_pathlist */
rel->pathlist = lappend(rel->pathlist, pathnode);
}
set_cheapest(rel);
}
break;
case RTE_FUNCTION:
/* RangeFunction */
set_function_pathlist(root, rel, rte);
break;
case RTE_VALUES:
/* Values list */
set_values_pathlist(root, rel, rte);
break;
case RTE_CTE:
/* CTE reference --- fully handled during set_rel_size */
break;
default:
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE),
(errmsg("unexpected rtekind when set relation path list: %d", (int)rel->rtekind))));
break;
}
}
debug1_print_rel(root, rel);
#ifdef OPTIMIZER_DEBUG
debug_print_rel(root, rel);
#endif
}
static void SetPlainReSizeWithPruningRatio(RelOptInfo *rel, double pruningRatio)
{
ListCell *cell = NULL;
IndexOptInfo *index = NULL;
Assert(rel->isPartitionedTable);
rel->pages = clamp_row_est(rel->pages * pruningRatio);
foreach (cell, rel->indexlist){
index = (IndexOptInfo *) lfirst(cell);
index->pages = clamp_row_est(index->pages * pruningRatio);
}
}
/*
* set_plain_rel_size
* Set size estimates for a plain relation (no subquery, no inheritance)
*/
static void set_plain_rel_size(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
set_rel_bucketinfo(root, rel, rte);
if (rte->ispartrel) {
Relation relation = heap_open(rte->relid, NoLock);
double pruningRatio = 1.0;
/* get pruning result */
if (rte->isContainPartition) {
rel->pruning_result = singlePartitionPruningForRestrictInfo(rte->partitionOid, relation);
} else {
rel->pruning_result = partitionPruningForRestrictInfo(root, rte, relation, rel->baserestrictinfo);
}
Assert(rel->pruning_result);
/* set flag for dealing with partintioned table */
rel->partItrs = bms_num_members(rel->pruning_result->bm_rangeSelectedPartitions) +
bms_num_members(rel->pruning_result->intervalSelectedPartitions);
if (relation->partMap != NULL && PartitionMapIsRange(relation->partMap)) {
RangePartitionMap *partMmap = (RangePartitionMap *)relation->partMap;
pruningRatio = (double)rel->partItrs / partMmap->rangeElementsNum;
}
heap_close(relation, NoLock);
/*
* refresh pages/tuples since executor will skip some page
* scan with pruning info
*/
SetPlainReSizeWithPruningRatio(rel, pruningRatio);
}
/*
* Test any partial indexes of rel for applicability. We must do this
* first since partial unique indexes can affect size estimates.
*/
check_partial_indexes(root, rel);
if (rte->tablesample == NULL) {
/* Mark rel with estimated output rows, width, etc */
set_baserel_size_estimates(root, rel);
/*
* Check to see if we can extract any restriction conditions from join
* quals that are OR-of-AND structures. If so, add them to the rel's
* restriction list, and redo the above steps.
*/
if (create_or_index_quals(root, rel)) {
check_partial_indexes(root, rel);
set_baserel_size_estimates(root, rel);
}
} else {
/* Sampled relation */
set_tablesample_rel_size(root, rel, rte);
}
}
/*
* Description: Set size estimates for a sampled relation.
*
* Parameters:
* @in root: plannerinfo struct for current query level.
* @in rel: Per-relation information for planning/optimization.
* @in rte: range table
*
* Return: void
*/
static void set_tablesample_rel_size(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
TableSampleClause* tsc = rte->tablesample;
/*
* Call the sampling method's estimation function to estimate the number
* of pages it will read and the number of tuples it will return. (Note:
* we assume the function returns sane values.)
*/
if (tsc->sampleType == SYSTEM_SAMPLE) {
system_samplescangetsamplesize(root, rel, tsc->args);
} else if (tsc->sampleType == BERNOULLI_SAMPLE) {
bernoulli_samplescangetsamplesize(root, rel, tsc->args);
} else {
AssertEreport(tsc->sampleType == HYBRID_SAMPLE, MOD_OPT, "");
hybrid_samplescangetsamplesize(root, rel, tsc->args);
}
/* Mark rel with estimated output rows, width, etc */
set_baserel_size_estimates(root, rel);
}
/*
* find_index_path
* bitmap_path_walker
*
* search corresponding index path for index col in g_index_vars from
* all optional paths. If index path found, set indexpath of var to
* true in g_index_vars.
*/
static void find_index_path(RelOptInfo* rel)
{
ListCell* lc = NULL;
foreach (lc, rel->pathlist) {
Path* path = (Path*)lfirst(lc);
if (path == NULL)
continue;
bitmap_path_walker(path);
}
}
static void bitmap_path_walker(Path* path)
{
ListCell* lc = NULL;
if (IsA(path, BitmapHeapPath)) {
BitmapHeapPath* bhpath = (BitmapHeapPath*)path;
bitmap_path_walker(bhpath->bitmapqual);
} else if (IsA(path, BitmapAndPath) || IsA(path, BitmapOrPath)) {
BitmapAndPath* bapath = (BitmapAndPath*)path;
foreach (lc, bapath->bitmapquals) {
Path* sub_path = (Path*)lfirst(lc);
bitmap_path_walker(sub_path);
}
} else if (IsA(path, IndexPath)) {
IndexPath* indexpath = (IndexPath*)path;
foreach (lc, g_index_vars) {
IndexVar* var = (IndexVar*)lfirst(lc);
if (list_member_oid(var->indexoids, indexpath->indexinfo->indexoid))
var->indexpath = true;
}
} else
return;
}
/*
* set_plain_rel_pathlist
* Build access paths for a plain relation (no subquery, no inheritance)
*/
static void set_plain_rel_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
List* baserestrictinfo = NIL;
List* quals = NIL;
bool has_vecengine_unsupport_expr = false;
ListCell* lc = NULL;
#ifdef PGXC
bool isrp = create_plainrel_rqpath(root, rel, rte);
/*
* We do not parallel the scan of replicate table
* since they are always small table. And we do not
* support normal row table unless it is partitioned.
* The partition table can be parallelized when partItrs > u_sess->opt_cxt.query_dop.
*/
bool can_parallel = IS_STREAM_PLAN && (u_sess->opt_cxt.query_dop > 1) &&
(rel->locator_type != LOCATOR_TYPE_REPLICATED) && (rte->tablesample == NULL);
if (!isrp) {
#endif
switch (rel->orientation) {
/*
* We do not parallel the scan of replicate table
* since they are always small table. And we do not
* support normal row table unless it is partitioned.
* The partition table can be parallelized when partItrs > u_sess->opt_cxt.query_dop.
*/
case REL_COL_ORIENTED:
case REL_PAX_ORIENTED:
case REL_TIMESERIES_ORIENTED: {
/*
* Check there is vector engine unsupport expression in rel->baserestrictinfo
* If find, pull up them to resultpath->pathqual
* Else remain it on rel->baserestrictinfo
*/
if (rel->baserestrictinfo != NIL) {
baserestrictinfo = rel->baserestrictinfo;
rel->baserestrictinfo = NULL;
foreach (lc, baserestrictinfo) {
RestrictInfo* restrict = (RestrictInfo*)lfirst(lc);
if (vector_engine_unsupport_expression_walker((Node*)restrict->clause)) {
/*
* If we find any vector engine unsupport expression
*/
has_vecengine_unsupport_expr = true;
quals = lappend(quals, restrict->clause);
} else
rel->baserestrictinfo = lappend(rel->baserestrictinfo, restrict);
}
}
if (vector_engine_unsupport_expression_walker((Node*)rel->reltargetlist))
has_vecengine_unsupport_expr = true;
if (rel->orientation == REL_TIMESERIES_ORIENTED) {
add_path(root, rel, create_tsstorescan_path(root, rel));
if (can_parallel)
add_path(root, rel, create_tsstorescan_path(root, rel, u_sess->opt_cxt.query_dop));
} else {
add_path(root, rel, create_cstorescan_path(root, rel));
if (can_parallel)
add_path(root, rel, create_cstorescan_path(root, rel, u_sess->opt_cxt.query_dop));
}
break;
}
case REL_ROW_ORIENTED: {
add_path(root, rel, create_seqscan_path(root, rel, NULL));
if (can_parallel)
add_path(root, rel, create_seqscan_path(root, rel, NULL, u_sess->opt_cxt.query_dop));
break;
}
default: {
ereport(ERROR,
(errmodule(MOD_OPT), errcode(ERRCODE_CASE_NOT_FOUND), errmsg("All orientations are not covered.")));
break;
}
}
/* Tablesample don't support indexscan and tidscan. */
if (rte->tablesample == NULL) {
/* Consider index scans */
create_index_paths(root, rel);
/*
* Consider TID scans
* Since former TidScan is not fit for column store table, just create
* TidScan path for row store table
*/
if (rel->orientation == REL_ROW_ORIENTED)
create_tidscan_paths(root, rel);
}
#ifdef PGXC
} else {
Oid relId = rte->relid;
Relation relation = RelationIdGetRelation(relId);
if (!RelationIsValid(relation)) {
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("could not open relation with OID %u", relId)));
}
if (RelationIsDfsStore(relation)) {
rte->inh = true;
}
RelationClose(relation);
}
#endif
/* Now find the cheapest of the paths for this rel */
set_cheapest(rel);
/* Consider partition's path for partitioned table */
#ifdef PGXC
if (!isrp)
#endif
try_add_partiterator(root, rel, rte);
if (has_vecengine_unsupport_expr) {
/*
* Cstorescan path has unsupport expression in vector engine,
* Add result operator to handle it
*/
add_upperop_for_vecscan_expr(root, rel, quals);
}
if ((rel->orientation == REL_ROW_ORIENTED || rel->orientation == REL_COL_ORIENTED) &&
enable_check_implicit_cast()) {
find_index_path(rel);
}
}
/*
* Description:add result operator over scan operator. And add
* vector type scan's qual with unsupport expression in vector engine
* to result operator
*
* Parameters:
* @in root: plannerinfo struct for current query level.
* @in rel: Per-relation information for planning/optimization.
* @in quals: filter condition
*
* Return: void
*/
static void add_upperop_for_vecscan_expr(PlannerInfo* root, RelOptInfo* rel, List* quals)
{
ListCell* pathCell = NULL;
foreach (pathCell, rel->pathlist) {
Path* path = (Path*)lfirst(pathCell);
Path* resPath = NULL;
ListCell* ctPathCell = NULL;
ListCell* cpPathCell = NULL;
resPath = (Path*)create_result_path(quals, path);
((ResultPath*)resPath)->ispulledupqual = true;
/* replace entry in pathlist */
lfirst(pathCell) = resPath;
if (path == rel->cheapest_startup_path) {
/* replace cheapest_startup_path */
rel->cheapest_startup_path = resPath;
}
if (path == rel->cheapest_unique_path) {
/* replace cheapest_unique_path */
rel->cheapest_unique_path = resPath;
}
/* replace entry in cheapest_total_path */
foreach (ctPathCell, rel->cheapest_total_path) {
if (lfirst(ctPathCell) == path) {
lfirst(ctPathCell) = resPath;
break;
}
}
/* replace entry in cheapest_parameterized_paths */
foreach (cpPathCell, rel->cheapest_parameterized_paths) {
/* we add cheapest total into cheapest_parameterized_paths in set_cheapest */
if (lfirst(cpPathCell) == path) {
lfirst(cpPathCell) = resPath;
break;
}
}
}
}
/*
* set_foreign_size
* Set size estimates for a foreign table RTE
*/
static void set_foreign_size(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
/* Mark rel with estimated output rows, width, etc */
set_foreign_size_estimates(root, rel);
AssertEreport(rel->fdwroutine, MOD_OPT, "");
/* Let FDW adjust the size estimates, if it can */
rel->fdwroutine->GetForeignRelSize(root, rel, rte->relid);
/* ... but do not let it set the rows estimate to zero */
rel->rows = clamp_row_est(rel->rows);
}
/*
* set_foreign_pathlist
* Build access paths for a foreign table RTE
*/
static void set_foreign_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
bool isrp = false;
/*
* If the query dose not support stream and the distribution type of foreign table
* is replication or roundrobin, the query can send remotequery to datanode.
*/
if (!IS_STREAM) {
isrp = create_plainrel_rqpath(root, rel, rte);
}
if (!isrp && rel->fdwroutine->GetFdwType && rel->fdwroutine->GetFdwType() == MOT_ORC) {
/* Consider index scans */
create_index_paths(root, rel);
if (rel->orientation == REL_ROW_ORIENTED)
create_tidscan_paths(root, rel);
}
if (!isrp) {
/* Call the FDW's GetForeignPaths function to generate path(s) */
rel->fdwroutine->GetForeignPaths(root, rel, rte->relid);
}
/* Select cheapest path */
if (!(rel->fdwroutine->GetFdwType && rel->fdwroutine->GetFdwType() == MOT_ORC) || isrp)
set_cheapest(rel);
}
/*
* set_append_rel_size
* Set size estimates for an "append relation"
*
* The passed-in rel and RTE represent the entire append relation. The
* relation's contents are computed by appending together the output of
* the individual member relations. Note that in the inheritance case,
* the first member relation is actually the same table as is mentioned in
* the parent RTE ... but it has a different RTE and RelOptInfo. This is
* a good thing because their outputs are not the same size.
*/
static void set_append_rel_size(PlannerInfo* root, RelOptInfo* rel, Index rti, RangeTblEntry* rte)
{
Index parentRTindex = rti;
bool has_live_children = false;
double parent_rows = 0;
double parent_global_rows = 0;
double parent_tuples = 0;
double parent_global_tuples = 0;
double parent_size = 0;
double* parent_attrsizes = NULL;
int nattrs;
ListCell* l = NULL;
/*
* Initialize to compute size estimates for whole append relation.
*
* We handle width estimates by weighting the widths of different child
* rels proportionally to their number of rows. This is sensible because
* the use of width estimates is mainly to compute the total relation
* "footprint" if we have to sort or hash it. To do this, we sum the
* total equivalent size (in "double" arithmetic) and then divide by the
* total rowcount estimate. This is done separately for the total rel
* width and each attribute.
*
* Note: if you consider changing this logic, beware that child rels could
* have zero rows and/or width, if they were excluded by constraints.
*/
nattrs = rel->max_attr - rel->min_attr + 1;
parent_attrsizes = (double*)palloc0(nattrs * sizeof(double));
foreach (l, root->append_rel_list) {
AppendRelInfo* appinfo = (AppendRelInfo*)lfirst(l);
Index childRTindex;
RangeTblEntry* childRTE = NULL;
RelOptInfo* childrel = NULL;
List* childquals = NIL;
Node* childqual = NULL;
ListCell* parentvars = NULL;
ListCell* childvars = NULL;
/* append_rel_list contains all append rels; ignore others */
if (appinfo->parent_relid != parentRTindex)
continue;
childRTindex = appinfo->child_relid;
childRTE = root->simple_rte_array[childRTindex];
/*
* The child rel's RelOptInfo was already created during
* add_base_rels_to_query.
*/
childrel = find_base_rel(root, childRTindex);
AssertEreport(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL, MOD_OPT, "");
/*
* We have to copy the parent's targetlist and quals to the child,
* with appropriate substitution of variables. However, only the
* baserestrictinfo quals are needed before we can check for
* constraint exclusion; so do that first and then check to see if we
* can disregard this child.
*
* As of 8.4, the child rel's targetlist might contain non-Var
* expressions, which means that substitution into the quals could
* produce opportunities for const-simplification, and perhaps even
* pseudoconstant quals. To deal with this, we strip the RestrictInfo
* nodes, do the substitution, do const-simplification, and then
* reconstitute the RestrictInfo layer.
*/
childquals = get_all_actual_clauses(rel->baserestrictinfo);
childquals = (List*)adjust_appendrel_attrs(root, (Node*)childquals, appinfo);
childqual = eval_const_expressions(root, (Node*)make_ands_explicit(childquals));
if (childqual && IsA(childqual, Const) &&
(((Const*)childqual)->constisnull || !DatumGetBool(((Const*)childqual)->constvalue))) {
/*
* Restriction reduces to constant FALSE or constant NULL after
* substitution, so this child need not be scanned.
*/
set_dummy_rel_pathlist(childrel);
continue;
}
childquals = make_ands_implicit((Expr*)childqual);
childquals = make_restrictinfos_from_actual_clauses(root, childquals);
childrel->baserestrictinfo = childquals;
if (relation_excluded_by_constraints(root, childrel, childRTE)) {
/*
* This child need not be scanned, so we can omit it from the
* appendrel.
*/
set_dummy_rel_pathlist(childrel);
continue;
}
/*
* CE failed, so finish copying/modifying targetlist and join quals.
*
* Note: the resulting childrel->reltargetlist may contain arbitrary
* expressions, which normally would not occur in a reltargetlist.
* That is okay because nothing outside of this routine will look at
* the child rel's reltargetlist. We do have to cope with the case
* while constructing attr_widths estimates below, though.
*/
childrel->joininfo = (List*)adjust_appendrel_attrs(root, (Node*)rel->joininfo, appinfo);
childrel->reltargetlist = (List*)adjust_appendrel_attrs(root, (Node*)rel->reltargetlist, appinfo);
/*
* When childrel's targetlist got changed, we should adjust itersting
* keys accrodingly
*/
if (childRTE->subquery != NULL) {
Assert(list_length(childrel->reltargetlist) == list_length(rel->reltargetlist));
childrel->rel_dis_keys.matching_keys =
(List*)replace_node_clause((Node*)childrel->rel_dis_keys.matching_keys,
(Node*)rel->reltargetlist,
(Node*)childrel->reltargetlist,
RNC_COPY_NON_LEAF_NODES);
childrel->rel_dis_keys.superset_keys =
(List*)replace_node_clause((Node*)childrel->rel_dis_keys.superset_keys,
(Node*)rel->reltargetlist,
(Node*)childrel->reltargetlist,
RNC_COPY_NON_LEAF_NODES);
}
/*
* We have to make child entries in the EquivalenceClass data
* structures as well. This is needed either if the parent
* participates in some eclass joins (because we will want to consider
* inner-indexscan joins on the individual children) or if the parent
* has useful pathkeys (because we should try to build MergeAppend
* paths that produce those sort orderings).
*/
if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
add_child_rel_equivalences(root, appinfo, rel, childrel);
childrel->has_eclass_joins = rel->has_eclass_joins;
/*
* Note: we could compute appropriate attr_needed data for the child's
* variables, by transforming the parent's attr_needed through the
* translated_vars mapping. However, currently there's no need
* because attr_needed is only examined for base relations not
* otherrels. So we just leave the child's attr_needed empty.
*/
/*
* Compute the child's size.
*/
set_rel_size(root, childrel, childRTindex, childRTE);
/*
* It is possible that constraint exclusion detected a contradiction
* within a child subquery, even though we didn't prove one above. If
* so, we can skip this child.
*/
if (IS_DUMMY_REL(childrel))
continue;
has_live_children = true;
/*
* Accumulate size information from each live child.
*/
Assert(childrel->rows > 0);
parent_rows += RELOPTINFO_LOCAL_FIELD(root, childrel, rows);
parent_global_rows += childrel->rows;
parent_tuples += RELOPTINFO_LOCAL_FIELD(root, childrel, tuples);
parent_global_tuples += childrel->tuples;
parent_size += childrel->width * RELOPTINFO_LOCAL_FIELD(root, childrel, rows);
/*
* Accumulate per-column estimates too. We need not do anything
* for PlaceHolderVars in the parent list. If child expression
* isn't a Var, or we didn't record a width estimate for it, we
* have to fall back on a datatype-based estimate.
*
* By construction, child's reltargetlist is 1-to-1 with parent's.
*/
forboth(parentvars, rel->reltargetlist, childvars, childrel->reltargetlist)
{
Var* parentvar = (Var*)lfirst(parentvars);
Node* childvar = (Node*)lfirst(childvars);
if (IsA(parentvar, Var)) {
int pndx = parentvar->varattno - rel->min_attr;
int32 child_width = 0;
if (IsA(childvar, Var)) {
int cndx = ((Var*)childvar)->varattno - childrel->min_attr;
child_width = childrel->attr_widths[cndx];
}
if (child_width <= 0)
child_width = get_typavgwidth(exprType(childvar), exprTypmod(childvar));
AssertEreport(child_width > 0, MOD_OPT, "");
parent_attrsizes[pndx] += child_width * RELOPTINFO_LOCAL_FIELD(root, childrel, rows);
}
}
}
if (has_live_children) {
/*
* Save the finished size estimates.
*/
int i;
parent_rows = clamp_row_est(parent_rows);
parent_global_rows = clamp_row_est(parent_global_rows);
parent_tuples = clamp_row_est(parent_tuples);
parent_global_tuples = clamp_row_est(parent_global_tuples);
rel->rows = parent_global_rows;
rel->width = (int)rint(parent_size / parent_rows);
for (i = 0; i < nattrs; i++)
rel->attr_widths[i] = (int32)rint(parent_attrsizes[i] / parent_rows);
rel->tuples = parent_global_tuples;
rel->multiple = parent_tuples / parent_global_tuples * ng_get_dest_num_data_nodes(root, rel);
} else {
/*
* All children were excluded by constraints, so mark the whole
* appendrel dummy. We must do this in this phase so that the rel's
* dummy-ness is visible when we generate paths for other rels.
*/
set_dummy_rel_pathlist(rel);
}
pfree_ext(parent_attrsizes);
}
/*
* @Description: Judge if path can be parameterized, only true if no materialize paths
* added due to streamed subplan or cstore index scan with delta.
* For correlated subpath, if path is hashed or containing stream, return false.
* @in root: Per-query information for planning/optimization.
* @in cheapest_total: Need judge path.
* @return: Return true if this path is non-replicated or contain stream else return false.
*/
static bool judge_path_parameterizable(PlannerInfo* root, Path* path)
{
if (root != NULL && root->is_correlated) {
Distribution* distribution = ng_get_dest_distribution(path);
Distribution* target_distribution = ng_get_correlated_subplan_group_distribution();
/*
* conditions with stream of potentially stream will be added will be figured out,
* and return false directly.
*/
if (!is_replicated_path(path) || !ng_is_same_group(distribution, target_distribution)) {
return false;
} else {
/* only check if there's stream node */
ContainStreamContext context;
context.outer_relids = NULL;
context.only_check_stream = true;
context.under_materialize_all = false;
context.has_stream = false;
context.has_parameterized_path = false;
context.has_cstore_index_delta = false;
stream_path_walker(path, &context);
if (context.has_stream || context.has_cstore_index_delta) {
return false;
}
}
}
return true;
}
/*
* set_append_rel_pathlist
* Build access paths for an "append relation"
*/
static void set_append_rel_pathlist(PlannerInfo* root, RelOptInfo* rel, Index rti, RangeTblEntry* rte)
{
Index parentRTindex = rti;
List* live_childrels = NIL;
List* subpaths = NIL;
List* all_child_pathkeys = NIL;
List* all_child_outers = NIL;
ListCell* l = NULL;
Path* append_path = NULL;
/*
* Generate access paths for each member relation, and remember the
* cheapest path for each one. Also, identify all pathkeys (orderings)
* and parameterizations (required_outer sets) available for the member
* relations.
*/
foreach (l, root->append_rel_list) {
AppendRelInfo* appinfo = (AppendRelInfo*)lfirst(l);
int childRTindex;
RangeTblEntry* childRTE = NULL;
RelOptInfo* childrel = NULL;
ListCell* lcp = NULL;
/* append_rel_list contains all append rels; ignore others */
if (appinfo->parent_relid != parentRTindex)
continue;
/* Re-locate the child RTE and RelOptInfo */
childRTindex = appinfo->child_relid;
childRTE = root->simple_rte_array[childRTindex];
childrel = root->simple_rel_array[childRTindex];
/*
* Compute the child's access paths.
*/
set_rel_pathlist(root, childrel, childRTindex, childRTE);
/*
* If child is dummy, ignore it.
*/
if (IS_DUMMY_REL(childrel))
continue;
/*
* Child is live, so add its cheapest access path to the Append path
* we are constructing for the parent.
*/
subpaths = accumulate_append_subpath(subpaths, (Path*)linitial(childrel->cheapest_total_path));
/* Remember which childrels are live, for logic below */
live_childrels = lappend(live_childrels, childrel);
/*
* Collect lists of all the available path orderings and
* parameterizations for all the children. We use these as a
* heuristic to indicate which sort orderings and parameterizations we
* should build Append and MergeAppend paths for.
*/
foreach (lcp, childrel->pathlist) {
Path* childpath = (Path*)lfirst(lcp);
List* childkeys = childpath->pathkeys;
Relids childouter = PATH_REQ_OUTER(childpath);
/* Unsorted paths don't contribute to pathkey list */
if (childkeys != NIL) {
ListCell* lpk = NULL;
bool found = false;
/* Have we already seen this ordering? */
foreach (lpk, all_child_pathkeys) {
List* existing_pathkeys = (List*)lfirst(lpk);
if (compare_pathkeys(existing_pathkeys, childkeys) == PATHKEYS_EQUAL) {
found = true;
break;
}
}
if (!found) {
/* No, so add it to all_child_pathkeys */
all_child_pathkeys = lappend(all_child_pathkeys, childkeys);
}
}
/* Unparameterized paths don't contribute to param-set list */
if (childouter) {
ListCell* lco = NULL;
bool found = false;
/* Have we already seen this param set? */
foreach (lco, all_child_outers) {
Relids existing_outers = (Relids)lfirst(lco);
if (bms_equal(existing_outers, childouter)) {
found = true;
break;
}
}
if (!found) {
/* No, so add it to all_child_outers */
all_child_outers = lappend(all_child_outers, childouter);
}
}
}
}
/*
* Next, build an unordered, unparameterized Append path for the rel.
* (Note: this is correct even if we have zero or one live subpath due to
* constraint exclusion.)
*/
append_path = (Path*)create_append_path(root, rel, subpaths, NULL);
if (append_path != NULL) {
add_path(root, rel, append_path);
}
/*
* Build unparameterized MergeAppend paths based on the collected list of
* child pathkeys.
*/
generate_mergeappend_paths(root, rel, live_childrels, all_child_pathkeys);
/*
* Build Append paths for each parameterization seen among the child rels.
* (This may look pretty expensive, but in most cases of practical
* interest, the child rels will expose mostly the same parameterizations,
* so that not that many cases actually get considered here.)
*
* The Append node itself cannot enforce quals, so all qual checking must
* be done in the child paths. This means that to have a parameterized
* Append path, we must have the exact same parameterization for each
* child path; otherwise some children might be failing to check the
* moved-down quals. To make them match up, we can try to increase the
* parameterization of lesser-parameterized paths.
*/
foreach (l, all_child_outers) {
Relids required_outer = (Relids)lfirst(l);
bool ok = true;
ListCell* lcr = NULL;
/* Select the child paths for an Append with this parameterization */
subpaths = NIL;
foreach (lcr, live_childrels) {
RelOptInfo* childrel = (RelOptInfo*)lfirst(lcr);
Path* cheapest_total = NULL;
cheapest_total = get_cheapest_path_for_pathkeys(childrel->pathlist, NIL, required_outer, TOTAL_COST);
AssertEreport(cheapest_total != NULL, MOD_OPT, "");
/*
* Judge this path, if it is correlation subquery and it is non-replicated or include stream,
* we will not generate plan with param_info. Because this upper levels add materialization or broadcast
* node without prarm_info.
*/
if (!judge_path_parameterizable(root, cheapest_total)) {
ok = false;
break;
}
/* Children must have exactly the desired parameterization */
if (!bms_equal(PATH_REQ_OUTER(cheapest_total), required_outer)) {
cheapest_total = reparameterize_path(root, cheapest_total, required_outer, 1.0);
if (cheapest_total == NULL) {
ok = false;
break;
}
}
subpaths = accumulate_append_subpath(subpaths, cheapest_total);
}
if (ok) {
append_path = (Path*)create_append_path(root, rel, subpaths, required_outer);
if (append_path != NULL) {
add_path(root, rel, append_path);
}
}
}
/* Select cheapest paths */
set_cheapest(rel);
}
/*
* generate_mergeappend_paths
* Generate MergeAppend paths for an append relation
*
* Generate a path for each ordering (pathkey list) appearing in
* all_child_pathkeys.
*
* We consider both cheapest-startup and cheapest-total cases, ie, for each
* interesting ordering, collect all the cheapest startup subpaths and all the
* cheapest total paths, and build a MergeAppend path for each case.
*
* We don't currently generate any parameterized MergeAppend paths. While
* it would not take much more code here to do so, it's very unclear that it
* is worth the planning cycles to investigate such paths: there's little
* use for an ordered path on the inside of a nestloop. In fact, it's likely
* that the current coding of add_path would reject such paths out of hand,
* because add_path gives no credit for sort ordering of parameterized paths,
* and a parameterized MergeAppend is going to be more expensive than the
* corresponding parameterized Append path. If we ever try harder to support
* parameterized mergejoin plans, it might be worth adding support for
* parameterized MergeAppends to feed such joins. (See notes in
* optimizer/README for why that might not ever happen, though.)
*/
static void generate_mergeappend_paths(PlannerInfo* root, RelOptInfo* rel,
List* live_childrels, List* all_child_pathkeys)
{
ListCell* lcp = NULL;
foreach (lcp, all_child_pathkeys) {
List* pathkeys = (List*)lfirst(lcp);
List* startup_subpaths = NIL;
List* total_subpaths = NIL;
bool startup_neq_total = false;
ListCell* lcr = NULL;
/* Select the child paths for this ordering... */
foreach (lcr, live_childrels) {
RelOptInfo* childrel = (RelOptInfo*)lfirst(lcr);
Path *cheapest_startup, *cheapest_total;
/* Locate the right paths, if they are available. */
cheapest_startup = get_cheapest_path_for_pathkeys(childrel->pathlist, pathkeys, NULL, STARTUP_COST);
cheapest_total = get_cheapest_path_for_pathkeys(childrel->pathlist, pathkeys, NULL, TOTAL_COST);
/*
* If we can't find any paths with the right order just use the
* cheapest-total path; we'll have to sort it later.
*/
if (cheapest_startup == NULL || cheapest_total == NULL) {
cheapest_startup = cheapest_total = (Path*)linitial(childrel->cheapest_total_path);
AssertEreport(cheapest_total != NULL, MOD_OPT, "");
}
/*
* Notice whether we actually have different paths for the
* "cheapest" and "total" cases; frequently there will be no point
* in two create_merge_append_path() calls.
*/
if (cheapest_startup != cheapest_total)
startup_neq_total = true;
startup_subpaths = accumulate_append_subpath(startup_subpaths, cheapest_startup);
total_subpaths = accumulate_append_subpath(total_subpaths, cheapest_total);
}
/* ... and build the MergeAppend paths */
Path* merge_append_path = (Path*)create_merge_append_path(root, rel, startup_subpaths, pathkeys, NULL);
if (merge_append_path != NULL) {
add_path(root, rel, merge_append_path);
}
if (startup_neq_total) {
merge_append_path = (Path*)create_merge_append_path(root, rel, total_subpaths, pathkeys, NULL);
if (merge_append_path != NULL) {
add_path(root, rel, merge_append_path);
}
}
}
}
/*
* accumulate_append_subpath
* Add a subpath to the list being built for an Append or MergeAppend
*
* It's possible that the child is itself an Append path, in which case
* we can "cut out the middleman" and just add its child paths to our
* own list. (We don't try to do this earlier because we need to
* apply both levels of transformation to the quals.)
*/
static List* accumulate_append_subpath(List* subpaths, Path* path)
{
if (IsA(path, AppendPath)) {
AppendPath* apath = (AppendPath*)path;
/* list_copy is important here to avoid sharing list substructure */
return list_concat(subpaths, list_copy(apath->subpaths));
} else
return lappend(subpaths, path);
}
/*
* set_dummy_rel_pathlist
* Build a dummy path for a relation that's been excluded by constraints
*
* Rather than inventing a special "dummy" path type, we represent this as an
* AppendPath with no members (see also IS_DUMMY_PATH/IS_DUMMY_REL macros).
*/
static void set_dummy_rel_pathlist(RelOptInfo* rel)
{
/*
* Set dummy tuples as 1 because it may be avoid some error about divided by 0
* during estimate selectivity of joinrel.
*/
rel->tuples = 1;
/* Set dummy size estimates --- we leave attr_widths[] as zeroes */
rel->rows = 0;
rel->width = 0;
/* Discard any pre-existing paths; no further need for them */
rel->pathlist = NIL;
Path* append_path = (Path*)create_append_path(NULL, rel, NIL, NULL);
if (append_path != NULL) {
add_path(NULL, rel, append_path);
}
/* Select cheapest path (pretty easy in this case...) */
set_cheapest(rel);
}
/* quick-and-dirty test to see if any joining is needed */
static bool has_multiple_baserels(PlannerInfo* root)
{
int num_base_rels = 0;
int rti;
for (rti = 1; rti < root->simple_rel_array_size; rti++) {
RelOptInfo* brel = root->simple_rel_array[rti];
if (brel == NULL)
continue;
/* ignore RTEs that are "other rels" */
if (brel->reloptkind == RELOPT_BASEREL)
if (++num_base_rels > 1)
return true;
}
return false;
}
/*
* set_subquery_pathlist
* Build the (single) access path for a subquery RTE
*
* There's no need for a separate set_subquery_size phase, since we don't
* support parameterized paths for subqueries.
*/
static void set_subquery_pathlist(PlannerInfo* root, RelOptInfo* rel, Index rti, RangeTblEntry* rte)
{
Query* parse = root->parse;
Query* subquery = rte->subquery;
bool* unsafeColumns = NULL;
double tuple_fraction;
PlannerInfo* subroot = NULL;
List* pathkeys = NIL;
/*
* Must copy the Query so that planning doesn't mess up the RTE contents
* (really really need to fix the planner to not scribble on its input,
* someday).
*/
subquery = (Query*)copyObject(subquery);
/*
* We need a workspace for keeping track of unsafe-to-reference columns.
* unsafeColumns[i] is set TRUE if we've found that output column i of the
* subquery is unsafe to use in a pushed-down qual.
*/
unsafeColumns = (bool*)palloc0((list_length(subquery->targetList) + 1) * sizeof(bool));
/*
* If there are any restriction clauses that have been attached to the
* subquery relation, consider pushing them down to become WHERE or HAVING
* quals of the subquery itself. This transformation is useful because it
* may allow us to generate a better plan for the subquery than evaluating
* all the subquery output rows and then filtering them.
*
* There are several cases where we cannot push down clauses. Restrictions
* involving the subquery are checked by subquery_is_pushdown_safe().
* Restrictions on individual clauses are checked by
* qual_is_pushdown_safe(). Also, we don't want to push down
* pseudoconstant clauses; better to have the gating node above the
* subquery.
*
* Also, if the sub-query has "security_barrier" flag, it means the
* sub-query originated from a view that must enforce row-level security.
* We must not push down quals in order to avoid information leaks, either
* via side-effects or error output.
*
* Non-pushed-down clauses will get evaluated as qpquals of the
* SubqueryScan node.
*
* XXX Are there any cases where we want to make a policy decision not to
* push down a pushable qual, because it'd result in a worse plan?
*/
if (rel->baserestrictinfo != NIL && subquery_is_pushdown_safe(subquery, subquery, unsafeColumns)) {
/* OK to consider pushing down individual quals */
List* upperrestrictlist = NIL;
ListCell* l = NULL;
foreach (l, rel->baserestrictinfo) {
RestrictInfo* rinfo = (RestrictInfo*)lfirst(l);
Node* clause = (Node*)rinfo->clause;
if (!rinfo->pseudoconstant && (!rte->security_barrier || !contain_leaky_functions(clause)) &&
qual_is_pushdown_safe(subquery, rti, clause, unsafeColumns)) {
/* Push it down */
subquery_push_qual(subquery, rte, rti, clause);
} else {
/* Keep it in the upper query */
upperrestrictlist = lappend(upperrestrictlist, rinfo);
}
}
rel->baserestrictinfo = upperrestrictlist;
}
pfree_ext(unsafeColumns);
/*
* We can safely pass the outer tuple_fraction down to the subquery if the
* outer level has no joining, aggregation, or sorting to do. Otherwise
* we'd better tell the subquery to plan for full retrieval. (XXX This
* could probably be made more intelligent ...)
*/
if (parse->hasAggs || parse->groupClause || parse->groupingSets || parse->havingQual || parse->distinctClause ||
parse->sortClause || has_multiple_baserels(root))
tuple_fraction = 0.0; /* default case */
else
tuple_fraction = root->tuple_fraction;
/* plan_params should not be in use in current query level */
AssertEreport(root->plan_params == NIL, MOD_OPT, "");
/* Generate the plan for the subquery */
rel->subplan = subquery_planner(
root->glob, subquery, root, false, tuple_fraction, &subroot, &rel->rel_dis_keys, rel->baserestrictinfo);
rel->subroot = subroot;
/*
* Since we don't yet support LATERAL, it should not be possible for the
* sub-query to have requested parameters of this level.
*/
if (root->plan_params)
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
(errmsg("unexpected outer reference in subquery in FROM"))));
/*
* It's possible that constraint exclusion proved the subquery empty. If
* so, it's convenient to turn it back into a dummy path so that we will
* recognize appropriate optimizations at this query level. (But see
* create_append_plan in createplan.c, which has to reverse this
* substitution.)
*/
if (is_dummy_plan(rel->subplan)) {
set_dummy_rel_pathlist(rel);
return;
}
/* Mark rel with estimated output rows, width, etc */
if (rel->base_rel == NULL) {
set_subquery_size_estimates(root, rel);
}
adjust_rows_according_to_hint(root->parse->hintState, rel);
/* Convert subquery pathkeys to outer representation */
pathkeys = convert_subquery_pathkeys(root, rel, subroot->query_pathkeys);
/* Generate appropriate path */
add_path(root, rel, create_subqueryscan_path(root, rel, pathkeys, NULL));
/* Select cheapest path (pretty easy in this case...) */
set_cheapest(rel);
}
/*
* set_function_pathlist
* Build the (single) access path for a function RTE
*/
static void set_function_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
/* Generate appropriate path */
add_path(root, rel, create_functionscan_path(root, rel));
/* Select cheapest path (pretty easy in this case...) */
set_cheapest(rel);
}
/*
* set_values_pathlist
* Build the (single) access path for a VALUES RTE
*/
static void set_values_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
/* Generate appropriate path */
add_path(root, rel, create_valuesscan_path(root, rel));
/* Select cheapest path (pretty easy in this case...) */
set_cheapest(rel);
}
/*
* set_cte_pathlist
* Build the (single) access path for a non-self-reference CTE RTE
*
* There's no need for a separate set_cte_size phase, since we don't
* support parameterized paths for CTEs.
*/
static void set_cte_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
Plan* cteplan = NULL;
PlannerInfo* cteroot = NULL;
Index levelsup;
int ndx;
ListCell* lc = NULL;
int plan_id;
/*
* Find the referenced CTE, and locate the plan previously made for it.
*/
levelsup = rte->ctelevelsup;
cteroot = root;
while (levelsup-- > 0) {
cteroot = cteroot->parent_root;
if (cteroot == NULL) { /* shouldn't happen */
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
errmsg("bad levelsup for CTE \"%s\" when set cte pathlist", rte->ctename)));
}
}
/*
* Note: cte_plan_ids can be shorter than cteList, if we are still working
* on planning the CTEs (ie, this is a side-reference from another CTE).
* So we mustn't use forboth here.
*/
ndx = 0;
foreach (lc, cteroot->parse->cteList) {
CommonTableExpr* cte = (CommonTableExpr*)lfirst(lc);
/*
* MPP with recursive support.
*
* Recursive CTE is initialized in subplan list, so we should only count
* the recursive CTE, the none-recursive CTE is fold in early stage of
* query rewrite.
*/
if (STREAM_RECURSIVECTE_SUPPORTED && !cte->cterecursive) {
continue;
}
if (strcmp(cte->ctename, rte->ctename) == 0)
break;
ndx++;
}
if (lc == NULL) { /* shouldn't happen */
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
errmsg("could not find CTE \"%s\" when set cte pathlist", rte->ctename)));
}
if (ndx >= list_length(cteroot->cte_plan_ids)) {
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
errmsg("could not find plan for CTE \"%s\" when set cte pathlist", rte->ctename)));
}
plan_id = list_nth_int(cteroot->cte_plan_ids, ndx);
AssertEreport(plan_id > 0, MOD_OPT, "");
cteplan = (Plan*)list_nth(root->glob->subplans, plan_id - 1);
/* Mark rel with estimated output rows, width, etc */
set_cte_size_estimates(root, rel, cteplan);
/* Inherit the locale info */
if (STREAM_RECURSIVECTE_SUPPORTED && is_hashed_plan(cteplan) && IsA(cteplan, RecursiveUnion)) {
List* distribute_index = distributeKeyIndex(cteroot, cteplan->distributed_keys, cteplan->targetlist);
if (NIL != distribute_index) {
ListCell* cell1 = NULL;
ListCell* cell2 = NULL;
foreach (cell1, distribute_index) {
bool found = false;
int resno = lfirst_int(cell1);
foreach (cell2, rel->reltargetlist) {
Var* relvar = locate_distribute_var((Expr*)lfirst(cell2));
if (relvar != NULL && relvar->varattno == resno) {
found = true;
rel->distribute_keys = lappend(rel->distribute_keys, relvar);
break;
}
}
if (found == false) {
list_free_ext(rel->distribute_keys);
break;
}
}
}
} else {
rel->distribute_keys = cteplan->distributed_keys;
}
if (cteplan->exec_nodes != NULL) {
rel->locator_type = cteplan->exec_nodes->baselocatortype;
}
/* Generate appropriate path */
add_path(root, rel, create_ctescan_path(root, rel));
/* Select cheapest path (pretty easy in this case...) */
set_cheapest(rel);
}
/*
* set_worktable_pathlist
* Build the (single) access path for a self-reference CTE RTE
*
* There's no need for a separate set_worktable_size phase, since we don't
* support parameterized paths for CTEs.
*/
static void set_worktable_pathlist(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
Plan* cteplan = NULL;
PlannerInfo* cteroot = NULL;
Index levelsup;
/*
* We need to find the non-recursive term's plan, which is in the plan
* level that's processing the recursive UNION, which is one level *below*
* where the CTE comes from.
*/
levelsup = rte->ctelevelsup;
if (levelsup == 0) { /* shouldn't happen */
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
errmsg("bad levelsup for CTE \"%s\" when set worktable pathlist", rte->ctename)));
}
levelsup--;
cteroot = root;
while (levelsup-- > 0) {
cteroot = cteroot->parent_root;
if (cteroot == NULL) { /* shouldn't happen */
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
errmsg("bad levelsup for CTE \"%s\" when set worktable pathlist", rte->ctename)));
}
}
cteplan = cteroot->non_recursive_plan;
if (cteplan == NULL) /* shouldn't happen */
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
(errmsg("could not find plan for CTE \"%s\" when set worktable pathlist", rte->ctename))));
/* Mark rel with estimated output rows, width, etc */
set_cte_size_estimates(root, rel, cteplan);
/* Generate appropriate path */
add_path(root, rel, create_worktablescan_path(root, rel));
/* Select cheapest path (pretty easy in this case...) */
set_cheapest(rel);
}
/*
* make_rel_from_joinlist
* Build access paths using a "joinlist" to guide the join path search.
*
* See comments for deconstruct_jointree() for definition of the joinlist
* data structure.
*/
static RelOptInfo* make_rel_from_joinlist(PlannerInfo* root, List* joinlist)
{
int levels_needed;
List* initial_rels = NIL;
ListCell* jl = NULL;
/*
* Count the number of child joinlist nodes. This is the depth of the
* dynamic-programming algorithm we must employ to consider all ways of
* joining the child nodes.
*/
levels_needed = list_length(joinlist);
if (levels_needed <= 0)
return NULL; /* nothing to do? */
/*
* Construct a list of rels corresponding to the child joinlist nodes.
* This may contain both base rels and rels constructed according to
* sub-joinlists.
*/
initial_rels = NIL;
foreach (jl, joinlist) {
Node* jlnode = (Node*)lfirst(jl);
RelOptInfo* thisrel = NULL;
if (IsA(jlnode, RangeTblRef)) {
int varno = ((RangeTblRef*)jlnode)->rtindex;
thisrel = find_base_rel(root, varno);
} else if (IsA(jlnode, List)) {
/* Recurse to handle subproblem */
thisrel = make_rel_from_joinlist(root, (List*)jlnode);
} else {
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE),
(errmsg("unrecognized joinlist node type when build access paths by joinlist: %d",
(int)nodeTag(jlnode)))));
thisrel = NULL; /* keep compiler quiet */
}
initial_rels = lappend(initial_rels, thisrel);
}
if (levels_needed == 1) {
/*
* Single joinlist node, so we're done.
*/
return (RelOptInfo*)linitial(initial_rels);
} else {
/*
* Consider the different orders in which we could join the rels,
* using a plugin, GEQO, or the regular join search code.
*
* We put the initial_rels list into a PlannerInfo field because
* has_legal_joinclause() needs to look at it (ugly :-().
*/
root->initial_rels = initial_rels;
if (u_sess->attr.attr_sql.enable_geqo && levels_needed >= u_sess->attr.attr_sql.geqo_threshold)
return geqo(root, levels_needed, initial_rels);
else
return standard_join_search(root, levels_needed, initial_rels);
}
}
/*
* standard_join_search
* Find possible joinpaths for a query by successively finding ways
* to join component relations into join relations.
*
* 'levels_needed' is the number of iterations needed, ie, the number of
* independent jointree items in the query. This is > 1.
*
* 'initial_rels' is a list of RelOptInfo nodes for each independent
* jointree item. These are the components to be joined together.
* Note that levels_needed == list_length(initial_rels).
*
* Returns the final level of join relations, i.e., the relation that is
* the result of joining all the original relations together.
* At least one implementation path must be provided for this relation and
* all required sub-relations.
*
* To support loadable plugins that modify planner behavior by changing the
* join searching algorithm, we provide a hook variable that lets a plugin
* replace or supplement this function. Any such hook must return the same
* final join relation as the standard code would, but it might have a
* different set of implementation paths attached, and only the sub-joinrels
* needed for these paths need have been instantiated.
*
* Note to plugin authors: the functions invoked during standard_join_search()
* modify root->join_rel_list and root->join_rel_hash. If you want to do more
* than one join-order search, you'll probably need to save and restore the
* original states of those data structures. See geqo_eval() for an example.
*/
RelOptInfo* standard_join_search(PlannerInfo* root, int levels_needed, List* initial_rels)
{
int lev;
RelOptInfo* rel = NULL;
/*
* This function cannot be invoked recursively within any one planning
* problem, so join_rel_level[] can't be in use already.
*/
AssertEreport(root->join_rel_level == NULL, MOD_OPT, "");
/*
* We employ a simple "dynamic programming" algorithm: we first find all
* ways to build joins of two jointree items, then all ways to build joins
* of three items (from two-item joins and single items), then four-item
* joins, and so on until we have considered all ways to join all the
* items into one rel.
*
* root->join_rel_level[j] is a list of all the j-item rels. Initially we
* set root->join_rel_level[1] to represent all the single-jointree-item
* relations.
*/
root->join_rel_level = (List**)palloc0((levels_needed + 1) * sizeof(List*));
root->join_rel_level[1] = initial_rels;
for (lev = 2; lev <= levels_needed; lev++) {
ListCell* lc = NULL;
/*
* Determine all possible pairs of relations to be joined at this
* level, and build paths for making each one from every available
* pair of lower-level relations.
*/
join_search_one_level(root, lev);
/*
* Do cleanup work on each just-processed rel.
*/
foreach (lc, root->join_rel_level[lev]) {
rel = (RelOptInfo*)lfirst(lc);
/* Find and save the cheapest paths for this rel */
set_cheapest(rel, root);
debug1_print_rel(root, rel);
#ifdef OPTIMIZER_DEBUG
debug_print_rel(root, rel);
#endif
}
}
/*
* We should have a single rel at the final level.
*/
if (root->join_rel_level[levels_needed] == NIL)
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
(errmsg("failed to build any %d-way joins in standard join search", levels_needed))));
AssertEreport(list_length(root->join_rel_level[levels_needed]) == 1, MOD_OPT, "");
rel = (RelOptInfo*)linitial(root->join_rel_level[levels_needed]);
root->join_rel_level = NULL;
return rel;
}
/*****************************************************************************
* PUSHING QUALS DOWN INTO SUBQUERIES
*****************************************************************************/
/*
* subquery_is_pushdown_safe - is a subquery safe for pushing down quals?
*
* subquery is the particular component query being checked. topquery
* is the top component of a set-operations tree (the same Query if no
* set-op is involved).
*
* Conditions checked here:
*
* 1. If the subquery has a LIMIT clause, we must not push down any quals,
* since that could change the set of rows returned.
*
* 2. If the subquery contains any window functions, we can't push quals
* into it, because that could change the results.
*
* 3. If the subquery contains EXCEPT or EXCEPT ALL set ops we cannot push
* quals into it, because that could change the results.
*
* In addition, we make several checks on the subquery's output columns
* to see if it is safe to reference them in pushed-down quals. If output
* column k is found to be unsafe to reference, we set unsafeColumns[k] to
* TRUE, but we don't reject the subquery overall since column k might
* not be referenced by some/all quals. The unsafeColumns[] array will be
* consulted later by qual_is_pushdown_safe(). It's better to do it this
* way than to make the checks directly in qual_is_pushdown_safe(), because
* when the subquery involves set operations we have to check the output
* expressions in each arm of the set op.
*/
static bool subquery_is_pushdown_safe(Query* subquery, Query* topquery, bool* unsafeColumns)
{
SetOperationStmt* topop = NULL;
/* Check point 1 */
if (subquery->limitOffset != NULL || subquery->limitCount != NULL)
return false;
/* Check point 2 */
if (subquery->hasWindowFuncs)
return false;
/*
* If we're at a leaf query, check for unsafe expressions in its target
* list, and mark any unsafe ones in unsafeColumns[]. (Non-leaf nodes in
* setop trees have only simple Vars in their tlists, so no need to check
* them.)
*/
if (subquery->setOperations == NULL)
check_output_expressions(subquery, unsafeColumns);
/* Are we at top level, or looking at a setop component? */
if (subquery == topquery) {
/* Top level, so check any component queries */
if (subquery->setOperations != NULL)
if (!recurse_pushdown_safe(subquery->setOperations, topquery, unsafeColumns))
return false;
} else {
/* Setop component must not have more components (too weird) */
if (subquery->setOperations != NULL)
return false;
/* Check whether setop component output types match top level */
topop = (SetOperationStmt*)topquery->setOperations;
AssertEreport(topop && IsA(topop, SetOperationStmt), MOD_OPT, "");
compare_tlist_datatypes(subquery->targetList, topop->colTypes, unsafeColumns);
}
return true;
}
/*
* Helper routine to recurse through setOperations tree
*/
static bool recurse_pushdown_safe(Node* setOp, Query* topquery, bool* unsafeColumns)
{
if (IsA(setOp, RangeTblRef)) {
RangeTblRef* rtr = (RangeTblRef*)setOp;
RangeTblEntry* rte = rt_fetch(rtr->rtindex, topquery->rtable);
Query* subquery = rte->subquery;
AssertEreport(subquery != NULL, MOD_OPT, "");
return subquery_is_pushdown_safe(subquery, topquery, unsafeColumns);
} else if (IsA(setOp, SetOperationStmt)) {
SetOperationStmt* op = (SetOperationStmt*)setOp;
/* EXCEPT is no good */
if (op->op == SETOP_EXCEPT)
return false;
/* Else recurse */
if (!recurse_pushdown_safe(op->larg, topquery, unsafeColumns))
return false;
if (!recurse_pushdown_safe(op->rarg, topquery, unsafeColumns))
return false;
} else {
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE),
errmsg("unrecognized node type when pushdown recurse through setOperations tree: %d",
(int)nodeTag(setOp))));
}
return true;
}
/*
* check_output_expressions - check subquery's output expressions for safety
*
* There are several cases in which it's unsafe to push down an upper-level
* qual if it references a particular output column of a subquery. We check
* each output column of the subquery and set unsafeColumns[k] to TRUE if
* that column is unsafe for a pushed-down qual to reference. The conditions
* checked here are:
*
* 1. We must not push down any quals that refer to subselect outputs that
* return sets, else we'd introduce functions-returning-sets into the
* subquery's WHERE/HAVING quals.
*
* 2. We must not push down any quals that refer to subselect outputs that
* contain volatile functions, for fear of introducing strange results due
* to multiple evaluation of a volatile function.
*
* 3. If the subquery uses DISTINCT ON, we must not push down any quals that
* refer to non-DISTINCT output columns, because that could change the set
* of rows returned. (This condition is vacuous for DISTINCT, because then
* there are no non-DISTINCT output columns, so we needn't check. But note
* we are assuming that the qual can't distinguish values that the DISTINCT
* operator sees as equal. This is a bit shaky but we have no way to test
* for the case, and it's unlikely enough that we shouldn't refuse the
* optimization just because it could theoretically happen.)
*/
static void check_output_expressions(Query* subquery, bool* unsafeColumns)
{
ListCell* lc = NULL;
foreach (lc, subquery->targetList) {
TargetEntry* tle = (TargetEntry*)lfirst(lc);
if (tle->resjunk)
continue; /* ignore resjunk columns */
/* We need not check further if output col is already known unsafe */
if (unsafeColumns[tle->resno])
continue;
/* Functions returning sets are unsafe (point 1) */
if (expression_returns_set((Node*)tle->expr)) {
unsafeColumns[tle->resno] = true;
continue;
}
/* Volatile functions are unsafe (point 2) */
if (contain_volatile_functions((Node*)tle->expr)) {
unsafeColumns[tle->resno] = true;
continue;
}
/* If subquery uses DISTINCT ON, check point 3 */
if (subquery->hasDistinctOn && !targetIsInSortList(tle, InvalidOid, subquery->distinctClause)) {
/* non-DISTINCT column, so mark it unsafe */
unsafeColumns[tle->resno] = true;
continue;
}
}
}
/*
* For subqueries using UNION/UNION ALL/INTERSECT/INTERSECT ALL, we can
* push quals into each component query, but the quals can only reference
* subquery columns that suffer no type coercions in the set operation.
* Otherwise there are possible semantic gotchas. So, we check the
* component queries to see if any of them have output types different from
* the top-level setop outputs. unsafeColumns[k] is set true if column k
* has different type in any component.
*
* We don't have to care about typmods here: the only allowed difference
* between set-op input and output typmods is input is a specific typmod
* and output is -1, and that does not require a coercion.
*
* tlist is a subquery tlist.
* colTypes is an OID list of the top-level setop's output column types.
* unsafeColumns[] is the result array.
*/
static void compare_tlist_datatypes(List* tlist, List* colTypes, bool* unsafeColumns)
{
ListCell* l = NULL;
ListCell* colType = list_head(colTypes);
foreach (l, tlist) {
TargetEntry* tle = (TargetEntry*)lfirst(l);
if (tle->resjunk)
continue; /* ignore resjunk columns */
if (colType == NULL)
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_CASE_NOT_FOUND),
(errmsg("wrong number of tlist entries when compare a subquery targetlist datatypes"))));
if (exprType((Node*)tle->expr) != lfirst_oid(colType))
unsafeColumns[tle->resno] = true;
colType = lnext(colType);
}
if (colType != NULL)
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_OPTIMIZER_INCONSISTENT_STATE),
(errmsg("wrong number of tlist entries when compare a subquery targetlist datatypes"))));
}
/*
* qual_is_pushdown_safe - is a particular qual safe to push down?
*
* qual is a restriction clause applying to the given subquery (whose RTE
* has index rti in the parent query).
*
* Conditions checked here:
*
* 1. The qual must not contain any subselects (mainly because I'm not sure
* it will work correctly: sublinks will already have been transformed into
* subplans in the qual, but not in the subquery).
*
* 2. The qual must not refer to the whole-row output of the subquery
* (since there is no easy way to name that within the subquery itself).
*
* 3. The qual must not refer to any subquery output columns that were
* found to be unsafe to reference by subquery_is_pushdown_safe().
*/
static bool qual_is_pushdown_safe(Query* subquery, Index rti, Node* qual, const bool* unsafeColumns)
{
bool safe = true;
List* vars = NIL;
ListCell* vl = NULL;
/* Refuse subselects (point 1) */
if (contain_subplans(qual)) {
return false;
}
if(contain_volatile_functions(qual)) {
return false;
}
/*
* It would be unsafe to push down window function calls, but at least for
* the moment we could never see any in a qual anyhow. (The same applies
* to aggregates, which we check for in pull_var_clause below.)
*/
AssertEreport(!contain_window_function(qual), MOD_OPT, "");
/*
* Examine all Vars used in clause; since it's a restriction clause, all
* such Vars must refer to subselect output columns.
*/
vars = pull_var_clause(qual, PVC_REJECT_AGGREGATES, PVC_INCLUDE_PLACEHOLDERS);
foreach (vl, vars) {
Var* var = (Var*)lfirst(vl);
/*
* XXX Punt if we find any PlaceHolderVars in the restriction clause.
* It's not clear whether a PHV could safely be pushed down, and even
* less clear whether such a situation could arise in any cases of
* practical interest anyway. So for the moment, just refuse to push
* down.
*/
if (!IsA(var, Var)) {
safe = false;
break;
}
AssertEreport(var->varno == rti, MOD_OPT, "");
AssertEreport(var->varattno >= 0, MOD_OPT, "");
/* Check point 2 */
if (var->varattno == 0) {
safe = false;
break;
}
/* Check point 3 */
if (unsafeColumns[var->varattno]) {
safe = false;
break;
}
}
list_free_ext(vars);
return safe;
}
/*
* subquery_push_qual - push down a qual that we have determined is safe
*/
static void subquery_push_qual(Query* subquery, RangeTblEntry* rte, Index rti, Node* qual)
{
if (subquery->setOperations != NULL) {
/* Recurse to push it separately to each component query */
recurse_push_qual(subquery->setOperations, subquery, rte, rti, qual);
} else {
/*
* We need to replace Vars in the qual (which must refer to outputs of
* the subquery) with copies of the subquery's targetlist expressions.
* Note that at this point, any uplevel Vars in the qual should have
* been replaced with Params, so they need no work.
*
* This step also ensures that when we are pushing into a setop tree,
* each component query gets its own copy of the qual.
*/
qual = ResolveNew(qual, rti, 0, rte, subquery->targetList, CMD_SELECT, 0, &subquery->hasSubLinks);
/*
* Now attach the qual to the proper place: normally WHERE, but if the
* subquery uses grouping or aggregation, put it in HAVING (since the
* qual really refers to the group-result rows).
*/
if (subquery->hasAggs || subquery->groupClause || subquery->havingQual)
subquery->havingQual = make_and_qual(subquery->havingQual, qual);
else
subquery->jointree->quals = make_and_qual(subquery->jointree->quals, qual);
/*
* We need not change the subquery's hasAggs or hasSublinks flags,
* since we can't be pushing down any aggregates that weren't there
* before, and we don't push down subselects at all.
*/
}
}
/*
* Helper routine to recurse through setOperations tree
*/
static void recurse_push_qual(Node* setOp, Query* topquery, RangeTblEntry* rte, Index rti, Node* qual)
{
if (IsA(setOp, RangeTblRef)) {
RangeTblRef* rtr = (RangeTblRef*)setOp;
RangeTblEntry* subrte = rt_fetch(rtr->rtindex, topquery->rtable);
Query* subquery = subrte->subquery;
AssertEreport(subquery != NULL, MOD_OPT, "");
subquery_push_qual(subquery, rte, rti, qual);
} else if (IsA(setOp, SetOperationStmt)) {
SetOperationStmt* op = (SetOperationStmt*)setOp;
recurse_push_qual(op->larg, topquery, rte, rti, qual);
recurse_push_qual(op->rarg, topquery, rte, rti, qual);
} else {
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE),
errmsg("unrecognized node type when recurse push qual through setOperations tree: %d",
(int)nodeTag(setOp))));
}
}
/*
* partIterator tries to inherit pathkeys from scan path
*
* Now we have done two things
* 1. Build all access paths for partitioned relation
* 2. Prune partitioned relation and know which partitions will be scaned
*
* We just use Partiterator to scan partitions from lowerboundary to upperboundary,
* and we brutally believe that Partiterator's output is disordered，howerver we can
* inherit pathkeys from scan path if the path's output is ordered by partiitonkeys, or
* exactly the opposite. since partiitonkeys is ordered by ASC NULLS LAST
*
* Just refuse to inherit pathkeys if some index on selected partition is unusable
*
* Now we try to inherit pathkeys from scan path as following steps
* 1) pruning result <= 1, since we can treat it as an ordinary table scan,
* 2) the path's output is is order by partkeys, or exactly the opposite.
*/
static void make_partiterator_pathkey(
PlannerInfo* root, RelOptInfo* rel, Relation relation, PartIteratorPath* itrpath, List* pathkeys)
{
int2vector* partitionKey = NULL;
ListCell* pk_cell = NULL;
ListCell* rt_ec_cell = NULL;
Oid indexOid = ((IndexPath*)itrpath->subPath)->indexinfo->indexoid;
IndexesUsableType usable_type = eliminate_partition_index_unusable(indexOid, rel->pruning_result, NULL, NULL);
if (INDEXES_FULL_USABLE != usable_type) {
/* some index partition is unusable */
OPT_LOG(DEBUG2, "fail to inherit pathkeys since some index partition is unusable");
return;
}
if (rel->partItrs <= 1) {
/* inherit pathkeys if pruning result is <= 1 */
itrpath->path.pathkeys = pathkeys;
return;
}
partitionKey = ((RangePartitionMap*)relation->partMap)->partitionKey;
pk_cell = (ListCell*)list_head(pathkeys);
bool pk_state_init = false; /* if all pathkey have same sort direction (ASC or DESC) */
bool pk_nulls_first = false; /* if all pathkey have same NULLs sort direction (FIRST or LAST) */
int pk_strategy = InvalidStrategy;
int partkey_index = 0;
/*
* check if partkeys' sort strategy is the same as pathkeys, or exactly the opposite
*
* create table t(a int, b int, c text) partition by range(a, b)
*
* we can inherit pathkeys only as follwing query
* a) select * from t order by a,b,c;
* b) select * from t order by a,b;
* c) select * from t order by a;
* d) select * from t where a = 1 order by a, b;
* e) select * from t where a = 1 and b = 1 order by a,b,c;
* f) above case with opposite sort strategy
*
* skip ec_collation check since we check var info which contains collation info
*/
for (partkey_index = 0; partkey_index < partitionKey->dim1; partkey_index++) {
PathKey* pathkey = NULL;
EquivalenceClass* pk_ec = NULL;
ListCell* pk_em_cell = NULL;
bool found_partkey = false;
int partkey_varattno = partitionKey->values[partkey_index];
if (!PointerIsValid(pk_cell)) {
/* all pathkeys have been checked */
break;
}
pathkey = (PathKey*)lfirst(pk_cell);
pk_ec = pathkey->pk_eclass;
if (pk_ec->ec_has_volatile) {
/* refuse to inherit pathkeys if sortclause is a volatile expr */
OPT_LOG(DEBUG2,
"partiterator fails to inherit pathkeys since"
" sortclauses contains volatile expr");
return;
}
if (pk_ec->ec_collation != attnumCollationId(relation, partkey_varattno)) {
OPT_LOG(DEBUG2,
"partiterator fails to inherit pathkeys since sortclauses's"
" collation mismatches corresponding partitonkey's collation");
return;
}
foreach (pk_em_cell, pk_ec->ec_members) {
EquivalenceMember* pk_em = (EquivalenceMember*)lfirst(pk_em_cell);
Expr* pk_em_expr = pk_em->em_expr;
/*
* check current pathkey is current partitionkey
* skip ec_below_outer_join check since
*/
if (!bms_equal(pk_em->em_relids, rel->relids)) {
/* skip if EquivalenceMember contains other table's column */
continue;
}
if (pk_em->em_is_const) {
OPT_LOG(DEBUG2,
"partiterator fails to inherit pathkeys since pathkey is"
" a const value which should never happen");
return;
}
if (IsA(pk_em_expr, RelabelType)) {
/*
* RelabelType represents a "dummy" type coercion between two
* binary-compatible datatypes. It is a no-op at runtime, we fetch
* inner expression to build index key Var, just as in ExecIndexBuildScanKeys
*/
pk_em_expr = ((RelabelType*)pk_em_expr)->arg;
}
if (!IsA(pk_em_expr, Var)) {
/* skip if EquivalenceMember is not a var since partitionkey can be treat as a var */
continue;
}
if (((Var*)pk_em_expr)->varattno == partkey_varattno) {
/* EquivalenceMembers is equal to current partitionkey */
found_partkey = true;
if (pk_state_init) {
/*
* if we have found 1st pathkey and have record 1st pathkey's strategy( ASC
* or DESC, NULL FIRST or NULL LAST), just to check if current pathkey's strategy
* is equal to 1st pathkey's strategy
*/
if (pk_nulls_first != pathkey->pk_nulls_first || pk_strategy != pathkey->pk_strategy) {
/* refuse to inherit pathkeys if it is not eqal */
OPT_LOG(DEBUG2,
"partiterator fails to inherit pathkeys since"
"pathkeys have different sort strategy");
return;
}
} else {
/* record 1st pathkey's sort strategy */
pk_state_init = true;
pk_nulls_first = pathkey->pk_nulls_first;
pk_strategy = pathkey->pk_strategy;
if (pk_strategy != BTLessStrategyNumber && pk_strategy != BTGreaterStrategyNumber) {
/*
* refuse to inherit pathkeys if current sort strategy is nether ASC nor
* DESC, should never happen
*/
OPT_LOG(DEBUG2,
"partiterator fails to inherit pathkeys since sort"
" strategy is nether ASC nor DESC");
return;
}
/*
* we do partitionkey comparison just as ''order by ASC NULL LAST'', and pathkey
* must follow the same rules. If sortcluase is ether ''ASC NULL FIRST'' or "DESC
* NULL LAST", just abandon pathkeys
*/
if (!(pk_strategy == BTLessStrategyNumber && pk_nulls_first == false) &&
!(pk_strategy == BTGreaterStrategyNumber && pk_nulls_first == true)) {
OPT_LOG(DEBUG2,
"partiterator fails to inherit pathkeys since sort strategy is"
" nether ASC NULL LAST nor DESC DESC NULL FIRST");
return;
}
}
}
}
if (found_partkey) {
/* find current partitionkey is equal to current pathkey */
pk_cell = lnext(pk_cell);
continue;
}
/*
* if current partitionkey is unequal to current pathkey, check if current
* partitionkey is equal to a const value, since 'order by col1, col2' is the
* same as ''order by col1, const_value, col2'
*/
foreach (rt_ec_cell, root->eq_classes) {
EquivalenceClass* ec = (EquivalenceClass*)lfirst(rt_ec_cell);
ListCell* rt_em_cell = NULL;
if (ec->ec_has_volatile || ec->ec_below_outer_join || !ec->ec_has_const ||
!bms_is_subset(rel->relids, ec->ec_relids)) {
/*
* skip current EquivalenceMember if
* 1. ec_has_volatile = true which means it is a volatile expr
* 2. ec_has_const = false which means it is not a const value
* 3. doesnot contain current partitioned table
*/
continue;
}
foreach (rt_em_cell, ec->ec_members) {
EquivalenceMember* rt_em = (EquivalenceMember*)lfirst(rt_em_cell);
Expr* rt_em_expr = rt_em->em_expr;
if (!bms_equal(rt_em->em_relids, rel->relids)) {
/* skip if EquivalenceMember contains other table's column */
continue;
}
if (IsA(rt_em_expr, RelabelType)) {
rt_em_expr = ((RelabelType*)rt_em_expr)->arg;
}
if (!IsA(rt_em_expr, Var)) {
continue;
}
if (((Var*)rt_em_expr)->varattno == partkey_varattno) {
/* find current partitionkey is equal to a const value */
found_partkey = true;
break;
}
}
if (found_partkey) {
/* current partkey is a const value */
break;
}
}
if (!found_partkey) {
/*
* refuse to inherit pathkeys if current partkey is nether a const value
* nor equal to current pathkey
*/
OPT_LOG(DEBUG2,
"partiterator fails to inherit pathkeys since current"
" partitionkey is nether a const value nor current pathkey");
return;
}
}
itrpath->path.pathkeys = pathkeys;
/*
* we will scan partition from HIGH Boundary to LOW Boundary if
* pathkeys is "order by DESC NULLS FIRST", or scan partition
* from LOW Boundary TO HIGH Boundary, we mark direction flag
* here for iterator method
*/
itrpath->direction = (BTLessStrategyNumber == pk_strategy ? ForwardScanDirection : BackwardScanDirection);
}
static Path* create_partiterator_path(PlannerInfo* root, RelOptInfo* rel, Path* path, Relation relation)
{
Path* result = NULL;
switch (path->pathtype) {
case T_SeqScan:
case T_CStoreScan:
case T_TsStoreScan:
case T_BitmapHeapScan:
case T_TidScan:
case T_IndexScan:
case T_IndexOnlyScan: {
PartIteratorPath* itrpath = makeNode(PartIteratorPath);
itrpath->subPath = path;
itrpath->path.pathtype = T_PartIterator;
itrpath->path.parent = rel;
itrpath->path.param_info = path->param_info;
itrpath->path.pathkeys = NIL;
itrpath->itrs = rel->partItrs;
set_path_rows(&itrpath->path, path->rows, path->multiple);
itrpath->path.startup_cost = path->startup_cost;
itrpath->path.total_cost = path->total_cost;
itrpath->path.dop = path->dop;
/* scan parttition from lower boundary to upper boundary by default */
itrpath->direction = ForwardScanDirection;
if (NIL != path->pathkeys && (T_IndexOnlyScan == path->pathtype || T_IndexScan == path->pathtype)) {
/* try to inherit pathkeys from IndexPath/IndexOnlyScan since only */
make_partiterator_pathkey(root, rel, relation, itrpath, path->pathkeys);
}
#ifdef STREAMPLAN
if (IS_STREAM_PLAN)
inherit_path_locator_info(&(itrpath->path), path);
#endif
result = (Path*)itrpath;
} break;
default: {
ereport(ERROR,
(errmodule(MOD_OPT),
errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE),
errmsg("unrecognized node type when create partiterator path: %d", (int)path->pathtype)));
} break;
}
return result;
}
/*
* try to add control operator PartIterator over scan operator, so we can
* scan all selected partitions
*/
static void try_add_partiterator(PlannerInfo* root, RelOptInfo* rel, RangeTblEntry* rte)
{
ListCell* pathCell = NULL;
Relation relation = NULL;
if (false == rel->isPartitionedTable) {
/* do nothing for non-partitioned table */
return;
}
/* specified lock must have been obtained */
relation = relation_open(rte->relid, NoLock);
foreach (pathCell, rel->pathlist) {
Path* path = (Path*)lfirst(pathCell);
Path* itrPath = NULL;
ListCell* ctPathCell = NULL;
ListCell* cpPathCell = NULL;
/* do not handle inlist2join path for Partition Table */
if (path->parent->base_rel && T_SubqueryScan == path->pathtype) {
Assert(path->parent->base_rel->alternatives != NIL);
continue;
}
itrPath = create_partiterator_path(root, rel, path, relation);
/* replace entry in pathlist */
lfirst(pathCell) = itrPath;
if (path == rel->cheapest_startup_path) {
/* replace cheapest_startup_path */
rel->cheapest_startup_path = itrPath;
}
if (path == rel->cheapest_unique_path) {
/* replace cheapest_unique_path */
rel->cheapest_unique_path = itrPath;
}
/* replace entry in cheapest_total_path */
foreach (ctPathCell, rel->cheapest_total_path) {
if (lfirst(ctPathCell) == path) {
lfirst(ctPathCell) = itrPath;
break;
}
}
/* replace entry in cheapest_parameterized_paths */
foreach (cpPathCell, rel->cheapest_parameterized_paths) {
/* we add cheapest total into cheapest_parameterized_paths in set_cheapest */
if (lfirst(cpPathCell) == path) {
lfirst(cpPathCell) = itrPath;
break;
}
}
}
relation_close(relation, NoLock);
}
/*
* passdown_itst_keys_to_rel:
* For single-table subquery, pass the interested keys to base rel,
* and later it can pass down to root of lower query level
* Paramters:
* @in root: planner info of current query level
* @in brel: single-table subquery rel
* @in rte: corresponding range table entry of brel
* @in inherit_matching_key: if matching key should be passed down, only
* when matching key only comes from this table
*/
static void passdown_itst_keys_to_rel(
PlannerInfo* root, RelOptInfo* brel, RangeTblEntry* rte, bool inherit_matching_key)
{
ListCell* lc = NULL;
/* for matching and superset key pass, there should only be one subquery rel */
if (rte->rtekind != RTE_SUBQUERY)
return;
if (inherit_matching_key)
brel->rel_dis_keys.matching_keys = root->dis_keys.matching_keys;
brel->rel_dis_keys.superset_keys = build_superset_keys_for_rel(root, brel, NULL, NULL, JOIN_INNER);
/* For inherit table (simple union all), we should pass keys down to all its children */
if (rte->inh) {
foreach (lc, root->append_rel_list) {
AppendRelInfo* appinfo = (AppendRelInfo*)lfirst(lc);
Index childRTindex;
RelOptInfo* childrel = NULL;
/* append_rel_list contains all append rels; ignore others */
if (appinfo->parent_relid != brel->relid)
continue;
/* Re-locate the child RTE and RelOptInfo */
childRTindex = appinfo->child_relid;
childrel = root->simple_rel_array[childRTindex];
/* only pass down for subqueries, or it will shared the same root as current */
if (root->simple_rte_array[childRTindex]->rtekind == RTE_SUBQUERY)
childrel->rel_dis_keys = brel->rel_dis_keys;
}
}
}
/*
* is_single_baseresult_plan:
* check if the plan node is single baseresult without lefttree.
* Paramters:
* @in plan: the plan node will be checked.
*/
bool is_single_baseresult_plan(Plan* plan)
{
if (plan == NULL) {
return false;
}
return IsA(plan, BaseResult) ? (plan->lefttree == NULL) : false;
}
/*****************************************************************************
* DEBUG SUPPORT
*****************************************************************************/
#ifdef OPTIMIZER_DEBUG
static void print_relids(Relids relids, List* rtable)
{
Relids tmprelids;
int x;
bool first = true;
RangeTblEntry* rte = NULL;
tmprelids = bms_copy(relids);
while ((x = bms_first_member(tmprelids)) >= 0) {
if (!first)
printf(" ");
printf("%d:", x);
rte = rt_fetch(x, rtable);
printf("%s ", rte->relname);
first = false;
}
bms_free_ext(tmprelids);
}
static void print_restrictclauses(PlannerInfo* root, List* clauses)
{
ListCell* l = NULL;
foreach (l, clauses) {
RestrictInfo* c = (RestrictInfo*)lfirst(l);
print_expr((Node*)c->clause, root->parse->rtable);
if (lnext(l))
printf(", ");
}
}
static void print_path(PlannerInfo* root, Path* path, int indent)
{
const char* ptype = NULL;
bool join = false;
Path* subpath = NULL;
int i;
ptype = nodeTagToString(path->pathtype);
switch (path->pathtype) {
case T_Material:
subpath = ((MaterialPath*)path)->subpath;
break;
case T_Unique:
subpath = ((UniquePath*)path)->subpath;
break;
case T_NestLoop:
join = true;
break;
case T_MergeJoin:
join = true;
break;
case T_HashJoin:
join = true;
break;
#ifdef STREAMPLAN
case T_Stream: {
ptype = StreamTypeToString(((StreamPath*)path)->type);
} break;
#endif
default:
/* noop */
break;
}
for (i = 0; i < indent; i++)
printf("\t");
printf("%s", ptype);
if (path->parent) {
printf("(");
print_relids(path->parent->relids, root->parse->rtable);
printf(") rows=%.0f multiple = %lf", path->parent->rows, path->parent->multiple);
}
printf(" cost=%.2f..%.2f\n", path->startup_cost, path->total_cost);
if (path->pathkeys) {
for (i = 0; i < indent; i++)
printf("\t");
printf(" pathkeys: ");
print_pathkeys(path->pathkeys, root->parse->rtable);
}
if (join) {
JoinPath* jp = (JoinPath*)path;
for (i = 0; i < indent; i++)
printf("\t");
printf(" clauses: ");
print_restrictclauses(root, jp->joinrestrictinfo);
printf("\n");
if (IsA(path, MergePath)) {
MergePath* mp = (MergePath*)path;
for (i = 0; i < indent; i++)
printf("\t");
printf(" sortouter=%d sortinner=%d materializeinner=%d\n",
((mp->outersortkeys) ? 1 : 0),
((mp->innersortkeys) ? 1 : 0),
((mp->materialize_inner) ? 1 : 0));
}
print_path(root, jp->outerjoinpath, indent + 1);
print_path(root, jp->innerjoinpath, indent + 1);
}
if (subpath != NULL)
print_path(root, subpath, indent + 1);
}
void debug_print_rel(PlannerInfo* root, RelOptInfo* rel)
{
ListCell* l = NULL;
printf("RELOPTINFO (");
print_relids(rel->relids, root->parse->rtable);
printf("): rows=%.0f multiple = %lf width=%d\n", rel->rows, rel->multiple, rel->width);
if (rel->baserestrictinfo) {
printf("\tbaserestrictinfo: ");
print_restrictclauses(root, rel->baserestrictinfo);
printf("\n");
}
if (rel->joininfo) {
printf("\tjoininfo: ");
print_restrictclauses(root, rel->joininfo);
printf("\n");
}
printf("\tpath list:\n");
foreach (l, rel->pathlist)
print_path(root, (Path*)lfirst(l), 1);
printf("\n\tcheapest startup path:\n");
print_path(root, rel->cheapest_startup_path, 1);
printf("\n\tcheapest total path:\n");
foreach (l, rel->cheapest_total_path)
print_path(root, (Path*)lfirst(l), 1);
printf("\n");
fflush(stdout);
}
#endif /* OPTIMIZER_DEBUG */
Reference in New Issue View Git Blame Copy Permalink