8
8
*
9
9
*
10
10
* IDENTIFICATION
11
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.59 2000/04 /1217:15:26 momjian Exp $
11
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.60 2000/05 /1201:33:54 tgl Exp $
12
12
*
13
13
*-------------------------------------------------------------------------
14
14
*/
@@ -41,8 +41,8 @@ static List *addTargetToSortList(TargetEntry *tle, List *sortlist,
41
41
static bool exprIsInSortList (Node * expr ,List * sortList ,List * targetList );
42
42
43
43
#ifndef DISABLE_OUTER_JOINS
44
- static Node * transformUsingClause (ParseState * pstate ,List * using ,List * left , List * right );
45
-
44
+ static List * transformUsingClause (ParseState * pstate ,List * using ,
45
+ List * left , List * right );
46
46
#endif
47
47
48
48
@@ -94,32 +94,33 @@ setTargetTable(ParseState *pstate, char *relname)
94
94
}
95
95
96
96
97
- Node *
98
- mergeInnerJoinQuals (ParseState * pstate ,Node * clause );
99
-
100
- Node *
97
+ static Node *
101
98
mergeInnerJoinQuals (ParseState * pstate ,Node * clause )
102
99
{
103
- A_Expr * expr = ( A_Expr * ) pstate -> p_join_quals ;
100
+ List * jquals ;
104
101
105
- if (expr == NULL )
106
- return clause ;
107
-
108
- if (clause != NULL )
102
+ foreach (jquals ,pstate -> p_join_quals )
109
103
{
110
- A_Expr * a = makeNode (A_Expr );
104
+ Node * jqual = (Node * )lfirst (jquals );
105
+
106
+ if (clause == NULL )
107
+ clause = jqual ;
108
+ else
109
+ {
110
+ A_Expr * a = makeNode (A_Expr );
111
111
112
- a -> oper = AND ;
113
- a -> opname = NULL ;
114
- a -> lexpr = (Node * )expr ;
115
- a -> rexpr = clause ;
116
- expr = a ;
112
+ a -> oper = AND ;
113
+ a -> opname = NULL ;
114
+ a -> lexpr = clause ;
115
+ a -> rexpr = jqual ;
116
+ clause = (Node * )a ;
117
+ }
117
118
}
118
119
119
- /* Make sure that we don'tdo this twice... */
120
- pstate -> p_join_quals = NULL ;
120
+ /* Make sure that we don'tadd same quals twice... */
121
+ pstate -> p_join_quals = NIL ;
121
122
122
- return ( Node * ) expr ;
123
+ return clause ;
123
124
}/* mergeInnerJoinQuals() */
124
125
125
126
/*
@@ -131,7 +132,7 @@ transformWhereClause(ParseState *pstate, Node *clause)
131
132
{
132
133
Node * qual ;
133
134
134
- if (pstate -> p_join_quals != NULL )
135
+ if (pstate -> p_join_quals != NIL )
135
136
clause = mergeInnerJoinQuals (pstate ,clause );
136
137
137
138
if (clause == NULL )
@@ -275,21 +276,22 @@ ExpandAttrs(Attr *attr)
275
276
276
277
/* transformUsingClause()
277
278
* Take an ON or USING clause from a join expression and expand if necessary.
279
+ * Result is an implicitly-ANDed list of untransformed qualification clauses.
278
280
*/
279
- static Node *
280
- transformUsingClause (ParseState * pstate ,List * usingList ,List * leftList ,List * rightList )
281
+ static List *
282
+ transformUsingClause (ParseState * pstate ,List * usingList ,
283
+ List * leftList ,List * rightList )
281
284
{
282
- A_Expr * expr = NULL ;
285
+ List * result = NIL ;
283
286
List * using ;
284
287
285
288
foreach (using ,usingList )
286
289
{
287
- List * col ;
288
- A_Expr * e ;
289
-
290
290
Attr * uattr = lfirst (using );
291
291
Attr * lattr = NULL ,
292
292
* rattr = NULL ;
293
+ List * col ;
294
+ A_Expr * e ;
293
295
294
296
/*
295
297
* find the first instances of this column in the shape list and
@@ -324,22 +326,11 @@ transformUsingClause(ParseState *pstate, List *usingList, List *leftList, List *
324
326
e -> lexpr = (Node * )lattr ;
325
327
e -> rexpr = (Node * )rattr ;
326
328
327
- if (expr != NULL )
328
- {
329
- A_Expr * a = makeNode (A_Expr );
330
-
331
- a -> oper = AND ;
332
- a -> opname = NULL ;
333
- a -> lexpr = (Node * )expr ;
334
- a -> rexpr = (Node * )e ;
335
- expr = a ;
336
- }
337
- else
338
- expr = e ;
329
+ result = lappend (result ,e );
339
330
}
340
331
341
- return (( Node * ) transformExpr ( pstate , ( Node * ) expr , EXPR_COLUMN_FIRST )) ;
342
- }/*transformUsiongClause () */
332
+ return result ;
333
+ }/*transformUsingClause () */
343
334
344
335
#endif
345
336
@@ -632,7 +623,7 @@ parseFromClause(ParseState *pstate, List *frmList)
632
623
633
624
printf ("JOIN/USING input quals are %s\n" ,nodeToString (j -> quals ));
634
625
635
- j -> quals = ( List * ) transformUsingClause (pstate ,shape ,l_cols ,r_cols );
626
+ j -> quals = transformUsingClause (pstate ,shape ,l_cols ,r_cols );
636
627
637
628
printf ("JOIN/USING transformed quals are %s\n" ,nodeToString (j -> quals ));
638
629
@@ -650,7 +641,12 @@ parseFromClause(ParseState *pstate, List *frmList)
650
641
else
651
642
j -> quals = (List * )lcons (j -> quals ,NIL );
652
643
653
- pstate -> p_join_quals = (Node * )j -> quals ;
644
+ /* listCopy may not be needed here --- will j->quals list
645
+ * be used again anywhere? The #ifdef'd code below may need
646
+ * it, if it ever gets used...
647
+ */
648
+ pstate -> p_join_quals = nconc (pstate -> p_join_quals ,
649
+ listCopy (j -> quals ));
654
650
655
651
#if 0
656
652
if (qual == NULL )
@@ -660,11 +656,13 @@ parseFromClause(ParseState *pstate, List *frmList)
660
656
#endif
661
657
662
658
#if 0
659
+ /* XXX this code is WRONG because j->quals is a List
660
+ * not a simple expression. Perhaps *qual
661
+ * ought also to be a List and we append to it,
662
+ * similarly to the way p_join_quals is handled above?
663
+ */
663
664
if (* qual == NULL )
664
665
{
665
- #endif
666
-
667
- #if 0
668
666
/* merge qualified join clauses... */
669
667
if (j -> quals != NULL )
670
668
{
@@ -682,9 +680,6 @@ parseFromClause(ParseState *pstate, List *frmList)
682
680
else
683
681
* qual = (Node * )j -> quals ;
684
682
}
685
- #endif
686
-
687
- #if 0
688
683
}
689
684
else
690
685
{