| blob | 40066320927867d8e96014a5bba3537b87083aa9 |
1 /*-------------------------------------------------------------------------
2 *
3 * analyze.c
4 * transform the raw parse tree into a query tree
5 *
6 * For optimizable statements, we are careful to obtain a suitable lock on
7 * each referenced table, and other modules of the backend preserve or
8 * re-obtain these locks before depending on the results. It is therefore
9 * okay to do significant semantic analysis of these statements. For
10 * utility commands, no locks are obtained here (and if they were, we could
11 * not be sure we'd still have them at execution). Hence the general rule
12 * for utility commands is to just dump them into a Query node untransformed.
13 * DECLARE CURSOR, EXPLAIN, and CREATE TABLE AS are exceptions because they
14 * contain optimizable statements, which we should transform.
15 *
16 *
17 * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
18 * Portions Copyright (c) 1994, Regents of the University of California
19 *
20 * src/backend/parser/analyze.c
21 *
22 *-------------------------------------------------------------------------
23 */
59 /* Hook for plugins to get control at end of parse analysis */
90 #ifdef RAW_EXPRESSION_COVERAGE_TEST
92 #endif
95 /*
96 * parse_analyze_fixedparams
97 * Analyze a raw parse tree and transform it to Query form.
98 *
99 * Optionally, information about $n parameter types can be supplied.
100 * References to $n indexes not defined by paramTypes[] are disallowed.
101 *
102 * The result is a Query node. Optimizable statements require considerable
103 * transformation, while utility-type statements are simply hung off
104 * a dummy CMD_UTILITY Query node.
105 */
106 Query *
110 {
137 }
139 /*
140 * parse_analyze_varparams
141 *
142 * This variant is used when it's okay to deduce information about $n
143 * symbol datatypes from context. The passed-in paramTypes[] array can
144 * be modified or enlarged (via repalloc).
145 */
146 Query *
150 {
165 /* make sure all is well with parameter types */
179 }
181 /*
182 * parse_analyze_withcb
183 *
184 * This variant is used when the caller supplies their own parser callback to
185 * resolve parameters and possibly other things.
186 */
187 Query *
189 ParserSetupHook parserSetup,
192 {
216 }
219 /*
220 * parse_sub_analyze
221 * Entry point for recursively analyzing a sub-statement.
222 */
223 Query *
228 {
241 }
243 /*
244 * transformTopLevelStmt -
245 * transform a Parse tree into a Query tree.
246 *
247 * This function is just responsible for transferring statement location data
248 * from the RawStmt into the finished Query.
249 */
250 Query *
252 {
255 /* We're at top level, so allow SELECT INTO */
262 }
264 /*
265 * transformOptionalSelectInto -
266 * If SELECT has INTO, convert it to CREATE TABLE AS.
267 *
268 * The only thing we do here that we don't do in transformStmt() is to
269 * convert SELECT ... INTO into CREATE TABLE AS. Since utility statements
270 * aren't allowed within larger statements, this is only allowed at the top
271 * of the parse tree, and so we only try it before entering the recursive
272 * transformStmt() processing.
273 */
276 {
278 {
281 /* If it's a set-operation tree, drill down to leftmost SelectStmt */
287 {
295 /*
296 * Remove the intoClause from the SelectStmt. This makes it safe
297 * for transformSelectStmt to complain if it finds intoClause set
298 * (implying that the INTO appeared in a disallowed place).
299 */
303 }
304 }
307 }
309 /*
310 * transformStmt -
311 * recursively transform a Parse tree into a Query tree.
312 */
313 Query *
315 {
318 /*
319 * We apply RAW_EXPRESSION_COVERAGE_TEST testing to basic DML statements;
320 * we can't just run it on everything because raw_expression_tree_walker()
321 * doesn't claim to handle utility statements.
322 */
323 #ifdef RAW_EXPRESSION_COVERAGE_TEST
325 {
335 }
339 {
340 /*
341 * Optimizable statements
342 */
360 {
367 else
369 }
381 /*
382 * Special cases
383 */
406 /*
407 * other statements don't require any transformation; just return
408 * the original parsetree with a Query node plastered on top.
409 */
414 }
416 /* Mark as original query until we learn differently */
421 }
423 /*
424 * analyze_requires_snapshot
425 * Returns true if a snapshot must be set before doing parse analysis
426 * on the given raw parse tree.
427 *
428 * Classification here should match transformStmt().
429 */
430 bool
432 {
436 {
437 /*
438 * Optimizable statements
439 */
449 /*
450 * Special cases
451 */
455 /* yes, because we must analyze the contained statement */
460 /* other utility statements don't have any real parse analysis */
463 }
466 }
468 /*
469 * transformDeleteStmt -
470 * transforms a Delete Statement
471 */
474 {
481 /* process the WITH clause independently of all else */
483 {
487 }
489 /* set up range table with just the result rel */
493 ACL_DELETE);
496 /* there's no DISTINCT in DELETE */
499 /* subqueries in USING cannot access the result relation */
503 /*
504 * The USING clause is non-standard SQL syntax, and is equivalent in
505 * functionality to the FROM list that can be specified for UPDATE. The
506 * USING keyword is used rather than FROM because FROM is already a
507 * keyword in the DELETE syntax.
508 */
511 /* remaining clauses can reference the result relation normally */
520 /* done building the range table and jointree */
532 /* this must be done after collations, for reliable comparison of exprs */
537 }
539 /*
540 * transformInsertStmt -
541 * transform an Insert Statement
542 */
545 {
561 AclMode targetPerms;
563 /* There can't be any outer WITH to worry about */
569 /* process the WITH clause independently of all else */
571 {
575 }
582 /*
583 * We have three cases to deal with: DEFAULT VALUES (selectStmt == NULL),
584 * VALUES list, or general SELECT input. We special-case VALUES, both for
585 * efficiency and so we can handle DEFAULT specifications.
586 *
587 * The grammar allows attaching ORDER BY, LIMIT, FOR UPDATE, or WITH to a
588 * VALUES clause. If we have any of those, treat it as a general SELECT;
589 * so it will work, but you can't use DEFAULT items together with those.
590 */
598 /*
599 * If a non-nil rangetable/namespace was passed in, and we are doing
600 * INSERT/SELECT, arrange to pass the rangetable/rteperminfos/namespace
601 * down to the SELECT. This can only happen if we are inside a CREATE
602 * RULE, and in that case we want the rule's OLD and NEW rtable entries to
603 * appear as part of the SELECT's rtable, not as outer references for it.
604 * (Kluge!) The SELECT's joinlist is not affected however. We must do
605 * this before adding the target table to the INSERT's rtable.
606 */
608 {
615 }
616 else
617 {
621 }
623 /*
624 * Must get write lock on INSERT target table before scanning SELECT, else
625 * we will grab the wrong kind of initial lock if the target table is also
626 * mentioned in the SELECT part. Note that the target table is not added
627 * to the joinlist or namespace.
628 */
635 /* Validate stmt->cols list, or build default list if no list given */
639 /*
640 * Determine which variant of INSERT we have.
641 */
643 {
644 /*
645 * We have INSERT ... DEFAULT VALUES. We can handle this case by
646 * emitting an empty targetlist --- all columns will be defaulted when
647 * the planner expands the targetlist.
648 */
650 }
652 {
653 /*
654 * We make the sub-pstate a child of the outer pstate so that it can
655 * see any Param definitions supplied from above. Since the outer
656 * pstate's rtable and namespace are presently empty, there are no
657 * side-effects of exposing names the sub-SELECT shouldn't be able to
658 * see.
659 */
663 /*
664 * Process the source SELECT.
665 *
666 * It is important that this be handled just like a standalone SELECT;
667 * otherwise the behavior of SELECT within INSERT might be different
668 * from a stand-alone SELECT. (Indeed, Postgres up through 6.5 had
669 * bugs of just that nature...)
670 *
671 * The sole exception is that we prevent resolving unknown-type
672 * outputs as TEXT. This does not change the semantics since if the
673 * column type matters semantically, it would have been resolved to
674 * something else anyway. Doing this lets us resolve such outputs as
675 * the target column's type, which we handle below.
676 */
688 /* The grammar should have produced a SELECT */
693 /*
694 * Make the source be a subquery in the INSERT's rangetable, and add
695 * it to the INSERT's joinlist (but not the namespace).
696 */
698 selectQuery,
704 /*----------
705 * Generate an expression list for the INSERT that selects all the
706 * non-resjunk columns from the subquery. (INSERT's tlist must be
707 * separate from the subquery's tlist because we may add columns,
708 * insert datatype coercions, etc.)
709 *
710 * HACK: unknown-type constants and params in the SELECT's targetlist
711 * are copied up as-is rather than being referenced as subquery
712 * outputs. This is to ensure that when we try to coerce them to
713 * the target column's datatype, the right things happen (see
714 * special cases in coerce_type). Otherwise, this fails:
715 * INSERT INTO foo SELECT 'bar', ... FROM baz
716 *----------
717 */
720 {
730 else
731 {
736 }
738 }
740 /* Prepare row for assignment to target table */
745 }
747 {
748 /*
749 * Process INSERT ... VALUES with multiple VALUES sublists. We
750 * generate a VALUES RTE holding the transformed expression lists, and
751 * build up a targetlist containing Vars that reference the VALUES
752 * RTE.
753 */
764 {
767 /*
768 * Do basic expression transformation (same as a ROW() expr, but
769 * allow SetToDefault at top level)
770 */
774 /*
775 * All the sublists must be the same length, *after*
776 * transformation (which might expand '*' into multiple items).
777 * The VALUES RTE can't handle anything different.
778 */
780 {
781 /* Remember post-transformation length of first sublist */
783 }
785 {
791 }
793 /*
794 * Prepare row for assignment to target table. We process any
795 * indirection on the target column specs normally but then strip
796 * off the resulting field/array assignment nodes, since we don't
797 * want the parsed statement to contain copies of those in each
798 * VALUES row. (It's annoying to have to transform the
799 * indirection specs over and over like this, but avoiding it
800 * would take some really messy refactoring of
801 * transformAssignmentIndirection.)
802 */
808 /*
809 * We must assign collations now because assign_query_collations
810 * doesn't process rangetable entries. We just assign all the
811 * collations independently in each row, and don't worry about
812 * whether they are consistent vertically. The outer INSERT query
813 * isn't going to care about the collations of the VALUES columns,
814 * so it's not worth the effort to identify a common collation for
815 * each one here. (But note this does have one user-visible
816 * consequence: INSERT ... VALUES won't complain about conflicting
817 * explicit COLLATEs in a column, whereas the same VALUES
818 * construct in another context would complain.)
819 */
823 }
825 /*
826 * Construct column type/typmod/collation lists for the VALUES RTE.
827 * Every expression in each column has been coerced to the type/typmod
828 * of the corresponding target column or subfield, so it's sufficient
829 * to look at the exprType/exprTypmod of the first row. We don't care
830 * about the collation labeling, so just fill in InvalidOid for that.
831 */
833 {
839 }
841 /*
842 * Ordinarily there can't be any current-level Vars in the expression
843 * lists, because the namespace was empty ... but if we're inside
844 * CREATE RULE, then NEW/OLD references might appear. In that case we
845 * have to mark the VALUES RTE as LATERAL.
846 */
851 /*
852 * Generate the VALUES RTE
853 */
859 /*
860 * Generate list of Vars referencing the RTE
861 */
864 /*
865 * Re-apply any indirection on the target column specs to the Vars
866 */
871 }
872 else
873 {
874 /*
875 * Process INSERT ... VALUES with a single VALUES sublist. We treat
876 * this case separately for efficiency. The sublist is just computed
877 * directly as the Query's targetlist, with no VALUES RTE. So it
878 * works just like a SELECT without any FROM.
879 */
885 /*
886 * Do basic expression transformation (same as a ROW() expr, but allow
887 * SetToDefault at top level)
888 */
891 EXPR_KIND_VALUES_SINGLE,
894 /* Prepare row for assignment to target table */
899 }
901 /*
902 * Generate query's target list using the computed list of expressions.
903 * Also, mark all the target columns as needing insert permissions.
904 */
909 {
916 attr_num,
923 }
925 /*
926 * If we have any clauses yet to process, set the query namespace to
927 * contain only the target relation, removing any entries added in a
928 * sub-SELECT or VALUES list.
929 */
931 {
935 }
937 /* Process ON CONFLICT, if any. */
942 /* Process RETURNING, if any. */
947 /* done building the range table and jointree */
958 }
960 /*
961 * Prepare an INSERT row for assignment to the target table.
962 *
963 * exprlist: transformed expressions for source values; these might come from
964 * a VALUES row, or be Vars referencing a sub-SELECT or VALUES RTE output.
965 * stmtcols: original target-columns spec for INSERT (we just test for NIL)
966 * icolumns: effective target-columns spec (list of ResTarget)
967 * attrnos: integer column numbers (must be same length as icolumns)
968 * strip_indirection: if true, remove any field/array assignment nodes
969 */
970 List *
974 {
980 /*
981 * Check length of expr list. It must not have more expressions than
982 * there are target columns. We allow fewer, but only if no explicit
983 * columns list was given (the remaining columns are implicitly
984 * defaulted). Note we must check this *after* transformation because
985 * that could expand '*' into multiple items.
986 */
996 {
997 /*
998 * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
999 * where the user accidentally created a RowExpr instead of separate
1000 * columns. Add a suitable hint if that seems to be the problem,
1001 * because the main error message is quite misleading for this case.
1002 * (If there's no stmtcols, you'll get something about data type
1003 * mismatch, which is less misleading so we don't worry about giving a
1004 * hint in that case.)
1005 */
1012 errhint("The insertion source is a row expression containing the same number of columns expected by the INSERT. Did you accidentally use extra parentheses?") : 0),
1016 }
1018 /*
1019 * Prepare columns for assignment to target table.
1020 */
1023 {
1029 EXPR_KIND_INSERT_TARGET,
1031 attno,
1036 {
1038 {
1040 {
1044 }
1046 {
1053 }
1054 else
1056 }
1057 }
1060 }
1063 }
1065 /*
1066 * transformOnConflictClause -
1067 * transforms an OnConflictClause in an INSERT
1068 */
1072 {
1076 Oid arbiterConstraint;
1083 /*
1084 * If this is ON CONFLICT ... UPDATE, first create the range table entry
1085 * for the EXCLUDED pseudo relation, so that that will be present while
1086 * processing arbiter expressions. (You can't actually reference it from
1087 * there, but this provides a useful error message if you try.)
1088 */
1090 {
1095 targetrel,
1096 RowExclusiveLock,
1102 /*
1103 * relkind is set to composite to signal that we're not dealing with
1104 * an actual relation, and no permission checks are required on it.
1105 * (We'll check the actual target relation, instead.)
1106 */
1109 /* Create EXCLUDED rel's targetlist for use by EXPLAIN */
1111 exclRelIndex);
1112 }
1114 /* Process the arbiter clause, ON CONFLICT ON (...) */
1118 /* Process DO UPDATE */
1120 {
1121 /*
1122 * Expressions in the UPDATE targetlist need to be handled like UPDATE
1123 * not INSERT. We don't need to save/restore this because all INSERT
1124 * expressions have been parsed already.
1125 */
1128 /*
1129 * Add the EXCLUDED pseudo relation to the query namespace, making it
1130 * available in the UPDATE subexpressions.
1131 */
1134 /*
1135 * Now transform the UPDATE subexpressions.
1136 */
1137 onConflictSet =
1144 /*
1145 * Remove the EXCLUDED pseudo relation from the query namespace, since
1146 * it's not supposed to be available in RETURNING. (Maybe someday we
1147 * could allow that, and drop this step.)
1148 */
1151 }
1153 /* Finally, build ON CONFLICT DO [NOTHING | UPDATE] expression */
1166 }
1169 /*
1170 * BuildOnConflictExcludedTargetlist
1171 * Create target list for the EXCLUDED pseudo-relation of ON CONFLICT,
1172 * representing the columns of targetrel with varno exclRelIndex.
1173 *
1174 * Note: Exported for use in the rewriter.
1175 */
1176 List *
1178 Index exclRelIndex)
1179 {
1185 /*
1186 * Note that resnos of the tlist must correspond to attnos of the
1187 * underlying relation, hence we need entries for dropped columns too.
1188 */
1190 {
1195 {
1196 /*
1197 * can't use atttypid here, but it doesn't really matter what type
1198 * the Const claims to be.
1199 */
1202 }
1203 else
1204 {
1210 }
1214 name,
1218 }
1220 /*
1221 * Add a whole-row-Var entry to support references to "EXCLUDED.*". Like
1222 * the other entries in the EXCLUDED tlist, its resno must match the Var's
1223 * varattno, else the wrong things happen while resolving references in
1224 * setrefs.c. This is against normal conventions for targetlists, but
1225 * it's okay since we don't use this as a real tlist.
1226 */
1234 }
1237 /*
1238 * count_rowexpr_columns -
1239 * get number of columns contained in a ROW() expression;
1240 * return -1 if expression isn't a RowExpr or a Var referencing one.
1241 *
1242 * This is currently used only for hint purposes, so we aren't terribly
1243 * tense about recognizing all possible cases. The Var case is interesting
1244 * because that's what we'll get in the INSERT ... SELECT (...) case.
1245 */
1246 static int
1248 {
1254 {
1259 {
1264 {
1265 /* Subselect-in-FROM: examine sub-select's output expr */
1267 attnum);
1274 }
1275 }
1276 }
1278 }
1281 /*
1282 * transformSelectStmt -
1283 * transforms a Select Statement
1284 *
1285 * Note: this covers only cases with no set operations and no VALUES lists;
1286 * see below for the other cases.
1287 */
1290 {
1297 /* process the WITH clause independently of all else */
1299 {
1303 }
1305 /* Complain if we get called from someplace where INTO is not allowed */
1313 /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
1316 /* make WINDOW info available for window functions, too */
1319 /* process the FROM clause */
1322 /* transform targetlist */
1324 EXPR_KIND_SELECT_TARGET);
1326 /* mark column origins */
1329 /* transform WHERE */
1333 /* initial processing of HAVING clause is much like WHERE clause */
1337 /*
1338 * Transform sorting/grouping stuff. Do ORDER BY first because both
1339 * transformGroupClause and transformDistinctClause need the results. Note
1340 * that these functions can also change the targetList, so it's passed to
1341 * them by reference.
1342 */
1346 EXPR_KIND_ORDER_BY,
1354 EXPR_KIND_GROUP_BY,
1359 {
1362 }
1364 {
1365 /* We had SELECT DISTINCT */
1371 }
1372 else
1373 {
1374 /* We had SELECT DISTINCT ON */
1380 }
1382 /* transform LIMIT */
1391 /* transform window clauses after we have seen all window functions */
1396 /* resolve any still-unresolved output columns as being type text */
1410 {
1413 }
1417 /* this must be done after collations, for reliable comparison of exprs */
1422 }
1424 /*
1425 * transformValuesClause -
1426 * transforms a VALUES clause that's being used as a standalone SELECT
1427 *
1428 * We build a Query containing a VALUES RTE, rather as if one had written
1429 * SELECT * FROM (VALUES ...) AS "*VALUES*"
1430 */
1433 {
1449 /* Most SELECT stuff doesn't apply in a VALUES clause */
1460 /* process the WITH clause independently of all else */
1462 {
1466 }
1468 /*
1469 * For each row of VALUES, transform the raw expressions.
1470 *
1471 * Note that the intermediate representation we build is column-organized
1472 * not row-organized. That simplifies the type and collation processing
1473 * below.
1474 */
1476 {
1479 /*
1480 * Do basic expression transformation (same as a ROW() expr, but here
1481 * we disallow SetToDefault)
1482 */
1486 /*
1487 * All the sublists must be the same length, *after* transformation
1488 * (which might expand '*' into multiple items). The VALUES RTE can't
1489 * handle anything different.
1490 */
1492 {
1493 /* Remember post-transformation length of first sublist */
1495 /* and allocate array for per-column lists */
1497 }
1499 {
1505 }
1507 /* Build per-column expression lists */
1510 {
1514 i++;
1515 }
1517 /* Release sub-list's cells to save memory */
1520 /* Prepare an exprsLists element for this row */
1522 }
1524 /*
1525 * Now resolve the common types of the columns, and coerce everything to
1526 * those types. Then identify the common typmod and common collation, if
1527 * any, of each column.
1528 *
1529 * We must do collation processing now because (1) assign_query_collations
1530 * doesn't process rangetable entries, and (2) we need to label the VALUES
1531 * RTE with column collations for use in the outer query. We don't
1532 * consider conflict of implicit collations to be an error here; instead
1533 * the column will just show InvalidOid as its collation, and you'll get a
1534 * failure later if that results in failure to resolve a collation.
1535 *
1536 * Note we modify the per-column expression lists in-place.
1537 */
1539 {
1540 Oid coltype;
1541 int32 coltypmod;
1542 Oid colcoll;
1547 {
1552 }
1560 }
1562 /*
1563 * Finally, rearrange the coerced expressions into row-organized lists.
1564 */
1566 {
1568 {
1574 }
1576 }
1578 /*
1579 * Ordinarily there can't be any current-level Vars in the expression
1580 * lists, because the namespace was empty ... but if we're inside CREATE
1581 * RULE, then NEW/OLD references might appear. In that case we have to
1582 * mark the VALUES RTE as LATERAL.
1583 */
1588 /*
1589 * Generate the VALUES RTE
1590 */
1596 /*
1597 * Generate a targetlist as though expanding "*"
1598 */
1602 /*
1603 * The grammar allows attaching ORDER BY, LIMIT, and FOR UPDATE to a
1604 * VALUES, so cope.
1605 */
1609 EXPR_KIND_ORDER_BY,
1623 /*------
1624 translator: %s is a SQL row locking clause such as FOR UPDATE */
1638 }
1640 /*
1641 * transformSetOperationStmt -
1642 * transforms a set-operations tree
1643 *
1644 * A set-operation tree is just a SELECT, but with UNION/INTERSECT/EXCEPT
1645 * structure to it. We must transform each leaf SELECT and build up a top-
1646 * level Query that contains the leaf SELECTs as subqueries in its rangetable.
1647 * The tree of set operations is converted into the setOperations field of
1648 * the top-level Query.
1649 */
1652 {
1680 /*
1681 * Find leftmost leaf SelectStmt. We currently only need to do this in
1682 * order to deliver a suitable error message if there's an INTO clause
1683 * there, implying the set-op tree is in a context that doesn't allow
1684 * INTO. (transformSetOperationTree would throw error anyway, but it
1685 * seems worth the trouble to throw a different error for non-leftmost
1686 * INTO, so we produce that error in transformSetOperationTree.)
1687 */
1700 /*
1701 * We need to extract ORDER BY and other top-level clauses here and not
1702 * let transformSetOperationTree() see them --- else it'll just recurse
1703 * right back here!
1704 */
1717 /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
1721 /*------
1722 translator: %s is a SQL row locking clause such as FOR UPDATE */
1727 /* Process the WITH clause independently of all else */
1729 {
1733 }
1735 /*
1736 * Recursively transform the components of the tree.
1737 */
1743 /*
1744 * Re-find leftmost SELECT (now it's a sub-query in rangetable)
1745 */
1754 /*
1755 * Generate dummy targetlist for outer query using column names of
1756 * leftmost select and common datatypes/collations of topmost set
1757 * operation. Also make lists of the dummy vars and their names for use
1758 * in parsing ORDER BY.
1759 *
1760 * Note: we use leftmostRTI as the varno of the dummy variables. It
1761 * shouldn't matter too much which RT index they have, as long as they
1762 * have one that corresponds to a real RT entry; else funny things may
1763 * happen when the tree is mashed by rule rewriting.
1764 */
1776 {
1789 colType,
1790 colTypmod,
1791 colCollation,
1796 colName,
1808 sortcolindex++;
1809 }
1811 /*
1812 * As a first step towards supporting sort clauses that are expressions
1813 * using the output columns, generate a namespace entry that makes the
1814 * output columns visible. A Join RTE node is handy for this, since we
1815 * can easily control the Vars generated upon matches.
1816 *
1817 * Note: we don't yet do anything useful with such cases, but at least
1818 * "ORDER BY upper(foo)" will draw the right error message rather than
1819 * "foo not found".
1820 */
1824 targetnames,
1825 sortnscolumns,
1826 JOIN_INNER,
1828 targetvars,
1829 NIL,
1830 NIL,
1831 NULL,
1832 NULL,
1838 /* add jnsitem to column namespace only */
1841 /*
1842 * For now, we don't support resjunk sort clauses on the output of a
1843 * setOperation tree --- you can only use the SQL92-spec options of
1844 * selecting an output column by name or number. Enforce by checking that
1845 * transformSortClause doesn't add any items to tlist.
1846 */
1850 sortClause,
1852 EXPR_KIND_ORDER_BY,
1855 /* restore namespace, remove join RTE from rtable */
1886 {
1889 }
1893 /* this must be done after collations, for reliable comparison of exprs */
1898 }
1900 /*
1901 * Make a SortGroupClause node for a SetOperationStmt's groupClauses
1902 *
1903 * If require_hash is true, the caller is indicating that they need hash
1904 * support or they will fail. So look extra hard for hash support.
1905 */
1906 SortGroupClause *
1908 {
1910 Oid sortop;
1911 Oid eqop;
1914 /* determine the eqop and optional sortop */
1920 /*
1921 * The type cache doesn't believe that record is hashable (see
1922 * cache_record_field_properties()), but if the caller really needs hash
1923 * support, we can assume it does. Worst case, if any components of the
1924 * record don't support hashing, we will fail at execution.
1925 */
1929 /* we don't have a tlist yet, so can't assign sortgrouprefs */
1937 }
1939 /*
1940 * transformSetOperationTree
1941 * Recursively transform leaves and internal nodes of a set-op tree
1942 *
1943 * In addition to returning the transformed node, if targetlist isn't NULL
1944 * then we return a list of its non-resjunk TargetEntry nodes. For a leaf
1945 * set-op node these are the actual targetlist entries; otherwise they are
1946 * dummy entries created to carry the type, typmod, collation, and location
1947 * (for error messages) of each output column of the set-op node. This info
1948 * is needed only during the internal recursion of this function, so outside
1949 * callers pass NULL for targetlist. Note: the reason for passing the
1950 * actual targetlist entries of a leaf node is so that upper levels can
1951 * replace UNKNOWN Consts with properly-coerced constants.
1952 */
1956 {
1961 /* Guard against stack overflow due to overly complex set-expressions */
1964 /*
1965 * Validity-check both leaf and internal SELECTs for disallowed ops.
1966 */
1974 /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
1978 /*------
1979 translator: %s is a SQL row locking clause such as FOR UPDATE */
1984 /*
1985 * If an internal node of a set-op tree has ORDER BY, LIMIT, FOR UPDATE,
1986 * or WITH clauses attached, we need to treat it like a leaf node to
1987 * generate an independent sub-Query tree. Otherwise, it can be
1988 * represented by a SetOperationStmt node underneath the parent Query.
1989 */
1991 {
1994 }
1995 else
1996 {
2001 else
2003 }
2006 {
2007 /* Process leaf SELECT */
2014 /*
2015 * Transform SelectStmt into a Query.
2016 *
2017 * This works the same as SELECT transformation normally would, except
2018 * that we prevent resolving unknown-type outputs as TEXT. This does
2019 * not change the subquery's semantics since if the column type
2020 * matters semantically, it would have been resolved to something else
2021 * anyway. Doing this lets us resolve such outputs using
2022 * select_common_type(), below.
2023 *
2024 * Note: previously transformed sub-queries don't affect the parsing
2025 * of this sub-query, because they are not in the toplevel pstate's
2026 * namespace list.
2027 */
2031 /*
2032 * Check for bogus references to Vars on the current query level (but
2033 * upper-level references are okay). Normally this can't happen
2034 * because the namespace will be empty, but it could happen if we are
2035 * inside a rule.
2036 */
2038 {
2042 errmsg("UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"),
2045 }
2047 /*
2048 * Extract a list of the non-junk TLEs for upper-level processing.
2049 */
2051 {
2054 {
2059 }
2060 }
2062 /*
2063 * Make the leaf query be a subquery in the top-level rangetable.
2064 */
2068 selectQuery,
2073 /*
2074 * Return a RangeTblRef to replace the SelectStmt in the set-op tree.
2075 */
2079 }
2080 else
2081 {
2082 /* Process an internal node (set operation node) */
2099 /*
2100 * Recursively transform the left child node.
2101 */
2106 /*
2107 * If we are processing a recursive union query, now is the time to
2108 * examine the non-recursive term's output columns and mark the
2109 * containing CTE as having those result columns. We should do this
2110 * only at the topmost setop of the CTE, of course.
2111 */
2115 /*
2116 * Recursively transform the right child node.
2117 */
2122 /*
2123 * Verify that the two children have the same number of non-junk
2124 * columns, and determine the types of the merged output columns.
2125 */
2130 context),
2141 {
2150 Oid rescoltype;
2151 int32 rescoltypmod;
2152 Oid rescolcoll;
2154 /* select common type, same as CASE et al */
2157 context,
2161 /*
2162 * Verify the coercions are actually possible. If not, we'd fail
2163 * later anyway, but we want to fail now while we have sufficient
2164 * context to produce an error cursor position.
2165 *
2166 * For all non-UNKNOWN-type cases, we verify coercibility but we
2167 * don't modify the child's expression, for fear of changing the
2168 * child query's semantics.
2169 *
2170 * If a child expression is an UNKNOWN-type Const or Param, we
2171 * want to replace it with the coerced expression. This can only
2172 * happen when the child is a leaf set-op node. It's safe to
2173 * replace the expression because if the child query's semantics
2174 * depended on the type of this output column, it'd have already
2175 * coerced the UNKNOWN to something else. We want to do this
2176 * because (a) we want to verify that a Const is valid for the
2177 * target type, or resolve the actual type of an UNKNOWN Param,
2178 * and (b) we want to avoid unnecessary discrepancies between the
2179 * output type of the child query and the resolved target type.
2180 * Such a discrepancy would disable optimization in the planner.
2181 *
2182 * If it's some other UNKNOWN-type node, eg a Var, we do nothing
2183 * (knowing that coerce_to_common_type would fail). The planner
2184 * is sometimes able to fold an UNKNOWN Var to a constant before
2185 * it has to coerce the type, so failing now would just break
2186 * cases that might work.
2187 */
2193 {
2197 }
2204 {
2208 }
2212 rescoltype);
2214 /*
2215 * Select common collation. A common collation is required for
2216 * all set operators except UNION ALL; see SQL:2008 7.13 <query
2217 * expression> Syntax Rule 15c. (If we fail to identify a common
2218 * collation for a UNION ALL column, the colCollations element
2219 * will be set to InvalidOid, which may result in a runtime error
2220 * if something at a higher query level wants to use the column's
2221 * collation.)
2222 */
2227 /* emit results */
2232 /*
2233 * For all cases except UNION ALL, identify the grouping operators
2234 * (and, if available, sorting operators) that will be used to
2235 * eliminate duplicates.
2236 */
2238 {
2239 ParseCallbackState pcbstate;
2242 bestlocation);
2244 /*
2245 * If it's a recursive union, we need to require hashing
2246 * support.
2247 */
2252 }
2254 /*
2255 * Construct a dummy tlist entry to return. We use a SetToDefault
2256 * node for the expression, since it carries exactly the fields
2257 * needed, but any other expression node type would do as well.
2258 */
2260 {
2270 NULL,
2273 }
2274 }
2277 }
2278 }
2280 /*
2281 * Process the outputs of the non-recursive term of a recursive union
2282 * to set up the parent CTE's columns
2283 */
2284 static void
2286 {
2295 /*
2296 * Find leftmost leaf SELECT
2297 */
2306 /*
2307 * Generate dummy targetlist using column names of leftmost select and
2308 * dummy result expressions of the non-recursive term.
2309 */
2314 {
2323 next_resno++,
2324 colName,
2327 }
2329 /* Now build CTE's output column info using dummy targetlist */
2331 }
2334 /*
2335 * transformReturnStmt -
2336 * transforms a return statement
2337 */
2340 {
2346 qry->targetList = list_make1(makeTargetEntry((Expr *) transformExpr(pstate, stmt->returnval, EXPR_KIND_SELECT_TARGET),
2362 }
2365 /*
2366 * transformUpdateStmt -
2367 * transforms an update statement
2368 */
2371 {
2379 /* process the WITH clause independently of all else */
2381 {
2385 }
2390 ACL_UPDATE);
2393 /* subqueries in FROM cannot access the result relation */
2397 /*
2398 * the FROM clause is non-standard SQL syntax. We used to be able to do
2399 * this with REPLACE in POSTQUEL so we keep the feature.
2400 */
2403 /* remaining clauses can reference the result relation normally */
2412 /*
2413 * Now we are done with SELECT-like processing, and can get on with
2414 * transforming the target list to match the UPDATE target columns.
2415 */
2428 }
2430 /*
2431 * transformUpdateTargetList -
2432 * handle SET clause in UPDATE/MERGE/INSERT ... ON CONFLICT UPDATE
2433 */
2434 List *
2436 {
2443 EXPR_KIND_UPDATE_SOURCE);
2445 /* Prepare to assign non-conflicting resnos to resjunk attributes */
2449 /* Prepare non-junk columns for assignment to target table */
2454 {
2460 {
2461 /*
2462 * Resjunk nodes need no additional processing, but be sure they
2463 * have resnos that do not match any target columns; else rewriter
2464 * or planner might get confused. They don't need a resname
2465 * either.
2466 */
2470 }
2486 attrno,
2490 /* Mark the target column as requiring update permissions */
2495 }
2500 }
2502 /*
2503 * transformReturningList -
2504 * handle a RETURNING clause in INSERT/UPDATE/DELETE
2505 */
2508 {
2515 /*
2516 * We need to assign resnos starting at one in the RETURNING list. Save
2517 * and restore the main tlist's value of p_next_resno, just in case
2518 * someone looks at it later (probably won't happen).
2519 */
2523 /* transform RETURNING identically to a SELECT targetlist */
2526 /*
2527 * Complain if the nonempty tlist expanded to nothing (which is possible
2528 * if it contains only a star-expansion of a zero-column table). If we
2529 * allow this, the parsed Query will look like it didn't have RETURNING,
2530 * with results that would probably surprise the user.
2531 */
2539 /* mark column origins */
2542 /* resolve any still-unresolved output columns as being type text */
2546 /* restore state */
2550 }
2553 /*
2554 * transformPLAssignStmt -
2555 * transform a PL/pgSQL assignment statement
2556 *
2557 * If there is no opt_indirection, the transformed statement looks like
2558 * "SELECT a_expr ...", except the expression has been cast to the type of
2559 * the target. With indirection, it's still a SELECT, but the expression will
2560 * incorporate FieldStore and/or assignment SubscriptingRef nodes to compute a
2561 * new value for a container-type variable represented by the target. The
2562 * expression references the target as the container source.
2563 */
2566 {
2573 Oid targettype;
2574 int32 targettypmod;
2575 Oid targetcollation;
2578 Oid type_id;
2582 /*
2583 * First, construct a ColumnRef for the target variable. If the target
2584 * has more than one dotted name, we have to pull the extra names out of
2585 * the indirection list.
2586 */
2590 {
2591 /* avoid munging the raw parsetree */
2594 {
2601 }
2602 }
2604 /*
2605 * Transform the target reference. Typically we will get back a Param
2606 * node, but there's no reason to be too picky about its type.
2607 */
2609 EXPR_KIND_UPDATE_TARGET);
2614 /*
2615 * The rest mostly matches transformSelectStmt, except that we needn't
2616 * consider WITH or INTO, and we build a targetlist our own way.
2617 */
2621 /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
2624 /* make WINDOW info available for window functions, too */
2627 /* process the FROM clause */
2630 /* initially transform the targetlist as if in SELECT */
2632 EXPR_KIND_SELECT_TARGET);
2634 /* we should have exactly one targetlist item */
2645 /*
2646 * This next bit is similar to transformAssignedExpr; the key difference
2647 * is we use COERCION_PLPGSQL not COERCION_ASSIGNMENT.
2648 */
2654 {
2657 target,
2660 targettype,
2661 targettypmod,
2662 targetcollation,
2663 indirection,
2666 COERCION_PLPGSQL,
2668 }
2672 {
2673 /*
2674 * Hack: do not let coerce_to_target_type() deal with inconsistent
2675 * composite types. Just pass the expression result through as-is,
2676 * and let the PL/pgSQL executor do the conversion its way. This is
2677 * rather bogus, but it's needed for backwards compatibility.
2678 */
2679 }
2680 else
2681 {
2682 /*
2683 * For normal non-qualified target column, do type checking and
2684 * coercion.
2685 */
2692 COERCION_PLPGSQL,
2693 COERCE_IMPLICIT_CAST,
2695 /* With COERCION_PLPGSQL, this error is probably unreachable */
2706 }
2712 /* transform WHERE */
2716 /* initial processing of HAVING clause is much like WHERE clause */
2720 /*
2721 * Transform sorting/grouping stuff. Do ORDER BY first because both
2722 * transformGroupClause and transformDistinctClause need the results. Note
2723 * that these functions can also change the targetList, so it's passed to
2724 * them by reference.
2725 */
2729 EXPR_KIND_ORDER_BY,
2737 EXPR_KIND_GROUP_BY,
2741 {
2744 }
2746 {
2747 /* We had SELECT DISTINCT */
2753 }
2754 else
2755 {
2756 /* We had SELECT DISTINCT ON */
2762 }
2764 /* transform LIMIT */
2773 /* transform window clauses after we have seen all window functions */
2788 {
2791 }
2795 /* this must be done after collations, for reliable comparison of exprs */
2800 }
2803 /*
2804 * transformDeclareCursorStmt -
2805 * transform a DECLARE CURSOR Statement
2806 *
2807 * DECLARE CURSOR is like other utility statements in that we emit it as a
2808 * CMD_UTILITY Query node; however, we must first transform the contained
2809 * query. We used to postpone that until execution, but it's really necessary
2810 * to do it during the normal parse analysis phase to ensure that side effects
2811 * of parser hooks happen at the expected time.
2812 */
2815 {
2823 /* translator: %s is a SQL keyword */
2831 /* translator: %s is a SQL keyword */
2835 /* Transform contained query, not allowing SELECT INTO */
2839 /* Grammar should not have allowed anything but SELECT */
2844 /*
2845 * We also disallow data-modifying WITH in a cursor. (This could be
2846 * allowed, but the semantics of when the updates occur might be
2847 * surprising.)
2848 */
2854 /* FOR UPDATE and WITH HOLD are not compatible */
2858 /*------
2859 translator: %s is a SQL row locking clause such as FOR UPDATE */
2865 /* FOR UPDATE and SCROLL are not compatible */
2869 /*------
2870 translator: %s is a SQL row locking clause such as FOR UPDATE */
2876 /* FOR UPDATE and INSENSITIVE are not compatible */
2880 /*------
2881 translator: %s is a SQL row locking clause such as FOR UPDATE */
2887 /* represent the command as a utility Query */
2893 }
2896 /*
2897 * transformExplainStmt -
2898 * transform an EXPLAIN Statement
2899 *
2900 * EXPLAIN is like other utility statements in that we emit it as a
2901 * CMD_UTILITY Query node; however, we must first transform the contained
2902 * query. We used to postpone that until execution, but it's really necessary
2903 * to do it during the normal parse analysis phase to ensure that side effects
2904 * of parser hooks happen at the expected time.
2905 */
2908 {
2914 /*
2915 * If we have no external source of parameter definitions, and the
2916 * GENERIC_PLAN option is specified, then accept variable parameter
2917 * definitions (similarly to PREPARE, for example).
2918 */
2920 {
2924 {
2929 /* don't "break", as we want the last value */
2930 }
2933 }
2935 /* transform contained query, allowing SELECT INTO */
2938 /* make sure all is well with parameter types */
2942 /* represent the command as a utility Query */
2948 }
2951 /*
2952 * transformCreateTableAsStmt -
2953 * transform a CREATE TABLE AS, SELECT ... INTO, or CREATE MATERIALIZED VIEW
2954 * Statement
2955 *
2956 * As with DECLARE CURSOR and EXPLAIN, transform the contained statement now.
2957 */
2960 {
2964 /* transform contained query, not allowing SELECT INTO */
2968 /* additional work needed for CREATE MATERIALIZED VIEW */
2970 {
2971 /*
2972 * Prohibit a data-modifying CTE in the query used to create a
2973 * materialized view. It's not sufficiently clear what the user would
2974 * want to happen if the MV is refreshed or incrementally maintained.
2975 */
2981 /*
2982 * Check whether any temporary database objects are used in the
2983 * creation query. It would be hard to refresh data or incrementally
2984 * maintain it if a source disappeared.
2985 */
2991 /*
2992 * A materialized view would either need to save parameters for use in
2993 * maintaining/loading the data or prohibit them entirely. The latter
2994 * seems safer and more sane.
2995 */
3001 /*
3002 * For now, we disallow unlogged materialized views, because it seems
3003 * like a bad idea for them to just go to empty after a crash. (If we
3004 * could mark them as unpopulated, that would be better, but that
3005 * requires catalog changes which crash recovery can't presently
3006 * handle.)
3007 */
3013 /*
3014 * At runtime, we'll need a copy of the parsed-but-not-rewritten Query
3015 * for purposes of creating the view's ON SELECT rule. We stash that
3016 * in the IntoClause because that's where intorel_startup() can
3017 * conveniently get it from.
3018 */
3020 }
3022 /* represent the command as a utility Query */
3028 }
3030 /*
3031 * transform a CallStmt
3032 */
3035 {
3040 HeapTuple proctup;
3041 Datum proargmodes;
3046 /*
3047 * First, do standard parse analysis on the procedure call and its
3048 * arguments, allowing us to identify the called procedure.
3049 */
3052 {
3055 EXPR_KIND_CALL_ARGUMENT));
3056 }
3060 targs,
3074 /*
3075 * Expand the argument list to deal with named-argument notation and
3076 * default arguments. For ordinary FuncExprs this'd be done during
3077 * planning, but a CallStmt doesn't go through planning, and there seems
3078 * no good reason not to do it here.
3079 */
3083 proctup);
3085 /* Fetch proargmodes; if it's null, there are no output args */
3087 Anum_pg_proc_proargmodes,
3090 {
3091 /*
3092 * Split the list into input arguments in fexpr->args and output
3093 * arguments in stmt->outargs. INOUT arguments appear in both lists.
3094 */
3108 numargs);
3114 {
3118 {
3131 /* note we don't support PROARGMODE_TABLE */
3135 }
3136 i++;
3137 }
3139 }
3146 /* represent the command as a utility Query */
3152 }
3154 /*
3155 * Produce a string representation of a LockClauseStrength value.
3156 * This should only be applied to valid values (not LCS_NONE).
3157 */
3160 {
3162 {
3174 }
3176 }
3178 /*
3179 * Check for features that are not supported with FOR [KEY] UPDATE/SHARE.
3180 *
3181 * exported so planner can check again after rewriting, query pullup, etc
3182 */
3183 void
3185 {
3191 /*------
3192 translator: %s is a SQL row locking clause such as FOR UPDATE */
3198 /*------
3199 translator: %s is a SQL row locking clause such as FOR UPDATE */
3205 /*------
3206 translator: %s is a SQL row locking clause such as FOR UPDATE */
3212 /*------
3213 translator: %s is a SQL row locking clause such as FOR UPDATE */
3219 /*------
3220 translator: %s is a SQL row locking clause such as FOR UPDATE */
3226 /*------
3227 translator: %s is a SQL row locking clause such as FOR UPDATE */
3233 /*------
3234 translator: %s is a SQL row locking clause such as FOR UPDATE */
3237 }
3239 /*
3240 * Transform a FOR [KEY] UPDATE/SHARE clause
3241 *
3242 * This basically involves replacing names by integer relids.
3243 *
3244 * NB: if you need to change this, see also markQueryForLocking()
3245 * in rewriteHandler.c, and isLockedRefname() in parse_relation.c.
3246 */
3247 static void
3250 {
3254 Index i;
3259 /* make a clause we can pass down to subqueries to select all rels */
3266 {
3267 /*
3268 * Lock all regular tables used in query and its subqueries. We
3269 * examine inFromCl to exclude auto-added RTEs, particularly NEW/OLD
3270 * in rules. This is a bit of an abuse of a mostly-obsolete flag, but
3271 * it's convenient. We can't rely on the namespace mechanism that has
3272 * largely replaced inFromCl, since for example we need to lock
3273 * base-relation RTEs even if they are masked by upper joins.
3274 */
3277 {
3284 {
3286 {
3292 pushedDown);
3295 }
3299 pushedDown);
3301 /*
3302 * FOR UPDATE/SHARE of subquery is propagated to all of
3303 * subquery's rels, too. We could do this later (based on
3304 * the marking of the subquery RTE) but it is convenient
3305 * to have local knowledge in each query level about which
3306 * rels need to be opened with RowShareLock.
3307 */
3312 /* ignore JOIN, SPECIAL, FUNCTION, VALUES, CTE RTEs */
3314 }
3315 }
3316 }
3317 else
3318 {
3319 /*
3320 * Lock just the named tables. As above, we allow locking any base
3321 * relation regardless of alias-visibility rules, so we need to
3322 * examine inFromCl to exclude OLD/NEW.
3323 */
3325 {
3328 /* For simplicity we insist on unqualified alias names here */
3332 /*------
3333 translator: %s is a SQL row locking clause such as FOR UPDATE */
3340 {
3348 /*
3349 * A join RTE without an alias is not visible as a relation
3350 * name and needs to be skipped (otherwise it might hide a
3351 * base relation with the same name), except if it has a USING
3352 * alias, which *is* visible.
3353 *
3354 * Subquery and values RTEs without aliases are never visible
3355 * as relation names and must always be skipped.
3356 */
3358 {
3360 {
3364 }
3368 }
3371 {
3373 {
3375 {
3381 pushedDown);
3384 }
3389 /* see comment above */
3396 /*------
3397 translator: %s is a SQL row locking clause such as FOR UPDATE */
3405 /*------
3406 translator: %s is a SQL row locking clause such as FOR UPDATE */
3414 /*------
3415 translator: %s is a SQL row locking clause such as FOR UPDATE */
3423 /*------
3424 translator: %s is a SQL row locking clause such as FOR UPDATE */
3432 /*------
3433 translator: %s is a SQL row locking clause such as FOR UPDATE */
3441 /*------
3442 translator: %s is a SQL row locking clause such as FOR UPDATE */
3448 /* Shouldn't be possible to see RTE_RESULT here */
3454 }
3456 }
3457 }
3461 /*------
3462 translator: %s is a SQL row locking clause such as FOR UPDATE */
3467 }
3468 }
3469 }
3471 /*
3472 * Record locking info for a single rangetable item
3473 */
3474 void
3478 {
3483 /* If it's an explicit clause, make sure hasForUpdate gets set */
3487 /* Check for pre-existing entry for same rtindex */
3489 {
3490 /*
3491 * If the same RTE is specified with more than one locking strength,
3492 * use the strongest. (Reasonable, since you can't take both a shared
3493 * and exclusive lock at the same time; it'll end up being exclusive
3494 * anyway.)
3495 *
3496 * Similarly, if the same RTE is specified with more than one lock
3497 * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
3498 * turn wins over waiting for the lock (the default). This is a bit
3499 * more debatable but raising an error doesn't seem helpful. (Consider
3500 * for instance SELECT FOR UPDATE NOWAIT from a view that internally
3501 * contains a plain FOR UPDATE spec.) Having NOWAIT win over SKIP
3502 * LOCKED is reasonable since the former throws an error in case of
3503 * coming across a locked tuple, which may be undesirable in some
3504 * cases but it seems better than silently returning inconsistent
3505 * results.
3506 *
3507 * And of course pushedDown becomes false if any clause is explicit.
3508 */
3513 }
3515 /* Make a new RowMarkClause */
3522 }
3524 /*
3525 * Coverage testing for raw_expression_tree_walker().
3526 *
3527 * When enabled, we run raw_expression_tree_walker() over every DML statement
3528 * submitted to parse analysis. Without this provision, that function is only
3529 * applied in limited cases involving CTEs, and we don't really want to have
3530 * to test everything inside as well as outside a CTE.
3531 */
3532 #ifdef RAW_EXPRESSION_COVERAGE_TEST
3534 static bool
3536 {
3540 test_raw_expression_coverage,
3541 context);
3542 }