static RelOptInfo * recurse_set_operations(Node *setOp, PlannerInfo *root, SetOperationStmt *parentOp, List *colTypes, List *colCollations, List *refnames_tlist, List **pTargetList, bool *istrivial_tlist)

Definition: prepunion.c:213

generate_recursion_path

static RelOptInfo * generate_recursion_path(SetOperationStmt *setOp, PlannerInfo *root, List *refnames_tlist, List **pTargetList)

Definition: prepunion.c:364

setup_simple_rel_arrays

void setup_simple_rel_arrays(PlannerInfo *root)

Definition: relnode.c:94

Query::targetList

List * targetList

Definition: parsenodes.h:198

RangeTblEntry::subquery

Query * subquery

Definition: parsenodes.h:1135

RelOptInfo

Definition: pathnodes.h:910

SetOperationStmt::larg

Node * larg

Definition: parsenodes.h:2257

References Assert(), castNode, generate_recursion_path(), IsA, SetOperationStmt::larg, NIL, parse(), recurse_set_operations(), root, setup_simple_rel_arrays(), RangeTblEntry::subquery, and Query::targetList.

Referenced by grouping_planner().

◆ preprocess_aggrefs()

void preprocess_aggrefs ( PlannerInfo * root,

Node * clause

)

Definition at line 110 of file prepagg.c.

111{

112 (void) preprocess_aggrefs_walker(clause, root);

113}

preprocess_aggrefs_walker

static bool preprocess_aggrefs_walker(Node *node, PlannerInfo *root)

Definition: prepagg.c:344

References preprocess_aggrefs_walker(), and root.

Referenced by grouping_planner().

◆ preprocess_function_rtes()

void preprocess_function_rtes ( PlannerInfo * root )

Definition at line 1093 of file prepjointree.c.

1094{

1095 ListCell *rt;

1096

1097 foreach(rt, root->parse->rtable)

1098 {

1099 RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);

1100

1101 if (rte->rtekind == RTE_FUNCTION)

1102 {

1103 Query *funcquery;

1104

1105 /* Apply const-simplification */

1106 rte->functions = (List *)

1107 eval_const_expressions(root, (Node *) rte->functions);

1108

1109 /* Check safety of expansion, and expand if possible */

1110 funcquery = inline_set_returning_function(root, rte);

1111 if (funcquery)

1112 {

1113 /* Successful expansion, convert the RTE to a subquery */

1114 rte->rtekind = RTE_SUBQUERY;

1115 rte->subquery = funcquery;

1116 rte->security_barrier = false;

1117

1118 /*

1119 * Clear fields that should not be set in a subquery RTE.

1120 * However, we leave rte->functions filled in for the moment,

1121 * in case makeWholeRowVar needs to consult it. We'll clear

1122 * it in setrefs.c (see add_rte_to_flat_rtable) so that this

1123 * abuse of the data structure doesn't escape the planner.

1124 */

1125 rte->funcordinality = false;

1126 }

1127 }

1128 }

1129}

inline_set_returning_function

Query * inline_set_returning_function(PlannerInfo *root, RangeTblEntry *rte)

Definition: clauses.c:5168

eval_const_expressions

Node * eval_const_expressions(PlannerInfo *root, Node *node)

Definition: clauses.c:2262

RTE_FUNCTION

@ RTE_FUNCTION

Definition: parsenodes.h:1046

RangeTblEntry::funcordinality

bool funcordinality

Definition: parsenodes.h:1210

RangeTblEntry::functions

List * functions

Definition: parsenodes.h:1208

References eval_const_expressions(), RangeTblEntry::funcordinality, RangeTblEntry::functions, inline_set_returning_function(), lfirst, root, RTE_FUNCTION, RTE_SUBQUERY, RangeTblEntry::rtekind, and RangeTblEntry::subquery.

Referenced by pull_up_simple_subquery(), and subquery_planner().

◆ preprocess_relation_rtes()

Query * preprocess_relation_rtes ( PlannerInfo * root )

Definition at line 417 of file prepjointree.c.

418{

419 Query *parse = root->parse;

420 int rtable_size;

421 int rt_index;

422

423 rtable_size = list_length(parse->rtable);

424

425 for (rt_index = 0; rt_index < rtable_size; rt_index++)

426 {

427 RangeTblEntry *rte = rt_fetch(rt_index + 1, parse->rtable);

428 Relation relation;

429

430 /* We only care about relation RTEs. */

431 if (rte->rtekind != RTE_RELATION)

432 continue;

433

434 /*

435 * We need not lock the relation since it was already locked by the

436 * rewriter.

437 */

438 relation = table_open(rte->relid, NoLock);

439

440 /*

441 * Check to see if the relation actually has any children; if not,

442 * clear the inh flag so we can treat it as a plain base relation.

443 *

444 * Note: this could give a false-positive result, if the rel once had

445 * children but no longer does. We used to be able to clear rte->inh

446 * later on when we discovered that, but no more; we have to handle

447 * such cases as full-fledged inheritance.

448 */

449 if (rte->inh)

450 rte->inh = relation->rd_rel->relhassubclass;

451

452 /*

453 * Check to see if the relation has any column not-null constraints;

454 * if so, retrieve the constraint information and store it in a

455 * relation OID based hash table.

456 */

457 get_relation_notnullatts(root, relation);

458

459 /*

460 * Check to see if the relation has any virtual generated columns; if

461 * so, replace all Var nodes in the query that reference these columns

462 * with the generation expressions.

463 */

464 parse = expand_virtual_generated_columns(root, parse,

465 rte, rt_index + 1,

466 relation);

467

468 table_close(relation, NoLock);

469 }

470

471 return parse;

472}

