1 /*-------------------------------------------------------------------------
2 *
3 * parse_clause.c
4 * handle clauses in parser
5 *
6 * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/parser/parse_clause.c
12 *
13 *-------------------------------------------------------------------------
14 */
15
16 #include "postgres.h"
17
18 #include "access/htup_details.h"
19 #include "access/nbtree.h"
20 #include "access/table.h"
21 #include "access/tsmapi.h"
22 #include "catalog/catalog.h"
23 #include "catalog/heap.h"
24 #include "catalog/pg_am.h"
25 #include "catalog/pg_amproc.h"
26 #include "catalog/pg_collation.h"
27 #include "catalog/pg_constraint.h"
28 #include "catalog/pg_type.h"
29 #include "commands/defrem.h"
30 #include "miscadmin.h"
31 #include "nodes/makefuncs.h"
32 #include "nodes/nodeFuncs.h"
33 #include "optimizer/optimizer.h"
34 #include "parser/analyze.h"
35 #include "parser/parse_clause.h"
36 #include "parser/parse_coerce.h"
37 #include "parser/parse_collate.h"
38 #include "parser/parse_expr.h"
39 #include "parser/parse_func.h"
40 #include "parser/parse_oper.h"
41 #include "parser/parse_relation.h"
42 #include "parser/parse_target.h"
43 #include "parser/parse_type.h"
44 #include "parser/parser.h"
45 #include "parser/parsetree.h"
46 #include "rewrite/rewriteManip.h"
47 #include "utils/builtins.h"
48 #include "utils/catcache.h"
49 #include "utils/guc.h"
50 #include "utils/lsyscache.h"
51 #include "utils/rel.h"
52 #include "utils/syscache.h"
53
54
55 static int extractRemainingColumns(ParseNamespaceColumn *src_nscolumns,
56 List *src_colnames,
57 List **src_colnos,
58 List **res_colnames, List **res_colvars,
59 ParseNamespaceColumn *res_nscolumns);
60 static Node *transformJoinUsingClause(ParseState *pstate,
61 RangeTblEntry *leftRTE, RangeTblEntry *rightRTE,
62 List *leftVars, List *rightVars);
63 static Node *transformJoinOnClause(ParseState *pstate, JoinExpr *j,
64 List *namespace);
65 static ParseNamespaceItem *transformTableEntry(ParseState *pstate, RangeVar *r);
66 static ParseNamespaceItem *transformRangeSubselect(ParseState *pstate,
67 RangeSubselect *r);
68 static ParseNamespaceItem *transformRangeFunction(ParseState *pstate,
69 RangeFunction *r);
70 static ParseNamespaceItem *transformRangeTableFunc(ParseState *pstate,
71 RangeTableFunc *t);
72 static TableSampleClause *transformRangeTableSample(ParseState *pstate,
73 RangeTableSample *rts);
74 static ParseNamespaceItem *getNSItemForSpecialRelationTypes(ParseState *pstate,
75 RangeVar *rv);
76 static Node *transformFromClauseItem(ParseState *pstate, Node *n,
77 ParseNamespaceItem **top_nsitem,
78 List **namespace);
79 static Var *buildVarFromNSColumn(ParseNamespaceColumn *nscol);
80 static Node *buildMergedJoinVar(ParseState *pstate, JoinType jointype,
81 Var *l_colvar, Var *r_colvar);
82 static void setNamespaceColumnVisibility(List *namespace, bool cols_visible);
83 static void setNamespaceLateralState(List *namespace,
84 bool lateral_only, bool lateral_ok);
85 static void checkExprIsVarFree(ParseState *pstate, Node *n,
86 const char *constructName);
87 static TargetEntry *findTargetlistEntrySQL92(ParseState *pstate, Node *node,
88 List **tlist, ParseExprKind exprKind);
89 static TargetEntry *findTargetlistEntrySQL99(ParseState *pstate, Node *node,
90 List **tlist, ParseExprKind exprKind);
91 static int get_matching_location(int sortgroupref,
92 List *sortgrouprefs, List *exprs);
93 static List *resolve_unique_index_expr(ParseState *pstate, InferClause *infer,
94 Relation heapRel);
95 static List *addTargetToGroupList(ParseState *pstate, TargetEntry *tle,
96 List *grouplist, List *targetlist, int location);
97 static WindowClause *findWindowClause(List *wclist, const char *name);
98 static Node *transformFrameOffset(ParseState *pstate, int frameOptions,
99 Oid rangeopfamily, Oid rangeopcintype, Oid *inRangeFunc,
100 Node *clause);
101
102
103 /*
104 * transformFromClause -
105 * Process the FROM clause and add items to the query's range table,
106 * joinlist, and namespace.
107 *
108 * Note: we assume that the pstate's p_rtable, p_joinlist, and p_namespace
109 * lists were initialized to NIL when the pstate was created.
110 * We will add onto any entries already present --- this is needed for rule
111 * processing, as well as for UPDATE and DELETE.
112 */
113 void
transformFromClause(ParseState * pstate,List * frmList)114 transformFromClause(ParseState *pstate, List *frmList)
115 {
116 ListCell *fl;
117
118 /*
119 * The grammar will have produced a list of RangeVars, RangeSubselects,
120 * RangeFunctions, and/or JoinExprs. Transform each one (possibly adding
121 * entries to the rtable), check for duplicate refnames, and then add it
122 * to the joinlist and namespace.
123 *
124 * Note we must process the items left-to-right for proper handling of
125 * LATERAL references.
126 */
127 foreach(fl, frmList)
128 {
129 Node *n = lfirst(fl);
130 ParseNamespaceItem *nsitem;
131 List *namespace;
132
133 n = transformFromClauseItem(pstate, n,
134 &nsitem,
135 &namespace);
136
137 checkNameSpaceConflicts(pstate, pstate->p_namespace, namespace);
138
139 /* Mark the new namespace items as visible only to LATERAL */
140 setNamespaceLateralState(namespace, true, true);
141
142 pstate->p_joinlist = lappend(pstate->p_joinlist, n);
143 pstate->p_namespace = list_concat(pstate->p_namespace, namespace);
144 }
145
146 /*
147 * We're done parsing the FROM list, so make all namespace items
148 * unconditionally visible. Note that this will also reset lateral_only
149 * for any namespace items that were already present when we were called;
150 * but those should have been that way already.
151 */
152 setNamespaceLateralState(pstate->p_namespace, false, true);
153 }
154
155 /*
156 * setTargetTable
157 * Add the target relation of INSERT/UPDATE/DELETE to the range table,
158 * and make the special links to it in the ParseState.
159 *
160 * We also open the target relation and acquire a write lock on it.
161 * This must be done before processing the FROM list, in case the target
162 * is also mentioned as a source relation --- we want to be sure to grab
163 * the write lock before any read lock.
164 *
165 * If alsoSource is true, add the target to the query's joinlist and
166 * namespace. For INSERT, we don't want the target to be joined to;
167 * it's a destination of tuples, not a source. For UPDATE/DELETE,
168 * we do need to scan or join the target. (NOTE: we do not bother
169 * to check for namespace conflict; we assume that the namespace was
170 * initially empty in these cases.)
171 *
172 * Finally, we mark the relation as requiring the permissions specified
173 * by requiredPerms.
174 *
175 * Returns the rangetable index of the target relation.
176 */
177 int
setTargetTable(ParseState * pstate,RangeVar * relation,bool inh,bool alsoSource,AclMode requiredPerms)178 setTargetTable(ParseState *pstate, RangeVar *relation,
179 bool inh, bool alsoSource, AclMode requiredPerms)
180 {
181 ParseNamespaceItem *nsitem;
182
183 /*
184 * ENRs hide tables of the same name, so we need to check for them first.
185 * In contrast, CTEs don't hide tables (for this purpose).
186 */
187 if (relation->schemaname == NULL &&
188 scanNameSpaceForENR(pstate, relation->relname))
189 ereport(ERROR,
190 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
191 errmsg("relation \"%s\" cannot be the target of a modifying statement",
192 relation->relname)));
193
194 /* Close old target; this could only happen for multi-action rules */
195 if (pstate->p_target_relation != NULL)
196 table_close(pstate->p_target_relation, NoLock);
197
198 /*
199 * Open target rel and grab suitable lock (which we will hold till end of
200 * transaction).
201 *
202 * free_parsestate() will eventually do the corresponding table_close(),
203 * but *not* release the lock.
204 */
205 pstate->p_target_relation = parserOpenTable(pstate, relation,
206 RowExclusiveLock);
207
208 /*
209 * Now build an RTE and a ParseNamespaceItem.
210 */
211 nsitem = addRangeTableEntryForRelation(pstate, pstate->p_target_relation,
212 RowExclusiveLock,
213 relation->alias, inh, false);
214
215 /* remember the RTE/nsitem as being the query target */
216 pstate->p_target_nsitem = nsitem;
217
218 /*
219 * Override addRangeTableEntry's default ACL_SELECT permissions check, and
220 * instead mark target table as requiring exactly the specified
221 * permissions.
222 *
223 * If we find an explicit reference to the rel later during parse
224 * analysis, we will add the ACL_SELECT bit back again; see
225 * markVarForSelectPriv and its callers.
226 */
227 nsitem->p_rte->requiredPerms = requiredPerms;
228
229 /*
230 * If UPDATE/DELETE, add table to joinlist and namespace.
231 */
232 if (alsoSource)
233 addNSItemToQuery(pstate, nsitem, true, true, true);
234
235 return nsitem->p_rtindex;
236 }
237
238 /*
239 * Extract all not-in-common columns from column lists of a source table
240 *
241 * src_nscolumns and src_colnames describe the source table.
242 *
243 * *src_colnos initially contains the column numbers of the already-merged
244 * columns. We add to it the column number of each additional column.
245 * Also append to *res_colnames the name of each additional column,
246 * append to *res_colvars a Var for each additional column, and copy the
247 * columns' nscolumns data into res_nscolumns[] (which is caller-allocated
248 * space that had better be big enough).
249 *
250 * Returns the number of columns added.
251 */
252 static int
extractRemainingColumns(ParseNamespaceColumn * src_nscolumns,List * src_colnames,List ** src_colnos,List ** res_colnames,List ** res_colvars,ParseNamespaceColumn * res_nscolumns)253 extractRemainingColumns(ParseNamespaceColumn *src_nscolumns,
254 List *src_colnames,
255 List **src_colnos,
256 List **res_colnames, List **res_colvars,
257 ParseNamespaceColumn *res_nscolumns)
258 {
259 int colcount = 0;
260 Bitmapset *prevcols;
261 int attnum;
262 ListCell *lc;
263
264 /*
265 * While we could just test "list_member_int(*src_colnos, attnum)" to
266 * detect already-merged columns in the loop below, that would be O(N^2)
267 * for a wide input table. Instead build a bitmapset of just the merged
268 * USING columns, which we won't add to within the main loop.
269 */
270 prevcols = NULL;
271 foreach(lc, *src_colnos)
272 {
273 prevcols = bms_add_member(prevcols, lfirst_int(lc));
274 }
275
276 attnum = 0;
277 foreach(lc, src_colnames)
278 {
279 char *colname = strVal(lfirst(lc));
280
281 attnum++;
282 /* Non-dropped and not already merged? */
283 if (colname[0] != '\0' && !bms_is_member(attnum, prevcols))
284 {
285 /* Yes, so emit it as next output column */
286 *src_colnos = lappend_int(*src_colnos, attnum);
287 *res_colnames = lappend(*res_colnames, lfirst(lc));
288 *res_colvars = lappend(*res_colvars,
289 buildVarFromNSColumn(src_nscolumns + attnum - 1));
290 /* Copy the input relation's nscolumn data for this column */
291 res_nscolumns[colcount] = src_nscolumns[attnum - 1];
292 colcount++;
293 }
294 }
295 return colcount;
296 }
297
298 /* transformJoinUsingClause()
299 * Build a complete ON clause from a partially-transformed USING list.
300 * We are given lists of nodes representing left and right match columns.
301 * Result is a transformed qualification expression.
302 */
303 static Node *
transformJoinUsingClause(ParseState * pstate,RangeTblEntry * leftRTE,RangeTblEntry * rightRTE,List * leftVars,List * rightVars)304 transformJoinUsingClause(ParseState *pstate,
305 RangeTblEntry *leftRTE, RangeTblEntry *rightRTE,
306 List *leftVars, List *rightVars)
307 {
308 Node *result;
309 List *andargs = NIL;
310 ListCell *lvars,
311 *rvars;
312
313 /*
314 * We cheat a little bit here by building an untransformed operator tree
315 * whose leaves are the already-transformed Vars. This requires collusion
316 * from transformExpr(), which normally could be expected to complain
317 * about already-transformed subnodes. However, this does mean that we
318 * have to mark the columns as requiring SELECT privilege for ourselves;
319 * transformExpr() won't do it.
320 */
321 forboth(lvars, leftVars, rvars, rightVars)
322 {
323 Var *lvar = (Var *) lfirst(lvars);
324 Var *rvar = (Var *) lfirst(rvars);
325 A_Expr *e;
326
327 /* Require read access to the join variables */
328 markVarForSelectPriv(pstate, lvar, leftRTE);
329 markVarForSelectPriv(pstate, rvar, rightRTE);
330
331 /* Now create the lvar = rvar join condition */
332 e = makeSimpleA_Expr(AEXPR_OP, "=",
333 (Node *) copyObject(lvar), (Node *) copyObject(rvar),
334 -1);
335
336 /* Prepare to combine into an AND clause, if multiple join columns */
337 andargs = lappend(andargs, e);
338 }
339
340 /* Only need an AND if there's more than one join column */
341 if (list_length(andargs) == 1)
342 result = (Node *) linitial(andargs);
343 else
344 result = (Node *) makeBoolExpr(AND_EXPR, andargs, -1);
345
346 /*
347 * Since the references are already Vars, and are certainly from the input
348 * relations, we don't have to go through the same pushups that
349 * transformJoinOnClause() does. Just invoke transformExpr() to fix up
350 * the operators, and we're done.
351 */
352 result = transformExpr(pstate, result, EXPR_KIND_JOIN_USING);
353
354 result = coerce_to_boolean(pstate, result, "JOIN/USING");
355
356 return result;
357 }
358
359 /* transformJoinOnClause()
360 * Transform the qual conditions for JOIN/ON.
361 * Result is a transformed qualification expression.
362 */
363 static Node *
transformJoinOnClause(ParseState * pstate,JoinExpr * j,List * namespace)364 transformJoinOnClause(ParseState *pstate, JoinExpr *j, List *namespace)
365 {
366 Node *result;
367 List *save_namespace;
368
369 /*
370 * The namespace that the join expression should see is just the two
371 * subtrees of the JOIN plus any outer references from upper pstate
372 * levels. Temporarily set this pstate's namespace accordingly. (We need
373 * not check for refname conflicts, because transformFromClauseItem()
374 * already did.) All namespace items are marked visible regardless of
375 * LATERAL state.
376 */
377 setNamespaceLateralState(namespace, false, true);
378
379 save_namespace = pstate->p_namespace;
380 pstate->p_namespace = namespace;
381
382 result = transformWhereClause(pstate, j->quals,
383 EXPR_KIND_JOIN_ON, "JOIN/ON");
384
385 pstate->p_namespace = save_namespace;
386
387 return result;
388 }
389
390 /*
391 * transformTableEntry --- transform a RangeVar (simple relation reference)
392 */
393 static ParseNamespaceItem *
transformTableEntry(ParseState * pstate,RangeVar * r)394 transformTableEntry(ParseState *pstate, RangeVar *r)
395 {
396 /* addRangeTableEntry does all the work */
397 return addRangeTableEntry(pstate, r, r->alias, r->inh, true);
398 }
399
400 /*
401 * transformRangeSubselect --- transform a sub-SELECT appearing in FROM
402 */
403 static ParseNamespaceItem *
transformRangeSubselect(ParseState * pstate,RangeSubselect * r)404 transformRangeSubselect(ParseState *pstate, RangeSubselect *r)
405 {
406 Query *query;
407
408 /*
409 * We require user to supply an alias for a subselect, per SQL92. To relax
410 * this, we'd have to be prepared to gin up a unique alias for an
411 * unlabeled subselect. (This is just elog, not ereport, because the
412 * grammar should have enforced it already. It'd probably be better to
413 * report the error here, but we don't have a good error location here.)
414 */
415 if (r->alias == NULL)
416 elog(ERROR, "subquery in FROM must have an alias");
417
418 /*
419 * Set p_expr_kind to show this parse level is recursing to a subselect.
420 * We can't be nested within any expression, so don't need save-restore
421 * logic here.
422 */
423 Assert(pstate->p_expr_kind == EXPR_KIND_NONE);
424 pstate->p_expr_kind = EXPR_KIND_FROM_SUBSELECT;
425
426 /*
427 * If the subselect is LATERAL, make lateral_only names of this level
428 * visible to it. (LATERAL can't nest within a single pstate level, so we
429 * don't need save/restore logic here.)
430 */
431 Assert(!pstate->p_lateral_active);
432 pstate->p_lateral_active = r->lateral;
433
434 /*
435 * Analyze and transform the subquery.
436 */
437 query = parse_sub_analyze(r->subquery, pstate, NULL,
438 isLockedRefname(pstate, r->alias->aliasname),
439 true);
440
441 /* Restore state */
442 pstate->p_lateral_active = false;
443 pstate->p_expr_kind = EXPR_KIND_NONE;
444
445 /*
446 * Check that we got a SELECT. Anything else should be impossible given
447 * restrictions of the grammar, but check anyway.
448 */
449 if (!IsA(query, Query) ||
450 query->commandType != CMD_SELECT)
451 elog(ERROR, "unexpected non-SELECT command in subquery in FROM");
452
453 /*
454 * OK, build an RTE and nsitem for the subquery.
455 */
456 return addRangeTableEntryForSubquery(pstate,
457 query,
458 r->alias,
459 r->lateral,
460 true);
461 }
462
463
464 /*
465 * transformRangeFunction --- transform a function call appearing in FROM
466 */
467 static ParseNamespaceItem *
transformRangeFunction(ParseState * pstate,RangeFunction * r)468 transformRangeFunction(ParseState *pstate, RangeFunction *r)
469 {
470 List *funcexprs = NIL;
471 List *funcnames = NIL;
472 List *coldeflists = NIL;
473 bool is_lateral;
474 ListCell *lc;
475
476 /*
477 * We make lateral_only names of this level visible, whether or not the
478 * RangeFunction is explicitly marked LATERAL. This is needed for SQL
479 * spec compliance in the case of UNNEST(), and seems useful on
480 * convenience grounds for all functions in FROM.
481 *
482 * (LATERAL can't nest within a single pstate level, so we don't need
483 * save/restore logic here.)
484 */
485 Assert(!pstate->p_lateral_active);
486 pstate->p_lateral_active = true;
487
488 /*
489 * Transform the raw expressions.
490 *
491 * While transforming, also save function names for possible use as alias
492 * and column names. We use the same transformation rules as for a SELECT
493 * output expression. For a FuncCall node, the result will be the
494 * function name, but it is possible for the grammar to hand back other
495 * node types.
496 *
497 * We have to get this info now, because FigureColname only works on raw
498 * parsetrees. Actually deciding what to do with the names is left up to
499 * addRangeTableEntryForFunction.
500 *
501 * Likewise, collect column definition lists if there were any. But
502 * complain if we find one here and the RangeFunction has one too.
503 */
504 foreach(lc, r->functions)
505 {
506 List *pair = (List *) lfirst(lc);
507 Node *fexpr;
508 List *coldeflist;
509 Node *newfexpr;
510 Node *last_srf;
511
512 /* Disassemble the function-call/column-def-list pairs */
513 Assert(list_length(pair) == 2);
514 fexpr = (Node *) linitial(pair);
515 coldeflist = (List *) lsecond(pair);
516
517 /*
518 * If we find a function call unnest() with more than one argument and
519 * no special decoration, transform it into separate unnest() calls on
520 * each argument. This is a kluge, for sure, but it's less nasty than
521 * other ways of implementing the SQL-standard UNNEST() syntax.
522 *
523 * If there is any decoration (including a coldeflist), we don't
524 * transform, which probably means a no-such-function error later. We
525 * could alternatively throw an error right now, but that doesn't seem
526 * tremendously helpful. If someone is using any such decoration,
527 * then they're not using the SQL-standard syntax, and they're more
528 * likely expecting an un-tweaked function call.
529 *
530 * Note: the transformation changes a non-schema-qualified unnest()
531 * function name into schema-qualified pg_catalog.unnest(). This
532 * choice is also a bit debatable, but it seems reasonable to force
533 * use of built-in unnest() when we make this transformation.
534 */
535 if (IsA(fexpr, FuncCall))
536 {
537 FuncCall *fc = (FuncCall *) fexpr;
538
539 if (list_length(fc->funcname) == 1 &&
540 strcmp(strVal(linitial(fc->funcname)), "unnest") == 0 &&
541 list_length(fc->args) > 1 &&
542 fc->agg_order == NIL &&
543 fc->agg_filter == NULL &&
544 !fc->agg_star &&
545 !fc->agg_distinct &&
546 !fc->func_variadic &&
547 fc->over == NULL &&
548 coldeflist == NIL)
549 {
550 ListCell *lc;
551
552 foreach(lc, fc->args)
553 {
554 Node *arg = (Node *) lfirst(lc);
555 FuncCall *newfc;
556
557 last_srf = pstate->p_last_srf;
558
559 newfc = makeFuncCall(SystemFuncName("unnest"),
560 list_make1(arg),
561 fc->location);
562
563 newfexpr = transformExpr(pstate, (Node *) newfc,
564 EXPR_KIND_FROM_FUNCTION);
565
566 /* nodeFunctionscan.c requires SRFs to be at top level */
567 if (pstate->p_last_srf != last_srf &&
568 pstate->p_last_srf != newfexpr)
569 ereport(ERROR,
570 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
571 errmsg("set-returning functions must appear at top level of FROM"),
572 parser_errposition(pstate,
573 exprLocation(pstate->p_last_srf))));
574
575 funcexprs = lappend(funcexprs, newfexpr);
576
577 funcnames = lappend(funcnames,
578 FigureColname((Node *) newfc));
579
580 /* coldeflist is empty, so no error is possible */
581
582 coldeflists = lappend(coldeflists, coldeflist);
583 }
584 continue; /* done with this function item */
585 }
586 }
587
588 /* normal case ... */
589 last_srf = pstate->p_last_srf;
590
591 newfexpr = transformExpr(pstate, fexpr,
592 EXPR_KIND_FROM_FUNCTION);
593
594 /* nodeFunctionscan.c requires SRFs to be at top level */
595 if (pstate->p_last_srf != last_srf &&
596 pstate->p_last_srf != newfexpr)
597 ereport(ERROR,
598 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
599 errmsg("set-returning functions must appear at top level of FROM"),
600 parser_errposition(pstate,
601 exprLocation(pstate->p_last_srf))));
602
603 funcexprs = lappend(funcexprs, newfexpr);
604
605 funcnames = lappend(funcnames,
606 FigureColname(fexpr));
607
608 if (coldeflist && r->coldeflist)
609 ereport(ERROR,
610 (errcode(ERRCODE_SYNTAX_ERROR),
611 errmsg("multiple column definition lists are not allowed for the same function"),
612 parser_errposition(pstate,
613 exprLocation((Node *) r->coldeflist))));
614
615 coldeflists = lappend(coldeflists, coldeflist);
616 }
617
618 pstate->p_lateral_active = false;
619
620 /*
621 * We must assign collations now so that the RTE exposes correct collation
622 * info for Vars created from it.
623 */
624 assign_list_collations(pstate, funcexprs);
625
626 /*
627 * Install the top-level coldeflist if there was one (we already checked
628 * that there was no conflicting per-function coldeflist).
629 *
630 * We only allow this when there's a single function (even after UNNEST
631 * expansion) and no WITH ORDINALITY. The reason for the latter
632 * restriction is that it's not real clear whether the ordinality column
633 * should be in the coldeflist, and users are too likely to make mistakes
634 * in one direction or the other. Putting the coldeflist inside ROWS
635 * FROM() is much clearer in this case.
636 */
637 if (r->coldeflist)
638 {
639 if (list_length(funcexprs) != 1)
640 {
641 if (r->is_rowsfrom)
642 ereport(ERROR,
643 (errcode(ERRCODE_SYNTAX_ERROR),
644 errmsg("ROWS FROM() with multiple functions cannot have a column definition list"),
645 errhint("Put a separate column definition list for each function inside ROWS FROM()."),
646 parser_errposition(pstate,
647 exprLocation((Node *) r->coldeflist))));
648 else
649 ereport(ERROR,
650 (errcode(ERRCODE_SYNTAX_ERROR),
651 errmsg("UNNEST() with multiple arguments cannot have a column definition list"),
652 errhint("Use separate UNNEST() calls inside ROWS FROM(), and attach a column definition list to each one."),
653 parser_errposition(pstate,
654 exprLocation((Node *) r->coldeflist))));
655 }
656 if (r->ordinality)
657 ereport(ERROR,
658 (errcode(ERRCODE_SYNTAX_ERROR),
659 errmsg("WITH ORDINALITY cannot be used with a column definition list"),
660 errhint("Put the column definition list inside ROWS FROM()."),
661 parser_errposition(pstate,
662 exprLocation((Node *) r->coldeflist))));
663
664 coldeflists = list_make1(r->coldeflist);
665 }
666
667 /*
668 * Mark the RTE as LATERAL if the user said LATERAL explicitly, or if
669 * there are any lateral cross-references in it.
670 */
671 is_lateral = r->lateral || contain_vars_of_level((Node *) funcexprs, 0);
672
673 /*
674 * OK, build an RTE and nsitem for the function.
675 */
676 return addRangeTableEntryForFunction(pstate,
677 funcnames, funcexprs, coldeflists,
678 r, is_lateral, true);
679 }
680
681 /*
682 * transformRangeTableFunc -
683 * Transform a raw RangeTableFunc into TableFunc.
684 *
685 * Transform the namespace clauses, the document-generating expression, the
686 * row-generating expression, the column-generating expressions, and the
687 * default value expressions.
688 */
689 static ParseNamespaceItem *
transformRangeTableFunc(ParseState * pstate,RangeTableFunc * rtf)690 transformRangeTableFunc(ParseState *pstate, RangeTableFunc *rtf)
691 {
692 TableFunc *tf = makeNode(TableFunc);
693 const char *constructName;
694 Oid docType;
695 bool is_lateral;
696 ListCell *col;
697 char **names;
698 int colno;
699
700 /* Currently only XMLTABLE is supported */
701 constructName = "XMLTABLE";
702 docType = XMLOID;
703
704 /*
705 * We make lateral_only names of this level visible, whether or not the
706 * RangeTableFunc is explicitly marked LATERAL. This is needed for SQL
707 * spec compliance and seems useful on convenience grounds for all
708 * functions in FROM.
709 *
710 * (LATERAL can't nest within a single pstate level, so we don't need
711 * save/restore logic here.)
712 */
713 Assert(!pstate->p_lateral_active);
714 pstate->p_lateral_active = true;
715
716 /* Transform and apply typecast to the row-generating expression ... */
717 Assert(rtf->rowexpr != NULL);
718 tf->rowexpr = coerce_to_specific_type(pstate,
719 transformExpr(pstate, rtf->rowexpr, EXPR_KIND_FROM_FUNCTION),
720 TEXTOID,
721 constructName);
722 assign_expr_collations(pstate, tf->rowexpr);
723
724 /* ... and to the document itself */
725 Assert(rtf->docexpr != NULL);
726 tf->docexpr = coerce_to_specific_type(pstate,
727 transformExpr(pstate, rtf->docexpr, EXPR_KIND_FROM_FUNCTION),
728 docType,
729 constructName);
730 assign_expr_collations(pstate, tf->docexpr);
731
732 /* undef ordinality column number */
733 tf->ordinalitycol = -1;
734
735 /* Process column specs */
736 names = palloc(sizeof(char *) * list_length(rtf->columns));
737
738 colno = 0;
739 foreach(col, rtf->columns)
740 {
741 RangeTableFuncCol *rawc = (RangeTableFuncCol *) lfirst(col);
742 Oid typid;
743 int32 typmod;
744 Node *colexpr;
745 Node *coldefexpr;
746 int j;
747
748 tf->colnames = lappend(tf->colnames,
749 makeString(pstrdup(rawc->colname)));
750
751 /*
752 * Determine the type and typmod for the new column. FOR ORDINALITY
753 * columns are INTEGER per spec; the others are user-specified.
754 */
755 if (rawc->for_ordinality)
756 {
757 if (tf->ordinalitycol != -1)
758 ereport(ERROR,
759 (errcode(ERRCODE_SYNTAX_ERROR),
760 errmsg("only one FOR ORDINALITY column is allowed"),
761 parser_errposition(pstate, rawc->location)));
762
763 typid = INT4OID;
764 typmod = -1;
765 tf->ordinalitycol = colno;
766 }
767 else
768 {
769 if (rawc->typeName->setof)
770 ereport(ERROR,
771 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
772 errmsg("column \"%s\" cannot be declared SETOF",
773 rawc->colname),
774 parser_errposition(pstate, rawc->location)));
775
776 typenameTypeIdAndMod(pstate, rawc->typeName,
777 &typid, &typmod);
778 }
779
780 tf->coltypes = lappend_oid(tf->coltypes, typid);
781 tf->coltypmods = lappend_int(tf->coltypmods, typmod);
782 tf->colcollations = lappend_oid(tf->colcollations,
783 get_typcollation(typid));
784
785 /* Transform the PATH and DEFAULT expressions */
786 if (rawc->colexpr)
787 {
788 colexpr = coerce_to_specific_type(pstate,
789 transformExpr(pstate, rawc->colexpr,
790 EXPR_KIND_FROM_FUNCTION),
791 TEXTOID,
792 constructName);
793 assign_expr_collations(pstate, colexpr);
794 }
795 else
796 colexpr = NULL;
797
798 if (rawc->coldefexpr)
799 {
800 coldefexpr = coerce_to_specific_type_typmod(pstate,
801 transformExpr(pstate, rawc->coldefexpr,
802 EXPR_KIND_FROM_FUNCTION),
803 typid, typmod,
804 constructName);
805 assign_expr_collations(pstate, coldefexpr);
806 }
807 else
808 coldefexpr = NULL;
809
810 tf->colexprs = lappend(tf->colexprs, colexpr);
811 tf->coldefexprs = lappend(tf->coldefexprs, coldefexpr);
812
813 if (rawc->is_not_null)
814 tf->notnulls = bms_add_member(tf->notnulls, colno);
815
816 /* make sure column names are unique */
817 for (j = 0; j < colno; j++)
818 if (strcmp(names[j], rawc->colname) == 0)
819 ereport(ERROR,
820 (errcode(ERRCODE_SYNTAX_ERROR),
821 errmsg("column name \"%s\" is not unique",
822 rawc->colname),
823 parser_errposition(pstate, rawc->location)));
824 names[colno] = rawc->colname;
825
826 colno++;
827 }
828 pfree(names);
829
830 /* Namespaces, if any, also need to be transformed */
831 if (rtf->namespaces != NIL)
832 {
833 ListCell *ns;
834 ListCell *lc2;
835 List *ns_uris = NIL;
836 List *ns_names = NIL;
837 bool default_ns_seen = false;
838
839 foreach(ns, rtf->namespaces)
840 {
841 ResTarget *r = (ResTarget *) lfirst(ns);
842 Node *ns_uri;
843
844 Assert(IsA(r, ResTarget));
845 ns_uri = transformExpr(pstate, r->val, EXPR_KIND_FROM_FUNCTION);
846 ns_uri = coerce_to_specific_type(pstate, ns_uri,
847 TEXTOID, constructName);
848 assign_expr_collations(pstate, ns_uri);
849 ns_uris = lappend(ns_uris, ns_uri);
850
851 /* Verify consistency of name list: no dupes, only one DEFAULT */
852 if (r->name != NULL)
853 {
854 foreach(lc2, ns_names)
855 {
856 Value *ns_node = (Value *) lfirst(lc2);
857
858 if (ns_node == NULL)
859 continue;
860 if (strcmp(strVal(ns_node), r->name) == 0)
861 ereport(ERROR,
862 (errcode(ERRCODE_SYNTAX_ERROR),
863 errmsg("namespace name \"%s\" is not unique",
864 r->name),
865 parser_errposition(pstate, r->location)));
866 }
867 }
868 else
869 {
870 if (default_ns_seen)
871 ereport(ERROR,
872 (errcode(ERRCODE_SYNTAX_ERROR),
873 errmsg("only one default namespace is allowed"),
874 parser_errposition(pstate, r->location)));
875 default_ns_seen = true;
876 }
877
878 /* We represent DEFAULT by a null pointer */
879 ns_names = lappend(ns_names,
880 r->name ? makeString(r->name) : NULL);
881 }
882
883 tf->ns_uris = ns_uris;
884 tf->ns_names = ns_names;
885 }
886
887 tf->location = rtf->location;
888
889 pstate->p_lateral_active = false;
890
891 /*
892 * Mark the RTE as LATERAL if the user said LATERAL explicitly, or if
893 * there are any lateral cross-references in it.
894 */
895 is_lateral = rtf->lateral || contain_vars_of_level((Node *) tf, 0);
896
897 return addRangeTableEntryForTableFunc(pstate,
898 tf, rtf->alias, is_lateral, true);
899 }
900
901 /*
902 * transformRangeTableSample --- transform a TABLESAMPLE clause
903 *
904 * Caller has already transformed rts->relation, we just have to validate
905 * the remaining fields and create a TableSampleClause node.
906 */
907 static TableSampleClause *
transformRangeTableSample(ParseState * pstate,RangeTableSample * rts)908 transformRangeTableSample(ParseState *pstate, RangeTableSample *rts)
909 {
910 TableSampleClause *tablesample;
911 Oid handlerOid;
912 Oid funcargtypes[1];
913 TsmRoutine *tsm;
914 List *fargs;
915 ListCell *larg,
916 *ltyp;
917
918 /*
919 * To validate the sample method name, look up the handler function, which
920 * has the same name, one dummy INTERNAL argument, and a result type of
921 * tsm_handler. (Note: tablesample method names are not schema-qualified
922 * in the SQL standard; but since they are just functions to us, we allow
923 * schema qualification to resolve any potential ambiguity.)
924 */
925 funcargtypes[0] = INTERNALOID;
926
927 handlerOid = LookupFuncName(rts->method, 1, funcargtypes, true);
928
929 /* we want error to complain about no-such-method, not no-such-function */
930 if (!OidIsValid(handlerOid))
931 ereport(ERROR,
932 (errcode(ERRCODE_UNDEFINED_OBJECT),
933 errmsg("tablesample method %s does not exist",
934 NameListToString(rts->method)),
935 parser_errposition(pstate, rts->location)));
936
937 /* check that handler has correct return type */
938 if (get_func_rettype(handlerOid) != TSM_HANDLEROID)
939 ereport(ERROR,
940 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
941 errmsg("function %s must return type %s",
942 NameListToString(rts->method), "tsm_handler"),
943 parser_errposition(pstate, rts->location)));
944
945 /* OK, run the handler to get TsmRoutine, for argument type info */
946 tsm = GetTsmRoutine(handlerOid);
947
948 tablesample = makeNode(TableSampleClause);
949 tablesample->tsmhandler = handlerOid;
950
951 /* check user provided the expected number of arguments */
952 if (list_length(rts->args) != list_length(tsm->parameterTypes))
953 ereport(ERROR,
954 (errcode(ERRCODE_INVALID_TABLESAMPLE_ARGUMENT),
955 errmsg_plural("tablesample method %s requires %d argument, not %d",
956 "tablesample method %s requires %d arguments, not %d",
957 list_length(tsm->parameterTypes),
958 NameListToString(rts->method),
959 list_length(tsm->parameterTypes),
960 list_length(rts->args)),
961 parser_errposition(pstate, rts->location)));
962
963 /*
964 * Transform the arguments, typecasting them as needed. Note we must also
965 * assign collations now, because assign_query_collations() doesn't
966 * examine any substructure of RTEs.
967 */
968 fargs = NIL;
969 forboth(larg, rts->args, ltyp, tsm->parameterTypes)
970 {
971 Node *arg = (Node *) lfirst(larg);
972 Oid argtype = lfirst_oid(ltyp);
973
974 arg = transformExpr(pstate, arg, EXPR_KIND_FROM_FUNCTION);
975 arg = coerce_to_specific_type(pstate, arg, argtype, "TABLESAMPLE");
976 assign_expr_collations(pstate, arg);
977 fargs = lappend(fargs, arg);
978 }
979 tablesample->args = fargs;
980
981 /* Process REPEATABLE (seed) */
982 if (rts->repeatable != NULL)
983 {
984 Node *arg;
985
986 if (!tsm->repeatable_across_queries)
987 ereport(ERROR,
988 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
989 errmsg("tablesample method %s does not support REPEATABLE",
990 NameListToString(rts->method)),
991 parser_errposition(pstate, rts->location)));
992
993 arg = transformExpr(pstate, rts->repeatable, EXPR_KIND_FROM_FUNCTION);
994 arg = coerce_to_specific_type(pstate, arg, FLOAT8OID, "REPEATABLE");
995 assign_expr_collations(pstate, arg);
996 tablesample->repeatable = (Expr *) arg;
997 }
998 else
999 tablesample->repeatable = NULL;
1000
1001 return tablesample;
1002 }
1003
1004 /*
1005 * getNSItemForSpecialRelationTypes
1006 *
1007 * If given RangeVar refers to a CTE or an EphemeralNamedRelation,
1008 * build and return an appropriate ParseNamespaceItem, otherwise return NULL
1009 */
1010 static ParseNamespaceItem *
getNSItemForSpecialRelationTypes(ParseState * pstate,RangeVar * rv)1011 getNSItemForSpecialRelationTypes(ParseState *pstate, RangeVar *rv)
1012 {
1013 ParseNamespaceItem *nsitem;
1014 CommonTableExpr *cte;
1015 Index levelsup;
1016
1017 /*
1018 * if it is a qualified name, it can't be a CTE or tuplestore reference
1019 */
1020 if (rv->schemaname)
1021 return NULL;
1022
1023 cte = scanNameSpaceForCTE(pstate, rv->relname, &levelsup);
1024 if (cte)
1025 nsitem = addRangeTableEntryForCTE(pstate, cte, levelsup, rv, true);
1026 else if (scanNameSpaceForENR(pstate, rv->relname))
1027 nsitem = addRangeTableEntryForENR(pstate, rv, true);
1028 else
1029 nsitem = NULL;
1030
1031 return nsitem;
1032 }
1033
1034 /*
1035 * transformFromClauseItem -
1036 * Transform a FROM-clause item, adding any required entries to the
1037 * range table list being built in the ParseState, and return the
1038 * transformed item ready to include in the joinlist. Also build a
1039 * ParseNamespaceItem list describing the names exposed by this item.
1040 * This routine can recurse to handle SQL92 JOIN expressions.
1041 *
1042 * The function return value is the node to add to the jointree (a
1043 * RangeTblRef or JoinExpr). Additional output parameters are:
1044 *
1045 * *top_nsitem: receives the ParseNamespaceItem directly corresponding to the
1046 * jointree item. (This is only used during internal recursion, not by
1047 * outside callers.)
1048 *
1049 * *namespace: receives a List of ParseNamespaceItems for the RTEs exposed
1050 * as table/column names by this item. (The lateral_only flags in these items
1051 * are indeterminate and should be explicitly set by the caller before use.)
1052 */
1053 static Node *
transformFromClauseItem(ParseState * pstate,Node * n,ParseNamespaceItem ** top_nsitem,List ** namespace)1054 transformFromClauseItem(ParseState *pstate, Node *n,
1055 ParseNamespaceItem **top_nsitem,
1056 List **namespace)
1057 {
1058 if (IsA(n, RangeVar))
1059 {
1060 /* Plain relation reference, or perhaps a CTE reference */
1061 RangeVar *rv = (RangeVar *) n;
1062 RangeTblRef *rtr;
1063 ParseNamespaceItem *nsitem;
1064
1065 /* Check if it's a CTE or tuplestore reference */
1066 nsitem = getNSItemForSpecialRelationTypes(pstate, rv);
1067
1068 /* if not found above, must be a table reference */
1069 if (!nsitem)
1070 nsitem = transformTableEntry(pstate, rv);
1071
1072 *top_nsitem = nsitem;
1073 *namespace = list_make1(nsitem);
1074 rtr = makeNode(RangeTblRef);
1075 rtr->rtindex = nsitem->p_rtindex;
1076 return (Node *) rtr;
1077 }
1078 else if (IsA(n, RangeSubselect))
1079 {
1080 /* sub-SELECT is like a plain relation */
1081 RangeTblRef *rtr;
1082 ParseNamespaceItem *nsitem;
1083
1084 nsitem = transformRangeSubselect(pstate, (RangeSubselect *) n);
1085 *top_nsitem = nsitem;
1086 *namespace = list_make1(nsitem);
1087 rtr = makeNode(RangeTblRef);
1088 rtr->rtindex = nsitem->p_rtindex;
1089 return (Node *) rtr;
1090 }
1091 else if (IsA(n, RangeFunction))
1092 {
1093 /* function is like a plain relation */
1094 RangeTblRef *rtr;
1095 ParseNamespaceItem *nsitem;
1096
1097 nsitem = transformRangeFunction(pstate, (RangeFunction *) n);
1098 *top_nsitem = nsitem;
1099 *namespace = list_make1(nsitem);
1100 rtr = makeNode(RangeTblRef);
1101 rtr->rtindex = nsitem->p_rtindex;
1102 return (Node *) rtr;
1103 }
1104 else if (IsA(n, RangeTableFunc))
1105 {
1106 /* table function is like a plain relation */
1107 RangeTblRef *rtr;
1108 ParseNamespaceItem *nsitem;
1109
1110 nsitem = transformRangeTableFunc(pstate, (RangeTableFunc *) n);
1111 *top_nsitem = nsitem;
1112 *namespace = list_make1(nsitem);
1113 rtr = makeNode(RangeTblRef);
1114 rtr->rtindex = nsitem->p_rtindex;
1115 return (Node *) rtr;
1116 }
1117 else if (IsA(n, RangeTableSample))
1118 {
1119 /* TABLESAMPLE clause (wrapping some other valid FROM node) */
1120 RangeTableSample *rts = (RangeTableSample *) n;
1121 Node *rel;
1122 RangeTblEntry *rte;
1123
1124 /* Recursively transform the contained relation */
1125 rel = transformFromClauseItem(pstate, rts->relation,
1126 top_nsitem, namespace);
1127 rte = (*top_nsitem)->p_rte;
1128 /* We only support this on plain relations and matviews */
1129 if (rte->rtekind != RTE_RELATION ||
1130 (rte->relkind != RELKIND_RELATION &&
1131 rte->relkind != RELKIND_MATVIEW &&
1132 rte->relkind != RELKIND_PARTITIONED_TABLE))
1133 ereport(ERROR,
1134 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1135 errmsg("TABLESAMPLE clause can only be applied to tables and materialized views"),
1136 parser_errposition(pstate, exprLocation(rts->relation))));
1137
1138 /* Transform TABLESAMPLE details and attach to the RTE */
1139 rte->tablesample = transformRangeTableSample(pstate, rts);
1140 return rel;
1141 }
1142 else if (IsA(n, JoinExpr))
1143 {
1144 /* A newfangled join expression */
1145 JoinExpr *j = (JoinExpr *) n;
1146 ParseNamespaceItem *nsitem;
1147 ParseNamespaceItem *l_nsitem;
1148 ParseNamespaceItem *r_nsitem;
1149 List *l_namespace,
1150 *r_namespace,
1151 *my_namespace,
1152 *l_colnames,
1153 *r_colnames,
1154 *res_colnames,
1155 *l_colnos,
1156 *r_colnos,
1157 *res_colvars;
1158 ParseNamespaceColumn *l_nscolumns,
1159 *r_nscolumns,
1160 *res_nscolumns;
1161 int res_colindex;
1162 bool lateral_ok;
1163 int sv_namespace_length;
1164 int k;
1165
1166 /*
1167 * Recursively process the left subtree, then the right. We must do
1168 * it in this order for correct visibility of LATERAL references.
1169 */
1170 j->larg = transformFromClauseItem(pstate, j->larg,
1171 &l_nsitem,
1172 &l_namespace);
1173
1174 /*
1175 * Make the left-side RTEs available for LATERAL access within the
1176 * right side, by temporarily adding them to the pstate's namespace
1177 * list. Per SQL:2008, if the join type is not INNER or LEFT then the
1178 * left-side names must still be exposed, but it's an error to
1179 * reference them. (Stupid design, but that's what it says.) Hence,
1180 * we always push them into the namespace, but mark them as not
1181 * lateral_ok if the jointype is wrong.
1182 *
1183 * Notice that we don't require the merged namespace list to be
1184 * conflict-free. See the comments for scanNameSpaceForRefname().
1185 */
1186 lateral_ok = (j->jointype == JOIN_INNER || j->jointype == JOIN_LEFT);
1187 setNamespaceLateralState(l_namespace, true, lateral_ok);
1188
1189 sv_namespace_length = list_length(pstate->p_namespace);
1190 pstate->p_namespace = list_concat(pstate->p_namespace, l_namespace);
1191
1192 /* And now we can process the RHS */
1193 j->rarg = transformFromClauseItem(pstate, j->rarg,
1194 &r_nsitem,
1195 &r_namespace);
1196
1197 /* Remove the left-side RTEs from the namespace list again */
1198 pstate->p_namespace = list_truncate(pstate->p_namespace,
1199 sv_namespace_length);
1200
1201 /*
1202 * Check for conflicting refnames in left and right subtrees. Must do
1203 * this because higher levels will assume I hand back a self-
1204 * consistent namespace list.
1205 */
1206 checkNameSpaceConflicts(pstate, l_namespace, r_namespace);
1207
1208 /*
1209 * Generate combined namespace info for possible use below.
1210 */
1211 my_namespace = list_concat(l_namespace, r_namespace);
1212
1213 /*
1214 * We'll work from the nscolumns data and eref alias column names for
1215 * each of the input nsitems. Note that these include dropped
1216 * columns, which is helpful because we can keep track of physical
1217 * input column numbers more easily.
1218 */
1219 l_nscolumns = l_nsitem->p_nscolumns;
1220 l_colnames = l_nsitem->p_rte->eref->colnames;
1221 r_nscolumns = r_nsitem->p_nscolumns;
1222 r_colnames = r_nsitem->p_rte->eref->colnames;
1223
1224 /*
1225 * Natural join does not explicitly specify columns; must generate
1226 * columns to join. Need to run through the list of columns from each
1227 * table or join result and match up the column names. Use the first
1228 * table, and check every column in the second table for a match.
1229 * (We'll check that the matches were unique later on.) The result of
1230 * this step is a list of column names just like an explicitly-written
1231 * USING list.
1232 */
1233 if (j->isNatural)
1234 {
1235 List *rlist = NIL;
1236 ListCell *lx,
1237 *rx;
1238
1239 Assert(j->usingClause == NIL); /* shouldn't have USING() too */
1240
1241 foreach(lx, l_colnames)
1242 {
1243 char *l_colname = strVal(lfirst(lx));
1244 Value *m_name = NULL;
1245
1246 if (l_colname[0] == '\0')
1247 continue; /* ignore dropped columns */
1248
1249 foreach(rx, r_colnames)
1250 {
1251 char *r_colname = strVal(lfirst(rx));
1252
1253 if (strcmp(l_colname, r_colname) == 0)
1254 {
1255 m_name = makeString(l_colname);
1256 break;
1257 }
1258 }
1259
1260 /* matched a right column? then keep as join column... */
1261 if (m_name != NULL)
1262 rlist = lappend(rlist, m_name);
1263 }
1264
1265 j->usingClause = rlist;
1266 }
1267
1268 /*
1269 * Now transform the join qualifications, if any.
1270 */
1271 l_colnos = NIL;
1272 r_colnos = NIL;
1273 res_colnames = NIL;
1274 res_colvars = NIL;
1275
1276 /* this may be larger than needed, but it's not worth being exact */
1277 res_nscolumns = (ParseNamespaceColumn *)
1278 palloc0((list_length(l_colnames) + list_length(r_colnames)) *
1279 sizeof(ParseNamespaceColumn));
1280 res_colindex = 0;
1281
1282 if (j->usingClause)
1283 {
1284 /*
1285 * JOIN/USING (or NATURAL JOIN, as transformed above). Transform
1286 * the list into an explicit ON-condition, and generate a list of
1287 * merged result columns.
1288 */
1289 List *ucols = j->usingClause;
1290 List *l_usingvars = NIL;
1291 List *r_usingvars = NIL;
1292 ListCell *ucol;
1293
1294 Assert(j->quals == NULL); /* shouldn't have ON() too */
1295
1296 foreach(ucol, ucols)
1297 {
1298 char *u_colname = strVal(lfirst(ucol));
1299 ListCell *col;
1300 int ndx;
1301 int l_index = -1;
1302 int r_index = -1;
1303 Var *l_colvar,
1304 *r_colvar;
1305 Node *u_colvar;
1306 ParseNamespaceColumn *res_nscolumn;
1307
1308 Assert(u_colname[0] != '\0');
1309
1310 /* Check for USING(foo,foo) */
1311 foreach(col, res_colnames)
1312 {
1313 char *res_colname = strVal(lfirst(col));
1314
1315 if (strcmp(res_colname, u_colname) == 0)
1316 ereport(ERROR,
1317 (errcode(ERRCODE_DUPLICATE_COLUMN),
1318 errmsg("column name \"%s\" appears more than once in USING clause",
1319 u_colname)));
1320 }
1321
1322 /* Find it in left input */
1323 ndx = 0;
1324 foreach(col, l_colnames)
1325 {
1326 char *l_colname = strVal(lfirst(col));
1327
1328 if (strcmp(l_colname, u_colname) == 0)
1329 {
1330 if (l_index >= 0)
1331 ereport(ERROR,
1332 (errcode(ERRCODE_AMBIGUOUS_COLUMN),
1333 errmsg("common column name \"%s\" appears more than once in left table",
1334 u_colname)));
1335 l_index = ndx;
1336 }
1337 ndx++;
1338 }
1339 if (l_index < 0)
1340 ereport(ERROR,
1341 (errcode(ERRCODE_UNDEFINED_COLUMN),
1342 errmsg("column \"%s\" specified in USING clause does not exist in left table",
1343 u_colname)));
1344 l_colnos = lappend_int(l_colnos, l_index + 1);
1345
1346 /* Find it in right input */
1347 ndx = 0;
1348 foreach(col, r_colnames)
1349 {
1350 char *r_colname = strVal(lfirst(col));
1351
1352 if (strcmp(r_colname, u_colname) == 0)
1353 {
1354 if (r_index >= 0)
1355 ereport(ERROR,
1356 (errcode(ERRCODE_AMBIGUOUS_COLUMN),
1357 errmsg("common column name \"%s\" appears more than once in right table",
1358 u_colname)));
1359 r_index = ndx;
1360 }
1361 ndx++;
1362 }
1363 if (r_index < 0)
1364 ereport(ERROR,
1365 (errcode(ERRCODE_UNDEFINED_COLUMN),
1366 errmsg("column \"%s\" specified in USING clause does not exist in right table",
1367 u_colname)));
1368 r_colnos = lappend_int(r_colnos, r_index + 1);
1369
1370 l_colvar = buildVarFromNSColumn(l_nscolumns + l_index);
1371 l_usingvars = lappend(l_usingvars, l_colvar);
1372 r_colvar = buildVarFromNSColumn(r_nscolumns + r_index);
1373 r_usingvars = lappend(r_usingvars, r_colvar);
1374
1375 res_colnames = lappend(res_colnames, lfirst(ucol));
1376 u_colvar = buildMergedJoinVar(pstate,
1377 j->jointype,
1378 l_colvar,
1379 r_colvar);
1380 res_colvars = lappend(res_colvars, u_colvar);
1381 res_nscolumn = res_nscolumns + res_colindex;
1382 res_colindex++;
1383 if (u_colvar == (Node *) l_colvar)
1384 {
1385 /* Merged column is equivalent to left input */
1386 *res_nscolumn = l_nscolumns[l_index];
1387 }
1388 else if (u_colvar == (Node *) r_colvar)
1389 {
1390 /* Merged column is equivalent to right input */
1391 *res_nscolumn = r_nscolumns[r_index];
1392 }
1393 else
1394 {
1395 /*
1396 * Merged column is not semantically equivalent to either
1397 * input, so it needs to be referenced as the join output
1398 * column. We don't know the join's varno yet, so we'll
1399 * replace these zeroes below.
1400 */
1401 res_nscolumn->p_varno = 0;
1402 res_nscolumn->p_varattno = res_colindex;
1403 res_nscolumn->p_vartype = exprType(u_colvar);
1404 res_nscolumn->p_vartypmod = exprTypmod(u_colvar);
1405 res_nscolumn->p_varcollid = exprCollation(u_colvar);
1406 res_nscolumn->p_varnosyn = 0;
1407 res_nscolumn->p_varattnosyn = res_colindex;
1408 }
1409 }
1410
1411 j->quals = transformJoinUsingClause(pstate,
1412 l_nsitem->p_rte,
1413 r_nsitem->p_rte,
1414 l_usingvars,
1415 r_usingvars);
1416 }
1417 else if (j->quals)
1418 {
1419 /* User-written ON-condition; transform it */
1420 j->quals = transformJoinOnClause(pstate, j, my_namespace);
1421 }
1422 else
1423 {
1424 /* CROSS JOIN: no quals */
1425 }
1426
1427 /* Add remaining columns from each side to the output columns */
1428 res_colindex +=
1429 extractRemainingColumns(l_nscolumns, l_colnames, &l_colnos,
1430 &res_colnames, &res_colvars,
1431 res_nscolumns + res_colindex);
1432 res_colindex +=
1433 extractRemainingColumns(r_nscolumns, r_colnames, &r_colnos,
1434 &res_colnames, &res_colvars,
1435 res_nscolumns + res_colindex);
1436
1437 /*
1438 * Check alias (AS clause), if any.
1439 */
1440 if (j->alias)
1441 {
1442 if (j->alias->colnames != NIL)
1443 {
1444 if (list_length(j->alias->colnames) > list_length(res_colnames))
1445 ereport(ERROR,
1446 (errcode(ERRCODE_SYNTAX_ERROR),
1447 errmsg("column alias list for \"%s\" has too many entries",
1448 j->alias->aliasname)));
1449 }
1450 }
1451
1452 /*
1453 * Now build an RTE and nsitem for the result of the join.
1454 * res_nscolumns isn't totally done yet, but that's OK because
1455 * addRangeTableEntryForJoin doesn't examine it, only store a pointer.
1456 */
1457 nsitem = addRangeTableEntryForJoin(pstate,
1458 res_colnames,
1459 res_nscolumns,
1460 j->jointype,
1461 list_length(j->usingClause),
1462 res_colvars,
1463 l_colnos,
1464 r_colnos,
1465 j->alias,
1466 true);
1467
1468 j->rtindex = nsitem->p_rtindex;
1469
1470 /*
1471 * Now that we know the join RTE's rangetable index, we can fix up the
1472 * res_nscolumns data in places where it should contain that.
1473 */
1474 Assert(res_colindex == list_length(nsitem->p_rte->eref->colnames));
1475 for (k = 0; k < res_colindex; k++)
1476 {
1477 ParseNamespaceColumn *nscol = res_nscolumns + k;
1478
1479 /* fill in join RTI for merged columns */
1480 if (nscol->p_varno == 0)
1481 nscol->p_varno = j->rtindex;
1482 if (nscol->p_varnosyn == 0)
1483 nscol->p_varnosyn = j->rtindex;
1484 /* if join has an alias, it syntactically hides all inputs */
1485 if (j->alias)
1486 {
1487 nscol->p_varnosyn = j->rtindex;
1488 nscol->p_varattnosyn = k + 1;
1489 }
1490 }
1491
1492 /* make a matching link to the JoinExpr for later use */
1493 for (k = list_length(pstate->p_joinexprs) + 1; k < j->rtindex; k++)
1494 pstate->p_joinexprs = lappend(pstate->p_joinexprs, NULL);
1495 pstate->p_joinexprs = lappend(pstate->p_joinexprs, j);
1496 Assert(list_length(pstate->p_joinexprs) == j->rtindex);
1497
1498 /*
1499 * Prepare returned namespace list. If the JOIN has an alias then it
1500 * hides the contained RTEs completely; otherwise, the contained RTEs
1501 * are still visible as table names, but are not visible for
1502 * unqualified column-name access.
1503 *
1504 * Note: if there are nested alias-less JOINs, the lower-level ones
1505 * will remain in the list although they have neither p_rel_visible
1506 * nor p_cols_visible set. We could delete such list items, but it's
1507 * unclear that it's worth expending cycles to do so.
1508 */
1509 if (j->alias != NULL)
1510 my_namespace = NIL;
1511 else
1512 setNamespaceColumnVisibility(my_namespace, false);
1513
1514 /*
1515 * The join RTE itself is always made visible for unqualified column
1516 * names. It's visible as a relation name only if it has an alias.
1517 */
1518 nsitem->p_rel_visible = (j->alias != NULL);
1519 nsitem->p_cols_visible = true;
1520 nsitem->p_lateral_only = false;
1521 nsitem->p_lateral_ok = true;
1522
1523 *top_nsitem = nsitem;
1524 *namespace = lappend(my_namespace, nsitem);
1525
1526 return (Node *) j;
1527 }
1528 else
1529 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(n));
1530 return NULL; /* can't get here, keep compiler quiet */
1531 }
1532
1533 /*
1534 * buildVarFromNSColumn -
1535 * build a Var node using ParseNamespaceColumn data
1536 *
1537 * We assume varlevelsup should be 0, and no location is specified
1538 */
1539 static Var *
buildVarFromNSColumn(ParseNamespaceColumn * nscol)1540 buildVarFromNSColumn(ParseNamespaceColumn *nscol)
1541 {
1542 Var *var;
1543
1544 Assert(nscol->p_varno > 0); /* i.e., not deleted column */
1545 var = makeVar(nscol->p_varno,
1546 nscol->p_varattno,
1547 nscol->p_vartype,
1548 nscol->p_vartypmod,
1549 nscol->p_varcollid,
1550 0);
1551 /* makeVar doesn't offer parameters for these, so set by hand: */
1552 var->varnosyn = nscol->p_varnosyn;
1553 var->varattnosyn = nscol->p_varattnosyn;
1554 return var;
1555 }
1556
1557 /*
1558 * buildMergedJoinVar -
1559 * generate a suitable replacement expression for a merged join column
1560 */
1561 static Node *
buildMergedJoinVar(ParseState * pstate,JoinType jointype,Var * l_colvar,Var * r_colvar)1562 buildMergedJoinVar(ParseState *pstate, JoinType jointype,
1563 Var *l_colvar, Var *r_colvar)
1564 {
1565 Oid outcoltype;
1566 int32 outcoltypmod;
1567 Node *l_node,
1568 *r_node,
1569 *res_node;
1570
1571 /*
1572 * Choose output type if input types are dissimilar.
1573 */
1574 outcoltype = l_colvar->vartype;
1575 outcoltypmod = l_colvar->vartypmod;
1576 if (outcoltype != r_colvar->vartype)
1577 {
1578 outcoltype = select_common_type(pstate,
1579 list_make2(l_colvar, r_colvar),
1580 "JOIN/USING",
1581 NULL);
1582 outcoltypmod = -1; /* ie, unknown */
1583 }
1584 else if (outcoltypmod != r_colvar->vartypmod)
1585 {
1586 /* same type, but not same typmod */
1587 outcoltypmod = -1; /* ie, unknown */
1588 }
1589
1590 /*
1591 * Insert coercion functions if needed. Note that a difference in typmod
1592 * can only happen if input has typmod but outcoltypmod is -1. In that
1593 * case we insert a RelabelType to clearly mark that result's typmod is
1594 * not same as input. We never need coerce_type_typmod.
1595 */
1596 if (l_colvar->vartype != outcoltype)
1597 l_node = coerce_type(pstate, (Node *) l_colvar, l_colvar->vartype,
1598 outcoltype, outcoltypmod,
1599 COERCION_IMPLICIT, COERCE_IMPLICIT_CAST, -1);
1600 else if (l_colvar->vartypmod != outcoltypmod)
1601 l_node = (Node *) makeRelabelType((Expr *) l_colvar,
1602 outcoltype, outcoltypmod,
1603 InvalidOid, /* fixed below */
1604 COERCE_IMPLICIT_CAST);
1605 else
1606 l_node = (Node *) l_colvar;
1607
1608 if (r_colvar->vartype != outcoltype)
1609 r_node = coerce_type(pstate, (Node *) r_colvar, r_colvar->vartype,
1610 outcoltype, outcoltypmod,
1611 COERCION_IMPLICIT, COERCE_IMPLICIT_CAST, -1);
1612 else if (r_colvar->vartypmod != outcoltypmod)
1613 r_node = (Node *) makeRelabelType((Expr *) r_colvar,
1614 outcoltype, outcoltypmod,
1615 InvalidOid, /* fixed below */
1616 COERCE_IMPLICIT_CAST);
1617 else
1618 r_node = (Node *) r_colvar;
1619
1620 /*
1621 * Choose what to emit
1622 */
1623 switch (jointype)
1624 {
1625 case JOIN_INNER:
1626
1627 /*
1628 * We can use either var; prefer non-coerced one if available.
1629 */
1630 if (IsA(l_node, Var))
1631 res_node = l_node;
1632 else if (IsA(r_node, Var))
1633 res_node = r_node;
1634 else
1635 res_node = l_node;
1636 break;
1637 case JOIN_LEFT:
1638 /* Always use left var */
1639 res_node = l_node;
1640 break;
1641 case JOIN_RIGHT:
1642 /* Always use right var */
1643 res_node = r_node;
1644 break;
1645 case JOIN_FULL:
1646 {
1647 /*
1648 * Here we must build a COALESCE expression to ensure that the
1649 * join output is non-null if either input is.
1650 */
1651 CoalesceExpr *c = makeNode(CoalesceExpr);
1652
1653 c->coalescetype = outcoltype;
1654 /* coalescecollid will get set below */
1655 c->args = list_make2(l_node, r_node);
1656 c->location = -1;
1657 res_node = (Node *) c;
1658 break;
1659 }
1660 default:
1661 elog(ERROR, "unrecognized join type: %d", (int) jointype);
1662 res_node = NULL; /* keep compiler quiet */
1663 break;
1664 }
1665
1666 /*
1667 * Apply assign_expr_collations to fix up the collation info in the
1668 * coercion and CoalesceExpr nodes, if we made any. This must be done now
1669 * so that the join node's alias vars show correct collation info.
1670 */
1671 assign_expr_collations(pstate, res_node);
1672
1673 return res_node;
1674 }
1675
1676 /*
1677 * setNamespaceColumnVisibility -
1678 * Convenience subroutine to update cols_visible flags in a namespace list.
1679 */
1680 static void
setNamespaceColumnVisibility(List * namespace,bool cols_visible)1681 setNamespaceColumnVisibility(List *namespace, bool cols_visible)
1682 {
1683 ListCell *lc;
1684
1685 foreach(lc, namespace)
1686 {
1687 ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(lc);
1688
1689 nsitem->p_cols_visible = cols_visible;
1690 }
1691 }
1692
1693 /*
1694 * setNamespaceLateralState -
1695 * Convenience subroutine to update LATERAL flags in a namespace list.
1696 */
1697 static void
setNamespaceLateralState(List * namespace,bool lateral_only,bool lateral_ok)1698 setNamespaceLateralState(List *namespace, bool lateral_only, bool lateral_ok)
1699 {
1700 ListCell *lc;
1701
1702 foreach(lc, namespace)
1703 {
1704 ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(lc);
1705
1706 nsitem->p_lateral_only = lateral_only;
1707 nsitem->p_lateral_ok = lateral_ok;
1708 }
1709 }
1710
1711
1712 /*
1713 * transformWhereClause -
1714 * Transform the qualification and make sure it is of type boolean.
1715 * Used for WHERE and allied clauses.
1716 *
1717 * constructName does not affect the semantics, but is used in error messages
1718 */
1719 Node *
transformWhereClause(ParseState * pstate,Node * clause,ParseExprKind exprKind,const char * constructName)1720 transformWhereClause(ParseState *pstate, Node *clause,
1721 ParseExprKind exprKind, const char *constructName)
1722 {
1723 Node *qual;
1724
1725 if (clause == NULL)
1726 return NULL;
1727
1728 qual = transformExpr(pstate, clause, exprKind);
1729
1730 qual = coerce_to_boolean(pstate, qual, constructName);
1731
1732 return qual;
1733 }
1734
1735
1736 /*
1737 * transformLimitClause -
1738 * Transform the expression and make sure it is of type bigint.
1739 * Used for LIMIT and allied clauses.
1740 *
1741 * Note: as of Postgres 8.2, LIMIT expressions are expected to yield int8,
1742 * rather than int4 as before.
1743 *
1744 * constructName does not affect the semantics, but is used in error messages
1745 */
1746 Node *
transformLimitClause(ParseState * pstate,Node * clause,ParseExprKind exprKind,const char * constructName,LimitOption limitOption)1747 transformLimitClause(ParseState *pstate, Node *clause,
1748 ParseExprKind exprKind, const char *constructName,
1749 LimitOption limitOption)
1750 {
1751 Node *qual;
1752
1753 if (clause == NULL)
1754 return NULL;
1755
1756 qual = transformExpr(pstate, clause, exprKind);
1757
1758 qual = coerce_to_specific_type(pstate, qual, INT8OID, constructName);
1759
1760 /* LIMIT can't refer to any variables of the current query */
1761 checkExprIsVarFree(pstate, qual, constructName);
1762
1763 /*
1764 * Don't allow NULLs in FETCH FIRST .. WITH TIES. This test is ugly and
1765 * extremely simplistic, in that you can pass a NULL anyway by hiding it
1766 * inside an expression -- but this protects ruleutils against emitting an
1767 * unadorned NULL that's not accepted back by the grammar.
1768 */
1769 if (exprKind == EXPR_KIND_LIMIT && limitOption == LIMIT_OPTION_WITH_TIES &&
1770 IsA(clause, A_Const) && ((A_Const *) clause)->val.type == T_Null)
1771 ereport(ERROR,
1772 (errcode(ERRCODE_INVALID_ROW_COUNT_IN_LIMIT_CLAUSE),
1773 errmsg("row count cannot be null in FETCH FIRST ... WITH TIES clause")));
1774
1775 return qual;
1776 }
1777
1778 /*
1779 * checkExprIsVarFree
1780 * Check that given expr has no Vars of the current query level
1781 * (aggregates and window functions should have been rejected already).
1782 *
1783 * This is used to check expressions that have to have a consistent value
1784 * across all rows of the query, such as a LIMIT. Arguably it should reject
1785 * volatile functions, too, but we don't do that --- whatever value the
1786 * function gives on first execution is what you get.
1787 *
1788 * constructName does not affect the semantics, but is used in error messages
1789 */
1790 static void
checkExprIsVarFree(ParseState * pstate,Node * n,const char * constructName)1791 checkExprIsVarFree(ParseState *pstate, Node *n, const char *constructName)
1792 {
1793 if (contain_vars_of_level(n, 0))
1794 {
1795 ereport(ERROR,
1796 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1797 /* translator: %s is name of a SQL construct, eg LIMIT */
1798 errmsg("argument of %s must not contain variables",
1799 constructName),
1800 parser_errposition(pstate,
1801 locate_var_of_level(n, 0))));
1802 }
1803 }
1804
1805
1806 /*
1807 * checkTargetlistEntrySQL92 -
1808 * Validate a targetlist entry found by findTargetlistEntrySQL92
1809 *
1810 * When we select a pre-existing tlist entry as a result of syntax such
1811 * as "GROUP BY 1", we have to make sure it is acceptable for use in the
1812 * indicated clause type; transformExpr() will have treated it as a regular
1813 * targetlist item.
1814 */
1815 static void
checkTargetlistEntrySQL92(ParseState * pstate,TargetEntry * tle,ParseExprKind exprKind)1816 checkTargetlistEntrySQL92(ParseState *pstate, TargetEntry *tle,
1817 ParseExprKind exprKind)
1818 {
1819 switch (exprKind)
1820 {
1821 case EXPR_KIND_GROUP_BY:
1822 /* reject aggregates and window functions */
1823 if (pstate->p_hasAggs &&
1824 contain_aggs_of_level((Node *) tle->expr, 0))
1825 ereport(ERROR,
1826 (errcode(ERRCODE_GROUPING_ERROR),
1827 /* translator: %s is name of a SQL construct, eg GROUP BY */
1828 errmsg("aggregate functions are not allowed in %s",
1829 ParseExprKindName(exprKind)),
1830 parser_errposition(pstate,
1831 locate_agg_of_level((Node *) tle->expr, 0))));
1832 if (pstate->p_hasWindowFuncs &&
1833 contain_windowfuncs((Node *) tle->expr))
1834 ereport(ERROR,
1835 (errcode(ERRCODE_WINDOWING_ERROR),
1836 /* translator: %s is name of a SQL construct, eg GROUP BY */
1837 errmsg("window functions are not allowed in %s",
1838 ParseExprKindName(exprKind)),
1839 parser_errposition(pstate,
1840 locate_windowfunc((Node *) tle->expr))));
1841 break;
1842 case EXPR_KIND_ORDER_BY:
1843 /* no extra checks needed */
1844 break;
1845 case EXPR_KIND_DISTINCT_ON:
1846 /* no extra checks needed */
1847 break;
1848 default:
1849 elog(ERROR, "unexpected exprKind in checkTargetlistEntrySQL92");
1850 break;
1851 }
1852 }
1853
1854 /*
1855 * findTargetlistEntrySQL92 -
1856 * Returns the targetlist entry matching the given (untransformed) node.
1857 * If no matching entry exists, one is created and appended to the target
1858 * list as a "resjunk" node.
1859 *
1860 * This function supports the old SQL92 ORDER BY interpretation, where the
1861 * expression is an output column name or number. If we fail to find a
1862 * match of that sort, we fall through to the SQL99 rules. For historical
1863 * reasons, Postgres also allows this interpretation for GROUP BY, though
1864 * the standard never did. However, for GROUP BY we prefer a SQL99 match.
1865 * This function is *not* used for WINDOW definitions.
1866 *
1867 * node the ORDER BY, GROUP BY, or DISTINCT ON expression to be matched
1868 * tlist the target list (passed by reference so we can append to it)
1869 * exprKind identifies clause type being processed
1870 */
1871 static TargetEntry *
findTargetlistEntrySQL92(ParseState * pstate,Node * node,List ** tlist,ParseExprKind exprKind)1872 findTargetlistEntrySQL92(ParseState *pstate, Node *node, List **tlist,
1873 ParseExprKind exprKind)
1874 {
1875 ListCell *tl;
1876
1877 /*----------
1878 * Handle two special cases as mandated by the SQL92 spec:
1879 *
1880 * 1. Bare ColumnName (no qualifier or subscripts)
1881 * For a bare identifier, we search for a matching column name
1882 * in the existing target list. Multiple matches are an error
1883 * unless they refer to identical values; for example,
1884 * we allow SELECT a, a FROM table ORDER BY a
1885 * but not SELECT a AS b, b FROM table ORDER BY b
1886 * If no match is found, we fall through and treat the identifier
1887 * as an expression.
1888 * For GROUP BY, it is incorrect to match the grouping item against
1889 * targetlist entries: according to SQL92, an identifier in GROUP BY
1890 * is a reference to a column name exposed by FROM, not to a target
1891 * list column. However, many implementations (including pre-7.0
1892 * PostgreSQL) accept this anyway. So for GROUP BY, we look first
1893 * to see if the identifier matches any FROM column name, and only
1894 * try for a targetlist name if it doesn't. This ensures that we
1895 * adhere to the spec in the case where the name could be both.
1896 * DISTINCT ON isn't in the standard, so we can do what we like there;
1897 * we choose to make it work like ORDER BY, on the rather flimsy
1898 * grounds that ordinary DISTINCT works on targetlist entries.
1899 *
1900 * 2. IntegerConstant
1901 * This means to use the n'th item in the existing target list.
1902 * Note that it would make no sense to order/group/distinct by an
1903 * actual constant, so this does not create a conflict with SQL99.
1904 * GROUP BY column-number is not allowed by SQL92, but since
1905 * the standard has no other behavior defined for this syntax,
1906 * we may as well accept this common extension.
1907 *
1908 * Note that pre-existing resjunk targets must not be used in either case,
1909 * since the user didn't write them in his SELECT list.
1910 *
1911 * If neither special case applies, fall through to treat the item as
1912 * an expression per SQL99.
1913 *----------
1914 */
1915 if (IsA(node, ColumnRef) &&
1916 list_length(((ColumnRef *) node)->fields) == 1 &&
1917 IsA(linitial(((ColumnRef *) node)->fields), String))
1918 {
1919 char *name = strVal(linitial(((ColumnRef *) node)->fields));
1920 int location = ((ColumnRef *) node)->location;
1921
1922 if (exprKind == EXPR_KIND_GROUP_BY)
1923 {
1924 /*
1925 * In GROUP BY, we must prefer a match against a FROM-clause
1926 * column to one against the targetlist. Look to see if there is
1927 * a matching column. If so, fall through to use SQL99 rules.
1928 * NOTE: if name could refer ambiguously to more than one column
1929 * name exposed by FROM, colNameToVar will ereport(ERROR). That's
1930 * just what we want here.
1931 *
1932 * Small tweak for 7.4.3: ignore matches in upper query levels.
1933 * This effectively changes the search order for bare names to (1)
1934 * local FROM variables, (2) local targetlist aliases, (3) outer
1935 * FROM variables, whereas before it was (1) (3) (2). SQL92 and
1936 * SQL99 do not allow GROUPing BY an outer reference, so this
1937 * breaks no cases that are legal per spec, and it seems a more
1938 * self-consistent behavior.
1939 */
1940 if (colNameToVar(pstate, name, true, location) != NULL)
1941 name = NULL;
1942 }
1943
1944 if (name != NULL)
1945 {
1946 TargetEntry *target_result = NULL;
1947
1948 foreach(tl, *tlist)
1949 {
1950 TargetEntry *tle = (TargetEntry *) lfirst(tl);
1951
1952 if (!tle->resjunk &&
1953 strcmp(tle->resname, name) == 0)
1954 {
1955 if (target_result != NULL)
1956 {
1957 if (!equal(target_result->expr, tle->expr))
1958 ereport(ERROR,
1959 (errcode(ERRCODE_AMBIGUOUS_COLUMN),
1960
1961 /*------
1962 translator: first %s is name of a SQL construct, eg ORDER BY */
1963 errmsg("%s \"%s\" is ambiguous",
1964 ParseExprKindName(exprKind),
1965 name),
1966 parser_errposition(pstate, location)));
1967 }
1968 else
1969 target_result = tle;
1970 /* Stay in loop to check for ambiguity */
1971 }
1972 }
1973 if (target_result != NULL)
1974 {
1975 /* return the first match, after suitable validation */
1976 checkTargetlistEntrySQL92(pstate, target_result, exprKind);
1977 return target_result;
1978 }
1979 }
1980 }
1981 if (IsA(node, A_Const))
1982 {
1983 Value *val = &((A_Const *) node)->val;
1984 int location = ((A_Const *) node)->location;
1985 int targetlist_pos = 0;
1986 int target_pos;
1987
1988 if (!IsA(val, Integer))
1989 ereport(ERROR,
1990 (errcode(ERRCODE_SYNTAX_ERROR),
1991 /* translator: %s is name of a SQL construct, eg ORDER BY */
1992 errmsg("non-integer constant in %s",
1993 ParseExprKindName(exprKind)),
1994 parser_errposition(pstate, location)));
1995
1996 target_pos = intVal(val);
1997 foreach(tl, *tlist)
1998 {
1999 TargetEntry *tle = (TargetEntry *) lfirst(tl);
2000
2001 if (!tle->resjunk)
2002 {
2003 if (++targetlist_pos == target_pos)
2004 {
2005 /* return the unique match, after suitable validation */
2006 checkTargetlistEntrySQL92(pstate, tle, exprKind);
2007 return tle;
2008 }
2009 }
2010 }
2011 ereport(ERROR,
2012 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
2013 /* translator: %s is name of a SQL construct, eg ORDER BY */
2014 errmsg("%s position %d is not in select list",
2015 ParseExprKindName(exprKind), target_pos),
2016 parser_errposition(pstate, location)));
2017 }
2018
2019 /*
2020 * Otherwise, we have an expression, so process it per SQL99 rules.
2021 */
2022 return findTargetlistEntrySQL99(pstate, node, tlist, exprKind);
2023 }
2024
2025 /*
2026 * findTargetlistEntrySQL99 -
2027 * Returns the targetlist entry matching the given (untransformed) node.
2028 * If no matching entry exists, one is created and appended to the target
2029 * list as a "resjunk" node.
2030 *
2031 * This function supports the SQL99 interpretation, wherein the expression
2032 * is just an ordinary expression referencing input column names.
2033 *
2034 * node the ORDER BY, GROUP BY, etc expression to be matched
2035 * tlist the target list (passed by reference so we can append to it)
2036 * exprKind identifies clause type being processed
2037 */
2038 static TargetEntry *
findTargetlistEntrySQL99(ParseState * pstate,Node * node,List ** tlist,ParseExprKind exprKind)2039 findTargetlistEntrySQL99(ParseState *pstate, Node *node, List **tlist,
2040 ParseExprKind exprKind)
2041 {
2042 TargetEntry *target_result;
2043 ListCell *tl;
2044 Node *expr;
2045
2046 /*
2047 * Convert the untransformed node to a transformed expression, and search
2048 * for a match in the tlist. NOTE: it doesn't really matter whether there
2049 * is more than one match. Also, we are willing to match an existing
2050 * resjunk target here, though the SQL92 cases above must ignore resjunk
2051 * targets.
2052 */
2053 expr = transformExpr(pstate, node, exprKind);
2054
2055 foreach(tl, *tlist)
2056 {
2057 TargetEntry *tle = (TargetEntry *) lfirst(tl);
2058 Node *texpr;
2059
2060 /*
2061 * Ignore any implicit cast on the existing tlist expression.
2062 *
2063 * This essentially allows the ORDER/GROUP/etc item to adopt the same
2064 * datatype previously selected for a textually-equivalent tlist item.
2065 * There can't be any implicit cast at top level in an ordinary SELECT
2066 * tlist at this stage, but the case does arise with ORDER BY in an
2067 * aggregate function.
2068 */
2069 texpr = strip_implicit_coercions((Node *) tle->expr);
2070
2071 if (equal(expr, texpr))
2072 return tle;
2073 }
2074
2075 /*
2076 * If no matches, construct a new target entry which is appended to the
2077 * end of the target list. This target is given resjunk = true so that it
2078 * will not be projected into the final tuple.
2079 */
2080 target_result = transformTargetEntry(pstate, node, expr, exprKind,
2081 NULL, true);
2082
2083 *tlist = lappend(*tlist, target_result);
2084
2085 return target_result;
2086 }
2087
2088 /*-------------------------------------------------------------------------
2089 * Flatten out parenthesized sublists in grouping lists, and some cases
2090 * of nested grouping sets.
2091 *
2092 * Inside a grouping set (ROLLUP, CUBE, or GROUPING SETS), we expect the
2093 * content to be nested no more than 2 deep: i.e. ROLLUP((a,b),(c,d)) is
2094 * ok, but ROLLUP((a,(b,c)),d) is flattened to ((a,b,c),d), which we then
2095 * (later) normalize to ((a,b,c),(d)).
2096 *
2097 * CUBE or ROLLUP can be nested inside GROUPING SETS (but not the reverse),
2098 * and we leave that alone if we find it. But if we see GROUPING SETS inside
2099 * GROUPING SETS, we can flatten and normalize as follows:
2100 * GROUPING SETS (a, (b,c), GROUPING SETS ((c,d),(e)), (f,g))
2101 * becomes
2102 * GROUPING SETS ((a), (b,c), (c,d), (e), (f,g))
2103 *
2104 * This is per the spec's syntax transformations, but these are the only such
2105 * transformations we do in parse analysis, so that queries retain the
2106 * originally specified grouping set syntax for CUBE and ROLLUP as much as
2107 * possible when deparsed. (Full expansion of the result into a list of
2108 * grouping sets is left to the planner.)
2109 *
2110 * When we're done, the resulting list should contain only these possible
2111 * elements:
2112 * - an expression
2113 * - a CUBE or ROLLUP with a list of expressions nested 2 deep
2114 * - a GROUPING SET containing any of:
2115 * - expression lists
2116 * - empty grouping sets
2117 * - CUBE or ROLLUP nodes with lists nested 2 deep
2118 * The return is a new list, but doesn't deep-copy the old nodes except for
2119 * GroupingSet nodes.
2120 *
2121 * As a side effect, flag whether the list has any GroupingSet nodes.
2122 *-------------------------------------------------------------------------
2123 */
2124 static Node *
flatten_grouping_sets(Node * expr,bool toplevel,bool * hasGroupingSets)2125 flatten_grouping_sets(Node *expr, bool toplevel, bool *hasGroupingSets)
2126 {
2127 /* just in case of pathological input */
2128 check_stack_depth();
2129
2130 if (expr == (Node *) NIL)
2131 return (Node *) NIL;
2132
2133 switch (expr->type)
2134 {
2135 case T_RowExpr:
2136 {
2137 RowExpr *r = (RowExpr *) expr;
2138
2139 if (r->row_format == COERCE_IMPLICIT_CAST)
2140 return flatten_grouping_sets((Node *) r->args,
2141 false, NULL);
2142 }
2143 break;
2144 case T_GroupingSet:
2145 {
2146 GroupingSet *gset = (GroupingSet *) expr;
2147 ListCell *l2;
2148 List *result_set = NIL;
2149
2150 if (hasGroupingSets)
2151 *hasGroupingSets = true;
2152
2153 /*
2154 * at the top level, we skip over all empty grouping sets; the
2155 * caller can supply the canonical GROUP BY () if nothing is
2156 * left.
2157 */
2158
2159 if (toplevel && gset->kind == GROUPING_SET_EMPTY)
2160 return (Node *) NIL;
2161
2162 foreach(l2, gset->content)
2163 {
2164 Node *n1 = lfirst(l2);
2165 Node *n2 = flatten_grouping_sets(n1, false, NULL);
2166
2167 if (IsA(n1, GroupingSet) &&
2168 ((GroupingSet *) n1)->kind == GROUPING_SET_SETS)
2169 result_set = list_concat(result_set, (List *) n2);
2170 else
2171 result_set = lappend(result_set, n2);
2172 }
2173
2174 /*
2175 * At top level, keep the grouping set node; but if we're in a
2176 * nested grouping set, then we need to concat the flattened
2177 * result into the outer list if it's simply nested.
2178 */
2179
2180 if (toplevel || (gset->kind != GROUPING_SET_SETS))
2181 {
2182 return (Node *) makeGroupingSet(gset->kind, result_set, gset->location);
2183 }
2184 else
2185 return (Node *) result_set;
2186 }
2187 case T_List:
2188 {
2189 List *result = NIL;
2190 ListCell *l;
2191
2192 foreach(l, (List *) expr)
2193 {
2194 Node *n = flatten_grouping_sets(lfirst(l), toplevel, hasGroupingSets);
2195
2196 if (n != (Node *) NIL)
2197 {
2198 if (IsA(n, List))
2199 result = list_concat(result, (List *) n);
2200 else
2201 result = lappend(result, n);
2202 }
2203 }
2204
2205 return (Node *) result;
2206 }
2207 default:
2208 break;
2209 }
2210
2211 return expr;
2212 }
2213
2214 /*
2215 * Transform a single expression within a GROUP BY clause or grouping set.
2216 *
2217 * The expression is added to the targetlist if not already present, and to the
2218 * flatresult list (which will become the groupClause) if not already present
2219 * there. The sortClause is consulted for operator and sort order hints.
2220 *
2221 * Returns the ressortgroupref of the expression.
2222 *
2223 * flatresult reference to flat list of SortGroupClause nodes
2224 * seen_local bitmapset of sortgrouprefs already seen at the local level
2225 * pstate ParseState
2226 * gexpr node to transform
2227 * targetlist reference to TargetEntry list
2228 * sortClause ORDER BY clause (SortGroupClause nodes)
2229 * exprKind expression kind
2230 * useSQL99 SQL99 rather than SQL92 syntax
2231 * toplevel false if within any grouping set
2232 */
2233 static Index
transformGroupClauseExpr(List ** flatresult,Bitmapset * seen_local,ParseState * pstate,Node * gexpr,List ** targetlist,List * sortClause,ParseExprKind exprKind,bool useSQL99,bool toplevel)2234 transformGroupClauseExpr(List **flatresult, Bitmapset *seen_local,
2235 ParseState *pstate, Node *gexpr,
2236 List **targetlist, List *sortClause,
2237 ParseExprKind exprKind, bool useSQL99, bool toplevel)
2238 {
2239 TargetEntry *tle;
2240 bool found = false;
2241
2242 if (useSQL99)
2243 tle = findTargetlistEntrySQL99(pstate, gexpr,
2244 targetlist, exprKind);
2245 else
2246 tle = findTargetlistEntrySQL92(pstate, gexpr,
2247 targetlist, exprKind);
2248
2249 if (tle->ressortgroupref > 0)
2250 {
2251 ListCell *sl;
2252
2253 /*
2254 * Eliminate duplicates (GROUP BY x, x) but only at local level.
2255 * (Duplicates in grouping sets can affect the number of returned
2256 * rows, so can't be dropped indiscriminately.)
2257 *
2258 * Since we don't care about anything except the sortgroupref, we can
2259 * use a bitmapset rather than scanning lists.
2260 */
2261 if (bms_is_member(tle->ressortgroupref, seen_local))
2262 return 0;
2263
2264 /*
2265 * If we're already in the flat clause list, we don't need to consider
2266 * adding ourselves again.
2267 */
2268 found = targetIsInSortList(tle, InvalidOid, *flatresult);
2269 if (found)
2270 return tle->ressortgroupref;
2271
2272 /*
2273 * If the GROUP BY tlist entry also appears in ORDER BY, copy operator
2274 * info from the (first) matching ORDER BY item. This means that if
2275 * you write something like "GROUP BY foo ORDER BY foo USING <<<", the
2276 * GROUP BY operation silently takes on the equality semantics implied
2277 * by the ORDER BY. There are two reasons to do this: it improves the
2278 * odds that we can implement both GROUP BY and ORDER BY with a single
2279 * sort step, and it allows the user to choose the equality semantics
2280 * used by GROUP BY, should she be working with a datatype that has
2281 * more than one equality operator.
2282 *
2283 * If we're in a grouping set, though, we force our requested ordering
2284 * to be NULLS LAST, because if we have any hope of using a sorted agg
2285 * for the job, we're going to be tacking on generated NULL values
2286 * after the corresponding groups. If the user demands nulls first,
2287 * another sort step is going to be inevitable, but that's the
2288 * planner's problem.
2289 */
2290
2291 foreach(sl, sortClause)
2292 {
2293 SortGroupClause *sc = (SortGroupClause *) lfirst(sl);
2294
2295 if (sc->tleSortGroupRef == tle->ressortgroupref)
2296 {
2297 SortGroupClause *grpc = copyObject(sc);
2298
2299 if (!toplevel)
2300 grpc->nulls_first = false;
2301 *flatresult = lappend(*flatresult, grpc);
2302 found = true;
2303 break;
2304 }
2305 }
2306 }
2307
2308 /*
2309 * If no match in ORDER BY, just add it to the result using default
2310 * sort/group semantics.
2311 */
2312 if (!found)
2313 *flatresult = addTargetToGroupList(pstate, tle,
2314 *flatresult, *targetlist,
2315 exprLocation(gexpr));
2316
2317 /*
2318 * _something_ must have assigned us a sortgroupref by now...
2319 */
2320
2321 return tle->ressortgroupref;
2322 }
2323
2324 /*
2325 * Transform a list of expressions within a GROUP BY clause or grouping set.
2326 *
2327 * The list of expressions belongs to a single clause within which duplicates
2328 * can be safely eliminated.
2329 *
2330 * Returns an integer list of ressortgroupref values.
2331 *
2332 * flatresult reference to flat list of SortGroupClause nodes
2333 * pstate ParseState
2334 * list nodes to transform
2335 * targetlist reference to TargetEntry list
2336 * sortClause ORDER BY clause (SortGroupClause nodes)
2337 * exprKind expression kind
2338 * useSQL99 SQL99 rather than SQL92 syntax
2339 * toplevel false if within any grouping set
2340 */
2341 static List *
transformGroupClauseList(List ** flatresult,ParseState * pstate,List * list,List ** targetlist,List * sortClause,ParseExprKind exprKind,bool useSQL99,bool toplevel)2342 transformGroupClauseList(List **flatresult,
2343 ParseState *pstate, List *list,
2344 List **targetlist, List *sortClause,
2345 ParseExprKind exprKind, bool useSQL99, bool toplevel)
2346 {
2347 Bitmapset *seen_local = NULL;
2348 List *result = NIL;
2349 ListCell *gl;
2350
2351 foreach(gl, list)
2352 {
2353 Node *gexpr = (Node *) lfirst(gl);
2354
2355 Index ref = transformGroupClauseExpr(flatresult,
2356 seen_local,
2357 pstate,
2358 gexpr,
2359 targetlist,
2360 sortClause,
2361 exprKind,
2362 useSQL99,
2363 toplevel);
2364
2365 if (ref > 0)
2366 {
2367 seen_local = bms_add_member(seen_local, ref);
2368 result = lappend_int(result, ref);
2369 }
2370 }
2371
2372 return result;
2373 }
2374
2375 /*
2376 * Transform a grouping set and (recursively) its content.
2377 *
2378 * The grouping set might be a GROUPING SETS node with other grouping sets
2379 * inside it, but SETS within SETS have already been flattened out before
2380 * reaching here.
2381 *
2382 * Returns the transformed node, which now contains SIMPLE nodes with lists
2383 * of ressortgrouprefs rather than expressions.
2384 *
2385 * flatresult reference to flat list of SortGroupClause nodes
2386 * pstate ParseState
2387 * gset grouping set to transform
2388 * targetlist reference to TargetEntry list
2389 * sortClause ORDER BY clause (SortGroupClause nodes)
2390 * exprKind expression kind
2391 * useSQL99 SQL99 rather than SQL92 syntax
2392 * toplevel false if within any grouping set
2393 */
2394 static Node *
transformGroupingSet(List ** flatresult,ParseState * pstate,GroupingSet * gset,List ** targetlist,List * sortClause,ParseExprKind exprKind,bool useSQL99,bool toplevel)2395 transformGroupingSet(List **flatresult,
2396 ParseState *pstate, GroupingSet *gset,
2397 List **targetlist, List *sortClause,
2398 ParseExprKind exprKind, bool useSQL99, bool toplevel)
2399 {
2400 ListCell *gl;
2401 List *content = NIL;
2402
2403 Assert(toplevel || gset->kind != GROUPING_SET_SETS);
2404
2405 foreach(gl, gset->content)
2406 {
2407 Node *n = lfirst(gl);
2408
2409 if (IsA(n, List))
2410 {
2411 List *l = transformGroupClauseList(flatresult,
2412 pstate, (List *) n,
2413 targetlist, sortClause,
2414 exprKind, useSQL99, false);
2415
2416 content = lappend(content, makeGroupingSet(GROUPING_SET_SIMPLE,
2417 l,
2418 exprLocation(n)));
2419 }
2420 else if (IsA(n, GroupingSet))
2421 {
2422 GroupingSet *gset2 = (GroupingSet *) lfirst(gl);
2423
2424 content = lappend(content, transformGroupingSet(flatresult,
2425 pstate, gset2,
2426 targetlist, sortClause,
2427 exprKind, useSQL99, false));
2428 }
2429 else
2430 {
2431 Index ref = transformGroupClauseExpr(flatresult,
2432 NULL,
2433 pstate,
2434 n,
2435 targetlist,
2436 sortClause,
2437 exprKind,
2438 useSQL99,
2439 false);
2440
2441 content = lappend(content, makeGroupingSet(GROUPING_SET_SIMPLE,
2442 list_make1_int(ref),
2443 exprLocation(n)));
2444 }
2445 }
2446
2447 /* Arbitrarily cap the size of CUBE, which has exponential growth */
2448 if (gset->kind == GROUPING_SET_CUBE)
2449 {
2450 if (list_length(content) > 12)
2451 ereport(ERROR,
2452 (errcode(ERRCODE_TOO_MANY_COLUMNS),
2453 errmsg("CUBE is limited to 12 elements"),
2454 parser_errposition(pstate, gset->location)));
2455 }
2456
2457 return (Node *) makeGroupingSet(gset->kind, content, gset->location);
2458 }
2459
2460
2461 /*
2462 * transformGroupClause -
2463 * transform a GROUP BY clause
2464 *
2465 * GROUP BY items will be added to the targetlist (as resjunk columns)
2466 * if not already present, so the targetlist must be passed by reference.
2467 *
2468 * This is also used for window PARTITION BY clauses (which act almost the
2469 * same, but are always interpreted per SQL99 rules).
2470 *
2471 * Grouping sets make this a lot more complex than it was. Our goal here is
2472 * twofold: we make a flat list of SortGroupClause nodes referencing each
2473 * distinct expression used for grouping, with those expressions added to the
2474 * targetlist if needed. At the same time, we build the groupingSets tree,
2475 * which stores only ressortgrouprefs as integer lists inside GroupingSet nodes
2476 * (possibly nested, but limited in depth: a GROUPING_SET_SETS node can contain
2477 * nested SIMPLE, CUBE or ROLLUP nodes, but not more sets - we flatten that
2478 * out; while CUBE and ROLLUP can contain only SIMPLE nodes).
2479 *
2480 * We skip much of the hard work if there are no grouping sets.
2481 *
2482 * One subtlety is that the groupClause list can end up empty while the
2483 * groupingSets list is not; this happens if there are only empty grouping
2484 * sets, or an explicit GROUP BY (). This has the same effect as specifying
2485 * aggregates or a HAVING clause with no GROUP BY; the output is one row per
2486 * grouping set even if the input is empty.
2487 *
2488 * Returns the transformed (flat) groupClause.
2489 *
2490 * pstate ParseState
2491 * grouplist clause to transform
2492 * groupingSets reference to list to contain the grouping set tree
2493 * targetlist reference to TargetEntry list
2494 * sortClause ORDER BY clause (SortGroupClause nodes)
2495 * exprKind expression kind
2496 * useSQL99 SQL99 rather than SQL92 syntax
2497 */
2498 List *
transformGroupClause(ParseState * pstate,List * grouplist,List ** groupingSets,List ** targetlist,List * sortClause,ParseExprKind exprKind,bool useSQL99)2499 transformGroupClause(ParseState *pstate, List *grouplist, List **groupingSets,
2500 List **targetlist, List *sortClause,
2501 ParseExprKind exprKind, bool useSQL99)
2502 {
2503 List *result = NIL;
2504 List *flat_grouplist;
2505 List *gsets = NIL;
2506 ListCell *gl;
2507 bool hasGroupingSets = false;
2508 Bitmapset *seen_local = NULL;
2509
2510 /*
2511 * Recursively flatten implicit RowExprs. (Technically this is only needed
2512 * for GROUP BY, per the syntax rules for grouping sets, but we do it
2513 * anyway.)
2514 */
2515 flat_grouplist = (List *) flatten_grouping_sets((Node *) grouplist,
2516 true,
2517 &hasGroupingSets);
2518
2519 /*
2520 * If the list is now empty, but hasGroupingSets is true, it's because we
2521 * elided redundant empty grouping sets. Restore a single empty grouping
2522 * set to leave a canonical form: GROUP BY ()
2523 */
2524
2525 if (flat_grouplist == NIL && hasGroupingSets)
2526 {
2527 flat_grouplist = list_make1(makeGroupingSet(GROUPING_SET_EMPTY,
2528 NIL,
2529 exprLocation((Node *) grouplist)));
2530 }
2531
2532 foreach(gl, flat_grouplist)
2533 {
2534 Node *gexpr = (Node *) lfirst(gl);
2535
2536 if (IsA(gexpr, GroupingSet))
2537 {
2538 GroupingSet *gset = (GroupingSet *) gexpr;
2539
2540 switch (gset->kind)
2541 {
2542 case GROUPING_SET_EMPTY:
2543 gsets = lappend(gsets, gset);
2544 break;
2545 case GROUPING_SET_SIMPLE:
2546 /* can't happen */
2547 Assert(false);
2548 break;
2549 case GROUPING_SET_SETS:
2550 case GROUPING_SET_CUBE:
2551 case GROUPING_SET_ROLLUP:
2552 gsets = lappend(gsets,
2553 transformGroupingSet(&result,
2554 pstate, gset,
2555 targetlist, sortClause,
2556 exprKind, useSQL99, true));
2557 break;
2558 }
2559 }
2560 else
2561 {
2562 Index ref = transformGroupClauseExpr(&result, seen_local,
2563 pstate, gexpr,
2564 targetlist, sortClause,
2565 exprKind, useSQL99, true);
2566
2567 if (ref > 0)
2568 {
2569 seen_local = bms_add_member(seen_local, ref);
2570 if (hasGroupingSets)
2571 gsets = lappend(gsets,
2572 makeGroupingSet(GROUPING_SET_SIMPLE,
2573 list_make1_int(ref),
2574 exprLocation(gexpr)));
2575 }
2576 }
2577 }
2578
2579 /* parser should prevent this */
2580 Assert(gsets == NIL || groupingSets != NULL);
2581
2582 if (groupingSets)
2583 *groupingSets = gsets;
2584
2585 return result;
2586 }
2587
2588 /*
2589 * transformSortClause -
2590 * transform an ORDER BY clause
2591 *
2592 * ORDER BY items will be added to the targetlist (as resjunk columns)
2593 * if not already present, so the targetlist must be passed by reference.
2594 *
2595 * This is also used for window and aggregate ORDER BY clauses (which act
2596 * almost the same, but are always interpreted per SQL99 rules).
2597 */
2598 List *
transformSortClause(ParseState * pstate,List * orderlist,List ** targetlist,ParseExprKind exprKind,bool useSQL99)2599 transformSortClause(ParseState *pstate,
2600 List *orderlist,
2601 List **targetlist,
2602 ParseExprKind exprKind,
2603 bool useSQL99)
2604 {
2605 List *sortlist = NIL;
2606 ListCell *olitem;
2607
2608 foreach(olitem, orderlist)
2609 {
2610 SortBy *sortby = (SortBy *) lfirst(olitem);
2611 TargetEntry *tle;
2612
2613 if (useSQL99)
2614 tle = findTargetlistEntrySQL99(pstate, sortby->node,
2615 targetlist, exprKind);
2616 else
2617 tle = findTargetlistEntrySQL92(pstate, sortby->node,
2618 targetlist, exprKind);
2619
2620 sortlist = addTargetToSortList(pstate, tle,
2621 sortlist, *targetlist, sortby);
2622 }
2623
2624 return sortlist;
2625 }
2626
2627 /*
2628 * transformWindowDefinitions -
2629 * transform window definitions (WindowDef to WindowClause)
2630 */
2631 List *
transformWindowDefinitions(ParseState * pstate,List * windowdefs,List ** targetlist)2632 transformWindowDefinitions(ParseState *pstate,
2633 List *windowdefs,
2634 List **targetlist)
2635 {
2636 List *result = NIL;
2637 Index winref = 0;
2638 ListCell *lc;
2639
2640 foreach(lc, windowdefs)
2641 {
2642 WindowDef *windef = (WindowDef *) lfirst(lc);
2643 WindowClause *refwc = NULL;
2644 List *partitionClause;
2645 List *orderClause;
2646 Oid rangeopfamily = InvalidOid;
2647 Oid rangeopcintype = InvalidOid;
2648 WindowClause *wc;
2649
2650 winref++;
2651
2652 /*
2653 * Check for duplicate window names.
2654 */
2655 if (windef->name &&
2656 findWindowClause(result, windef->name) != NULL)
2657 ereport(ERROR,
2658 (errcode(ERRCODE_WINDOWING_ERROR),
2659 errmsg("window \"%s\" is already defined", windef->name),
2660 parser_errposition(pstate, windef->location)));
2661
2662 /*
2663 * If it references a previous window, look that up.
2664 */
2665 if (windef->refname)
2666 {
2667 refwc = findWindowClause(result, windef->refname);
2668 if (refwc == NULL)
2669 ereport(ERROR,
2670 (errcode(ERRCODE_UNDEFINED_OBJECT),
2671 errmsg("window \"%s\" does not exist",
2672 windef->refname),
2673 parser_errposition(pstate, windef->location)));
2674 }
2675
2676 /*
2677 * Transform PARTITION and ORDER specs, if any. These are treated
2678 * almost exactly like top-level GROUP BY and ORDER BY clauses,
2679 * including the special handling of nondefault operator semantics.
2680 */
2681 orderClause = transformSortClause(pstate,
2682 windef->orderClause,
2683 targetlist,
2684 EXPR_KIND_WINDOW_ORDER,
2685 true /* force SQL99 rules */ );
2686 partitionClause = transformGroupClause(pstate,
2687 windef->partitionClause,
2688 NULL,
2689 targetlist,
2690 orderClause,
2691 EXPR_KIND_WINDOW_PARTITION,
2692 true /* force SQL99 rules */ );
2693
2694 /*
2695 * And prepare the new WindowClause.
2696 */
2697 wc = makeNode(WindowClause);
2698 wc->name = windef->name;
2699 wc->refname = windef->refname;
2700
2701 /*
2702 * Per spec, a windowdef that references a previous one copies the
2703 * previous partition clause (and mustn't specify its own). It can
2704 * specify its own ordering clause, but only if the previous one had
2705 * none. It always specifies its own frame clause, and the previous
2706 * one must not have a frame clause. Yeah, it's bizarre that each of
2707 * these cases works differently, but SQL:2008 says so; see 7.11
2708 * <window clause> syntax rule 10 and general rule 1. The frame
2709 * clause rule is especially bizarre because it makes "OVER foo"
2710 * different from "OVER (foo)", and requires the latter to throw an
2711 * error if foo has a nondefault frame clause. Well, ours not to
2712 * reason why, but we do go out of our way to throw a useful error
2713 * message for such cases.
2714 */
2715 if (refwc)
2716 {
2717 if (partitionClause)
2718 ereport(ERROR,
2719 (errcode(ERRCODE_WINDOWING_ERROR),
2720 errmsg("cannot override PARTITION BY clause of window \"%s\"",
2721 windef->refname),
2722 parser_errposition(pstate, windef->location)));
2723 wc->partitionClause = copyObject(refwc->partitionClause);
2724 }
2725 else
2726 wc->partitionClause = partitionClause;
2727 if (refwc)
2728 {
2729 if (orderClause && refwc->orderClause)
2730 ereport(ERROR,
2731 (errcode(ERRCODE_WINDOWING_ERROR),
2732 errmsg("cannot override ORDER BY clause of window \"%s\"",
2733 windef->refname),
2734 parser_errposition(pstate, windef->location)));
2735 if (orderClause)
2736 {
2737 wc->orderClause = orderClause;
2738 wc->copiedOrder = false;
2739 }
2740 else
2741 {
2742 wc->orderClause = copyObject(refwc->orderClause);
2743 wc->copiedOrder = true;
2744 }
2745 }
2746 else
2747 {
2748 wc->orderClause = orderClause;
2749 wc->copiedOrder = false;
2750 }
2751 if (refwc && refwc->frameOptions != FRAMEOPTION_DEFAULTS)
2752 {
2753 /*
2754 * Use this message if this is a WINDOW clause, or if it's an OVER
2755 * clause that includes ORDER BY or framing clauses. (We already
2756 * rejected PARTITION BY above, so no need to check that.)
2757 */
2758 if (windef->name ||
2759 orderClause || windef->frameOptions != FRAMEOPTION_DEFAULTS)
2760 ereport(ERROR,
2761 (errcode(ERRCODE_WINDOWING_ERROR),
2762 errmsg("cannot copy window \"%s\" because it has a frame clause",
2763 windef->refname),
2764 parser_errposition(pstate, windef->location)));
2765 /* Else this clause is just OVER (foo), so say this: */
2766 ereport(ERROR,
2767 (errcode(ERRCODE_WINDOWING_ERROR),
2768 errmsg("cannot copy window \"%s\" because it has a frame clause",
2769 windef->refname),
2770 errhint("Omit the parentheses in this OVER clause."),
2771 parser_errposition(pstate, windef->location)));
2772 }
2773 wc->frameOptions = windef->frameOptions;
2774
2775 /*
2776 * RANGE offset PRECEDING/FOLLOWING requires exactly one ORDER BY
2777 * column; check that and get its sort opfamily info.
2778 */
2779 if ((wc->frameOptions & FRAMEOPTION_RANGE) &&
2780 (wc->frameOptions & (FRAMEOPTION_START_OFFSET |
2781 FRAMEOPTION_END_OFFSET)))
2782 {
2783 SortGroupClause *sortcl;
2784 Node *sortkey;
2785 int16 rangestrategy;
2786
2787 if (list_length(wc->orderClause) != 1)
2788 ereport(ERROR,
2789 (errcode(ERRCODE_WINDOWING_ERROR),
2790 errmsg("RANGE with offset PRECEDING/FOLLOWING requires exactly one ORDER BY column"),
2791 parser_errposition(pstate, windef->location)));
2792 sortcl = castNode(SortGroupClause, linitial(wc->orderClause));
2793 sortkey = get_sortgroupclause_expr(sortcl, *targetlist);
2794 /* Find the sort operator in pg_amop */
2795 if (!get_ordering_op_properties(sortcl->sortop,
2796 &rangeopfamily,
2797 &rangeopcintype,
2798 &rangestrategy))
2799 elog(ERROR, "operator %u is not a valid ordering operator",
2800 sortcl->sortop);
2801 /* Record properties of sort ordering */
2802 wc->inRangeColl = exprCollation(sortkey);
2803 wc->inRangeAsc = (rangestrategy == BTLessStrategyNumber);
2804 wc->inRangeNullsFirst = sortcl->nulls_first;
2805 }
2806
2807 /* Per spec, GROUPS mode requires an ORDER BY clause */
2808 if (wc->frameOptions & FRAMEOPTION_GROUPS)
2809 {
2810 if (wc->orderClause == NIL)
2811 ereport(ERROR,
2812 (errcode(ERRCODE_WINDOWING_ERROR),
2813 errmsg("GROUPS mode requires an ORDER BY clause"),
2814 parser_errposition(pstate, windef->location)));
2815 }
2816
2817 /* Process frame offset expressions */
2818 wc->startOffset = transformFrameOffset(pstate, wc->frameOptions,
2819 rangeopfamily, rangeopcintype,
2820 &wc->startInRangeFunc,
2821 windef->startOffset);
2822 wc->endOffset = transformFrameOffset(pstate, wc->frameOptions,
2823 rangeopfamily, rangeopcintype,
2824 &wc->endInRangeFunc,
2825 windef->endOffset);
2826 wc->winref = winref;
2827
2828 result = lappend(result, wc);
2829 }
2830
2831 return result;
2832 }
2833
2834 /*
2835 * transformDistinctClause -
2836 * transform a DISTINCT clause
2837 *
2838 * Since we may need to add items to the query's targetlist, that list
2839 * is passed by reference.
2840 *
2841 * As with GROUP BY, we absorb the sorting semantics of ORDER BY as much as
2842 * possible into the distinctClause. This avoids a possible need to re-sort,
2843 * and allows the user to choose the equality semantics used by DISTINCT,
2844 * should she be working with a datatype that has more than one equality
2845 * operator.
2846 *
2847 * is_agg is true if we are transforming an aggregate(DISTINCT ...)
2848 * function call. This does not affect any behavior, only the phrasing
2849 * of error messages.
2850 */
2851 List *
transformDistinctClause(ParseState * pstate,List ** targetlist,List * sortClause,bool is_agg)2852 transformDistinctClause(ParseState *pstate,
2853 List **targetlist, List *sortClause, bool is_agg)
2854 {
2855 List *result = NIL;
2856 ListCell *slitem;
2857 ListCell *tlitem;
2858
2859 /*
2860 * The distinctClause should consist of all ORDER BY items followed by all
2861 * other non-resjunk targetlist items. There must not be any resjunk
2862 * ORDER BY items --- that would imply that we are sorting by a value that
2863 * isn't necessarily unique within a DISTINCT group, so the results
2864 * wouldn't be well-defined. This construction ensures we follow the rule
2865 * that sortClause and distinctClause match; in fact the sortClause will
2866 * always be a prefix of distinctClause.
2867 *
2868 * Note a corner case: the same TLE could be in the ORDER BY list multiple
2869 * times with different sortops. We have to include it in the
2870 * distinctClause the same way to preserve the prefix property. The net
2871 * effect will be that the TLE value will be made unique according to both
2872 * sortops.
2873 */
2874 foreach(slitem, sortClause)
2875 {
2876 SortGroupClause *scl = (SortGroupClause *) lfirst(slitem);
2877 TargetEntry *tle = get_sortgroupclause_tle(scl, *targetlist);
2878
2879 if (tle->resjunk)
2880 ereport(ERROR,
2881 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
2882 is_agg ?
2883 errmsg("in an aggregate with DISTINCT, ORDER BY expressions must appear in argument list") :
2884 errmsg("for SELECT DISTINCT, ORDER BY expressions must appear in select list"),
2885 parser_errposition(pstate,
2886 exprLocation((Node *) tle->expr))));
2887 result = lappend(result, copyObject(scl));
2888 }
2889
2890 /*
2891 * Now add any remaining non-resjunk tlist items, using default sort/group
2892 * semantics for their data types.
2893 */
2894 foreach(tlitem, *targetlist)
2895 {
2896 TargetEntry *tle = (TargetEntry *) lfirst(tlitem);
2897
2898 if (tle->resjunk)
2899 continue; /* ignore junk */
2900 result = addTargetToGroupList(pstate, tle,
2901 result, *targetlist,
2902 exprLocation((Node *) tle->expr));
2903 }
2904
2905 /*
2906 * Complain if we found nothing to make DISTINCT. Returning an empty list
2907 * would cause the parsed Query to look like it didn't have DISTINCT, with
2908 * results that would probably surprise the user. Note: this case is
2909 * presently impossible for aggregates because of grammar restrictions,
2910 * but we check anyway.
2911 */
2912 if (result == NIL)
2913 ereport(ERROR,
2914 (errcode(ERRCODE_SYNTAX_ERROR),
2915 is_agg ?
2916 errmsg("an aggregate with DISTINCT must have at least one argument") :
2917 errmsg("SELECT DISTINCT must have at least one column")));
2918
2919 return result;
2920 }
2921
2922 /*
2923 * transformDistinctOnClause -
2924 * transform a DISTINCT ON clause
2925 *
2926 * Since we may need to add items to the query's targetlist, that list
2927 * is passed by reference.
2928 *
2929 * As with GROUP BY, we absorb the sorting semantics of ORDER BY as much as
2930 * possible into the distinctClause. This avoids a possible need to re-sort,
2931 * and allows the user to choose the equality semantics used by DISTINCT,
2932 * should she be working with a datatype that has more than one equality
2933 * operator.
2934 */
2935 List *
transformDistinctOnClause(ParseState * pstate,List * distinctlist,List ** targetlist,List * sortClause)2936 transformDistinctOnClause(ParseState *pstate, List *distinctlist,
2937 List **targetlist, List *sortClause)
2938 {
2939 List *result = NIL;
2940 List *sortgrouprefs = NIL;
2941 bool skipped_sortitem;
2942 ListCell *lc;
2943 ListCell *lc2;
2944
2945 /*
2946 * Add all the DISTINCT ON expressions to the tlist (if not already
2947 * present, they are added as resjunk items). Assign sortgroupref numbers
2948 * to them, and make a list of these numbers. (NB: we rely below on the
2949 * sortgrouprefs list being one-for-one with the original distinctlist.
2950 * Also notice that we could have duplicate DISTINCT ON expressions and
2951 * hence duplicate entries in sortgrouprefs.)
2952 */
2953 foreach(lc, distinctlist)
2954 {
2955 Node *dexpr = (Node *) lfirst(lc);
2956 int sortgroupref;
2957 TargetEntry *tle;
2958
2959 tle = findTargetlistEntrySQL92(pstate, dexpr, targetlist,
2960 EXPR_KIND_DISTINCT_ON);
2961 sortgroupref = assignSortGroupRef(tle, *targetlist);
2962 sortgrouprefs = lappend_int(sortgrouprefs, sortgroupref);
2963 }
2964
2965 /*
2966 * If the user writes both DISTINCT ON and ORDER BY, adopt the sorting
2967 * semantics from ORDER BY items that match DISTINCT ON items, and also
2968 * adopt their column sort order. We insist that the distinctClause and
2969 * sortClause match, so throw error if we find the need to add any more
2970 * distinctClause items after we've skipped an ORDER BY item that wasn't
2971 * in DISTINCT ON.
2972 */
2973 skipped_sortitem = false;
2974 foreach(lc, sortClause)
2975 {
2976 SortGroupClause *scl = (SortGroupClause *) lfirst(lc);
2977
2978 if (list_member_int(sortgrouprefs, scl->tleSortGroupRef))
2979 {
2980 if (skipped_sortitem)
2981 ereport(ERROR,
2982 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
2983 errmsg("SELECT DISTINCT ON expressions must match initial ORDER BY expressions"),
2984 parser_errposition(pstate,
2985 get_matching_location(scl->tleSortGroupRef,
2986 sortgrouprefs,
2987 distinctlist))));
2988 else
2989 result = lappend(result, copyObject(scl));
2990 }
2991 else
2992 skipped_sortitem = true;
2993 }
2994
2995 /*
2996 * Now add any remaining DISTINCT ON items, using default sort/group
2997 * semantics for their data types. (Note: this is pretty questionable; if
2998 * the ORDER BY list doesn't include all the DISTINCT ON items and more
2999 * besides, you certainly aren't using DISTINCT ON in the intended way,
3000 * and you probably aren't going to get consistent results. It might be
3001 * better to throw an error or warning here. But historically we've
3002 * allowed it, so keep doing so.)
3003 */
3004 forboth(lc, distinctlist, lc2, sortgrouprefs)
3005 {
3006 Node *dexpr = (Node *) lfirst(lc);
3007 int sortgroupref = lfirst_int(lc2);
3008 TargetEntry *tle = get_sortgroupref_tle(sortgroupref, *targetlist);
3009
3010 if (targetIsInSortList(tle, InvalidOid, result))
3011 continue; /* already in list (with some semantics) */
3012 if (skipped_sortitem)
3013 ereport(ERROR,
3014 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
3015 errmsg("SELECT DISTINCT ON expressions must match initial ORDER BY expressions"),
3016 parser_errposition(pstate, exprLocation(dexpr))));
3017 result = addTargetToGroupList(pstate, tle,
3018 result, *targetlist,
3019 exprLocation(dexpr));
3020 }
3021
3022 /*
3023 * An empty result list is impossible here because of grammar
3024 * restrictions.
3025 */
3026 Assert(result != NIL);
3027
3028 return result;
3029 }
3030
3031 /*
3032 * get_matching_location
3033 * Get the exprLocation of the exprs member corresponding to the
3034 * (first) member of sortgrouprefs that equals sortgroupref.
3035 *
3036 * This is used so that we can point at a troublesome DISTINCT ON entry.
3037 * (Note that we need to use the original untransformed DISTINCT ON list
3038 * item, as whatever TLE it corresponds to will very possibly have a
3039 * parse location pointing to some matching entry in the SELECT list
3040 * or ORDER BY list.)
3041 */
3042 static int
get_matching_location(int sortgroupref,List * sortgrouprefs,List * exprs)3043 get_matching_location(int sortgroupref, List *sortgrouprefs, List *exprs)
3044 {
3045 ListCell *lcs;
3046 ListCell *lce;
3047
3048 forboth(lcs, sortgrouprefs, lce, exprs)
3049 {
3050 if (lfirst_int(lcs) == sortgroupref)
3051 return exprLocation((Node *) lfirst(lce));
3052 }
3053 /* if no match, caller blew it */
3054 elog(ERROR, "get_matching_location: no matching sortgroupref");
3055 return -1; /* keep compiler quiet */
3056 }
3057
3058 /*
3059 * resolve_unique_index_expr
3060 * Infer a unique index from a list of indexElems, for ON
3061 * CONFLICT clause
3062 *
3063 * Perform parse analysis of expressions and columns appearing within ON
3064 * CONFLICT clause. During planning, the returned list of expressions is used
3065 * to infer which unique index to use.
3066 */
3067 static List *
resolve_unique_index_expr(ParseState * pstate,InferClause * infer,Relation heapRel)3068 resolve_unique_index_expr(ParseState *pstate, InferClause *infer,
3069 Relation heapRel)
3070 {
3071 List *result = NIL;
3072 ListCell *l;
3073
3074 foreach(l, infer->indexElems)
3075 {
3076 IndexElem *ielem = (IndexElem *) lfirst(l);
3077 InferenceElem *pInfer = makeNode(InferenceElem);
3078 Node *parse;
3079
3080 /*
3081 * Raw grammar re-uses CREATE INDEX infrastructure for unique index
3082 * inference clause, and so will accept opclasses by name and so on.
3083 *
3084 * Make no attempt to match ASC or DESC ordering or NULLS FIRST/NULLS
3085 * LAST ordering, since those are not significant for inference
3086 * purposes (any unique index matching the inference specification in
3087 * other regards is accepted indifferently). Actively reject this as
3088 * wrong-headed.
3089 */
3090 if (ielem->ordering != SORTBY_DEFAULT)
3091 ereport(ERROR,
3092 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
3093 errmsg("ASC/DESC is not allowed in ON CONFLICT clause"),
3094 parser_errposition(pstate,
3095 exprLocation((Node *) infer))));
3096 if (ielem->nulls_ordering != SORTBY_NULLS_DEFAULT)
3097 ereport(ERROR,
3098 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
3099 errmsg("NULLS FIRST/LAST is not allowed in ON CONFLICT clause"),
3100 parser_errposition(pstate,
3101 exprLocation((Node *) infer))));
3102
3103 if (!ielem->expr)
3104 {
3105 /* Simple index attribute */
3106 ColumnRef *n;
3107
3108 /*
3109 * Grammar won't have built raw expression for us in event of
3110 * plain column reference. Create one directly, and perform
3111 * expression transformation. Planner expects this, and performs
3112 * its own normalization for the purposes of matching against
3113 * pg_index.
3114 */
3115 n = makeNode(ColumnRef);
3116 n->fields = list_make1(makeString(ielem->name));
3117 /* Location is approximately that of inference specification */
3118 n->location = infer->location;
3119 parse = (Node *) n;
3120 }
3121 else
3122 {
3123 /* Do parse transformation of the raw expression */
3124 parse = (Node *) ielem->expr;
3125 }
3126
3127 /*
3128 * transformExpr() will reject subqueries, aggregates, window
3129 * functions, and SRFs, based on being passed
3130 * EXPR_KIND_INDEX_EXPRESSION. So we needn't worry about those
3131 * further ... not that they would match any available index
3132 * expression anyway.
3133 */
3134 pInfer->expr = transformExpr(pstate, parse, EXPR_KIND_INDEX_EXPRESSION);
3135
3136 /* Perform lookup of collation and operator class as required */
3137 if (!ielem->collation)
3138 pInfer->infercollid = InvalidOid;
3139 else
3140 pInfer->infercollid = LookupCollation(pstate, ielem->collation,
3141 exprLocation(pInfer->expr));
3142
3143 if (!ielem->opclass)
3144 pInfer->inferopclass = InvalidOid;
3145 else
3146 pInfer->inferopclass = get_opclass_oid(BTREE_AM_OID,
3147 ielem->opclass, false);
3148
3149 result = lappend(result, pInfer);
3150 }
3151
3152 return result;
3153 }
3154
3155 /*
3156 * transformOnConflictArbiter -
3157 * transform arbiter expressions in an ON CONFLICT clause.
3158 *
3159 * Transformed expressions used to infer one unique index relation to serve as
3160 * an ON CONFLICT arbiter. Partial unique indexes may be inferred using WHERE
3161 * clause from inference specification clause.
3162 */
3163 void
transformOnConflictArbiter(ParseState * pstate,OnConflictClause * onConflictClause,List ** arbiterExpr,Node ** arbiterWhere,Oid * constraint)3164 transformOnConflictArbiter(ParseState *pstate,
3165 OnConflictClause *onConflictClause,
3166 List **arbiterExpr, Node **arbiterWhere,
3167 Oid *constraint)
3168 {
3169 InferClause *infer = onConflictClause->infer;
3170
3171 *arbiterExpr = NIL;
3172 *arbiterWhere = NULL;
3173 *constraint = InvalidOid;
3174
3175 if (onConflictClause->action == ONCONFLICT_UPDATE && !infer)
3176 ereport(ERROR,
3177 (errcode(ERRCODE_SYNTAX_ERROR),
3178 errmsg("ON CONFLICT DO UPDATE requires inference specification or constraint name"),
3179 errhint("For example, ON CONFLICT (column_name)."),
3180 parser_errposition(pstate,
3181 exprLocation((Node *) onConflictClause))));
3182
3183 /*
3184 * To simplify certain aspects of its design, speculative insertion into
3185 * system catalogs is disallowed
3186 */
3187 if (IsCatalogRelation(pstate->p_target_relation))
3188 ereport(ERROR,
3189 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3190 errmsg("ON CONFLICT is not supported with system catalog tables"),
3191 parser_errposition(pstate,
3192 exprLocation((Node *) onConflictClause))));
3193
3194 /* Same applies to table used by logical decoding as catalog table */
3195 if (RelationIsUsedAsCatalogTable(pstate->p_target_relation))
3196 ereport(ERROR,
3197 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3198 errmsg("ON CONFLICT is not supported on table \"%s\" used as a catalog table",
3199 RelationGetRelationName(pstate->p_target_relation)),
3200 parser_errposition(pstate,
3201 exprLocation((Node *) onConflictClause))));
3202
3203 /* ON CONFLICT DO NOTHING does not require an inference clause */
3204 if (infer)
3205 {
3206 List *save_namespace;
3207
3208 /*
3209 * While we process the arbiter expressions, accept only non-qualified
3210 * references to the target table. Hide any other relations.
3211 */
3212 save_namespace = pstate->p_namespace;
3213 pstate->p_namespace = NIL;
3214 addNSItemToQuery(pstate, pstate->p_target_nsitem,
3215 false, false, true);
3216
3217 if (infer->indexElems)
3218 *arbiterExpr = resolve_unique_index_expr(pstate, infer,
3219 pstate->p_target_relation);
3220
3221 /*
3222 * Handling inference WHERE clause (for partial unique index
3223 * inference)
3224 */
3225 if (infer->whereClause)
3226 *arbiterWhere = transformExpr(pstate, infer->whereClause,
3227 EXPR_KIND_INDEX_PREDICATE);
3228
3229 pstate->p_namespace = save_namespace;
3230
3231 /*
3232 * If the arbiter is specified by constraint name, get the constraint
3233 * OID and mark the constrained columns as requiring SELECT privilege,
3234 * in the same way as would have happened if the arbiter had been
3235 * specified by explicit reference to the constraint's index columns.
3236 */
3237 if (infer->conname)
3238 {
3239 Oid relid = RelationGetRelid(pstate->p_target_relation);
3240 RangeTblEntry *rte = pstate->p_target_nsitem->p_rte;
3241 Bitmapset *conattnos;
3242
3243 conattnos = get_relation_constraint_attnos(relid, infer->conname,
3244 false, constraint);
3245
3246 /* Make sure the rel as a whole is marked for SELECT access */
3247 rte->requiredPerms |= ACL_SELECT;
3248 /* Mark the constrained columns as requiring SELECT access */
3249 rte->selectedCols = bms_add_members(rte->selectedCols, conattnos);
3250 }
3251 }
3252
3253 /*
3254 * It's convenient to form a list of expressions based on the
3255 * representation used by CREATE INDEX, since the same restrictions are
3256 * appropriate (e.g. on subqueries). However, from here on, a dedicated
3257 * primnode representation is used for inference elements, and so
3258 * assign_query_collations() can be trusted to do the right thing with the
3259 * post parse analysis query tree inference clause representation.
3260 */
3261 }
3262
3263 /*
3264 * addTargetToSortList
3265 * If the given targetlist entry isn't already in the SortGroupClause
3266 * list, add it to the end of the list, using the given sort ordering
3267 * info.
3268 *
3269 * Returns the updated SortGroupClause list.
3270 */
3271 List *
addTargetToSortList(ParseState * pstate,TargetEntry * tle,List * sortlist,List * targetlist,SortBy * sortby)3272 addTargetToSortList(ParseState *pstate, TargetEntry *tle,
3273 List *sortlist, List *targetlist, SortBy *sortby)
3274 {
3275 Oid restype = exprType((Node *) tle->expr);
3276 Oid sortop;
3277 Oid eqop;
3278 bool hashable;
3279 bool reverse;
3280 int location;
3281 ParseCallbackState pcbstate;
3282
3283 /* if tlist item is an UNKNOWN literal, change it to TEXT */
3284 if (restype == UNKNOWNOID)
3285 {
3286 tle->expr = (Expr *) coerce_type(pstate, (Node *) tle->expr,
3287 restype, TEXTOID, -1,
3288 COERCION_IMPLICIT,
3289 COERCE_IMPLICIT_CAST,
3290 -1);
3291 restype = TEXTOID;
3292 }
3293
3294 /*
3295 * Rather than clutter the API of get_sort_group_operators and the other
3296 * functions we're about to use, make use of error context callback to
3297 * mark any error reports with a parse position. We point to the operator
3298 * location if present, else to the expression being sorted. (NB: use the
3299 * original untransformed expression here; the TLE entry might well point
3300 * at a duplicate expression in the regular SELECT list.)
3301 */
3302 location = sortby->location;
3303 if (location < 0)
3304 location = exprLocation(sortby->node);
3305 setup_parser_errposition_callback(&pcbstate, pstate, location);
3306
3307 /* determine the sortop, eqop, and directionality */
3308 switch (sortby->sortby_dir)
3309 {
3310 case SORTBY_DEFAULT:
3311 case SORTBY_ASC:
3312 get_sort_group_operators(restype,
3313 true, true, false,
3314 &sortop, &eqop, NULL,
3315 &hashable);
3316 reverse = false;
3317 break;
3318 case SORTBY_DESC:
3319 get_sort_group_operators(restype,
3320 false, true, true,
3321 NULL, &eqop, &sortop,
3322 &hashable);
3323 reverse = true;
3324 break;
3325 case SORTBY_USING:
3326 Assert(sortby->useOp != NIL);
3327 sortop = compatible_oper_opid(sortby->useOp,
3328 restype,
3329 restype,
3330 false);
3331
3332 /*
3333 * Verify it's a valid ordering operator, fetch the corresponding
3334 * equality operator, and determine whether to consider it like
3335 * ASC or DESC.
3336 */
3337 eqop = get_equality_op_for_ordering_op(sortop, &reverse);
3338 if (!OidIsValid(eqop))
3339 ereport(ERROR,
3340 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3341 errmsg("operator %s is not a valid ordering operator",
3342 strVal(llast(sortby->useOp))),
3343 errhint("Ordering operators must be \"<\" or \">\" members of btree operator families.")));
3344
3345 /*
3346 * Also see if the equality operator is hashable.
3347 */
3348 hashable = op_hashjoinable(eqop, restype);
3349 break;
3350 default:
3351 elog(ERROR, "unrecognized sortby_dir: %d", sortby->sortby_dir);
3352 sortop = InvalidOid; /* keep compiler quiet */
3353 eqop = InvalidOid;
3354 hashable = false;
3355 reverse = false;
3356 break;
3357 }
3358
3359 cancel_parser_errposition_callback(&pcbstate);
3360
3361 /* avoid making duplicate sortlist entries */
3362 if (!targetIsInSortList(tle, sortop, sortlist))
3363 {
3364 SortGroupClause *sortcl = makeNode(SortGroupClause);
3365
3366 sortcl->tleSortGroupRef = assignSortGroupRef(tle, targetlist);
3367
3368 sortcl->eqop = eqop;
3369 sortcl->sortop = sortop;
3370 sortcl->hashable = hashable;
3371
3372 switch (sortby->sortby_nulls)
3373 {
3374 case SORTBY_NULLS_DEFAULT:
3375 /* NULLS FIRST is default for DESC; other way for ASC */
3376 sortcl->nulls_first = reverse;
3377 break;
3378 case SORTBY_NULLS_FIRST:
3379 sortcl->nulls_first = true;
3380 break;
3381 case SORTBY_NULLS_LAST:
3382 sortcl->nulls_first = false;
3383 break;
3384 default:
3385 elog(ERROR, "unrecognized sortby_nulls: %d",
3386 sortby->sortby_nulls);
3387 break;
3388 }
3389
3390 sortlist = lappend(sortlist, sortcl);
3391 }
3392
3393 return sortlist;
3394 }
3395
3396 /*
3397 * addTargetToGroupList
3398 * If the given targetlist entry isn't already in the SortGroupClause
3399 * list, add it to the end of the list, using default sort/group
3400 * semantics.
3401 *
3402 * This is very similar to addTargetToSortList, except that we allow the
3403 * case where only a grouping (equality) operator can be found, and that
3404 * the TLE is considered "already in the list" if it appears there with any
3405 * sorting semantics.
3406 *
3407 * location is the parse location to be fingered in event of trouble. Note
3408 * that we can't rely on exprLocation(tle->expr), because that might point
3409 * to a SELECT item that matches the GROUP BY item; it'd be pretty confusing
3410 * to report such a location.
3411 *
3412 * Returns the updated SortGroupClause list.
3413 */
3414 static List *
addTargetToGroupList(ParseState * pstate,TargetEntry * tle,List * grouplist,List * targetlist,int location)3415 addTargetToGroupList(ParseState *pstate, TargetEntry *tle,
3416 List *grouplist, List *targetlist, int location)
3417 {
3418 Oid restype = exprType((Node *) tle->expr);
3419
3420 /* if tlist item is an UNKNOWN literal, change it to TEXT */
3421 if (restype == UNKNOWNOID)
3422 {
3423 tle->expr = (Expr *) coerce_type(pstate, (Node *) tle->expr,
3424 restype, TEXTOID, -1,
3425 COERCION_IMPLICIT,
3426 COERCE_IMPLICIT_CAST,
3427 -1);
3428 restype = TEXTOID;
3429 }
3430
3431 /* avoid making duplicate grouplist entries */
3432 if (!targetIsInSortList(tle, InvalidOid, grouplist))
3433 {
3434 SortGroupClause *grpcl = makeNode(SortGroupClause);
3435 Oid sortop;
3436 Oid eqop;
3437 bool hashable;
3438 ParseCallbackState pcbstate;
3439
3440 setup_parser_errposition_callback(&pcbstate, pstate, location);
3441
3442 /* determine the eqop and optional sortop */
3443 get_sort_group_operators(restype,
3444 false, true, false,
3445 &sortop, &eqop, NULL,
3446 &hashable);
3447
3448 cancel_parser_errposition_callback(&pcbstate);
3449
3450 grpcl->tleSortGroupRef = assignSortGroupRef(tle, targetlist);
3451 grpcl->eqop = eqop;
3452 grpcl->sortop = sortop;
3453 grpcl->nulls_first = false; /* OK with or without sortop */
3454 grpcl->hashable = hashable;
3455
3456 grouplist = lappend(grouplist, grpcl);
3457 }
3458
3459 return grouplist;
3460 }
3461
3462 /*
3463 * assignSortGroupRef
3464 * Assign the targetentry an unused ressortgroupref, if it doesn't
3465 * already have one. Return the assigned or pre-existing refnumber.
3466 *
3467 * 'tlist' is the targetlist containing (or to contain) the given targetentry.
3468 */
3469 Index
assignSortGroupRef(TargetEntry * tle,List * tlist)3470 assignSortGroupRef(TargetEntry *tle, List *tlist)
3471 {
3472 Index maxRef;
3473 ListCell *l;
3474
3475 if (tle->ressortgroupref) /* already has one? */
3476 return tle->ressortgroupref;
3477
3478 /* easiest way to pick an unused refnumber: max used + 1 */
3479 maxRef = 0;
3480 foreach(l, tlist)
3481 {
3482 Index ref = ((TargetEntry *) lfirst(l))->ressortgroupref;
3483
3484 if (ref > maxRef)
3485 maxRef = ref;
3486 }
3487 tle->ressortgroupref = maxRef + 1;
3488 return tle->ressortgroupref;
3489 }
3490
3491 /*
3492 * targetIsInSortList
3493 * Is the given target item already in the sortlist?
3494 * If sortop is not InvalidOid, also test for a match to the sortop.
3495 *
3496 * It is not an oversight that this function ignores the nulls_first flag.
3497 * We check sortop when determining if an ORDER BY item is redundant with
3498 * earlier ORDER BY items, because it's conceivable that "ORDER BY
3499 * foo USING <, foo USING <<<" is not redundant, if <<< distinguishes
3500 * values that < considers equal. We need not check nulls_first
3501 * however, because a lower-order column with the same sortop but
3502 * opposite nulls direction is redundant. Also, we can consider
3503 * ORDER BY foo ASC, foo DESC redundant, so check for a commutator match.
3504 *
3505 * Works for both ordering and grouping lists (sortop would normally be
3506 * InvalidOid when considering grouping). Note that the main reason we need
3507 * this routine (and not just a quick test for nonzeroness of ressortgroupref)
3508 * is that a TLE might be in only one of the lists.
3509 */
3510 bool
targetIsInSortList(TargetEntry * tle,Oid sortop,List * sortList)3511 targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList)
3512 {
3513 Index ref = tle->ressortgroupref;
3514 ListCell *l;
3515
3516 /* no need to scan list if tle has no marker */
3517 if (ref == 0)
3518 return false;
3519
3520 foreach(l, sortList)
3521 {
3522 SortGroupClause *scl = (SortGroupClause *) lfirst(l);
3523
3524 if (scl->tleSortGroupRef == ref &&
3525 (sortop == InvalidOid ||
3526 sortop == scl->sortop ||
3527 sortop == get_commutator(scl->sortop)))
3528 return true;
3529 }
3530 return false;
3531 }
3532
3533 /*
3534 * findWindowClause
3535 * Find the named WindowClause in the list, or return NULL if not there
3536 */
3537 static WindowClause *
findWindowClause(List * wclist,const char * name)3538 findWindowClause(List *wclist, const char *name)
3539 {
3540 ListCell *l;
3541
3542 foreach(l, wclist)
3543 {
3544 WindowClause *wc = (WindowClause *) lfirst(l);
3545
3546 if (wc->name && strcmp(wc->name, name) == 0)
3547 return wc;
3548 }
3549
3550 return NULL;
3551 }
3552
3553 /*
3554 * transformFrameOffset
3555 * Process a window frame offset expression
3556 *
3557 * In RANGE mode, rangeopfamily is the sort opfamily for the input ORDER BY
3558 * column, and rangeopcintype is the input data type the sort operator is
3559 * registered with. We expect the in_range function to be registered with
3560 * that same type. (In binary-compatible cases, it might be different from
3561 * the input column's actual type, so we can't use that for the lookups.)
3562 * We'll return the OID of the in_range function to *inRangeFunc.
3563 */
3564 static Node *
transformFrameOffset(ParseState * pstate,int frameOptions,Oid rangeopfamily,Oid rangeopcintype,Oid * inRangeFunc,Node * clause)3565 transformFrameOffset(ParseState *pstate, int frameOptions,
3566 Oid rangeopfamily, Oid rangeopcintype, Oid *inRangeFunc,
3567 Node *clause)
3568 {
3569 const char *constructName = NULL;
3570 Node *node;
3571
3572 *inRangeFunc = InvalidOid; /* default result */
3573
3574 /* Quick exit if no offset expression */
3575 if (clause == NULL)
3576 return NULL;
3577
3578 if (frameOptions & FRAMEOPTION_ROWS)
3579 {
3580 /* Transform the raw expression tree */
3581 node = transformExpr(pstate, clause, EXPR_KIND_WINDOW_FRAME_ROWS);
3582
3583 /*
3584 * Like LIMIT clause, simply coerce to int8
3585 */
3586 constructName = "ROWS";
3587 node = coerce_to_specific_type(pstate, node, INT8OID, constructName);
3588 }
3589 else if (frameOptions & FRAMEOPTION_RANGE)
3590 {
3591 /*
3592 * We must look up the in_range support function that's to be used,
3593 * possibly choosing one of several, and coerce the "offset" value to
3594 * the appropriate input type.
3595 */
3596 Oid nodeType;
3597 Oid preferredType;
3598 int nfuncs = 0;
3599 int nmatches = 0;
3600 Oid selectedType = InvalidOid;
3601 Oid selectedFunc = InvalidOid;
3602 CatCList *proclist;
3603 int i;
3604
3605 /* Transform the raw expression tree */
3606 node = transformExpr(pstate, clause, EXPR_KIND_WINDOW_FRAME_RANGE);
3607 nodeType = exprType(node);
3608
3609 /*
3610 * If there are multiple candidates, we'll prefer the one that exactly
3611 * matches nodeType; or if nodeType is as yet unknown, prefer the one
3612 * that exactly matches the sort column type. (The second rule is
3613 * like what we do for "known_type operator unknown".)
3614 */
3615 preferredType = (nodeType != UNKNOWNOID) ? nodeType : rangeopcintype;
3616
3617 /* Find the in_range support functions applicable to this case */
3618 proclist = SearchSysCacheList2(AMPROCNUM,
3619 ObjectIdGetDatum(rangeopfamily),
3620 ObjectIdGetDatum(rangeopcintype));
3621 for (i = 0; i < proclist->n_members; i++)
3622 {
3623 HeapTuple proctup = &proclist->members[i]->tuple;
3624 Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
3625
3626 /* The search will find all support proc types; ignore others */
3627 if (procform->amprocnum != BTINRANGE_PROC)
3628 continue;
3629 nfuncs++;
3630
3631 /* Ignore function if given value can't be coerced to that type */
3632 if (!can_coerce_type(1, &nodeType, &procform->amprocrighttype,
3633 COERCION_IMPLICIT))
3634 continue;
3635 nmatches++;
3636
3637 /* Remember preferred match, or any match if didn't find that */
3638 if (selectedType != preferredType)
3639 {
3640 selectedType = procform->amprocrighttype;
3641 selectedFunc = procform->amproc;
3642 }
3643 }
3644 ReleaseCatCacheList(proclist);
3645
3646 /*
3647 * Throw error if needed. It seems worth taking the trouble to
3648 * distinguish "no support at all" from "you didn't match any
3649 * available offset type".
3650 */
3651 if (nfuncs == 0)
3652 ereport(ERROR,
3653 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3654 errmsg("RANGE with offset PRECEDING/FOLLOWING is not supported for column type %s",
3655 format_type_be(rangeopcintype)),
3656 parser_errposition(pstate, exprLocation(node))));
3657 if (nmatches == 0)
3658 ereport(ERROR,
3659 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3660 errmsg("RANGE with offset PRECEDING/FOLLOWING is not supported for column type %s and offset type %s",
3661 format_type_be(rangeopcintype),
3662 format_type_be(nodeType)),
3663 errhint("Cast the offset value to an appropriate type."),
3664 parser_errposition(pstate, exprLocation(node))));
3665 if (nmatches != 1 && selectedType != preferredType)
3666 ereport(ERROR,
3667 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3668 errmsg("RANGE with offset PRECEDING/FOLLOWING has multiple interpretations for column type %s and offset type %s",
3669 format_type_be(rangeopcintype),
3670 format_type_be(nodeType)),
3671 errhint("Cast the offset value to the exact intended type."),
3672 parser_errposition(pstate, exprLocation(node))));
3673
3674 /* OK, coerce the offset to the right type */
3675 constructName = "RANGE";
3676 node = coerce_to_specific_type(pstate, node,
3677 selectedType, constructName);
3678 *inRangeFunc = selectedFunc;
3679 }
3680 else if (frameOptions & FRAMEOPTION_GROUPS)
3681 {
3682 /* Transform the raw expression tree */
3683 node = transformExpr(pstate, clause, EXPR_KIND_WINDOW_FRAME_GROUPS);
3684
3685 /*
3686 * Like LIMIT clause, simply coerce to int8
3687 */
3688 constructName = "GROUPS";
3689 node = coerce_to_specific_type(pstate, node, INT8OID, constructName);
3690 }
3691 else
3692 {
3693 Assert(false);
3694 node = NULL;
3695 }
3696
3697 /* Disallow variables in frame offsets */
3698 checkExprIsVarFree(pstate, node, constructName);
3699
3700 return node;
3701 }
3702