| blob | 039f897331c863336fa3f7f397810c5913522920 |
1 /*-------------------------------------------------------------------------
2 *
3 * ruleutils.c
4 * Functions to convert stored expressions/querytrees back to
5 * source text
6 *
7 * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 *
11 * IDENTIFICATION
12 * src/backend/utils/adt/ruleutils.c
13 *
14 *-------------------------------------------------------------------------
15 */
18 #include <ctype.h>
19 #include <unistd.h>
20 #include <fcntl.h>
76 /* ----------
77 * Pretty formatting constants
78 * ----------
79 */
81 /* Indent counts */
82 #define PRETTYINDENT_STD 8
83 #define PRETTYINDENT_JOIN 4
84 #define PRETTYINDENT_VAR 4
88 /* Pretty flags */
89 #define PRETTYFLAG_PAREN 0x0001
90 #define PRETTYFLAG_INDENT 0x0002
91 #define PRETTYFLAG_SCHEMA 0x0004
93 /* Default line length for pretty-print wrapping: 0 means wrap always */
94 #define WRAP_COLUMN_DEFAULT 0
96 /* macros to test if pretty action needed */
97 #define PRETTY_PAREN(context) ((context)->prettyFlags & PRETTYFLAG_PAREN)
98 #define PRETTY_INDENT(context) ((context)->prettyFlags & PRETTYFLAG_INDENT)
99 #define PRETTY_SCHEMA(context) ((context)->prettyFlags & PRETTYFLAG_SCHEMA)
102 /* ----------
103 * Local data types
104 * ----------
105 */
107 /* Context info needed for invoking a recursive querytree display routine */
109 {
119 * handling */
121 * back to the parent rel */
124 /*
125 * Each level of query context around a subtree needs a level of Var namespace.
126 * A Var having varlevelsup=N refers to the N'th item (counting from 0) in
127 * the current context's namespaces list.
128 *
129 * rtable is the list of actual RTEs from the Query or PlannedStmt.
130 * rtable_names holds the alias name to be used for each RTE (either a C
131 * string, or NULL for nameless RTEs such as unnamed joins).
132 * rtable_columns holds the column alias names to be used for each RTE.
133 *
134 * subplans is a list of Plan trees for SubPlans and CTEs (it's only used
135 * in the PlannedStmt case).
136 * ctes is a list of CommonTableExpr nodes (only used in the Query case).
137 * appendrels, if not null (it's only used in the PlannedStmt case), is an
138 * array of AppendRelInfo nodes, indexed by child relid. We use that to map
139 * child-table Vars to their inheritance parents.
140 *
141 * In some cases we need to make names of merged JOIN USING columns unique
142 * across the whole query, not only per-RTE. If so, unique_using is true
143 * and using_names is a list of C strings representing names already assigned
144 * to USING columns.
145 *
146 * When deparsing plan trees, there is always just a single item in the
147 * deparse_namespace list (since a plan tree never contains Vars with
148 * varlevelsup > 0). We store the Plan node that is the immediate
149 * parent of the expression to be deparsed, as well as a list of that
150 * Plan's ancestors. In addition, we store its outer and inner subplan nodes,
151 * as well as their targetlists, and the index tlist if the current plan node
152 * might contain INDEX_VAR Vars. (These fields could be derived on-the-fly
153 * from the current Plan node, but it seems notationally clearer to set them
154 * up as separate fields.)
155 */
157 {
164 /* Workspace for column alias assignment: */
167 /* Remaining fields are used only when deparsing a Plan tree: */
175 /* Special namespace representing a function signature: */
181 /*
182 * Per-relation data about column alias names.
183 *
184 * Selecting aliases is unreasonably complicated because of the need to dump
185 * rules/views whose underlying tables may have had columns added, deleted, or
186 * renamed since the query was parsed. We must nonetheless print the rule/view
187 * in a form that can be reloaded and will produce the same results as before.
188 *
189 * For each RTE used in the query, we must assign column aliases that are
190 * unique within that RTE. SQL does not require this of the original query,
191 * but due to factors such as *-expansion we need to be able to uniquely
192 * reference every column in a decompiled query. As long as we qualify all
193 * column references, per-RTE uniqueness is sufficient for that.
194 *
195 * However, we can't ensure per-column name uniqueness for unnamed join RTEs,
196 * since they just inherit column names from their input RTEs, and we can't
197 * rename the columns at the join level. Most of the time this isn't an issue
198 * because we don't need to reference the join's output columns as such; we
199 * can reference the input columns instead. That approach can fail for merged
200 * JOIN USING columns, however, so when we have one of those in an unnamed
201 * join, we have to make that column's alias globally unique across the whole
202 * query to ensure it can be referenced unambiguously.
203 *
204 * Another problem is that a JOIN USING clause requires the columns to be
205 * merged to have the same aliases in both input RTEs, and that no other
206 * columns in those RTEs or their children conflict with the USING names.
207 * To handle that, we do USING-column alias assignment in a recursive
208 * traversal of the query's jointree. When descending through a JOIN with
209 * USING, we preassign the USING column names to the child columns, overriding
210 * other rules for column alias assignment. We also mark each RTE with a list
211 * of all USING column names selected for joins containing that RTE, so that
212 * when we assign other columns' aliases later, we can avoid conflicts.
213 *
214 * Another problem is that if a JOIN's input tables have had columns added or
215 * deleted since the query was parsed, we must generate a column alias list
216 * for the join that matches the current set of input columns --- otherwise, a
217 * change in the number of columns in the left input would throw off matching
218 * of aliases to columns of the right input. Thus, positions in the printable
219 * column alias list are not necessarily one-for-one with varattnos of the
220 * JOIN, so we need a separate new_colnames[] array for printing purposes.
221 */
223 {
224 /*
225 * colnames is an array containing column aliases to use for columns that
226 * existed when the query was parsed. Dropped columns have NULL entries.
227 * This array can be directly indexed by varattno to get a Var's name.
228 *
229 * Non-NULL entries are guaranteed unique within the RTE, *except* when
230 * this is for an unnamed JOIN RTE. In that case we merely copy up names
231 * from the two input RTEs.
232 *
233 * During the recursive descent in set_using_names(), forcible assignment
234 * of a child RTE's column name is represented by pre-setting that element
235 * of the child's colnames array. So at that stage, NULL entries in this
236 * array just mean that no name has been preassigned, not necessarily that
237 * the column is dropped.
238 */
242 /*
243 * new_colnames is an array containing column aliases to use for columns
244 * that would exist if the query was re-parsed against the current
245 * definitions of its base tables. This is what to print as the column
246 * alias list for the RTE. This array does not include dropped columns,
247 * but it will include columns added since original parsing. Indexes in
248 * it therefore have little to do with current varattno values. As above,
249 * entries are unique unless this is for an unnamed JOIN RTE. (In such an
250 * RTE, we never actually print this array, but we must compute it anyway
251 * for possible use in computing column names of upper joins.) The
252 * parallel array is_new_col marks which of these columns are new since
253 * original parsing. Entries with is_new_col false must match the
254 * non-NULL colnames entries one-for-one.
255 */
260 /* This flag tells whether we should actually print a column alias list */
263 /* This list has all names used as USING names in joins above this RTE */
266 /*
267 * If this struct is for a JOIN RTE, we fill these fields during the
268 * set_using_names() pass to describe its relationship to its child RTEs.
269 *
270 * leftattnos and rightattnos are arrays with one entry per existing
271 * output column of the join (hence, indexable by join varattno). For a
272 * simple reference to a column of the left child, leftattnos[i] is the
273 * child RTE's attno and rightattnos[i] is zero; and conversely for a
274 * column of the right child. But for merged columns produced by JOIN
275 * USING/NATURAL JOIN, both leftattnos[i] and rightattnos[i] are nonzero.
276 * Note that a simple reference might be to a child RTE column that's been
277 * dropped; but that's OK since the column could not be used in the query.
278 *
279 * If it's a JOIN USING, usingNames holds the alias names selected for the
280 * merged columns (these might be different from the original USING list,
281 * if we had to modify names to achieve uniqueness).
282 */
290 /* This macro is analogous to rt_fetch(), but for deparse_columns structs */
291 #define deparse_columns_fetch(rangetable_index, dpns) \
292 ((deparse_columns *) list_nth((dpns)->rtable_columns, (rangetable_index)-1))
294 /*
295 * Entry in set_rtable_names' hash table
296 */
298 {
303 /* Callback signature for resolve_special_varno() */
308 /* ----------
309 * Global data
310 * ----------
311 */
315 static const char *query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";
317 /* GUC parameters */
321 /* ----------
322 * Local functions
323 *
324 * Most of these functions used to use fixed-size buffers to build their
325 * results. Now, they take an (already initialized) StringInfo object
326 * as a parameter, and append their text output to its contents.
327 * ----------
328 */
336 StringInfo buf);
393 TupleDesc resultDesc,
398 TupleDesc resultDesc);
407 TupleDesc resultDesc);
409 TupleDesc resultDesc);
412 TupleDesc resultDesc);
475 StringInfo buf);
484 ParseExprKind special_exprkind);
495 /* ----------
496 * pg_get_ruledef - Do it all and return a text
497 * that could be used as a statement
498 * to recreate the rule
499 * ----------
500 */
501 Datum
503 {
516 }
519 Datum
521 {
527 prettyFlags = pretty ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) : PRETTYFLAG_INDENT;
535 }
540 {
544 HeapTuple ruletup;
545 TupleDesc rulettc;
546 StringInfoData buf;
548 /*
549 * Do this first so that string is alloc'd in outer context not SPI's.
550 */
553 /*
554 * Connect to SPI manager
555 */
559 /*
560 * On the first call prepare the plan to lookup pg_rewrite. We read
561 * pg_rewrite over the SPI manager instead of using the syscache to be
562 * checked for read access on pg_rewrite.
563 */
565 {
567 SPIPlanPtr plan;
575 }
577 /*
578 * Get the pg_rewrite tuple for this rule
579 */
586 {
587 /*
588 * There is no tuple data available here, just keep the output buffer
589 * empty.
590 */
591 }
592 else
593 {
594 /*
595 * Get the rule's definition and put it into executor's memory
596 */
600 }
602 /*
603 * Disconnect from SPI manager
604 */
612 }
615 /* ----------
616 * pg_get_viewdef - Mainly the same thing, but we
617 * only return the SELECT part of a view
618 * ----------
619 */
620 Datum
622 {
623 /* By OID */
636 }
639 Datum
641 {
642 /* By OID */
648 prettyFlags = pretty ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) : PRETTYFLAG_INDENT;
656 }
658 Datum
660 {
661 /* By OID */
667 /* calling this implies we want pretty printing */
676 }
678 Datum
680 {
681 /* By qualified name */
685 Oid viewoid;
690 /* Look up view name. Can't lock it - we might not have privileges. */
700 }
703 Datum
705 {
706 /* By qualified name */
711 Oid viewoid;
714 prettyFlags = pretty ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) : PRETTYFLAG_INDENT;
716 /* Look up view name. Can't lock it - we might not have privileges. */
726 }
728 /*
729 * Common code for by-OID and by-name variants of pg_get_viewdef
730 */
733 {
737 HeapTuple ruletup;
738 TupleDesc rulettc;
739 StringInfoData buf;
741 /*
742 * Do this first so that string is alloc'd in outer context not SPI's.
743 */
746 /*
747 * Connect to SPI manager
748 */
752 /*
753 * On the first call prepare the plan to lookup pg_rewrite. We read
754 * pg_rewrite over the SPI manager instead of using the syscache to be
755 * checked for read access on pg_rewrite.
756 */
758 {
760 SPIPlanPtr plan;
769 }
771 /*
772 * Get the pg_rewrite tuple for the view's SELECT rule
773 */
782 {
783 /*
784 * There is no tuple data available here, just keep the output buffer
785 * empty.
786 */
787 }
788 else
789 {
790 /*
791 * Get the rule's definition and put it into executor's memory
792 */
796 }
798 /*
799 * Disconnect from SPI manager
800 */
808 }
810 /* ----------
811 * pg_get_triggerdef - Get the definition of a trigger
812 * ----------
813 */
814 Datum
816 {
826 }
828 Datum
830 {
841 }
845 {
846 HeapTuple ht_trig;
847 Form_pg_trigger trigrec;
848 StringInfoData buf;
849 Relation tgrel;
851 SysScanDesc tgscan;
856 Datum value;
859 /*
860 * Fetch the pg_trigger tuple by the Oid of the trigger
861 */
865 Anum_pg_trigger_oid,
875 {
879 }
883 /*
884 * Start the trigger definition. Note that the trigger's name should never
885 * be schema-qualified, but the trigger rel's name may be.
886 */
900 else
904 {
906 findx++;
907 }
909 {
912 else
914 findx++;
915 }
917 {
920 else
922 findx++;
923 /* tgattr is first var-width field, so OK to access directly */
925 {
930 {
938 }
939 }
940 }
942 {
945 else
947 findx++;
948 }
950 /*
951 * In non-pretty mode, always schema-qualify the target table name for
952 * safety. In pretty mode, schema-qualify only if not visible.
953 */
955 pretty ?
960 {
969 else
971 }
977 else
983 else
986 {
994 }
998 else
1001 /* If the trigger has a WHEN qualification, add that */
1005 {
1008 deparse_context context;
1009 deparse_namespace dpns;
1019 /* Build minimal OLD and NEW RTEs for the rel */
1042 /* Build two-element rtable */
1051 /* Set up context with one-deep namespace stack */
1057 context.prettyFlags = pretty ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) : PRETTYFLAG_INDENT;
1066 }
1074 {
1084 {
1088 /* advance p to next string embedded in tgargs */
1090 p++;
1091 p++;
1092 }
1093 }
1095 /* We deliberately do not put semi-colon at end */
1098 /* Clean up */
1104 }
1106 /* ----------
1107 * pg_get_indexdef - Get the definition of an index
1108 *
1109 * In the extended version, there is a colno argument as well as pretty bool.
1110 * if colno == 0, we want a complete index definition.
1111 * if colno > 0, we only want the Nth index key's variable or expression.
1112 *
1113 * Note that the SQL-function versions of this omit any info about the
1114 * index tablespace; this is intentional because pg_dump wants it that way.
1115 * However pg_get_indexdef_string() includes the index tablespace.
1116 * ----------
1117 */
1118 Datum
1120 {
1136 }
1138 Datum
1140 {
1147 prettyFlags = pretty ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) : PRETTYFLAG_INDENT;
1158 }
1160 /*
1161 * Internal version for use by ALTER TABLE.
1162 * Includes a tablespace clause in the result.
1163 * Returns a palloc'd C string; no pretty-printing.
1164 */
1167 {
1172 }
1174 /* Internal version that just reports the key-column definitions */
1177 {
1180 prettyFlags = pretty ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) : PRETTYFLAG_INDENT;
1186 }
1188 /*
1189 * Internal workhorse to decompile an index definition.
1190 *
1191 * This is now used for exclusion constraints as well: if excludeOps is not
1192 * NULL then it points to an array of exclusion operator OIDs.
1193 */
1200 {
1201 /* might want a separate isConstraint parameter later */
1203 HeapTuple ht_idx;
1204 HeapTuple ht_idxrel;
1205 HeapTuple ht_am;
1206 Form_pg_index idxrec;
1207 Form_pg_class idxrelrec;
1208 Form_pg_am amrec;
1213 Oid indrelid;
1215 Datum indcollDatum;
1216 Datum indclassDatum;
1217 Datum indoptionDatum;
1222 StringInfoData buf;
1226 /*
1227 * Fetch the pg_index tuple by the Oid of the index
1228 */
1231 {
1235 }
1241 /* Must get indcollation, indclass, and indoption the hard way */
1257 /*
1258 * Fetch the pg_class tuple of the index relation
1259 */
1265 /*
1266 * Fetch the pg_am tuple of the index' access method
1267 */
1274 /* Fetch the index AM's API struct */
1277 /*
1278 * Get the index expressions, if any. (NOTE: we do not use the relcache
1279 * versions of the expressions and predicate, because we want to display
1280 * non-const-folded expressions.)
1281 */
1283 {
1284 Datum exprsDatum;
1294 }
1295 else
1302 /*
1303 * Start the index definition. Note that the index's name should never be
1304 * schema-qualified, but the indexed rel's name may be.
1305 */
1309 {
1323 }
1325 /*
1326 * Report the indexed attributes
1327 */
1330 {
1332 Oid keycoltype;
1333 Oid keycolcollation;
1335 /*
1336 * Ignore non-key attributes if told to.
1337 */
1341 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1343 {
1346 }
1353 {
1354 /* Simple index column */
1356 int32 keycoltypmod;
1364 }
1365 else
1366 {
1367 /* expressional index */
1374 /* Deparse */
1378 {
1379 /* Need parens if it's not a bare function call */
1382 else
1384 }
1387 }
1389 /* Print additional decoration for (selected) key columns */
1392 {
1398 /* Add collation, if not default for column */
1403 /* Add the operator class name, if not default */
1408 {
1412 }
1414 /* Add options if relevant */
1416 {
1417 /* if it supports sort ordering, report DESC and NULLS opts */
1419 {
1421 /* NULLS FIRST is the default in this case */
1424 }
1425 else
1426 {
1429 }
1430 }
1432 /* Add the exclusion operator if relevant */
1436 keycoltype,
1437 keycoltype));
1438 }
1439 }
1442 {
1445 /*
1446 * If it has options, append "WITH (options)"
1447 */
1450 {
1453 }
1455 /*
1456 * Print tablespace, but only if requested
1457 */
1459 {
1460 Oid tblspc;
1464 {
1469 }
1470 }
1472 /*
1473 * If it's a partial index, decompile and append the predicate
1474 */
1476 {
1478 Datum predDatum;
1482 /* Convert text string to node tree */
1490 /* Deparse */
1495 else
1497 }
1498 }
1500 /* Clean up */
1506 }
1508 /*
1509 * pg_get_statisticsobjdef
1510 * Get the definition of an extended statistics object
1511 */
1512 Datum
1514 {
1524 }
1526 /*
1527 * Internal version for use by ALTER TABLE.
1528 * Includes a tablespace clause in the result.
1529 * Returns a palloc'd C string; no pretty-printing.
1530 */
1533 {
1535 }
1537 /*
1538 * pg_get_statisticsobjdef_columns
1539 * Get columns and expressions for an extended statistics object
1540 */
1541 Datum
1543 {
1553 }
1555 /*
1556 * Internal workhorse to decompile an extended statistics object.
1557 */
1560 {
1561 Form_pg_statistic_ext statextrec;
1562 HeapTuple statexttup;
1563 StringInfoData buf;
1568 Datum datum;
1583 {
1587 }
1589 /* has the statistics expressions? */
1594 /*
1595 * Get the statistics expressions, if any. (NOTE: we do not use the
1596 * relcache versions of the expressions, because we want to display
1597 * non-const-folded expressions.)
1598 */
1600 {
1601 Datum exprsDatum;
1611 }
1612 else
1615 /* count the number of columns (attributes and expressions) */
1621 {
1627 /*
1628 * Decode the stxkind column so that we know which stats types to
1629 * print.
1630 */
1646 {
1654 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
1655 }
1657 /*
1658 * If any option is disabled, then we'll need to append the types
1659 * clause to show which options are enabled. We omit the types clause
1660 * on purpose when all options are enabled, so a pg_dump/pg_restore
1661 * will create all statistics types on a newer postgres version, if
1662 * the statistics had all options enabled on the original version.
1663 *
1664 * But if the statistics is defined on just a single column, it has to
1665 * be an expression statistics. In that case we don't need to specify
1666 * kinds.
1667 */
1670 {
1676 {
1679 }
1682 {
1685 }
1691 }
1694 }
1696 /* decode simple column references */
1698 {
1708 }
1714 {
1725 /* Need parens if it's not a bare function call */
1728 else
1731 colno++;
1732 }
1741 }
1743 /*
1744 * Generate text array of expressions for statistics object.
1745 */
1746 Datum
1748 {
1750 Form_pg_statistic_ext statextrec;
1751 HeapTuple statexttup;
1752 Datum datum;
1766 /* Does the stats object have expressions? */
1769 /* no expressions? we're done */
1771 {
1774 }
1778 /*
1779 * Get the statistics expressions, and deparse them into text values.
1780 */
1793 {
1804 TEXTOID,
1805 CurrentMemoryContext);
1806 }
1811 }
1813 /*
1814 * pg_get_partkeydef
1815 *
1816 * Returns the partition key specification, ie, the following:
1817 *
1818 * PARTITION BY { RANGE | LIST | HASH } (column opt_collation opt_opclass [, ...])
1819 */
1820 Datum
1822 {
1832 }
1834 /* Internal version that just reports the column definitions */
1837 {
1840 prettyFlags = pretty ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) : PRETTYFLAG_INDENT;
1843 }
1845 /*
1846 * Internal workhorse to decompile a partition key definition.
1847 */
1851 {
1852 Form_pg_partitioned_table form;
1853 HeapTuple tuple;
1859 Datum datum;
1861 StringInfoData buf;
1868 {
1872 }
1878 /* Must get partclass and partcollation the hard way */
1890 /*
1891 * Get the expressions, if any. (NOTE: we do not use the relcache
1892 * versions of the expressions, because we want to display
1893 * non-const-folded expressions.)
1894 */
1896 {
1897 Datum exprsDatum;
1912 }
1913 else
1922 {
1938 }
1944 {
1946 Oid keycoltype;
1947 Oid keycolcollation;
1948 Oid partcoll;
1953 {
1954 /* Simple attribute reference */
1956 int32 keycoltypmod;
1963 }
1964 else
1965 {
1966 /* Expression */
1974 /* Deparse */
1977 /* Need parens if it's not a bare function call */
1980 else
1985 }
1987 /* Add collation, if not default for column */
1993 /* Add the operator class name, if not default */
1996 }
2001 /* Clean up */
2005 }
2007 /*
2008 * pg_get_partition_constraintdef
2009 *
2010 * Returns partition constraint expression as a string for the input relation
2011 */
2012 Datum
2014 {
2023 /* Quick exit if no partition constraint */
2027 /*
2028 * Deparse and return the constraint expression.
2029 */
2036 }
2038 /*
2039 * pg_get_partconstrdef_string
2040 *
2041 * Returns the partition constraint as a C-string for the input relation, with
2042 * the given alias. No pretty-printing.
2043 */
2046 {
2054 }
2056 /*
2057 * pg_get_constraintdef
2058 *
2059 * Returns the definition for the constraint, ie, everything that needs to
2060 * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
2061 */
2062 Datum
2064 {
2077 }
2079 Datum
2081 {
2087 prettyFlags = pretty ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) : PRETTYFLAG_INDENT;
2095 }
2097 /*
2098 * Internal version that returns a full ALTER TABLE ... ADD CONSTRAINT command
2099 */
2102 {
2104 }
2106 /*
2107 * As of 9.4, we now use an MVCC snapshot for this.
2108 */
2112 {
2113 HeapTuple tup;
2114 Form_pg_constraint conForm;
2115 StringInfoData buf;
2116 SysScanDesc scandesc;
2122 Anum_pg_constraint_oid,
2127 ConstraintOidIndexId,
2129 snapshot,
2131 scankey);
2133 /*
2134 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2135 * via SearchSysCache, which works fine.
2136 */
2142 {
2144 {
2148 }
2150 }
2157 {
2159 {
2160 /*
2161 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2162 * constraints, and other types of constraints don't inherit
2163 * anyway so it doesn't matter whether we say ONLY or not. Someday
2164 * we might need to let callers specify whether to put ONLY in the
2165 * command.
2166 */
2170 }
2171 else
2172 {
2173 /* Must be a domain constraint */
2178 }
2179 }
2182 {
2184 {
2185 Datum val;
2189 /* Start off the constraint definition */
2192 /* Fetch and build referencing-column list */
2197 constraintId);
2201 /* add foreign relation name */
2204 NIL));
2206 /* Fetch and build referenced-column list */
2211 constraintId);
2217 /* Add match type */
2219 {
2234 }
2237 /* Add ON UPDATE and ON DELETE clauses, if needed */
2239 {
2260 }
2265 {
2286 }
2290 /* Add columns specified to SET NULL or SET DEFAULT if provided. */
2294 {
2298 }
2301 }
2304 {
2305 Datum val;
2307 Oid indexId;
2309 HeapTuple indtup;
2311 /* Start off the constraint definition */
2314 else
2317 /* Fetch and build target column list */
2322 constraintId);
2330 /* Build including column list (from pg_index.indkeys) */
2339 {
2340 Datum cols;
2357 {
2365 }
2368 }
2371 /* XXX why do we only print these bits if fullCommand? */
2373 {
2375 Oid tblspc;
2378 {
2381 }
2383 /*
2384 * Print the tablespace, unless it's the database default.
2385 * This is to help ALTER TABLE usage of this facility,
2386 * which needs this behavior to recreate exact catalog
2387 * state.
2388 */
2393 }
2396 }
2398 {
2399 Datum val;
2406 /* Fetch constraint expression in parsetree form */
2411 constraintId);
2416 /* Set up deparsing context for Var nodes in constraint */
2418 {
2419 /* relation constraint */
2422 }
2423 else
2424 {
2425 /* domain constraint --- can't have Vars */
2427 }
2432 /*
2433 * Now emit the constraint definition, adding NO INHERIT if
2434 * necessary.
2435 *
2436 * There are cases where the constraint expression will be
2437 * fully parenthesized and we don't need the outer parens ...
2438 * but there are other cases where we do need 'em. Be
2439 * conservative for now.
2440 *
2441 * Note that simply checking for leading '(' and trailing ')'
2442 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2443 */
2445 consrc,
2448 }
2451 /*
2452 * There isn't an ALTER TABLE syntax for creating a user-defined
2453 * constraint trigger, but it seems better to print something than
2454 * throw an error; if we throw error then this function couldn't
2455 * safely be applied to all rows of pg_constraint.
2456 */
2460 {
2462 Datum val;
2469 /* Extract operator OIDs from the pg_constraint tuple */
2471 Anum_pg_constraint_conexclop,
2475 constraintId);
2485 /* pg_get_indexdef_worker does the rest */
2486 /* suppress tablespace because pg_dump wants it that way */
2490 operators,
2495 prettyFlags,
2498 }
2502 }
2511 /* Cleanup */
2516 }
2519 /*
2520 * Convert an int16[] Datum into a comma-separated list of column names
2521 * for the indicated relation; append the list to buf. Returns the number
2522 * of keys.
2523 */
2524 static int
2526 StringInfo buf)
2527 {
2532 /* Extract data from array of int16 */
2538 {
2545 else
2547 }
2550 }
2553 /* ----------
2554 * pg_get_expr - Decompile an expression tree
2555 *
2556 * Input: an expression tree in nodeToString form, and a relation OID
2557 *
2558 * Output: reverse-listed expression
2559 *
2560 * Currently, the expression can only refer to a single relation, namely
2561 * the one specified by the second parameter. This is sufficient for
2562 * partial indexes, column default expressions, etc. We also support
2563 * Var-free expressions, for which the OID can be InvalidOid.
2564 * ----------
2565 */
2566 Datum
2568 {
2577 {
2578 /* Get the name for the relation */
2581 /*
2582 * If the OID isn't actually valid, don't throw an error, just return
2583 * NULL. This is a bit questionable, but it's what we've done
2584 * historically, and it can help avoid unwanted failures when
2585 * examining catalog entries for just-deleted relations.
2586 */
2589 }
2590 else
2594 }
2596 Datum
2598 {
2605 prettyFlags = pretty ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) : PRETTYFLAG_INDENT;
2608 {
2609 /* Get the name for the relation */
2611 /* See notes above */
2614 }
2615 else
2619 }
2623 {
2629 /* Convert input TEXT object to C string */
2632 /* Convert expression to node tree */
2637 /* Prepare deparse context if needed */
2640 else
2643 /* Deparse */
2648 }
2651 /* ----------
2652 * pg_get_userbyid - Get a user name by roleid and
2653 * fallback to 'unknown (OID=n)'
2654 * ----------
2655 */
2656 Datum
2658 {
2660 Name result;
2661 HeapTuple roletup;
2662 Form_pg_authid role_rec;
2664 /*
2665 * Allocate space for the result
2666 */
2670 /*
2671 * Get the pg_authid entry and print the result
2672 */
2675 {
2679 }
2680 else
2684 }
2687 /*
2688 * pg_get_serial_sequence
2689 * Get the name of the sequence used by an identity or serial column,
2690 * formatted suitably for passing to setval, nextval or currval.
2691 * First parameter is not treated as double-quoted, second parameter
2692 * is --- see documentation for reason.
2693 */
2694 Datum
2696 {
2700 Oid tableOid;
2702 AttrNumber attnum;
2704 Relation depRel;
2706 SysScanDesc scan;
2707 HeapTuple tup;
2709 /* Look up table name. Can't lock it - we might not have privileges. */
2713 /* Get the number of the column */
2723 /* Search the dependency table for the dependent sequence */
2727 Anum_pg_depend_refclassid,
2731 Anum_pg_depend_refobjid,
2735 Anum_pg_depend_refobjsubid,
2743 {
2746 /*
2747 * Look for an auto dependency (serial column) or internal dependency
2748 * (identity column) of a sequence on a column. (We need the relkind
2749 * test because indexes can also have auto dependencies on columns.)
2750 */
2756 {
2759 }
2760 }
2766 {
2772 }
2775 }
2778 /*
2779 * pg_get_functiondef
2780 * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
2781 * the specified function.
2782 *
2783 * Note: if you change the output format of this function, be careful not
2784 * to break psql's rules (in \ef and \sf) for identifying the start of the
2785 * function body. To wit: the function body starts on a line that begins
2786 * with "AS ", and no preceding line will look like that.
2787 */
2788 Datum
2790 {
2792 StringInfoData buf;
2793 StringInfoData dq;
2794 HeapTuple proctup;
2795 Form_pg_proc proc;
2797 Datum tmp;
2802 float4 procost;
2807 /* Look up the function */
2822 /*
2823 * We always qualify the function name, to ensure the right function gets
2824 * replaced.
2825 */
2833 {
2837 }
2844 /* Emit some miscellaneous options on one line */
2850 {
2859 }
2862 {
2871 }
2880 /* This code for the default cost and rows should match functioncmds.c */
2884 else
2893 {
2896 /*
2897 * We should qualify the support function's name if it wouldn't be
2898 * resolved by lookup in the current search path.
2899 */
2905 }
2910 /* Emit any proconfig options, one per line */
2913 {
2922 {
2923 Datum d;
2932 {
2944 /*
2945 * Variables that are marked GUC_LIST_QUOTE were already fully
2946 * quoted by flatten_set_variable_args() before they were put
2947 * into the proconfig array. However, because the quoting
2948 * rules used there aren't exactly like SQL's, we have to
2949 * break the list value apart and then quote the elements as
2950 * string literals. (The elements may be double-quoted as-is,
2951 * but we can't just feed them to the SQL parser; it would do
2952 * the wrong thing with elements that are zero-length or
2953 * longer than NAMEDATALEN.)
2954 *
2955 * Variables that are not so marked should just be emitted as
2956 * simple string literals. If the variable is not known to
2957 * guc.c, we'll do that; this makes it unsafe to use
2958 * GUC_LIST_QUOTE for extension variables.
2959 */
2961 {
2965 /* Parse string into list of identifiers */
2967 {
2968 /* this shouldn't fail really */
2970 }
2972 {
2978 }
2979 }
2980 else
2983 }
2984 }
2985 }
2987 /* And finally the function definition ... */
2990 {
2992 }
2993 else
2994 {
2999 {
3002 }
3009 /*
3010 * We always use dollar quoting. Figure out a suitable delimiter.
3011 *
3012 * Since the user is likely to be editing the function body string, we
3013 * shouldn't use a short delimiter that he might easily create a
3014 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3015 * if needed.
3016 */
3027 }
3034 }
3036 /*
3037 * pg_get_function_arguments
3038 * Get a nicely-formatted list of arguments for a function.
3039 * This is everything that would go between the parentheses in
3040 * CREATE FUNCTION.
3041 */
3042 Datum
3044 {
3046 StringInfoData buf;
3047 HeapTuple proctup;
3060 }
3062 /*
3063 * pg_get_function_identity_arguments
3064 * Get a formatted list of arguments for a function.
3065 * This is everything that would go between the parentheses in
3066 * ALTER FUNCTION, etc. In particular, don't print defaults.
3067 */
3068 Datum
3070 {
3072 StringInfoData buf;
3073 HeapTuple proctup;
3086 }
3088 /*
3089 * pg_get_function_result
3090 * Get a nicely-formatted version of the result type of a function.
3091 * This is what would appear after RETURNS in CREATE FUNCTION.
3092 */
3093 Datum
3095 {
3097 StringInfoData buf;
3098 HeapTuple proctup;
3105 {
3108 }
3117 }
3119 /*
3120 * Guts of pg_get_function_result: append the function's return type
3121 * to the specified buffer.
3122 */
3123 static void
3125 {
3128 StringInfoData rbuf;
3133 {
3134 /* It might be a table function; try to print the arguments */
3139 else
3141 }
3144 {
3145 /* Not a table function, so do the normal thing */
3149 }
3152 }
3154 /*
3155 * Common code for pg_get_function_arguments and pg_get_function_result:
3156 * append the desired subset of arguments to buf. We print only TABLE
3157 * arguments when print_table_args is true, and all the others when it's false.
3158 * We print argument defaults only if print_defaults is true.
3159 * Function return value is the number of arguments printed.
3160 */
3161 static int
3164 {
3183 {
3184 Datum proargdefaults;
3188 Anum_pg_proc_proargdefaults,
3191 {
3198 /* nlackdefaults counts only *input* arguments lacking defaults */
3200 }
3201 }
3203 /* Check for special treatment of ordered-set aggregates */
3205 {
3206 HeapTuple aggtup;
3207 Form_pg_aggregate agg;
3217 }
3222 {
3230 {
3233 /*
3234 * For procedures, explicitly mark all argument modes, so as
3235 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3236 */
3239 else
3264 }
3272 {
3276 }
3285 {
3294 }
3295 argsprinted++;
3297 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3299 {
3300 i--;
3301 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3303 }
3304 }
3307 }
3309 static bool
3311 {
3316 }
3318 /*
3319 * Append used transformed types to specified buffer
3320 */
3321 static void
3323 {
3329 {
3334 {
3338 }
3340 }
3341 }
3343 /*
3344 * Get textual representation of a function argument's default value. The
3345 * second argument of this function is the argument number among all arguments
3346 * (i.e. proallargtypes, *not* proargtypes), starting with 1, because that's
3347 * how information_schema.sql uses it.
3348 */
3349 Datum
3351 {
3354 HeapTuple proctup;
3355 Form_pg_proc proc;
3365 Datum proargdefaults;
3375 {
3378 }
3383 nth_inputarg++;
3386 Anum_pg_proc_proargdefaults,
3389 {
3392 }
3400 /*
3401 * Calculate index into proargdefaults: proargdefaults corresponds to the
3402 * last N input arguments, where N = pronargdefaults.
3403 */
3407 {
3410 }
3417 }
3419 static void
3421 {
3427 Datum tmp;
3442 {
3451 {
3454 /* It seems advisable to get at least AccessShareLock on rels */
3460 }
3463 }
3464 else
3465 {
3468 /* It seems advisable to get at least AccessShareLock on rels */
3472 }
3473 }
3475 Datum
3477 {
3479 StringInfoData buf;
3480 HeapTuple proctup;
3485 /* Look up the function */
3492 {
3495 }
3502 }
3505 /*
3506 * deparse_expression - General utility for deparsing expressions
3507 *
3508 * calls deparse_expression_pretty with all prettyPrinting disabled
3509 */
3513 {
3516 }
3518 /* ----------
3519 * deparse_expression_pretty - General utility for deparsing expressions
3520 *
3521 * expr is the node tree to be deparsed. It must be a transformed expression
3522 * tree (ie, not the raw output of gram.y).
3523 *
3524 * dpcontext is a list of deparse_namespace nodes representing the context
3525 * for interpreting Vars in the node tree. It can be NIL if no Vars are
3526 * expected.
3527 *
3528 * forceprefix is true to force all Vars to be prefixed with their table names.
3529 *
3530 * showimplicit is true to force all implicit casts to be shown explicitly.
3531 *
3532 * Tries to pretty up the output according to prettyFlags and startIndent.
3533 *
3534 * The result is a palloc'd string.
3535 * ----------
3536 */
3541 {
3542 StringInfoData buf;
3543 deparse_context context;
3560 }
3562 /* ----------
3563 * deparse_context_for - Build deparse context for a single relation
3564 *
3565 * Given the reference name (alias) and OID of a relation, build deparsing
3566 * context for an expression referencing only that relation (as varno 1,
3567 * varlevelsup 0). This is sufficient for many uses of deparse_expression.
3568 * ----------
3569 */
3570 List *
3572 {
3578 /* Build a minimal RTE for the rel */
3590 /* Build one-element rtable */
3598 /* Return a one-deep namespace stack */
3600 }
3602 /*
3603 * deparse_context_for_plan_tree - Build deparse context for a Plan tree
3604 *
3605 * When deparsing an expression in a Plan tree, we use the plan's rangetable
3606 * to resolve names of simple Vars. The initialization of column names for
3607 * this is rather expensive if the rangetable is large, and it'll be the same
3608 * for every expression in the Plan tree; so we do it just once and re-use
3609 * the result of this function for each expression. (Note that the result
3610 * is not usable until set_deparse_context_plan() is applied to it.)
3611 *
3612 * In addition to the PlannedStmt, pass the per-RTE alias names
3613 * assigned by a previous call to select_rtable_names_for_explain.
3614 */
3615 List *
3617 {
3622 /* Initialize fields that stay the same across the whole plan tree */
3628 {
3629 /* Set up the array, indexed by child relid */
3636 {
3643 }
3644 }
3645 else
3648 /*
3649 * Set up column name aliases. We will get rather bogus results for join
3650 * RTEs, but that doesn't matter because plan trees don't contain any join
3651 * alias Vars.
3652 */
3655 /* Return a one-deep namespace stack */
3657 }
3659 /*
3660 * set_deparse_context_plan - Specify Plan node containing expression
3661 *
3662 * When deparsing an expression in a Plan tree, we might have to resolve
3663 * OUTER_VAR, INNER_VAR, or INDEX_VAR references. To do this, the caller must
3664 * provide the parent Plan node. Then OUTER_VAR and INNER_VAR references
3665 * can be resolved by drilling down into the left and right child plans.
3666 * Similarly, INDEX_VAR references can be resolved by reference to the
3667 * indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
3668 * ForeignScan and CustomScan nodes. (Note that we don't currently support
3669 * deparsing of indexquals in regular IndexScan or BitmapIndexScan nodes;
3670 * for those, we can only deparse the indexqualorig fields, which won't
3671 * contain INDEX_VAR Vars.)
3672 *
3673 * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
3674 * the most-closely-nested first. This is needed to resolve PARAM_EXEC
3675 * Params. Note we assume that all the Plan nodes share the same rtable.
3676 *
3677 * Once this function has been called, deparse_expression() can be called on
3678 * subsidiary expression(s) of the specified Plan node. To deparse
3679 * expressions of a different Plan node in the same Plan tree, re-call this
3680 * function to identify the new parent Plan node.
3681 *
3682 * The result is the same List passed in; this is a notational convenience.
3683 */
3684 List *
3686 {
3689 /* Should always have one-entry namespace list for Plan deparsing */
3693 /* Set our attention on the specific plan node passed in */
3698 }
3700 /*
3701 * select_rtable_names_for_explain - Select RTE aliases for EXPLAIN
3702 *
3703 * Determine the relation aliases we'll use during an EXPLAIN operation.
3704 * This is just a frontend to set_rtable_names. We have to expose the aliases
3705 * to EXPLAIN because EXPLAIN needs to know the right alias names to print.
3706 */
3707 List *
3709 {
3710 deparse_namespace dpns;
3718 /* We needn't bother computing column aliases yet */
3721 }
3723 /*
3724 * set_rtable_names: select RTE aliases to be used in printing a query
3725 *
3726 * We fill in dpns->rtable_names with a list of names that is one-for-one with
3727 * the already-filled dpns->rtable list. Each RTE name is unique among those
3728 * in the new namespace plus any ancestor namespaces listed in
3729 * parent_namespaces.
3730 *
3731 * If rels_used isn't NULL, only RTE indexes listed in it are given aliases.
3732 *
3733 * Note that this function is only concerned with relation names, not column
3734 * names.
3735 */
3736 static void
3739 {
3740 HASHCTL hash_ctl;
3748 /* nothing more to do if empty rtable */
3752 /*
3753 * We use a hash table to hold known names, so that this process is O(N)
3754 * not O(N^2) for N names.
3755 */
3764 /* Preload the hash table with names appearing in parent_namespaces */
3766 {
3771 {
3777 oldname,
3778 HASH_ENTER,
3780 /* we do not complain about duplicate names in parent namespaces */
3782 }
3783 }
3785 /* Now we can scan the rtable */
3788 {
3792 /* Just in case this takes an unreasonable amount of time ... */
3796 {
3797 /* Ignore unreferenced RTE */
3799 }
3801 {
3802 /* If RTE has a user-defined alias, prefer that */
3804 }
3806 {
3807 /* Use the current actual name of the relation */
3809 }
3811 {
3812 /* Unnamed join has no refname */
3814 }
3815 else
3816 {
3817 /* Otherwise use whatever the parser assigned */
3819 }
3821 /*
3822 * If the selected name isn't unique, append digits to make it so, and
3823 * make a new hash entry for it once we've got a unique name. For a
3824 * very long input name, we might have to truncate to stay within
3825 * NAMEDATALEN.
3826 */
3828 {
3830 refname,
3831 HASH_ENTER,
3834 {
3835 /* Name already in use, must choose a new one */
3840 do
3841 {
3844 {
3849 /* drop chars from refname to keep all the digits */
3852 }
3854 modname,
3855 HASH_ENTER,
3860 }
3861 else
3862 {
3863 /* Name not previously used, need only initialize hentry */
3865 }
3866 }
3869 rtindex++;
3870 }
3873 }
3875 /*
3876 * set_deparse_for_query: set up deparse_namespace for deparsing a Query tree
3877 *
3878 * For convenience, this is defined to initialize the deparse_namespace struct
3879 * from scratch.
3880 */
3881 static void
3884 {
3888 /* Initialize *dpns and fill rtable/ctes links */
3895 /* Assign a unique relation alias to each RTE */
3898 /* Initialize dpns->rtable_columns to contain zeroed structs */
3904 /* If it's a utility query, it won't have a jointree */
3906 {
3907 /* Detect whether global uniqueness of USING names is needed */
3911 /*
3912 * Select names for columns merged by USING, via a recursive pass over
3913 * the query jointree.
3914 */
3916 }
3918 /*
3919 * Now assign remaining column aliases for each RTE. We do this in a
3920 * linear scan of the rtable, so as to process RTEs whether or not they
3921 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
3922 * etc). JOIN RTEs must be processed after their children, but this is
3923 * okay because they appear later in the rtable list than their children
3924 * (cf Asserts in identify_join_columns()).
3925 */
3927 {
3933 else
3935 }
3936 }
3938 /*
3939 * set_simple_column_names: fill in column aliases for non-query situations
3940 *
3941 * This handles EXPLAIN and cases where we only have relation RTEs. Without
3942 * a join tree, we can't do anything smart about join RTEs, but we don't
3943 * need to (note that EXPLAIN should never see join alias Vars anyway).
3944 * If we do hit a join RTE we'll just process it like a non-table base RTE.
3945 */
3946 static void
3948 {
3952 /* Initialize dpns->rtable_columns to contain zeroed structs */
3958 /* Assign unique column aliases within each RTE */
3960 {
3965 }
3966 }
3968 /*
3969 * has_dangerous_join_using: search jointree for unnamed JOIN USING
3970 *
3971 * Merged columns of a JOIN USING may act differently from either of the input
3972 * columns, either because they are merged with COALESCE (in a FULL JOIN) or
3973 * because an implicit coercion of the underlying input column is required.
3974 * In such a case the column must be referenced as a column of the JOIN not as
3975 * a column of either input. And this is problematic if the join is unnamed
3976 * (alias-less): we cannot qualify the column's name with an RTE name, since
3977 * there is none. (Forcibly assigning an alias to the join is not a solution,
3978 * since that will prevent legal references to tables below the join.)
3979 * To ensure that every column in the query is unambiguously referenceable,
3980 * we must assign such merged columns names that are globally unique across
3981 * the whole query, aliasing other columns out of the way as necessary.
3982 *
3983 * Because the ensuing re-aliasing is fairly damaging to the readability of
3984 * the query, we don't do this unless we have to. So, we must pre-scan
3985 * the join tree to see if we have to, before starting set_using_names().
3986 */
3987 static bool
3989 {
3991 {
3992 /* nothing to do here */
3993 }
3995 {
4000 {
4003 }
4004 }
4006 {
4009 /* Is it an unnamed JOIN with USING? */
4011 {
4012 /*
4013 * Yes, so check each join alias var to see if any of them are not
4014 * simple references to underlying columns. If so, we have a
4015 * dangerous situation and must pick unique aliases.
4016 */
4019 /* We need only examine the merged columns */
4021 {
4026 }
4027 }
4029 /* Nope, but inspect children */
4034 }
4035 else
4039 }
4041 /*
4042 * set_using_names: select column aliases to be used for merged USING columns
4043 *
4044 * We do this during a recursive descent of the query jointree.
4045 * dpns->unique_using must already be set to determine the global strategy.
4046 *
4047 * Column alias info is saved in the dpns->rtable_columns list, which is
4048 * assumed to be filled with pre-zeroed deparse_columns structs.
4049 *
4050 * parentUsing is a list of all USING aliases assigned in parent joins of
4051 * the current jointree node. (The passed-in list must not be modified.)
4052 */
4053 static void
4055 {
4057 {
4058 /* nothing to do now */
4059 }
4061 {
4067 }
4069 {
4080 /* Get info about the shape of the join */
4085 /* Look up the not-yet-filled-in child deparse_columns structs */
4089 /*
4090 * If this join is unnamed, then we cannot substitute new aliases at
4091 * this level, so any name requirements pushed down to here must be
4092 * pushed down again to the children.
4093 */
4095 {
4097 {
4103 /* Push down to left column, unless it's a system column */
4105 {
4108 }
4110 /* Same on the righthand side */
4112 {
4115 }
4116 }
4117 }
4119 /*
4120 * If there's a USING clause, select the USING column names and push
4121 * those names down to the children. We have two strategies:
4122 *
4123 * If dpns->unique_using is true, we force all USING names to be
4124 * unique across the whole query level. In principle we'd only need
4125 * the names of dangerous USING columns to be globally unique, but to
4126 * safely assign all USING names in a single pass, we have to enforce
4127 * the same uniqueness rule for all of them. However, if a USING
4128 * column's name has been pushed down from the parent, we should use
4129 * it as-is rather than making a uniqueness adjustment. This is
4130 * necessary when we're at an unnamed join, and it creates no risk of
4131 * ambiguity. Also, if there's a user-written output alias for a
4132 * merged column, we prefer to use that rather than the input name;
4133 * this simplifies the logic and seems likely to lead to less aliasing
4134 * overall.
4135 *
4136 * If dpns->unique_using is false, we only need USING names to be
4137 * unique within their own join RTE. We still need to honor
4138 * pushed-down names, though.
4139 *
4140 * Though significantly different in results, these two strategies are
4141 * implemented by the same code, with only the difference of whether
4142 * to put assigned names into dpns->using_names.
4143 */
4145 {
4146 /* Copy the input parentUsing list so we don't modify it */
4149 /* USING names must correspond to the first join output columns */
4153 {
4156 /* Assert it's a merged column */
4159 /* Adopt passed-down name if any, else select unique name */
4162 else
4163 {
4164 /* Prefer user-written output alias if any */
4167 /* Make it appropriately unique */
4171 colname);
4172 /* Save it as output column name, too */
4174 }
4176 /* Remember selected names for use later */
4180 /* Push down to left column, unless it's a system column */
4182 {
4185 }
4187 /* Same on the righthand side */
4189 {
4192 }
4194 i++;
4195 }
4196 }
4198 /* Mark child deparse_columns structs with correct parentUsing info */
4202 /* Now recursively assign USING column names in children */
4205 }
4206 else
4209 }
4211 /*
4212 * set_relation_column_names: select column aliases for a non-join RTE
4213 *
4214 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4215 * If any colnames entries are already filled in, those override local
4216 * choices.
4217 */
4218 static void
4221 {
4229 /*
4230 * Extract the RTE's "real" column names. This is comparable to
4231 * get_rte_attribute_name, except that it's important to disregard dropped
4232 * columns. We put NULL into the array for a dropped column.
4233 */
4235 {
4236 /* Relation --- look to the system catalogs for up-to-date info */
4237 Relation rel;
4238 TupleDesc tupdesc;
4247 {
4252 else
4254 }
4256 }
4257 else
4258 {
4259 /* Otherwise use the column names from eref */
4267 {
4268 /*
4269 * If the column name shown in eref is an empty string, then it's
4270 * a column that was dropped at the time of parsing the query, so
4271 * treat it as dropped.
4272 */
4278 i++;
4279 }
4280 }
4282 /*
4283 * Ensure colinfo->colnames has a slot for each column. (It could be long
4284 * enough already, if we pushed down a name for the last column.) Note:
4285 * it's possible that there are now more columns than there were when the
4286 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4287 * We must assign unique aliases to the new columns too, else there could
4288 * be unresolved conflicts when the view/rule is reloaded.
4289 */
4293 /*
4294 * Make sufficiently large new_colnames and is_new_col arrays, too.
4295 *
4296 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4297 * colname_is_unique will not consult that array, which is fine because it
4298 * would only be duplicate effort.
4299 */
4303 /*
4304 * Scan the columns, select a unique alias for each one, and store it in
4305 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4306 * entries for dropped columns, the latter omits them. Also mark
4307 * new_colnames entries as to whether they are new since parse time; this
4308 * is the case for entries beyond the length of rte->eref->colnames.
4309 */
4314 {
4318 /* Skip dropped columns */
4320 {
4323 }
4325 /* If alias already assigned, that's what to use */
4327 {
4328 /* If user wrote an alias, prefer that over real column name */
4331 else
4334 /* Unique-ify and insert into colinfo */
4338 }
4340 /* Put names of non-dropped columns in new_colnames[] too */
4342 /* And mark them as new or not */
4344 j++;
4346 /* Remember if any assigned aliases differ from "real" name */
4349 }
4351 /*
4352 * Set correct length for new_colnames[] array. (Note: if columns have
4353 * been added, colinfo->num_cols includes them, which is not really quite
4354 * right but is harmless, since any new columns must be at the end where
4355 * they won't affect varattnos of pre-existing columns.)
4356 */
4359 /*
4360 * For a relation RTE, we need only print the alias column names if any
4361 * are different from the underlying "real" names. For a function RTE,
4362 * always emit a complete column alias list; this is to protect against
4363 * possible instability of the default column names (eg, from altering
4364 * parameter names). For tablefunc RTEs, we never print aliases, because
4365 * the column names are part of the clause itself. For other RTE types,
4366 * print if we changed anything OR if there were user-written column
4367 * aliases (since the latter would be part of the underlying "reality").
4368 */
4377 else
4379 }
4381 /*
4382 * set_join_column_names: select column aliases for a join RTE
4383 *
4384 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4385 * If any colnames entries are already filled in, those override local
4386 * choices. Also, names for USING columns were already chosen by
4387 * set_using_names(). We further expect that column alias selection has been
4388 * completed for both input RTEs.
4389 */
4390 static void
4393 {
4406 /* Look up the previously-filled-in child deparse_columns structs */
4410 /*
4411 * Ensure colinfo->colnames has a slot for each column. (It could be long
4412 * enough already, if we pushed down a name for the last column.) Note:
4413 * it's possible that one or both inputs now have more columns than there
4414 * were when the query was parsed, but we'll deal with that below. We
4415 * only need entries in colnames for pre-existing columns.
4416 */
4421 /*
4422 * Scan the join output columns, select an alias for each one, and store
4423 * it in colinfo->colnames. If there are USING columns, set_using_names()
4424 * already selected their names, so we can start the loop at the first
4425 * non-merged column.
4426 */
4429 {
4433 /* Join column must refer to at least one input column */
4436 /* Get the child column name */
4441 else
4442 {
4443 /* We're joining system columns --- use eref name */
4445 }
4447 /* If child col has been dropped, no need to assign a join colname */
4449 {
4452 }
4454 /* In an unnamed join, just report child column names as-is */
4456 {
4459 }
4461 /* If alias already assigned, that's what to use */
4463 {
4464 /* If user wrote an alias, prefer that over real column name */
4467 else
4470 /* Unique-ify and insert into colinfo */
4474 }
4476 /* Remember if any assigned aliases differ from "real" name */
4479 }
4481 /*
4482 * Calculate number of columns the join would have if it were re-parsed
4483 * now, and create storage for the new_colnames and is_new_col arrays.
4484 *
4485 * Note: colname_is_unique will be consulting new_colnames[] during the
4486 * loops below, so its not-yet-filled entries must be zeroes.
4487 */
4494 /*
4495 * Generating the new_colnames array is a bit tricky since any new columns
4496 * added since parse time must be inserted in the right places. This code
4497 * must match the parser, which will order a join's columns as merged
4498 * columns first (in USING-clause order), then non-merged columns from the
4499 * left input (in attnum order), then non-merged columns from the right
4500 * input (ditto). If one of the inputs is itself a join, its columns will
4501 * be ordered according to the same rule, which means newly-added columns
4502 * might not be at the end. We can figure out what's what by consulting
4503 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
4504 *
4505 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
4506 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
4507 * meanings for the current child RTE.
4508 */
4510 /* Handle merged columns; they are first and can't be new */
4515 {
4516 /* column name is already determined and known unique */
4520 /* build bitmapsets of child attnums of merged columns */
4527 }
4529 /* Handle non-merged left-child columns */
4532 {
4536 {
4537 /* Advance ic to next non-dropped old column of left child */
4540 ic++;
4542 ic++;
4543 /* If it is a merged column, we already processed it */
4546 /* Else, advance i to the corresponding existing join column */
4549 i++;
4552 /* Use the already-assigned name of this column */
4554 i++;
4555 }
4556 else
4557 {
4558 /*
4559 * Unique-ify the new child column name and assign, unless we're
4560 * in an unnamed join, in which case just copy
4561 */
4563 {
4569 }
4570 else
4572 }
4575 j++;
4576 }
4578 /* Handle non-merged right-child columns in exactly the same way */
4581 {
4585 {
4586 /* Advance ic to next non-dropped old column of right child */
4589 ic++;
4591 ic++;
4592 /* If it is a merged column, we already processed it */
4595 /* Else, advance i to the corresponding existing join column */
4598 i++;
4601 /* Use the already-assigned name of this column */
4603 i++;
4604 }
4605 else
4606 {
4607 /*
4608 * Unique-ify the new child column name and assign, unless we're
4609 * in an unnamed join, in which case just copy
4610 */
4612 {
4618 }
4619 else
4621 }
4624 j++;
4625 }
4627 /* Assert we processed the right number of columns */
4628 #ifdef USE_ASSERT_CHECKING
4630 i++;
4633 #endif
4635 /*
4636 * For a named join, print column aliases if we changed any from the child
4637 * names. Unnamed joins cannot print aliases.
4638 */
4641 else
4643 }
4645 /*
4646 * colname_is_unique: is colname distinct from already-chosen column names?
4647 *
4648 * dpns is query-wide info, colinfo is for the column's RTE
4649 */
4650 static bool
4653 {
4657 /* Check against already-assigned column aliases within RTE */
4659 {
4664 }
4666 /*
4667 * If we're building a new_colnames array, check that too (this will be
4668 * partially but not completely redundant with the previous checks)
4669 */
4671 {
4676 }
4678 /* Also check against USING-column names that must be globally unique */
4680 {
4685 }
4687 /* Also check against names already assigned for parent-join USING cols */
4689 {
4694 }
4697 }
4699 /*
4700 * make_colname_unique: modify colname if necessary to make it unique
4701 *
4702 * dpns is query-wide info, colinfo is for the column's RTE
4703 */
4707 {
4708 /*
4709 * If the selected name isn't unique, append digits to make it so. For a
4710 * very long input name, we might have to truncate to stay within
4711 * NAMEDATALEN.
4712 */
4714 {
4719 do
4720 {
4721 i++;
4723 {
4728 /* drop chars from colname to keep all the digits */
4731 }
4734 }
4736 }
4738 /*
4739 * expand_colnames_array_to: make colinfo->colnames at least n items long
4740 *
4741 * Any added array entries are initialized to zero.
4742 */
4743 static void
4745 {
4747 {
4750 else
4751 {
4756 }
4758 }
4759 }
4761 /*
4762 * identify_join_columns: figure out where columns of a join come from
4763 *
4764 * Fills the join-specific fields of the colinfo struct, except for
4765 * usingNames which is filled later.
4766 */
4767 static void
4770 {
4776 /* Extract left/right child RT indexes */
4781 else
4788 else
4792 /* Assert children will be processed earlier than join in second pass */
4796 /* Initialize result arrays with zeroes */
4802 /*
4803 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
4804 * Recall that the column(s) merged due to USING are the first column(s)
4805 * of the join output. We need not do anything special while scanning
4806 * joinleftcols, but while scanning joinrightcols we must distinguish
4807 * merged from unmerged columns.
4808 */
4811 {
4815 }
4818 {
4823 else
4825 rcolno++;
4826 }
4828 }
4830 /*
4831 * get_rtable_name: convenience function to get a previously assigned RTE alias
4832 *
4833 * The RTE must belong to the topmost namespace level in "context".
4834 */
4837 {
4842 }
4844 /*
4845 * set_deparse_plan: set up deparse_namespace to parse subexpressions
4846 * of a given Plan node
4847 *
4848 * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
4849 * and index_tlist fields. Caller must already have adjusted the ancestors
4850 * list if necessary. Note that the rtable, subplans, and ctes fields do
4851 * not need to change when shifting attention to different plan nodes in a
4852 * single plan tree.
4853 */
4854 static void
4856 {
4859 /*
4860 * We special-case Append and MergeAppend to pretend that the first child
4861 * plan is the OUTER referent; we have to interpret OUTER Vars in their
4862 * tlists according to one of the children, and the first one is the most
4863 * natural choice.
4864 */
4869 else
4874 else
4877 /*
4878 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
4879 * use OUTER because that could someday conflict with the normal meaning.)
4880 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
4881 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
4882 * that as INNER referent.
4883 *
4884 * For ON CONFLICT .. UPDATE we just need the inner tlist to point to the
4885 * excluded expression's tlist. (Similar to the SubqueryScan we don't want
4886 * to reuse OUTER, it's used for RETURNING in some modify table cases,
4887 * although not INSERT .. CONFLICT).
4888 */
4899 else
4906 else
4909 /* Set up referent for INDEX_VAR Vars, if needed */
4916 else
4918 }
4920 /*
4921 * Locate the ancestor plan node that is the RecursiveUnion generating
4922 * the WorkTableScan's work table. We can match on wtParam, since that
4923 * should be unique within the plan tree.
4924 */
4927 {
4931 {
4937 }
4941 }
4943 /*
4944 * push_child_plan: temporarily transfer deparsing attention to a child plan
4945 *
4946 * When expanding an OUTER_VAR or INNER_VAR reference, we must adjust the
4947 * deparse context in case the referenced expression itself uses
4948 * OUTER_VAR/INNER_VAR. We modify the top stack entry in-place to avoid
4949 * affecting levelsup issues (although in a Plan tree there really shouldn't
4950 * be any).
4951 *
4952 * Caller must provide a local deparse_namespace variable to save the
4953 * previous state for pop_child_plan.
4954 */
4955 static void
4958 {
4959 /* Save state for restoration later */
4962 /* Link current plan node into ancestors list */
4965 /* Set attention on selected child */
4967 }
4969 /*
4970 * pop_child_plan: undo the effects of push_child_plan
4971 */
4972 static void
4974 {
4977 /* Get rid of ancestors list cell added by push_child_plan */
4980 /* Restore fields changed by push_child_plan */
4983 /* Make sure dpns->ancestors is right (may be unnecessary) */
4985 }
4987 /*
4988 * push_ancestor_plan: temporarily transfer deparsing attention to an
4989 * ancestor plan
4990 *
4991 * When expanding a Param reference, we must adjust the deparse context
4992 * to match the plan node that contains the expression being printed;
4993 * otherwise we'd fail if that expression itself contains a Param or
4994 * OUTER_VAR/INNER_VAR/INDEX_VAR variable.
4995 *
4996 * The target ancestor is conveniently identified by the ListCell holding it
4997 * in dpns->ancestors.
4998 *
4999 * Caller must provide a local deparse_namespace variable to save the
5000 * previous state for pop_ancestor_plan.
5001 */
5002 static void
5005 {
5008 /* Save state for restoration later */
5011 /* Build a new ancestor list with just this node's ancestors */
5016 /* Set attention on selected ancestor */
5018 }
5020 /*
5021 * pop_ancestor_plan: undo the effects of push_ancestor_plan
5022 */
5023 static void
5025 {
5026 /* Free the ancestor list made in push_ancestor_plan */
5029 /* Restore fields changed by push_ancestor_plan */
5031 }
5034 /* ----------
5035 * make_ruledef - reconstruct the CREATE RULE command
5036 * for a given pg_rewrite tuple
5037 * ----------
5038 */
5039 static void
5042 {
5045 Oid ev_class;
5050 Relation ev_relation;
5053 Datum dat;
5056 /*
5057 * Get the attribute values from the rules tuple
5058 */
5092 /*
5093 * Build the rules definition text
5094 */
5100 else
5103 /* The event the rule is fired for */
5105 {
5129 }
5131 /* The relation the rule is fired on */
5137 /* If the rule has an event qualification, add it */
5139 {
5142 deparse_context context;
5143 deparse_namespace dpns;
5151 /*
5152 * We need to make a context for recognizing any Vars in the qual
5153 * (which can only be references to OLD and NEW). Use the rtable of
5154 * the first query in the action list for this purpose.
5155 */
5158 /*
5159 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5160 * into the SELECT, and that's what we need to look at. (Ugly kluge
5161 * ... try to fix this when we redesign querytrees.)
5162 */
5165 /* Must acquire locks right away; see notes in get_query_def() */
5182 }
5186 /* The INSTEAD keyword (if so) */
5190 /* Finally the rules actions */
5192 {
5198 {
5204 else
5206 }
5208 }
5209 else
5210 {
5217 }
5220 }
5223 /* ----------
5224 * make_viewdef - reconstruct the SELECT part of a
5225 * view rewrite rule
5226 * ----------
5227 */
5228 static void
5231 {
5234 Oid ev_class;
5239 Relation ev_relation;
5241 Datum dat;
5244 /*
5245 * Get the attribute values from the rules tuple
5246 */
5272 {
5273 /* keep output buffer empty and leave */
5275 }
5281 {
5282 /* keep output buffer empty and leave */
5284 }
5293 }
5296 /* ----------
5297 * get_query_def - Parse back one query parsetree
5298 *
5299 * If resultDesc is not NULL, then it is the output tuple descriptor for
5300 * the view represented by a SELECT query.
5301 * ----------
5302 */
5303 static void
5305 TupleDesc resultDesc,
5307 {
5308 deparse_context context;
5309 deparse_namespace dpns;
5311 /* Guard against excessively long or deeply-nested queries */
5315 /*
5316 * Before we begin to examine the query, acquire locks on referenced
5317 * relations, and fix up deleted columns in JOIN RTEs. This ensures
5318 * consistent results. Note we assume it's OK to scribble on the passed
5319 * querytree!
5320 *
5321 * We are only deparsing the query (we are not about to execute it), so we
5322 * only need AccessShareLock on the relations it mentions.
5323 */
5341 {
5370 }
5371 }
5373 /* ----------
5374 * get_values_def - Parse back a VALUES list
5375 * ----------
5376 */
5377 static void
5379 {
5387 {
5394 else
5399 {
5404 else
5407 /*
5408 * Print the value. Whole-row Vars need special treatment.
5409 */
5411 }
5413 }
5414 }
5416 /* ----------
5417 * get_with_clause - Parse back a WITH clause
5418 * ----------
5419 */
5420 static void
5422 {
5431 {
5434 }
5438 else
5441 {
5447 {
5453 {
5456 else
5460 }
5462 }
5465 {
5474 }
5486 {
5494 {
5497 else
5501 }
5504 }
5507 {
5514 {
5517 else
5521 }
5525 {
5529 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
5531 {
5536 }
5537 }
5540 }
5543 }
5546 {
5549 }
5550 else
5552 }
5554 /* ----------
5555 * get_select_query_def - Parse back a SELECT parsetree
5556 * ----------
5557 */
5558 static void
5560 TupleDesc resultDesc)
5561 {
5568 /* Insert the WITH clause if given */
5571 /* Set up context for possible window functions */
5577 /*
5578 * If the Query node has a setOperations tree, then it's the top level of
5579 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
5580 * fields are interesting in the top query itself.
5581 */
5583 {
5585 /* ORDER BY clauses must be simple in this case */
5587 }
5588 else
5589 {
5592 }
5594 /* Add the ORDER BY clause if given */
5596 {
5601 }
5603 /*
5604 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
5605 * standard spelling of LIMIT.
5606 */
5608 {
5612 }
5614 {
5616 {
5621 }
5622 else
5623 {
5629 else
5631 }
5632 }
5634 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
5636 {
5638 {
5641 /* don't print implicit clauses */
5646 {
5648 /* we intentionally throw an error for LCS_NONE */
5668 }
5672 context)));
5677 }
5678 }
5682 }
5684 /*
5685 * Detect whether query looks like SELECT ... FROM VALUES(),
5686 * with no need to rename the output columns of the VALUES RTE.
5687 * If so, return the VALUES RTE. Otherwise return NULL.
5688 */
5691 {
5695 /*
5696 * We want to detect a match even if the Query also contains OLD or NEW
5697 * rule RTEs. So the idea is to scan the rtable and see if there is only
5698 * one inFromCl RTE that is a VALUES RTE.
5699 */
5701 {
5705 {
5709 }
5712 else
5714 }
5716 /*
5717 * We don't need to check the targetlist in any great detail, because
5718 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
5719 * appear inside auto-generated sub-queries with very restricted
5720 * structure. However, DefineView might have modified the tlist by
5721 * injecting new column aliases, or we might have some other column
5722 * aliases forced by a resultDesc. We can only simplify if the RTE's
5723 * column names match the names that get_target_list() would select.
5724 */
5726 {
5734 {
5742 /* compute name that get_target_list would use for column */
5743 colno++;
5746 else
5749 /* does it match the VALUES RTE? */
5752 }
5753 }
5756 }
5758 static void
5760 TupleDesc resultDesc)
5761 {
5768 {
5771 }
5773 /*
5774 * If the query looks like SELECT * FROM (VALUES ...), then print just the
5775 * VALUES part. This reverses what transformValuesClause() did at parse
5776 * time.
5777 */
5780 {
5783 }
5785 /*
5786 * Build up the query string - first we say SELECT
5787 */
5790 else
5793 /* Add the DISTINCT clause if given */
5795 {
5797 {
5801 {
5808 }
5810 }
5811 else
5813 }
5815 /* Then we tell what to select (the targetlist) */
5818 /* Add the FROM clause if needed */
5821 /* Add the WHERE clause if given */
5823 {
5827 }
5829 /* Add the GROUP BY clause if given */
5831 {
5832 ParseExprKind save_exprkind;
5843 {
5846 {
5853 }
5854 }
5855 else
5856 {
5859 {
5865 }
5866 }
5869 }
5871 /* Add the HAVING clause if given */
5873 {
5877 }
5879 /* Add the WINDOW clause if needed */
5882 }
5884 /* ----------
5885 * get_target_list - Parse back a SELECT target list
5886 *
5887 * This is also used for RETURNING lists in INSERT/UPDATE/DELETE.
5888 * ----------
5889 */
5890 static void
5892 TupleDesc resultDesc)
5893 {
5895 StringInfoData targetbuf;
5901 /* we use targetbuf to hold each TLE's text temporarily */
5907 {
5917 colno++;
5919 /*
5920 * Put the new field text into targetbuf so we can decide after we've
5921 * got it whether or not it needs to go on a new line.
5922 */
5926 /*
5927 * We special-case Var nodes rather than using get_rule_expr. This is
5928 * needed because get_rule_expr will display a whole-row Var as
5929 * "foo.*", which is the preferred notation in most contexts, but at
5930 * the top level of a SELECT list it's not right (the parser will
5931 * expand that notation into multiple columns, yielding behavior
5932 * different from a whole-row Var). We need to call get_variable
5933 * directly so that we can tell it to do the right thing, and so that
5934 * we can get the attribute name which is the default AS label.
5935 */
5937 {
5939 }
5940 else
5941 {
5943 /* We'll show the AS name unless it's this: */
5945 }
5947 /*
5948 * Figure out what the result column should be called. In the context
5949 * of a view, use the view's tuple descriptor (so as to pick up the
5950 * effects of any column RENAME that's been done on the view).
5951 * Otherwise, just use what we can find in the TLE.
5952 */
5955 else
5958 /* Show AS unless the column's name is correct as-is */
5960 {
5963 }
5965 /* Restore context's output buffer */
5968 /* Consider line-wrapping if enabled */
5970 {
5973 /* Does the new field start with a new line? */
5976 else
5979 /* If so, we shouldn't add anything */
5981 {
5982 /* instead, remove any trailing spaces currently in buf */
5984 }
5985 else
5986 {
5989 /* Locate the start of the current line in the output buffer */
5993 else
5994 trailing_nl++;
5996 /*
5997 * Add a newline, plus some indentation, if the new field is
5998 * not the first and either the new field would cause an
5999 * overflow or the last field used more than one line.
6000 */
6003 last_was_multiline))
6006 }
6008 /* Remember this field's multiline status for next iteration */
6009 last_was_multiline =
6011 }
6013 /* Add the new field */
6015 }
6017 /* clean up */
6019 }
6021 static void
6023 TupleDesc resultDesc)
6024 {
6028 /* Guard against excessively long or deeply-nested queries */
6033 {
6040 /* Need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y */
6053 }
6055 {
6059 /*
6060 * We force parens when nesting two SetOperationStmts, except when the
6061 * lefthand input is another setop of the same kind. Syntactically,
6062 * we could omit parens in rather more cases, but it seems best to use
6063 * parens to flag cases where the setop operator changes. If we use
6064 * parens, we also increase the indentation level for the child query.
6065 *
6066 * There are some cases in which parens are needed around a leaf query
6067 * too, but those are more easily handled at the next level down (see
6068 * code above).
6069 */
6071 {
6076 else
6078 }
6079 else
6083 {
6087 }
6088 else
6097 else
6101 {
6114 }
6118 /* Always parenthesize if RHS is another setop */
6121 /*
6122 * The indentation code here is deliberately a bit different from that
6123 * for the lefthand input, because we want the line breaks in
6124 * different places.
6125 */
6127 {
6130 }
6131 else
6141 }
6142 else
6143 {
6146 }
6147 }
6149 /*
6150 * Display a sort/group clause.
6151 *
6152 * Also returns the expression tree, so caller need not find it again.
6153 */
6157 {
6165 /*
6166 * Use column-number form if requested by caller. Otherwise, if
6167 * expression is a constant, force it to be dumped with an explicit cast
6168 * as decoration --- this is because a simple integer constant is
6169 * ambiguous (and will be misinterpreted by findTargetlistEntry()) if we
6170 * dump it without any decoration. If it's anything more complex than a
6171 * simple Var, then force extra parens around it, to ensure it can't be
6172 * misinterpreted as a cube() or rollup() construct.
6173 */
6175 {
6178 }
6183 else
6184 {
6185 /*
6186 * We must force parens for function-like expressions even if
6187 * PRETTY_PAREN is off, since those are the ones in danger of
6188 * misparsing. For other expressions we need to force them only if
6189 * PRETTY_PAREN is on, since otherwise the expression will output them
6190 * itself. (We can't skip the parens.)
6191 */
6202 }
6205 }
6207 /*
6208 * Display a GroupingSet
6209 */
6210 static void
6213 {
6220 {
6226 {
6231 {
6238 }
6242 }
6255 }
6258 {
6262 }
6265 }
6267 /*
6268 * Display an ORDER BY list.
6269 */
6270 static void
6273 {
6280 {
6283 Oid sortcoltype;
6290 /* See whether operator is default < or > for datatype */
6294 {
6295 /* ASC is default, so emit nothing for it */
6298 }
6300 {
6302 /* DESC defaults to NULLS FIRST */
6305 }
6306 else
6307 {
6310 sortcoltype,
6311 sortcoltype));
6312 /* be specific to eliminate ambiguity */
6315 else
6317 }
6319 }
6320 }
6322 /*
6323 * Display a WINDOW clause.
6324 *
6325 * Note that the windowClause list might contain only anonymous window
6326 * specifications, in which case we should print nothing here.
6327 */
6328 static void
6330 {
6337 {
6346 else
6354 }
6355 }
6357 /*
6358 * Display a window definition
6359 */
6360 static void
6363 {
6371 {
6374 }
6375 /* partition clauses are always inherited, so only print if no refname */
6377 {
6383 {
6390 }
6392 }
6393 /* print ordering clause only if not inherited */
6395 {
6401 }
6402 /* framing clause is never inherited, so print unless it's default */
6404 {
6413 else
6422 {
6428 else
6430 }
6431 else
6434 {
6441 {
6447 else
6449 }
6450 else
6452 }
6459 /* we will now have a trailing space; remove it */
6461 }
6463 }
6465 /* ----------
6466 * get_insert_query_def - Parse back an INSERT parsetree
6467 * ----------
6468 */
6469 static void
6471 {
6480 /* Insert the WITH clause if given */
6483 /*
6484 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
6485 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
6486 */
6488 {
6492 {
6496 }
6499 {
6503 }
6504 }
6508 /*
6509 * Start the query with INSERT INTO relname
6510 */
6515 {
6518 }
6521 /* INSERT requires AS keyword for target alias */
6526 /*
6527 * Add the insert-column-names list. Any indirection decoration needed on
6528 * the column names can be inferred from the top targetlist.
6529 */
6535 {
6544 /*
6545 * Put out name of target column; look in the catalogs, not at
6546 * tle->resname, since resname will fail to track RENAME.
6547 */
6553 /*
6554 * Print any indirection needed (subfields or subscripts), and strip
6555 * off the top-level nodes representing the indirection assignments.
6556 * Add the stripped expressions to strippedexprs. (If it's a
6557 * single-VALUES statement, the stripped expressions are the VALUES to
6558 * print below. Otherwise they're just Vars and not really
6559 * interesting.)
6560 */
6563 context));
6564 }
6569 {
6574 }
6577 {
6578 /* Add the SELECT */
6582 }
6584 {
6585 /* Add the multi-VALUES expression lists */
6587 }
6589 {
6590 /* Add the single-VALUES expression list */
6595 }
6596 else
6597 {
6598 /* No expressions, so it must be DEFAULT VALUES */
6600 }
6602 /* Add ON CONFLICT if present */
6604 {
6610 {
6611 /* Add the single-VALUES expression list */
6616 /* Add a WHERE clause (for partial indexes) if given */
6618 {
6621 /*
6622 * Force non-prefixing of Vars, since parser assumes that they
6623 * belong to target relation. WHERE clause does not use
6624 * InferenceElem, so this is separately required.
6625 */
6634 }
6635 }
6637 {
6645 }
6648 {
6650 }
6651 else
6652 {
6654 /* Deparse targetlist */
6658 /* Add a WHERE clause if given */
6660 {
6664 }
6665 }
6666 }
6668 /* Add RETURNING if present */
6670 {
6674 }
6675 }
6678 /* ----------
6679 * get_update_query_def - Parse back an UPDATE parsetree
6680 * ----------
6681 */
6682 static void
6684 {
6688 /* Insert the WITH clause if given */
6691 /*
6692 * Start the query with UPDATE relname SET
6693 */
6697 {
6700 }
6709 /* Deparse targetlist */
6712 /* Add the FROM clause if needed */
6715 /* Add a WHERE clause if given */
6717 {
6721 }
6723 /* Add RETURNING if present */
6725 {
6729 }
6730 }
6733 /* ----------
6734 * get_update_query_targetlist_def - Parse back an UPDATE targetlist
6735 * ----------
6736 */
6737 static void
6740 {
6749 /*
6750 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
6751 * into a list. We expect them to appear, in ID order, in resjunk tlist
6752 * entries.
6753 */
6756 {
6758 {
6762 {
6766 {
6769 }
6770 }
6771 }
6772 }
6777 /* Add the comma separated list of 'attname = value' */
6780 {
6787 /* Emit separator (OK whether we're in multiassignment or not) */
6791 /*
6792 * Check to see if we're starting a multiassignment group: if so,
6793 * output a left paren.
6794 */
6796 {
6797 /*
6798 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
6799 * Param. That could be buried under FieldStores and
6800 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
6801 * and underneath those there could be an implicit type coercion.
6802 * Because we would ignore implicit type coercions anyway, we
6803 * don't need to be as careful as processIndirection() is about
6804 * descending past implicit CoerceToDomains.
6805 */
6808 {
6810 {
6814 }
6816 {
6823 }
6825 {
6831 }
6832 else
6834 }
6839 {
6842 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
6846 }
6847 }
6849 /*
6850 * Put out name of target column; look in the catalogs, not at
6851 * tle->resname, since resname will fail to track RENAME.
6852 */
6858 /*
6859 * Print any indirection needed (subfields or subscripts), and strip
6860 * off the top-level nodes representing the indirection assignments.
6861 */
6864 /*
6865 * If we're in a multiassignment, skip printing anything more, unless
6866 * this is the last column; in which case, what we print should be the
6867 * sublink, not the Param.
6868 */
6870 {
6876 }
6881 }
6882 }
6885 /* ----------
6886 * get_delete_query_def - Parse back a DELETE parsetree
6887 * ----------
6888 */
6889 static void
6891 {
6895 /* Insert the WITH clause if given */
6898 /*
6899 * Start the query with DELETE FROM relname
6900 */
6904 {
6907 }
6915 /* Add the USING clause if given */
6918 /* Add a WHERE clause if given */
6920 {
6924 }
6926 /* Add RETURNING if present */
6928 {
6932 }
6933 }
6936 /* ----------
6937 * get_utility_query_def - Parse back a UTILITY parsetree
6938 * ----------
6939 */
6940 static void
6942 {
6946 {
6954 {
6957 }
6958 }
6959 else
6960 {
6961 /* Currently only NOTIFY utility commands can appear in rules */
6963 }
6964 }
6966 /*
6967 * Display a Var appropriately.
6968 *
6969 * In some cases (currently only when recursing into an unnamed join)
6970 * the Var's varlevelsup has to be interpreted with respect to a context
6971 * above the current one; levelsup indicates the offset.
6972 *
6973 * If istoplevel is true, the Var is at the top level of a SELECT's
6974 * targetlist, which means we need special treatment of whole-row Vars.
6975 * Instead of the normal "tab.*", we'll print "tab.*::typename", which is a
6976 * dirty hack to prevent "tab.*" from being expanded into multiple columns.
6977 * (The parser will strip the useless coercion, so no inefficiency is added in
6978 * dump and reload.) We used to print just "tab" in such cases, but that is
6979 * ambiguous and will yield the wrong result if "tab" is also a plain column
6980 * name in the query.
6981 *
6982 * Returns the attname of the Var, or NULL if the Var has no attname (because
6983 * it is a whole-row Var or a subplan output reference).
6984 */
6987 {
6990 AttrNumber attnum;
6994 AttrNumber varattno;
6999 /* Find appropriate nesting depth */
7005 netlevelsup);
7007 /*
7008 * If we have a syntactic referent for the Var, and we're working from a
7009 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7010 * on the semantic referent. (Forcing use of the semantic referent when
7011 * printing plan trees is a design choice that's perhaps more motivated by
7012 * backwards compatibility than anything else. But it does have the
7013 * advantage of making plans more explicit.)
7014 */
7016 {
7019 }
7020 else
7021 {
7024 }
7026 /*
7027 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7028 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7029 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
7030 * find the aliases previously assigned for this RTE.
7031 */
7033 {
7034 /*
7035 * We might have been asked to map child Vars to some parent relation.
7036 */
7038 {
7044 /* Only map up to inheritance parents, not UNION ALL appendrels */
7048 {
7051 {
7057 }
7062 /* If the parent is itself a child, continue up. */
7065 }
7067 /*
7068 * If we found an ancestral rel, and that rel is included in
7069 * appendparents, print that column not the original one.
7070 */
7072 {
7075 }
7076 }
7082 }
7083 else
7084 {
7088 }
7090 /*
7091 * The planner will sometimes emit Vars referencing resjunk elements of a
7092 * subquery's target list (this is currently only possible if it chooses
7093 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
7094 * Although we prefer to print subquery-referencing Vars using the
7095 * subquery's alias, that's not possible for resjunk items since they have
7096 * no alias. So in that case, drill down to the subplan and print the
7097 * contents of the referenced tlist item. This works because in a plan
7098 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
7099 * we'll have set dpns->inner_plan to reference the child plan node.
7100 */
7104 {
7106 deparse_namespace save_dpns;
7116 /*
7117 * Force parentheses because our caller probably assumed a Var is a
7118 * simple expression.
7119 */
7128 }
7130 /*
7131 * If it's an unnamed join, look at the expansion of the alias variable.
7132 * If it's a simple reference to one of the input vars, then recursively
7133 * print the name of that var instead. When it's not a simple reference,
7134 * we have to just print the unqualified join column name. (This can only
7135 * happen with "dangerous" merged columns in a JOIN USING; we took pains
7136 * previously to make the unqualified column name unique in such cases.)
7137 *
7138 * This wouldn't work in decompiling plan trees, because we don't store
7139 * joinaliasvars lists after planning; but a plan tree should never
7140 * contain a join alias variable.
7141 */
7143 {
7147 {
7151 /* we intentionally don't strip implicit coercions here */
7153 {
7156 }
7157 }
7159 /*
7160 * Unnamed join has no refname. (Note: since it's unnamed, there is
7161 * no way the user could have referenced it to create a whole-row Var
7162 * for it. So we don't have to cover that case below.)
7163 */
7165 }
7170 {
7171 /* Get column name to use from the colinfo struct */
7179 }
7180 else
7181 {
7182 /* System column - name is fixed, get it from the catalog */
7184 }
7187 {
7190 }
7193 else
7194 {
7200 }
7203 }
7205 /*
7206 * Deparse a Var which references OUTER_VAR, INNER_VAR, or INDEX_VAR. This
7207 * routine is actually a callback for resolve_special_varno, which handles
7208 * finding the correct TargetEntry. We get the expression contained in that
7209 * TargetEntry and just need to deparse it, a job we can throw back on
7210 * get_rule_expr.
7211 */
7212 static void
7214 {
7217 /*
7218 * For a non-Var referent, force parentheses because our caller probably
7219 * assumed a Var is a simple expression.
7220 */
7226 }
7228 /*
7229 * Chase through plan references to special varnos (OUTER_VAR, INNER_VAR,
7230 * INDEX_VAR) until we find a real Var or some kind of non-Var node; then,
7231 * invoke the callback provided.
7232 */
7233 static void
7236 {
7240 /* This function is recursive, so let's be paranoid. */
7243 /* If it's not a Var, invoke the callback. */
7245 {
7248 }
7250 /* Find appropriate nesting depth */
7255 /*
7256 * If varno is special, recurse. (Don't worry about varnosyn; if we're
7257 * here, we already decided not to use that.)
7258 */
7260 {
7262 deparse_namespace save_dpns;
7269 /*
7270 * If we're descending to the first child of an Append or MergeAppend,
7271 * update appendparents. This will affect deparsing of all Vars
7272 * appearing within the eventually-resolved subexpression.
7273 */
7289 }
7291 {
7293 deparse_namespace save_dpns;
7304 }
7306 {
7316 }
7320 /* Not special. Just invoke the callback. */
7322 }
7324 /*
7325 * Get the name of a field of an expression of composite type. The
7326 * expression is usually a Var, but we handle other cases too.
7327 *
7328 * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
7329 *
7330 * This is fairly straightforward when the expression has a named composite
7331 * type; we need only look up the type in the catalogs. However, the type
7332 * could also be RECORD. Since no actual table or view column is allowed to
7333 * have type RECORD, a Var of type RECORD must refer to a JOIN or FUNCTION RTE
7334 * or to a subquery output. We drill down to find the ultimate defining
7335 * expression and attempt to infer the field name from it. We ereport if we
7336 * can't determine the name.
7337 *
7338 * Similarly, a PARAM of type RECORD has to refer to some expression of
7339 * a determinable composite type.
7340 */
7344 {
7346 AttrNumber attnum;
7350 AttrNumber varattno;
7351 TupleDesc tupleDesc;
7354 /*
7355 * If it's a RowExpr that was expanded from a whole-row Var, use the
7356 * column names attached to it.
7357 */
7359 {
7364 }
7366 /*
7367 * If it's a Param of type RECORD, try to find what the Param refers to.
7368 */
7370 {
7376 {
7377 /* Found a match, so recurse to decipher the field name */
7378 deparse_namespace save_dpns;
7386 }
7387 }
7389 /*
7390 * If it's a Var of type RECORD, we have to find what the Var refers to;
7391 * if not, we can use get_expr_result_tupdesc().
7392 */
7395 {
7397 /* Got the tupdesc, so we can extract the field name */
7400 }
7402 /* Find appropriate nesting depth */
7408 netlevelsup);
7410 /*
7411 * If we have a syntactic referent for the Var, and we're working from a
7412 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7413 * on the semantic referent. (See comments in get_variable().)
7414 */
7416 {
7419 }
7420 else
7421 {
7424 }
7426 /*
7427 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7428 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7429 * down into the subplans, or INDEX_VAR, which is resolved similarly.
7430 *
7431 * Note: unlike get_variable and resolve_special_varno, we need not worry
7432 * about inheritance mapping: a child Var should have the same datatype as
7433 * its parent, and here we're really only interested in the Var's type.
7434 */
7436 {
7439 }
7441 {
7443 deparse_namespace save_dpns;
7458 }
7460 {
7462 deparse_namespace save_dpns;
7477 }
7479 {
7493 }
7494 else
7495 {
7498 }
7501 {
7502 /* Var is whole-row reference to RTE, so select the right field */
7504 }
7506 /*
7507 * This part has essentially the same logic as the parser's
7508 * expandRecordVariable() function, but we are dealing with a different
7509 * representation of the input context, and we only need one field name
7510 * not a TupleDesc. Also, we need special cases for finding subquery and
7511 * CTE subplans when deparsing Plan trees.
7512 */
7516 {
7522 /*
7523 * This case should not occur: a column of a table, values list,
7524 * or ENR shouldn't have type RECORD. Fall through and fail (most
7525 * likely) at the bottom.
7526 */
7529 /* Subselect-in-FROM: examine sub-select's output expr */
7530 {
7532 {
7534 attnum);
7541 {
7542 /*
7543 * Recurse into the sub-select to see what its Var
7544 * refers to. We have to build an additional level of
7545 * namespace to keep in step with varlevelsup in the
7546 * subselect.
7547 */
7548 deparse_namespace mydpns;
7564 }
7565 /* else fall through to inspect the expression */
7566 }
7567 else
7568 {
7569 /*
7570 * We're deparsing a Plan tree so we don't have complete
7571 * RTE entries (in particular, rte->subquery is NULL). But
7572 * the only place we'd see a Var directly referencing a
7573 * SUBQUERY RTE is in a SubqueryScan plan node, and we can
7574 * look into the child plan's tlist instead.
7575 */
7577 deparse_namespace save_dpns;
7586 attnum);
7595 }
7596 }
7599 /* Join RTE --- recursively inspect the alias variable */
7605 /* we intentionally don't strip implicit coercions here */
7609 context);
7610 /* else fall through to inspect the expression */
7615 /*
7616 * We couldn't get here unless a function is declared with one of
7617 * its result columns as RECORD, which is not allowed.
7618 */
7621 /* CTE reference: examine subquery's output expr */
7622 {
7624 Index ctelevelsup;
7627 /*
7628 * Try to find the referenced CTE using the namespace stack.
7629 */
7633 else
7634 {
7640 {
7644 }
7645 }
7647 {
7650 attnum);
7657 {
7658 /*
7659 * Recurse into the CTE to see what its Var refers to.
7660 * We have to build an additional level of namespace
7661 * to keep in step with varlevelsup in the CTE.
7662 * Furthermore it could be an outer CTE, so we may
7663 * have to delete some levels of namespace.
7664 */
7667 deparse_namespace mydpns;
7674 ctelevelsup);
7683 }
7684 /* else fall through to inspect the expression */
7685 }
7686 else
7687 {
7688 /*
7689 * We're deparsing a Plan tree so we don't have a CTE
7690 * list. But the only places we'd see a Var directly
7691 * referencing a CTE RTE are in CteScan or WorkTableScan
7692 * plan nodes. For those cases, set_deparse_plan arranged
7693 * for dpns->inner_plan to be the plan node that emits the
7694 * CTE or RecursiveUnion result, and we can look at its
7695 * tlist instead.
7696 */
7698 deparse_namespace save_dpns;
7707 attnum);
7716 }
7717 }
7719 }
7721 /*
7722 * We now have an expression we can't expand any more, so see if
7723 * get_expr_result_tupdesc() can do anything with it.
7724 */
7726 /* Got the tupdesc, so we can extract the field name */
7729 }
7731 /*
7732 * Try to find the referenced expression for a PARAM_EXEC Param that might
7733 * reference a parameter supplied by an upper NestLoop or SubPlan plan node.
7734 *
7735 * If successful, return the expression and set *dpns_p and *ancestor_cell_p
7736 * appropriately for calling push_ancestor_plan(). If no referent can be
7737 * found, return NULL.
7738 */
7742 {
7743 /* Initialize output parameters to prevent compiler warnings */
7747 /*
7748 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
7749 * SubPlan argument. This will necessarily be in some ancestor of the
7750 * current expression's Plan node.
7751 */
7753 {
7764 {
7768 /*
7769 * NestLoops transmit params to their inner child only; also, once
7770 * we've crawled up out of a subplan, this couldn't possibly be
7771 * the right match.
7772 */
7775 in_same_plan_level)
7776 {
7780 {
7784 {
7785 /* Found a match, so return it */
7789 }
7790 }
7791 }
7793 /*
7794 * If ancestor is a SubPlan, check the arguments it provides.
7795 */
7797 {
7803 {
7808 {
7809 /*
7810 * Found a match, so return it. But, since Vars in
7811 * the arg are to be evaluated in the surrounding
7812 * context, we have to point to the next ancestor item
7813 * that is *not* a SubPlan.
7814 */
7819 {
7823 {
7827 }
7828 }
7830 }
7831 }
7833 /* We have emerged from a subplan. */
7836 /* SubPlan isn't a kind of Plan, so skip the rest */
7838 }
7840 /*
7841 * Check to see if we're emerging from an initplan of the current
7842 * ancestor plan. Initplans never have any parParams, so no need
7843 * to search that list, but we need to know if we should reset
7844 * in_same_plan_level.
7845 */
7847 {
7854 /* No parameters to be had here. */
7857 /* We have emerged from an initplan. */
7860 }
7862 /* No luck, crawl up to next ancestor */
7864 }
7865 }
7867 /* No referent found */
7869 }
7871 /*
7872 * Display a Param appropriately.
7873 */
7874 static void
7876 {
7881 /*
7882 * If it's a PARAM_EXEC parameter, try to locate the expression from which
7883 * the parameter was computed. Note that failing to find a referent isn't
7884 * an error, since the Param might well be a subplan output rather than an
7885 * input.
7886 */
7889 {
7890 /* Found a match, so print it */
7891 deparse_namespace save_dpns;
7895 /* Switch attention to the ancestor plan node */
7898 /*
7899 * Force prefixing of Vars, since they won't belong to the relation
7900 * being scanned in the original plan node.
7901 */
7905 /*
7906 * A Param's expansion is typically a Var, Aggref, or upper-level
7907 * Param, which wouldn't need extra parentheses. Otherwise, insert
7908 * parens to ensure the expression looks atomic.
7909 */
7926 }
7928 /*
7929 * If it's an external parameter, see if the outermost namespace provides
7930 * function argument names.
7931 */
7933 {
7938 {
7942 {
7946 /*
7947 * Qualify the parameter name if there are any other deparse
7948 * namespaces with range tables. This avoids qualifying in
7949 * trivial cases like "RETURN a + b", but makes it safe in all
7950 * other cases.
7951 */
7953 {
7957 {
7960 }
7961 }
7963 {
7966 }
7970 }
7971 }
7972 }
7974 /*
7975 * Not PARAM_EXEC, or couldn't find referent: just print $N.
7976 */
7978 }
7980 /*
7981 * get_simple_binary_op_name
7982 *
7983 * helper function for isSimpleNode
7984 * will return single char binary operator name, or NULL if it's not
7985 */
7988 {
7992 {
7993 /* binary operator */
8001 }
8003 }
8006 /*
8007 * isSimpleNode - check if given node is simple (doesn't need parenthesizing)
8008 *
8009 * true : simple in the context of parent node's type
8010 * false : not simple
8011 */
8012 static bool
8014 {
8019 {
8026 /* single words: always simple */
8041 /* function-like: name(..) or name[..] */
8044 /* CASE keywords act as parentheses */
8050 /*
8051 * appears simple since . has top precedence, unless parent is
8052 * T_FieldSelect itself!
8053 */
8058 /*
8059 * treat like FieldSelect (probably doesn't matter)
8060 */
8064 /* maybe simple, check args */
8081 {
8082 /* depends on parent node type; needs further checking */
8084 {
8096 /* We know only the basic operators + - and * / % */
8117 /*
8118 * Operators are same priority --- can skip parens only if
8119 * we have (a - b) - c, not a - (b - c).
8120 */
8125 }
8126 /* else do the same stuff as for T_SubLink et al. */
8127 }
8128 /* FALLTHROUGH */
8135 {
8137 {
8138 /* special handling for casts */
8145 }
8160 }
8164 {
8167 {
8168 BoolExprType type;
8169 BoolExprType parentType;
8174 {
8184 }
8185 }
8188 {
8189 /* special handling for casts */
8196 }
8210 }
8214 }
8215 /* those we don't know: in dubio complexo */
8217 }
8220 /*
8221 * appendContextKeyword - append a keyword to buffer
8222 *
8223 * If prettyPrint is enabled, perform a line break, and adjust indentation.
8224 * Otherwise, just append the keyword.
8225 */
8226 static void
8229 {
8233 {
8238 /* remove any trailing spaces currently in the buffer ... */
8240 /* ... then add a newline and some spaces */
8245 else
8246 {
8247 /*
8248 * If we're indented more than PRETTYINDENT_LIMIT characters, try
8249 * to conserve horizontal space by reducing the per-level
8250 * indentation. For best results the scale factor here should
8251 * divide all the indent amounts that get added to indentLevel
8252 * (PRETTYINDENT_STD, etc). It's important that the indentation
8253 * not grow unboundedly, else deeply-nested trees use O(N^2)
8254 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
8255 */
8260 /* scale/wrap logic affects indentLevel, but not indentPlus */
8262 }
8270 }
8271 else
8273 }
8275 /*
8276 * removeStringInfoSpaces - delete trailing spaces from a buffer.
8277 *
8278 * Possibly this should move to stringinfo.c at some point.
8279 */
8280 static void
8282 {
8285 }
8288 /*
8289 * get_rule_expr_paren - deparse expr using get_rule_expr,
8290 * embracing the string with parentheses if necessary for prettyPrint.
8291 *
8292 * Never embrace if prettyFlags=0, because it's done in the calling node.
8293 *
8294 * Any node that does *not* embrace its argument node by sql syntax (with
8295 * parentheses, non-operator keywords like CASE/WHEN/ON, or comma etc) should
8296 * use get_rule_expr_paren instead of get_rule_expr so parentheses can be
8297 * added.
8298 */
8299 static void
8302 {
8315 }
8318 /* ----------
8319 * get_rule_expr - Parse back an expression
8320 *
8321 * Note: showimplicit determines whether we display any implicit cast that
8322 * is present at the top of the expression tree. It is a passed argument,
8323 * not a field of the context struct, because we change the value as we
8324 * recurse down into the expression. In general we suppress implicit casts
8325 * when the result type is known with certainty (eg, the arguments of an
8326 * OR must be boolean). We display implicit casts for arguments of functions
8327 * and operators, since this is needed to be certain that the same function
8328 * or operator will be chosen when the expression is re-parsed.
8329 * ----------
8330 */
8331 static void
8334 {
8340 /* Guard against excessively long or deeply-nested queries */
8344 /*
8345 * Each level of get_rule_expr must emit an indivisible term
8346 * (parenthesized if necessary) to ensure result is reparsed into the same
8347 * expression tree. The only exception is that when the input is a List,
8348 * we emit the component items comma-separated with no surrounding
8349 * decoration; this is convenient for most callers.
8350 */
8352 {
8370 {
8376 }
8384 {
8388 /*
8389 * If the argument is a CaseTestExpr, we must be inside a
8390 * FieldStore, ie, we are assigning to an element of an array
8391 * within a composite column. Since we already punted on
8392 * displaying the FieldStore's target information, just punt
8393 * here too, and display only the assignment source
8394 * expression.
8395 */
8397 {
8402 }
8404 /*
8405 * Parenthesize the argument unless it's a simple Var or a
8406 * FieldSelect. (In particular, if it's another
8407 * SubscriptingRef, we *must* parenthesize to avoid
8408 * confusion.)
8409 */
8418 /*
8419 * If there's a refassgnexpr, we want to print the node in the
8420 * format "container[subscripts] := refassgnexpr". This is
8421 * not legal SQL, so decompilation of INSERT or UPDATE
8422 * statements should always use processIndirection as part of
8423 * the statement-level syntax. We should only see this when
8424 * EXPLAIN tries to print the targetlist of a plan resulting
8425 * from such a statement.
8426 */
8428 {
8431 /*
8432 * Use processIndirection to print this node's subscripts
8433 * as well as any additional field selections or
8434 * subscripting in immediate descendants. It returns the
8435 * RHS expr that is actually being "assigned".
8436 */
8440 }
8441 else
8442 {
8443 /* Just an ordinary container fetch, so print subscripts */
8445 }
8446 }
8454 {
8459 }
8467 {
8480 }
8484 {
8490 }
8494 {
8510 /*
8511 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
8512 * a bare sub-SELECT. Since we're here, the sub-SELECT must
8513 * be meant as a scalar sub-SELECT yielding an array value to
8514 * be used in ScalarArrayOpExpr; but the grammar will
8515 * preferentially interpret such a construct as an ANY/ALL
8516 * SubLink. To prevent misparsing the output that way, insert
8517 * a dummy coercion (which will be stripped by parse analysis,
8518 * so no inefficiency is added in dump and reload). This is
8519 * indeed most likely what the user wrote to get the construct
8520 * accepted in the first place.
8521 */
8530 }
8534 {
8540 {
8547 {
8551 }
8562 {
8566 }
8584 }
8585 }
8593 {
8596 /*
8597 * We cannot see an already-planned subplan in rule deparsing,
8598 * only while EXPLAINing a query plan. We don't try to
8599 * reconstruct the original SQL, just reference the subplan
8600 * that appears elsewhere in EXPLAIN's result.
8601 */
8604 else
8606 }
8610 {
8614 /*
8615 * This case cannot be reached in normal usage, since no
8616 * AlternativeSubPlan can appear either in parsetrees or
8617 * finished plan trees. We keep it just in case somebody
8618 * wants to use this code to print planner data structures.
8619 */
8622 {
8627 else
8631 }
8633 }
8637 {
8644 /*
8645 * Parenthesize the argument unless it's an SubscriptingRef or
8646 * another FieldSelect. Note in particular that it would be
8647 * WRONG to not parenthesize a Var argument; simplicity is not
8648 * the issue here, having the right number of names is.
8649 */
8658 /*
8659 * Get and print the field name.
8660 */
8664 }
8668 {
8672 /*
8673 * There is no good way to represent a FieldStore as real SQL,
8674 * so decompilation of INSERT or UPDATE statements should
8675 * always use processIndirection as part of the
8676 * statement-level syntax. We should only get here when
8677 * EXPLAIN tries to print the targetlist of a plan resulting
8678 * from such a statement. The plan case is even harder than
8679 * ordinary rules would be, because the planner tries to
8680 * collapse multiple assignments to the same field or subfield
8681 * into one FieldStore; so we can see a list of target fields
8682 * not just one, and the arguments could be FieldStores
8683 * themselves. We don't bother to try to print the target
8684 * field names; we just print the source arguments, with a
8685 * ROW() around them if there's more than one. This isn't
8686 * terribly complete, but it's probably good enough for
8687 * EXPLAIN's purposes; especially since anything more would be
8688 * either hopelessly confusing or an even poorer
8689 * representation of what the plan is actually doing.
8690 */
8697 }
8701 {
8707 {
8708 /* don't show the implicit cast */
8710 }
8711 else
8712 {
8716 node);
8717 }
8718 }
8722 {
8728 {
8729 /* don't show the implicit cast */
8731 }
8732 else
8733 {
8737 node);
8738 }
8739 }
8743 {
8749 {
8750 /* don't show the implicit cast */
8752 }
8753 else
8754 {
8758 node);
8759 }
8760 }
8764 {
8770 {
8771 /* don't show the implicit cast */
8773 }
8774 else
8775 {
8778 node);
8779 }
8780 }
8784 {
8795 }
8799 {
8806 {
8809 }
8811 {
8816 {
8817 /*
8818 * The parser should have produced WHEN clauses of the
8819 * form "CaseTestExpr = RHS", possibly with an
8820 * implicit coercion inserted above the CaseTestExpr.
8821 * For accurate decompilation of rules it's essential
8822 * that we show just the RHS. However in an
8823 * expression that's been through the optimizer, the
8824 * WHEN clause could be almost anything (since the
8825 * equality operator could have been expanded into an
8826 * inline function). If we don't recognize the form
8827 * of the WHEN clause, just punt and display it as-is.
8828 */
8830 {
8835 CaseTestExpr))
8837 }
8838 }
8847 }
8857 }
8861 {
8862 /*
8863 * Normally we should never get here, since for expressions
8864 * that can contain this node type we attempt to avoid
8865 * recursing to it. But in an optimized expression we might
8866 * be unable to avoid that (see comments for CaseExpr). If we
8867 * do see one, print it as CASE_TEST_EXPR.
8868 */
8870 }
8874 {
8881 /*
8882 * If the array isn't empty, we assume its elements are
8883 * coerced to the desired type. If it's empty, though, we
8884 * need an explicit coercion to the array type.
8885 */
8889 }
8893 {
8900 /*
8901 * If it's a named type and not RECORD, we may have to skip
8902 * dropped columns and/or claim there are NULLs for added
8903 * columns.
8904 */
8906 {
8909 }
8911 /*
8912 * SQL99 allows "ROW" to be omitted when there is more than
8913 * one column, but for simplicity we always print it.
8914 */
8919 {
8924 {
8926 /* Whole-row Vars need special treatment here */
8929 }
8930 i++;
8931 }
8933 {
8935 {
8937 {
8941 }
8942 i++;
8943 }
8946 }
8951 }
8955 {
8960 /*
8961 * SQL99 allows "ROW" to be omitted when there is more than
8962 * one column, but for simplicity we always print it.
8963 */
8967 {
8973 }
8975 /*
8976 * We assume that the name of the first-column operator will
8977 * do for all the rest too. This is definitely open to
8978 * failure, eg if some but not all operators were renamed
8979 * since the construct was parsed, but there seems no way to
8980 * be perfect.
8981 */
8988 {
8994 }
8996 }
9000 {
9006 }
9010 {
9014 {
9021 }
9024 }
9028 {
9031 /*
9032 * Note: this code knows that typmod for time, timestamp, and
9033 * timestamptz just prints as integer.
9034 */
9036 {
9084 }
9085 }
9089 {
9097 {
9121 }
9123 {
9126 else
9128 }
9130 {
9134 }
9136 {
9138 {
9143 }
9145 {
9155 }
9158 }
9160 {
9164 {
9170 /* no extra decoration needed */
9184 else
9199 else
9205 else
9206 {
9208 {
9223 }
9224 }
9229 }
9231 }
9238 else
9240 }
9244 {
9251 /*
9252 * For scalar inputs, we prefer to print as IS [NOT] NULL,
9253 * which is shorter and traditional. If it's a rowtype input
9254 * but we're applying a scalar test, must print IS [NOT]
9255 * DISTINCT FROM NULL to be semantically correct.
9256 */
9259 {
9261 {
9271 }
9272 }
9273 else
9274 {
9276 {
9286 }
9287 }
9290 }
9294 {
9301 {
9323 }
9326 }
9330 {
9336 {
9337 /* don't show the implicit cast */
9339 }
9340 else
9341 {
9345 node);
9346 }
9347 }
9359 {
9365 else
9368 }
9372 {
9375 /*
9376 * This isn't exactly nextval(), but that seems close enough
9377 * for EXPLAIN's purposes.
9378 */
9382 NIL));
9384 }
9388 {
9393 /*
9394 * InferenceElem can only refer to target relation, so a
9395 * prefix is not useful, and indeed would cause parse errors.
9396 */
9400 /*
9401 * Parenthesize the element unless it's a simple Var or a bare
9402 * function call. Follows pg_get_indexdef_worker().
9403 */
9407 COERCE_EXPLICIT_CALL)
9423 /* Add the operator class name, if not default */
9425 {
9430 }
9431 }
9435 {
9441 {
9444 }
9447 {
9463 {
9469 }
9489 }
9490 }
9494 {
9500 {
9504 }
9505 }
9515 }
9516 }
9518 /*
9519 * get_rule_expr_toplevel - Parse back a toplevel expression
9520 *
9521 * Same as get_rule_expr(), except that if the expr is just a Var, we pass
9522 * istoplevel = true not false to get_variable(). This causes whole-row Vars
9523 * to get printed with decoration that will prevent expansion of "*".
9524 * We need to use this in contexts such as ROW() and VALUES(), where the
9525 * parser would expand "foo.*" appearing at top level. (In principle we'd
9526 * use this in get_target_list() too, but that has additional worries about
9527 * whether to print AS, so it needs to invoke get_variable() directly anyway.)
9528 */
9529 static void
9532 {
9535 else
9537 }
9539 /*
9540 * get_rule_expr_funccall - Parse back a function-call expression
9541 *
9542 * Same as get_rule_expr(), except that we guarantee that the output will
9543 * look like a function call, or like one of the things the grammar treats as
9544 * equivalent to a function call (see the func_expr_windowless production).
9545 * This is needed in places where the grammar uses func_expr_windowless and
9546 * you can't substitute a parenthesized a_expr. If what we have isn't going
9547 * to look like a function call, wrap it in a dummy CAST() expression, which
9548 * will satisfy the grammar --- and, indeed, is likely what the user wrote to
9549 * produce such a thing.
9550 */
9551 static void
9554 {
9557 else
9558 {
9562 /* no point in showing any top-level implicit cast */
9567 }
9568 }
9570 /*
9571 * Helper function to identify node types that satisfy func_expr_windowless.
9572 * If in doubt, "false" is always a safe answer.
9573 */
9574 static bool
9576 {
9580 {
9582 /* OK, unless it's going to deparse as a cast */
9590 /* these are all accepted by func_expr_common_subexpr */
9594 }
9596 }
9599 /*
9600 * get_oper_expr - Parse back an OpExpr node
9601 */
9602 static void
9604 {
9612 {
9613 /* binary operator */
9623 }
9624 else
9625 {
9626 /* prefix operator */
9631 InvalidOid,
9634 }
9637 }
9639 /*
9640 * get_func_expr - Parse back a FuncExpr node
9641 */
9642 static void
9645 {
9654 /*
9655 * If the function call came from an implicit coercion, then just show the
9656 * first argument --- unless caller wants to see implicit coercions.
9657 */
9659 {
9663 }
9665 /*
9666 * If the function call came from a cast, then show the first argument
9667 * plus an explicit cast operation.
9668 */
9671 {
9674 int32 coercedTypmod;
9676 /* Get the typmod if this is a length-coercion function */
9684 }
9686 /*
9687 * If the function was called using one of the SQL spec's random special
9688 * syntaxes, try to reproduce that. If we don't recognize the function,
9689 * fall through.
9690 */
9692 {
9695 }
9697 /*
9698 * Normal function: display as proname(args). First we need to extract
9699 * the argument datatypes.
9700 */
9708 {
9714 nargs++;
9715 }
9725 {
9731 }
9733 }
9735 /*
9736 * get_agg_expr - Parse back an Aggref node
9737 */
9738 static void
9741 {
9747 /*
9748 * For a combining aggregate, we look up and deparse the corresponding
9749 * partial aggregate instead. This is necessary because our input
9750 * argument list has been replaced; the new argument list always has just
9751 * one element, which will point to a partial Aggref that supplies us with
9752 * transition states to combine.
9753 */
9755 {
9763 }
9765 /*
9766 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
9767 * to avoid printing this when recursing from the code just above.
9768 */
9772 /* Extract the argument types as seen by the parser */
9775 /* Print the aggregate name, schema-qualified if needed */
9785 {
9786 /*
9787 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
9788 * worry about inserting VARIADIC. So we can just dump the direct
9789 * args as-is.
9790 */
9796 }
9797 else
9798 {
9799 /* aggstar can be set only in zero-argument aggregates */
9802 else
9803 {
9809 {
9821 }
9822 }
9825 {
9828 }
9829 }
9832 {
9835 }
9838 }
9840 /*
9841 * This is a helper function for get_agg_expr(). It's used when we deparse
9842 * a combining Aggref; resolve_special_varno locates the corresponding partial
9843 * Aggref and then calls this.
9844 */
9845 static void
9847 {
9856 }
9858 /*
9859 * get_windowfunc_expr - Parse back a WindowFunc node
9860 */
9861 static void
9863 {
9877 {
9883 nargs++;
9884 }
9891 /* winstar can be set only in zero-argument aggregates */
9894 else
9898 {
9901 }
9906 {
9910 {
9913 else
9916 }
9917 }
9919 {
9924 /*
9925 * In EXPLAIN, we don't have window context information available, so
9926 * we have to settle for this:
9927 */
9929 }
9930 }
9932 /*
9933 * get_func_sql_syntax - Parse back a SQL-syntax function call
9934 *
9935 * Returns true if we successfully deparsed, false if we did not
9936 * recognize the function.
9937 */
9938 static bool
9940 {
9945 {
9952 /* AT TIME ZONE ... note reversed argument order */
9973 /* (x1, x2) OVERLAPS (y1, y2) */
9991 /* EXTRACT (x FROM y) */
9993 {
10000 }
10007 /* IS xxx NORMALIZED */
10012 {
10020 }
10025 /* COLLATION FOR */
10031 /*
10032 * XXX EXTRACT, a/k/a date_part(), is intentionally not covered
10033 * yet. Add it after we change the return type to numeric.
10034 */
10037 /* NORMALIZE() */
10041 {
10049 }
10059 /* OVERLAY() */
10067 {
10070 }
10077 /* POSITION() ... extra parens since args are b_expr not a_expr */
10091 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
10097 {
10100 }
10105 /* SUBSTRING SIMILAR/ESCAPE */
10118 /* TRIM() */
10121 {
10124 }
10133 /* TRIM() */
10136 {
10139 }
10148 /* TRIM() */
10151 {
10154 }
10161 /* XMLEXISTS ... extra parens because args are c_expr */
10168 }
10170 }
10172 /* ----------
10173 * get_coercion_expr
10174 *
10175 * Make a string representation of a value coerced to a specific type
10176 * ----------
10177 */
10178 static void
10182 {
10185 /*
10186 * Since parse_coerce.c doesn't immediately collapse application of
10187 * length-coercion functions to constants, what we'll typically see in
10188 * such cases is a Const with typmod -1 and a length-coercion function
10189 * right above it. Avoid generating redundant output. However, beware of
10190 * suppressing casts when the user actually wrote something like
10191 * 'foo'::text::char(3).
10192 *
10193 * Note: it might seem that we are missing the possibility of needing to
10194 * print a COLLATE clause for such a Const. However, a Const could only
10195 * have nondefault collation in a post-constant-folding tree, in which the
10196 * length coercion would have been folded too. See also the special
10197 * handling of CollateExpr in coerce_to_target_type(): any collation
10198 * marking will be above the coercion node, not below it.
10199 */
10203 {
10204 /* Show the constant without normal ::typename decoration */
10206 }
10207 else
10208 {
10214 }
10216 /*
10217 * Never emit resulttype(arg) functional notation. A pg_proc entry could
10218 * take precedence, and a resulttype in pg_temp would require schema
10219 * qualification that format_type_with_typemod() would usually omit. We've
10220 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
10221 * would work fine.
10222 */
10225 }
10227 /* ----------
10228 * get_const_expr
10229 *
10230 * Make a string representation of a Const
10231 *
10232 * showtype can be -1 to never show "::typename" decoration, or +1 to always
10233 * show it, or 0 to show it only if the constant wouldn't be assumed to be
10234 * the right type by default.
10235 *
10236 * If the Const's collation isn't default for its type, show that too.
10237 * We mustn't do this when showtype is -1 (since that means the caller will
10238 * print "::typename", and we can't put a COLLATE clause in between). It's
10239 * caller's responsibility that collation isn't missed in such cases.
10240 * ----------
10241 */
10242 static void
10244 {
10246 Oid typoutput;
10252 {
10253 /*
10254 * Always label the type of a NULL constant to prevent misdecisions
10255 * about type when reparsing.
10256 */
10259 {
10264 }
10266 }
10274 {
10277 /*
10278 * INT4 can be printed without any decoration, unless it is
10279 * negative; in that case print it as '-nnn'::integer to ensure
10280 * that the output will re-parse as a constant, not as a constant
10281 * plus operator. In most cases we could get away with printing
10282 * (-nnn) instead, because of the way that gram.y handles negative
10283 * literals; but that doesn't work for INT_MIN, and it doesn't
10284 * seem that much prettier anyway.
10285 */
10288 else
10289 {
10292 }
10297 /*
10298 * NUMERIC can be printed without quotes if it looks like a float
10299 * constant (not an integer, and not Infinity or NaN) and doesn't
10300 * have a leading sign (for the same reason as for INT4).
10301 */
10304 {
10306 }
10307 else
10308 {
10311 }
10317 else
10324 }
10331 /*
10332 * For showtype == 0, append ::typename unless the constant will be
10333 * implicitly typed as the right type when it is read in.
10334 *
10335 * XXX this code has to be kept in sync with the behavior of the parser,
10336 * especially make_const.
10337 */
10339 {
10342 /* These types can be left unlabeled */
10346 /* We determined above whether a label is needed */
10350 /*
10351 * Float-looking constants will be typed as numeric, which we
10352 * checked above; but if there's a nondefault typmod we need to
10353 * show it.
10354 */
10360 }
10367 }
10369 /*
10370 * helper for get_const_expr: append COLLATE if needed
10371 */
10372 static void
10374 {
10378 {
10382 {
10385 }
10386 }
10387 }
10389 /*
10390 * simple_quote_literal - Format a string as a SQL literal, append to buf
10391 */
10392 static void
10394 {
10397 /*
10398 * We form the string literal according to the prevailing setting of
10399 * standard_conforming_strings; we never use E''. User is responsible for
10400 * making sure result is used correctly.
10401 */
10404 {
10410 }
10412 }
10415 /* ----------
10416 * get_sublink_expr - Parse back a sublink
10417 * ----------
10418 */
10419 static void
10421 {
10429 else
10432 /*
10433 * Note that we print the name of only the first operator, when there are
10434 * multiple combining operators. This is an approximation that could go
10435 * wrong in various scenarios (operators in different schemas, renamed
10436 * operators, etc) but there is not a whole lot we can do about it, since
10437 * the syntax allows only one operator to be shown.
10438 */
10440 {
10442 {
10443 /* single combining operator */
10450 }
10452 {
10453 /* multiple combining operators, = or <> cases */
10460 {
10470 }
10472 }
10474 {
10475 /* multiple combining operators, < <= > >= cases */
10484 }
10485 else
10488 }
10493 {
10501 else
10524 }
10535 else
10537 }
10540 /* ----------
10541 * get_tablefunc - Parse back a table function
10542 * ----------
10543 */
10544 static void
10546 {
10549 /* XMLTABLE is the only existing implementation. */
10554 {
10561 {
10567 else
10571 {
10574 }
10575 else
10576 {
10579 }
10580 }
10582 }
10591 {
10602 {
10613 colnum++;
10622 {
10626 }
10628 {
10632 }
10635 }
10636 }
10639 }
10641 /* ----------
10642 * get_from_clause - Parse back a FROM clause
10643 *
10644 * "prefix" is the keyword that denotes the start of the list of FROM
10645 * elements. It is FROM when used to parse back SELECT and UPDATE, but
10646 * is USING when parsing back DELETE.
10647 * ----------
10648 */
10649 static void
10651 {
10656 /*
10657 * We use the query's jointree as a guide to what to print. However, we
10658 * must ignore auto-added RTEs that are marked not inFromCl. (These can
10659 * only appear at the top level of the jointree, so it's sufficient to
10660 * check here.) This check also ensures we ignore the rule pseudo-RTEs
10661 * for NEW and OLD.
10662 */
10664 {
10668 {
10674 }
10677 {
10683 }
10684 else
10685 {
10686 StringInfoData itembuf;
10690 /*
10691 * Put the new FROM item's text into itembuf so we can decide
10692 * after we've got it whether or not it needs to go on a new line.
10693 */
10699 /* Restore context's output buffer */
10702 /* Consider line-wrapping if enabled */
10704 {
10705 /* Does the new item start with a new line? */
10707 {
10708 /* If so, we shouldn't add anything */
10709 /* instead, remove any trailing spaces currently in buf */
10711 }
10712 else
10713 {
10716 /* Locate the start of the current line in the buffer */
10720 else
10721 trailing_nl++;
10723 /*
10724 * Add a newline, plus some indentation, if the new item
10725 * would cause an overflow.
10726 */
10729 PRETTYINDENT_STD,
10730 PRETTYINDENT_VAR);
10731 }
10732 }
10734 /* Add the new item */
10737 /* clean up */
10739 }
10740 }
10741 }
10743 static void
10745 {
10750 {
10761 /* Print the FROM item proper */
10763 {
10765 /* Normal relation RTE */
10772 /* Subquery RTE */
10780 /* Function RTE */
10783 /*
10784 * Omit ROWS FROM() syntax for just one function, unless it
10785 * has both a coldeflist and WITH ORDINALITY. If it has both,
10786 * we must use ROWS FROM() syntax to avoid ambiguity about
10787 * whether the coldeflist includes the ordinality column.
10788 */
10791 {
10793 /* we'll print the coldeflist below, if it has one */
10794 }
10795 else
10796 {
10800 /*
10801 * If all the function calls in the list are to unnest,
10802 * and none need a coldeflist, then collapse the list back
10803 * down to UNNEST(args). (If we had more than one
10804 * built-in unnest function, this would get more
10805 * difficult.)
10806 *
10807 * XXX This is pretty ugly, since it makes not-terribly-
10808 * future-proof assumptions about what the parser would do
10809 * with the output; but the alternative is to emit our
10810 * nonstandard ROWS FROM() notation for what might have
10811 * been a perfectly spec-compliant multi-argument
10812 * UNNEST().
10813 */
10816 {
10822 {
10825 }
10826 }
10829 {
10833 {
10838 }
10843 }
10844 else
10845 {
10850 {
10857 {
10858 /* Reconstruct the column definition list */
10861 NULL,
10862 context);
10863 }
10864 funcno++;
10865 }
10867 }
10868 /* prevent printing duplicate coldeflist below */
10870 }
10878 /* Values list RTE */
10889 }
10891 /* Print the relation alias, if needed */
10894 {
10895 /* Always print alias if user provided one */
10897 }
10899 {
10900 /* Always print alias if we need to print column aliases */
10902 }
10904 {
10905 /*
10906 * No need to print alias if it's same as relation name (this
10907 * would normally be the case, but not if set_rtable_names had to
10908 * resolve a conflict).
10909 */
10912 }
10914 {
10915 /*
10916 * For a function RTE, always print alias. This covers possible
10917 * renaming of the function and/or instability of the
10918 * FigureColname rules for things that aren't simple functions.
10919 * Note we'd need to force it anyway for the columndef list case.
10920 */
10922 }
10924 {
10925 /* Alias is syntactically required for VALUES */
10927 }
10929 {
10930 /*
10931 * No need to print alias if it's same as CTE name (this would
10932 * normally be the case, but not if set_rtable_names had to
10933 * resolve a conflict).
10934 */
10937 }
10941 /* Print the column definitions or aliases, if needed */
10943 {
10944 /* Reconstruct the columndef list, which is also the aliases */
10946 }
10947 else
10948 {
10949 /* Else print column aliases as needed */
10951 }
10953 /* Tablesample clause must go after any alias */
10956 }
10958 {
10973 {
10978 PRETTYINDENT_STD,
10979 PRETTYINDENT_JOIN);
10980 else
10983 PRETTYINDENT_STD,
10984 PRETTYINDENT_JOIN);
10989 PRETTYINDENT_STD,
10990 PRETTYINDENT_JOIN);
10995 PRETTYINDENT_STD,
10996 PRETTYINDENT_JOIN);
11001 PRETTYINDENT_STD,
11002 PRETTYINDENT_JOIN);
11007 }
11016 {
11021 /* Use the assigned names, not what's in usingClause */
11023 {
11028 else
11031 }
11037 }
11039 {
11046 }
11048 {
11049 /* If we didn't say CROSS JOIN above, we must provide an ON */
11051 }
11056 /* Yes, it's correct to put alias after the right paren ... */
11058 {
11059 /*
11060 * Note that it's correct to emit an alias clause if and only if
11061 * there was one originally. Otherwise we'd be converting a named
11062 * join to unnamed or vice versa, which creates semantic
11063 * subtleties we don't want. However, we might print a different
11064 * alias name than was there originally.
11065 */
11068 context)));
11070 }
11071 }
11072 else
11075 }
11077 /*
11078 * get_column_alias_list - print column alias list for an RTE
11079 *
11080 * Caller must already have printed the relation's alias name.
11081 */
11082 static void
11084 {
11089 /* Don't print aliases if not needed */
11094 {
11098 {
11101 }
11102 else
11105 }
11108 }
11110 /*
11111 * get_from_clause_coldeflist - reproduce FROM clause coldeflist
11112 *
11113 * When printing a top-level coldeflist (which is syntactically also the
11114 * relation's column alias list), use column names from colinfo. But when
11115 * printing a coldeflist embedded inside ROWS FROM(), we prefer to use the
11116 * original coldeflist's names, which are available in rtfunc->funccolnames.
11117 * Pass NULL for colinfo to select the latter behavior.
11118 *
11119 * The coldeflist is appended immediately (no space) to buf. Caller is
11120 * responsible for ensuring that an alias or AS is present before it.
11121 */
11122 static void
11126 {
11141 {
11149 else
11164 i++;
11165 }
11168 }
11170 /*
11171 * get_tablesample_def - print a TableSampleClause
11172 */
11173 static void
11175 {
11181 /*
11182 * We should qualify the handler's function name if it wouldn't be
11183 * resolved by lookup in the current search path.
11184 */
11193 {
11197 }
11201 {
11205 }
11206 }
11208 /*
11209 * get_opclass_name - fetch name of an index operator class
11210 *
11211 * The opclass name is appended (after a space) to buf.
11212 *
11213 * Output is suppressed if the opclass is the default for the given
11214 * actual_datatype. (If you don't want this behavior, just pass
11215 * InvalidOid for actual_datatype.)
11216 */
11217 static void
11219 StringInfo buf)
11220 {
11221 HeapTuple ht_opc;
11222 Form_pg_opclass opcrec;
11233 {
11234 /* Okay, we need the opclass name. Do we need to qualify it? */
11238 else
11239 {
11244 }
11245 }
11247 }
11249 /*
11250 * generate_opclass_name
11251 * Compute the name to display for a opclass specified by OID
11252 *
11253 * The result includes all necessary quoting and schema-prefixing.
11254 */
11257 {
11258 StringInfoData buf;
11264 }
11266 /*
11267 * processIndirection - take care of array and subfield assignment
11268 *
11269 * We strip any top-level FieldStore or assignment SubscriptingRef nodes that
11270 * appear in the input, printing them as decoration for the base column
11271 * name (which we assume the caller just printed). We might also need to
11272 * strip CoerceToDomain nodes, but only ones that appear above assignment
11273 * nodes.
11274 *
11275 * Returns the subexpression that's to be assigned.
11276 */
11279 {
11284 {
11288 {
11290 Oid typrelid;
11293 /* lookup tuple type */
11299 /*
11300 * Print the field name. There should only be one target field in
11301 * stored rules. There could be more than that in executable
11302 * target lists, but this function cannot be used for that case.
11303 */
11309 /*
11310 * We ignore arg since it should be an uninteresting reference to
11311 * the target column or subcolumn.
11312 */
11314 }
11316 {
11324 /*
11325 * We ignore refexpr since it should be an uninteresting reference
11326 * to the target column or subcolumn.
11327 */
11329 }
11331 {
11333 /* If it's an explicit domain coercion, we're done */
11336 /* Tentatively descend past the CoerceToDomain */
11338 }
11339 else
11341 }
11343 /*
11344 * If we descended past a CoerceToDomain whose argument turned out not to
11345 * be a FieldStore or array assignment, back up to the CoerceToDomain.
11346 * (This is not enough to be fully correct if there are nested implicit
11347 * CoerceToDomains, but such cases shouldn't ever occur.)
11348 */
11353 }
11355 static void
11357 {
11364 {
11367 {
11368 /* If subexpression is NULL, get_rule_expr prints nothing */
11372 }
11373 /* If subexpression is NULL, get_rule_expr prints nothing */
11376 }
11377 }
11379 /*
11380 * quote_identifier - Quote an identifier only if needed
11381 *
11382 * When quotes are needed, we palloc the required space; slightly
11383 * space-wasteful but well worth it for notational simplicity.
11384 */
11387 {
11388 /*
11389 * Can avoid quoting if ident starts with a lowercase letter or underscore
11390 * and contains only lowercase letters, digits, and underscores, *and* is
11391 * not any SQL keyword. Otherwise, supply quotes.
11392 */
11399 /*
11400 * would like to use <ctype.h> macros here, but they might yield unwanted
11401 * locale-specific results...
11402 */
11406 {
11412 {
11413 /* okay */
11414 }
11415 else
11416 {
11419 nquotes++;
11420 }
11421 }
11427 {
11428 /*
11429 * Check for keyword. We quote keywords except for unreserved ones.
11430 * (In some cases we could avoid quoting a col_name or type_func_name
11431 * keyword, but it seems much harder than it's worth to tell that.)
11432 *
11433 * Note: ScanKeywordLookup() does case-insensitive comparison, but
11434 * that's fine, since we already know we have all-lower-case.
11435 */
11440 }
11450 {
11456 }
11461 }
11463 /*
11464 * quote_qualified_identifier - Quote a possibly-qualified identifier
11465 *
11466 * Return a name of the form qualifier.ident, or just ident if qualifier
11467 * is NULL, quoting each component if necessary. The result is palloc'd.
11468 */
11472 {
11473 StringInfoData buf;
11480 }
11482 /*
11483 * get_relation_name
11484 * Get the unqualified name of a relation specified by OID
11485 *
11486 * This differs from the underlying get_rel_name() function in that it will
11487 * throw error instead of silently returning NULL if the OID is bad.
11488 */
11491 {
11497 }
11499 /*
11500 * generate_relation_name
11501 * Compute the name to display for a relation specified by OID
11502 *
11503 * The result includes all necessary quoting and schema-prefixing.
11504 *
11505 * If namespaces isn't NIL, it must be a list of deparse_namespace nodes.
11506 * We will forcibly qualify the relation name if it equals any CTE name
11507 * visible in the namespace list.
11508 */
11511 {
11512 HeapTuple tp;
11513 Form_pg_class reltup;
11526 /* Check for conflicting CTE name */
11529 {
11534 {
11538 {
11541 }
11542 }
11545 }
11547 /* Otherwise, qualify the name if not visible in search path */
11553 else
11561 }
11563 /*
11564 * generate_qualified_relation_name
11565 * Compute the name to display for a relation specified by OID
11566 *
11567 * As above, but unconditionally schema-qualify the name.
11568 */
11571 {
11572 HeapTuple tp;
11573 Form_pg_class reltup;
11594 }
11596 /*
11597 * generate_function_name
11598 * Compute the name to display for a function specified by OID,
11599 * given that it is being called with the specified actual arg names and
11600 * types. (Those matter because of ambiguous-function resolution rules.)
11601 *
11602 * If we're dealing with a potentially variadic function (in practice, this
11603 * means a FuncExpr or Aggref, not some other way of calling a function), then
11604 * has_variadic must specify whether variadic arguments have been merged,
11605 * and *use_variadic_p will be set to indicate whether to print VARIADIC in
11606 * the output. For non-FuncExpr cases, has_variadic should be false and
11607 * use_variadic_p can be NULL.
11608 *
11609 * The result includes all necessary quoting and schema-prefixing.
11610 */
11614 ParseExprKind special_exprkind)
11615 {
11617 HeapTuple proctup;
11618 Form_pg_proc procform;
11622 FuncDetailCode p_result;
11623 Oid p_funcid;
11624 Oid p_rettype;
11627 Oid p_vatype;
11637 /*
11638 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
11639 * qualification in some special cases.
11640 */
11642 {
11645 }
11647 /*
11648 * Determine whether VARIADIC should be printed. We must do this first
11649 * since it affects the lookup rules in func_get_detail().
11650 *
11651 * We always print VARIADIC if the function has a merged variadic-array
11652 * argument. Note that this is always the case for functions taking a
11653 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
11654 * and printed the array elements as separate arguments, the call could
11655 * match a newer non-VARIADIC function.
11656 */
11658 {
11659 /* Parser should not have set funcvariadic unless fn is variadic */
11663 }
11664 else
11665 {
11668 }
11670 /*
11671 * The idea here is to schema-qualify only if the parser would fail to
11672 * resolve the correct function given the unqualified func name with the
11673 * specified argtypes and VARIADIC flag. But if we already decided to
11674 * force qualification, then we can skip the lookup and pretend we didn't
11675 * find it.
11676 */
11684 else
11685 {
11688 }
11695 else
11703 }
11705 /*
11706 * generate_operator_name
11707 * Compute the name to display for an operator specified by OID,
11708 * given that it is being called with the specified actual arg types.
11709 * (Arg types matter because of ambiguous-operator resolution rules.
11710 * Pass InvalidOid for unused arg of a unary operator.)
11711 *
11712 * The result includes all necessary quoting and schema-prefixing,
11713 * plus the OPERATOR() decoration needed to use a qualified operator name
11714 * in an expression.
11715 */
11718 {
11719 StringInfoData buf;
11720 HeapTuple opertup;
11721 Form_pg_operator operform;
11724 Operator p_result;
11734 /*
11735 * The idea here is to schema-qualify only if the parser would fail to
11736 * resolve the correct operator given the unqualified op name with the
11737 * specified argtypes.
11738 */
11740 {
11753 }
11757 else
11758 {
11761 }
11774 }
11776 /*
11777 * generate_operator_clause --- generate a binary-operator WHERE clause
11778 *
11779 * This is used for internally-generated-and-executed SQL queries, where
11780 * precision is essential and readability is secondary. The basic
11781 * requirement is to append "leftop op rightop" to buf, where leftop and
11782 * rightop are given as strings and are assumed to yield types leftoptype
11783 * and rightoptype; the operator is identified by OID. The complexity
11784 * comes from needing to be sure that the parser will select the desired
11785 * operator when the query is parsed. We always name the operator using
11786 * OPERATOR(schema.op) syntax, so as to avoid search-path uncertainties.
11787 * We have to emit casts too, if either input isn't already the input type
11788 * of the operator; else we are at the mercy of the parser's heuristics for
11789 * ambiguous-operator resolution. The caller must ensure that leftop and
11790 * rightop are suitable arguments for a cast operation; it's best to insert
11791 * parentheses if they aren't just variables or parameters.
11792 */
11793 void
11796 Oid opoid,
11798 {
11799 HeapTuple opertup;
11800 Form_pg_operator operform;
11823 }
11825 /*
11826 * Add a cast specification to buf. We spell out the type name the hard way,
11827 * intentionally not using format_type_be(). This is to avoid corner cases
11828 * for CHARACTER, BIT, and perhaps other types, where specifying the type
11829 * using SQL-standard syntax results in undesirable data truncation. By
11830 * doing it this way we can be certain that the cast will have default (-1)
11831 * target typmod.
11832 */
11833 static void
11835 {
11836 HeapTuple typetup;
11837 Form_pg_type typform;
11853 }
11855 /*
11856 * generate_qualified_type_name
11857 * Compute the name to display for a type specified by OID
11858 *
11859 * This is different from format_type_be() in that we unconditionally
11860 * schema-qualify the name. That also means no special syntax for
11861 * SQL-standard type names ... although in current usage, this should
11862 * only get used for domains, so such cases wouldn't occur anyway.
11863 */
11866 {
11867 HeapTuple tp;
11868 Form_pg_type typtup;
11889 }
11891 /*
11892 * generate_collation_name
11893 * Compute the name to display for a collation specified by OID
11894 *
11895 * The result includes all necessary quoting and schema-prefixing.
11896 */
11899 {
11900 HeapTuple tp;
11901 Form_pg_collation colltup;
11914 else
11922 }
11924 /*
11925 * Given a C string, produce a TEXT datum.
11926 *
11927 * We assume that the input was palloc'd and may be freed.
11928 */
11931 {
11937 }
11939 /*
11940 * Generate a C string representing a relation options from text[] datum.
11941 */
11942 static void
11944 {
11954 {
11960 /*
11961 * Each array element should have the form name=value. If the "=" is
11962 * missing for some reason, treat it like an empty value.
11963 */
11967 {
11970 }
11971 else
11978 /*
11979 * In general we need to quote the value; but to avoid unnecessary
11980 * clutter, do not quote if it is an identifier that would not need
11981 * quoting. (We could also allow numbers, but that is a bit trickier
11982 * than it looks --- for example, are leading zeroes significant? We
11983 * don't want to assume very much here about what custom reloptions
11984 * might mean.)
11985 */
11988 else
11992 }
11993 }
11995 /*
11996 * Generate a C string representing a relation's reloptions, or NULL if none.
11997 */
12000 {
12002 HeapTuple tuple;
12003 Datum reloptions;
12013 {
12014 StringInfoData buf;
12020 }
12025 }
12027 /*
12028 * get_range_partbound_string
12029 * A C string representation of one range partition bound
12030 */
12033 {
12034 deparse_context context;
12045 {
12054 else
12055 {
12059 }
12061 }
12065 }