NoLock

#define NoLock

Definition: lockdefs.h:34

RTE_RELATION

@ RTE_RELATION

Definition: parsenodes.h:1043

get_relation_notnullatts

void get_relation_notnullatts(PlannerInfo *root, Relation relation)

Definition: plancat.c:682

expand_virtual_generated_columns

static Query * expand_virtual_generated_columns(PlannerInfo *root, Query *parse, RangeTblEntry *rte, int rt_index, Relation relation)

Definition: prepjointree.c:486

RelationData

Definition: rel.h:56

RelationData::rd_rel

Form_pg_class rd_rel

Definition: rel.h:111

table_close

void table_close(Relation relation, LOCKMODE lockmode)

Definition: table.c:126

table_open

Relation table_open(Oid relationId, LOCKMODE lockmode)

Definition: table.c:40

References expand_virtual_generated_columns(), get_relation_notnullatts(), RangeTblEntry::inh, list_length(), NoLock, parse(), RelationData::rd_rel, root, rt_fetch, RTE_RELATION, RangeTblEntry::rtekind, table_close(), and table_open().

Referenced by convert_EXISTS_sublink_to_join(), pull_up_simple_subquery(), and subquery_planner().

◆ preprocess_targetlist()

void preprocess_targetlist ( PlannerInfo * root )

Definition at line 64 of file preptlist.c.

65{

66 Query *parse = root->parse;

67 int result_relation = parse->resultRelation;

68 List *range_table = parse->rtable;

69 CmdType command_type = parse->commandType;

70 RangeTblEntry *target_rte = NULL;

71 Relation target_relation = NULL;

72 List *tlist;

73 ListCell *lc;

74

75 /*

76 * If there is a result relation, open it so we can look for missing

77 * columns and so on. We assume that previous code already acquired at

78 * least AccessShareLock on the relation, so we need no lock here.

79 */

80 if (result_relation)

81 {

82 target_rte = rt_fetch(result_relation, range_table);

83

84 /*

85 * Sanity check: it'd better be a real relation not, say, a subquery.

86 * Else parser or rewriter messed up.

87 */

88 if (target_rte->rtekind != RTE_RELATION)

89 elog(ERROR, "result relation must be a regular relation");

90

91 target_relation = table_open(target_rte->relid, NoLock);

92 }

93 else

94 Assert(command_type == CMD_SELECT);

95

96 /*

97 * In an INSERT, the executor expects the targetlist to match the exact

98 * order of the target table's attributes, including entries for

99 * attributes not mentioned in the source query.

100 *

101 * In an UPDATE, we don't rearrange the tlist order, but we need to make a

102 * separate list of the target attribute numbers, in tlist order, and then

103 * renumber the processed_tlist entries to be consecutive.

104 */

105 tlist = parse->targetList;

106 if (command_type == CMD_INSERT)

107 tlist = expand_insert_targetlist(root, tlist, target_relation);

108 else if (command_type == CMD_UPDATE)

109 root->update_colnos = extract_update_targetlist_colnos(tlist);

110

111 /*

112 * For non-inherited UPDATE/DELETE/MERGE, register any junk column(s)

113 * needed to allow the executor to identify the rows to be updated or

114 * deleted. In the inheritance case, we do nothing now, leaving this to

115 * be dealt with when expand_inherited_rtentry() makes the leaf target

116 * relations. (But there might not be any leaf target relations, in which

117 * case we must do this in distribute_row_identity_vars().)

118 */

119 if ((command_type == CMD_UPDATE || command_type == CMD_DELETE ||

120 command_type == CMD_MERGE) &&

121 !target_rte->inh)

122 {

123 /* row-identity logic expects to add stuff to processed_tlist */

124 root->processed_tlist = tlist;

125 add_row_identity_columns(root, result_relation,

126 target_rte, target_relation);

127 tlist = root->processed_tlist;

128 }

129

130 /*

131 * For MERGE we also need to handle the target list for each INSERT and

132 * UPDATE action separately. In addition, we examine the qual of each

133 * action and add any Vars there (other than those of the target rel) to

134 * the subplan targetlist.

135 */

136 if (command_type == CMD_MERGE)

137 {

138 ListCell *l;

139 List *vars;

140

141 /*

142 * For MERGE, handle targetlist of each MergeAction separately. Give

143 * the same treatment to MergeAction->targetList as we would have

144 * given to a regular INSERT. For UPDATE, collect the column numbers

145 * being modified.

146 */

147 foreach(l, parse->mergeActionList)

148 {

149 MergeAction *action = (MergeAction *) lfirst(l);

150 ListCell *l2;

151

152 if (action->commandType == CMD_INSERT)

153 action->targetList = expand_insert_targetlist(root,

154 action->targetList,

155 target_relation);

156 else if (action->commandType == CMD_UPDATE)

157 action->updateColnos =

158 extract_update_targetlist_colnos(action->targetList);

159

160 /*

161 * Add resjunk entries for any Vars and PlaceHolderVars used in

162 * each action's targetlist and WHEN condition that belong to

163 * relations other than the target. We don't expect to see any

164 * aggregates or window functions here.

165 */

166 vars = pull_var_clause((Node *)

167 list_concat_copy((List *) action->qual,

168 action->targetList),

169 PVC_INCLUDE_PLACEHOLDERS);

170 foreach(l2, vars)

171 {

172 Var *var = (Var *) lfirst(l2);

173 TargetEntry *tle;

174

175 if (IsA(var, Var) && var->varno == result_relation)

176 continue; /* don't need it */

177

178 if (tlist_member((Expr *) var, tlist))

179 continue; /* already got it */

180

181 tle = makeTargetEntry((Expr *) var,

182 list_length(tlist) + 1,

183 NULL, true);

184 tlist = lappend(tlist, tle);

185 }

186 list_free(vars);

187 }

188

189 /*

190 * Add resjunk entries for any Vars and PlaceHolderVars used in the

191 * join condition that belong to relations other than the target. We

192 * don't expect to see any aggregates or window functions here.

193 */

194 vars = pull_var_clause(parse->mergeJoinCondition,

195 PVC_INCLUDE_PLACEHOLDERS);

196 foreach(l, vars)

197 {

198 Var *var = (Var *) lfirst(l);

199 TargetEntry *tle;

200

201 if (IsA(var, Var) && var->varno == result_relation)

202 continue; /* don't need it */

203

204 if (tlist_member((Expr *) var, tlist))

205 continue; /* already got it */

206

207 tle = makeTargetEntry((Expr *) var,

208 list_length(tlist) + 1,

209 NULL, true);

210 tlist = lappend(tlist, tle);

211 }

212 }

213

214 /*

215 * Add necessary junk columns for rowmarked rels. These values are needed

216 * for locking of rels selected FOR UPDATE/SHARE, and to do EvalPlanQual

217 * rechecking. See comments for PlanRowMark in plannodes.h. If you

218 * change this stanza, see also expand_inherited_rtentry(), which has to

219 * be able to add on junk columns equivalent to these.

220 *

221 * (Someday it might be useful to fold these resjunk columns into the

222 * row-identity-column management used for UPDATE/DELETE. Today is not

223 * that day, however. One notable issue is that it seems important that

224 * the whole-row Vars made here use the real table rowtype, not RECORD, so

225 * that conversion to/from child relations' rowtypes will happen. Also,

226 * since these entries don't potentially bloat with more and more child

227 * relations, there's not really much need for column sharing.)

228 */

229 foreach(lc, root->rowMarks)

230 {

231 PlanRowMark *rc = (PlanRowMark *) lfirst(lc);

232 Var *var;

233 char resname[32];

234 TargetEntry *tle;

235

236 /* child rels use the same junk attrs as their parents */

237 if (rc->rti != rc->prti)

238 continue;

239

240 if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))

