PostgreSQL Source Code git master
Functions
paramassign.c File Reference
#include "postgres.h"
#include "nodes/nodeFuncs.h"
#include "nodes/plannodes.h"
#include "optimizer/paramassign.h"
#include "optimizer/placeholder.h"
#include "rewrite/rewriteManip.h"
Include dependency graph for paramassign.c:

Go to the source code of this file.

Functions

static int  assign_param_for_var (PlannerInfo *root, Var *var)
 
Param *  replace_outer_var (PlannerInfo *root, Var *var)
 
static int  assign_param_for_placeholdervar (PlannerInfo *root, PlaceHolderVar *phv)
 
Param *  replace_outer_placeholdervar (PlannerInfo *root, PlaceHolderVar *phv)
 
Param *  replace_outer_agg (PlannerInfo *root, Aggref *agg)
 
Param *  replace_outer_grouping (PlannerInfo *root, GroupingFunc *grp)
 
Param *  replace_outer_merge_support (PlannerInfo *root, MergeSupportFunc *msf)
 
Param *  replace_outer_returning (PlannerInfo *root, ReturningExpr *rexpr)
 
Param *  replace_nestloop_param_var (PlannerInfo *root, Var *var)
 
Param *  replace_nestloop_param_placeholdervar (PlannerInfo *root, PlaceHolderVar *phv)
 
void  process_subquery_nestloop_params (PlannerInfo *root, List *subplan_params)
 
List *  identify_current_nestloop_params (PlannerInfo *root, Relids leftrelids, Relids outerrelids)
 
Param *  generate_new_exec_param (PlannerInfo *root, Oid paramtype, int32 paramtypmod, Oid paramcollation)
 
int  assign_special_exec_param (PlannerInfo *root)
 

Function Documentation

◆ assign_param_for_placeholdervar()

static int assign_param_for_placeholdervar ( PlannerInfo *  root,
PlaceHolderVar *  phv 
)
static

Definition at line 150 of file paramassign.c.

151{
152 ListCell *ppl;
153 PlannerParamItem *pitem;
154 Index levelsup;
155
156 /* Find the query level the PHV belongs to */
157 for (levelsup = phv->phlevelsup; levelsup > 0; levelsup--)
158 root = root->parent_root;
159
160 /* If there's already a matching PlannerParamItem there, just use it */
161 foreach(ppl, root->plan_params)
162 {
163 pitem = (PlannerParamItem *) lfirst(ppl);
164 if (IsA(pitem->item, PlaceHolderVar))
165 {
166 PlaceHolderVar *pphv = (PlaceHolderVar *) pitem->item;
167
168 /* We assume comparing the PHIDs is sufficient */
169 if (pphv->phid == phv->phid)
170 return pitem->paramId;
171 }
172 }
173
174 /* Nope, so make a new one */
175 phv = copyObject(phv);
176 IncrementVarSublevelsUp((Node *) phv, -((int) phv->phlevelsup), 0);
177 Assert(phv->phlevelsup == 0);
178
179 pitem = makeNode(PlannerParamItem);
180 pitem->item = (Node *) phv;
181 pitem->paramId = list_length(root->glob->paramExecTypes);
182 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
183 exprType((Node *) phv->phexpr));
184
185 root->plan_params = lappend(root->plan_params, pitem);
186
187 return pitem->paramId;
188}
unsigned int Index
Definition: c.h:619
Assert(PointerIsAligned(start, uint64))
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
List * lappend(List *list, void *datum)
Definition: list.c:339
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
#define copyObject(obj)
Definition: nodes.h:232
#define makeNode(_type_)
Definition: nodes.h:161
#define lfirst(lc)
Definition: pg_list.h:172
static int list_length(const List *l)
Definition: pg_list.h:152
tree ctl root
Definition: radixtree.h:1857
void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up, int min_sublevels_up)
Definition: rewriteManip.c:884
Definition: nodes.h:135
Index phid
Definition: pathnodes.h:2934
Index phlevelsup
Definition: pathnodes.h:2937
Definition: pg_list.h:46

References Assert(), copyObject, exprType(), if(), IncrementVarSublevelsUp(), IsA, PlannerParamItem::item, lappend(), lappend_oid(), lfirst, list_length(), makeNode, PlannerParamItem::paramId, PlaceHolderVar::phid, PlaceHolderVar::phlevelsup, and root.

