| blob | 54dad975553d2a6614a611c7dd4eedb81f22ea80 |
1 /*-------------------------------------------------------------------------
2 *
3 * ruleutils.c
4 * Functions to convert stored expressions/querytrees back to
5 * source text
6 *
7 * Portions Copyright (c) 1996-2025, 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>
75 /* ----------
76 * Pretty formatting constants
77 * ----------
78 */
80 /* Indent counts */
81 #define PRETTYINDENT_STD 8
82 #define PRETTYINDENT_JOIN 4
83 #define PRETTYINDENT_VAR 4
87 /* Pretty flags */
88 #define PRETTYFLAG_PAREN 0x0001
89 #define PRETTYFLAG_INDENT 0x0002
90 #define PRETTYFLAG_SCHEMA 0x0004
92 /* Standard conversion of a "bool pretty" option to detailed flags */
93 #define GET_PRETTY_FLAGS(pretty) \
94 ((pretty) ? (PRETTYFLAG_PAREN | PRETTYFLAG_INDENT | PRETTYFLAG_SCHEMA) \
95 : PRETTYFLAG_INDENT)
97 /* Default line length for pretty-print wrapping: 0 means wrap always */
98 #define WRAP_COLUMN_DEFAULT 0
100 /* macros to test if pretty action needed */
101 #define PRETTY_PAREN(context) ((context)->prettyFlags & PRETTYFLAG_PAREN)
102 #define PRETTY_INDENT(context) ((context)->prettyFlags & PRETTYFLAG_INDENT)
103 #define PRETTY_SCHEMA(context) ((context)->prettyFlags & PRETTYFLAG_SCHEMA)
106 /* ----------
107 * Local data types
108 * ----------
109 */
111 /* Context info needed for invoking a recursive querytree display routine */
113 {
127 * back to the parent rel */
130 /*
131 * Each level of query context around a subtree needs a level of Var namespace.
132 * A Var having varlevelsup=N refers to the N'th item (counting from 0) in
133 * the current context's namespaces list.
134 *
135 * rtable is the list of actual RTEs from the Query or PlannedStmt.
136 * rtable_names holds the alias name to be used for each RTE (either a C
137 * string, or NULL for nameless RTEs such as unnamed joins).
138 * rtable_columns holds the column alias names to be used for each RTE.
139 *
140 * subplans is a list of Plan trees for SubPlans and CTEs (it's only used
141 * in the PlannedStmt case).
142 * ctes is a list of CommonTableExpr nodes (only used in the Query case).
143 * appendrels, if not null (it's only used in the PlannedStmt case), is an
144 * array of AppendRelInfo nodes, indexed by child relid. We use that to map
145 * child-table Vars to their inheritance parents.
146 *
147 * In some cases we need to make names of merged JOIN USING columns unique
148 * across the whole query, not only per-RTE. If so, unique_using is true
149 * and using_names is a list of C strings representing names already assigned
150 * to USING columns.
151 *
152 * When deparsing plan trees, there is always just a single item in the
153 * deparse_namespace list (since a plan tree never contains Vars with
154 * varlevelsup > 0). We store the Plan node that is the immediate
155 * parent of the expression to be deparsed, as well as a list of that
156 * Plan's ancestors. In addition, we store its outer and inner subplan nodes,
157 * as well as their targetlists, and the index tlist if the current plan node
158 * might contain INDEX_VAR Vars. (These fields could be derived on-the-fly
159 * from the current Plan node, but it seems notationally clearer to set them
160 * up as separate fields.)
161 */
163 {
172 /* Workspace for column alias assignment: */
175 /* Remaining fields are used only when deparsing a Plan tree: */
183 /* Special namespace representing a function signature: */
189 /*
190 * Per-relation data about column alias names.
191 *
192 * Selecting aliases is unreasonably complicated because of the need to dump
193 * rules/views whose underlying tables may have had columns added, deleted, or
194 * renamed since the query was parsed. We must nonetheless print the rule/view
195 * in a form that can be reloaded and will produce the same results as before.
196 *
197 * For each RTE used in the query, we must assign column aliases that are
198 * unique within that RTE. SQL does not require this of the original query,
199 * but due to factors such as *-expansion we need to be able to uniquely
200 * reference every column in a decompiled query. As long as we qualify all
201 * column references, per-RTE uniqueness is sufficient for that.
202 *
203 * However, we can't ensure per-column name uniqueness for unnamed join RTEs,
204 * since they just inherit column names from their input RTEs, and we can't
205 * rename the columns at the join level. Most of the time this isn't an issue
206 * because we don't need to reference the join's output columns as such; we
207 * can reference the input columns instead. That approach can fail for merged
208 * JOIN USING columns, however, so when we have one of those in an unnamed
209 * join, we have to make that column's alias globally unique across the whole
210 * query to ensure it can be referenced unambiguously.
211 *
212 * Another problem is that a JOIN USING clause requires the columns to be
213 * merged to have the same aliases in both input RTEs, and that no other
214 * columns in those RTEs or their children conflict with the USING names.
215 * To handle that, we do USING-column alias assignment in a recursive
216 * traversal of the query's jointree. When descending through a JOIN with
217 * USING, we preassign the USING column names to the child columns, overriding
218 * other rules for column alias assignment. We also mark each RTE with a list
219 * of all USING column names selected for joins containing that RTE, so that
220 * when we assign other columns' aliases later, we can avoid conflicts.
221 *
222 * Another problem is that if a JOIN's input tables have had columns added or
223 * deleted since the query was parsed, we must generate a column alias list
224 * for the join that matches the current set of input columns --- otherwise, a
225 * change in the number of columns in the left input would throw off matching
226 * of aliases to columns of the right input. Thus, positions in the printable
227 * column alias list are not necessarily one-for-one with varattnos of the
228 * JOIN, so we need a separate new_colnames[] array for printing purposes.
229 *
230 * Finally, when dealing with wide tables we risk O(N^2) costs in assigning
231 * non-duplicate column names. We ameliorate that by using a hash table that
232 * holds all the strings appearing in colnames, new_colnames, and parentUsing.
233 */
235 {
236 /*
237 * colnames is an array containing column aliases to use for columns that
238 * existed when the query was parsed. Dropped columns have NULL entries.
239 * This array can be directly indexed by varattno to get a Var's name.
240 *
241 * Non-NULL entries are guaranteed unique within the RTE, *except* when
242 * this is for an unnamed JOIN RTE. In that case we merely copy up names
243 * from the two input RTEs.
244 *
245 * During the recursive descent in set_using_names(), forcible assignment
246 * of a child RTE's column name is represented by pre-setting that element
247 * of the child's colnames array. So at that stage, NULL entries in this
248 * array just mean that no name has been preassigned, not necessarily that
249 * the column is dropped.
250 */
254 /*
255 * new_colnames is an array containing column aliases to use for columns
256 * that would exist if the query was re-parsed against the current
257 * definitions of its base tables. This is what to print as the column
258 * alias list for the RTE. This array does not include dropped columns,
259 * but it will include columns added since original parsing. Indexes in
260 * it therefore have little to do with current varattno values. As above,
261 * entries are unique unless this is for an unnamed JOIN RTE. (In such an
262 * RTE, we never actually print this array, but we must compute it anyway
263 * for possible use in computing column names of upper joins.) The
264 * parallel array is_new_col marks which of these columns are new since
265 * original parsing. Entries with is_new_col false must match the
266 * non-NULL colnames entries one-for-one.
267 */
272 /* This flag tells whether we should actually print a column alias list */
275 /* This list has all names used as USING names in joins above this RTE */
278 /*
279 * If this struct is for a JOIN RTE, we fill these fields during the
280 * set_using_names() pass to describe its relationship to its child RTEs.
281 *
282 * leftattnos and rightattnos are arrays with one entry per existing
283 * output column of the join (hence, indexable by join varattno). For a
284 * simple reference to a column of the left child, leftattnos[i] is the
285 * child RTE's attno and rightattnos[i] is zero; and conversely for a
286 * column of the right child. But for merged columns produced by JOIN
287 * USING/NATURAL JOIN, both leftattnos[i] and rightattnos[i] are nonzero.
288 * Note that a simple reference might be to a child RTE column that's been
289 * dropped; but that's OK since the column could not be used in the query.
290 *
291 * If it's a JOIN USING, usingNames holds the alias names selected for the
292 * merged columns (these might be different from the original USING list,
293 * if we had to modify names to achieve uniqueness).
294 */
301 /*
302 * Hash table holding copies of all the strings appearing in this struct's
303 * colnames, new_colnames, and parentUsing. We use a hash table only for
304 * sufficiently wide relations, and only during the colname-assignment
305 * functions set_relation_column_names and set_join_column_names;
306 * otherwise, names_hash is NULL.
307 */
311 /* This macro is analogous to rt_fetch(), but for deparse_columns structs */
312 #define deparse_columns_fetch(rangetable_index, dpns) \
313 ((deparse_columns *) list_nth((dpns)->rtable_columns, (rangetable_index)-1))
315 /*
316 * Entry in set_rtable_names' hash table
317 */
319 {
324 /* Callback signature for resolve_special_varno() */
329 /* ----------
330 * Global data
331 * ----------
332 */
334 static const char *const query_getrulebyoid = "SELECT * FROM pg_catalog.pg_rewrite WHERE oid = $1";
336 static const char *const query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";
338 /* GUC parameters */
342 /* ----------
343 * Local functions
344 *
345 * Most of these functions used to use fixed-size buffers to build their
346 * results. Now, they take an (already initialized) StringInfo object
347 * as a parameter, and append their text output to its contents.
348 * ----------
349 */
498 StringInfo buf);
521 StringInfo buf);
550 /* ----------
551 * pg_get_ruledef - Do it all and return a text
552 * that could be used as a statement
553 * to recreate the rule
554 * ----------
555 */
556 Datum
558 {
571 }
574 Datum
576 {
590 }
595 {
599 HeapTuple ruletup;
600 TupleDesc rulettc;
601 StringInfoData buf;
603 /*
604 * Do this first so that string is alloc'd in outer context not SPI's.
605 */
608 /*
609 * Connect to SPI manager
610 */
613 /*
614 * On the first call prepare the plan to lookup pg_rewrite. We read
615 * pg_rewrite over the SPI manager instead of using the syscache to be
616 * checked for read access on pg_rewrite.
617 */
619 {
621 SPIPlanPtr plan;
629 }
631 /*
632 * Get the pg_rewrite tuple for this rule
633 */
640 {
641 /*
642 * There is no tuple data available here, just keep the output buffer
643 * empty.
644 */
645 }
646 else
647 {
648 /*
649 * Get the rule's definition and put it into executor's memory
650 */
654 }
656 /*
657 * Disconnect from SPI manager
658 */
666 }
669 /* ----------
670 * pg_get_viewdef - Mainly the same thing, but we
671 * only return the SELECT part of a view
672 * ----------
673 */
674 Datum
676 {
677 /* By OID */
690 }
693 Datum
695 {
696 /* By OID */
710 }
712 Datum
714 {
715 /* By OID */
721 /* calling this implies we want pretty printing */
730 }
732 Datum
734 {
735 /* By qualified name */
739 Oid viewoid;
744 /* Look up view name. Can't lock it - we might not have privileges. */
754 }
757 Datum
759 {
760 /* By qualified name */
765 Oid viewoid;
770 /* Look up view name. Can't lock it - we might not have privileges. */
780 }
782 /*
783 * Common code for by-OID and by-name variants of pg_get_viewdef
784 */
787 {
791 HeapTuple ruletup;
792 TupleDesc rulettc;
793 StringInfoData buf;
795 /*
796 * Do this first so that string is alloc'd in outer context not SPI's.
797 */
800 /*
801 * Connect to SPI manager
802 */
805 /*
806 * On the first call prepare the plan to lookup pg_rewrite. We read
807 * pg_rewrite over the SPI manager instead of using the syscache to be
808 * checked for read access on pg_rewrite.
809 */
811 {
813 SPIPlanPtr plan;
822 }
824 /*
825 * Get the pg_rewrite tuple for the view's SELECT rule
826 */
835 {
836 /*
837 * There is no tuple data available here, just keep the output buffer
838 * empty.
839 */
840 }
841 else
842 {
843 /*
844 * Get the rule's definition and put it into executor's memory
845 */
849 }
851 /*
852 * Disconnect from SPI manager
853 */
861 }
863 /* ----------
864 * pg_get_triggerdef - Get the definition of a trigger
865 * ----------
866 */
867 Datum
869 {
879 }
881 Datum
883 {
894 }
898 {
899 HeapTuple ht_trig;
900 Form_pg_trigger trigrec;
901 StringInfoData buf;
902 Relation tgrel;
904 SysScanDesc tgscan;
909 Datum value;
912 /*
913 * Fetch the pg_trigger tuple by the Oid of the trigger
914 */
918 Anum_pg_trigger_oid,
928 {
932 }
936 /*
937 * Start the trigger definition. Note that the trigger's name should never
938 * be schema-qualified, but the trigger rel's name may be.
939 */
953 else
957 {
959 findx++;
960 }
962 {
965 else
967 findx++;
968 }
970 {
973 else
975 findx++;
976 /* tgattr is first var-width field, so OK to access directly */
978 {
983 {
991 }
992 }
993 }
995 {
998 else
1000 findx++;
1001 }
1003 /*
1004 * In non-pretty mode, always schema-qualify the target table name for
1005 * safety. In pretty mode, schema-qualify only if not visible.
1006 */
1008 pretty ?
1013 {
1022 else
1024 }
1030 else
1036 else
1039 {
1047 }
1051 else
1054 /* If the trigger has a WHEN qualification, add that */
1058 {
1061 deparse_context context;
1062 deparse_namespace dpns;
1072 /* Build minimal OLD and NEW RTEs for the rel */
1095 /* Build two-element rtable */
1104 /* Set up context with one-deep namespace stack */
1122 }
1130 {
1140 {
1144 /* advance p to next string embedded in tgargs */
1146 p++;
1147 p++;
1148 }
1149 }
1151 /* We deliberately do not put semi-colon at end */
1154 /* Clean up */
1160 }
1162 /* ----------
1163 * pg_get_indexdef - Get the definition of an index
1164 *
1165 * In the extended version, there is a colno argument as well as pretty bool.
1166 * if colno == 0, we want a complete index definition.
1167 * if colno > 0, we only want the Nth index key's variable or expression.
1168 *
1169 * Note that the SQL-function versions of this omit any info about the
1170 * index tablespace; this is intentional because pg_dump wants it that way.
1171 * However pg_get_indexdef_string() includes the index tablespace.
1172 * ----------
1173 */
1174 Datum
1176 {
1192 }
1194 Datum
1196 {
1214 }
1216 /*
1217 * Internal version for use by ALTER TABLE.
1218 * Includes a tablespace clause in the result.
1219 * Returns a palloc'd C string; no pretty-printing.
1220 */
1223 {
1228 }
1230 /* Internal version that just reports the key-column definitions */
1233 {
1242 }
1244 /* Internal version, extensible with flags to control its behavior */
1247 {
1258 }
1260 /*
1261 * Internal workhorse to decompile an index definition.
1262 *
1263 * This is now used for exclusion constraints as well: if excludeOps is not
1264 * NULL then it points to an array of exclusion operator OIDs.
1265 */
1272 {
1273 /* might want a separate isConstraint parameter later */
1275 HeapTuple ht_idx;
1276 HeapTuple ht_idxrel;
1277 HeapTuple ht_am;
1278 Form_pg_index idxrec;
1279 Form_pg_class idxrelrec;
1280 Form_pg_am amrec;
1285 Oid indrelid;
1287 Datum indcollDatum;
1288 Datum indclassDatum;
1289 Datum indoptionDatum;
1293 StringInfoData buf;
1297 /*
1298 * Fetch the pg_index tuple by the Oid of the index
1299 */
1302 {
1306 }
1312 /* Must get indcollation, indclass, and indoption the hard way */
1314 Anum_pg_index_indcollation);
1318 Anum_pg_index_indclass);
1322 Anum_pg_index_indoption);
1325 /*
1326 * Fetch the pg_class tuple of the index relation
1327 */
1333 /*
1334 * Fetch the pg_am tuple of the index' access method
1335 */
1342 /* Fetch the index AM's API struct */
1345 /*
1346 * Get the index expressions, if any. (NOTE: we do not use the relcache
1347 * versions of the expressions and predicate, because we want to display
1348 * non-const-folded expressions.)
1349 */
1351 {
1352 Datum exprsDatum;
1356 Anum_pg_index_indexprs);
1360 }
1361 else
1368 /*
1369 * Start the index definition. Note that the index's name should never be
1370 * schema-qualified, but the indexed rel's name may be.
1371 */
1375 {
1389 }
1391 /*
1392 * Report the indexed attributes
1393 */
1396 {
1398 Oid keycoltype;
1399 Oid keycolcollation;
1401 /*
1402 * Ignore non-key attributes if told to.
1403 */
1407 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1409 {
1412 }
1419 {
1420 /* Simple index column */
1422 int32 keycoltypmod;
1430 }
1431 else
1432 {
1433 /* expressional index */
1440 /* Deparse */
1444 {
1445 /* Need parens if it's not a bare function call */
1448 else
1450 }
1453 }
1455 /* Print additional decoration for (selected) key columns */
1458 {
1464 /* Add collation, if not default for column */
1469 /* Add the operator class name, if not default */
1474 {
1478 }
1480 /* Add options if relevant */
1482 {
1483 /* if it supports sort ordering, report DESC and NULLS opts */
1485 {
1487 /* NULLS FIRST is the default in this case */
1490 }
1491 else
1492 {
1495 }
1496 }
1498 /* Add the exclusion operator if relevant */
1502 keycoltype,
1503 keycoltype));
1504 }
1505 }
1508 {
1514 /*
1515 * If it has options, append "WITH (options)"
1516 */
1519 {
1522 }
1524 /*
1525 * Print tablespace, but only if requested
1526 */
1528 {
1529 Oid tblspc;
1533 {
1538 }
1539 }
1541 /*
1542 * If it's a partial index, decompile and append the predicate
1543 */
1545 {
1547 Datum predDatum;
1550 /* Convert text string to node tree */
1552 Anum_pg_index_indpred);
1557 /* Deparse */
1562 else
1564 }
1565 }
1567 /* Clean up */
1573 }
1575 /* ----------
1576 * pg_get_querydef
1577 *
1578 * Public entry point to deparse one query parsetree.
1579 * The pretty flags are determined by GET_PRETTY_FLAGS(pretty).
1580 *
1581 * The result is a palloc'd C string.
1582 * ----------
1583 */
1586 {
1587 StringInfoData buf;
1598 }
1600 /*
1601 * pg_get_statisticsobjdef
1602 * Get the definition of an extended statistics object
1603 */
1604 Datum
1606 {
1616 }
1618 /*
1619 * Internal version for use by ALTER TABLE.
1620 * Includes a tablespace clause in the result.
1621 * Returns a palloc'd C string; no pretty-printing.
1622 */
1625 {
1627 }
1629 /*
1630 * pg_get_statisticsobjdef_columns
1631 * Get columns and expressions for an extended statistics object
1632 */
1633 Datum
1635 {
1645 }
1647 /*
1648 * Internal workhorse to decompile an extended statistics object.
1649 */
1652 {
1653 Form_pg_statistic_ext statextrec;
1654 HeapTuple statexttup;
1655 StringInfoData buf;
1660 Datum datum;
1674 {
1678 }
1680 /* has the statistics expressions? */
1685 /*
1686 * Get the statistics expressions, if any. (NOTE: we do not use the
1687 * relcache versions of the expressions, because we want to display
1688 * non-const-folded expressions.)
1689 */
1691 {
1692 Datum exprsDatum;
1696 Anum_pg_statistic_ext_stxexprs);
1700 }
1701 else
1704 /* count the number of columns (attributes and expressions) */
1710 {
1716 /*
1717 * Decode the stxkind column so that we know which stats types to
1718 * print.
1719 */
1721 Anum_pg_statistic_ext_stxkind);
1734 {
1742 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
1743 }
1745 /*
1746 * If any option is disabled, then we'll need to append the types
1747 * clause to show which options are enabled. We omit the types clause
1748 * on purpose when all options are enabled, so a pg_dump/pg_restore
1749 * will create all statistics types on a newer postgres version, if
1750 * the statistics had all options enabled on the original version.
1751 *
1752 * But if the statistics is defined on just a single column, it has to
1753 * be an expression statistics. In that case we don't need to specify
1754 * kinds.
1755 */
1758 {
1764 {
1767 }
1770 {
1773 }
1779 }
1782 }
1784 /* decode simple column references */
1786 {
1796 }
1802 {
1813 /* Need parens if it's not a bare function call */
1816 else
1819 colno++;
1820 }
1829 }
1831 /*
1832 * Generate text array of expressions for statistics object.
1833 */
1834 Datum
1836 {
1838 Form_pg_statistic_ext statextrec;
1839 HeapTuple statexttup;
1840 Datum datum;
1853 /* Does the stats object have expressions? */
1856 /* no expressions? we're done */
1858 {
1861 }
1865 /*
1866 * Get the statistics expressions, and deparse them into text values.
1867 */
1869 Anum_pg_statistic_ext_stxexprs);
1878 {
1889 TEXTOID,
1890 CurrentMemoryContext);
1891 }
1896 }
1898 /*
1899 * pg_get_partkeydef
1900 *
1901 * Returns the partition key specification, ie, the following:
1902 *
1903 * { RANGE | LIST | HASH } (column opt_collation opt_opclass [, ...])
1904 */
1905 Datum
1907 {
1917 }
1919 /* Internal version that just reports the column definitions */
1922 {
1928 }
1930 /*
1931 * Internal workhorse to decompile a partition key definition.
1932 */
1936 {
1937 Form_pg_partitioned_table form;
1938 HeapTuple tuple;
1944 Datum datum;
1945 StringInfoData buf;
1952 {
1956 }
1962 /* Must get partclass and partcollation the hard way */
1964 Anum_pg_partitioned_table_partclass);
1968 Anum_pg_partitioned_table_partcollation);
1972 /*
1973 * Get the expressions, if any. (NOTE: we do not use the relcache
1974 * versions of the expressions, because we want to display
1975 * non-const-folded expressions.)
1976 */
1978 {
1979 Datum exprsDatum;
1983 Anum_pg_partitioned_table_partexprs);
1992 }
1993 else
2002 {
2018 }
2024 {
2026 Oid keycoltype;
2027 Oid keycolcollation;
2028 Oid partcoll;
2033 {
2034 /* Simple attribute reference */
2036 int32 keycoltypmod;
2043 }
2044 else
2045 {
2046 /* Expression */
2054 /* Deparse */
2057 /* Need parens if it's not a bare function call */
2060 else
2065 }
2067 /* Add collation, if not default for column */
2073 /* Add the operator class name, if not default */
2076 }
2081 /* Clean up */
2085 }
2087 /*
2088 * pg_get_partition_constraintdef
2089 *
2090 * Returns partition constraint expression as a string for the input relation
2091 */
2092 Datum
2094 {
2103 /* Quick exit if no partition constraint */
2107 /*
2108 * Deparse and return the constraint expression.
2109 */
2116 }
2118 /*
2119 * pg_get_partconstrdef_string
2120 *
2121 * Returns the partition constraint as a C-string for the input relation, with
2122 * the given alias. No pretty-printing.
2123 */
2126 {
2134 }
2136 /*
2137 * pg_get_constraintdef
2138 *
2139 * Returns the definition for the constraint, ie, everything that needs to
2140 * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
2141 */
2142 Datum
2144 {
2157 }
2159 Datum
2161 {
2175 }
2177 /*
2178 * Internal version that returns a full ALTER TABLE ... ADD CONSTRAINT command
2179 */
2182 {
2184 }
2186 /*
2187 * As of 9.4, we now use an MVCC snapshot for this.
2188 */
2192 {
2193 HeapTuple tup;
2194 Form_pg_constraint conForm;
2195 StringInfoData buf;
2196 SysScanDesc scandesc;
2202 Anum_pg_constraint_oid,
2207 ConstraintOidIndexId,
2209 snapshot,
2211 scankey);
2213 /*
2214 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2215 * via SearchSysCache, which works fine.
2216 */
2222 {
2224 {
2228 }
2230 }
2237 {
2239 {
2240 /*
2241 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2242 * constraints, and other types of constraints don't inherit
2243 * anyway so it doesn't matter whether we say ONLY or not. Someday
2244 * we might need to let callers specify whether to put ONLY in the
2245 * command.
2246 */
2250 }
2251 else
2252 {
2253 /* Must be a domain constraint */
2258 }
2259 }
2262 {
2264 {
2265 Datum val;
2269 /* Start off the constraint definition */
2272 /* Fetch and build referencing-column list */
2274 Anum_pg_constraint_conkey);
2276 /* If it is a temporal foreign key then it uses PERIOD. */
2279 /* add foreign relation name */
2282 NIL));
2284 /* Fetch and build referenced-column list */
2286 Anum_pg_constraint_confkey);
2292 /* Add match type */
2294 {
2309 }
2312 /* Add ON UPDATE and ON DELETE clauses, if needed */
2314 {
2335 }
2340 {
2361 }
2365 /*
2366 * Add columns specified to SET NULL or SET DEFAULT if
2367 * provided.
2368 */
2372 {
2376 }
2379 }
2382 {
2383 Datum val;
2384 Oid indexId;
2386 HeapTuple indtup;
2388 /* Start off the constraint definition */
2391 else
2405 /* Fetch and build target column list */
2407 Anum_pg_constraint_conkey);
2415 /* Build including column list (from pg_index.indkeys) */
2417 Anum_pg_index_indnatts);
2419 {
2420 Datum cols;
2428 Anum_pg_index_indkey);
2434 {
2442 }
2445 }
2448 /* XXX why do we only print these bits if fullCommand? */
2450 {
2452 Oid tblspc;
2455 {
2458 }
2460 /*
2461 * Print the tablespace, unless it's the database default.
2462 * This is to help ALTER TABLE usage of this facility,
2463 * which needs this behavior to recreate exact catalog
2464 * state.
2465 */
2470 }
2473 }
2475 {
2476 Datum val;
2482 /* Fetch constraint expression in parsetree form */
2484 Anum_pg_constraint_conbin);
2489 /* Set up deparsing context for Var nodes in constraint */
2491 {
2492 /* relation constraint */
2495 }
2496 else
2497 {
2498 /* domain constraint --- can't have Vars */
2500 }
2505 /*
2506 * Now emit the constraint definition, adding NO INHERIT if
2507 * necessary.
2508 *
2509 * There are cases where the constraint expression will be
2510 * fully parenthesized and we don't need the outer parens ...
2511 * but there are other cases where we do need 'em. Be
2512 * conservative for now.
2513 *
2514 * Note that simply checking for leading '(' and trailing ')'
2515 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2516 */
2518 consrc,
2521 }
2523 {
2525 {
2526 AttrNumber attnum;
2535 }
2537 {
2538 /* conkey is null for domain not-null constraints */
2540 }
2542 }
2546 /*
2547 * There isn't an ALTER TABLE syntax for creating a user-defined
2548 * constraint trigger, but it seems better to print something than
2549 * throw an error; if we throw error then this function couldn't
2550 * safely be applied to all rows of pg_constraint.
2551 */
2555 {
2557 Datum val;
2563 /* Extract operator OIDs from the pg_constraint tuple */
2565 Anum_pg_constraint_conexclop);
2574 /* pg_get_indexdef_worker does the rest */
2575 /* suppress tablespace because pg_dump wants it that way */
2579 operators,
2584 prettyFlags,
2587 }
2591 }
2598 /* Validated status is irrelevant when the constraint is NOT ENFORCED. */
2604 /* Cleanup */
2609 }
2612 /*
2613 * Convert an int16[] Datum into a comma-separated list of column names
2614 * for the indicated relation; append the list to buf. Returns the number
2615 * of keys.
2616 */
2617 static int
2620 {
2625 /* Extract data from array of int16 */
2630 {
2637 else
2641 }
2644 }
2647 /* ----------
2648 * pg_get_expr - Decompile an expression tree
2649 *
2650 * Input: an expression tree in nodeToString form, and a relation OID
2651 *
2652 * Output: reverse-listed expression
2653 *
2654 * Currently, the expression can only refer to a single relation, namely
2655 * the one specified by the second parameter. This is sufficient for
2656 * partial indexes, column default expressions, etc. We also support
2657 * Var-free expressions, for which the OID can be InvalidOid.
2658 *
2659 * If the OID is nonzero but not actually valid, don't throw an error,
2660 * just return NULL. This is a bit questionable, but it's what we've
2661 * done historically, and it can help avoid unwanted failures when
2662 * examining catalog entries for just-deleted relations.
2663 *
2664 * We expect this function to work, or throw a reasonably clean error,
2665 * for any node tree that can appear in a catalog pg_node_tree column.
2666 * Query trees, such as those appearing in pg_rewrite.ev_action, are
2667 * not supported. Nor are expressions in more than one relation, which
2668 * can appear in places like pg_rewrite.ev_qual.
2669 * ----------
2670 */
2671 Datum
2673 {
2684 else
2686 }
2688 Datum
2690 {
2702 else
2704 }
2708 {
2711 Relids relids;
2717 /* Convert input pg_node_tree (really TEXT) object to C string */
2720 /* Convert expression to node tree */
2725 /*
2726 * Throw error if the input is a querytree rather than an expression tree.
2727 * While we could support queries here, there seems no very good reason
2728 * to. In most such catalog columns, we'll see a List of Query nodes, or
2729 * even nested Lists, so drill down to a non-List node before checking.
2730 */
2739 /*
2740 * Throw error if the expression contains Vars we won't be able to
2741 * deparse.
2742 */
2745 {
2750 }
2751 else
2752 {
2757 }
2759 /*
2760 * Prepare deparse context if needed. If we are deparsing with a relid,
2761 * we need to transiently open and lock the rel, to make sure it won't go
2762 * away underneath us. (set_relation_column_names would lock it anyway,
2763 * so this isn't really introducing any new behavior.)
2764 */
2766 {
2771 }
2772 else
2775 /* Deparse */
2783 }
2786 /* ----------
2787 * pg_get_userbyid - Get a user name by roleid and
2788 * fallback to 'unknown (OID=n)'
2789 * ----------
2790 */
2791 Datum
2793 {
2795 Name result;
2796 HeapTuple roletup;
2797 Form_pg_authid role_rec;
2799 /*
2800 * Allocate space for the result
2801 */
2805 /*
2806 * Get the pg_authid entry and print the result
2807 */
2810 {
2814 }
2815 else
2819 }
2822 /*
2823 * pg_get_serial_sequence
2824 * Get the name of the sequence used by an identity or serial column,
2825 * formatted suitably for passing to setval, nextval or currval.
2826 * First parameter is not treated as double-quoted, second parameter
2827 * is --- see documentation for reason.
2828 */
2829 Datum
2831 {
2835 Oid tableOid;
2837 AttrNumber attnum;
2839 Relation depRel;
2841 SysScanDesc scan;
2842 HeapTuple tup;
2844 /* Look up table name. Can't lock it - we might not have privileges. */
2848 /* Get the number of the column */
2858 /* Search the dependency table for the dependent sequence */
2862 Anum_pg_depend_refclassid,
2866 Anum_pg_depend_refobjid,
2870 Anum_pg_depend_refobjsubid,
2878 {
2881 /*
2882 * Look for an auto dependency (serial column) or internal dependency
2883 * (identity column) of a sequence on a column. (We need the relkind
2884 * test because indexes can also have auto dependencies on columns.)
2885 */
2891 {
2894 }
2895 }
2901 {
2907 }
2910 }
2913 /*
2914 * pg_get_functiondef
2915 * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
2916 * the specified function.
2917 *
2918 * Note: if you change the output format of this function, be careful not
2919 * to break psql's rules (in \ef and \sf) for identifying the start of the
2920 * function body. To wit: the function body starts on a line that begins with
2921 * "AS ", "BEGIN ", or "RETURN ", and no preceding line will look like that.
2922 */
2923 Datum
2925 {
2927 StringInfoData buf;
2928 StringInfoData dq;
2929 HeapTuple proctup;
2930 Form_pg_proc proc;
2932 Datum tmp;
2937 float4 procost;
2942 /* Look up the function */
2957 /*
2958 * We always qualify the function name, to ensure the right function gets
2959 * replaced.
2960 */
2968 {
2972 }
2979 /* Emit some miscellaneous options on one line */
2985 {
2994 }
2997 {
3006 }
3015 /* This code for the default cost and rows should match functioncmds.c */
3019 else
3028 {
3031 /*
3032 * We should qualify the support function's name if it wouldn't be
3033 * resolved by lookup in the current search path.
3034 */
3040 }
3045 /* Emit any proconfig options, one per line */
3048 {
3057 {
3058 Datum d;
3067 {
3079 /*
3080 * Variables that are marked GUC_LIST_QUOTE were already fully
3081 * quoted by flatten_set_variable_args() before they were put
3082 * into the proconfig array. However, because the quoting
3083 * rules used there aren't exactly like SQL's, we have to
3084 * break the list value apart and then quote the elements as
3085 * string literals. (The elements may be double-quoted as-is,
3086 * but we can't just feed them to the SQL parser; it would do
3087 * the wrong thing with elements that are zero-length or
3088 * longer than NAMEDATALEN.)
3089 *
3090 * Variables that are not so marked should just be emitted as
3091 * simple string literals. If the variable is not known to
3092 * guc.c, we'll do that; this makes it unsafe to use
3093 * GUC_LIST_QUOTE for extension variables.
3094 */
3096 {
3100 /* Parse string into list of identifiers */
3102 {
3103 /* this shouldn't fail really */
3105 }
3107 {
3113 }
3114 }
3115 else
3118 }
3119 }
3120 }
3122 /* And finally the function definition ... */
3125 {
3127 }
3128 else
3129 {
3134 {
3137 }
3142 /*
3143 * We always use dollar quoting. Figure out a suitable delimiter.
3144 *
3145 * Since the user is likely to be editing the function body string, we
3146 * shouldn't use a short delimiter that he might easily create a
3147 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3148 * if needed.
3149 */
3160 }
3167 }
3169 /*
3170 * pg_get_function_arguments
3171 * Get a nicely-formatted list of arguments for a function.
3172 * This is everything that would go between the parentheses in
3173 * CREATE FUNCTION.
3174 */
3175 Datum
3177 {
3179 StringInfoData buf;
3180 HeapTuple proctup;
3193 }
3195 /*
3196 * pg_get_function_identity_arguments
3197 * Get a formatted list of arguments for a function.
3198 * This is everything that would go between the parentheses in
3199 * ALTER FUNCTION, etc. In particular, don't print defaults.
3200 */
3201 Datum
3203 {
3205 StringInfoData buf;
3206 HeapTuple proctup;
3219 }
3221 /*
3222 * pg_get_function_result
3223 * Get a nicely-formatted version of the result type of a function.
3224 * This is what would appear after RETURNS in CREATE FUNCTION.
3225 */
3226 Datum
3228 {
3230 StringInfoData buf;
3231 HeapTuple proctup;
3238 {
3241 }
3250 }
3252 /*
3253 * Guts of pg_get_function_result: append the function's return type
3254 * to the specified buffer.
3255 */
3256 static void
3258 {
3261 StringInfoData rbuf;
3266 {
3267 /* It might be a table function; try to print the arguments */
3272 else
3274 }
3277 {
3278 /* Not a table function, so do the normal thing */
3282 }
3285 }
3287 /*
3288 * Common code for pg_get_function_arguments and pg_get_function_result:
3289 * append the desired subset of arguments to buf. We print only TABLE
3290 * arguments when print_table_args is true, and all the others when it's false.
3291 * We print argument defaults only if print_defaults is true.
3292 * Function return value is the number of arguments printed.
3293 */
3294 static int
3297 {
3316 {
3317 Datum proargdefaults;
3321 Anum_pg_proc_proargdefaults,
3324 {
3331 /* nlackdefaults counts only *input* arguments lacking defaults */
3333 }
3334 }
3336 /* Check for special treatment of ordered-set aggregates */
3338 {
3339 HeapTuple aggtup;
3340 Form_pg_aggregate agg;
3350 }
3355 {
3363 {
3366 /*
3367 * For procedures, explicitly mark all argument modes, so as
3368 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3369 */
3372 else
3397 }
3405 {
3409 }
3418 {
3427 }
3428 argsprinted++;
3430 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3432 {
3433 i--;
3434 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3436 }
3437 }
3440 }
3442 static bool
3444 {
3449 }
3451 /*
3452 * Append used transformed types to specified buffer
3453 */
3454 static void
3456 {
3462 {
3467 {
3471 }
3473 }
3474 }
3476 /*
3477 * Get textual representation of a function argument's default value. The
3478 * second argument of this function is the argument number among all arguments
3479 * (i.e. proallargtypes, *not* proargtypes), starting with 1, because that's
3480 * how information_schema.sql uses it.
3481 */
3482 Datum
3484 {
3487 HeapTuple proctup;
3488 Form_pg_proc proc;
3498 Datum proargdefaults;
3508 {
3511 }
3516 nth_inputarg++;
3519 Anum_pg_proc_proargdefaults,
3522 {
3525 }
3533 /*
3534 * Calculate index into proargdefaults: proargdefaults corresponds to the
3535 * last N input arguments, where N = pronargdefaults.
3536 */
3540 {
3543 }
3550 }
3552 static void
3554 {
3560 Datum tmp;
3573 {
3582 {
3585 /* It seems advisable to get at least AccessShareLock on rels */
3591 }
3594 }
3595 else
3596 {
3599 /* It seems advisable to get at least AccessShareLock on rels */
3603 }
3604 }
3606 Datum
3608 {
3610 StringInfoData buf;
3611 HeapTuple proctup;
3616 /* Look up the function */
3623 {
3626 }
3633 }
3636 /*
3637 * deparse_expression - General utility for deparsing expressions
3638 *
3639 * calls deparse_expression_pretty with all prettyPrinting disabled
3640 */
3644 {
3647 }
3649 /* ----------
3650 * deparse_expression_pretty - General utility for deparsing expressions
3651 *
3652 * expr is the node tree to be deparsed. It must be a transformed expression
3653 * tree (ie, not the raw output of gram.y).
3654 *
3655 * dpcontext is a list of deparse_namespace nodes representing the context
3656 * for interpreting Vars in the node tree. It can be NIL if no Vars are
3657 * expected.
3658 *
3659 * forceprefix is true to force all Vars to be prefixed with their table names.
3660 *
3661 * showimplicit is true to force all implicit casts to be shown explicitly.
3662 *
3663 * Tries to pretty up the output according to prettyFlags and startIndent.
3664 *
3665 * The result is a palloc'd string.
3666 * ----------
3667 */
3672 {
3673 StringInfoData buf;
3674 deparse_context context;
3694 }
3696 /* ----------
3697 * deparse_context_for - Build deparse context for a single relation
3698 *
3699 * Given the reference name (alias) and OID of a relation, build deparsing
3700 * context for an expression referencing only that relation (as varno 1,
3701 * varlevelsup 0). This is sufficient for many uses of deparse_expression.
3702 * ----------
3703 */
3704 List *
3706 {
3712 /* Build a minimal RTE for the rel */
3724 /* Build one-element rtable */
3732 /* Return a one-deep namespace stack */
3734 }
3736 /*
3737 * deparse_context_for_plan_tree - Build deparse context for a Plan tree
3738 *
3739 * When deparsing an expression in a Plan tree, we use the plan's rangetable
3740 * to resolve names of simple Vars. The initialization of column names for
3741 * this is rather expensive if the rangetable is large, and it'll be the same
3742 * for every expression in the Plan tree; so we do it just once and re-use
3743 * the result of this function for each expression. (Note that the result
3744 * is not usable until set_deparse_context_plan() is applied to it.)
3745 *
3746 * In addition to the PlannedStmt, pass the per-RTE alias names
3747 * assigned by a previous call to select_rtable_names_for_explain.
3748 */
3749 List *
3751 {
3756 /* Initialize fields that stay the same across the whole plan tree */
3762 {
3763 /* Set up the array, indexed by child relid */
3770 {
3777 }
3778 }
3779 else
3782 /*
3783 * Set up column name aliases, ignoring any join RTEs; they don't matter
3784 * because plan trees don't contain any join alias Vars.
3785 */
3788 /* Return a one-deep namespace stack */
3790 }
3792 /*
3793 * set_deparse_context_plan - Specify Plan node containing expression
3794 *
3795 * When deparsing an expression in a Plan tree, we might have to resolve
3796 * OUTER_VAR, INNER_VAR, or INDEX_VAR references. To do this, the caller must
3797 * provide the parent Plan node. Then OUTER_VAR and INNER_VAR references
3798 * can be resolved by drilling down into the left and right child plans.
3799 * Similarly, INDEX_VAR references can be resolved by reference to the
3800 * indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
3801 * ForeignScan and CustomScan nodes. (Note that we don't currently support
3802 * deparsing of indexquals in regular IndexScan or BitmapIndexScan nodes;
3803 * for those, we can only deparse the indexqualorig fields, which won't
3804 * contain INDEX_VAR Vars.)
3805 *
3806 * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
3807 * the most-closely-nested first. This is needed to resolve PARAM_EXEC
3808 * Params. Note we assume that all the Plan nodes share the same rtable.
3809 *
3810 * For a ModifyTable plan, we might also need to resolve references to OLD/NEW
3811 * variables in the RETURNING list, so we copy the alias names of the OLD and
3812 * NEW rows from the ModifyTable plan node.
3813 *
3814 * Once this function has been called, deparse_expression() can be called on
3815 * subsidiary expression(s) of the specified Plan node. To deparse
3816 * expressions of a different Plan node in the same Plan tree, re-call this
3817 * function to identify the new parent Plan node.
3818 *
3819 * The result is the same List passed in; this is a notational convenience.
3820 */
3821 List *
3823 {
3826 /* Should always have one-entry namespace list for Plan deparsing */
3830 /* Set our attention on the specific plan node passed in */
3834 /* For ModifyTable, set aliases for OLD and NEW in RETURNING */
3836 {
3839 }
3842 }
3844 /*
3845 * select_rtable_names_for_explain - Select RTE aliases for EXPLAIN
3846 *
3847 * Determine the relation aliases we'll use during an EXPLAIN operation.
3848 * This is just a frontend to set_rtable_names. We have to expose the aliases
3849 * to EXPLAIN because EXPLAIN needs to know the right alias names to print.
3850 */
3851 List *
3853 {
3854 deparse_namespace dpns;
3862 /* We needn't bother computing column aliases yet */
3865 }
3867 /*
3868 * set_rtable_names: select RTE aliases to be used in printing a query
3869 *
3870 * We fill in dpns->rtable_names with a list of names that is one-for-one with
3871 * the already-filled dpns->rtable list. Each RTE name is unique among those
3872 * in the new namespace plus any ancestor namespaces listed in
3873 * parent_namespaces.
3874 *
3875 * If rels_used isn't NULL, only RTE indexes listed in it are given aliases.
3876 *
3877 * Note that this function is only concerned with relation names, not column
3878 * names.
3879 */
3880 static void
3883 {
3884 HASHCTL hash_ctl;
3892 /* nothing more to do if empty rtable */
3896 /*
3897 * We use a hash table to hold known names, so that this process is O(N)
3898 * not O(N^2) for N names.
3899 */
3908 /* Preload the hash table with names appearing in parent_namespaces */
3910 {
3915 {
3921 oldname,
3922 HASH_ENTER,
3924 /* we do not complain about duplicate names in parent namespaces */
3926 }
3927 }
3929 /* Now we can scan the rtable */
3932 {
3936 /* Just in case this takes an unreasonable amount of time ... */
3940 {
3941 /* Ignore unreferenced RTE */
3943 }
3945 {
3946 /* If RTE has a user-defined alias, prefer that */
3948 }
3950 {
3951 /* Use the current actual name of the relation */
3953 }
3955 {
3956 /* Unnamed join has no refname */
3958 }
3959 else
3960 {
3961 /* Otherwise use whatever the parser assigned */
3963 }
3965 /*
3966 * If the selected name isn't unique, append digits to make it so, and
3967 * make a new hash entry for it once we've got a unique name. For a
3968 * very long input name, we might have to truncate to stay within
3969 * NAMEDATALEN.
3970 */
3972 {
3974 refname,
3975 HASH_ENTER,
3978 {
3979 /* Name already in use, must choose a new one */
3984 do
3985 {
3988 {
3993 /* drop chars from refname to keep all the digits */
3996 }
3998 modname,
3999 HASH_ENTER,
4004 }
4005 else
4006 {
4007 /* Name not previously used, need only initialize hentry */
4009 }
4010 }
4013 rtindex++;
4014 }
4017 }
4019 /*
4020 * set_deparse_for_query: set up deparse_namespace for deparsing a Query tree
4021 *
4022 * For convenience, this is defined to initialize the deparse_namespace struct
4023 * from scratch.
4024 */
4025 static void
4028 {
4032 /* Initialize *dpns and fill rtable/ctes links */
4041 /* Assign a unique relation alias to each RTE */
4044 /* Initialize dpns->rtable_columns to contain zeroed structs */
4050 /* If it's a utility query, it won't have a jointree */
4052 {
4053 /* Detect whether global uniqueness of USING names is needed */
4057 /*
4058 * Select names for columns merged by USING, via a recursive pass over
4059 * the query jointree.
4060 */
4062 }
4064 /*
4065 * Now assign remaining column aliases for each RTE. We do this in a
4066 * linear scan of the rtable, so as to process RTEs whether or not they
4067 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4068 * etc). JOIN RTEs must be processed after their children, but this is
4069 * okay because they appear later in the rtable list than their children
4070 * (cf Asserts in identify_join_columns()).
4071 */
4073 {
4079 else
4081 }
4082 }
4084 /*
4085 * set_simple_column_names: fill in column aliases for non-query situations
4086 *
4087 * This handles EXPLAIN and cases where we only have relation RTEs. Without
4088 * a join tree, we can't do anything smart about join RTEs, but we don't
4089 * need to, because EXPLAIN should never see join alias Vars anyway.
4090 * If we find a join RTE we'll just skip it, leaving its deparse_columns
4091 * struct all-zero. If somehow we try to deparse a join alias Var, we'll
4092 * error out cleanly because the struct's num_cols will be zero.
4093 */
4094 static void
4096 {
4100 /* Initialize dpns->rtable_columns to contain zeroed structs */
4106 /* Assign unique column aliases within each non-join RTE */
4108 {
4114 }
4115 }
4117 /*
4118 * has_dangerous_join_using: search jointree for unnamed JOIN USING
4119 *
4120 * Merged columns of a JOIN USING may act differently from either of the input
4121 * columns, either because they are merged with COALESCE (in a FULL JOIN) or
4122 * because an implicit coercion of the underlying input column is required.
4123 * In such a case the column must be referenced as a column of the JOIN not as
4124 * a column of either input. And this is problematic if the join is unnamed
4125 * (alias-less): we cannot qualify the column's name with an RTE name, since
4126 * there is none. (Forcibly assigning an alias to the join is not a solution,
4127 * since that will prevent legal references to tables below the join.)
4128 * To ensure that every column in the query is unambiguously referenceable,
4129 * we must assign such merged columns names that are globally unique across
4130 * the whole query, aliasing other columns out of the way as necessary.
4131 *
4132 * Because the ensuing re-aliasing is fairly damaging to the readability of
4133 * the query, we don't do this unless we have to. So, we must pre-scan
4134 * the join tree to see if we have to, before starting set_using_names().
4135 */
4136 static bool
4138 {
4140 {
4141 /* nothing to do here */
4142 }
4144 {
4149 {
4152 }
4153 }
4155 {
4158 /* Is it an unnamed JOIN with USING? */
4160 {
4161 /*
4162 * Yes, so check each join alias var to see if any of them are not
4163 * simple references to underlying columns. If so, we have a
4164 * dangerous situation and must pick unique aliases.
4165 */
4168 /* We need only examine the merged columns */
4170 {
4175 }
4176 }
4178 /* Nope, but inspect children */
4183 }
4184 else
4188 }
4190 /*
4191 * set_using_names: select column aliases to be used for merged USING columns
4192 *
4193 * We do this during a recursive descent of the query jointree.
4194 * dpns->unique_using must already be set to determine the global strategy.
4195 *
4196 * Column alias info is saved in the dpns->rtable_columns list, which is
4197 * assumed to be filled with pre-zeroed deparse_columns structs.
4198 *
4199 * parentUsing is a list of all USING aliases assigned in parent joins of
4200 * the current jointree node. (The passed-in list must not be modified.)
4201 *
4202 * Note that we do not use per-deparse_columns hash tables in this function.
4203 * The number of names that need to be assigned should be small enough that
4204 * we don't need to trouble with that.
4205 */
4206 static void
4208 {
4210 {
4211 /* nothing to do now */
4212 }
4214 {
4220 }
4222 {
4233 /* Get info about the shape of the join */
4238 /* Look up the not-yet-filled-in child deparse_columns structs */
4242 /*
4243 * If this join is unnamed, then we cannot substitute new aliases at
4244 * this level, so any name requirements pushed down to here must be
4245 * pushed down again to the children.
4246 */
4248 {
4250 {
4256 /* Push down to left column, unless it's a system column */
4258 {
4261 }
4263 /* Same on the righthand side */
4265 {
4268 }
4269 }
4270 }
4272 /*
4273 * If there's a USING clause, select the USING column names and push
4274 * those names down to the children. We have two strategies:
4275 *
4276 * If dpns->unique_using is true, we force all USING names to be
4277 * unique across the whole query level. In principle we'd only need
4278 * the names of dangerous USING columns to be globally unique, but to
4279 * safely assign all USING names in a single pass, we have to enforce
4280 * the same uniqueness rule for all of them. However, if a USING
4281 * column's name has been pushed down from the parent, we should use
4282 * it as-is rather than making a uniqueness adjustment. This is
4283 * necessary when we're at an unnamed join, and it creates no risk of
4284 * ambiguity. Also, if there's a user-written output alias for a
4285 * merged column, we prefer to use that rather than the input name;
4286 * this simplifies the logic and seems likely to lead to less aliasing
4287 * overall.
4288 *
4289 * If dpns->unique_using is false, we only need USING names to be
4290 * unique within their own join RTE. We still need to honor
4291 * pushed-down names, though.
4292 *
4293 * Though significantly different in results, these two strategies are
4294 * implemented by the same code, with only the difference of whether
4295 * to put assigned names into dpns->using_names.
4296 */
4298 {
4299 /* Copy the input parentUsing list so we don't modify it */
4302 /* USING names must correspond to the first join output columns */
4306 {
4309 /* Assert it's a merged column */
4312 /* Adopt passed-down name if any, else select unique name */
4315 else
4316 {
4317 /* Prefer user-written output alias if any */
4320 /* Make it appropriately unique */
4324 colname);
4325 /* Save it as output column name, too */
4327 }
4329 /* Remember selected names for use later */
4333 /* Push down to left column, unless it's a system column */
4335 {
4338 }
4340 /* Same on the righthand side */
4342 {
4345 }
4347 i++;
4348 }
4349 }
4351 /* Mark child deparse_columns structs with correct parentUsing info */
4355 /* Now recursively assign USING column names in children */
4358 }
4359 else
4362 }
4364 /*
4365 * set_relation_column_names: select column aliases for a non-join RTE
4366 *
4367 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4368 * If any colnames entries are already filled in, those override local
4369 * choices.
4370 */
4371 static void
4374 {
4382 /*
4383 * Construct an array of the current "real" column names of the RTE.
4384 * real_colnames[] will be indexed by physical column number, with NULL
4385 * entries for dropped columns.
4386 */
4388 {
4389 /* Relation --- look to the system catalogs for up-to-date info */
4390 Relation rel;
4391 TupleDesc tupdesc;
4400 {
4405 else
4407 }
4409 }
4410 else
4411 {
4412 /* Otherwise get the column names from eref or expandRTE() */
4416 /*
4417 * Functions returning composites have the annoying property that some
4418 * of the composite type's columns might have been dropped since the
4419 * query was parsed. If possible, use expandRTE() to handle that
4420 * case, since it has the tedious logic needed to find out about
4421 * dropped columns. However, if we're explaining a plan, then we
4422 * don't have rte->functions because the planner thinks that won't be
4423 * needed later, and that breaks expandRTE(). So in that case we have
4424 * to rely on rte->eref, which may lead us to report a dropped
4425 * column's old name; that seems close enough for EXPLAIN's purposes.
4426 *
4427 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4428 * which should be sufficiently up-to-date: no other RTE types can
4429 * have columns get dropped from under them after parsing.
4430 */
4432 {
4433 /* Since we're not creating Vars, rtindex etc. don't matter */
4436 }
4437 else
4445 {
4446 /*
4447 * If the column name we find here is an empty string, then it's a
4448 * dropped column, so change to NULL.
4449 */
4455 i++;
4456 }
4457 }
4459 /*
4460 * Ensure colinfo->colnames has a slot for each column. (It could be long
4461 * enough already, if we pushed down a name for the last column.) Note:
4462 * it's possible that there are now more columns than there were when the
4463 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4464 * We must assign unique aliases to the new columns too, else there could
4465 * be unresolved conflicts when the view/rule is reloaded.
4466 */
4470 /*
4471 * Make sufficiently large new_colnames and is_new_col arrays, too.
4472 *
4473 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4474 * colname_is_unique will not consult that array, which is fine because it
4475 * would only be duplicate effort.
4476 */
4480 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4483 /*
4484 * Scan the columns, select a unique alias for each one, and store it in
4485 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4486 * entries for dropped columns, the latter omits them. Also mark
4487 * new_colnames entries as to whether they are new since parse time; this
4488 * is the case for entries beyond the length of rte->eref->colnames.
4489 */
4494 {
4498 /* Skip dropped columns */
4500 {
4503 }
4505 /* If alias already assigned, that's what to use */
4507 {
4508 /* If user wrote an alias, prefer that over real column name */
4511 else
4514 /* Unique-ify and insert into colinfo */
4519 }
4521 /* Put names of non-dropped columns in new_colnames[] too */
4523 /* And mark them as new or not */
4525 j++;
4527 /* Remember if any assigned aliases differ from "real" name */
4530 }
4532 /* We're now done needing the colinfo's names_hash */
4535 /*
4536 * Set correct length for new_colnames[] array. (Note: if columns have
4537 * been added, colinfo->num_cols includes them, which is not really quite
4538 * right but is harmless, since any new columns must be at the end where
4539 * they won't affect varattnos of pre-existing columns.)
4540 */
4543 /*
4544 * For a relation RTE, we need only print the alias column names if any
4545 * are different from the underlying "real" names. For a function RTE,
4546 * always emit a complete column alias list; this is to protect against
4547 * possible instability of the default column names (eg, from altering
4548 * parameter names). For tablefunc RTEs, we never print aliases, because
4549 * the column names are part of the clause itself. For other RTE types,
4550 * print if we changed anything OR if there were user-written column
4551 * aliases (since the latter would be part of the underlying "reality").
4552 */
4561 else
4563 }
4565 /*
4566 * set_join_column_names: select column aliases for a join RTE
4567 *
4568 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4569 * If any colnames entries are already filled in, those override local
4570 * choices. Also, names for USING columns were already chosen by
4571 * set_using_names(). We further expect that column alias selection has been
4572 * completed for both input RTEs.
4573 */
4574 static void
4577 {
4590 /* Look up the previously-filled-in child deparse_columns structs */
4594 /*
4595 * Ensure colinfo->colnames has a slot for each column. (It could be long
4596 * enough already, if we pushed down a name for the last column.) Note:
4597 * it's possible that one or both inputs now have more columns than there
4598 * were when the query was parsed, but we'll deal with that below. We
4599 * only need entries in colnames for pre-existing columns.
4600 */
4605 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4608 /*
4609 * Scan the join output columns, select an alias for each one, and store
4610 * it in colinfo->colnames. If there are USING columns, set_using_names()
4611 * already selected their names, so we can start the loop at the first
4612 * non-merged column.
4613 */
4616 {
4620 /* Join column must refer to at least one input column */
4623 /* Get the child column name */
4628 else
4629 {
4630 /* We're joining system columns --- use eref name */
4632 }
4634 /* If child col has been dropped, no need to assign a join colname */
4636 {
4639 }
4641 /* In an unnamed join, just report child column names as-is */
4643 {
4647 }
4649 /* If alias already assigned, that's what to use */
4651 {
4652 /* If user wrote an alias, prefer that over real column name */
4655 else
4658 /* Unique-ify and insert into colinfo */
4663 }
4665 /* Remember if any assigned aliases differ from "real" name */
4668 }
4670 /*
4671 * Calculate number of columns the join would have if it were re-parsed
4672 * now, and create storage for the new_colnames and is_new_col arrays.
4673 *
4674 * Note: colname_is_unique will be consulting new_colnames[] during the
4675 * loops below, so its not-yet-filled entries must be zeroes.
4676 */
4683 /*
4684 * Generating the new_colnames array is a bit tricky since any new columns
4685 * added since parse time must be inserted in the right places. This code
4686 * must match the parser, which will order a join's columns as merged
4687 * columns first (in USING-clause order), then non-merged columns from the
4688 * left input (in attnum order), then non-merged columns from the right
4689 * input (ditto). If one of the inputs is itself a join, its columns will
4690 * be ordered according to the same rule, which means newly-added columns
4691 * might not be at the end. We can figure out what's what by consulting
4692 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
4693 *
4694 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
4695 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
4696 * meanings for the current child RTE.
4697 */
4699 /* Handle merged columns; they are first and can't be new */
4704 {
4705 /* column name is already determined and known unique */
4709 /* build bitmapsets of child attnums of merged columns */
4716 }
4718 /* Handle non-merged left-child columns */
4721 {
4725 {
4726 /* Advance ic to next non-dropped old column of left child */
4729 ic++;
4731 ic++;
4732 /* If it is a merged column, we already processed it */
4735 /* Else, advance i to the corresponding existing join column */
4738 i++;
4741 /* Use the already-assigned name of this column */
4743 i++;
4744 }
4745 else
4746 {
4747 /*
4748 * Unique-ify the new child column name and assign, unless we're
4749 * in an unnamed join, in which case just copy
4750 */
4752 {
4758 }
4759 else
4762 }
4765 j++;
4766 }
4768 /* Handle non-merged right-child columns in exactly the same way */
4771 {
4775 {
4776 /* Advance ic to next non-dropped old column of right child */
4779 ic++;
4781 ic++;
4782 /* If it is a merged column, we already processed it */
4785 /* Else, advance i to the corresponding existing join column */
4788 i++;
4791 /* Use the already-assigned name of this column */
4793 i++;
4794 }
4795 else
4796 {
4797 /*
4798 * Unique-ify the new child column name and assign, unless we're
4799 * in an unnamed join, in which case just copy
4800 */
4802 {
4808 }
4809 else
4812 }
4815 j++;
4816 }
4818 /* Assert we processed the right number of columns */
4819 #ifdef USE_ASSERT_CHECKING
4821 i++;
4824 #endif
4826 /* We're now done needing the colinfo's names_hash */
4829 /*
4830 * For a named join, print column aliases if we changed any from the child
4831 * names. Unnamed joins cannot print aliases.
4832 */
4835 else
4837 }
4839 /*
4840 * colname_is_unique: is colname distinct from already-chosen column names?
4841 *
4842 * dpns is query-wide info, colinfo is for the column's RTE
4843 */
4844 static bool
4847 {
4851 /*
4852 * If we have a hash table, consult that instead of linearly scanning the
4853 * colinfo's strings.
4854 */
4856 {
4858 colname,
4859 HASH_FIND,
4862 }
4863 else
4864 {
4865 /* Check against already-assigned column aliases within RTE */
4867 {
4872 }
4874 /*
4875 * If we're building a new_colnames array, check that too (this will
4876 * be partially but not completely redundant with the previous checks)
4877 */
4879 {
4884 }
4886 /*
4887 * Also check against names already assigned for parent-join USING
4888 * cols
4889 */
4891 {
4896 }
4897 }
4899 /*
4900 * Also check against USING-column names that must be globally unique.
4901 * These are not hashed, but there should be few of them.
4902 */
4904 {
4909 }
4912 }
4914 /*
4915 * make_colname_unique: modify colname if necessary to make it unique
4916 *
4917 * dpns is query-wide info, colinfo is for the column's RTE
4918 */
4922 {
4923 /*
4924 * If the selected name isn't unique, append digits to make it so. For a
4925 * very long input name, we might have to truncate to stay within
4926 * NAMEDATALEN.
4927 */
4929 {
4934 do
4935 {
4936 i++;
4938 {
4943 /* drop chars from colname to keep all the digits */
4946 }
4949 }
4951 }
4953 /*
4954 * expand_colnames_array_to: make colinfo->colnames at least n items long
4955 *
4956 * Any added array entries are initialized to zero.
4957 */
4958 static void
4960 {
4962 {
4965 else
4968 }
4969 }
4971 /*
4972 * build_colinfo_names_hash: optionally construct a hash table for colinfo
4973 */
4974 static void
4976 {
4977 HASHCTL hash_ctl;
4981 /*
4982 * Use a hash table only for RTEs with at least 32 columns. (The cutoff
4983 * is somewhat arbitrary, but let's choose it so that this code does get
4984 * exercised in the regression tests.)
4985 */
4989 /*
4990 * Set up the hash table. The entries are just strings with no other
4991 * payload.
4992 */
5001 /*
5002 * Preload the hash table with any names already present (these would have
5003 * come from set_using_names).
5004 */
5006 {
5011 }
5014 {
5019 }
5022 {
5026 }
5027 }
5029 /*
5030 * add_to_names_hash: add a string to the names_hash, if we're using one
5031 */
5032 static void
5034 {
5037 name,
5038 HASH_ENTER,
5039 NULL);
5040 }
5042 /*
5043 * destroy_colinfo_names_hash: destroy hash table when done with it
5044 */
5045 static void
5047 {
5049 {
5052 }
5053 }
5055 /*
5056 * identify_join_columns: figure out where columns of a join come from
5057 *
5058 * Fills the join-specific fields of the colinfo struct, except for
5059 * usingNames which is filled later.
5060 */
5061 static void
5064 {
5070 /* Extract left/right child RT indexes */
5075 else
5082 else
5086 /* Assert children will be processed earlier than join in second pass */
5090 /* Initialize result arrays with zeroes */
5096 /*
5097 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
5098 * Recall that the column(s) merged due to USING are the first column(s)
5099 * of the join output. We need not do anything special while scanning
5100 * joinleftcols, but while scanning joinrightcols we must distinguish
5101 * merged from unmerged columns.
5102 */
5105 {
5109 }
5112 {
5117 else
5119 rcolno++;
5120 }
5122 }
5124 /*
5125 * get_rtable_name: convenience function to get a previously assigned RTE alias
5126 *
5127 * The RTE must belong to the topmost namespace level in "context".
5128 */
5131 {
5136 }
5138 /*
5139 * set_deparse_plan: set up deparse_namespace to parse subexpressions
5140 * of a given Plan node
5141 *
5142 * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
5143 * and index_tlist fields. Caller must already have adjusted the ancestors
5144 * list if necessary. Note that the rtable, subplans, and ctes fields do
5145 * not need to change when shifting attention to different plan nodes in a
5146 * single plan tree.
5147 */
5148 static void
5150 {
5153 /*
5154 * We special-case Append and MergeAppend to pretend that the first child
5155 * plan is the OUTER referent; we have to interpret OUTER Vars in their
5156 * tlists according to one of the children, and the first one is the most
5157 * natural choice.
5158 */
5163 else
5168 else
5171 /*
5172 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
5173 * use OUTER because that could someday conflict with the normal meaning.)
5174 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
5175 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
5176 * that as INNER referent.
5177 *
5178 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
5179 * INNER referent. This is the join from the target relation to the data
5180 * source, and all INNER_VAR Vars in other parts of the query refer to its
5181 * targetlist.
5182 *
5183 * For ON CONFLICT .. UPDATE we just need the inner tlist to point to the
5184 * excluded expression's tlist. (Similar to the SubqueryScan we don't want
5185 * to reuse OUTER, it's used for RETURNING in some modify table cases,
5186 * although not INSERT .. CONFLICT).
5187 */
5197 {
5200 else
5202 }
5203 else
5210 else
5213 /* Set up referent for INDEX_VAR Vars, if needed */
5220 else
5222 }
5224 /*
5225 * Locate the ancestor plan node that is the RecursiveUnion generating
5226 * the WorkTableScan's work table. We can match on wtParam, since that
5227 * should be unique within the plan tree.
5228 */
5231 {
5235 {
5241 }
5245 }
5247 /*
5248 * push_child_plan: temporarily transfer deparsing attention to a child plan
5249 *
5250 * When expanding an OUTER_VAR or INNER_VAR reference, we must adjust the
5251 * deparse context in case the referenced expression itself uses
5252 * OUTER_VAR/INNER_VAR. We modify the top stack entry in-place to avoid
5253 * affecting levelsup issues (although in a Plan tree there really shouldn't
5254 * be any).
5255 *
5256 * Caller must provide a local deparse_namespace variable to save the
5257 * previous state for pop_child_plan.
5258 */
5259 static void
5262 {
5263 /* Save state for restoration later */
5266 /* Link current plan node into ancestors list */
5269 /* Set attention on selected child */
5271 }
5273 /*
5274 * pop_child_plan: undo the effects of push_child_plan
5275 */
5276 static void
5278 {
5281 /* Get rid of ancestors list cell added by push_child_plan */
5284 /* Restore fields changed by push_child_plan */
5287 /* Make sure dpns->ancestors is right (may be unnecessary) */
5289 }
5291 /*
5292 * push_ancestor_plan: temporarily transfer deparsing attention to an
5293 * ancestor plan
5294 *
5295 * When expanding a Param reference, we must adjust the deparse context
5296 * to match the plan node that contains the expression being printed;
5297 * otherwise we'd fail if that expression itself contains a Param or
5298 * OUTER_VAR/INNER_VAR/INDEX_VAR variable.
5299 *
5300 * The target ancestor is conveniently identified by the ListCell holding it
5301 * in dpns->ancestors.
5302 *
5303 * Caller must provide a local deparse_namespace variable to save the
5304 * previous state for pop_ancestor_plan.
5305 */
5306 static void
5309 {
5312 /* Save state for restoration later */
5315 /* Build a new ancestor list with just this node's ancestors */
5320 /* Set attention on selected ancestor */
5322 }
5324 /*
5325 * pop_ancestor_plan: undo the effects of push_ancestor_plan
5326 */
5327 static void
5329 {
5330 /* Free the ancestor list made in push_ancestor_plan */
5333 /* Restore fields changed by push_ancestor_plan */
5335 }
5338 /* ----------
5339 * make_ruledef - reconstruct the CREATE RULE command
5340 * for a given pg_rewrite tuple
5341 * ----------
5342 */
5343 static void
5346 {
5349 Oid ev_class;
5354 Relation ev_relation;
5357 Datum dat;
5360 /*
5361 * Get the attribute values from the rules tuple
5362 */
5396 /*
5397 * Build the rules definition text
5398 */
5404 else
5407 /* The event the rule is fired for */
5409 {
5433 }
5435 /* The relation the rule is fired on */
5441 /* If the rule has an event qualification, add it */
5443 {
5446 deparse_context context;
5447 deparse_namespace dpns;
5455 /*
5456 * We need to make a context for recognizing any Vars in the qual
5457 * (which can only be references to OLD and NEW). Use the rtable of
5458 * the first query in the action list for this purpose.
5459 */
5462 /*
5463 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5464 * into the SELECT, and that's what we need to look at. (Ugly kluge
5465 * ... try to fix this when we redesign querytrees.)
5466 */
5469 /* Must acquire locks right away; see notes in get_query_def() */
5489 }
5493 /* The INSTEAD keyword (if so) */
5497 /* Finally the rules actions */
5499 {
5505 {
5511 else
5513 }
5515 }
5516 else
5517 {
5524 }
5527 }
5530 /* ----------
5531 * make_viewdef - reconstruct the SELECT part of a
5532 * view rewrite rule
5533 * ----------
5534 */
5535 static void
5538 {
5541 Oid ev_class;
5546 Relation ev_relation;
5548 Datum dat;
5551 /*
5552 * Get the attribute values from the rules tuple
5553 */
5579 {
5580 /* keep output buffer empty and leave */
5582 }
5588 {
5589 /* keep output buffer empty and leave */
5591 }
5600 }
5603 /* ----------
5604 * get_query_def - Parse back one query parsetree
5605 *
5606 * query: parsetree to be displayed
5607 * buf: output text is appended to buf
5608 * parentnamespace: list (initially empty) of outer-level deparse_namespace's
5609 * resultDesc: if not NULL, the output tuple descriptor for the view
5610 * represented by a SELECT query. We use the column names from it
5611 * to label SELECT output columns, in preference to names in the query
5612 * colNamesVisible: true if the surrounding context cares about the output
5613 * column names at all (as, for example, an EXISTS() context does not);
5614 * when false, we can suppress dummy column labels such as "?column?"
5615 * prettyFlags: bitmask of PRETTYFLAG_XXX options
5616 * wrapColumn: maximum line length, or -1 to disable wrapping
5617 * startIndent: initial indentation amount
5618 * ----------
5619 */
5620 static void
5624 {
5625 deparse_context context;
5626 deparse_namespace dpns;
5629 /* Guard against excessively long or deeply-nested queries */
5637 /*
5638 * Replace any Vars in the query's targetlist and havingQual that
5639 * reference GROUP outputs with the underlying grouping expressions.
5640 */
5642 {
5647 }
5649 /*
5650 * Before we begin to examine the query, acquire locks on referenced
5651 * relations, and fix up deleted columns in JOIN RTEs. This ensures
5652 * consistent results. Note we assume it's OK to scribble on the passed
5653 * querytree!
5654 *
5655 * We are only deparsing the query (we are not about to execute it), so we
5656 * only need AccessShareLock on the relations it mentions.
5657 */
5678 {
5680 /* We set context.resultDesc only if it's a SELECT */
5713 }
5714 }
5716 /* ----------
5717 * get_values_def - Parse back a VALUES list
5718 * ----------
5719 */
5720 static void
5722 {
5730 {
5737 else
5742 {
5747 else
5750 /*
5751 * Print the value. Whole-row Vars need special treatment.
5752 */
5754 }
5756 }
5757 }
5759 /* ----------
5760 * get_with_clause - Parse back a WITH clause
5761 * ----------
5762 */
5763 static void
5765 {
5774 {
5777 }
5781 else
5784 {
5790 {
5796 {
5799 else
5803 }
5805 }
5808 {
5817 }
5830 {
5838 {
5841 else
5845 }
5848 }
5851 {
5858 {
5861 else
5865 }
5869 {
5873 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
5875 {
5880 }
5881 }
5884 }
5887 }
5890 {
5893 }
5894 else
5896 }
5898 /* ----------
5899 * get_select_query_def - Parse back a SELECT parsetree
5900 * ----------
5901 */
5902 static void
5904 {
5909 /* Insert the WITH clause if given */
5912 /* Subroutines may need to consult the SELECT targetlist and windowClause */
5916 /*
5917 * If the Query node has a setOperations tree, then it's the top level of
5918 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
5919 * fields are interesting in the top query itself.
5920 */
5922 {
5924 /* ORDER BY clauses must be simple in this case */
5926 }
5927 else
5928 {
5931 }
5933 /* Add the ORDER BY clause if given */
5935 {
5940 }
5942 /*
5943 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
5944 * standard spelling of LIMIT.
5945 */
5947 {
5951 }
5953 {
5955 {
5960 }
5961 else
5962 {
5968 else
5970 }
5971 }
5973 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
5975 {
5977 {
5980 /* don't print implicit clauses */
5985 {
5987 /* we intentionally throw an error for LCS_NONE */
6007 }
6011 context)));
6016 }
6017 }
6018 }
6020 /*
6021 * Detect whether query looks like SELECT ... FROM VALUES(),
6022 * with no need to rename the output columns of the VALUES RTE.
6023 * If so, return the VALUES RTE. Otherwise return NULL.
6024 */
6027 {
6031 /*
6032 * We want to detect a match even if the Query also contains OLD or NEW
6033 * rule RTEs. So the idea is to scan the rtable and see if there is only
6034 * one inFromCl RTE that is a VALUES RTE.
6035 */
6037 {
6041 {
6045 }
6048 else
6050 }
6052 /*
6053 * We don't need to check the targetlist in any great detail, because
6054 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6055 * appear inside auto-generated sub-queries with very restricted
6056 * structure. However, DefineView might have modified the tlist by
6057 * injecting new column aliases, or we might have some other column
6058 * aliases forced by a resultDesc. We can only simplify if the RTE's
6059 * column names match the names that get_target_list() would select.
6060 */
6062 {
6070 {
6078 /* compute name that get_target_list would use for column */
6079 colno++;
6082 else
6085 /* does it match the VALUES RTE? */
6088 }
6089 }
6092 }
6094 static void
6096 {
6103 {
6106 }
6108 /*
6109 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6110 * VALUES part. This reverses what transformValuesClause() did at parse
6111 * time.
6112 */
6115 {
6118 }
6120 /*
6121 * Build up the query string - first we say SELECT
6122 */
6125 else
6128 /* Add the DISTINCT clause if given */
6130 {
6132 {
6136 {
6143 }
6145 }
6146 else
6148 }
6150 /* Then we tell what to select (the targetlist) */
6153 /* Add the FROM clause if needed */
6156 /* Add the WHERE clause if given */
6158 {
6162 }
6164 /* Add the GROUP BY clause if given */
6166 {
6178 {
6181 {
6188 }
6189 }
6190 else
6191 {
6194 {
6200 }
6201 }
6204 }
6206 /* Add the HAVING clause if given */
6208 {
6212 }
6214 /* Add the WINDOW clause if needed */
6217 }
6219 /* ----------
6220 * get_target_list - Parse back a SELECT target list
6221 *
6222 * This is also used for RETURNING lists in INSERT/UPDATE/DELETE/MERGE.
6223 * ----------
6224 */
6225 static void
6227 {
6229 StringInfoData targetbuf;
6235 /* we use targetbuf to hold each TLE's text temporarily */
6241 {
6251 colno++;
6253 /*
6254 * Put the new field text into targetbuf so we can decide after we've
6255 * got it whether or not it needs to go on a new line.
6256 */
6260 /*
6261 * We special-case Var nodes rather than using get_rule_expr. This is
6262 * needed because get_rule_expr will display a whole-row Var as
6263 * "foo.*", which is the preferred notation in most contexts, but at
6264 * the top level of a SELECT list it's not right (the parser will
6265 * expand that notation into multiple columns, yielding behavior
6266 * different from a whole-row Var). We need to call get_variable
6267 * directly so that we can tell it to do the right thing, and so that
6268 * we can get the attribute name which is the default AS label.
6269 */
6271 {
6273 }
6274 else
6275 {
6278 /*
6279 * When colNamesVisible is true, we should always show the
6280 * assigned column name explicitly. Otherwise, show it only if
6281 * it's not FigureColname's fallback.
6282 */
6284 }
6286 /*
6287 * Figure out what the result column should be called. In the context
6288 * of a view, use the view's tuple descriptor (so as to pick up the
6289 * effects of any column RENAME that's been done on the view).
6290 * Otherwise, just use what we can find in the TLE.
6291 */
6295 else
6298 /* Show AS unless the column's name is correct as-is */
6300 {
6303 }
6305 /* Restore context's output buffer */
6308 /* Consider line-wrapping if enabled */
6310 {
6313 /* Does the new field start with a new line? */
6316 else
6319 /* If so, we shouldn't add anything */
6321 {
6322 /* instead, remove any trailing spaces currently in buf */
6324 }
6325 else
6326 {
6329 /* Locate the start of the current line in the output buffer */
6333 else
6334 trailing_nl++;
6336 /*
6337 * Add a newline, plus some indentation, if the new field is
6338 * not the first and either the new field would cause an
6339 * overflow or the last field used more than one line.
6340 */
6343 last_was_multiline))
6346 }
6348 /* Remember this field's multiline status for next iteration */
6349 last_was_multiline =
6351 }
6353 /* Add the new field */
6355 }
6357 /* clean up */
6359 }
6361 static void
6363 {
6367 {
6373 /* Add WITH (OLD/NEW) options, if they're not the defaults */
6375 {
6379 }
6381 {
6385 else
6386 {
6390 }
6391 }
6395 /* Add the returning expressions themselves */
6397 }
6398 }
6400 static void
6402 {
6406 /* Guard against excessively long or deeply-nested queries */
6411 {
6418 /*
6419 * We need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y.
6420 * Also add parens if the leaf query contains its own set operations.
6421 * (That shouldn't happen unless one of the other clauses is also
6422 * present, see transformSetOperationTree; but let's be safe.)
6423 */
6438 }
6440 {
6445 /*
6446 * We force parens when nesting two SetOperationStmts, except when the
6447 * lefthand input is another setop of the same kind. Syntactically,
6448 * we could omit parens in rather more cases, but it seems best to use
6449 * parens to flag cases where the setop operator changes. If we use
6450 * parens, we also increase the indentation level for the child query.
6451 *
6452 * There are some cases in which parens are needed around a leaf query
6453 * too, but those are more easily handled at the next level down (see
6454 * code above).
6455 */
6457 {
6462 else
6464 }
6465 else
6469 {
6473 }
6474 else
6483 else
6487 {
6500 }
6504 /* Always parenthesize if RHS is another setop */
6507 /*
6508 * The indentation code here is deliberately a bit different from that
6509 * for the lefthand input, because we want the line breaks in
6510 * different places.
6511 */
6513 {
6516 }
6517 else
6521 /*
6522 * The output column names of the RHS sub-select don't matter.
6523 */
6535 }
6536 else
6537 {
6540 }
6541 }
6543 /*
6544 * Display a sort/group clause.
6545 *
6546 * Also returns the expression tree, so caller need not find it again.
6547 */
6551 {
6559 /*
6560 * Use column-number form if requested by caller. Otherwise, if
6561 * expression is a constant, force it to be dumped with an explicit cast
6562 * as decoration --- this is because a simple integer constant is
6563 * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
6564 * we dump it without any decoration. Similarly, if it's just a Var,
6565 * there is risk of misinterpretation if the column name is reassigned in
6566 * the SELECT list, so we may need to force table qualification. And, if
6567 * it's anything more complex than a simple Var, then force extra parens
6568 * around it, to ensure it can't be misinterpreted as a cube() or rollup()
6569 * construct.
6570 */
6572 {
6575 }
6581 {
6582 /* Tell get_variable to check for name conflict */
6588 }
6589 else
6590 {
6591 /*
6592 * We must force parens for function-like expressions even if
6593 * PRETTY_PAREN is off, since those are the ones in danger of
6594 * misparsing. For other expressions we need to force them only if
6595 * PRETTY_PAREN is on, since otherwise the expression will output them
6596 * itself. (We can't skip the parens.)
6597 */
6609 }
6612 }
6614 /*
6615 * Display a GroupingSet
6616 */
6617 static void
6620 {
6627 {
6633 {
6638 {
6645 }
6649 }
6662 }
6665 {
6669 }
6672 }
6674 /*
6675 * Display an ORDER BY list.
6676 */
6677 static void
6680 {
6687 {
6690 Oid sortcoltype;
6697 /* See whether operator is default < or > for datatype */
6701 {
6702 /* ASC is default, so emit nothing for it */
6705 }
6707 {
6709 /* DESC defaults to NULLS FIRST */
6712 }
6713 else
6714 {
6717 sortcoltype,
6718 sortcoltype));
6719 /* be specific to eliminate ambiguity */
6722 else
6724 }
6726 }
6727 }
6729 /*
6730 * Display a WINDOW clause.
6731 *
6732 * Note that the windowClause list might contain only anonymous window
6733 * specifications, in which case we should print nothing here.
6734 */
6735 static void
6737 {
6744 {
6753 else
6761 }
6762 }
6764 /*
6765 * Display a window definition
6766 */
6767 static void
6770 {
6778 {
6781 }
6782 /* partition clauses are always inherited, so only print if no refname */
6784 {
6790 {
6797 }
6799 }
6800 /* print ordering clause only if not inherited */
6802 {
6808 }
6809 /* framing clause is never inherited, so print unless it's default */
6811 {
6820 else
6829 {
6835 else
6837 }
6838 else
6841 {
6848 {
6854 else
6856 }
6857 else
6859 }
6866 /* we will now have a trailing space; remove it */
6868 }
6870 }
6872 /* ----------
6873 * get_insert_query_def - Parse back an INSERT parsetree
6874 * ----------
6875 */
6876 static void
6878 {
6887 /* Insert the WITH clause if given */
6890 /*
6891 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
6892 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
6893 */
6895 {
6899 {
6903 }
6906 {
6910 }
6911 }
6915 /*
6916 * Start the query with INSERT INTO relname
6917 */
6922 {
6925 }
6929 /* Print the relation alias, if needed; INSERT requires explicit AS */
6932 /* always want a space here */
6935 /*
6936 * Add the insert-column-names list. Any indirection decoration needed on
6937 * the column names can be inferred from the top targetlist.
6938 */
6944 {
6953 /*
6954 * Put out name of target column; look in the catalogs, not at
6955 * tle->resname, since resname will fail to track RENAME.
6956 */
6962 /*
6963 * Print any indirection needed (subfields or subscripts), and strip
6964 * off the top-level nodes representing the indirection assignments.
6965 * Add the stripped expressions to strippedexprs. (If it's a
6966 * single-VALUES statement, the stripped expressions are the VALUES to
6967 * print below. Otherwise they're just Vars and not really
6968 * interesting.)
6969 */
6972 context));
6973 }
6978 {
6983 }
6986 {
6987 /* Add the SELECT */
6992 }
6994 {
6995 /* Add the multi-VALUES expression lists */
6997 }
6999 {
7000 /* Add the single-VALUES expression list */
7005 }
7006 else
7007 {
7008 /* No expressions, so it must be DEFAULT VALUES */
7010 }
7012 /* Add ON CONFLICT if present */
7014 {
7020 {
7021 /* Add the single-VALUES expression list */
7026 /* Add a WHERE clause (for partial indexes) if given */
7028 {
7031 /*
7032 * Force non-prefixing of Vars, since parser assumes that they
7033 * belong to target relation. WHERE clause does not use
7034 * InferenceElem, so this is separately required.
7035 */
7044 }
7045 }
7047 {
7055 }
7058 {
7060 }
7061 else
7062 {
7064 /* Deparse targetlist */
7068 /* Add a WHERE clause if given */
7070 {
7074 }
7075 }
7076 }
7078 /* Add RETURNING if present */
7081 }
7084 /* ----------
7085 * get_update_query_def - Parse back an UPDATE parsetree
7086 * ----------
7087 */
7088 static void
7090 {
7094 /* Insert the WITH clause if given */
7097 /*
7098 * Start the query with UPDATE relname SET
7099 */
7103 {
7106 }
7111 /* Print the relation alias, if needed */
7116 /* Deparse targetlist */
7119 /* Add the FROM clause if needed */
7122 /* Add a WHERE clause if given */
7124 {
7128 }
7130 /* Add RETURNING if present */
7133 }
7136 /* ----------
7137 * get_update_query_targetlist_def - Parse back an UPDATE targetlist
7138 * ----------
7139 */
7140 static void
7143 {
7152 /*
7153 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
7154 * into a list. We expect them to appear, in ID order, in resjunk tlist
7155 * entries.
7156 */
7159 {
7161 {
7165 {
7169 {
7172 }
7173 }
7174 }
7175 }
7180 /* Add the comma separated list of 'attname = value' */
7183 {
7190 /* Emit separator (OK whether we're in multiassignment or not) */
7194 /*
7195 * Check to see if we're starting a multiassignment group: if so,
7196 * output a left paren.
7197 */
7199 {
7200 /*
7201 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
7202 * Param. That could be buried under FieldStores and
7203 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
7204 * and underneath those there could be an implicit type coercion.
7205 * Because we would ignore implicit type coercions anyway, we
7206 * don't need to be as careful as processIndirection() is about
7207 * descending past implicit CoerceToDomains.
7208 */
7211 {
7213 {
7217 }
7219 {
7226 }
7228 {
7234 }
7235 else
7237 }
7242 {
7245 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
7249 }
7250 }
7252 /*
7253 * Put out name of target column; look in the catalogs, not at
7254 * tle->resname, since resname will fail to track RENAME.
7255 */
7261 /*
7262 * Print any indirection needed (subfields or subscripts), and strip
7263 * off the top-level nodes representing the indirection assignments.
7264 */
7267 /*
7268 * If we're in a multiassignment, skip printing anything more, unless
7269 * this is the last column; in which case, what we print should be the
7270 * sublink, not the Param.
7271 */
7273 {
7279 }
7284 }
7285 }
7288 /* ----------
7289 * get_delete_query_def - Parse back a DELETE parsetree
7290 * ----------
7291 */
7292 static void
7294 {
7298 /* Insert the WITH clause if given */
7301 /*
7302 * Start the query with DELETE FROM relname
7303 */
7307 {
7310 }
7315 /* Print the relation alias, if needed */
7318 /* Add the USING clause if given */
7321 /* Add a WHERE clause if given */
7323 {
7327 }
7329 /* Add RETURNING if present */
7332 }
7335 /* ----------
7336 * get_merge_query_def - Parse back a MERGE parsetree
7337 * ----------
7338 */
7339 static void
7341 {
7347 /* Insert the WITH clause if given */
7350 /*
7351 * Start the query with MERGE INTO relname
7352 */
7356 {
7359 }
7364 /* Print the relation alias, if needed */
7367 /* Print the source relation and join clause */
7373 /*
7374 * Test for any NOT MATCHED BY SOURCE actions. If there are none, then
7375 * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
7376 * SQL standard. Otherwise, we have a non-SQL-standard query, so output
7377 * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
7378 * more explicit.
7379 */
7382 {
7386 {
7389 }
7390 }
7392 /* Print each merge action */
7394 {
7400 {
7410 else
7416 }
7419 {
7423 }
7428 {
7429 /* This generally matches get_insert_query_def() */
7439 {
7453 context));
7454 }
7459 {
7464 }
7467 {
7472 }
7473 else
7475 }
7477 {
7481 }
7486 }
7488 /* Add RETURNING if present */
7491 }
7494 /* ----------
7495 * get_utility_query_def - Parse back a UTILITY parsetree
7496 * ----------
7497 */
7498 static void
7500 {
7504 {
7512 {
7515 }
7516 }
7517 else
7518 {
7519 /* Currently only NOTIFY utility commands can appear in rules */
7521 }
7522 }
7524 /*
7525 * Display a Var appropriately.
7526 *
7527 * In some cases (currently only when recursing into an unnamed join)
7528 * the Var's varlevelsup has to be interpreted with respect to a context
7529 * above the current one; levelsup indicates the offset.
7530 *
7531 * If istoplevel is true, the Var is at the top level of a SELECT's
7532 * targetlist, which means we need special treatment of whole-row Vars.
7533 * Instead of the normal "tab.*", we'll print "tab.*::typename", which is a
7534 * dirty hack to prevent "tab.*" from being expanded into multiple columns.
7535 * (The parser will strip the useless coercion, so no inefficiency is added in
7536 * dump and reload.) We used to print just "tab" in such cases, but that is
7537 * ambiguous and will yield the wrong result if "tab" is also a plain column
7538 * name in the query.
7539 *
7540 * Returns the attname of the Var, or NULL if the Var has no attname (because
7541 * it is a whole-row Var or a subplan output reference).
7542 */
7545 {
7548 AttrNumber attnum;
7552 AttrNumber varattno;
7558 /* Find appropriate nesting depth */
7564 netlevelsup);
7566 /*
7567 * If we have a syntactic referent for the Var, and we're working from a
7568 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7569 * on the semantic referent. (Forcing use of the semantic referent when
7570 * printing plan trees is a design choice that's perhaps more motivated by
7571 * backwards compatibility than anything else. But it does have the
7572 * advantage of making plans more explicit.)
7573 */
7575 {
7578 }
7579 else
7580 {
7583 }
7585 /*
7586 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7587 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7588 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
7589 * find the aliases previously assigned for this RTE.
7590 */
7592 {
7593 /*
7594 * We might have been asked to map child Vars to some parent relation.
7595 */
7597 {
7603 /* Only map up to inheritance parents, not UNION ALL appendrels */
7607 {
7610 {
7616 }
7621 /* If the parent is itself a child, continue up. */
7624 }
7626 /*
7627 * If we found an ancestral rel, and that rel is included in
7628 * appendparents, print that column not the original one.
7629 */
7631 {
7634 }
7635 }
7639 /* might be returning old/new column value */
7644 else
7649 }
7650 else
7651 {
7655 }
7657 /*
7658 * The planner will sometimes emit Vars referencing resjunk elements of a
7659 * subquery's target list (this is currently only possible if it chooses
7660 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
7661 * Although we prefer to print subquery-referencing Vars using the
7662 * subquery's alias, that's not possible for resjunk items since they have
7663 * no alias. So in that case, drill down to the subplan and print the
7664 * contents of the referenced tlist item. This works because in a plan
7665 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
7666 * we'll have set dpns->inner_plan to reference the child plan node.
7667 */
7671 {
7673 deparse_namespace save_dpns;
7683 /*
7684 * Force parentheses because our caller probably assumed a Var is a
7685 * simple expression.
7686 */
7695 }
7697 /*
7698 * If it's an unnamed join, look at the expansion of the alias variable.
7699 * If it's a simple reference to one of the input vars, then recursively
7700 * print the name of that var instead. When it's not a simple reference,
7701 * we have to just print the unqualified join column name. (This can only
7702 * happen with "dangerous" merged columns in a JOIN USING; we took pains
7703 * previously to make the unqualified column name unique in such cases.)
7704 *
7705 * This wouldn't work in decompiling plan trees, because we don't store
7706 * joinaliasvars lists after planning; but a plan tree should never
7707 * contain a join alias variable.
7708 */
7710 {
7714 {
7718 /* we intentionally don't strip implicit coercions here */
7720 {
7723 }
7724 }
7726 /*
7727 * Unnamed join has no refname. (Note: since it's unnamed, there is
7728 * no way the user could have referenced it to create a whole-row Var
7729 * for it. So we don't have to cover that case below.)
7730 */
7732 }
7737 {
7738 /* Get column name to use from the colinfo struct */
7744 /*
7745 * If we find a Var referencing a dropped column, it seems better to
7746 * print something (anything) than to fail. In general this should
7747 * not happen, but it used to be possible for some cases involving
7748 * functions returning named composite types, and perhaps there are
7749 * still bugs out there.
7750 */
7753 }
7754 else
7755 {
7756 /* System column - name is fixed, get it from the catalog */
7758 }
7763 /*
7764 * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
7765 * clause, we may need to add a table-name prefix to prevent
7766 * findTargetlistEntrySQL92 from misinterpreting the name as an
7767 * output-column name. To avoid cluttering the output with unnecessary
7768 * prefixes, do so only if there is a name match to a SELECT tlist item
7769 * that is different from the Var.
7770 */
7772 {
7776 {
7781 colno++;
7783 /* This must match colname-choosing logic in get_target_list() */
7787 else
7792 {
7795 }
7796 }
7797 }
7800 {
7803 }
7806 else
7807 {
7813 }
7816 }
7818 /*
7819 * Deparse a Var which references OUTER_VAR, INNER_VAR, or INDEX_VAR. This
7820 * routine is actually a callback for resolve_special_varno, which handles
7821 * finding the correct TargetEntry. We get the expression contained in that
7822 * TargetEntry and just need to deparse it, a job we can throw back on
7823 * get_rule_expr.
7824 */
7825 static void
7827 {
7830 /*
7831 * For a non-Var referent, force parentheses because our caller probably
7832 * assumed a Var is a simple expression.
7833 */
7839 }
7841 /*
7842 * Chase through plan references to special varnos (OUTER_VAR, INNER_VAR,
7843 * INDEX_VAR) until we find a real Var or some kind of non-Var node; then,
7844 * invoke the callback provided.
7845 */
7846 static void
7849 {
7853 /* This function is recursive, so let's be paranoid. */
7856 /* If it's not a Var, invoke the callback. */
7858 {
7861 }
7863 /* Find appropriate nesting depth */
7868 /*
7869 * If varno is special, recurse. (Don't worry about varnosyn; if we're
7870 * here, we already decided not to use that.)
7871 */
7873 {
7875 deparse_namespace save_dpns;
7882 /*
7883 * If we're descending to the first child of an Append or MergeAppend,
7884 * update appendparents. This will affect deparsing of all Vars
7885 * appearing within the eventually-resolved subexpression.
7886 */
7902 }
7904 {
7906 deparse_namespace save_dpns;
7917 }
7919 {
7929 }
7933 /* Not special. Just invoke the callback. */
7935 }
7937 /*
7938 * Get the name of a field of an expression of composite type. The
7939 * expression is usually a Var, but we handle other cases too.
7940 *
7941 * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
7942 *
7943 * This is fairly straightforward when the expression has a named composite
7944 * type; we need only look up the type in the catalogs. However, the type
7945 * could also be RECORD. Since no actual table or view column is allowed to
7946 * have type RECORD, a Var of type RECORD must refer to a JOIN or FUNCTION RTE
7947 * or to a subquery output. We drill down to find the ultimate defining
7948 * expression and attempt to infer the field name from it. We ereport if we
7949 * can't determine the name.
7950 *
7951 * Similarly, a PARAM of type RECORD has to refer to some expression of
7952 * a determinable composite type.
7953 */
7957 {
7959 AttrNumber attnum;
7963 AttrNumber varattno;
7964 TupleDesc tupleDesc;
7967 /*
7968 * If it's a RowExpr that was expanded from a whole-row Var, use the
7969 * column names attached to it. (We could let get_expr_result_tupdesc()
7970 * handle this, but it's much cheaper to just pull out the name we need.)
7971 */
7973 {
7978 }
7980 /*
7981 * If it's a Param of type RECORD, try to find what the Param refers to.
7982 */
7984 {
7990 {
7991 /* Found a match, so recurse to decipher the field name */
7992 deparse_namespace save_dpns;
8000 }
8001 }
8003 /*
8004 * If it's a Var of type RECORD, we have to find what the Var refers to;
8005 * if not, we can use get_expr_result_tupdesc().
8006 */
8009 {
8011 /* Got the tupdesc, so we can extract the field name */
8014 }
8016 /* Find appropriate nesting depth */
8022 netlevelsup);
8024 /*
8025 * If we have a syntactic referent for the Var, and we're working from a
8026 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8027 * on the semantic referent. (See comments in get_variable().)
8028 */
8030 {
8033 }
8034 else
8035 {
8038 }
8040 /*
8041 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8042 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8043 * down into the subplans, or INDEX_VAR, which is resolved similarly.
8044 *
8045 * Note: unlike get_variable and resolve_special_varno, we need not worry
8046 * about inheritance mapping: a child Var should have the same datatype as
8047 * its parent, and here we're really only interested in the Var's type.
8048 */
8050 {
8053 }
8055 {
8057 deparse_namespace save_dpns;
8072 }
8074 {
8076 deparse_namespace save_dpns;
8091 }
8093 {
8107 }
8108 else
8109 {
8112 }
8115 {
8116 /* Var is whole-row reference to RTE, so select the right field */
8118 }
8120 /*
8121 * This part has essentially the same logic as the parser's
8122 * expandRecordVariable() function, but we are dealing with a different
8123 * representation of the input context, and we only need one field name
8124 * not a TupleDesc. Also, we need special cases for finding subquery and
8125 * CTE subplans when deparsing Plan trees.
8126 */
8130 {
8136 /*
8137 * This case should not occur: a column of a table, values list,
8138 * or ENR shouldn't have type RECORD. Fall through and fail (most
8139 * likely) at the bottom.
8140 */
8143 /* Subselect-in-FROM: examine sub-select's output expr */
8144 {
8146 {
8148 attnum);
8155 {
8156 /*
8157 * Recurse into the sub-select to see what its Var
8158 * refers to. We have to build an additional level of
8159 * namespace to keep in step with varlevelsup in the
8160 * subselect; furthermore, the subquery RTE might be
8161 * from an outer query level, in which case the
8162 * namespace for the subselect must have that outer
8163 * level as parent namespace.
8164 */
8167 deparse_namespace mydpns;
8171 netlevelsup);
8174 parent_namespaces);
8184 }
8185 /* else fall through to inspect the expression */
8186 }
8187 else
8188 {
8189 /*
8190 * We're deparsing a Plan tree so we don't have complete
8191 * RTE entries (in particular, rte->subquery is NULL). But
8192 * the only place we'd normally see a Var directly
8193 * referencing a SUBQUERY RTE is in a SubqueryScan plan
8194 * node, and we can look into the child plan's tlist
8195 * instead. An exception occurs if the subquery was
8196 * proven empty and optimized away: then we'd find such a
8197 * Var in a childless Result node, and there's nothing in
8198 * the plan tree that would let us figure out what it had
8199 * originally referenced. In that case, fall back on
8200 * printing "fN", analogously to the default column names
8201 * for RowExprs.
8202 */
8204 deparse_namespace save_dpns;
8208 {
8214 }
8220 attnum);
8229 }
8230 }
8233 /* Join RTE --- recursively inspect the alias variable */
8239 /* we intentionally don't strip implicit coercions here */
8243 context);
8244 /* else fall through to inspect the expression */
8249 /*
8250 * We couldn't get here unless a function is declared with one of
8251 * its result columns as RECORD, which is not allowed.
8252 */
8255 /* CTE reference: examine subquery's output expr */
8256 {
8258 Index ctelevelsup;
8261 /*
8262 * Try to find the referenced CTE using the namespace stack.
8263 */
8267 else
8268 {
8274 {
8278 }
8279 }
8281 {
8284 attnum);
8291 {
8292 /*
8293 * Recurse into the CTE to see what its Var refers to.
8294 * We have to build an additional level of namespace
8295 * to keep in step with varlevelsup in the CTE;
8296 * furthermore it could be an outer CTE (compare
8297 * SUBQUERY case above).
8298 */
8301 deparse_namespace mydpns;
8305 ctelevelsup);
8308 parent_namespaces);
8318 }
8319 /* else fall through to inspect the expression */
8320 }
8321 else
8322 {
8323 /*
8324 * We're deparsing a Plan tree so we don't have a CTE
8325 * list. But the only places we'd normally see a Var
8326 * directly referencing a CTE RTE are in CteScan or
8327 * WorkTableScan plan nodes. For those cases,
8328 * set_deparse_plan arranged for dpns->inner_plan to be
8329 * the plan node that emits the CTE or RecursiveUnion
8330 * result, and we can look at its tlist instead. As
8331 * above, this can fail if the CTE has been proven empty,
8332 * in which case fall back to "fN".
8333 */
8335 deparse_namespace save_dpns;
8339 {
8345 }
8352 attnum);
8361 }
8362 }
8366 /*
8367 * We couldn't get here: any Vars that reference the RTE_GROUP RTE
8368 * should have been replaced with the underlying grouping
8369 * expressions.
8370 */
8372 }
8374 /*
8375 * We now have an expression we can't expand any more, so see if
8376 * get_expr_result_tupdesc() can do anything with it.
8377 */
8379 /* Got the tupdesc, so we can extract the field name */
8382 }
8384 /*
8385 * Try to find the referenced expression for a PARAM_EXEC Param that might
8386 * reference a parameter supplied by an upper NestLoop or SubPlan plan node.
8387 *
8388 * If successful, return the expression and set *dpns_p and *ancestor_cell_p
8389 * appropriately for calling push_ancestor_plan(). If no referent can be
8390 * found, return NULL.
8391 */
8395 {
8396 /* Initialize output parameters to prevent compiler warnings */
8400 /*
8401 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
8402 * SubPlan argument. This will necessarily be in some ancestor of the
8403 * current expression's Plan node.
8404 */
8406 {
8415 {
8419 /*
8420 * NestLoops transmit params to their inner child only.
8421 */
8424 {
8428 {
8432 {
8433 /* Found a match, so return it */
8437 }
8438 }
8439 }
8441 /*
8442 * If ancestor is a SubPlan, check the arguments it provides.
8443 */
8445 {
8451 {
8456 {
8457 /*
8458 * Found a match, so return it. But, since Vars in
8459 * the arg are to be evaluated in the surrounding
8460 * context, we have to point to the next ancestor item
8461 * that is *not* a SubPlan.
8462 */
8467 {
8471 {
8475 }
8476 }
8478 }
8479 }
8481 /* SubPlan isn't a kind of Plan, so skip the rest */
8483 }
8485 /*
8486 * We need not consider the ancestor's initPlan list, since
8487 * initplans never have any parParams.
8488 */
8490 /* No luck, crawl up to next ancestor */
8492 }
8493 }
8495 /* No referent found */
8497 }
8499 /*
8500 * Try to find a subplan/initplan that emits the value for a PARAM_EXEC Param.
8501 *
8502 * If successful, return the generating subplan/initplan and set *column_p
8503 * to the subplan's 0-based output column number.
8504 * Otherwise, return NULL.
8505 */
8508 {
8509 /* Initialize output parameter to prevent compiler warnings */
8512 /*
8513 * If it's a PARAM_EXEC parameter, search the current plan node as well as
8514 * ancestor nodes looking for a subplan or initplan that emits the value
8515 * for the Param. It could appear in the setParams of an initplan or
8516 * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
8517 */
8519 {
8526 /* First check the innermost plan node's initplans */
8531 /*
8532 * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
8533 * which can be referenced by Params elsewhere in the targetlist.
8534 * (Such Params should always be in the same targetlist, so there's no
8535 * need to do this work at upper plan nodes.)
8536 */
8538 {
8540 {
8544 {
8546 {
8548 {
8549 /* Found a match, so return it. */
8552 }
8553 }
8554 }
8555 }
8556 }
8558 /* No luck, so check the ancestor nodes */
8560 {
8563 /*
8564 * If ancestor is a SubPlan, check the paramIds it provides.
8565 */
8567 {
8571 {
8573 {
8574 /* Found a match, so return it. */
8577 }
8578 }
8580 /* SubPlan isn't a kind of Plan, so skip the rest */
8582 }
8584 /*
8585 * Otherwise, it's some kind of Plan node, so check its initplans.
8586 */
8588 column_p);
8592 /* No luck, crawl up to next ancestor */
8593 }
8594 }
8596 /* No generator found */
8598 }
8600 /*
8601 * Subroutine for find_param_generator: search one Plan node's initplans
8602 */
8605 {
8607 {
8609 {
8611 {
8612 /* Found a match, so return it. */
8615 }
8616 }
8617 }
8619 }
8621 /*
8622 * Display a Param appropriately.
8623 */
8624 static void
8626 {
8633 /*
8634 * If it's a PARAM_EXEC parameter, try to locate the expression from which
8635 * the parameter was computed. This stanza handles only cases in which
8636 * the Param represents an input to the subplan we are currently in.
8637 */
8640 {
8641 /* Found a match, so print it */
8642 deparse_namespace save_dpns;
8646 /* Switch attention to the ancestor plan node */
8649 /*
8650 * Force prefixing of Vars, since they won't belong to the relation
8651 * being scanned in the original plan node.
8652 */
8656 /*
8657 * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
8658 * upper-level Param, which wouldn't need extra parentheses.
8659 * Otherwise, insert parens to ensure the expression looks atomic.
8660 */
8678 }
8680 /*
8681 * Alternatively, maybe it's a subplan output, which we print as a
8682 * reference to the subplan. (We could drill down into the subplan and
8683 * print the relevant targetlist expression, but that has been deemed too
8684 * confusing since it would violate normal SQL scope rules. Also, we're
8685 * relying on this reference to show that the testexpr containing the
8686 * Param has anything to do with that subplan at all.)
8687 */
8690 {
8696 }
8698 /*
8699 * If it's an external parameter, see if the outermost namespace provides
8700 * function argument names.
8701 */
8703 {
8708 {
8712 {
8716 /*
8717 * Qualify the parameter name if there are any other deparse
8718 * namespaces with range tables. This avoids qualifying in
8719 * trivial cases like "RETURN a + b", but makes it safe in all
8720 * other cases.
8721 */
8723 {
8727 {
8730 }
8731 }
8733 {
8736 }
8740 }
8741 }
8742 }
8744 /*
8745 * Not PARAM_EXEC, or couldn't find referent: just print $N.
8746 *
8747 * It's a bug if we get here for anything except PARAM_EXTERN Params, but
8748 * in production builds printing $N seems more useful than failing.
8749 */
8753 }
8755 /*
8756 * get_simple_binary_op_name
8757 *
8758 * helper function for isSimpleNode
8759 * will return single char binary operator name, or NULL if it's not
8760 */
8763 {
8767 {
8768 /* binary operator */
8776 }
8778 }
8781 /*
8782 * isSimpleNode - check if given node is simple (doesn't need parenthesizing)
8783 *
8784 * true : simple in the context of parent node's type
8785 * false : not simple
8786 */
8787 static bool
8789 {
8794 {
8801 /* single words: always simple */
8820 /* function-like: name(..) or name[..] */
8823 /* CASE keywords act as parentheses */
8829 /*
8830 * appears simple since . has top precedence, unless parent is
8831 * T_FieldSelect itself!
8832 */
8837 /*
8838 * treat like FieldSelect (probably doesn't matter)
8839 */
8843 /* maybe simple, check args */
8863 {
8864 /* depends on parent node type; needs further checking */
8866 {
8878 /* We know only the basic operators + - and * / % */
8899 /*
8900 * Operators are same priority --- can skip parens only if
8901 * we have (a - b) - c, not a - (b - c).
8902 */
8907 }
8908 /* else do the same stuff as for T_SubLink et al. */
8909 }
8910 /* FALLTHROUGH */
8918 {
8920 {
8921 /* special handling for casts and COERCE_SQL_SYNTAX */
8929 }
8945 }
8949 {
8952 {
8953 BoolExprType type;
8954 BoolExprType parentType;
8959 {
8969 }
8970 }
8973 {
8974 /* special handling for casts and COERCE_SQL_SYNTAX */
8982 }
8998 }
9001 /* maybe simple, check args */
9007 }
9008 /* those we don't know: in dubio complexo */
9010 }
9013 /*
9014 * appendContextKeyword - append a keyword to buffer
9015 *
9016 * If prettyPrint is enabled, perform a line break, and adjust indentation.
9017 * Otherwise, just append the keyword.
9018 */
9019 static void
9022 {
9026 {
9031 /* remove any trailing spaces currently in the buffer ... */
9033 /* ... then add a newline and some spaces */
9038 else
9039 {
9040 /*
9041 * If we're indented more than PRETTYINDENT_LIMIT characters, try
9042 * to conserve horizontal space by reducing the per-level
9043 * indentation. For best results the scale factor here should
9044 * divide all the indent amounts that get added to indentLevel
9045 * (PRETTYINDENT_STD, etc). It's important that the indentation
9046 * not grow unboundedly, else deeply-nested trees use O(N^2)
9047 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
9048 */
9053 /* scale/wrap logic affects indentLevel, but not indentPlus */
9055 }
9063 }
9064 else
9066 }
9068 /*
9069 * removeStringInfoSpaces - delete trailing spaces from a buffer.
9070 *
9071 * Possibly this should move to stringinfo.c at some point.
9072 */
9073 static void
9075 {
9078 }
9081 /*
9082 * get_rule_expr_paren - deparse expr using get_rule_expr,
9083 * embracing the string with parentheses if necessary for prettyPrint.
9084 *
9085 * Never embrace if prettyFlags=0, because it's done in the calling node.
9086 *
9087 * Any node that does *not* embrace its argument node by sql syntax (with
9088 * parentheses, non-operator keywords like CASE/WHEN/ON, or comma etc) should
9089 * use get_rule_expr_paren instead of get_rule_expr so parentheses can be
9090 * added.
9091 */
9092 static void
9095 {
9108 }
9110 static void
9113 {
9114 /*
9115 * The order of array elements must correspond to the order of
9116 * JsonBehaviorType members.
9117 */
9119 {
9128 " DEFAULT "
9129 };
9140 }
9142 /*
9143 * get_json_expr_options
9144 *
9145 * Parse back common options for JSON_QUERY, JSON_VALUE, JSON_EXISTS and
9146 * JSON_TABLE columns.
9147 */
9148 static void
9150 JsonBehaviorType default_behavior)
9151 {
9153 {
9158 /* The default */
9164 /* The default */
9165 else
9167 }
9174 }
9176 /* ----------
9177 * get_rule_expr - Parse back an expression
9178 *
9179 * Note: showimplicit determines whether we display any implicit cast that
9180 * is present at the top of the expression tree. It is a passed argument,
9181 * not a field of the context struct, because we change the value as we
9182 * recurse down into the expression. In general we suppress implicit casts
9183 * when the result type is known with certainty (eg, the arguments of an
9184 * OR must be boolean). We display implicit casts for arguments of functions
9185 * and operators, since this is needed to be certain that the same function
9186 * or operator will be chosen when the expression is re-parsed.
9187 * ----------
9188 */
9189 static void
9192 {
9198 /* Guard against excessively long or deeply-nested queries */
9202 /*
9203 * Each level of get_rule_expr must emit an indivisible term
9204 * (parenthesized if necessary) to ensure result is reparsed into the same
9205 * expression tree. The only exception is that when the input is a List,
9206 * we emit the component items comma-separated with no surrounding
9207 * decoration; this is convenient for most callers.
9208 */
9210 {
9228 {
9234 }
9246 {
9250 /*
9251 * If the argument is a CaseTestExpr, we must be inside a
9252 * FieldStore, ie, we are assigning to an element of an array
9253 * within a composite column. Since we already punted on
9254 * displaying the FieldStore's target information, just punt
9255 * here too, and display only the assignment source
9256 * expression.
9257 */
9259 {
9264 }
9266 /*
9267 * Parenthesize the argument unless it's a simple Var or a
9268 * FieldSelect. (In particular, if it's another
9269 * SubscriptingRef, we *must* parenthesize to avoid
9270 * confusion.)
9271 */
9280 /*
9281 * If there's a refassgnexpr, we want to print the node in the
9282 * format "container[subscripts] := refassgnexpr". This is
9283 * not legal SQL, so decompilation of INSERT or UPDATE
9284 * statements should always use processIndirection as part of
9285 * the statement-level syntax. We should only see this when
9286 * EXPLAIN tries to print the targetlist of a plan resulting
9287 * from such a statement.
9288 */
9290 {
9293 /*
9294 * Use processIndirection to print this node's subscripts
9295 * as well as any additional field selections or
9296 * subscripting in immediate descendants. It returns the
9297 * RHS expr that is actually being "assigned".
9298 */
9302 }
9303 else
9304 {
9305 /* Just an ordinary container fetch, so print subscripts */
9307 }
9308 }
9316 {
9321 }
9329 {
9342 }
9346 {
9352 }
9356 {
9372 /*
9373 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
9374 * a bare sub-SELECT. Since we're here, the sub-SELECT must
9375 * be meant as a scalar sub-SELECT yielding an array value to
9376 * be used in ScalarArrayOpExpr; but the grammar will
9377 * preferentially interpret such a construct as an ANY/ALL
9378 * SubLink. To prevent misparsing the output that way, insert
9379 * a dummy coercion (which will be stripped by parse analysis,
9380 * so no inefficiency is added in dump and reload). This is
9381 * indeed most likely what the user wrote to get the construct
9382 * accepted in the first place.
9383 */
9392 }
9396 {
9402 {
9409 {
9413 }
9424 {
9428 }
9446 }
9447 }
9455 {
9458 /*
9459 * We cannot see an already-planned subplan in rule deparsing,
9460 * only while EXPLAINing a query plan. We don't try to
9461 * reconstruct the original SQL, just reference the subplan
9462 * that appears elsewhere in EXPLAIN's result. It does seem
9463 * useful to show the subLinkType and testexpr (if any), and
9464 * we also note whether the subplan will be hashed.
9465 */
9467 {
9481 /* Parenthesizing the testexpr seems sufficient */
9486 /* No need to decorate these subplan references */
9491 /* MULTIEXPR isn't executed in the normal way */
9500 /* This case is unreachable within expressions */
9504 }
9507 {
9510 /*
9511 * Push SubPlan into ancestors list while deparsing
9512 * testexpr, so that we can handle PARAM_EXEC references
9513 * to the SubPlan's paramIds. (This makes it look like
9514 * the SubPlan is an "ancestor" of the current plan node,
9515 * which is a little weird, but it does no harm.) In this
9516 * path, we don't need to mention the SubPlan explicitly,
9517 * because the referencing Params will show its existence.
9518 */
9526 }
9527 else
9528 {
9529 /* No referencing Params, so show the SubPlan's name */
9532 else
9534 }
9535 }
9539 {
9543 /*
9544 * This case cannot be reached in normal usage, since no
9545 * AlternativeSubPlan can appear either in parsetrees or
9546 * finished plan trees. We keep it just in case somebody
9547 * wants to use this code to print planner data structures.
9548 */
9551 {
9556 else
9560 }
9562 }
9566 {
9573 /*
9574 * Parenthesize the argument unless it's an SubscriptingRef or
9575 * another FieldSelect. Note in particular that it would be
9576 * WRONG to not parenthesize a Var argument; simplicity is not
9577 * the issue here, having the right number of names is.
9578 */
9587 /*
9588 * Get and print the field name.
9589 */
9593 }
9597 {
9601 /*
9602 * There is no good way to represent a FieldStore as real SQL,
9603 * so decompilation of INSERT or UPDATE statements should
9604 * always use processIndirection as part of the
9605 * statement-level syntax. We should only get here when
9606 * EXPLAIN tries to print the targetlist of a plan resulting
9607 * from such a statement. The plan case is even harder than
9608 * ordinary rules would be, because the planner tries to
9609 * collapse multiple assignments to the same field or subfield
9610 * into one FieldStore; so we can see a list of target fields
9611 * not just one, and the arguments could be FieldStores
9612 * themselves. We don't bother to try to print the target
9613 * field names; we just print the source arguments, with a
9614 * ROW() around them if there's more than one. This isn't
9615 * terribly complete, but it's probably good enough for
9616 * EXPLAIN's purposes; especially since anything more would be
9617 * either hopelessly confusing or an even poorer
9618 * representation of what the plan is actually doing.
9619 */
9626 }
9630 {
9636 {
9637 /* don't show the implicit cast */
9639 }
9640 else
9641 {
9645 node);
9646 }
9647 }
9651 {
9657 {
9658 /* don't show the implicit cast */
9660 }
9661 else
9662 {
9666 node);
9667 }
9668 }
9672 {
9678 {
9679 /* don't show the implicit cast */
9681 }
9682 else
9683 {
9687 node);
9688 }
9689 }
9693 {
9699 {
9700 /* don't show the implicit cast */
9702 }
9703 else
9704 {
9707 node);
9708 }
9709 }
9713 {
9724 }
9728 {
9735 {
9738 }
9740 {
9745 {
9746 /*
9747 * The parser should have produced WHEN clauses of the
9748 * form "CaseTestExpr = RHS", possibly with an
9749 * implicit coercion inserted above the CaseTestExpr.
9750 * For accurate decompilation of rules it's essential
9751 * that we show just the RHS. However in an
9752 * expression that's been through the optimizer, the
9753 * WHEN clause could be almost anything (since the
9754 * equality operator could have been expanded into an
9755 * inline function). If we don't recognize the form
9756 * of the WHEN clause, just punt and display it as-is.
9757 */
9759 {
9764 CaseTestExpr))
9766 }
9767 }
9776 }
9786 }
9790 {
9791 /*
9792 * Normally we should never get here, since for expressions
9793 * that can contain this node type we attempt to avoid
9794 * recursing to it. But in an optimized expression we might
9795 * be unable to avoid that (see comments for CaseExpr). If we
9796 * do see one, print it as CASE_TEST_EXPR.
9797 */
9799 }
9803 {
9810 /*
9811 * If the array isn't empty, we assume its elements are
9812 * coerced to the desired type. If it's empty, though, we
9813 * need an explicit coercion to the array type.
9814 */
9818 }
9822 {
9829 /*
9830 * If it's a named type and not RECORD, we may have to skip
9831 * dropped columns and/or claim there are NULLs for added
9832 * columns.
9833 */
9835 {
9838 }
9840 /*
9841 * SQL99 allows "ROW" to be omitted when there is more than
9842 * one column, but for simplicity we always print it.
9843 */
9848 {
9853 {
9855 /* Whole-row Vars need special treatment here */
9858 }
9859 i++;
9860 }
9862 {
9864 {
9866 {
9870 }
9871 i++;
9872 }
9875 }
9880 }
9884 {
9887 /*
9888 * SQL99 allows "ROW" to be omitted when there is more than
9889 * one column, but for simplicity we always print it. Within
9890 * a ROW expression, whole-row Vars need special treatment, so
9891 * use get_rule_list_toplevel.
9892 */
9896 /*
9897 * We assume that the name of the first-column operator will
9898 * do for all the rest too. This is definitely open to
9899 * failure, eg if some but not all operators were renamed
9900 * since the construct was parsed, but there seems no way to
9901 * be perfect.
9902 */
9909 }
9913 {
9919 }
9923 {
9927 {
9934 }
9937 }
9941 {
9944 /*
9945 * Note: this code knows that typmod for time, timestamp, and
9946 * timestamptz just prints as integer.
9947 */
9949 {
9997 }
9998 }
10002 {
10010 {
10034 }
10036 {
10039 else
10041 }
10043 {
10047 }
10049 {
10051 {
10056 }
10058 {
10068 }
10071 }
10073 {
10077 {
10083 /* no extra decoration needed */
10097 else
10112 else
10118 else
10119 {
10121 {
10136 }
10137 }
10142 }
10143 }
10150 else
10152 }
10156 {
10163 /*
10164 * For scalar inputs, we prefer to print as IS [NOT] NULL,
10165 * which is shorter and traditional. If it's a rowtype input
10166 * but we're applying a scalar test, must print IS [NOT]
10167 * DISTINCT FROM NULL to be semantically correct.
10168 */
10171 {
10173 {
10183 }
10184 }
10185 else
10186 {
10188 {
10198 }
10199 }
10202 }
10206 {
10213 {
10235 }
10238 }
10242 {
10248 {
10249 /* don't show the implicit cast */
10251 }
10252 else
10253 {
10257 node);
10258 }
10259 }
10271 {
10277 else
10280 }
10284 {
10287 /*
10288 * This isn't exactly nextval(), but that seems close enough
10289 * for EXPLAIN's purposes.
10290 */
10294 NIL));
10296 }
10300 {
10305 /*
10306 * InferenceElem can only refer to target relation, so a
10307 * prefix is not useful, and indeed would cause parse errors.
10308 */
10312 /*
10313 * Parenthesize the element unless it's a simple Var or a bare
10314 * function call. Follows pg_get_indexdef_worker().
10315 */
10319 COERCE_EXPLICIT_CALL)
10335 /* Add the operator class name, if not default */
10337 {
10342 }
10343 }
10347 {
10350 /*
10351 * We cannot see a ReturningExpr in rule deparsing, only while
10352 * EXPLAINing a query plan (ReturningExpr nodes are only ever
10353 * adding during query rewriting). Just display the expression
10354 * returned (an expanded view column).
10355 */
10357 }
10361 {
10367 {
10370 }
10373 {
10389 {
10395 }
10415 }
10416 }
10420 {
10425 }
10433 {
10443 /* TODO: handle FORMAT clause */
10446 {
10458 }
10465 }
10469 {
10473 {
10486 }
10495 {
10504 {
10512 }
10513 }
10522 JSON_BEHAVIOR_NULL :
10523 JSON_BEHAVIOR_FALSE);
10526 }
10530 {
10536 {
10540 }
10541 }
10551 }
10552 }
10554 /*
10555 * get_rule_expr_toplevel - Parse back a toplevel expression
10556 *
10557 * Same as get_rule_expr(), except that if the expr is just a Var, we pass
10558 * istoplevel = true not false to get_variable(). This causes whole-row Vars
10559 * to get printed with decoration that will prevent expansion of "*".
10560 * We need to use this in contexts such as ROW() and VALUES(), where the
10561 * parser would expand "foo.*" appearing at top level. (In principle we'd
10562 * use this in get_target_list() too, but that has additional worries about
10563 * whether to print AS, so it needs to invoke get_variable() directly anyway.)
10564 */
10565 static void
10568 {
10571 else
10573 }
10575 /*
10576 * get_rule_list_toplevel - Parse back a list of toplevel expressions
10577 *
10578 * Apply get_rule_expr_toplevel() to each element of a List.
10579 *
10580 * This adds commas between the expressions, but caller is responsible
10581 * for printing surrounding decoration.
10582 */
10583 static void
10586 {
10592 {
10598 }
10599 }
10601 /*
10602 * get_rule_expr_funccall - Parse back a function-call expression
10603 *
10604 * Same as get_rule_expr(), except that we guarantee that the output will
10605 * look like a function call, or like one of the things the grammar treats as
10606 * equivalent to a function call (see the func_expr_windowless production).
10607 * This is needed in places where the grammar uses func_expr_windowless and
10608 * you can't substitute a parenthesized a_expr. If what we have isn't going
10609 * to look like a function call, wrap it in a dummy CAST() expression, which
10610 * will satisfy the grammar --- and, indeed, is likely what the user wrote to
10611 * produce such a thing.
10612 */
10613 static void
10616 {
10619 else
10620 {
10624 /* no point in showing any top-level implicit cast */
10629 }
10630 }
10632 /*
10633 * Helper function to identify node types that satisfy func_expr_windowless.
10634 * If in doubt, "false" is always a safe answer.
10635 */
10636 static bool
10638 {
10642 {
10644 /* OK, unless it's going to deparse as a cast */
10653 /* these are all accepted by func_expr_common_subexpr */
10657 }
10659 }
10662 /*
10663 * get_oper_expr - Parse back an OpExpr node
10664 */
10665 static void
10667 {
10675 {
10676 /* binary operator */
10686 }
10687 else
10688 {
10689 /* prefix operator */
10694 InvalidOid,
10697 }
10700 }
10702 /*
10703 * get_func_expr - Parse back a FuncExpr node
10704 */
10705 static void
10708 {
10717 /*
10718 * If the function call came from an implicit coercion, then just show the
10719 * first argument --- unless caller wants to see implicit coercions.
10720 */
10722 {
10726 }
10728 /*
10729 * If the function call came from a cast, then show the first argument
10730 * plus an explicit cast operation.
10731 */
10734 {
10737 int32 coercedTypmod;
10739 /* Get the typmod if this is a length-coercion function */
10747 }
10749 /*
10750 * If the function was called using one of the SQL spec's random special
10751 * syntaxes, try to reproduce that. If we don't recognize the function,
10752 * fall through.
10753 */
10755 {
10758 }
10760 /*
10761 * Normal function: display as proname(args). First we need to extract
10762 * the argument datatypes.
10763 */
10771 {
10777 nargs++;
10778 }
10788 {
10794 }
10796 }
10798 /*
10799 * get_agg_expr - Parse back an Aggref node
10800 */
10801 static void
10804 {
10807 }
10809 /*
10810 * get_agg_expr_helper - subroutine for get_agg_expr and
10811 * get_json_agg_constructor
10812 */
10813 static void
10817 {
10823 /*
10824 * For a combining aggregate, we look up and deparse the corresponding
10825 * partial aggregate instead. This is necessary because our input
10826 * argument list has been replaced; the new argument list always has just
10827 * one element, which will point to a partial Aggref that supplies us with
10828 * transition states to combine.
10829 */
10831 {
10839 }
10841 /*
10842 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
10843 * to avoid printing this when recursing from the code just above.
10844 */
10848 /* Extract the argument types as seen by the parser */
10857 /* Print the aggregate name, schema-qualified if needed */
10862 {
10863 /*
10864 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
10865 * worry about inserting VARIADIC. So we can just dump the direct
10866 * args as-is.
10867 */
10873 }
10874 else
10875 {
10876 /* aggstar can be set only in zero-argument aggregates */
10879 else
10880 {
10886 {
10894 {
10896 {
10897 /*
10898 * the ABSENT ON NULL and WITH UNIQUE args are printed
10899 * separately, so ignore them here
10900 */
10905 }
10906 else
10908 }
10912 }
10913 }
10916 {
10919 }
10920 }
10926 {
10929 }
10932 }
10934 /*
10935 * This is a helper function for get_agg_expr(). It's used when we deparse
10936 * a combining Aggref; resolve_special_varno locates the corresponding partial
10937 * Aggref and then calls this.
10938 */
10939 static void
10941 {
10950 }
10952 /*
10953 * get_windowfunc_expr - Parse back a WindowFunc node
10954 */
10955 static void
10957 {
10959 }
10962 /*
10963 * get_windowfunc_expr_helper - subroutine for get_windowfunc_expr and
10964 * get_json_agg_constructor
10965 */
10966 static void
10970 {
10984 {
10990 nargs++;
10991 }
11000 /* winstar can be set only in zero-argument aggregates */
11003 else
11004 {
11006 {
11010 }
11011 else
11013 }
11019 {
11022 }
11027 {
11031 {
11034 else
11037 }
11038 }
11040 {
11045 /*
11046 * In EXPLAIN, we don't have window context information available, so
11047 * we have to settle for this:
11048 */
11050 }
11051 }
11053 /*
11054 * get_func_sql_syntax - Parse back a SQL-syntax function call
11055 *
11056 * Returns true if we successfully deparsed, false if we did not
11057 * recognize the function.
11058 */
11059 static bool
11061 {
11066 {
11073 /* AT TIME ZONE ... note reversed argument order */
11086 /* AT LOCAL */
11106 /* (x1, x2) OVERLAPS (y1, y2) */
11124 /* EXTRACT (x FROM y) */
11126 {
11133 }
11140 /* IS xxx NORMALIZED */
11146 {
11154 }
11159 /* COLLATION FOR */
11166 /* NORMALIZE() */
11170 {
11178 }
11188 /* OVERLAY() */
11196 {
11199 }
11206 /* POSITION() ... extra parens since args are b_expr not a_expr */
11220 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
11226 {
11229 }
11234 /* SUBSTRING SIMILAR/ESCAPE */
11247 /* TRIM() */
11250 {
11253 }
11262 /* TRIM() */
11265 {
11268 }
11277 /* TRIM() */
11280 {
11283 }
11294 /* XMLEXISTS ... extra parens because args are c_expr */
11301 }
11303 }
11305 /* ----------
11306 * get_coercion_expr
11307 *
11308 * Make a string representation of a value coerced to a specific type
11309 * ----------
11310 */
11311 static void
11315 {
11318 /*
11319 * Since parse_coerce.c doesn't immediately collapse application of
11320 * length-coercion functions to constants, what we'll typically see in
11321 * such cases is a Const with typmod -1 and a length-coercion function
11322 * right above it. Avoid generating redundant output. However, beware of
11323 * suppressing casts when the user actually wrote something like
11324 * 'foo'::text::char(3).
11325 *
11326 * Note: it might seem that we are missing the possibility of needing to
11327 * print a COLLATE clause for such a Const. However, a Const could only
11328 * have nondefault collation in a post-constant-folding tree, in which the
11329 * length coercion would have been folded too. See also the special
11330 * handling of CollateExpr in coerce_to_target_type(): any collation
11331 * marking will be above the coercion node, not below it.
11332 */
11336 {
11337 /* Show the constant without normal ::typename decoration */
11339 }
11340 else
11341 {
11347 }
11349 /*
11350 * Never emit resulttype(arg) functional notation. A pg_proc entry could
11351 * take precedence, and a resulttype in pg_temp would require schema
11352 * qualification that format_type_with_typemod() would usually omit. We've
11353 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
11354 * would work fine.
11355 */
11358 }
11360 /* ----------
11361 * get_const_expr
11362 *
11363 * Make a string representation of a Const
11364 *
11365 * showtype can be -1 to never show "::typename" decoration, or +1 to always
11366 * show it, or 0 to show it only if the constant wouldn't be assumed to be
11367 * the right type by default.
11368 *
11369 * If the Const's collation isn't default for its type, show that too.
11370 * We mustn't do this when showtype is -1 (since that means the caller will
11371 * print "::typename", and we can't put a COLLATE clause in between). It's
11372 * caller's responsibility that collation isn't missed in such cases.
11373 * ----------
11374 */
11375 static void
11377 {
11379 Oid typoutput;
11385 {
11386 /*
11387 * Always label the type of a NULL constant to prevent misdecisions
11388 * about type when reparsing.
11389 */
11392 {
11397 }
11399 }
11407 {
11410 /*
11411 * INT4 can be printed without any decoration, unless it is
11412 * negative; in that case print it as '-nnn'::integer to ensure
11413 * that the output will re-parse as a constant, not as a constant
11414 * plus operator. In most cases we could get away with printing
11415 * (-nnn) instead, because of the way that gram.y handles negative
11416 * literals; but that doesn't work for INT_MIN, and it doesn't
11417 * seem that much prettier anyway.
11418 */
11421 else
11422 {
11425 }
11430 /*
11431 * NUMERIC can be printed without quotes if it looks like a float
11432 * constant (not an integer, and not Infinity or NaN) and doesn't
11433 * have a leading sign (for the same reason as for INT4).
11434 */
11437 {
11439 }
11440 else
11441 {
11444 }
11450 else
11457 }
11464 /*
11465 * For showtype == 0, append ::typename unless the constant will be
11466 * implicitly typed as the right type when it is read in.
11467 *
11468 * XXX this code has to be kept in sync with the behavior of the parser,
11469 * especially make_const.
11470 */
11472 {
11475 /* These types can be left unlabeled */
11479 /* We determined above whether a label is needed */
11483 /*
11484 * Float-looking constants will be typed as numeric, which we
11485 * checked above; but if there's a nondefault typmod we need to
11486 * show it.
11487 */
11493 }
11500 }
11502 /*
11503 * helper for get_const_expr: append COLLATE if needed
11504 */
11505 static void
11507 {
11511 {
11515 {
11518 }
11519 }
11520 }
11522 /*
11523 * get_json_path_spec - Parse back a JSON path specification
11524 */
11525 static void
11527 {
11530 else
11532 }
11534 /*
11535 * get_json_format - Parse back a JsonFormat node
11536 */
11537 static void
11539 {
11548 {
11551 encoding =
11556 }
11557 }
11559 /*
11560 * get_json_returning - Parse back a JsonReturning structure
11561 */
11562 static void
11565 {
11577 }
11579 /*
11580 * get_json_constructor - Parse back a JsonConstructorExpr node
11581 */
11582 static void
11585 {
11593 {
11596 }
11598 {
11601 }
11604 {
11622 }
11628 {
11631 {
11636 }
11639 }
11643 }
11645 /*
11646 * Append options, if any, to the JSON constructor being deparsed
11647 */
11648 static void
11650 {
11652 {
11656 }
11657 else
11658 {
11662 }
11667 /*
11668 * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
11669 * support one.
11670 */
11673 }
11675 /*
11676 * get_json_agg_constructor - Parse back an aggregate JsonConstructorExpr node
11677 */
11678 static void
11681 {
11682 StringInfoData options;
11694 is_json_objectagg);
11695 else
11698 }
11700 /*
11701 * simple_quote_literal - Format a string as a SQL literal, append to buf
11702 */
11703 static void
11705 {
11708 /*
11709 * We form the string literal according to the prevailing setting of
11710 * standard_conforming_strings; we never use E''. User is responsible for
11711 * making sure result is used correctly.
11712 */
11715 {
11721 }
11723 }
11726 /* ----------
11727 * get_sublink_expr - Parse back a sublink
11728 * ----------
11729 */
11730 static void
11732 {
11740 else
11743 /*
11744 * Note that we print the name of only the first operator, when there are
11745 * multiple combining operators. This is an approximation that could go
11746 * wrong in various scenarios (operators in different schemas, renamed
11747 * operators, etc) but there is not a whole lot we can do about it, since
11748 * the syntax allows only one operator to be shown.
11749 */
11751 {
11753 {
11754 /* single combining operator */
11761 }
11763 {
11764 /* multiple combining operators, = or <> cases */
11771 {
11781 }
11783 }
11785 {
11786 /* multiple combining operators, < <= > >= cases */
11795 }
11796 else
11799 }
11804 {
11812 else
11835 }
11846 else
11848 }
11851 /* ----------
11852 * get_xmltable - Parse back a XMLTABLE function
11853 * ----------
11854 */
11855 static void
11857 {
11863 {
11870 {
11876 else
11880 {
11884 }
11885 else
11886 {
11889 }
11890 }
11892 }
11901 {
11912 {
11923 colnum++;
11932 {
11936 }
11938 {
11942 }
11945 }
11946 }
11949 }
11951 /*
11952 * get_json_table_nested_columns - Parse back nested JSON_TABLE columns
11953 */
11954 static void
11958 {
11960 {
11971 }
11973 {
11977 needcomma);
11980 }
11981 }
11983 /*
11984 * get_json_table_columns - Parse back JSON_TABLE columns
11985 */
11986 static void
11990 {
12008 {
12011 Oid typid;
12012 int32 typmod;
12014 JsonBehaviorType default_behavior;
12020 /* Skip columns that don't belong to this scan. */
12022 {
12023 colnum++;
12025 }
12032 colnum++;
12044 /*
12045 * Set default_behavior to guide get_json_expr_options() on whether to
12046 * to emit the ON ERROR / EMPTY clauses.
12047 */
12049 {
12052 }
12053 else
12054 {
12056 {
12066 }
12069 }
12076 }
12086 }
12088 /* ----------
12089 * get_json_table - Parse back a JSON_TABLE function
12090 * ----------
12091 */
12092 static void
12094 {
12115 {
12128 {
12138 );
12139 }
12143 }
12146 showimplicit);
12155 }
12157 /* ----------
12158 * get_tablefunc - Parse back a table function
12159 * ----------
12160 */
12161 static void
12163 {
12164 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12170 }
12172 /* ----------
12173 * get_from_clause - Parse back a FROM clause
12174 *
12175 * "prefix" is the keyword that denotes the start of the list of FROM
12176 * elements. It is FROM when used to parse back SELECT and UPDATE, but
12177 * is USING when parsing back DELETE.
12178 * ----------
12179 */
12180 static void
12182 {
12187 /*
12188 * We use the query's jointree as a guide to what to print. However, we
12189 * must ignore auto-added RTEs that are marked not inFromCl. (These can
12190 * only appear at the top level of the jointree, so it's sufficient to
12191 * check here.) This check also ensures we ignore the rule pseudo-RTEs
12192 * for NEW and OLD.
12193 */
12195 {
12199 {
12205 }
12208 {
12214 }
12215 else
12216 {
12217 StringInfoData itembuf;
12221 /*
12222 * Put the new FROM item's text into itembuf so we can decide
12223 * after we've got it whether or not it needs to go on a new line.
12224 */
12230 /* Restore context's output buffer */
12233 /* Consider line-wrapping if enabled */
12235 {
12236 /* Does the new item start with a new line? */
12238 {
12239 /* If so, we shouldn't add anything */
12240 /* instead, remove any trailing spaces currently in buf */
12242 }
12243 else
12244 {
12247 /* Locate the start of the current line in the buffer */
12251 else
12252 trailing_nl++;
12254 /*
12255 * Add a newline, plus some indentation, if the new item
12256 * would cause an overflow.
12257 */
12260 PRETTYINDENT_STD,
12261 PRETTYINDENT_VAR);
12262 }
12263 }
12265 /* Add the new item */
12268 /* clean up */
12270 }
12271 }
12272 }
12274 static void
12276 {
12281 {
12290 /* Print the FROM item proper */
12292 {
12294 /* Normal relation RTE */
12301 /* Subquery RTE */
12310 /* Function RTE */
12313 /*
12314 * Omit ROWS FROM() syntax for just one function, unless it
12315 * has both a coldeflist and WITH ORDINALITY. If it has both,
12316 * we must use ROWS FROM() syntax to avoid ambiguity about
12317 * whether the coldeflist includes the ordinality column.
12318 */
12321 {
12323 /* we'll print the coldeflist below, if it has one */
12324 }
12325 else
12326 {
12330 /*
12331 * If all the function calls in the list are to unnest,
12332 * and none need a coldeflist, then collapse the list back
12333 * down to UNNEST(args). (If we had more than one
12334 * built-in unnest function, this would get more
12335 * difficult.)
12336 *
12337 * XXX This is pretty ugly, since it makes not-terribly-
12338 * future-proof assumptions about what the parser would do
12339 * with the output; but the alternative is to emit our
12340 * nonstandard ROWS FROM() notation for what might have
12341 * been a perfectly spec-compliant multi-argument
12342 * UNNEST().
12343 */
12346 {
12352 {
12355 }
12356 }
12359 {
12363 {
12368 }
12373 }
12374 else
12375 {
12380 {
12387 {
12388 /* Reconstruct the column definition list */
12391 NULL,
12392 context);
12393 }
12394 funcno++;
12395 }
12397 }
12398 /* prevent printing duplicate coldeflist below */
12400 }
12408 /* Values list RTE */
12419 }
12421 /* Print the relation alias, if needed */
12424 /* Print the column definitions or aliases, if needed */
12426 {
12427 /* Reconstruct the columndef list, which is also the aliases */
12429 }
12430 else
12431 {
12432 /* Else print column aliases as needed */
12434 }
12436 /* Tablesample clause must go after any alias */
12439 }
12441 {
12456 {
12461 PRETTYINDENT_STD,
12462 PRETTYINDENT_JOIN);
12463 else
12466 PRETTYINDENT_STD,
12467 PRETTYINDENT_JOIN);
12472 PRETTYINDENT_STD,
12473 PRETTYINDENT_JOIN);
12478 PRETTYINDENT_STD,
12479 PRETTYINDENT_JOIN);
12484 PRETTYINDENT_STD,
12485 PRETTYINDENT_JOIN);
12490 }
12499 {
12504 /* Use the assigned names, not what's in usingClause */
12506 {
12511 else
12514 }
12520 }
12522 {
12529 }
12531 {
12532 /* If we didn't say CROSS JOIN above, we must provide an ON */
12534 }
12539 /* Yes, it's correct to put alias after the right paren ... */
12541 {
12542 /*
12543 * Note that it's correct to emit an alias clause if and only if
12544 * there was one originally. Otherwise we'd be converting a named
12545 * join to unnamed or vice versa, which creates semantic
12546 * subtleties we don't want. However, we might print a different
12547 * alias name than was there originally.
12548 */
12551 context)));
12553 }
12554 }
12555 else
12558 }
12560 /*
12561 * get_rte_alias - print the relation's alias, if needed
12562 *
12563 * If printed, the alias is preceded by a space, or by " AS " if use_as is true.
12564 */
12565 static void
12568 {
12575 {
12576 /* Always print alias if user provided one */
12578 }
12580 {
12581 /* Always print alias if we need to print column aliases */
12583 }
12585 {
12586 /*
12587 * No need to print alias if it's same as relation name (this would
12588 * normally be the case, but not if set_rtable_names had to resolve a
12589 * conflict).
12590 */
12593 }
12595 {
12596 /*
12597 * For a function RTE, always print alias. This covers possible
12598 * renaming of the function and/or instability of the FigureColname
12599 * rules for things that aren't simple functions. Note we'd need to
12600 * force it anyway for the columndef list case.
12601 */
12603 }
12606 {
12607 /*
12608 * For a subquery, always print alias. This makes the output
12609 * SQL-spec-compliant, even though we allow such aliases to be omitted
12610 * on input.
12611 */
12613 }
12615 {
12616 /*
12617 * No need to print alias if it's same as CTE name (this would
12618 * normally be the case, but not if set_rtable_names had to resolve a
12619 * conflict).
12620 */
12623 }
12629 }
12631 /*
12632 * get_column_alias_list - print column alias list for an RTE
12633 *
12634 * Caller must already have printed the relation's alias name.
12635 */
12636 static void
12638 {
12643 /* Don't print aliases if not needed */
12648 {
12652 {
12655 }
12656 else
12659 }
12662 }
12664 /*
12665 * get_from_clause_coldeflist - reproduce FROM clause coldeflist
12666 *
12667 * When printing a top-level coldeflist (which is syntactically also the
12668 * relation's column alias list), use column names from colinfo. But when
12669 * printing a coldeflist embedded inside ROWS FROM(), we prefer to use the
12670 * original coldeflist's names, which are available in rtfunc->funccolnames.
12671 * Pass NULL for colinfo to select the latter behavior.
12672 *
12673 * The coldeflist is appended immediately (no space) to buf. Caller is
12674 * responsible for ensuring that an alias or AS is present before it.
12675 */
12676 static void
12680 {
12695 {
12703 else
12718 i++;
12719 }
12722 }
12724 /*
12725 * get_tablesample_def - print a TableSampleClause
12726 */
12727 static void
12729 {
12735 /*
12736 * We should qualify the handler's function name if it wouldn't be
12737 * resolved by lookup in the current search path.
12738 */
12747 {
12751 }
12755 {
12759 }
12760 }
12762 /*
12763 * get_opclass_name - fetch name of an index operator class
12764 *
12765 * The opclass name is appended (after a space) to buf.
12766 *
12767 * Output is suppressed if the opclass is the default for the given
12768 * actual_datatype. (If you don't want this behavior, just pass
12769 * InvalidOid for actual_datatype.)
12770 */
12771 static void
12773 StringInfo buf)
12774 {
12775 HeapTuple ht_opc;
12776 Form_pg_opclass opcrec;
12787 {
12788 /* Okay, we need the opclass name. Do we need to qualify it? */
12792 else
12793 {
12798 }
12799 }
12801 }
12803 /*
12804 * generate_opclass_name
12805 * Compute the name to display for an opclass specified by OID
12806 *
12807 * The result includes all necessary quoting and schema-prefixing.
12808 */
12811 {
12812 StringInfoData buf;
12818 }
12820 /*
12821 * processIndirection - take care of array and subfield assignment
12822 *
12823 * We strip any top-level FieldStore or assignment SubscriptingRef nodes that
12824 * appear in the input, printing them as decoration for the base column
12825 * name (which we assume the caller just printed). We might also need to
12826 * strip CoerceToDomain nodes, but only ones that appear above assignment
12827 * nodes.
12828 *
12829 * Returns the subexpression that's to be assigned.
12830 */
12833 {
12838 {
12842 {
12844 Oid typrelid;
12847 /* lookup tuple type */
12853 /*
12854 * Print the field name. There should only be one target field in
12855 * stored rules. There could be more than that in executable
12856 * target lists, but this function cannot be used for that case.
12857 */
12863 /*
12864 * We ignore arg since it should be an uninteresting reference to
12865 * the target column or subcolumn.
12866 */
12868 }
12870 {
12878 /*
12879 * We ignore refexpr since it should be an uninteresting reference
12880 * to the target column or subcolumn.
12881 */
12883 }
12885 {
12887 /* If it's an explicit domain coercion, we're done */
12890 /* Tentatively descend past the CoerceToDomain */
12892 }
12893 else
12895 }
12897 /*
12898 * If we descended past a CoerceToDomain whose argument turned out not to
12899 * be a FieldStore or array assignment, back up to the CoerceToDomain.
12900 * (This is not enough to be fully correct if there are nested implicit
12901 * CoerceToDomains, but such cases shouldn't ever occur.)
12902 */
12907 }
12909 static void
12911 {
12918 {
12921 {
12922 /* If subexpression is NULL, get_rule_expr prints nothing */
12926 }
12927 /* If subexpression is NULL, get_rule_expr prints nothing */
12930 }
12931 }
12933 /*
12934 * quote_identifier - Quote an identifier only if needed
12935 *
12936 * When quotes are needed, we palloc the required space; slightly
12937 * space-wasteful but well worth it for notational simplicity.
12938 */
12941 {
12942 /*
12943 * Can avoid quoting if ident starts with a lowercase letter or underscore
12944 * and contains only lowercase letters, digits, and underscores, *and* is
12945 * not any SQL keyword. Otherwise, supply quotes.
12946 */
12953 /*
12954 * would like to use <ctype.h> macros here, but they might yield unwanted
12955 * locale-specific results...
12956 */
12960 {
12966 {
12967 /* okay */
12968 }
12969 else
12970 {
12973 nquotes++;
12974 }
12975 }
12981 {
12982 /*
12983 * Check for keyword. We quote keywords except for unreserved ones.
12984 * (In some cases we could avoid quoting a col_name or type_func_name
12985 * keyword, but it seems much harder than it's worth to tell that.)
12986 *
12987 * Note: ScanKeywordLookup() does case-insensitive comparison, but
12988 * that's fine, since we already know we have all-lower-case.
12989 */
12994 }
13004 {
13010 }
13015 }
13017 /*
13018 * quote_qualified_identifier - Quote a possibly-qualified identifier
13019 *
13020 * Return a name of the form qualifier.ident, or just ident if qualifier
13021 * is NULL, quoting each component if necessary. The result is palloc'd.
13022 */
13026 {
13027 StringInfoData buf;
13034 }
13036 /*
13037 * get_relation_name
13038 * Get the unqualified name of a relation specified by OID
13039 *
13040 * This differs from the underlying get_rel_name() function in that it will
13041 * throw error instead of silently returning NULL if the OID is bad.
13042 */
13045 {
13051 }
13053 /*
13054 * generate_relation_name
13055 * Compute the name to display for a relation specified by OID
13056 *
13057 * The result includes all necessary quoting and schema-prefixing.
13058 *
13059 * If namespaces isn't NIL, it must be a list of deparse_namespace nodes.
13060 * We will forcibly qualify the relation name if it equals any CTE name
13061 * visible in the namespace list.
13062 */
13065 {
13066 HeapTuple tp;
13067 Form_pg_class reltup;
13080 /* Check for conflicting CTE name */
13083 {
13088 {
13092 {
13095 }
13096 }
13099 }
13101 /* Otherwise, qualify the name if not visible in search path */
13107 else
13115 }
13117 /*
13118 * generate_qualified_relation_name
13119 * Compute the name to display for a relation specified by OID
13120 *
13121 * As above, but unconditionally schema-qualify the name.
13122 */
13125 {
13126 HeapTuple tp;
13127 Form_pg_class reltup;
13148 }
13150 /*
13151 * generate_function_name
13152 * Compute the name to display for a function specified by OID,
13153 * given that it is being called with the specified actual arg names and
13154 * types. (Those matter because of ambiguous-function resolution rules.)
13155 *
13156 * If we're dealing with a potentially variadic function (in practice, this
13157 * means a FuncExpr or Aggref, not some other way of calling a function), then
13158 * has_variadic must specify whether variadic arguments have been merged,
13159 * and *use_variadic_p will be set to indicate whether to print VARIADIC in
13160 * the output. For non-FuncExpr cases, has_variadic should be false and
13161 * use_variadic_p can be NULL.
13162 *
13163 * inGroupBy must be true if we're deparsing a GROUP BY clause.
13164 *
13165 * The result includes all necessary quoting and schema-prefixing.
13166 */
13171 {
13173 HeapTuple proctup;
13174 Form_pg_proc procform;
13178 FuncDetailCode p_result;
13179 Oid p_funcid;
13180 Oid p_rettype;
13183 Oid p_vatype;
13193 /*
13194 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
13195 * qualification of some function names within GROUP BY.
13196 */
13198 {
13201 }
13203 /*
13204 * Determine whether VARIADIC should be printed. We must do this first
13205 * since it affects the lookup rules in func_get_detail().
13206 *
13207 * We always print VARIADIC if the function has a merged variadic-array
13208 * argument. Note that this is always the case for functions taking a
13209 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
13210 * and printed the array elements as separate arguments, the call could
13211 * match a newer non-VARIADIC function.
13212 */
13214 {
13215 /* Parser should not have set funcvariadic unless fn is variadic */
13219 }
13220 else
13221 {
13224 }
13226 /*
13227 * The idea here is to schema-qualify only if the parser would fail to
13228 * resolve the correct function given the unqualified func name with the
13229 * specified argtypes and VARIADIC flag. But if we already decided to
13230 * force qualification, then we can skip the lookup and pretend we didn't
13231 * find it.
13232 */
13240 else
13241 {
13244 }
13251 else
13259 }
13261 /*
13262 * generate_operator_name
13263 * Compute the name to display for an operator specified by OID,
13264 * given that it is being called with the specified actual arg types.
13265 * (Arg types matter because of ambiguous-operator resolution rules.
13266 * Pass InvalidOid for unused arg of a unary operator.)
13267 *
13268 * The result includes all necessary quoting and schema-prefixing,
13269 * plus the OPERATOR() decoration needed to use a qualified operator name
13270 * in an expression.
13271 */
13274 {
13275 StringInfoData buf;
13276 HeapTuple opertup;
13277 Form_pg_operator operform;
13280 Operator p_result;
13290 /*
13291 * The idea here is to schema-qualify only if the parser would fail to
13292 * resolve the correct operator given the unqualified op name with the
13293 * specified argtypes.
13294 */
13296 {
13309 }
13313 else
13314 {
13317 }
13330 }
13332 /*
13333 * generate_operator_clause --- generate a binary-operator WHERE clause
13334 *
13335 * This is used for internally-generated-and-executed SQL queries, where
13336 * precision is essential and readability is secondary. The basic
13337 * requirement is to append "leftop op rightop" to buf, where leftop and
13338 * rightop are given as strings and are assumed to yield types leftoptype
13339 * and rightoptype; the operator is identified by OID. The complexity
13340 * comes from needing to be sure that the parser will select the desired
13341 * operator when the query is parsed. We always name the operator using
13342 * OPERATOR(schema.op) syntax, so as to avoid search-path uncertainties.
13343 * We have to emit casts too, if either input isn't already the input type
13344 * of the operator; else we are at the mercy of the parser's heuristics for
13345 * ambiguous-operator resolution. The caller must ensure that leftop and
13346 * rightop are suitable arguments for a cast operation; it's best to insert
13347 * parentheses if they aren't just variables or parameters.
13348 */
13349 void
13352 Oid opoid,
13354 {
13355 HeapTuple opertup;
13356 Form_pg_operator operform;
13379 }
13381 /*
13382 * Add a cast specification to buf. We spell out the type name the hard way,
13383 * intentionally not using format_type_be(). This is to avoid corner cases
13384 * for CHARACTER, BIT, and perhaps other types, where specifying the type
13385 * using SQL-standard syntax results in undesirable data truncation. By
13386 * doing it this way we can be certain that the cast will have default (-1)
13387 * target typmod.
13388 */
13389 static void
13391 {
13392 HeapTuple typetup;
13393 Form_pg_type typform;
13409 }
13411 /*
13412 * generate_qualified_type_name
13413 * Compute the name to display for a type specified by OID
13414 *
13415 * This is different from format_type_be() in that we unconditionally
13416 * schema-qualify the name. That also means no special syntax for
13417 * SQL-standard type names ... although in current usage, this should
13418 * only get used for domains, so such cases wouldn't occur anyway.
13419 */
13422 {
13423 HeapTuple tp;
13424 Form_pg_type typtup;
13445 }
13447 /*
13448 * generate_collation_name
13449 * Compute the name to display for a collation specified by OID
13450 *
13451 * The result includes all necessary quoting and schema-prefixing.
13452 */
13455 {
13456 HeapTuple tp;
13457 Form_pg_collation colltup;
13470 else
13478 }
13480 /*
13481 * Given a C string, produce a TEXT datum.
13482 *
13483 * We assume that the input was palloc'd and may be freed.
13484 */
13487 {
13493 }
13495 /*
13496 * Generate a C string representing a relation options from text[] datum.
13497 */
13498 static void
13500 {
13509 {
13515 /*
13516 * Each array element should have the form name=value. If the "=" is
13517 * missing for some reason, treat it like an empty value.
13518 */
13522 {
13525 }
13526 else
13533 /*
13534 * In general we need to quote the value; but to avoid unnecessary
13535 * clutter, do not quote if it is an identifier that would not need
13536 * quoting. (We could also allow numbers, but that is a bit trickier
13537 * than it looks --- for example, are leading zeroes significant? We
13538 * don't want to assume very much here about what custom reloptions
13539 * might mean.)
13540 */
13543 else
13547 }
13548 }
13550 /*
13551 * Generate a C string representing a relation's reloptions, or NULL if none.
13552 */
13555 {
13557 HeapTuple tuple;
13558 Datum reloptions;
13568 {
13569 StringInfoData buf;
13575 }
13580 }
13582 /*
13583 * get_range_partbound_string
13584 * A C string representation of one range partition bound
13585 */
13588 {
13589 deparse_context context;
13600 {
13609 else
13610 {
13614 }
13616 }
13620 }