241 {

242 /* Need to fetch TID */

243 var = makeVar(rc->rti,

244 SelfItemPointerAttributeNumber,

245 TIDOID,

246 -1,

247 InvalidOid,

248 0);

249 snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);

250 tle = makeTargetEntry((Expr *) var,

251 list_length(tlist) + 1,

252 pstrdup(resname),

253 true);

254 tlist = lappend(tlist, tle);

255 }

256 if (rc->allMarkTypes & (1 << ROW_MARK_COPY))

257 {

258 /* Need the whole row as a junk var */

259 var = makeWholeRowVar(rt_fetch(rc->rti, range_table),

260 rc->rti,

261 0,

262 false);

263 snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);

264 tle = makeTargetEntry((Expr *) var,

265 list_length(tlist) + 1,

266 pstrdup(resname),

267 true);

268 tlist = lappend(tlist, tle);

269 }

270

271 /* If parent of inheritance tree, always fetch the tableoid too. */

272 if (rc->isParent)

273 {

274 var = makeVar(rc->rti,

275 TableOidAttributeNumber,

276 OIDOID,

277 -1,

278 InvalidOid,

279 0);

280 snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);

281 tle = makeTargetEntry((Expr *) var,

282 list_length(tlist) + 1,

283 pstrdup(resname),

284 true);

285 tlist = lappend(tlist, tle);

286 }

287 }

288

289 /*

290 * If the query has a RETURNING list, add resjunk entries for any Vars

291 * used in RETURNING that belong to other relations. We need to do this

292 * to make these Vars available for the RETURNING calculation. Vars that

293 * belong to the result rel don't need to be added, because they will be

294 * made to refer to the actual heap tuple.

295 */

296 if (parse->returningList && list_length(parse->rtable) > 1)

297 {

298 List *vars;

299 ListCell *l;

300

301 vars = pull_var_clause((Node *) parse->returningList,

302 PVC_RECURSE_AGGREGATES |

303 PVC_RECURSE_WINDOWFUNCS |

304 PVC_INCLUDE_PLACEHOLDERS);

305 foreach(l, vars)

306 {

307 Var *var = (Var *) lfirst(l);

308 TargetEntry *tle;

309

310 if (IsA(var, Var) &&

311 var->varno == result_relation)

312 continue; /* don't need it */

313

314 if (tlist_member((Expr *) var, tlist))

315 continue; /* already got it */

316

317 tle = makeTargetEntry((Expr *) var,

318 list_length(tlist) + 1,

319 NULL,

320 true);

321

322 tlist = lappend(tlist, tle);

323 }

324 list_free(vars);

325 }

326

327 root->processed_tlist = tlist;

328

329 if (target_relation)

330 table_close(target_relation, NoLock);

331}

add_row_identity_columns

void add_row_identity_columns(PlannerInfo *root, Index rtindex, RangeTblEntry *target_rte, Relation target_relation)

Definition: appendinfo.c:904

list_concat_copy

List * list_concat_copy(const List *list1, const List *list2)

Definition: list.c:598

list_free

void list_free(List *list)

Definition: list.c:1546

makeVar

Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)

