71 Node *testexpr,
List *testexpr_paramids,
122 if (
plan->targetlist)
164 Node *testexpr,
bool isTopQual)
167 bool simple_exists =
false;
168 double tuple_fraction;
210 tuple_fraction = 1.0;
213 tuple_fraction = 0.5;
215 tuple_fraction = 0.0;
223 false, tuple_fraction);
240 subLinkType, subLinkId,
241 testexpr,
NIL, isTopQual);
264 &newtestexpr, ¶mIds);
304 result = (
Node *) asplan;
323 Node *testexpr,
List *testexpr_paramids,
336 splan->subLinkType = subLinkType;
337 splan->testexpr = NULL;
340 &
splan->firstColCollation);
341 splan->useHashTable =
false;
342 splan->unknownEqFalse = unknownEqFalse;
343 splan->parallel_safe =
plan->parallel_safe;
352 foreach(lc, plan_params)
394 result = (
Node *) prm;
409 result = (
Node *) prm;
421 elog(
ERROR,
"could not find array type for datatype %s",
429 result = (
Node *) prm;
493 if (testexpr && testexpr_paramids ==
NIL)
506 splan->testexpr = testexpr;
507 splan->paramIds = testexpr_paramids;
521 splan->useHashTable =
true;
558 if (
splan->parParam ==
NIL && !isInitPlan && !
splan->useHashTable)
565 isInitPlan ?
"InitPlan" :
"SubPlan",
569 char *ptr =
splan->plan_name + strlen(
splan->plan_name);
571 ptr +=
sprintf(ptr,
" (returns ");
572 foreach(lc,
splan->setParam)
612 result =
lappend(result, param);
727 double subquery_size;
735 subquery_size =
plan->plan_rows *
751 double subquery_size;
759 subquery_size = path->
rows *
852 if (opid == ARRAY_EQ_OP ||
853 opid == RECORD_EQ_OP)
868 elog(
ERROR,
"cache lookup failed for operator %u", opid);
870 if (!optup->oprcanhash || !
func_strict(optup->oprcode))
914 if (cte->cterefcount == 0 && cmdType ==
CMD_SELECT)
954 cte->cterefcount == 1)) &&
955 !cte->cterecursive &&
958 (cte->cterefcount <= 1 ||
983 cte->cterecursive, 0.0);
991 elog(
ERROR,
"unexpected outer reference in CTE query");
1010 splan->testexpr = NULL;
1013 &
splan->firstColCollation);
1014 splan->useHashTable =
false;
1015 splan->unknownEqFalse =
false;
1021 splan->parallel_safe =
false;
1278 List *subquery_vars;
1328 rte = nsitem->p_rte;
1336 rtr->rtindex = rtindex;
1356 result->
larg = NULL;
1358 result->usingClause =
NIL;
1359 result->join_using_alias = NULL;
1360 result->
quals = quals;
1361 result->alias = NULL;
1376 bool under_not,
Relids available_rels)
1482 upper_varnos = NULL;
1486 if (varno <= rtoffset)
1504 subselect->
rtable, subselect->rteperminfos);
1512 result->
larg = NULL;
1518 result->usingClause =
NIL;
1519 result->join_using_alias = NULL;
1520 result->
quals = whereClause;
1521 result->alias = NULL;
1558 query->hasWindowFuncs ||
1559 query->hasTargetSRFs ||
1560 query->hasModifyingCTE ||
1591 limit = (
Const *) node;
1593 if (!limit->constisnull &&
DatumGetInt64(limit->constvalue) <= 0)
1612 query->hasDistinctOn =
false;
1711 leftargs = rightargs = opids = opcollations = newWhere =
NIL;
1712 foreach(lc, (
List *) whereClause)
1724 leftargs =
lappend(leftargs, leftarg);
1725 rightargs =
lappend(rightargs, rightarg);
1727 opcollations =
lappend_oid(opcollations, expr->inputcollid);
1741 leftargs =
lappend(leftargs, rightarg);
1742 rightargs =
lappend(rightargs, leftarg);
1744 opcollations =
lappend_oid(opcollations, expr->inputcollid);
1752 newWhere =
lappend(newWhere, expr);
1758 if (leftargs ==
NIL)
1773 if (root->
parse->hasAggs &&
1811 tlist = testlist = paramids =
NIL;
1813 forfour(lc, leftargs, rc, rightargs, oc, opids, cc, opcollations)
1840 *paramIds = paramids;
1884 if (((
Var *) node)->varlevelsup > 0)
1895 if (((
Aggref *) node)->agglevelsup > 0)
1920 context.
root = root;
1971 if (((
Aggref *) node)->agglevelsup > 0)
2019 newargs =
lappend(newargs, newarg);
2040 newargs =
lappend(newargs, newarg);
2053 (
void *) &locContext);
2088 outer_params = NULL;
2089 for (proot = root->parent_root; proot != NULL; proot = proot->parent_root)
2134 bool unsafe_initplans;
2146 &initplan_cost, &unsafe_initplans);
2157 if (unsafe_initplans)
2165 if (unsafe_initplans)
2196 Cost *initplan_cost_p,
2197 bool *unsafe_initplans_p)
2200 bool unsafe_initplans;
2209 unsafe_initplans =
false;
2210 foreach(lc, init_plans)
2216 unsafe_initplans =
true;
2218 *initplan_cost_p = initplan_cost;
2219 *unsafe_initplans_p = unsafe_initplans;
2295 int locally_added_param;
2305 context.
root = root;
2307 locally_added_param = -1;
2308 nestloop_params = NULL;
2315 initExtParam = initSetParam = NULL;
2316 foreach(l,
plan->initPlan)
2331 valid_params =
bms_union(valid_params, initSetParam);
2348 if (
plan->parallel_aware)
2350 if (gather_param < 0)
2351 elog(
ERROR,
"parallel-aware plan node is not below a Gather");
2388 case T_IndexOnlyScan:
2402 case T_BitmapIndexScan:
2412 case T_BitmapHeapScan:
2424 case T_TidRangeScan:
2430 case T_SubqueryScan:
2439 if (gather_param >= 0)
2443 subquery_params, NULL);
2454 case T_FunctionScan:
2470 funccontext = context;
2476 rtfunc->funcparams = funccontext.
paramids;
2488 case T_TableFuncScan:
2518 elog(
ERROR,
"could not find plan for CteScan referencing plan ID %d",
2536 case T_WorkTableScan:
2543 case T_NamedTuplestoreScan:
2592 locally_added_param = mtplan->
epqParam;
2594 locally_added_param);
2596 locally_added_param);
2708 case T_RecursiveUnion:
2712 locally_added_param);
2720 locally_added_param);
2722 locally_added_param);
2737 aggcontext.
root = root;
2757 locally_added_param = ((
Gather *)
plan)->rescan_param;
2758 if (locally_added_param >= 0)
2761 locally_added_param);
2768 Assert(gather_param < 0);
2770 gather_param = locally_added_param;
2778 if (locally_added_param >= 0)
2781 locally_added_param);
2788 Assert(gather_param < 0);
2790 gather_param = locally_added_param;
2803 case T_IncrementalSort:
2811 elog(
ERROR,
"unrecognized node type: %d",
2823 if (nestloop_params)
2829 bms_union(nestloop_params, valid_params),
2852 if (locally_added_param >= 0)
2855 locally_added_param);
2861 elog(
ERROR,
"plan should not reference subplan's variable");
2879 return plan->allParam;
2895 int paramid = ((
Param *) node)->paramid;
2915 if (aggparam != NULL)
2999 Oid resulttype,
int32 resulttypmod,
3000 Oid resultcollation)
3003 resulttypmod, resultcollation);
Bitmapset * bms_join(Bitmapset *a, Bitmapset *b)
int bms_next_member(const Bitmapset *a, int prevbit)
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
void bms_free(Bitmapset *a)
Bitmapset * bms_add_member(Bitmapset *a, int x)
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Bitmapset * bms_del_member(Bitmapset *a, int x)
Bitmapset * bms_copy(const Bitmapset *a)
#define OidIsValid(objectId)
Node * eval_const_expressions(PlannerInfo *root, Node *node)
bool contain_subplans(Node *clause)
bool contain_volatile_functions(Node *clause)
bool contain_exec_param(Node *clause, List *param_ids)
void cost_subplan(PlannerInfo *root, SubPlan *subplan, Plan *plan)
Plan * create_plan(PlannerInfo *root, Path *best_path)
Plan * materialize_finished_plan(Plan *subplan)
elog(ERROR, "%s: %s", p2, msg)
bool ExecMaterializesOutput(NodeTag plantype)
#define HeapTupleIsValid(tuple)
#define SizeofHeapTupleHeader
Assert(fmt[strlen(fmt) - 1] !='\n')
List * lappend(List *list, void *datum)
List * lappend_int(List *list, int datum)
List * lappend_oid(List *list, Oid datum)
List * list_copy(const List *oldlist)
List * list_concat(List *list1, const List *list2)
bool op_hashjoinable(Oid opno, Oid inputtype)
bool func_strict(Oid funcid)
Oid get_promoted_array_type(Oid typid)
Oid get_commutator(Oid opno)
Expr * make_opclause(Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
Alias * makeAlias(const char *aliasname, List *colnames)
Var * makeVarFromTargetEntry(int varno, TargetEntry *tle)
List * make_ands_implicit(Expr *clause)
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Expr * make_andclause(List *andclauses)
Expr * make_ands_explicit(List *andclauses)
Expr * make_orclause(List *orclauses)
Oid exprType(const Node *expr)
int32 exprTypmod(const Node *expr)
Oid exprCollation(const Node *expr)
#define expression_tree_mutator(n, m, c)
static bool is_andclause(const void *clause)
static bool is_orclause(const void *clause)
#define query_tree_walker(q, w, c, f)
#define QTW_EXAMINE_RTES_AFTER
#define expression_tree_walker(n, w, c)
#define QTW_EXAMINE_RTES_BEFORE
size_t get_hash_memory_limit(void)
#define IsA(nodeptr, _type_)
#define castNode(_type_, nodeptr)
Param * generate_new_exec_param(PlannerInfo *root, Oid paramtype, int32 paramtypmod, Oid paramcollation)
Param * replace_outer_var(PlannerInfo *root, Var *var)
Param * replace_outer_grouping(PlannerInfo *root, GroupingFunc *grp)
Param * replace_outer_placeholdervar(PlannerInfo *root, PlaceHolderVar *phv)
Param * replace_outer_agg(PlannerInfo *root, Aggref *agg)
int assign_special_exec_param(PlannerInfo *root)
ParseState * make_parsestate(ParseState *parentParseState)
ParseNamespaceItem * addRangeTableEntryForSubquery(ParseState *pstate, Query *subquery, Alias *alias, bool lateral, bool inFromCl)
#define planner_subplan_get_plan(root, subplan)
#define lfirst_node(type, lc)
static int list_length(const List *l)
#define linitial_node(type, l)
static ListCell * list_nth_cell(const List *list, int n)
#define forfour(cell1, list1, cell2, list2, cell3, list3, cell4, list4)
static void * list_nth(const List *list, int n)
static ListCell * lnext(const List *l, const ListCell *c)
#define list_make1_int(x1)
#define list_make2(x1, x2)
FormData_pg_operator * Form_pg_operator
PlannerInfo * subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root, bool hasRecursion, double tuple_fraction)
Path * get_cheapest_fractional_path(RelOptInfo *rel, double tuple_fraction)
static int64 DatumGetInt64(Datum X)
static Datum ObjectIdGetDatum(Oid X)
void replace_empty_jointree(Query *parse)
Expr * canonicalize_qual(Expr *qual, bool is_check)
char * psprintf(const char *fmt,...)
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
RelOptInfo * find_base_rel(PlannerInfo *root, int relid)
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
void OffsetVarNodes(Node *node, int offset, int sublevels_up)
void CombineRangeTables(List **dst_rtable, List **dst_perminfos, List *src_rtable, List *src_perminfos)
bool contain_aggs_of_level(Node *node, int levelsup)
void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up, int min_sublevels_up)
Param * find_minmax_agg_replacement_param(PlannerInfo *root, Aggref *aggref)
CTEMaterialize ctematerialized
Bitmapset * rewindPlanIDs
bool hasAlternativeSubPlans
struct Path * cheapest_total_path
static bool contain_dml_walker(Node *node, void *context)
static bool testexpr_is_hashable(Node *testexpr, List *param_ids)
static Node * build_subplan(PlannerInfo *root, Plan *plan, PlannerInfo *subroot, List *plan_params, SubLinkType subLinkType, int subLinkId, Node *testexpr, List *testexpr_paramids, bool unknownEqFalse)
void SS_process_ctes(PlannerInfo *root)
JoinExpr * convert_ANY_sublink_to_join(PlannerInfo *root, SubLink *sublink, Relids available_rels)
void SS_identify_outer_params(PlannerInfo *root)
static bool finalize_agg_primnode(Node *node, finalize_primnode_context *context)
static bool contain_outer_selfref(Node *node)
static List * generate_subquery_vars(PlannerInfo *root, List *tlist, Index varno)
static bool contain_dml(Node *node)
void SS_finalize_plan(PlannerInfo *root, Plan *plan)
static Query * convert_EXISTS_to_ANY(PlannerInfo *root, Query *subselect, Node **testexpr, List **paramIds)
Node * SS_replace_correlation_vars(PlannerInfo *root, Node *expr)
static Node * process_sublinks_mutator(Node *node, process_sublinks_context *context)
Param * SS_make_initplan_output_param(PlannerInfo *root, Oid resulttype, int32 resulttypmod, Oid resultcollation)
struct process_sublinks_context process_sublinks_context
static Node * replace_correlation_vars_mutator(Node *node, PlannerInfo *root)
static bool test_opexpr_is_hashable(OpExpr *testexpr, List *param_ids)
static List * generate_subquery_params(PlannerInfo *root, List *tlist, List **paramIds)
static Node * convert_testexpr(PlannerInfo *root, Node *testexpr, List *subst_nodes)
static bool subpath_is_hashable(Path *path)
static Node * make_subplan(PlannerInfo *root, Query *orig_subquery, SubLinkType subLinkType, int subLinkId, Node *testexpr, bool isTopQual)
static bool contain_outer_selfref_walker(Node *node, Index *depth)
struct convert_testexpr_context convert_testexpr_context
static bool hash_ok_operator(OpExpr *expr)
static void inline_cte(PlannerInfo *root, CommonTableExpr *cte)
JoinExpr * convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink, bool under_not, Relids available_rels)
static bool subplan_is_hashable(Plan *plan)
static bool simplify_EXISTS_query(PlannerInfo *root, Query *query)
struct finalize_primnode_context finalize_primnode_context
static bool finalize_primnode(Node *node, finalize_primnode_context *context)
static void get_first_col_type(Plan *plan, Oid *coltype, int32 *coltypmod, Oid *colcollation)
static bool inline_cte_walker(Node *node, inline_cte_walker_context *context)
void SS_attach_initplans(PlannerInfo *root, Plan *plan)
Node * SS_process_sublinks(PlannerInfo *root, Node *expr, bool isQual)
void SS_compute_initplan_cost(List *init_plans, Cost *initplan_cost_p, bool *unsafe_initplans_p)
void SS_charge_for_initplans(PlannerInfo *root, RelOptInfo *final_rel)
static Node * convert_testexpr_mutator(Node *node, convert_testexpr_context *context)
struct inline_cte_walker_context inline_cte_walker_context
void SS_make_initplan_from_plan(PlannerInfo *root, PlannerInfo *subroot, Plan *plan, Param *prm)
static Bitmapset * finalize_plan(PlannerInfo *root, Plan *plan, int gather_param, Bitmapset *valid_params, Bitmapset *scan_params)
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
bool contain_vars_of_level(Node *node, int levelsup)
bool contain_var_clause(Node *node)
Relids pull_varnos(PlannerInfo *root, Node *node)