Referenced by replace_outer_placeholdervar().

◆ assign_param_for_var()

static int assign_param_for_var ( PlannerInfo *  root,
Var *  var 
)
static

Definition at line 66 of file paramassign.c.

67{
68 ListCell *ppl;
69 PlannerParamItem *pitem;
70 Index levelsup;
71
72 /* Find the query level the Var belongs to */
73 for (levelsup = var->varlevelsup; levelsup > 0; levelsup--)
74 root = root->parent_root;
75
76 /* If there's already a matching PlannerParamItem there, just use it */
77 foreach(ppl, root->plan_params)
78 {
79 pitem = (PlannerParamItem *) lfirst(ppl);
80 if (IsA(pitem->item, Var))
81 {
82 Var *pvar = (Var *) pitem->item;
83
84 /*
85 * This comparison must match _equalVar(), except for ignoring
86 * varlevelsup. Note that _equalVar() ignores varnosyn,
87 * varattnosyn, and location, so this does too.
88 */
89 if (pvar->varno == var->varno &&
90 pvar->varattno == var->varattno &&
91 pvar->vartype == var->vartype &&
92 pvar->vartypmod == var->vartypmod &&
93 pvar->varcollid == var->varcollid &&
94 pvar->varreturningtype == var->varreturningtype &&
95 bms_equal(pvar->varnullingrels, var->varnullingrels))
96 return pitem->paramId;
97 }
98 }
99
100 /* Nope, so make a new one */
101 var = copyObject(var);
102 var->varlevelsup = 0;
103
104 pitem = makeNode(PlannerParamItem);
105 pitem->item = (Node *) var;
106 pitem->paramId = list_length(root->glob->paramExecTypes);
107 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
108 var->vartype);
109
110 root->plan_params = lappend(root->plan_params, pitem);
111
112 return pitem->paramId;
113}
bool bms_equal(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:142
Definition: primnodes.h:262
AttrNumber varattno
Definition: primnodes.h:274
int varno
Definition: primnodes.h:269
VarReturningType varreturningtype
Definition: primnodes.h:297
Index varlevelsup
Definition: primnodes.h:294

References bms_equal(), copyObject, if(), IsA, PlannerParamItem::item, lappend(), lappend_oid(), lfirst, list_length(), makeNode, PlannerParamItem::paramId, root, Var::varattno, Var::varlevelsup, Var::varno, and Var::varreturningtype.

Referenced by replace_outer_var().

◆ assign_special_exec_param()

int assign_special_exec_param ( PlannerInfo *  root )

Definition at line 754 of file paramassign.c.

755{
756 int paramId = list_length(root->glob->paramExecTypes);
757
758 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
759 InvalidOid);
760 return paramId;
761}
#define InvalidOid
Definition: postgres_ext.h:37

References InvalidOid, lappend_oid(), list_length(), and root.

Referenced by create_gather_merge_plan(), create_gather_plan(), grouping_planner(), SS_process_ctes(), and subquery_planner().

◆ generate_new_exec_param()

Param * generate_new_exec_param ( PlannerInfo *  root,
Oid  paramtype,
int32  paramtypmod,
Oid  paramcollation 
)

Definition at line 727 of file paramassign.c.

729{
730 Param *retval;
731
732 retval = makeNode(Param);
733 retval->paramkind = PARAM_EXEC;
734 retval->paramid = list_length(root->glob->paramExecTypes);
735 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
736 paramtype);
737 retval->paramtype = paramtype;
738 retval->paramtypmod = paramtypmod;
739 retval->paramcollid = paramcollation;
740 retval->location = -1;
741
742 return retval;
743}
@ PARAM_EXEC
Definition: primnodes.h:385
Definition: primnodes.h:391
ParseLoc location
Definition: primnodes.h:403
int32 paramtypmod
Definition: primnodes.h:399
int paramid
Definition: primnodes.h:396
Oid paramtype
Definition: primnodes.h:397
ParamKind paramkind
Definition: primnodes.h:395
Oid paramcollid
Definition: primnodes.h:401

References lappend_oid(), list_length(), Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, and root.

Referenced by build_subplan(), convert_EXISTS_to_ANY(), generate_subquery_params(), replace_nestloop_param_placeholdervar(), replace_nestloop_param_var(), and SS_make_initplan_output_param().

◆ identify_current_nestloop_params()