Definition: makefuncs.c:66

makeWholeRowVar

Var * makeWholeRowVar(RangeTblEntry *rte, int varno, Index varlevelsup, bool allowScalar)

Definition: makefuncs.c:137

makeTargetEntry

TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)

Definition: makefuncs.c:289

pstrdup

char * pstrdup(const char *in)

Definition: mcxt.c:1759

generate_unaccent_rules.action

action

Definition: generate_unaccent_rules.py:287

CmdType

Definition: nodes.h:273

CMD_MERGE

@ CMD_MERGE

Definition: nodes.h:279

CMD_INSERT

@ CMD_INSERT

Definition: nodes.h:277

CMD_DELETE

@ CMD_DELETE

Definition: nodes.h:278

CMD_UPDATE

@ CMD_UPDATE

Definition: nodes.h:276

CMD_SELECT

@ CMD_SELECT

Definition: nodes.h:275

PVC_RECURSE_AGGREGATES

#define PVC_RECURSE_AGGREGATES

Definition: optimizer.h:184

PVC_RECURSE_WINDOWFUNCS

#define PVC_RECURSE_WINDOWFUNCS

Definition: optimizer.h:186

PVC_INCLUDE_PLACEHOLDERS

#define PVC_INCLUDE_PLACEHOLDERS

Definition: optimizer.h:187

ROW_MARK_COPY

@ ROW_MARK_COPY

Definition: plannodes.h:1534

snprintf

#define snprintf

Definition: port.h:239

InvalidOid

#define InvalidOid

Definition: postgres_ext.h:37

extract_update_targetlist_colnos

List * extract_update_targetlist_colnos(List *tlist)

Definition: preptlist.c:348

expand_insert_targetlist

static List * expand_insert_targetlist(PlannerInfo *root, List *tlist, Relation rel)

Definition: preptlist.c:382

Expr

Definition: primnodes.h:189

MergeAction

Definition: primnodes.h:2029

PlanRowMark::prti

Index prti

Definition: plannodes.h:1585

PlanRowMark::isParent

bool isParent

Definition: plannodes.h:1597

PlanRowMark::rowmarkId

Index rowmarkId

Definition: plannodes.h:1587

PlanRowMark::allMarkTypes

int allMarkTypes

Definition: plannodes.h:1591

Var

Definition: primnodes.h:262

Var::varno

int varno

Definition: primnodes.h:269

vars

Definition: regcomp.c:282

TableOidAttributeNumber

#define TableOidAttributeNumber

Definition: sysattr.h:26

SelfItemPointerAttributeNumber

#define SelfItemPointerAttributeNumber

Definition: sysattr.h:21

tlist_member

TargetEntry * tlist_member(Expr *node, List *targetlist)

Definition: tlist.c:79

pull_var_clause

List * pull_var_clause(Node *node, int flags)

Definition: var.c:653

References generate_unaccent_rules::action, add_row_identity_columns(), PlanRowMark::allMarkTypes, Assert(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, elog, ERROR, expand_insert_targetlist(), extract_update_targetlist_colnos(), RangeTblEntry::inh, InvalidOid, IsA, PlanRowMark::isParent, lappend(), lfirst, list_concat_copy(), list_free(), list_length(), makeTargetEntry(), makeVar(), makeWholeRowVar(), NoLock, parse(), PlanRowMark::prti, pstrdup(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, root, ROW_MARK_COPY, PlanRowMark::rowmarkId, rt_fetch, RTE_RELATION, RangeTblEntry::rtekind, PlanRowMark::rti, SelfItemPointerAttributeNumber, snprintf, table_close(), table_open(), TableOidAttributeNumber, tlist_member(), and Var::varno.

Referenced by grouping_planner().

◆ pull_up_sublinks()

void pull_up_sublinks ( PlannerInfo * root )

Definition at line 647 of file prepjointree.c.

648{

649 Node *jtnode;

650 Relids relids;

651

652 /* Begin recursion through the jointree */

653 jtnode = pull_up_sublinks_jointree_recurse(root,

654 (Node *) root->parse->jointree,

655 &relids);

656

657 /*

658 * root->parse->jointree must always be a FromExpr, so insert a dummy one

659 * if we got a bare RangeTblRef or JoinExpr out of the recursion.

660 */

661 if (IsA(jtnode, FromExpr))

662 root->parse->jointree = (FromExpr *) jtnode;

663 else

664 root->parse->jointree = makeFromExpr(list_make1(jtnode), NULL);

665}

makeFromExpr

FromExpr * makeFromExpr(List *fromlist, Node *quals)

Definition: makefuncs.c:336

pull_up_sublinks_jointree_recurse

static Node * pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode, Relids *relids)

Definition: prepjointree.c:674

References IsA, list_make1, makeFromExpr(), pull_up_sublinks_jointree_recurse(), and root.

Referenced by pull_up_simple_subquery(), and subquery_planner().

◆ pull_up_subqueries()

void pull_up_subqueries ( PlannerInfo * root )

Definition at line 1140 of file prepjointree.c.

1141{

1142 /* Top level of jointree must always be a FromExpr */

1143 Assert(IsA(root->parse->jointree, FromExpr));

1144 /* Recursion starts with no containing join nor appendrel */

1145 root->parse->jointree = (FromExpr *)

1146 pull_up_subqueries_recurse(root, (Node *) root->parse->jointree,

1147 NULL, NULL);

1148 /* We should still have a FromExpr */

1149 Assert(IsA(root->parse->jointree, FromExpr));

1150}

pull_up_subqueries_recurse

static Node * pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode, JoinExpr *lowest_outer_join, AppendRelInfo *containing_appendrel)

