9
9
*
10
10
*
11
11
* IDENTIFICATION
12
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.77 2002/05/18 00:42:55 tgl Exp $
12
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.78 2002/05/18 02:25:50 tgl Exp $
13
13
*
14
14
*-------------------------------------------------------------------------
15
15
*/
28
28
29
29
typedef struct
30
30
{
31
- Query * root ;
31
+ List * rtable ;
32
32
List * outer_tlist ;
33
33
List * inner_tlist ;
34
34
Index acceptable_rel ;
@@ -42,7 +42,7 @@ typedef struct
42
42
} replace_vars_with_subplan_refs_context ;
43
43
44
44
static void fix_expr_references (Plan * plan , Node * node );
45
- static void set_join_references (Query * root , Join * join );
45
+ static void set_join_references (Join * join , List * rtable );
46
46
static void set_uppernode_references (Plan * plan , Index subvarno );
47
47
static Node * join_references_mutator (Node * node ,
48
48
join_references_context * context );
@@ -75,7 +75,7 @@ static bool fix_opids_walker(Node *node, void *context);
75
75
* Returns nothing of interest, but modifies internal fields of nodes.
76
76
*/
77
77
void
78
- set_plan_references (Query * root , Plan * plan )
78
+ set_plan_references (Plan * plan , List * rtable )
79
79
{
80
80
List * pl ;
81
81
@@ -110,16 +110,24 @@ set_plan_references(Query *root, Plan *plan)
110
110
fix_expr_references (plan , (Node * ) plan -> qual );
111
111
break ;
112
112
case T_SubqueryScan :
113
+ {
114
+ RangeTblEntry * rte ;
113
115
114
- /*
115
- * We do not do set_uppernode_references() here, because a
116
- * SubqueryScan will always have been created with correct
117
- * references to its subplan's outputs to begin with.
118
- */
119
- fix_expr_references (plan , (Node * ) plan -> targetlist );
120
- fix_expr_references (plan , (Node * ) plan -> qual );
121
- /* Recurse into subplan too */
122
- set_plan_references (root , ((SubqueryScan * ) plan )-> subplan );
116
+ /*
117
+ * We do not do set_uppernode_references() here, because a
118
+ * SubqueryScan will always have been created with correct
119
+ * references to its subplan's outputs to begin with.
120
+ */
121
+ fix_expr_references (plan , (Node * ) plan -> targetlist );
122
+ fix_expr_references (plan , (Node * ) plan -> qual );
123
+
124
+ /* Recurse into subplan too */
125
+ rte = rt_fetch (((SubqueryScan * ) plan )-> scan .scanrelid ,
126
+ rtable );
127
+ Assert (rte -> rtekind == RTE_SUBQUERY );
128
+ set_plan_references (((SubqueryScan * ) plan )-> subplan ,
129
+ rte -> subquery -> rtable );
130
+ }
123
131
break ;
124
132
case T_FunctionScan :
125
133
{
@@ -128,27 +136,27 @@ set_plan_references(Query *root, Plan *plan)
128
136
fix_expr_references (plan , (Node * ) plan -> targetlist );
129
137
fix_expr_references (plan , (Node * ) plan -> qual );
130
138
rte = rt_fetch (((FunctionScan * ) plan )-> scan .scanrelid ,
131
- root -> rtable );
139
+ rtable );
132
140
Assert (rte -> rtekind == RTE_FUNCTION );
133
141
fix_expr_references (plan , rte -> funcexpr );
134
142
}
135
143
break ;
136
144
case T_NestLoop :
137
- set_join_references (root , (Join * ) plan );
145
+ set_join_references ((Join * ) plan , rtable );
138
146
fix_expr_references (plan , (Node * ) plan -> targetlist );
139
147
fix_expr_references (plan , (Node * ) plan -> qual );
140
148
fix_expr_references (plan , (Node * ) ((Join * ) plan )-> joinqual );
141
149
break ;
142
150
case T_MergeJoin :
143
- set_join_references (root , (Join * ) plan );
151
+ set_join_references ((Join * ) plan , rtable );
144
152
fix_expr_references (plan , (Node * ) plan -> targetlist );
145
153
fix_expr_references (plan , (Node * ) plan -> qual );
146
154
fix_expr_references (plan , (Node * ) ((Join * ) plan )-> joinqual );
147
155
fix_expr_references (plan ,
148
156
(Node * ) ((MergeJoin * ) plan )-> mergeclauses );
149
157
break ;
150
158
case T_HashJoin :
151
- set_join_references (root , (Join * ) plan );
159
+ set_join_references ((Join * ) plan , rtable );
152
160
fix_expr_references (plan , (Node * ) plan -> targetlist );
153
161
fix_expr_references (plan , (Node * ) plan -> qual );
154
162
fix_expr_references (plan , (Node * ) ((Join * ) plan )-> joinqual );
@@ -202,7 +210,7 @@ set_plan_references(Query *root, Plan *plan)
202
210
* recurse into subplans.
203
211
*/
204
212
foreach (pl , ((Append * ) plan )-> appendplans )
205
- set_plan_references (root , (Plan * ) lfirst (pl ));
213
+ set_plan_references ((Plan * ) lfirst (pl ), rtable );
206
214
break ;
207
215
default :
208
216
elog (ERROR , "set_plan_references: unknown plan type %d" ,
@@ -219,21 +227,21 @@ set_plan_references(Query *root, Plan *plan)
219
227
* plan's var nodes against the already-modified nodes of the
220
228
* subplans.
221
229
*/
222
- set_plan_references (root , plan -> lefttree );
223
- set_plan_references (root , plan -> righttree );
230
+ set_plan_references (plan -> lefttree , rtable );
231
+ set_plan_references (plan -> righttree , rtable );
224
232
foreach (pl , plan -> initPlan )
225
233
{
226
234
SubPlan * sp = (SubPlan * ) lfirst (pl );
227
235
228
236
Assert (IsA (sp , SubPlan ));
229
- set_plan_references (root , sp -> plan );
237
+ set_plan_references (sp -> plan , sp -> rtable );
230
238
}
231
239
foreach (pl , plan -> subPlan )
232
240
{
233
241
SubPlan * sp = (SubPlan * ) lfirst (pl );
234
242
235
243
Assert (IsA (sp , SubPlan ));
236
- set_plan_references (root , sp -> plan );
244
+ set_plan_references (sp -> plan , sp -> rtable );
237
245
}
238
246
}
239
247
@@ -269,18 +277,19 @@ fix_expr_references(Plan *plan, Node *node)
269
277
* creation of a plan node by createplan.c and its fixing by this module.
270
278
* Fortunately, there doesn't seem to be any need to do that.
271
279
*
272
- * 'join' is a join plan node
280
+ * 'join' is a join plan node
281
+ * 'rtable' is the associated range table
273
282
*/
274
283
static void
275
- set_join_references (Query * root , Join * join )
284
+ set_join_references (Join * join , List * rtable )
276
285
{
277
286
Plan * outer = join -> plan .lefttree ;
278
287
Plan * inner = join -> plan .righttree ;
279
288
List * outer_tlist = ((outer == NULL ) ? NIL : outer -> targetlist );
280
289
List * inner_tlist = ((inner == NULL ) ? NIL : inner -> targetlist );
281
290
282
291
join -> plan .targetlist = join_references (join -> plan .targetlist ,
283
- root ,
292
+ rtable ,
284
293
outer_tlist ,
285
294
inner_tlist ,
286
295
(Index ) 0 );
@@ -374,6 +383,7 @@ set_uppernode_references(Plan *plan, Index subvarno)
374
383
* pass inner_tlist = NIL and acceptable_rel = the ID of the inner relation.
375
384
*
376
385
* 'clauses' is the targetlist or list of join clauses
386
+ * 'rtable' is the current range table
377
387
* 'outer_tlist' is the target list of the outer join relation
378
388
* 'inner_tlist' is the target list of the inner join relation, or NIL
379
389
* 'acceptable_rel' is either zero or the rangetable index of a relation
@@ -384,14 +394,14 @@ set_uppernode_references(Plan *plan, Index subvarno)
384
394
*/
385
395
List *
386
396
join_references (List * clauses ,
387
- Query * root ,
397
+ List * rtable ,
388
398
List * outer_tlist ,
389
399
List * inner_tlist ,
390
400
Index acceptable_rel )
391
401
{
392
402
join_references_context context ;
393
403
394
- context .root = root ;
404
+ context .rtable = rtable ;
395
405
context .outer_tlist = outer_tlist ;
396
406
context .inner_tlist = inner_tlist ;
397
407
context .acceptable_rel = acceptable_rel ;
@@ -432,7 +442,7 @@ join_references_mutator(Node *node,
432
442
433
443
/* Perhaps it's a join alias that can be resolved to input vars? */
434
444
newnode = flatten_join_alias_vars ((Node * ) var ,
435
- context -> root ,
445
+ context -> rtable ,
436
446
true);
437
447
if (!equal (newnode , (Node * ) var ))
438
448
{
0 commit comments