List * identify_current_nestloop_params ( PlannerInfo *  root,
Relids  leftrelids,
Relids  outerrelids 
)

Definition at line 622 of file paramassign.c.

625{
626 List *result;
627 Relids allleftrelids;
628 ListCell *cell;
629
630 /*
631 * We'll be able to evaluate a PHV in the lefthand path if it uses the
632 * lefthand rels plus any available required-outer rels. But don't do so
633 * if it uses *only* required-outer rels; in that case it should be
634 * evaluated higher in the tree. For Vars, no such hair-splitting is
635 * necessary since they depend on only one relid.
636 */
637 if (outerrelids)
638 allleftrelids = bms_union(leftrelids, outerrelids);
639 else
640 allleftrelids = leftrelids;
641
642 result = NIL;
643 foreach(cell, root->curOuterParams)
644 {
645 NestLoopParam *nlp = (NestLoopParam *) lfirst(cell);
646
647 /*
648 * We are looking for Vars and PHVs that can be supplied by the
649 * lefthand rels. When we find one, it's okay to modify it in-place
650 * because all the routines above make a fresh copy to put into
651 * curOuterParams.
652 */
653 if (IsA(nlp->paramval, Var) &&
654 bms_is_member(nlp->paramval->varno, leftrelids))
655 {
656 Var *var = (Var *) nlp->paramval;
657 RelOptInfo *rel = root->simple_rel_array[var->varno];
658
659 root->curOuterParams = foreach_delete_current(root->curOuterParams,
660 cell);
661 var->varnullingrels = bms_intersect(rel->nulling_relids,
662 leftrelids);
663 result = lappend(result, nlp);
664 }
665 else if (IsA(nlp->paramval, PlaceHolderVar))
666 {
667 PlaceHolderVar *phv = (PlaceHolderVar *) nlp->paramval;
669 Relids eval_at = phinfo->ph_eval_at;
670
671 if (bms_is_subset(eval_at, allleftrelids) &&
672 bms_overlap(eval_at, leftrelids))
673 {
674 root->curOuterParams = foreach_delete_current(root->curOuterParams,
675 cell);
676
677 /*
678 * Deal with an edge case: if the PHV was pulled up out of a
679 * subquery and it contains a subquery that was originally
680 * pushed down from this query level, then that will still be
681 * represented as a SubLink, because SS_process_sublinks won't
682 * recurse into outer PHVs, so it didn't get transformed
683 * during expression preprocessing in the subquery. We need a
684 * version of the PHV that has a SubPlan, which we can get
685 * from the current query level's placeholder_list. This is
686 * quite grotty of course, but dealing with it earlier in the
687 * handling of subplan params would be just as grotty, and it
688 * might end up being a waste of cycles if we don't decide to
689 * treat the PHV as a NestLoopParam. (Perhaps that whole
690 * mechanism should be redesigned someday, but today is not
691 * that day.)
692 */
693 if (root->parse->hasSubLinks)
694 {
695 phv = copyObject(phinfo->ph_var);
696
697 /*
698 * The ph_var will have empty nullingrels, but that
699 * doesn't matter since we're about to overwrite
700 * phv->phnullingrels. Other fields should be OK already.
701 */
702 nlp->paramval = (Var *) phv;
703 }
704
705 phv->phnullingrels =
707 leftrelids);
708
709 result = lappend(result, nlp);
710 }
711 }
712 }
713 return result;
714}
Bitmapset * bms_intersect(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:292
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:412
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:251
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:582
#define NIL
Definition: pg_list.h:68
#define foreach_delete_current(lst, var_or_cell)
Definition: pg_list.h:391
Relids get_placeholder_nulling_relids(PlannerInfo *root, PlaceHolderInfo *phinfo)
Definition: placeholder.c:559
PlaceHolderInfo * find_placeholder_info(PlannerInfo *root, PlaceHolderVar *phv)
Definition: placeholder.c:83
Definition: pg_list.h:54
Var * paramval
Definition: plannodes.h:993
Relids phnullingrels
Definition: pathnodes.h:2931

References bms_intersect(), bms_is_member(), bms_is_subset(), bms_overlap(), bms_union(), copyObject, find_placeholder_info(), foreach_delete_current, get_placeholder_nulling_relids(), IsA, lappend(), lfirst, NIL, NestLoopParam::paramval, PlaceHolderVar::phnullingrels, root, and Var::varno.

Referenced by create_nestloop_plan().

◆ process_subquery_nestloop_params()

void process_subquery_nestloop_params ( PlannerInfo *  root,
List *  subplan_params 
)

Definition at line 527 of file paramassign.c.

528{
529 ListCell *lc;
530
531 foreach(lc, subplan_params)
532 {
534
535 if (IsA(pitem->item, Var))
536 {
537 Var *var = (Var *) pitem->item;
538 NestLoopParam *nlp;
539 ListCell *lc2;
540
541 /* If not from a nestloop outer rel, complain */
542 if (!bms_is_member(var->varno, root->curOuterRels))
543 elog(ERROR, "non-LATERAL parameter required by subquery");
544
545 /* Is this param already listed in root->curOuterParams? */
546 foreach(lc2, root->curOuterParams)
547 {
548 nlp = (NestLoopParam *) lfirst(lc2);
549 if (nlp->paramno == pitem->paramId)
550 {
551 Assert(equal(var, nlp->paramval));
552 /* Present, so nothing to do */
553 break;
554 }
555 }
556 if (lc2 == NULL)
557 {
558 /* No, so add it */
559 nlp = makeNode(NestLoopParam);
560 nlp->paramno = pitem->paramId;
561 nlp->paramval = copyObject(var);
562 root->curOuterParams = lappend(root->curOuterParams, nlp);
563 }
564 }
565 else if (IsA(pitem->item, PlaceHolderVar))
566 {
567 PlaceHolderVar *phv = (PlaceHolderVar *) pitem->item;
568 NestLoopParam *nlp;
569 ListCell *lc2;
570
571 /* If not from a nestloop outer rel, complain */
572 if (!bms_is_subset(find_placeholder_info(root, phv)->ph_eval_at,
573 root->curOuterRels))
574 elog(ERROR, "non-LATERAL parameter required by subquery");
575
576 /* Is this param already listed in root->curOuterParams? */
577 foreach(lc2, root->curOuterParams)
578 {
579 nlp = (NestLoopParam *) lfirst(lc2);
580 if (nlp->paramno == pitem->paramId)
581 {
582 Assert(equal(phv, nlp->paramval));
583 /* Present, so nothing to do */
584 break;
585 }
586 }
587 if (lc2 == NULL)
588 {
589 /* No, so add it */
590 nlp = makeNode(NestLoopParam);
591 nlp->paramno = pitem->paramId;
592 nlp->paramval = (Var *) copyObject(phv);
593 root->curOuterParams = lappend(root->curOuterParams, nlp);
594 }
595 }
596 else
597 elog(ERROR, "unexpected type of subquery parameter");
598 }
599}
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:223
#define lfirst_node(type, lc)
Definition: pg_list.h:176

References Assert(), bms_is_member(), bms_is_subset(), copyObject, elog, equal(), ERROR, find_placeholder_info(), if(), IsA, PlannerParamItem::item, lappend(), lfirst, lfirst_node, makeNode, PlannerParamItem::paramId, root, and Var::varno.

Referenced by create_subqueryscan_plan().

◆ replace_nestloop_param_placeholdervar()

Param * replace_nestloop_param_placeholdervar ( PlannerInfo *  root,
PlaceHolderVar *  phv 
)

Definition at line 463 of file paramassign.c.

464{
465 Param *param;
466 NestLoopParam *nlp;
467 ListCell *lc;
468
469 /* Is this PHV already listed in root->curOuterParams? */
470 foreach(lc, root->curOuterParams)
471 {
472 nlp = (NestLoopParam *) lfirst(lc);
473 if (equal(phv, nlp->paramval))
474 {
475 /* Yes, so just make a Param referencing this NLP's slot */
476 param = makeNode(Param);
477 param->paramkind = PARAM_EXEC;
478 param->paramid = nlp->paramno;
479 param->paramtype = exprType((Node *) phv->phexpr);
480 param->paramtypmod = exprTypmod((Node *) phv->phexpr);
481 param->paramcollid = exprCollation((Node *) phv->phexpr);
482 param->location = -1;
483 return param;
484 }
485 }
486
487 /* No, so assign a PARAM_EXEC slot for a new NLP */
489 exprType((Node *) phv->phexpr),
490 exprTypmod((Node *) phv->phexpr),
491 exprCollation((Node *) phv->phexpr));
492
493 /* Add it to the list of required NLPs */
494 nlp = makeNode(NestLoopParam);
495 nlp->paramno = param->paramid;
496 nlp->paramval = (Var *) copyObject(phv);
497 root->curOuterParams = lappend(root->curOuterParams, nlp);
498
499 /* And return the replacement Param */
500 return param;
501}
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:301
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:821
Param * generate_new_exec_param(PlannerInfo *root, Oid paramtype, int32 paramtypmod, Oid paramcollation)
Definition: paramassign.c:727
int paramno
Definition: plannodes.h:991