Definition: prepjointree.c:1184

References Assert(), IsA, pull_up_subqueries_recurse(), and root.

Referenced by pull_up_simple_subquery(), and subquery_planner().

◆ reduce_outer_joins()

void reduce_outer_joins ( PlannerInfo * root )

Definition at line 3164 of file prepjointree.c.

3165{

3166 reduce_outer_joins_pass1_state *state1;

3167 reduce_outer_joins_pass2_state state2;

3168 ListCell *lc;

3169

3170 /*

3171 * To avoid doing strictness checks on more quals than necessary, we want

3172 * to stop descending the jointree as soon as there are no outer joins

3173 * below our current point. This consideration forces a two-pass process.

3174 * The first pass gathers information about which base rels appear below

3175 * each side of each join clause, and about whether there are outer

3176 * join(s) below each side of each join clause. The second pass examines

3177 * qual clauses and changes join types as it descends the tree.

3178 */

3179 state1 = reduce_outer_joins_pass1((Node *) root->parse->jointree);

3180

3181 /* planner.c shouldn't have called me if no outer joins */

3182 if (state1 == NULL || !state1->contains_outer)

3183 elog(ERROR, "so where are the outer joins?");

3184

3185 state2.inner_reduced = NULL;

3186 state2.partial_reduced = NIL;

3187

3188 reduce_outer_joins_pass2((Node *) root->parse->jointree,

3189 state1, &state2,

3190 root, NULL, NIL);

3191

3192 /*

3193 * If we successfully reduced the strength of any outer joins, we must

3194 * remove references to those joins as nulling rels. This is handled as

3195 * an additional pass, for simplicity and because we can handle all

3196 * fully-reduced joins in a single pass over the parse tree.

3197 */

3198 if (!bms_is_empty(state2.inner_reduced))

3199 {

3200 root->parse = (Query *)

3201 remove_nulling_relids((Node *) root->parse,

3202 state2.inner_reduced,

3203 NULL);

3204 /* There could be references in the append_rel_list, too */

3205 root->append_rel_list = (List *)

3206 remove_nulling_relids((Node *) root->append_rel_list,

3207 state2.inner_reduced,

3208 NULL);

3209 }

3210

3211 /*

3212 * Partially-reduced full joins have to be done one at a time, since

3213 * they'll each need a different setting of except_relids.

3214 */

3215 foreach(lc, state2.partial_reduced)

3216 {

3217 reduce_outer_joins_partial_state *statep = lfirst(lc);

3218 Relids full_join_relids = bms_make_singleton(statep->full_join_rti);

3219

3220 root->parse = (Query *)

3221 remove_nulling_relids((Node *) root->parse,

3222 full_join_relids,

3223 statep->unreduced_side);

3224 root->append_rel_list = (List *)

3225 remove_nulling_relids((Node *) root->append_rel_list,

3226 full_join_relids,

3227 statep->unreduced_side);

3228 }

3229}

bms_is_empty

#define bms_is_empty(a)

Definition: bitmapset.h:118

reduce_outer_joins_pass2

static void reduce_outer_joins_pass2(Node *jtnode, reduce_outer_joins_pass1_state *state1, reduce_outer_joins_pass2_state *state2, PlannerInfo *root, Relids nonnullable_rels, List *forced_null_vars)

Definition: prepjointree.c:3315

reduce_outer_joins_pass1

static reduce_outer_joins_pass1_state * reduce_outer_joins_pass1(Node *jtnode)

Definition: prepjointree.c:3237

remove_nulling_relids

Node * remove_nulling_relids(Node *node, const Bitmapset *removable_relids, const Bitmapset *except_relids)

Definition: rewriteManip.c:1331

reduce_outer_joins_partial_state

Definition: prepjointree.c:101

reduce_outer_joins_partial_state::full_join_rti

int full_join_rti

Definition: prepjointree.c:102

reduce_outer_joins_partial_state::unreduced_side

Relids unreduced_side

Definition: prepjointree.c:103

reduce_outer_joins_pass1_state

Definition: prepjointree.c:88

reduce_outer_joins_pass1_state::contains_outer

bool contains_outer

Definition: prepjointree.c:90

reduce_outer_joins_pass2_state

Definition: prepjointree.c:95

reduce_outer_joins_pass2_state::partial_reduced

List * partial_reduced

Definition: prepjointree.c:97

reduce_outer_joins_pass2_state::inner_reduced

Relids inner_reduced

Definition: prepjointree.c:96

References bms_is_empty, bms_make_singleton(), reduce_outer_joins_pass1_state::contains_outer, elog, ERROR, reduce_outer_joins_partial_state::full_join_rti, reduce_outer_joins_pass2_state::inner_reduced, lfirst, NIL, reduce_outer_joins_pass2_state::partial_reduced, reduce_outer_joins_pass1(), reduce_outer_joins_pass2(), remove_nulling_relids(), root, and reduce_outer_joins_partial_state::unreduced_side.

Referenced by subquery_planner().

◆ remove_useless_result_rtes()

void remove_useless_result_rtes ( PlannerInfo * root )

Definition at line 3658 of file prepjointree.c.

