| blob | 76f58b3aca34d795da28addcad14ababe71bec0e |
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-2025, 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 */
58 /* Hook for plugins to get control at end of parse analysis */
88 #ifdef DEBUG_NODE_TESTS_ENABLED
90 #endif
93 /*
94 * parse_analyze_fixedparams
95 * Analyze a raw parse tree and transform it to Query form.
96 *
97 * Optionally, information about $n parameter types can be supplied.
98 * References to $n indexes not defined by paramTypes[] are disallowed.
99 *
100 * The result is a Query node. Optimizable statements require considerable
101 * transformation, while utility-type statements are simply hung off
102 * a dummy CMD_UTILITY Query node.
103 */
104 Query *
108 {
135 }
137 /*
138 * parse_analyze_varparams
139 *
140 * This variant is used when it's okay to deduce information about $n
141 * symbol datatypes from context. The passed-in paramTypes[] array can
142 * be modified or enlarged (via repalloc).
143 */
144 Query *
148 {
163 /* make sure all is well with parameter types */
177 }
179 /*
180 * parse_analyze_withcb
181 *
182 * This variant is used when the caller supplies their own parser callback to
183 * resolve parameters and possibly other things.
184 */
185 Query *
187 ParserSetupHook parserSetup,
190 {
214 }
217 /*
218 * parse_sub_analyze
219 * Entry point for recursively analyzing a sub-statement.
220 */
221 Query *
226 {
239 }
241 /*
242 * setQueryLocationAndLength
243 * Set query's location and length from statement and ParseState
244 *
245 * Some statements, like PreparableStmt, can be located within parentheses.
246 * For example "(SELECT 1)" or "COPY (UPDATE ...) to x;". For those, we
247 * cannot use the whole string from the statement's location or the SQL
248 * string would yield incorrectly. The parser will set stmt_len, reflecting
249 * the size of the statement within the parentheses. Thus, when stmt_len is
250 * available, we need to use it for the Query's stmt_len.
251 *
252 * For other cases, the parser can't provide the length of individual
253 * statements. However, we have the statement's location plus the length
254 * (p_stmt_len) and location (p_stmt_location) of the top level RawStmt,
255 * stored in pstate. Thus, the statement's length is the RawStmt's length
256 * minus how much we've advanced in the RawStmt's string.
257 */
258 static void
260 {
263 /*
264 * If there is no information about the top RawStmt's length, leave it at
265 * 0 to use the whole string.
266 */
271 {
304 }
307 {
308 /* Statement's length is known, use it */
310 }
311 else
312 {
313 /*
314 * Compute the statement's length from the statement's location and
315 * the RawStmt's length and location.
316 */
318 }
320 /* The calculated statement length should be calculated as positive. */
322 }
324 /*
325 * transformTopLevelStmt -
326 * transform a Parse tree into a Query tree.
327 *
328 * This function is just responsible for storing location data
329 * from the RawStmt into the ParseState.
330 */
331 Query *
333 {
336 /* Store RawStmt's length and location in pstate */
340 /* We're at top level, so allow SELECT INTO */
344 }
346 /*
347 * transformOptionalSelectInto -
348 * If SELECT has INTO, convert it to CREATE TABLE AS.
349 *
350 * The only thing we do here that we don't do in transformStmt() is to
351 * convert SELECT ... INTO into CREATE TABLE AS. Since utility statements
352 * aren't allowed within larger statements, this is only allowed at the top
353 * of the parse tree, and so we only try it before entering the recursive
354 * transformStmt() processing.
355 */
358 {
360 {
363 /* If it's a set-operation tree, drill down to leftmost SelectStmt */
369 {
377 /*
378 * Remove the intoClause from the SelectStmt. This makes it safe
379 * for transformSelectStmt to complain if it finds intoClause set
380 * (implying that the INTO appeared in a disallowed place).
381 */
385 }
386 }
389 }
391 /*
392 * transformStmt -
393 * recursively transform a Parse tree into a Query tree.
394 */
395 Query *
397 {
400 #ifdef DEBUG_NODE_TESTS_ENABLED
402 /*
403 * We apply debug_raw_expression_coverage_test testing to basic DML
404 * statements; we can't just run it on everything because
405 * raw_expression_tree_walker() doesn't claim to handle utility
406 * statements.
407 */
409 {
411 {
421 }
422 }
425 /*
426 * Caution: when changing the set of statement types that have non-default
427 * processing here, see also stmt_requires_parse_analysis() and
428 * analyze_requires_snapshot().
429 */
431 {
432 /*
433 * Optimizable statements
434 */
452 {
459 else
461 }
473 /*
474 * Special cases
475 */
498 /*
499 * other statements don't require any transformation; just return
500 * the original parsetree with a Query node plastered on top.
501 */
506 }
508 /* Mark as original query until we learn differently */
514 }
516 /*
517 * stmt_requires_parse_analysis
518 * Returns true if parse analysis will do anything non-trivial
519 * with the given raw parse tree.
520 *
521 * Generally, this should return true for any statement type for which
522 * transformStmt() does more than wrap a CMD_UTILITY Query around it.
523 * When it returns false, the caller can assume that there is no situation
524 * in which parse analysis of the raw statement could need to be re-done.
525 *
526 * Currently, since the rewriter and planner do nothing for CMD_UTILITY
527 * Queries, a false result means that the entire parse analysis/rewrite/plan
528 * pipeline will never need to be re-done. If that ever changes, callers
529 * will likely need adjustment.
530 */
531 bool
533 {
537 {
538 /*
539 * Optimizable statements
540 */
551 /*
552 * Special cases
553 */
562 /* all other statements just get wrapped in a CMD_UTILITY Query */
565 }
568 }
570 /*
571 * analyze_requires_snapshot
572 * Returns true if a snapshot must be set before doing parse analysis
573 * on the given raw parse tree.
574 */
575 bool
577 {
578 /*
579 * Currently, this should return true in exactly the same cases that
580 * stmt_requires_parse_analysis() does, so we just invoke that function
581 * rather than duplicating it. We keep the two entry points separate for
582 * clarity of callers, since from the callers' standpoint these are
583 * different conditions.
584 *
585 * While there may someday be a statement type for which transformStmt()
586 * does something nontrivial and yet no snapshot is needed for that
587 * processing, it seems likely that making such a choice would be fragile.
588 * If you want to install an exception, document the reasoning for it in a
589 * comment.
590 */
592 }
594 /*
595 * transformDeleteStmt -
596 * transforms a Delete Statement
597 */
600 {
607 /* process the WITH clause independently of all else */
609 {
613 }
615 /* set up range table with just the result rel */
619 ACL_DELETE);
622 /* there's no DISTINCT in DELETE */
625 /* subqueries in USING cannot access the result relation */
629 /*
630 * The USING clause is non-standard SQL syntax, and is equivalent in
631 * functionality to the FROM list that can be specified for UPDATE. The
632 * USING keyword is used rather than FROM because FROM is already a
633 * keyword in the DELETE syntax.
634 */
637 /* remaining clauses can reference the result relation normally */
645 EXPR_KIND_RETURNING);
647 /* done building the range table and jointree */
659 /* this must be done after collations, for reliable comparison of exprs */
664 }
666 /*
667 * transformInsertStmt -
668 * transform an Insert Statement
669 */
672 {
688 AclMode targetPerms;
690 /* There can't be any outer WITH to worry about */
696 /* process the WITH clause independently of all else */
698 {
702 }
709 /*
710 * We have three cases to deal with: DEFAULT VALUES (selectStmt == NULL),
711 * VALUES list, or general SELECT input. We special-case VALUES, both for
712 * efficiency and so we can handle DEFAULT specifications.
713 *
714 * The grammar allows attaching ORDER BY, LIMIT, FOR UPDATE, or WITH to a
715 * VALUES clause. If we have any of those, treat it as a general SELECT;
716 * so it will work, but you can't use DEFAULT items together with those.
717 */
725 /*
726 * If a non-nil rangetable/namespace was passed in, and we are doing
727 * INSERT/SELECT, arrange to pass the rangetable/rteperminfos/namespace
728 * down to the SELECT. This can only happen if we are inside a CREATE
729 * RULE, and in that case we want the rule's OLD and NEW rtable entries to
730 * appear as part of the SELECT's rtable, not as outer references for it.
731 * (Kluge!) The SELECT's joinlist is not affected however. We must do
732 * this before adding the target table to the INSERT's rtable.
733 */
735 {
742 }
743 else
744 {
748 }
750 /*
751 * Must get write lock on INSERT target table before scanning SELECT, else
752 * we will grab the wrong kind of initial lock if the target table is also
753 * mentioned in the SELECT part. Note that the target table is not added
754 * to the joinlist or namespace.
755 */
762 /* Validate stmt->cols list, or build default list if no list given */
766 /*
767 * Determine which variant of INSERT we have.
768 */
770 {
771 /*
772 * We have INSERT ... DEFAULT VALUES. We can handle this case by
773 * emitting an empty targetlist --- all columns will be defaulted when
774 * the planner expands the targetlist.
775 */
777 }
779 {
780 /*
781 * We make the sub-pstate a child of the outer pstate so that it can
782 * see any Param definitions supplied from above. Since the outer
783 * pstate's rtable and namespace are presently empty, there are no
784 * side-effects of exposing names the sub-SELECT shouldn't be able to
785 * see.
786 */
790 /*
791 * Process the source SELECT.
792 *
793 * It is important that this be handled just like a standalone SELECT;
794 * otherwise the behavior of SELECT within INSERT might be different
795 * from a stand-alone SELECT. (Indeed, Postgres up through 6.5 had
796 * bugs of just that nature...)
797 *
798 * The sole exception is that we prevent resolving unknown-type
799 * outputs as TEXT. This does not change the semantics since if the
800 * column type matters semantically, it would have been resolved to
801 * something else anyway. Doing this lets us resolve such outputs as
802 * the target column's type, which we handle below.
803 */
815 /* The grammar should have produced a SELECT */
820 /*
821 * Make the source be a subquery in the INSERT's rangetable, and add
822 * it to the INSERT's joinlist (but not the namespace).
823 */
825 selectQuery,
831 /*----------
832 * Generate an expression list for the INSERT that selects all the
833 * non-resjunk columns from the subquery. (INSERT's tlist must be
834 * separate from the subquery's tlist because we may add columns,
835 * insert datatype coercions, etc.)
836 *
837 * HACK: unknown-type constants and params in the SELECT's targetlist
838 * are copied up as-is rather than being referenced as subquery
839 * outputs. This is to ensure that when we try to coerce them to
840 * the target column's datatype, the right things happen (see
841 * special cases in coerce_type). Otherwise, this fails:
842 * INSERT INTO foo SELECT 'bar', ... FROM baz
843 *----------
844 */
847 {
857 else
858 {
863 }
865 }
867 /* Prepare row for assignment to target table */
872 }
874 {
875 /*
876 * Process INSERT ... VALUES with multiple VALUES sublists. We
877 * generate a VALUES RTE holding the transformed expression lists, and
878 * build up a targetlist containing Vars that reference the VALUES
879 * RTE.
880 */
891 {
894 /*
895 * Do basic expression transformation (same as a ROW() expr, but
896 * allow SetToDefault at top level)
897 */
901 /*
902 * All the sublists must be the same length, *after*
903 * transformation (which might expand '*' into multiple items).
904 * The VALUES RTE can't handle anything different.
905 */
907 {
908 /* Remember post-transformation length of first sublist */
910 }
912 {
918 }
920 /*
921 * Prepare row for assignment to target table. We process any
922 * indirection on the target column specs normally but then strip
923 * off the resulting field/array assignment nodes, since we don't
924 * want the parsed statement to contain copies of those in each
925 * VALUES row. (It's annoying to have to transform the
926 * indirection specs over and over like this, but avoiding it
927 * would take some really messy refactoring of
928 * transformAssignmentIndirection.)
929 */
935 /*
936 * We must assign collations now because assign_query_collations
937 * doesn't process rangetable entries. We just assign all the
938 * collations independently in each row, and don't worry about
939 * whether they are consistent vertically. The outer INSERT query
940 * isn't going to care about the collations of the VALUES columns,
941 * so it's not worth the effort to identify a common collation for
942 * each one here. (But note this does have one user-visible
943 * consequence: INSERT ... VALUES won't complain about conflicting
944 * explicit COLLATEs in a column, whereas the same VALUES
945 * construct in another context would complain.)
946 */
950 }
952 /*
953 * Construct column type/typmod/collation lists for the VALUES RTE.
954 * Every expression in each column has been coerced to the type/typmod
955 * of the corresponding target column or subfield, so it's sufficient
956 * to look at the exprType/exprTypmod of the first row. We don't care
957 * about the collation labeling, so just fill in InvalidOid for that.
958 */
960 {
966 }
968 /*
969 * Ordinarily there can't be any current-level Vars in the expression
970 * lists, because the namespace was empty ... but if we're inside
971 * CREATE RULE, then NEW/OLD references might appear. In that case we
972 * have to mark the VALUES RTE as LATERAL.
973 */
978 /*
979 * Generate the VALUES RTE
980 */
986 /*
987 * Generate list of Vars referencing the RTE
988 */
991 /*
992 * Re-apply any indirection on the target column specs to the Vars
993 */
998 }
999 else
1000 {
1001 /*
1002 * Process INSERT ... VALUES with a single VALUES sublist. We treat
1003 * this case separately for efficiency. The sublist is just computed
1004 * directly as the Query's targetlist, with no VALUES RTE. So it
1005 * works just like a SELECT without any FROM.
1006 */
1012 /*
1013 * Do basic expression transformation (same as a ROW() expr, but allow
1014 * SetToDefault at top level)
1015 */
1018 EXPR_KIND_VALUES_SINGLE,
1021 /* Prepare row for assignment to target table */
1026 }
1028 /*
1029 * Generate query's target list using the computed list of expressions.
1030 * Also, mark all the target columns as needing insert permissions.
1031 */
1036 {
1043 attr_num,
1050 }
1052 /*
1053 * If we have any clauses yet to process, set the query namespace to
1054 * contain only the target relation, removing any entries added in a
1055 * sub-SELECT or VALUES list.
1056 */
1058 {
1062 }
1064 /* Process ON CONFLICT, if any. */
1069 /* Process RETURNING, if any. */
1072 EXPR_KIND_RETURNING);
1074 /* done building the range table and jointree */
1085 }
1087 /*
1088 * Prepare an INSERT row for assignment to the target table.
1089 *
1090 * exprlist: transformed expressions for source values; these might come from
1091 * a VALUES row, or be Vars referencing a sub-SELECT or VALUES RTE output.
1092 * stmtcols: original target-columns spec for INSERT (we just test for NIL)
1093 * icolumns: effective target-columns spec (list of ResTarget)
1094 * attrnos: integer column numbers (must be same length as icolumns)
1095 * strip_indirection: if true, remove any field/array assignment nodes
1096 */
1097 List *
1101 {
1107 /*
1108 * Check length of expr list. It must not have more expressions than
1109 * there are target columns. We allow fewer, but only if no explicit
1110 * columns list was given (the remaining columns are implicitly
1111 * defaulted). Note we must check this *after* transformation because
1112 * that could expand '*' into multiple items.
1113 */
1123 {
1124 /*
1125 * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
1126 * where the user accidentally created a RowExpr instead of separate
1127 * columns. Add a suitable hint if that seems to be the problem,
1128 * because the main error message is quite misleading for this case.
1129 * (If there's no stmtcols, you'll get something about data type
1130 * mismatch, which is less misleading so we don't worry about giving a
1131 * hint in that case.)
1132 */
1139 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),
1143 }
1145 /*
1146 * Prepare columns for assignment to target table.
1147 */
1150 {
1156 EXPR_KIND_INSERT_TARGET,
1158 attno,
1163 {
1164 /*
1165 * We need to remove top-level FieldStores and SubscriptingRefs,
1166 * as well as any CoerceToDomain appearing above one of those ---
1167 * but not a CoerceToDomain that isn't above one of those.
1168 */
1170 {
1174 {
1176 }
1178 {
1182 }
1184 {
1191 }
1192 else
1194 }
1195 }
1198 }
1201 }
1203 /*
1204 * transformOnConflictClause -
1205 * transforms an OnConflictClause in an INSERT
1206 */
1210 {
1214 Oid arbiterConstraint;
1221 /*
1222 * If this is ON CONFLICT ... UPDATE, first create the range table entry
1223 * for the EXCLUDED pseudo relation, so that that will be present while
1224 * processing arbiter expressions. (You can't actually reference it from
1225 * there, but this provides a useful error message if you try.)
1226 */
1228 {
1233 targetrel,
1234 RowExclusiveLock,
1240 /*
1241 * relkind is set to composite to signal that we're not dealing with
1242 * an actual relation, and no permission checks are required on it.
1243 * (We'll check the actual target relation, instead.)
1244 */
1247 /* Create EXCLUDED rel's targetlist for use by EXPLAIN */
1249 exclRelIndex);
1250 }
1252 /* Process the arbiter clause, ON CONFLICT ON (...) */
1256 /* Process DO UPDATE */
1258 {
1259 /*
1260 * Expressions in the UPDATE targetlist need to be handled like UPDATE
1261 * not INSERT. We don't need to save/restore this because all INSERT
1262 * expressions have been parsed already.
1263 */
1266 /*
1267 * Add the EXCLUDED pseudo relation to the query namespace, making it
1268 * available in the UPDATE subexpressions.
1269 */
1272 /*
1273 * Now transform the UPDATE subexpressions.
1274 */
1275 onConflictSet =
1282 /*
1283 * Remove the EXCLUDED pseudo relation from the query namespace, since
1284 * it's not supposed to be available in RETURNING. (Maybe someday we
1285 * could allow that, and drop this step.)
1286 */
1289 }
1291 /* Finally, build ON CONFLICT DO [NOTHING | UPDATE] expression */
1304 }
1307 /*
1308 * BuildOnConflictExcludedTargetlist
1309 * Create target list for the EXCLUDED pseudo-relation of ON CONFLICT,
1310 * representing the columns of targetrel with varno exclRelIndex.
1311 *
1312 * Note: Exported for use in the rewriter.
1313 */
1314 List *
1316 Index exclRelIndex)
1317 {
1323 /*
1324 * Note that resnos of the tlist must correspond to attnos of the
1325 * underlying relation, hence we need entries for dropped columns too.
1326 */
1328 {
1333 {
1334 /*
1335 * can't use atttypid here, but it doesn't really matter what type
1336 * the Const claims to be.
1337 */
1340 }
1341 else
1342 {
1348 }
1352 name,
1356 }
1358 /*
1359 * Add a whole-row-Var entry to support references to "EXCLUDED.*". Like
1360 * the other entries in the EXCLUDED tlist, its resno must match the Var's
1361 * varattno, else the wrong things happen while resolving references in
1362 * setrefs.c. This is against normal conventions for targetlists, but
1363 * it's okay since we don't use this as a real tlist.
1364 */
1372 }
1375 /*
1376 * count_rowexpr_columns -
1377 * get number of columns contained in a ROW() expression;
1378 * return -1 if expression isn't a RowExpr or a Var referencing one.
1379 *
1380 * This is currently used only for hint purposes, so we aren't terribly
1381 * tense about recognizing all possible cases. The Var case is interesting
1382 * because that's what we'll get in the INSERT ... SELECT (...) case.
1383 */
1384 static int
1386 {
1392 {
1397 {
1402 {
1403 /* Subselect-in-FROM: examine sub-select's output expr */
1405 attnum);
1412 }
1413 }
1414 }
1416 }
1419 /*
1420 * transformSelectStmt -
1421 * transforms a Select Statement
1422 *
1423 * Note: this covers only cases with no set operations and no VALUES lists;
1424 * see below for the other cases.
1425 */
1428 {
1435 /* process the WITH clause independently of all else */
1437 {
1441 }
1443 /* Complain if we get called from someplace where INTO is not allowed */
1451 /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
1454 /* make WINDOW info available for window functions, too */
1457 /* process the FROM clause */
1460 /* transform targetlist */
1462 EXPR_KIND_SELECT_TARGET);
1464 /* mark column origins */
1467 /* transform WHERE */
1471 /* initial processing of HAVING clause is much like WHERE clause */
1475 /*
1476 * Transform sorting/grouping stuff. Do ORDER BY first because both
1477 * transformGroupClause and transformDistinctClause need the results. Note
1478 * that these functions can also change the targetList, so it's passed to
1479 * them by reference.
1480 */
1484 EXPR_KIND_ORDER_BY,
1492 EXPR_KIND_GROUP_BY,
1497 {
1500 }
1502 {
1503 /* We had SELECT DISTINCT */
1509 }
1510 else
1511 {
1512 /* We had SELECT DISTINCT ON */
1518 }
1520 /* transform LIMIT */
1529 /* transform window clauses after we have seen all window functions */
1534 /* resolve any still-unresolved output columns as being type text */
1548 {
1551 }
1555 /* this must be done after collations, for reliable comparison of exprs */
1560 }
1562 /*
1563 * transformValuesClause -
1564 * transforms a VALUES clause that's being used as a standalone SELECT
1565 *
1566 * We build a Query containing a VALUES RTE, rather as if one had written
1567 * SELECT * FROM (VALUES ...) AS "*VALUES*"
1568 */
1571 {
1587 /* Most SELECT stuff doesn't apply in a VALUES clause */
1598 /* process the WITH clause independently of all else */
1600 {
1604 }
1606 /*
1607 * For each row of VALUES, transform the raw expressions.
1608 *
1609 * Note that the intermediate representation we build is column-organized
1610 * not row-organized. That simplifies the type and collation processing
1611 * below.
1612 */
1614 {
1617 /*
1618 * Do basic expression transformation (same as a ROW() expr, but here
1619 * we disallow SetToDefault)
1620 */
1624 /*
1625 * All the sublists must be the same length, *after* transformation
1626 * (which might expand '*' into multiple items). The VALUES RTE can't
1627 * handle anything different.
1628 */
1630 {
1631 /* Remember post-transformation length of first sublist */
1633 /* and allocate array for per-column lists */
1635 }
1637 {
1643 }
1645 /* Build per-column expression lists */
1648 {
1652 i++;
1653 }
1655 /* Release sub-list's cells to save memory */
1658 /* Prepare an exprsLists element for this row */
1660 }
1662 /*
1663 * Now resolve the common types of the columns, and coerce everything to
1664 * those types. Then identify the common typmod and common collation, if
1665 * any, of each column.
1666 *
1667 * We must do collation processing now because (1) assign_query_collations
1668 * doesn't process rangetable entries, and (2) we need to label the VALUES
1669 * RTE with column collations for use in the outer query. We don't
1670 * consider conflict of implicit collations to be an error here; instead
1671 * the column will just show InvalidOid as its collation, and you'll get a
1672 * failure later if that results in failure to resolve a collation.
1673 *
1674 * Note we modify the per-column expression lists in-place.
1675 */
1677 {
1678 Oid coltype;
1679 int32 coltypmod;
1680 Oid colcoll;
1685 {
1690 }
1698 }
1700 /*
1701 * Finally, rearrange the coerced expressions into row-organized lists.
1702 */
1704 {
1706 {
1712 }
1714 }
1716 /*
1717 * Ordinarily there can't be any current-level Vars in the expression
1718 * lists, because the namespace was empty ... but if we're inside CREATE
1719 * RULE, then NEW/OLD references might appear. In that case we have to
1720 * mark the VALUES RTE as LATERAL.
1721 */
1726 /*
1727 * Generate the VALUES RTE
1728 */
1734 /*
1735 * Generate a targetlist as though expanding "*"
1736 */
1740 /*
1741 * The grammar allows attaching ORDER BY, LIMIT, and FOR UPDATE to a
1742 * VALUES, so cope.
1743 */
1747 EXPR_KIND_ORDER_BY,
1761 /*------
1762 translator: %s is a SQL row locking clause such as FOR UPDATE */
1776 }
1778 /*
1779 * transformSetOperationStmt -
1780 * transforms a set-operations tree
1781 *
1782 * A set-operation tree is just a SELECT, but with UNION/INTERSECT/EXCEPT
1783 * structure to it. We must transform each leaf SELECT and build up a top-
1784 * level Query that contains the leaf SELECTs as subqueries in its rangetable.
1785 * The tree of set operations is converted into the setOperations field of
1786 * the top-level Query.
1787 */
1790 {
1818 /*
1819 * Find leftmost leaf SelectStmt. We currently only need to do this in
1820 * order to deliver a suitable error message if there's an INTO clause
1821 * there, implying the set-op tree is in a context that doesn't allow
1822 * INTO. (transformSetOperationTree would throw error anyway, but it
1823 * seems worth the trouble to throw a different error for non-leftmost
1824 * INTO, so we produce that error in transformSetOperationTree.)
1825 */
1838 /*
1839 * We need to extract ORDER BY and other top-level clauses here and not
1840 * let transformSetOperationTree() see them --- else it'll just recurse
1841 * right back here!
1842 */
1855 /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
1859 /*------
1860 translator: %s is a SQL row locking clause such as FOR UPDATE */
1865 /* Process the WITH clause independently of all else */
1867 {
1871 }
1873 /*
1874 * Recursively transform the components of the tree.
1875 */
1881 /*
1882 * Re-find leftmost SELECT (now it's a sub-query in rangetable)
1883 */
1892 /*
1893 * Generate dummy targetlist for outer query using column names of
1894 * leftmost select and common datatypes/collations of topmost set
1895 * operation. Also make lists of the dummy vars and their names for use
1896 * in parsing ORDER BY.
1897 *
1898 * Note: we use leftmostRTI as the varno of the dummy variables. It
1899 * shouldn't matter too much which RT index they have, as long as they
1900 * have one that corresponds to a real RT entry; else funny things may
1901 * happen when the tree is mashed by rule rewriting.
1902 */
1914 {
1927 colType,
1928 colTypmod,
1929 colCollation,
1934 colName,
1946 sortcolindex++;
1947 }
1949 /*
1950 * As a first step towards supporting sort clauses that are expressions
1951 * using the output columns, generate a namespace entry that makes the
1952 * output columns visible. A Join RTE node is handy for this, since we
1953 * can easily control the Vars generated upon matches.
1954 *
1955 * Note: we don't yet do anything useful with such cases, but at least
1956 * "ORDER BY upper(foo)" will draw the right error message rather than
1957 * "foo not found".
1958 */
1962 targetnames,
1963 sortnscolumns,
1964 JOIN_INNER,
1966 targetvars,
1967 NIL,
1968 NIL,
1969 NULL,
1970 NULL,
1976 /* add jnsitem to column namespace only */
1979 /*
1980 * For now, we don't support resjunk sort clauses on the output of a
1981 * setOperation tree --- you can only use the SQL92-spec options of
1982 * selecting an output column by name or number. Enforce by checking that
1983 * transformSortClause doesn't add any items to tlist. Note, if changing
1984 * this, add_setop_child_rel_equivalences() will need to be updated.
1985 */
1989 sortClause,
1991 EXPR_KIND_ORDER_BY,
1994 /* restore namespace, remove join RTE from rtable */
2025 {
2028 }
2032 /* this must be done after collations, for reliable comparison of exprs */
2037 }
2039 /*
2040 * Make a SortGroupClause node for a SetOperationStmt's groupClauses
2041 *
2042 * If require_hash is true, the caller is indicating that they need hash
2043 * support or they will fail. So look extra hard for hash support.
2044 */
2045 SortGroupClause *
2047 {
2049 Oid sortop;
2050 Oid eqop;
2053 /* determine the eqop and optional sortop */
2059 /*
2060 * The type cache doesn't believe that record is hashable (see
2061 * cache_record_field_properties()), but if the caller really needs hash
2062 * support, we can assume it does. Worst case, if any components of the
2063 * record don't support hashing, we will fail at execution.
2064 */
2068 /* we don't have a tlist yet, so can't assign sortgrouprefs */
2077 }
2079 /*
2080 * transformSetOperationTree
2081 * Recursively transform leaves and internal nodes of a set-op tree
2082 *
2083 * In addition to returning the transformed node, if targetlist isn't NULL
2084 * then we return a list of its non-resjunk TargetEntry nodes. For a leaf
2085 * set-op node these are the actual targetlist entries; otherwise they are
2086 * dummy entries created to carry the type, typmod, collation, and location
2087 * (for error messages) of each output column of the set-op node. This info
2088 * is needed only during the internal recursion of this function, so outside
2089 * callers pass NULL for targetlist. Note: the reason for passing the
2090 * actual targetlist entries of a leaf node is so that upper levels can
2091 * replace UNKNOWN Consts with properly-coerced constants.
2092 */
2096 {
2101 /* Guard against stack overflow due to overly complex set-expressions */
2104 /*
2105 * Validity-check both leaf and internal SELECTs for disallowed ops.
2106 */
2114 /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
2118 /*------
2119 translator: %s is a SQL row locking clause such as FOR UPDATE */
2124 /*
2125 * If an internal node of a set-op tree has ORDER BY, LIMIT, FOR UPDATE,
2126 * or WITH clauses attached, we need to treat it like a leaf node to
2127 * generate an independent sub-Query tree. Otherwise, it can be
2128 * represented by a SetOperationStmt node underneath the parent Query.
2129 */
2131 {
2134 }
2135 else
2136 {
2141 else
2143 }
2146 {
2147 /* Process leaf SELECT */
2154 /*
2155 * Transform SelectStmt into a Query.
2156 *
2157 * This works the same as SELECT transformation normally would, except
2158 * that we prevent resolving unknown-type outputs as TEXT. This does
2159 * not change the subquery's semantics since if the column type
2160 * matters semantically, it would have been resolved to something else
2161 * anyway. Doing this lets us resolve such outputs using
2162 * select_common_type(), below.
2163 *
2164 * Note: previously transformed sub-queries don't affect the parsing
2165 * of this sub-query, because they are not in the toplevel pstate's
2166 * namespace list.
2167 */
2171 /*
2172 * Check for bogus references to Vars on the current query level (but
2173 * upper-level references are okay). Normally this can't happen
2174 * because the namespace will be empty, but it could happen if we are
2175 * inside a rule.
2176 */
2178 {
2182 errmsg("UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"),
2185 }
2187 /*
2188 * Extract a list of the non-junk TLEs for upper-level processing.
2189 */
2191 {
2194 {
2199 }
2200 }
2202 /*
2203 * Make the leaf query be a subquery in the top-level rangetable.
2204 */
2208 selectQuery,
2213 /*
2214 * Return a RangeTblRef to replace the SelectStmt in the set-op tree.
2215 */
2219 }
2220 else
2221 {
2222 /* Process an internal node (set operation node) */
2239 /*
2240 * Recursively transform the left child node.
2241 */
2246 /*
2247 * If we are processing a recursive union query, now is the time to
2248 * examine the non-recursive term's output columns and mark the
2249 * containing CTE as having those result columns. We should do this
2250 * only at the topmost setop of the CTE, of course.
2251 */
2255 /*
2256 * Recursively transform the right child node.
2257 */
2262 /*
2263 * Verify that the two children have the same number of non-junk
2264 * columns, and determine the types of the merged output columns.
2265 */
2270 context),
2281 {
2290 Oid rescoltype;
2291 int32 rescoltypmod;
2292 Oid rescolcoll;
2294 /* select common type, same as CASE et al */
2297 context,
2301 /*
2302 * Verify the coercions are actually possible. If not, we'd fail
2303 * later anyway, but we want to fail now while we have sufficient
2304 * context to produce an error cursor position.
2305 *
2306 * For all non-UNKNOWN-type cases, we verify coercibility but we
2307 * don't modify the child's expression, for fear of changing the
2308 * child query's semantics.
2309 *
2310 * If a child expression is an UNKNOWN-type Const or Param, we
2311 * want to replace it with the coerced expression. This can only
2312 * happen when the child is a leaf set-op node. It's safe to
2313 * replace the expression because if the child query's semantics
2314 * depended on the type of this output column, it'd have already
2315 * coerced the UNKNOWN to something else. We want to do this
2316 * because (a) we want to verify that a Const is valid for the
2317 * target type, or resolve the actual type of an UNKNOWN Param,
2318 * and (b) we want to avoid unnecessary discrepancies between the
2319 * output type of the child query and the resolved target type.
2320 * Such a discrepancy would disable optimization in the planner.
2321 *
2322 * If it's some other UNKNOWN-type node, eg a Var, we do nothing
2323 * (knowing that coerce_to_common_type would fail). The planner
2324 * is sometimes able to fold an UNKNOWN Var to a constant before
2325 * it has to coerce the type, so failing now would just break
2326 * cases that might work.
2327 */
2333 {
2337 }
2344 {
2348 }
2352 rescoltype);
2354 /*
2355 * Select common collation. A common collation is required for
2356 * all set operators except UNION ALL; see SQL:2008 7.13 <query
2357 * expression> Syntax Rule 15c. (If we fail to identify a common
2358 * collation for a UNION ALL column, the colCollations element
2359 * will be set to InvalidOid, which may result in a runtime error
2360 * if something at a higher query level wants to use the column's
2361 * collation.)
2362 */
2367 /* emit results */
2372 /*
2373 * For all cases except UNION ALL, identify the grouping operators
2374 * (and, if available, sorting operators) that will be used to
2375 * eliminate duplicates.
2376 */
2378 {
2379 ParseCallbackState pcbstate;
2382 bestlocation);
2384 /*
2385 * If it's a recursive union, we need to require hashing
2386 * support.
2387 */
2392 }
2394 /*
2395 * Construct a dummy tlist entry to return. We use a SetToDefault
2396 * node for the expression, since it carries exactly the fields
2397 * needed, but any other expression node type would do as well.
2398 */
2400 {
2410 NULL,
2413 }
2414 }
2417 }
2418 }
2420 /*
2421 * Process the outputs of the non-recursive term of a recursive union
2422 * to set up the parent CTE's columns
2423 */
2424 static void
2426 {
2435 /*
2436 * Find leftmost leaf SELECT
2437 */
2446 /*
2447 * Generate dummy targetlist using column names of leftmost select and
2448 * dummy result expressions of the non-recursive term.
2449 */
2454 {
2463 next_resno++,
2464 colName,
2467 }
2469 /* Now build CTE's output column info using dummy targetlist */
2471 }
2474 /*
2475 * transformReturnStmt -
2476 * transforms a return statement
2477 */
2480 {
2486 qry->targetList = list_make1(makeTargetEntry((Expr *) transformExpr(pstate, stmt->returnval, EXPR_KIND_SELECT_TARGET),
2502 }
2505 /*
2506 * transformUpdateStmt -
2507 * transforms an update statement
2508 */
2511 {
2519 /* process the WITH clause independently of all else */
2521 {
2525 }
2530 ACL_UPDATE);
2533 /* subqueries in FROM cannot access the result relation */
2537 /*
2538 * the FROM clause is non-standard SQL syntax. We used to be able to do
2539 * this with REPLACE in POSTQUEL so we keep the feature.
2540 */
2543 /* remaining clauses can reference the result relation normally */
2551 EXPR_KIND_RETURNING);
2553 /*
2554 * Now we are done with SELECT-like processing, and can get on with
2555 * transforming the target list to match the UPDATE target columns.
2556 */
2569 }
2571 /*
2572 * transformUpdateTargetList -
2573 * handle SET clause in UPDATE/MERGE/INSERT ... ON CONFLICT UPDATE
2574 */
2575 List *
2577 {
2584 EXPR_KIND_UPDATE_SOURCE);
2586 /* Prepare to assign non-conflicting resnos to resjunk attributes */
2590 /* Prepare non-junk columns for assignment to target table */
2595 {
2601 {
2602 /*
2603 * Resjunk nodes need no additional processing, but be sure they
2604 * have resnos that do not match any target columns; else rewriter
2605 * or planner might get confused. They don't need a resname
2606 * either.
2607 */
2611 }
2630 attrno,
2634 /* Mark the target column as requiring update permissions */
2639 }
2644 }
2646 /*
2647 * addNSItemForReturning -
2648 * add a ParseNamespaceItem for the OLD or NEW alias in RETURNING.
2649 */
2650 static void
2652 VarReturningType returning_type)
2653 {
2659 /* copy per-column data from the target relation */
2669 /* mark all columns as returning OLD/NEW */
2673 /* build the nsitem, copying most fields from the target relation */
2682 /* add it to the query namespace as a table-only item */
2684 }
2686 /*
2687 * transformReturningClause -
2688 * handle a RETURNING clause in INSERT/UPDATE/DELETE/MERGE
2689 */
2690 void
2693 ParseExprKind exprKind)
2694 {
2701 /*
2702 * Scan RETURNING WITH(...) options for OLD/NEW alias names. Complain if
2703 * there is any conflict with existing relations.
2704 */
2706 {
2708 {
2713 /* translator: %s is OLD or NEW */
2723 /* translator: %s is OLD or NEW */
2731 }
2743 }
2745 /*
2746 * If OLD/NEW alias names weren't explicitly specified, use "old"/"new"
2747 * unless masked by existing relations.
2748 */
2751 {
2754 }
2757 {
2760 }
2762 /*
2763 * We need to assign resnos starting at one in the RETURNING list. Save
2764 * and restore the main tlist's value of p_next_resno, just in case
2765 * someone looks at it later (probably won't happen).
2766 */
2770 /* transform RETURNING expressions identically to a SELECT targetlist */
2773 exprKind);
2775 /*
2776 * Complain if the nonempty tlist expanded to nothing (which is possible
2777 * if it contains only a star-expansion of a zero-column table). If we
2778 * allow this, the parsed Query will look like it didn't have RETURNING,
2779 * with results that would probably surprise the user.
2780 */
2788 /* mark column origins */
2791 /* resolve any still-unresolved output columns as being type text */
2795 /* restore state */
2798 }
2801 /*
2802 * transformPLAssignStmt -
2803 * transform a PL/pgSQL assignment statement
2804 *
2805 * If there is no opt_indirection, the transformed statement looks like
2806 * "SELECT a_expr ...", except the expression has been cast to the type of
2807 * the target. With indirection, it's still a SELECT, but the expression will
2808 * incorporate FieldStore and/or assignment SubscriptingRef nodes to compute a
2809 * new value for a container-type variable represented by the target. The
2810 * expression references the target as the container source.
2811 */
2814 {
2821 Oid targettype;
2822 int32 targettypmod;
2823 Oid targetcollation;
2826 Oid type_id;
2830 /*
2831 * First, construct a ColumnRef for the target variable. If the target
2832 * has more than one dotted name, we have to pull the extra names out of
2833 * the indirection list.
2834 */
2838 {
2839 /* avoid munging the raw parsetree */
2842 {
2849 }
2850 }
2852 /*
2853 * Transform the target reference. Typically we will get back a Param
2854 * node, but there's no reason to be too picky about its type.
2855 */
2857 EXPR_KIND_UPDATE_TARGET);
2862 /*
2863 * The rest mostly matches transformSelectStmt, except that we needn't
2864 * consider WITH or INTO, and we build a targetlist our own way.
2865 */
2869 /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
2872 /* make WINDOW info available for window functions, too */
2875 /* process the FROM clause */
2878 /* initially transform the targetlist as if in SELECT */
2880 EXPR_KIND_SELECT_TARGET);
2882 /* we should have exactly one targetlist item */
2893 /*
2894 * This next bit is similar to transformAssignedExpr; the key difference
2895 * is we use COERCION_PLPGSQL not COERCION_ASSIGNMENT.
2896 */
2902 {
2905 target,
2908 targettype,
2909 targettypmod,
2910 targetcollation,
2911 indirection,
2914 COERCION_PLPGSQL,
2916 }
2920 {
2921 /*
2922 * Hack: do not let coerce_to_target_type() deal with inconsistent
2923 * composite types. Just pass the expression result through as-is,
2924 * and let the PL/pgSQL executor do the conversion its way. This is
2925 * rather bogus, but it's needed for backwards compatibility.
2926 */
2927 }
2928 else
2929 {
2930 /*
2931 * For normal non-qualified target column, do type checking and
2932 * coercion.
2933 */
2940 COERCION_PLPGSQL,
2941 COERCE_IMPLICIT_CAST,
2943 /* With COERCION_PLPGSQL, this error is probably unreachable */
2954 }
2960 /* transform WHERE */
2964 /* initial processing of HAVING clause is much like WHERE clause */
2968 /*
2969 * Transform sorting/grouping stuff. Do ORDER BY first because both
2970 * transformGroupClause and transformDistinctClause need the results. Note
2971 * that these functions can also change the targetList, so it's passed to
2972 * them by reference.
2973 */
2977 EXPR_KIND_ORDER_BY,
2985 EXPR_KIND_GROUP_BY,
2989 {
2992 }
2994 {
2995 /* We had SELECT DISTINCT */
3001 }
3002 else
3003 {
3004 /* We had SELECT DISTINCT ON */
3010 }
3012 /* transform LIMIT */
3021 /* transform window clauses after we have seen all window functions */
3036 {
3039 }
3043 /* this must be done after collations, for reliable comparison of exprs */
3048 }
3051 /*
3052 * transformDeclareCursorStmt -
3053 * transform a DECLARE CURSOR Statement
3054 *
3055 * DECLARE CURSOR is like other utility statements in that we emit it as a
3056 * CMD_UTILITY Query node; however, we must first transform the contained
3057 * query. We used to postpone that until execution, but it's really necessary
3058 * to do it during the normal parse analysis phase to ensure that side effects
3059 * of parser hooks happen at the expected time.
3060 */
3063 {
3071 /* translator: %s is a SQL keyword */
3079 /* translator: %s is a SQL keyword */
3083 /* Transform contained query, not allowing SELECT INTO */
3087 /* Grammar should not have allowed anything but SELECT */
3092 /*
3093 * We also disallow data-modifying WITH in a cursor. (This could be
3094 * allowed, but the semantics of when the updates occur might be
3095 * surprising.)
3096 */
3102 /* FOR UPDATE and WITH HOLD are not compatible */
3106 /*------
3107 translator: %s is a SQL row locking clause such as FOR UPDATE */
3113 /* FOR UPDATE and SCROLL are not compatible */
3117 /*------
3118 translator: %s is a SQL row locking clause such as FOR UPDATE */
3124 /* FOR UPDATE and INSENSITIVE are not compatible */
3128 /*------
3129 translator: %s is a SQL row locking clause such as FOR UPDATE */
3135 /* represent the command as a utility Query */
3141 }
3144 /*
3145 * transformExplainStmt -
3146 * transform an EXPLAIN Statement
3147 *
3148 * EXPLAIN is like other utility statements in that we emit it as a
3149 * CMD_UTILITY Query node; however, we must first transform the contained
3150 * query. We used to postpone that until execution, but it's really necessary
3151 * to do it during the normal parse analysis phase to ensure that side effects
3152 * of parser hooks happen at the expected time.
3153 */
3156 {
3162 /*
3163 * If we have no external source of parameter definitions, and the
3164 * GENERIC_PLAN option is specified, then accept variable parameter
3165 * definitions (similarly to PREPARE, for example).
3166 */
3168 {
3172 {
3177 /* don't "break", as we want the last value */
3178 }
3181 }
3183 /* transform contained query, allowing SELECT INTO */
3186 /* make sure all is well with parameter types */
3190 /* represent the command as a utility Query */
3196 }
3199 /*
3200 * transformCreateTableAsStmt -
3201 * transform a CREATE TABLE AS, SELECT ... INTO, or CREATE MATERIALIZED VIEW
3202 * Statement
3203 *
3204 * As with DECLARE CURSOR and EXPLAIN, transform the contained statement now.
3205 */
3208 {
3212 /* transform contained query, not allowing SELECT INTO */
3216 /* additional work needed for CREATE MATERIALIZED VIEW */
3218 {
3219 /*
3220 * Prohibit a data-modifying CTE in the query used to create a
3221 * materialized view. It's not sufficiently clear what the user would
3222 * want to happen if the MV is refreshed or incrementally maintained.
3223 */
3229 /*
3230 * Check whether any temporary database objects are used in the
3231 * creation query. It would be hard to refresh data or incrementally
3232 * maintain it if a source disappeared.
3233 */
3239 /*
3240 * A materialized view would either need to save parameters for use in
3241 * maintaining/loading the data or prohibit them entirely. The latter
3242 * seems safer and more sane.
3243 */
3249 /*
3250 * For now, we disallow unlogged materialized views, because it seems
3251 * like a bad idea for them to just go to empty after a crash. (If we
3252 * could mark them as unpopulated, that would be better, but that
3253 * requires catalog changes which crash recovery can't presently
3254 * handle.)
3255 */
3261 /*
3262 * At runtime, we'll need a copy of the parsed-but-not-rewritten Query
3263 * for purposes of creating the view's ON SELECT rule. We stash that
3264 * in the IntoClause because that's where intorel_startup() can
3265 * conveniently get it from.
3266 */
3268 }
3270 /* represent the command as a utility Query */
3276 }
3278 /*
3279 * transform a CallStmt
3280 */
3283 {
3288 HeapTuple proctup;
3289 Datum proargmodes;
3294 /*
3295 * First, do standard parse analysis on the procedure call and its
3296 * arguments, allowing us to identify the called procedure.
3297 */
3300 {
3303 EXPR_KIND_CALL_ARGUMENT));
3304 }
3308 targs,
3322 /*
3323 * Expand the argument list to deal with named-argument notation and
3324 * default arguments. For ordinary FuncExprs this'd be done during
3325 * planning, but a CallStmt doesn't go through planning, and there seems
3326 * no good reason not to do it here.
3327 */
3331 proctup);
3333 /* Fetch proargmodes; if it's null, there are no output args */
3335 Anum_pg_proc_proargmodes,
3338 {
3339 /*
3340 * Split the list into input arguments in fexpr->args and output
3341 * arguments in stmt->outargs. INOUT arguments appear in both lists.
3342 */
3356 numargs);
3362 {
3366 {
3379 /* note we don't support PROARGMODE_TABLE */
3383 }
3384 i++;
3385 }
3387 }
3394 /* represent the command as a utility Query */
3400 }
3402 /*
3403 * Produce a string representation of a LockClauseStrength value.
3404 * This should only be applied to valid values (not LCS_NONE).
3405 */
3408 {
3410 {
3422 }
3424 }
3426 /*
3427 * Check for features that are not supported with FOR [KEY] UPDATE/SHARE.
3428 *
3429 * exported so planner can check again after rewriting, query pullup, etc
3430 */
3431 void
3433 {
3439 /*------
3440 translator: %s is a SQL row locking clause such as FOR UPDATE */
3446 /*------
3447 translator: %s is a SQL row locking clause such as FOR UPDATE */
3453 /*------
3454 translator: %s is a SQL row locking clause such as FOR UPDATE */
3460 /*------
3461 translator: %s is a SQL row locking clause such as FOR UPDATE */
3467 /*------
3468 translator: %s is a SQL row locking clause such as FOR UPDATE */
3474 /*------
3475 translator: %s is a SQL row locking clause such as FOR UPDATE */
3481 /*------
3482 translator: %s is a SQL row locking clause such as FOR UPDATE */
3485 }
3487 /*
3488 * Transform a FOR [KEY] UPDATE/SHARE clause
3489 *
3490 * This basically involves replacing names by integer relids.
3491 *
3492 * NB: if you need to change this, see also markQueryForLocking()
3493 * in rewriteHandler.c, and isLockedRefname() in parse_relation.c.
3494 */
3495 static void
3498 {
3502 Index i;
3507 /* make a clause we can pass down to subqueries to select all rels */
3514 {
3515 /*
3516 * Lock all regular tables used in query and its subqueries. We
3517 * examine inFromCl to exclude auto-added RTEs, particularly NEW/OLD
3518 * in rules. This is a bit of an abuse of a mostly-obsolete flag, but
3519 * it's convenient. We can't rely on the namespace mechanism that has
3520 * largely replaced inFromCl, since for example we need to lock
3521 * base-relation RTEs even if they are masked by upper joins.
3522 */
3525 {
3532 {
3534 {
3540 pushedDown);
3543 }
3547 pushedDown);
3549 /*
3550 * FOR UPDATE/SHARE of subquery is propagated to all of
3551 * subquery's rels, too. We could do this later (based on
3552 * the marking of the subquery RTE) but it is convenient
3553 * to have local knowledge in each query level about which
3554 * rels need to be opened with RowShareLock.
3555 */
3560 /* ignore JOIN, SPECIAL, FUNCTION, VALUES, CTE RTEs */
3562 }
3563 }
3564 }
3565 else
3566 {
3567 /*
3568 * Lock just the named tables. As above, we allow locking any base
3569 * relation regardless of alias-visibility rules, so we need to
3570 * examine inFromCl to exclude OLD/NEW.
3571 */
3573 {
3576 /* For simplicity we insist on unqualified alias names here */
3580 /*------
3581 translator: %s is a SQL row locking clause such as FOR UPDATE */
3588 {
3596 /*
3597 * A join RTE without an alias is not visible as a relation
3598 * name and needs to be skipped (otherwise it might hide a
3599 * base relation with the same name), except if it has a USING
3600 * alias, which *is* visible.
3601 *
3602 * Subquery and values RTEs without aliases are never visible
3603 * as relation names and must always be skipped.
3604 */
3606 {
3608 {
3612 }
3616 }
3619 {
3621 {
3623 {
3629 pushedDown);
3632 }
3637 /* see comment above */
3644 /*------
3645 translator: %s is a SQL row locking clause such as FOR UPDATE */
3653 /*------
3654 translator: %s is a SQL row locking clause such as FOR UPDATE */
3662 /*------
3663 translator: %s is a SQL row locking clause such as FOR UPDATE */
3671 /*------
3672 translator: %s is a SQL row locking clause such as FOR UPDATE */
3680 /*------
3681 translator: %s is a SQL row locking clause such as FOR UPDATE */
3689 /*------
3690 translator: %s is a SQL row locking clause such as FOR UPDATE */
3696 /* Shouldn't be possible to see RTE_RESULT here */
3702 }
3704 }
3705 }
3709 /*------
3710 translator: %s is a SQL row locking clause such as FOR UPDATE */
3715 }
3716 }
3717 }
3719 /*
3720 * Record locking info for a single rangetable item
3721 */
3722 void
3726 {
3731 /* If it's an explicit clause, make sure hasForUpdate gets set */
3735 /* Check for pre-existing entry for same rtindex */
3737 {
3738 /*
3739 * If the same RTE is specified with more than one locking strength,
3740 * use the strongest. (Reasonable, since you can't take both a shared
3741 * and exclusive lock at the same time; it'll end up being exclusive
3742 * anyway.)
3743 *
3744 * Similarly, if the same RTE is specified with more than one lock
3745 * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
3746 * turn wins over waiting for the lock (the default). This is a bit
3747 * more debatable but raising an error doesn't seem helpful. (Consider
3748 * for instance SELECT FOR UPDATE NOWAIT from a view that internally
3749 * contains a plain FOR UPDATE spec.) Having NOWAIT win over SKIP
3750 * LOCKED is reasonable since the former throws an error in case of
3751 * coming across a locked tuple, which may be undesirable in some
3752 * cases but it seems better than silently returning inconsistent
3753 * results.
3754 *
3755 * And of course pushedDown becomes false if any clause is explicit.
3756 */
3761 }
3763 /* Make a new RowMarkClause */
3770 }
3772 #ifdef DEBUG_NODE_TESTS_ENABLED
3773 /*
3774 * Coverage testing for raw_expression_tree_walker().
3775 *
3776 * When enabled, we run raw_expression_tree_walker() over every DML statement
3777 * submitted to parse analysis. Without this provision, that function is only
3778 * applied in limited cases involving CTEs, and we don't really want to have
3779 * to test everything inside as well as outside a CTE.
3780 */
3781 static bool
3783 {
3787 test_raw_expression_coverage,
3788 context);
3789 }