References copyObject, equal(), exprCollation(), exprType(), exprTypmod(), generate_new_exec_param(), lappend(), lfirst, Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, NestLoopParam::paramno, Param::paramtype, Param::paramtypmod, NestLoopParam::paramval, and root.

Referenced by replace_nestloop_params_mutator().

◆ replace_nestloop_param_var()

Param * replace_nestloop_param_var ( PlannerInfo *  root,
Var *  var 
)

Definition at line 414 of file paramassign.c.

415{
416 Param *param;
417 NestLoopParam *nlp;
418 ListCell *lc;
419
420 /* Is this Var already listed in root->curOuterParams? */
421 foreach(lc, root->curOuterParams)
422 {
423 nlp = (NestLoopParam *) lfirst(lc);
424 if (equal(var, nlp->paramval))
425 {
426 /* Yes, so just make a Param referencing this NLP's slot */
427 param = makeNode(Param);
428 param->paramkind = PARAM_EXEC;
429 param->paramid = nlp->paramno;
430 param->paramtype = var->vartype;
431 param->paramtypmod = var->vartypmod;
432 param->paramcollid = var->varcollid;
433 param->location = var->location;
434 return param;
435 }
436 }
437
438 /* No, so assign a PARAM_EXEC slot for a new NLP */
440 var->vartype,
441 var->vartypmod,
442 var->varcollid);
443 param->location = var->location;
444
445 /* Add it to the list of required NLPs */
446 nlp = makeNode(NestLoopParam);
447 nlp->paramno = param->paramid;
448 nlp->paramval = copyObject(var);
449 root->curOuterParams = lappend(root->curOuterParams, nlp);
450
451 /* And return the replacement Param */
452 return param;
453}
ParseLoc location
Definition: primnodes.h:310