3659{

3660 Relids dropped_outer_joins = NULL;

3661 ListCell *cell;

3662

3663 /* Top level of jointree must always be a FromExpr */

3664 Assert(IsA(root->parse->jointree, FromExpr));

3665 /* Recurse ... */

3666 root->parse->jointree = (FromExpr *)

3667 remove_useless_results_recurse(root,

3668 (Node *) root->parse->jointree,

3669 NULL,

3670 &dropped_outer_joins);

3671 /* We should still have a FromExpr */

3672 Assert(IsA(root->parse->jointree, FromExpr));

3673

3674 /*

3675 * If we removed any outer-join nodes from the jointree, run around and

3676 * remove references to those joins as nulling rels. (There could be such

3677 * references in PHVs that we pulled up out of the original subquery that

3678 * the RESULT rel replaced. This is kosher on the grounds that we now

3679 * know that such an outer join wouldn't really have nulled anything.) We

3680 * don't do this during the main recursion, for simplicity and because we

3681 * can handle all such joins in a single pass over the parse tree.

3682 */

3683 if (!bms_is_empty(dropped_outer_joins))

3684 {

3685 root->parse = (Query *)

3686 remove_nulling_relids((Node *) root->parse,

3687 dropped_outer_joins,

3688 NULL);

3689 /* There could be references in the append_rel_list, too */

3690 root->append_rel_list = (List *)

3691 remove_nulling_relids((Node *) root->append_rel_list,

3692 dropped_outer_joins,

3693 NULL);

3694 }

3695

3696 /*

3697 * Remove any PlanRowMark referencing an RTE_RESULT RTE. We obviously

3698 * must do that for any RTE_RESULT that we just removed. But one for a

3699 * RTE that we did not remove can be dropped anyway: since the RTE has

3700 * only one possible output row, there is no need for EPQ to mark and

3701 * restore that row.

3702 *

3703 * It's necessary, not optional, to remove the PlanRowMark for a surviving

3704 * RTE_RESULT RTE; otherwise we'll generate a whole-row Var for the

3705 * RTE_RESULT, which the executor has no support for.

3706 */

3707 foreach(cell, root->rowMarks)

3708 {

3709 PlanRowMark *rc = (PlanRowMark *) lfirst(cell);

3710

3711 if (rt_fetch(rc->rti, root->parse->rtable)->rtekind == RTE_RESULT)

3712 root->rowMarks = foreach_delete_current(root->rowMarks, cell);

3713 }

3714}

RTE_RESULT

@ RTE_RESULT

Definition: parsenodes.h:1051

foreach_delete_current

#define foreach_delete_current(lst, var_or_cell)

Definition: pg_list.h:391

remove_useless_results_recurse

static Node * remove_useless_results_recurse(PlannerInfo *root, Node *jtnode, Node **parent_quals, Relids *dropped_outer_joins)

Definition: prepjointree.c:3731

References Assert(), bms_is_empty, foreach_delete_current, IsA, lfirst, remove_nulling_relids(), remove_useless_results_recurse(), root, rt_fetch, RTE_RESULT, and PlanRowMark::rti.

Referenced by subquery_planner().

◆ replace_empty_jointree()

void replace_empty_jointree ( Query * parse )

Definition at line 589 of file prepjointree.c.

590{

591 RangeTblEntry *rte;

592 Index rti;

593 RangeTblRef *rtr;

594

595 /* Nothing to do if jointree is already nonempty */

596 if (parse->jointree->fromlist != NIL)

597 return;

598

599 /* We mustn't change it in the top level of a setop tree, either */

600 if (parse->setOperations)

601 return;

602

603 /* Create suitable RTE */

604 rte = makeNode(RangeTblEntry);

605 rte->rtekind = RTE_RESULT;

606 rte->eref = makeAlias("*RESULT*", NIL);

607

608 /* Add it to rangetable */

609 parse->rtable = lappend(parse->rtable, rte);

610 rti = list_length(parse->rtable);

611

612 /* And jam a reference into the jointree */

613 rtr = makeNode(RangeTblRef);

614 rtr->rtindex = rti;

615 parse->jointree->fromlist = list_make1(rtr);

616}

Index

unsigned int Index

Definition: c.h:619

makeAlias

Alias * makeAlias(const char *aliasname, List *colnames)

Definition: makefuncs.c:438

References lappend(), list_length(), list_make1, makeAlias(), makeNode, NIL, parse(), RTE_RESULT, RangeTblEntry::rtekind, and RangeTblRef::rtindex.

Referenced by convert_EXISTS_sublink_to_join(), pull_up_simple_subquery(), and subquery_planner().

◆ transform_MERGE_to_join()

void transform_MERGE_to_join ( Query * parse )

Definition at line 187 of file prepjointree.c.

188{

189 RangeTblEntry *joinrte;

190 JoinExpr *joinexpr;

191 bool have_action[NUM_MERGE_MATCH_KINDS];

192 JoinType jointype;

193 int joinrti;

194 List *vars;

195 RangeTblRef *rtr;

196 FromExpr *target;

197 Node *source;

198 int sourcerti;

199

200 if (parse->commandType != CMD_MERGE)

201 return;

202

203 /* XXX probably bogus */

204 vars = NIL;

205

206 /*

207 * Work out what kind of join is required. If there any WHEN NOT MATCHED

208 * BY SOURCE/TARGET actions, an outer join is required so that we process

209 * all unmatched tuples from the source and/or target relations.

210 * Otherwise, we can use an inner join.

211 */

212 have_action[MERGE_WHEN_MATCHED] = false;

213 have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE] = false;

214 have_action[MERGE_WHEN_NOT_MATCHED_BY_TARGET] = false;

215

216 foreach_node(MergeAction, action, parse->mergeActionList)

217 {

218 if (action->commandType != CMD_NOTHING)

219 have_action[action->matchKind] = true;

220 }

221

222 if (have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE] &&

223 have_action[MERGE_WHEN_NOT_MATCHED_BY_TARGET])

224 jointype = JOIN_FULL;

225 else if (have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE])

226 jointype = JOIN_LEFT;

227 else if (have_action[MERGE_WHEN_NOT_MATCHED_BY_TARGET])

228 jointype = JOIN_RIGHT;

229 else

230 jointype = JOIN_INNER;

231

232 /* Manufacture a join RTE to use. */

233 joinrte = makeNode(RangeTblEntry);

234 joinrte->rtekind = RTE_JOIN;

235 joinrte->jointype = jointype;

236 joinrte->joinmergedcols = 0;

237 joinrte->joinaliasvars = vars;

238 joinrte->joinleftcols = NIL; /* MERGE does not allow JOIN USING */

239 joinrte->joinrightcols = NIL; /* ditto */

240 joinrte->join_using_alias = NULL;

241

242 joinrte->alias = NULL;

243 joinrte->eref = makeAlias("*MERGE*", NIL);

244 joinrte->lateral = false;

245 joinrte->inh = false;

246 joinrte->inFromCl = true;

247

248 /*

249 * Add completed RTE to pstate's range table list, so that we know its

250 * index.

251 */

252 parse->rtable = lappend(parse->rtable, joinrte);

253 joinrti = list_length(parse->rtable);

254

255 /*

256 * Create a JOIN between the target and the source relation.

257 *

258 * Here the target is identified by parse->mergeTargetRelation. For a

259 * regular table, this will equal parse->resultRelation, but for a

260 * trigger-updatable view, it will be the expanded view subquery that we

261 * need to pull data from.

262 *

263 * The source relation is in parse->jointree->fromlist, but any quals in

264 * parse->jointree->quals are restrictions on the target relation (if the

265 * target relation is an auto-updatable view).

266 */

267 /* target rel, with any quals */

268 rtr = makeNode(RangeTblRef);

269 rtr->rtindex = parse->mergeTargetRelation;

270 target = makeFromExpr(list_make1(rtr), parse->jointree->quals);

271

272 /* source rel (expect exactly one -- see transformMergeStmt()) */

273 Assert(list_length(parse->jointree->fromlist) == 1);

274 source = linitial(parse->jointree->fromlist);

275

276 /*

277 * index of source rel (expect either a RangeTblRef or a JoinExpr -- see

278 * transformFromClauseItem()).

279 */

280 if (IsA(source, RangeTblRef))

281 sourcerti = ((RangeTblRef *) source)->rtindex;

282 else if (IsA(source, JoinExpr))

283 sourcerti = ((JoinExpr *) source)->rtindex;

284 else

285 {

286 elog(ERROR, "unrecognized source node type: %d",

287 (int) nodeTag(source));

288 sourcerti = 0; /* keep compiler quiet */

289 }

290

291 /* Join the source and target */

292 joinexpr = makeNode(JoinExpr);

293 joinexpr->jointype = jointype;

294 joinexpr->isNatural = false;

295 joinexpr->larg = (Node *) target;

296 joinexpr->rarg = source;

297 joinexpr->usingClause = NIL;

298 joinexpr->join_using_alias = NULL;

299 joinexpr->quals = parse->mergeJoinCondition;

300 joinexpr->alias = NULL;

301 joinexpr->rtindex = joinrti;

302

303 /* Make the new join be the sole entry in the query's jointree */

304 parse->jointree->fromlist = list_make1(joinexpr);

305 parse->jointree->quals = NULL;

306

307 /*

308 * If necessary, mark parse->targetlist entries that refer to the target

309 * as nullable by the join. Normally the targetlist will be empty for a

310 * MERGE, but if the target is a trigger-updatable view, it will contain a

311 * whole-row Var referring to the expanded view query.

312 */

313 if (parse->targetList != NIL &&

314 (jointype == JOIN_RIGHT || jointype == JOIN_FULL))

315 parse->targetList = (List *)

316 add_nulling_relids((Node *) parse->targetList,

317 bms_make_singleton(parse->mergeTargetRelation),

318 bms_make_singleton(joinrti));

319

320 /*

321 * If the source relation is on the outer side of the join, mark any

322 * source relation Vars in the join condition, actions, and RETURNING list

323 * as nullable by the join. These Vars will be added to the targetlist by

324 * preprocess_targetlist(), so it's important to mark them correctly here.

325 *

326 * It might seem that this is not necessary for Vars in the join

327 * condition, since it is inside the join, but it is also needed above the

328 * join (in the ModifyTable node) to distinguish between the MATCHED and

329 * NOT MATCHED BY SOURCE cases -- see ExecMergeMatched(). Note that this

330 * creates a modified copy of the join condition, for use above the join,

331 * without modifying the original join condition, inside the join.

332 */

333 if (jointype == JOIN_LEFT || jointype == JOIN_FULL)

334 {

335 parse->mergeJoinCondition =

336 add_nulling_relids(parse->mergeJoinCondition,

337 bms_make_singleton(sourcerti),

338 bms_make_singleton(joinrti));

339

340 foreach_node(MergeAction, action, parse->mergeActionList)

341 {

342 action->qual =

343 add_nulling_relids(action->qual,

344 bms_make_singleton(sourcerti),

345 bms_make_singleton(joinrti));

346

347 action->targetList = (List *)

348 add_nulling_relids((Node *) action->targetList,

349 bms_make_singleton(sourcerti),

350 bms_make_singleton(joinrti));

351 }

352

353 parse->returningList = (List *)

354 add_nulling_relids((Node *) parse->returningList,

355 bms_make_singleton(sourcerti),

356 bms_make_singleton(joinrti));

357 }