References copyObject, equal(), generate_new_exec_param(), lappend(), lfirst, Var::location, Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, NestLoopParam::paramno, Param::paramtype, Param::paramtypmod, NestLoopParam::paramval, and root.

Referenced by replace_nestloop_params_mutator().

◆ replace_outer_agg()

Param * replace_outer_agg ( PlannerInfo *  root,
Aggref *  agg 
)

Definition at line 225 of file paramassign.c.

226{
227 Param *retval;
228 PlannerParamItem *pitem;
229 Index levelsup;
230
231 Assert(agg->agglevelsup > 0 && agg->agglevelsup < root->query_level);
232
233 /* Find the query level the Aggref belongs to */
234 for (levelsup = agg->agglevelsup; levelsup > 0; levelsup--)
235 root = root->parent_root;
236
237 /*
238 * It does not seem worthwhile to try to de-duplicate references to outer
239 * aggs. Just make a new slot every time.
240 */
241 agg = copyObject(agg);
242 IncrementVarSublevelsUp((Node *) agg, -((int) agg->agglevelsup), 0);
243 Assert(agg->agglevelsup == 0);
244
245 pitem = makeNode(PlannerParamItem);
246 pitem->item = (Node *) agg;
247 pitem->paramId = list_length(root->glob->paramExecTypes);
248 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
249 agg->aggtype);
250
251 root->plan_params = lappend(root->plan_params, pitem);
252
253 retval = makeNode(Param);
254 retval->paramkind = PARAM_EXEC;
255 retval->paramid = pitem->paramId;
256 retval->paramtype = agg->aggtype;
257 retval->paramtypmod = -1;
258 retval->paramcollid = agg->aggcollid;
259 retval->location = agg->location;
260
261 return retval;
262}

References Assert(), copyObject, IncrementVarSublevelsUp(), PlannerParamItem::item, lappend(), lappend_oid(), list_length(), Param::location, Aggref::location, makeNode, PARAM_EXEC, Param::paramcollid, PlannerParamItem::paramId, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, and root.

Referenced by replace_correlation_vars_mutator().

◆ replace_outer_grouping()