358

359 /*

360 * If there are any WHEN NOT MATCHED BY SOURCE actions, the executor will

361 * use the join condition to distinguish between MATCHED and NOT MATCHED

362 * BY SOURCE cases. Otherwise, it's no longer needed, and we set it to

363 * NULL, saving cycles during planning and execution.

364 *

365 * We need to be careful though: the executor evaluates this condition

366 * using the output of the join subplan node, which nulls the output from

367 * the source relation when the join condition doesn't match. That risks

368 * producing incorrect results when rechecking using a "non-strict" join

369 * condition, such as "src.col IS NOT DISTINCT FROM tgt.col". To guard

370 * against that, we add an additional "src IS NOT NULL" check to the join

371 * condition, so that it does the right thing when performing a recheck

372 * based on the output of the join subplan.

373 */

374 if (have_action[MERGE_WHEN_NOT_MATCHED_BY_SOURCE])

375 {

376 Var *var;

377 NullTest *ntest;

378

379 /* source wholerow Var (nullable by the new join) */

380 var = makeWholeRowVar(rt_fetch(sourcerti, parse->rtable),

381 sourcerti, 0, false);

382 var->varnullingrels = bms_make_singleton(joinrti);

383

384 /* "src IS NOT NULL" check */

385 ntest = makeNode(NullTest);

386 ntest->arg = (Expr *) var;

387 ntest->nulltesttype = IS_NOT_NULL;

388 ntest->argisrow = false;

389 ntest->location = -1;

390

391 /* combine it with the original join condition */

392 parse->mergeJoinCondition =

393 (Node *) make_and_qual((Node *) ntest, parse->mergeJoinCondition);

394 }

395 else

396 parse->mergeJoinCondition = NULL; /* join condition not needed */

397}

make_and_qual

Node * make_and_qual(Node *qual1, Node *qual2)

Definition: makefuncs.c:780

CMD_NOTHING

@ CMD_NOTHING

Definition: nodes.h:282

JoinType

Definition: nodes.h:298

JOIN_FULL

@ JOIN_FULL

Definition: nodes.h:305

JOIN_RIGHT

@ JOIN_RIGHT

Definition: nodes.h:306

JOIN_LEFT

@ JOIN_LEFT

Definition: nodes.h:304

RTE_JOIN

@ RTE_JOIN

Definition: parsenodes.h:1045

linitial

#define linitial(l)

Definition: pg_list.h:178

foreach_node

#define foreach_node(type, var, lst)

Definition: pg_list.h:496

source

static rewind_source * source

Definition: pg_rewind.c:89

NUM_MERGE_MATCH_KINDS

#define NUM_MERGE_MATCH_KINDS

Definition: primnodes.h:2026

IS_NOT_NULL

@ IS_NOT_NULL

Definition: primnodes.h:1977

MERGE_WHEN_NOT_MATCHED_BY_TARGET

@ MERGE_WHEN_NOT_MATCHED_BY_TARGET

Definition: primnodes.h:2023

MERGE_WHEN_NOT_MATCHED_BY_SOURCE

@ MERGE_WHEN_NOT_MATCHED_BY_SOURCE

Definition: primnodes.h:2022

MERGE_WHEN_MATCHED

@ MERGE_WHEN_MATCHED

Definition: primnodes.h:2021

add_nulling_relids

Node * add_nulling_relids(Node *node, const Bitmapset *target_relids, const Bitmapset *added_relids)

Definition: rewriteManip.c:1243

JoinExpr::quals

Node * quals

Definition: primnodes.h:2338

JoinExpr::jointype

JoinType jointype

Definition: primnodes.h:2329

JoinExpr::rtindex

int rtindex

Definition: primnodes.h:2342

JoinExpr::larg

Node * larg

Definition: primnodes.h:2331

JoinExpr::isNatural

bool isNatural

Definition: primnodes.h:2330

JoinExpr::rarg

Node * rarg

Definition: primnodes.h:2332

NullTest

Definition: primnodes.h:1981

NullTest::nulltesttype

NullTestType nulltesttype

Definition: primnodes.h:1984

NullTest::location

ParseLoc location

Definition: primnodes.h:1987

NullTest::arg

Expr * arg

Definition: primnodes.h:1983

RangeTblEntry::jointype

JoinType jointype

Definition: parsenodes.h:1182

References generate_unaccent_rules::action, add_nulling_relids(), NullTest::arg, Assert(), bms_make_singleton(), CMD_MERGE, CMD_NOTHING, elog, ERROR, foreach_node, RangeTblEntry::inh, IS_NOT_NULL, IsA, JoinExpr::isNatural, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, RangeTblEntry::jointype, JoinExpr::jointype, lappend(), JoinExpr::larg, linitial, list_length(), list_make1, NullTest::location, make_and_qual(), makeAlias(), makeFromExpr(), makeNode, makeWholeRowVar(), MERGE_WHEN_MATCHED, MERGE_WHEN_NOT_MATCHED_BY_SOURCE, MERGE_WHEN_NOT_MATCHED_BY_TARGET, NIL, nodeTag, NullTest::nulltesttype, NUM_MERGE_MATCH_KINDS, parse(), JoinExpr::quals, JoinExpr::rarg, rt_fetch, RTE_JOIN, RangeTblEntry::rtekind, RangeTblRef::rtindex, JoinExpr::rtindex, and source.

Referenced by subquery_planner().