Param * replace_outer_grouping ( PlannerInfo *  root,
GroupingFunc *  grp 
)

Definition at line 271 of file paramassign.c.

272{
273 Param *retval;
274 PlannerParamItem *pitem;
275 Index levelsup;
276 Oid ptype = exprType((Node *) grp);
277
278 Assert(grp->agglevelsup > 0 && grp->agglevelsup < root->query_level);
279
280 /* Find the query level the GroupingFunc belongs to */
281 for (levelsup = grp->agglevelsup; levelsup > 0; levelsup--)
282 root = root->parent_root;
283
284 /*
285 * It does not seem worthwhile to try to de-duplicate references to outer
286 * aggs. Just make a new slot every time.
287 */
288 grp = copyObject(grp);
289 IncrementVarSublevelsUp((Node *) grp, -((int) grp->agglevelsup), 0);
290 Assert(grp->agglevelsup == 0);
291
292 pitem = makeNode(PlannerParamItem);
293 pitem->item = (Node *) grp;
294 pitem->paramId = list_length(root->glob->paramExecTypes);
295 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
296 ptype);
297
298 root->plan_params = lappend(root->plan_params, pitem);
299
300 retval = makeNode(Param);
301 retval->paramkind = PARAM_EXEC;
302 retval->paramid = pitem->paramId;
303 retval->paramtype = ptype;
304 retval->paramtypmod = -1;
305 retval->paramcollid = InvalidOid;
306 retval->location = grp->location;
307
308 return retval;
309}
unsigned int Oid
Definition: postgres_ext.h:32
Index agglevelsup
Definition: primnodes.h:570

References GroupingFunc::agglevelsup, Assert(), copyObject, exprType(), IncrementVarSublevelsUp(), InvalidOid, PlannerParamItem::item, lappend(), lappend_oid(), list_length(), Param::location, GroupingFunc::location, makeNode, PARAM_EXEC, Param::paramcollid, PlannerParamItem::paramId, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, and root.

Referenced by replace_correlation_vars_mutator().

◆ replace_outer_merge_support()

Param * replace_outer_merge_support ( PlannerInfo *  root,
MergeSupportFunc *  msf 
)

Definition at line 318 of file paramassign.c.

319{
320 Param *retval;
321 PlannerParamItem *pitem;
322 Oid ptype = exprType((Node *) msf);
323
324 Assert(root->parse->commandType != CMD_MERGE);
325
326 /*
327 * The parser should have ensured that the MergeSupportFunc is in the
328 * RETURNING list of an upper-level MERGE query, so find that query.
329 */
330 do
331 {
332 root = root->parent_root;
333 if (root == NULL)
334 elog(ERROR, "MergeSupportFunc found outside MERGE");
335 } while (root->parse->commandType != CMD_MERGE);
336
337 /*
338 * It does not seem worthwhile to try to de-duplicate references to outer
339 * MergeSupportFunc expressions. Just make a new slot every time.
340 */
341 msf = copyObject(msf);
342
343 pitem = makeNode(PlannerParamItem);
344 pitem->item = (Node *) msf;
345 pitem->paramId = list_length(root->glob->paramExecTypes);
346 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
347 ptype);
348
349 root->plan_params = lappend(root->plan_params, pitem);
350
351 retval = makeNode(Param);
352 retval->paramkind = PARAM_EXEC;
353 retval->paramid = pitem->paramId;
354 retval->paramtype = ptype;
355 retval->paramtypmod = -1;
356 retval->paramcollid = InvalidOid;
357 retval->location = msf->location;
358
359 return retval;
360}
@ CMD_MERGE
Definition: nodes.h:279
ParseLoc location
Definition: primnodes.h:668

References Assert(), CMD_MERGE, copyObject, elog, ERROR, exprType(), InvalidOid, PlannerParamItem::item, lappend(), lappend_oid(), list_length(), Param::location, MergeSupportFunc::location, makeNode, PARAM_EXEC, Param::paramcollid, PlannerParamItem::paramId, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, and root.

Referenced by replace_correlation_vars_mutator().

◆ replace_outer_placeholdervar()

Param * replace_outer_placeholdervar ( PlannerInfo *  root,
PlaceHolderVar *  phv 
)

Definition at line 198 of file paramassign.c.

199{
200 Param *retval;
201 int i;
202
203 Assert(phv->phlevelsup > 0 && phv->phlevelsup < root->query_level);
204
205 /* Find the PHV in the appropriate plan_params, or add it if not present */
207
208 retval = makeNode(Param);
209 retval->paramkind = PARAM_EXEC;
210 retval->paramid = i;
211 retval->paramtype = exprType((Node *) phv->phexpr);
212 retval->paramtypmod = exprTypmod((Node *) phv->phexpr);
213 retval->paramcollid = exprCollation((Node *) phv->phexpr);
214 retval->location = -1;
215
216 return retval;
217}
i
int i
Definition: isn.c:77
static int assign_param_for_placeholdervar(PlannerInfo *root, PlaceHolderVar *phv)
Definition: paramassign.c:150

References Assert(), assign_param_for_placeholdervar(), exprCollation(), exprType(), exprTypmod(), i, Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, PlaceHolderVar::phlevelsup, and root.

Referenced by replace_correlation_vars_mutator().

◆ replace_outer_returning()

Param * replace_outer_returning ( PlannerInfo *  root,
ReturningExpr *  rexpr 
)

Definition at line 368 of file paramassign.c.

369{
370 Param *retval;
371 PlannerParamItem *pitem;
372 Index levelsup;
373 Oid ptype = exprType((Node *) rexpr->retexpr);
374
375 Assert(rexpr->retlevelsup > 0 && rexpr->retlevelsup < root->query_level);
376
377 /* Find the query level the ReturningExpr belongs to */
378 for (levelsup = rexpr->retlevelsup; levelsup > 0; levelsup--)
379 root = root->parent_root;
380
381 /*
382 * It does not seem worthwhile to try to de-duplicate references to outer
383 * ReturningExprs. Just make a new slot every time.
384 */
385 rexpr = copyObject(rexpr);
386 IncrementVarSublevelsUp((Node *) rexpr, -((int) rexpr->retlevelsup), 0);
387 Assert(rexpr->retlevelsup == 0);
388
389 pitem = makeNode(PlannerParamItem);
390 pitem->item = (Node *) rexpr;
391 pitem->paramId = list_length(root->glob->paramExecTypes);
392 root->glob->paramExecTypes = lappend_oid(root->glob->paramExecTypes,
393 ptype);
394
395 root->plan_params = lappend(root->plan_params, pitem);
396
397 retval = makeNode(Param);
398 retval->paramkind = PARAM_EXEC;
399 retval->paramid = pitem->paramId;
400 retval->paramtype = ptype;
401 retval->paramtypmod = exprTypmod((Node *) rexpr->retexpr);
402 retval->paramcollid = exprCollation((Node *) rexpr->retexpr);
403 retval->location = exprLocation((Node *) rexpr->retexpr);
404
405 return retval;
406}
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1388
int retlevelsup
Definition: primnodes.h:2174
Expr * retexpr
Definition: primnodes.h:2176

References Assert(), copyObject, exprCollation(), exprLocation(), exprType(), exprTypmod(), IncrementVarSublevelsUp(), PlannerParamItem::item, lappend(), lappend_oid(), list_length(), Param::location, makeNode, PARAM_EXEC, Param::paramcollid, PlannerParamItem::paramId, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, ReturningExpr::retexpr, ReturningExpr::retlevelsup, and root.

Referenced by replace_correlation_vars_mutator().

◆ replace_outer_var()

Param * replace_outer_var ( PlannerInfo *  root,
Var *  var 
)

Definition at line 121 of file paramassign.c.

122{
123 Param *retval;
124 int i;
125
126 Assert(var->varlevelsup > 0 && var->varlevelsup < root->query_level);
127
128 /* Find the Var in the appropriate plan_params, or add it if not present */
130
131 retval = makeNode(Param);
132 retval->paramkind = PARAM_EXEC;
133 retval->paramid = i;
134 retval->paramtype = var->vartype;
135 retval->paramtypmod = var->vartypmod;
136 retval->paramcollid = var->varcollid;
137 retval->location = var->location;
138
139 return retval;
140}
static int assign_param_for_var(PlannerInfo *root, Var *var)
Definition: paramassign.c:66

References Assert(), assign_param_for_var(), i, Var::location, Param::location, makeNode, PARAM_EXEC, Param::paramcollid, Param::paramid, Param::paramkind, Param::paramtype, Param::paramtypmod, root, and Var::varlevelsup.

Referenced by replace_correlation_vars_mutator().

AltStyle によって変換されたページ (->オリジナル) /