| blob | b31be31321dc3c6bbc36a5be8e8495e835c4cea3 |
1 /*-------------------------------------------------------------------------
2 *
3 * ruleutils.c
4 * Functions to convert stored expressions/querytrees back to
5 * source text
6 *
7 * Portions Copyright (c) 1996-2024, 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 {
170 /* Workspace for column alias assignment: */
173 /* Remaining fields are used only when deparsing a Plan tree: */
181 /* Special namespace representing a function signature: */
187 /*
188 * Per-relation data about column alias names.
189 *
190 * Selecting aliases is unreasonably complicated because of the need to dump
191 * rules/views whose underlying tables may have had columns added, deleted, or
192 * renamed since the query was parsed. We must nonetheless print the rule/view
193 * in a form that can be reloaded and will produce the same results as before.
194 *
195 * For each RTE used in the query, we must assign column aliases that are
196 * unique within that RTE. SQL does not require this of the original query,
197 * but due to factors such as *-expansion we need to be able to uniquely
198 * reference every column in a decompiled query. As long as we qualify all
199 * column references, per-RTE uniqueness is sufficient for that.
200 *
201 * However, we can't ensure per-column name uniqueness for unnamed join RTEs,
202 * since they just inherit column names from their input RTEs, and we can't
203 * rename the columns at the join level. Most of the time this isn't an issue
204 * because we don't need to reference the join's output columns as such; we
205 * can reference the input columns instead. That approach can fail for merged
206 * JOIN USING columns, however, so when we have one of those in an unnamed
207 * join, we have to make that column's alias globally unique across the whole
208 * query to ensure it can be referenced unambiguously.
209 *
210 * Another problem is that a JOIN USING clause requires the columns to be
211 * merged to have the same aliases in both input RTEs, and that no other
212 * columns in those RTEs or their children conflict with the USING names.
213 * To handle that, we do USING-column alias assignment in a recursive
214 * traversal of the query's jointree. When descending through a JOIN with
215 * USING, we preassign the USING column names to the child columns, overriding
216 * other rules for column alias assignment. We also mark each RTE with a list
217 * of all USING column names selected for joins containing that RTE, so that
218 * when we assign other columns' aliases later, we can avoid conflicts.
219 *
220 * Another problem is that if a JOIN's input tables have had columns added or
221 * deleted since the query was parsed, we must generate a column alias list
222 * for the join that matches the current set of input columns --- otherwise, a
223 * change in the number of columns in the left input would throw off matching
224 * of aliases to columns of the right input. Thus, positions in the printable
225 * column alias list are not necessarily one-for-one with varattnos of the
226 * JOIN, so we need a separate new_colnames[] array for printing purposes.
227 */
229 {
230 /*
231 * colnames is an array containing column aliases to use for columns that
232 * existed when the query was parsed. Dropped columns have NULL entries.
233 * This array can be directly indexed by varattno to get a Var's name.
234 *
235 * Non-NULL entries are guaranteed unique within the RTE, *except* when
236 * this is for an unnamed JOIN RTE. In that case we merely copy up names
237 * from the two input RTEs.
238 *
239 * During the recursive descent in set_using_names(), forcible assignment
240 * of a child RTE's column name is represented by pre-setting that element
241 * of the child's colnames array. So at that stage, NULL entries in this
242 * array just mean that no name has been preassigned, not necessarily that
243 * the column is dropped.
244 */
248 /*
249 * new_colnames is an array containing column aliases to use for columns
250 * that would exist if the query was re-parsed against the current
251 * definitions of its base tables. This is what to print as the column
252 * alias list for the RTE. This array does not include dropped columns,
253 * but it will include columns added since original parsing. Indexes in
254 * it therefore have little to do with current varattno values. As above,
255 * entries are unique unless this is for an unnamed JOIN RTE. (In such an
256 * RTE, we never actually print this array, but we must compute it anyway
257 * for possible use in computing column names of upper joins.) The
258 * parallel array is_new_col marks which of these columns are new since
259 * original parsing. Entries with is_new_col false must match the
260 * non-NULL colnames entries one-for-one.
261 */
266 /* This flag tells whether we should actually print a column alias list */
269 /* This list has all names used as USING names in joins above this RTE */
272 /*
273 * If this struct is for a JOIN RTE, we fill these fields during the
274 * set_using_names() pass to describe its relationship to its child RTEs.
275 *
276 * leftattnos and rightattnos are arrays with one entry per existing
277 * output column of the join (hence, indexable by join varattno). For a
278 * simple reference to a column of the left child, leftattnos[i] is the
279 * child RTE's attno and rightattnos[i] is zero; and conversely for a
280 * column of the right child. But for merged columns produced by JOIN
281 * USING/NATURAL JOIN, both leftattnos[i] and rightattnos[i] are nonzero.
282 * Note that a simple reference might be to a child RTE column that's been
283 * dropped; but that's OK since the column could not be used in the query.
284 *
285 * If it's a JOIN USING, usingNames holds the alias names selected for the
286 * merged columns (these might be different from the original USING list,
287 * if we had to modify names to achieve uniqueness).
288 */
296 /* This macro is analogous to rt_fetch(), but for deparse_columns structs */
297 #define deparse_columns_fetch(rangetable_index, dpns) \
298 ((deparse_columns *) list_nth((dpns)->rtable_columns, (rangetable_index)-1))
300 /*
301 * Entry in set_rtable_names' hash table
302 */
304 {
309 /* Callback signature for resolve_special_varno() */
314 /* ----------
315 * Global data
316 * ----------
317 */
319 static const char *const query_getrulebyoid = "SELECT * FROM pg_catalog.pg_rewrite WHERE oid = $1";
321 static const char *const query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";
323 /* GUC parameters */
327 /* ----------
328 * Local functions
329 *
330 * Most of these functions used to use fixed-size buffers to build their
331 * results. Now, they take an (already initialized) StringInfo object
332 * as a parameter, and append their text output to its contents.
333 * ----------
334 */
342 StringInfo buf);
479 StringInfo buf);
502 StringInfo buf);
531 /* ----------
532 * pg_get_ruledef - Do it all and return a text
533 * that could be used as a statement
534 * to recreate the rule
535 * ----------
536 */
537 Datum
539 {
552 }
555 Datum
557 {
571 }
576 {
580 HeapTuple ruletup;
581 TupleDesc rulettc;
582 StringInfoData buf;
584 /*
585 * Do this first so that string is alloc'd in outer context not SPI's.
586 */
589 /*
590 * Connect to SPI manager
591 */
595 /*
596 * On the first call prepare the plan to lookup pg_rewrite. We read
597 * pg_rewrite over the SPI manager instead of using the syscache to be
598 * checked for read access on pg_rewrite.
599 */
601 {
603 SPIPlanPtr plan;
611 }
613 /*
614 * Get the pg_rewrite tuple for this rule
615 */
622 {
623 /*
624 * There is no tuple data available here, just keep the output buffer
625 * empty.
626 */
627 }
628 else
629 {
630 /*
631 * Get the rule's definition and put it into executor's memory
632 */
636 }
638 /*
639 * Disconnect from SPI manager
640 */
648 }
651 /* ----------
652 * pg_get_viewdef - Mainly the same thing, but we
653 * only return the SELECT part of a view
654 * ----------
655 */
656 Datum
658 {
659 /* By OID */
672 }
675 Datum
677 {
678 /* By OID */
692 }
694 Datum
696 {
697 /* By OID */
703 /* calling this implies we want pretty printing */
712 }
714 Datum
716 {
717 /* By qualified name */
721 Oid viewoid;
726 /* Look up view name. Can't lock it - we might not have privileges. */
736 }
739 Datum
741 {
742 /* By qualified name */
747 Oid viewoid;
752 /* Look up view name. Can't lock it - we might not have privileges. */
762 }
764 /*
765 * Common code for by-OID and by-name variants of pg_get_viewdef
766 */
769 {
773 HeapTuple ruletup;
774 TupleDesc rulettc;
775 StringInfoData buf;
777 /*
778 * Do this first so that string is alloc'd in outer context not SPI's.
779 */
782 /*
783 * Connect to SPI manager
784 */
788 /*
789 * On the first call prepare the plan to lookup pg_rewrite. We read
790 * pg_rewrite over the SPI manager instead of using the syscache to be
791 * checked for read access on pg_rewrite.
792 */
794 {
796 SPIPlanPtr plan;
805 }
807 /*
808 * Get the pg_rewrite tuple for the view's SELECT rule
809 */
818 {
819 /*
820 * There is no tuple data available here, just keep the output buffer
821 * empty.
822 */
823 }
824 else
825 {
826 /*
827 * Get the rule's definition and put it into executor's memory
828 */
832 }
834 /*
835 * Disconnect from SPI manager
836 */
844 }
846 /* ----------
847 * pg_get_triggerdef - Get the definition of a trigger
848 * ----------
849 */
850 Datum
852 {
862 }
864 Datum
866 {
877 }
881 {
882 HeapTuple ht_trig;
883 Form_pg_trigger trigrec;
884 StringInfoData buf;
885 Relation tgrel;
887 SysScanDesc tgscan;
892 Datum value;
895 /*
896 * Fetch the pg_trigger tuple by the Oid of the trigger
897 */
901 Anum_pg_trigger_oid,
911 {
915 }
919 /*
920 * Start the trigger definition. Note that the trigger's name should never
921 * be schema-qualified, but the trigger rel's name may be.
922 */
936 else
940 {
942 findx++;
943 }
945 {
948 else
950 findx++;
951 }
953 {
956 else
958 findx++;
959 /* tgattr is first var-width field, so OK to access directly */
961 {
966 {
974 }
975 }
976 }
978 {
981 else
983 findx++;
984 }
986 /*
987 * In non-pretty mode, always schema-qualify the target table name for
988 * safety. In pretty mode, schema-qualify only if not visible.
989 */
991 pretty ?
996 {
1005 else
1007 }
1013 else
1019 else
1022 {
1030 }
1034 else
1037 /* If the trigger has a WHEN qualification, add that */
1041 {
1044 deparse_context context;
1045 deparse_namespace dpns;
1055 /* Build minimal OLD and NEW RTEs for the rel */
1078 /* Build two-element rtable */
1087 /* Set up context with one-deep namespace stack */
1105 }
1113 {
1123 {
1127 /* advance p to next string embedded in tgargs */
1129 p++;
1130 p++;
1131 }
1132 }
1134 /* We deliberately do not put semi-colon at end */
1137 /* Clean up */
1143 }
1145 /* ----------
1146 * pg_get_indexdef - Get the definition of an index
1147 *
1148 * In the extended version, there is a colno argument as well as pretty bool.
1149 * if colno == 0, we want a complete index definition.
1150 * if colno > 0, we only want the Nth index key's variable or expression.
1151 *
1152 * Note that the SQL-function versions of this omit any info about the
1153 * index tablespace; this is intentional because pg_dump wants it that way.
1154 * However pg_get_indexdef_string() includes the index tablespace.
1155 * ----------
1156 */
1157 Datum
1159 {
1175 }
1177 Datum
1179 {
1197 }
1199 /*
1200 * Internal version for use by ALTER TABLE.
1201 * Includes a tablespace clause in the result.
1202 * Returns a palloc'd C string; no pretty-printing.
1203 */
1206 {
1211 }
1213 /* Internal version that just reports the key-column definitions */
1216 {
1225 }
1227 /* Internal version, extensible with flags to control its behavior */
1230 {
1241 }
1243 /*
1244 * Internal workhorse to decompile an index definition.
1245 *
1246 * This is now used for exclusion constraints as well: if excludeOps is not
1247 * NULL then it points to an array of exclusion operator OIDs.
1248 */
1255 {
1256 /* might want a separate isConstraint parameter later */
1258 HeapTuple ht_idx;
1259 HeapTuple ht_idxrel;
1260 HeapTuple ht_am;
1261 Form_pg_index idxrec;
1262 Form_pg_class idxrelrec;
1263 Form_pg_am amrec;
1268 Oid indrelid;
1270 Datum indcollDatum;
1271 Datum indclassDatum;
1272 Datum indoptionDatum;
1276 StringInfoData buf;
1280 /*
1281 * Fetch the pg_index tuple by the Oid of the index
1282 */
1285 {
1289 }
1295 /* Must get indcollation, indclass, and indoption the hard way */
1297 Anum_pg_index_indcollation);
1301 Anum_pg_index_indclass);
1305 Anum_pg_index_indoption);
1308 /*
1309 * Fetch the pg_class tuple of the index relation
1310 */
1316 /*
1317 * Fetch the pg_am tuple of the index' access method
1318 */
1325 /* Fetch the index AM's API struct */
1328 /*
1329 * Get the index expressions, if any. (NOTE: we do not use the relcache
1330 * versions of the expressions and predicate, because we want to display
1331 * non-const-folded expressions.)
1332 */
1334 {
1335 Datum exprsDatum;
1339 Anum_pg_index_indexprs);
1343 }
1344 else
1351 /*
1352 * Start the index definition. Note that the index's name should never be
1353 * schema-qualified, but the indexed rel's name may be.
1354 */
1358 {
1372 }
1374 /*
1375 * Report the indexed attributes
1376 */
1379 {
1381 Oid keycoltype;
1382 Oid keycolcollation;
1384 /*
1385 * Ignore non-key attributes if told to.
1386 */
1390 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1392 {
1395 }
1402 {
1403 /* Simple index column */
1405 int32 keycoltypmod;
1413 }
1414 else
1415 {
1416 /* expressional index */
1423 /* Deparse */
1427 {
1428 /* Need parens if it's not a bare function call */
1431 else
1433 }
1436 }
1438 /* Print additional decoration for (selected) key columns */
1441 {
1447 /* Add collation, if not default for column */
1452 /* Add the operator class name, if not default */
1457 {
1461 }
1463 /* Add options if relevant */
1465 {
1466 /* if it supports sort ordering, report DESC and NULLS opts */
1468 {
1470 /* NULLS FIRST is the default in this case */
1473 }
1474 else
1475 {
1478 }
1479 }
1481 /* Add the exclusion operator if relevant */
1485 keycoltype,
1486 keycoltype));
1487 }
1488 }
1491 {
1497 /*
1498 * If it has options, append "WITH (options)"
1499 */
1502 {
1505 }
1507 /*
1508 * Print tablespace, but only if requested
1509 */
1511 {
1512 Oid tblspc;
1516 {
1521 }
1522 }
1524 /*
1525 * If it's a partial index, decompile and append the predicate
1526 */
1528 {
1530 Datum predDatum;
1533 /* Convert text string to node tree */
1535 Anum_pg_index_indpred);
1540 /* Deparse */
1545 else
1547 }
1548 }
1550 /* Clean up */
1556 }
1558 /* ----------
1559 * pg_get_querydef
1560 *
1561 * Public entry point to deparse one query parsetree.
1562 * The pretty flags are determined by GET_PRETTY_FLAGS(pretty).
1563 *
1564 * The result is a palloc'd C string.
1565 * ----------
1566 */
1569 {
1570 StringInfoData buf;
1581 }
1583 /*
1584 * pg_get_statisticsobjdef
1585 * Get the definition of an extended statistics object
1586 */
1587 Datum
1589 {
1599 }
1601 /*
1602 * Internal version for use by ALTER TABLE.
1603 * Includes a tablespace clause in the result.
1604 * Returns a palloc'd C string; no pretty-printing.
1605 */
1608 {
1610 }
1612 /*
1613 * pg_get_statisticsobjdef_columns
1614 * Get columns and expressions for an extended statistics object
1615 */
1616 Datum
1618 {
1628 }
1630 /*
1631 * Internal workhorse to decompile an extended statistics object.
1632 */
1635 {
1636 Form_pg_statistic_ext statextrec;
1637 HeapTuple statexttup;
1638 StringInfoData buf;
1643 Datum datum;
1657 {
1661 }
1663 /* has the statistics expressions? */
1668 /*
1669 * Get the statistics expressions, if any. (NOTE: we do not use the
1670 * relcache versions of the expressions, because we want to display
1671 * non-const-folded expressions.)
1672 */
1674 {
1675 Datum exprsDatum;
1679 Anum_pg_statistic_ext_stxexprs);
1683 }
1684 else
1687 /* count the number of columns (attributes and expressions) */
1693 {
1699 /*
1700 * Decode the stxkind column so that we know which stats types to
1701 * print.
1702 */
1704 Anum_pg_statistic_ext_stxkind);
1717 {
1725 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
1726 }
1728 /*
1729 * If any option is disabled, then we'll need to append the types
1730 * clause to show which options are enabled. We omit the types clause
1731 * on purpose when all options are enabled, so a pg_dump/pg_restore
1732 * will create all statistics types on a newer postgres version, if
1733 * the statistics had all options enabled on the original version.
1734 *
1735 * But if the statistics is defined on just a single column, it has to
1736 * be an expression statistics. In that case we don't need to specify
1737 * kinds.
1738 */
1741 {
1747 {
1750 }
1753 {
1756 }
1762 }
1765 }
1767 /* decode simple column references */
1769 {
1779 }
1785 {
1796 /* Need parens if it's not a bare function call */
1799 else
1802 colno++;
1803 }
1812 }
1814 /*
1815 * Generate text array of expressions for statistics object.
1816 */
1817 Datum
1819 {
1821 Form_pg_statistic_ext statextrec;
1822 HeapTuple statexttup;
1823 Datum datum;
1836 /* Does the stats object have expressions? */
1839 /* no expressions? we're done */
1841 {
1844 }
1848 /*
1849 * Get the statistics expressions, and deparse them into text values.
1850 */
1852 Anum_pg_statistic_ext_stxexprs);
1861 {
1872 TEXTOID,
1873 CurrentMemoryContext);
1874 }
1879 }
1881 /*
1882 * pg_get_partkeydef
1883 *
1884 * Returns the partition key specification, ie, the following:
1885 *
1886 * { RANGE | LIST | HASH } (column opt_collation opt_opclass [, ...])
1887 */
1888 Datum
1890 {
1900 }
1902 /* Internal version that just reports the column definitions */
1905 {
1911 }
1913 /*
1914 * Internal workhorse to decompile a partition key definition.
1915 */
1919 {
1920 Form_pg_partitioned_table form;
1921 HeapTuple tuple;
1927 Datum datum;
1928 StringInfoData buf;
1935 {
1939 }
1945 /* Must get partclass and partcollation the hard way */
1947 Anum_pg_partitioned_table_partclass);
1951 Anum_pg_partitioned_table_partcollation);
1955 /*
1956 * Get the expressions, if any. (NOTE: we do not use the relcache
1957 * versions of the expressions, because we want to display
1958 * non-const-folded expressions.)
1959 */
1961 {
1962 Datum exprsDatum;
1966 Anum_pg_partitioned_table_partexprs);
1975 }
1976 else
1985 {
2001 }
2007 {
2009 Oid keycoltype;
2010 Oid keycolcollation;
2011 Oid partcoll;
2016 {
2017 /* Simple attribute reference */
2019 int32 keycoltypmod;
2026 }
2027 else
2028 {
2029 /* Expression */
2037 /* Deparse */
2040 /* Need parens if it's not a bare function call */
2043 else
2048 }
2050 /* Add collation, if not default for column */
2056 /* Add the operator class name, if not default */
2059 }
2064 /* Clean up */
2068 }
2070 /*
2071 * pg_get_partition_constraintdef
2072 *
2073 * Returns partition constraint expression as a string for the input relation
2074 */
2075 Datum
2077 {
2086 /* Quick exit if no partition constraint */
2090 /*
2091 * Deparse and return the constraint expression.
2092 */
2099 }
2101 /*
2102 * pg_get_partconstrdef_string
2103 *
2104 * Returns the partition constraint as a C-string for the input relation, with
2105 * the given alias. No pretty-printing.
2106 */
2109 {
2117 }
2119 /*
2120 * pg_get_constraintdef
2121 *
2122 * Returns the definition for the constraint, ie, everything that needs to
2123 * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
2124 */
2125 Datum
2127 {
2140 }
2142 Datum
2144 {
2158 }
2160 /*
2161 * Internal version that returns a full ALTER TABLE ... ADD CONSTRAINT command
2162 */
2165 {
2167 }
2169 /*
2170 * As of 9.4, we now use an MVCC snapshot for this.
2171 */
2175 {
2176 HeapTuple tup;
2177 Form_pg_constraint conForm;
2178 StringInfoData buf;
2179 SysScanDesc scandesc;
2185 Anum_pg_constraint_oid,
2190 ConstraintOidIndexId,
2192 snapshot,
2194 scankey);
2196 /*
2197 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2198 * via SearchSysCache, which works fine.
2199 */
2205 {
2207 {
2211 }
2213 }
2220 {
2222 {
2223 /*
2224 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2225 * constraints, and other types of constraints don't inherit
2226 * anyway so it doesn't matter whether we say ONLY or not. Someday
2227 * we might need to let callers specify whether to put ONLY in the
2228 * command.
2229 */
2233 }
2234 else
2235 {
2236 /* Must be a domain constraint */
2241 }
2242 }
2245 {
2247 {
2248 Datum val;
2252 /* Start off the constraint definition */
2255 /* Fetch and build referencing-column list */
2257 Anum_pg_constraint_conkey);
2261 /* add foreign relation name */
2264 NIL));
2266 /* Fetch and build referenced-column list */
2268 Anum_pg_constraint_confkey);
2274 /* Add match type */
2276 {
2291 }
2294 /* Add ON UPDATE and ON DELETE clauses, if needed */
2296 {
2317 }
2322 {
2343 }
2347 /*
2348 * Add columns specified to SET NULL or SET DEFAULT if
2349 * provided.
2350 */
2354 {
2358 }
2361 }
2364 {
2365 Datum val;
2366 Oid indexId;
2368 HeapTuple indtup;
2370 /* Start off the constraint definition */
2373 else
2387 /* Fetch and build target column list */
2389 Anum_pg_constraint_conkey);
2395 /* Build including column list (from pg_index.indkeys) */
2397 Anum_pg_index_indnatts);
2399 {
2400 Datum cols;
2408 Anum_pg_index_indkey);
2414 {
2422 }
2425 }
2428 /* XXX why do we only print these bits if fullCommand? */
2430 {
2432 Oid tblspc;
2435 {
2438 }
2440 /*
2441 * Print the tablespace, unless it's the database default.
2442 * This is to help ALTER TABLE usage of this facility,
2443 * which needs this behavior to recreate exact catalog
2444 * state.
2445 */
2450 }
2453 }
2455 {
2456 Datum val;
2462 /* Fetch constraint expression in parsetree form */
2464 Anum_pg_constraint_conbin);
2469 /* Set up deparsing context for Var nodes in constraint */
2471 {
2472 /* relation constraint */
2475 }
2476 else
2477 {
2478 /* domain constraint --- can't have Vars */
2480 }
2485 /*
2486 * Now emit the constraint definition, adding NO INHERIT if
2487 * necessary.
2488 *
2489 * There are cases where the constraint expression will be
2490 * fully parenthesized and we don't need the outer parens ...
2491 * but there are other cases where we do need 'em. Be
2492 * conservative for now.
2493 *
2494 * Note that simply checking for leading '(' and trailing ')'
2495 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2496 */
2498 consrc,
2501 }
2504 /*
2505 * There isn't an ALTER TABLE syntax for creating a user-defined
2506 * constraint trigger, but it seems better to print something than
2507 * throw an error; if we throw error then this function couldn't
2508 * safely be applied to all rows of pg_constraint.
2509 */
2513 {
2515 Datum val;
2521 /* Extract operator OIDs from the pg_constraint tuple */
2523 Anum_pg_constraint_conexclop);
2532 /* pg_get_indexdef_worker does the rest */
2533 /* suppress tablespace because pg_dump wants it that way */
2537 operators,
2542 prettyFlags,
2545 }
2549 }
2558 /* Cleanup */
2563 }
2566 /*
2567 * Convert an int16[] Datum into a comma-separated list of column names
2568 * for the indicated relation; append the list to buf. Returns the number
2569 * of keys.
2570 */
2571 static int
2573 StringInfo buf)
2574 {
2579 /* Extract data from array of int16 */
2584 {
2591 else
2593 }
2596 }
2599 /* ----------
2600 * pg_get_expr - Decompile an expression tree
2601 *
2602 * Input: an expression tree in nodeToString form, and a relation OID
2603 *
2604 * Output: reverse-listed expression
2605 *
2606 * Currently, the expression can only refer to a single relation, namely
2607 * the one specified by the second parameter. This is sufficient for
2608 * partial indexes, column default expressions, etc. We also support
2609 * Var-free expressions, for which the OID can be InvalidOid.
2610 *
2611 * If the OID is nonzero but not actually valid, don't throw an error,
2612 * just return NULL. This is a bit questionable, but it's what we've
2613 * done historically, and it can help avoid unwanted failures when
2614 * examining catalog entries for just-deleted relations.
2615 *
2616 * We expect this function to work, or throw a reasonably clean error,
2617 * for any node tree that can appear in a catalog pg_node_tree column.
2618 * Query trees, such as those appearing in pg_rewrite.ev_action, are
2619 * not supported. Nor are expressions in more than one relation, which
2620 * can appear in places like pg_rewrite.ev_qual.
2621 * ----------
2622 */
2623 Datum
2625 {
2636 else
2638 }
2640 Datum
2642 {
2654 else
2656 }
2660 {
2663 Relids relids;
2669 /* Convert input pg_node_tree (really TEXT) object to C string */
2672 /* Convert expression to node tree */
2677 /*
2678 * Throw error if the input is a querytree rather than an expression tree.
2679 * While we could support queries here, there seems no very good reason
2680 * to. In most such catalog columns, we'll see a List of Query nodes, or
2681 * even nested Lists, so drill down to a non-List node before checking.
2682 */
2691 /*
2692 * Throw error if the expression contains Vars we won't be able to
2693 * deparse.
2694 */
2697 {
2702 }
2703 else
2704 {
2709 }
2711 /*
2712 * Prepare deparse context if needed. If we are deparsing with a relid,
2713 * we need to transiently open and lock the rel, to make sure it won't go
2714 * away underneath us. (set_relation_column_names would lock it anyway,
2715 * so this isn't really introducing any new behavior.)
2716 */
2718 {
2723 }
2724 else
2727 /* Deparse */
2735 }
2738 /* ----------
2739 * pg_get_userbyid - Get a user name by roleid and
2740 * fallback to 'unknown (OID=n)'
2741 * ----------
2742 */
2743 Datum
2745 {
2747 Name result;
2748 HeapTuple roletup;
2749 Form_pg_authid role_rec;
2751 /*
2752 * Allocate space for the result
2753 */
2757 /*
2758 * Get the pg_authid entry and print the result
2759 */
2762 {
2766 }
2767 else
2771 }
2774 /*
2775 * pg_get_serial_sequence
2776 * Get the name of the sequence used by an identity or serial column,
2777 * formatted suitably for passing to setval, nextval or currval.
2778 * First parameter is not treated as double-quoted, second parameter
2779 * is --- see documentation for reason.
2780 */
2781 Datum
2783 {
2787 Oid tableOid;
2789 AttrNumber attnum;
2791 Relation depRel;
2793 SysScanDesc scan;
2794 HeapTuple tup;
2796 /* Look up table name. Can't lock it - we might not have privileges. */
2800 /* Get the number of the column */
2810 /* Search the dependency table for the dependent sequence */
2814 Anum_pg_depend_refclassid,
2818 Anum_pg_depend_refobjid,
2822 Anum_pg_depend_refobjsubid,
2830 {
2833 /*
2834 * Look for an auto dependency (serial column) or internal dependency
2835 * (identity column) of a sequence on a column. (We need the relkind
2836 * test because indexes can also have auto dependencies on columns.)
2837 */
2843 {
2846 }
2847 }
2853 {
2859 }
2862 }
2865 /*
2866 * pg_get_functiondef
2867 * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
2868 * the specified function.
2869 *
2870 * Note: if you change the output format of this function, be careful not
2871 * to break psql's rules (in \ef and \sf) for identifying the start of the
2872 * function body. To wit: the function body starts on a line that begins with
2873 * "AS ", "BEGIN ", or "RETURN ", and no preceding line will look like that.
2874 */
2875 Datum
2877 {
2879 StringInfoData buf;
2880 StringInfoData dq;
2881 HeapTuple proctup;
2882 Form_pg_proc proc;
2884 Datum tmp;
2889 float4 procost;
2894 /* Look up the function */
2909 /*
2910 * We always qualify the function name, to ensure the right function gets
2911 * replaced.
2912 */
2920 {
2924 }
2931 /* Emit some miscellaneous options on one line */
2937 {
2946 }
2949 {
2958 }
2967 /* This code for the default cost and rows should match functioncmds.c */
2971 else
2980 {
2983 /*
2984 * We should qualify the support function's name if it wouldn't be
2985 * resolved by lookup in the current search path.
2986 */
2992 }
2997 /* Emit any proconfig options, one per line */
3000 {
3009 {
3010 Datum d;
3019 {
3031 /*
3032 * Variables that are marked GUC_LIST_QUOTE were already fully
3033 * quoted by flatten_set_variable_args() before they were put
3034 * into the proconfig array. However, because the quoting
3035 * rules used there aren't exactly like SQL's, we have to
3036 * break the list value apart and then quote the elements as
3037 * string literals. (The elements may be double-quoted as-is,
3038 * but we can't just feed them to the SQL parser; it would do
3039 * the wrong thing with elements that are zero-length or
3040 * longer than NAMEDATALEN.)
3041 *
3042 * Variables that are not so marked should just be emitted as
3043 * simple string literals. If the variable is not known to
3044 * guc.c, we'll do that; this makes it unsafe to use
3045 * GUC_LIST_QUOTE for extension variables.
3046 */
3048 {
3052 /* Parse string into list of identifiers */
3054 {
3055 /* this shouldn't fail really */
3057 }
3059 {
3065 }
3066 }
3067 else
3070 }
3071 }
3072 }
3074 /* And finally the function definition ... */
3077 {
3079 }
3080 else
3081 {
3086 {
3089 }
3094 /*
3095 * We always use dollar quoting. Figure out a suitable delimiter.
3096 *
3097 * Since the user is likely to be editing the function body string, we
3098 * shouldn't use a short delimiter that he might easily create a
3099 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3100 * if needed.
3101 */
3112 }
3119 }
3121 /*
3122 * pg_get_function_arguments
3123 * Get a nicely-formatted list of arguments for a function.
3124 * This is everything that would go between the parentheses in
3125 * CREATE FUNCTION.
3126 */
3127 Datum
3129 {
3131 StringInfoData buf;
3132 HeapTuple proctup;
3145 }
3147 /*
3148 * pg_get_function_identity_arguments
3149 * Get a formatted list of arguments for a function.
3150 * This is everything that would go between the parentheses in
3151 * ALTER FUNCTION, etc. In particular, don't print defaults.
3152 */
3153 Datum
3155 {
3157 StringInfoData buf;
3158 HeapTuple proctup;
3171 }
3173 /*
3174 * pg_get_function_result
3175 * Get a nicely-formatted version of the result type of a function.
3176 * This is what would appear after RETURNS in CREATE FUNCTION.
3177 */
3178 Datum
3180 {
3182 StringInfoData buf;
3183 HeapTuple proctup;
3190 {
3193 }
3202 }
3204 /*
3205 * Guts of pg_get_function_result: append the function's return type
3206 * to the specified buffer.
3207 */
3208 static void
3210 {
3213 StringInfoData rbuf;
3218 {
3219 /* It might be a table function; try to print the arguments */
3224 else
3226 }
3229 {
3230 /* Not a table function, so do the normal thing */
3234 }
3237 }
3239 /*
3240 * Common code for pg_get_function_arguments and pg_get_function_result:
3241 * append the desired subset of arguments to buf. We print only TABLE
3242 * arguments when print_table_args is true, and all the others when it's false.
3243 * We print argument defaults only if print_defaults is true.
3244 * Function return value is the number of arguments printed.
3245 */
3246 static int
3249 {
3268 {
3269 Datum proargdefaults;
3273 Anum_pg_proc_proargdefaults,
3276 {
3283 /* nlackdefaults counts only *input* arguments lacking defaults */
3285 }
3286 }
3288 /* Check for special treatment of ordered-set aggregates */
3290 {
3291 HeapTuple aggtup;
3292 Form_pg_aggregate agg;
3302 }
3307 {
3315 {
3318 /*
3319 * For procedures, explicitly mark all argument modes, so as
3320 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3321 */
3324 else
3349 }
3357 {
3361 }
3370 {
3379 }
3380 argsprinted++;
3382 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3384 {
3385 i--;
3386 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3388 }
3389 }
3392 }
3394 static bool
3396 {
3401 }
3403 /*
3404 * Append used transformed types to specified buffer
3405 */
3406 static void
3408 {
3414 {
3419 {
3423 }
3425 }
3426 }
3428 /*
3429 * Get textual representation of a function argument's default value. The
3430 * second argument of this function is the argument number among all arguments
3431 * (i.e. proallargtypes, *not* proargtypes), starting with 1, because that's
3432 * how information_schema.sql uses it.
3433 */
3434 Datum
3436 {
3439 HeapTuple proctup;
3440 Form_pg_proc proc;
3450 Datum proargdefaults;
3460 {
3463 }
3468 nth_inputarg++;
3471 Anum_pg_proc_proargdefaults,
3474 {
3477 }
3485 /*
3486 * Calculate index into proargdefaults: proargdefaults corresponds to the
3487 * last N input arguments, where N = pronargdefaults.
3488 */
3492 {
3495 }
3502 }
3504 static void
3506 {
3512 Datum tmp;
3525 {
3534 {
3537 /* It seems advisable to get at least AccessShareLock on rels */
3543 }
3546 }
3547 else
3548 {
3551 /* It seems advisable to get at least AccessShareLock on rels */
3555 }
3556 }
3558 Datum
3560 {
3562 StringInfoData buf;
3563 HeapTuple proctup;
3568 /* Look up the function */
3575 {
3578 }
3585 }
3588 /*
3589 * deparse_expression - General utility for deparsing expressions
3590 *
3591 * calls deparse_expression_pretty with all prettyPrinting disabled
3592 */
3596 {
3599 }
3601 /* ----------
3602 * deparse_expression_pretty - General utility for deparsing expressions
3603 *
3604 * expr is the node tree to be deparsed. It must be a transformed expression
3605 * tree (ie, not the raw output of gram.y).
3606 *
3607 * dpcontext is a list of deparse_namespace nodes representing the context
3608 * for interpreting Vars in the node tree. It can be NIL if no Vars are
3609 * expected.
3610 *
3611 * forceprefix is true to force all Vars to be prefixed with their table names.
3612 *
3613 * showimplicit is true to force all implicit casts to be shown explicitly.
3614 *
3615 * Tries to pretty up the output according to prettyFlags and startIndent.
3616 *
3617 * The result is a palloc'd string.
3618 * ----------
3619 */
3624 {
3625 StringInfoData buf;
3626 deparse_context context;
3646 }
3648 /* ----------
3649 * deparse_context_for - Build deparse context for a single relation
3650 *
3651 * Given the reference name (alias) and OID of a relation, build deparsing
3652 * context for an expression referencing only that relation (as varno 1,
3653 * varlevelsup 0). This is sufficient for many uses of deparse_expression.
3654 * ----------
3655 */
3656 List *
3658 {
3664 /* Build a minimal RTE for the rel */
3676 /* Build one-element rtable */
3684 /* Return a one-deep namespace stack */
3686 }
3688 /*
3689 * deparse_context_for_plan_tree - Build deparse context for a Plan tree
3690 *
3691 * When deparsing an expression in a Plan tree, we use the plan's rangetable
3692 * to resolve names of simple Vars. The initialization of column names for
3693 * this is rather expensive if the rangetable is large, and it'll be the same
3694 * for every expression in the Plan tree; so we do it just once and re-use
3695 * the result of this function for each expression. (Note that the result
3696 * is not usable until set_deparse_context_plan() is applied to it.)
3697 *
3698 * In addition to the PlannedStmt, pass the per-RTE alias names
3699 * assigned by a previous call to select_rtable_names_for_explain.
3700 */
3701 List *
3703 {
3708 /* Initialize fields that stay the same across the whole plan tree */
3714 {
3715 /* Set up the array, indexed by child relid */
3722 {
3729 }
3730 }
3731 else
3734 /*
3735 * Set up column name aliases. We will get rather bogus results for join
3736 * RTEs, but that doesn't matter because plan trees don't contain any join
3737 * alias Vars.
3738 */
3741 /* Return a one-deep namespace stack */
3743 }
3745 /*
3746 * set_deparse_context_plan - Specify Plan node containing expression
3747 *
3748 * When deparsing an expression in a Plan tree, we might have to resolve
3749 * OUTER_VAR, INNER_VAR, or INDEX_VAR references. To do this, the caller must
3750 * provide the parent Plan node. Then OUTER_VAR and INNER_VAR references
3751 * can be resolved by drilling down into the left and right child plans.
3752 * Similarly, INDEX_VAR references can be resolved by reference to the
3753 * indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
3754 * ForeignScan and CustomScan nodes. (Note that we don't currently support
3755 * deparsing of indexquals in regular IndexScan or BitmapIndexScan nodes;
3756 * for those, we can only deparse the indexqualorig fields, which won't
3757 * contain INDEX_VAR Vars.)
3758 *
3759 * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
3760 * the most-closely-nested first. This is needed to resolve PARAM_EXEC
3761 * Params. Note we assume that all the Plan nodes share the same rtable.
3762 *
3763 * Once this function has been called, deparse_expression() can be called on
3764 * subsidiary expression(s) of the specified Plan node. To deparse
3765 * expressions of a different Plan node in the same Plan tree, re-call this
3766 * function to identify the new parent Plan node.
3767 *
3768 * The result is the same List passed in; this is a notational convenience.
3769 */
3770 List *
3772 {
3775 /* Should always have one-entry namespace list for Plan deparsing */
3779 /* Set our attention on the specific plan node passed in */
3784 }
3786 /*
3787 * select_rtable_names_for_explain - Select RTE aliases for EXPLAIN
3788 *
3789 * Determine the relation aliases we'll use during an EXPLAIN operation.
3790 * This is just a frontend to set_rtable_names. We have to expose the aliases
3791 * to EXPLAIN because EXPLAIN needs to know the right alias names to print.
3792 */
3793 List *
3795 {
3796 deparse_namespace dpns;
3804 /* We needn't bother computing column aliases yet */
3807 }
3809 /*
3810 * set_rtable_names: select RTE aliases to be used in printing a query
3811 *
3812 * We fill in dpns->rtable_names with a list of names that is one-for-one with
3813 * the already-filled dpns->rtable list. Each RTE name is unique among those
3814 * in the new namespace plus any ancestor namespaces listed in
3815 * parent_namespaces.
3816 *
3817 * If rels_used isn't NULL, only RTE indexes listed in it are given aliases.
3818 *
3819 * Note that this function is only concerned with relation names, not column
3820 * names.
3821 */
3822 static void
3825 {
3826 HASHCTL hash_ctl;
3834 /* nothing more to do if empty rtable */
3838 /*
3839 * We use a hash table to hold known names, so that this process is O(N)
3840 * not O(N^2) for N names.
3841 */
3850 /* Preload the hash table with names appearing in parent_namespaces */
3852 {
3857 {
3863 oldname,
3864 HASH_ENTER,
3866 /* we do not complain about duplicate names in parent namespaces */
3868 }
3869 }
3871 /* Now we can scan the rtable */
3874 {
3878 /* Just in case this takes an unreasonable amount of time ... */
3882 {
3883 /* Ignore unreferenced RTE */
3885 }
3887 {
3888 /* If RTE has a user-defined alias, prefer that */
3890 }
3892 {
3893 /* Use the current actual name of the relation */
3895 }
3897 {
3898 /* Unnamed join has no refname */
3900 }
3901 else
3902 {
3903 /* Otherwise use whatever the parser assigned */
3905 }
3907 /*
3908 * If the selected name isn't unique, append digits to make it so, and
3909 * make a new hash entry for it once we've got a unique name. For a
3910 * very long input name, we might have to truncate to stay within
3911 * NAMEDATALEN.
3912 */
3914 {
3916 refname,
3917 HASH_ENTER,
3920 {
3921 /* Name already in use, must choose a new one */
3926 do
3927 {
3930 {
3935 /* drop chars from refname to keep all the digits */
3938 }
3940 modname,
3941 HASH_ENTER,
3946 }
3947 else
3948 {
3949 /* Name not previously used, need only initialize hentry */
3951 }
3952 }
3955 rtindex++;
3956 }
3959 }
3961 /*
3962 * set_deparse_for_query: set up deparse_namespace for deparsing a Query tree
3963 *
3964 * For convenience, this is defined to initialize the deparse_namespace struct
3965 * from scratch.
3966 */
3967 static void
3970 {
3974 /* Initialize *dpns and fill rtable/ctes links */
3981 /* Assign a unique relation alias to each RTE */
3984 /* Initialize dpns->rtable_columns to contain zeroed structs */
3990 /* If it's a utility query, it won't have a jointree */
3992 {
3993 /* Detect whether global uniqueness of USING names is needed */
3997 /*
3998 * Select names for columns merged by USING, via a recursive pass over
3999 * the query jointree.
4000 */
4002 }
4004 /*
4005 * Now assign remaining column aliases for each RTE. We do this in a
4006 * linear scan of the rtable, so as to process RTEs whether or not they
4007 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4008 * etc). JOIN RTEs must be processed after their children, but this is
4009 * okay because they appear later in the rtable list than their children
4010 * (cf Asserts in identify_join_columns()).
4011 */
4013 {
4019 else
4021 }
4022 }
4024 /*
4025 * set_simple_column_names: fill in column aliases for non-query situations
4026 *
4027 * This handles EXPLAIN and cases where we only have relation RTEs. Without
4028 * a join tree, we can't do anything smart about join RTEs, but we don't
4029 * need to (note that EXPLAIN should never see join alias Vars anyway).
4030 * If we do hit a join RTE we'll just process it like a non-table base RTE.
4031 */
4032 static void
4034 {
4038 /* Initialize dpns->rtable_columns to contain zeroed structs */
4044 /* Assign unique column aliases within each RTE */
4046 {
4051 }
4052 }
4054 /*
4055 * has_dangerous_join_using: search jointree for unnamed JOIN USING
4056 *
4057 * Merged columns of a JOIN USING may act differently from either of the input
4058 * columns, either because they are merged with COALESCE (in a FULL JOIN) or
4059 * because an implicit coercion of the underlying input column is required.
4060 * In such a case the column must be referenced as a column of the JOIN not as
4061 * a column of either input. And this is problematic if the join is unnamed
4062 * (alias-less): we cannot qualify the column's name with an RTE name, since
4063 * there is none. (Forcibly assigning an alias to the join is not a solution,
4064 * since that will prevent legal references to tables below the join.)
4065 * To ensure that every column in the query is unambiguously referenceable,
4066 * we must assign such merged columns names that are globally unique across
4067 * the whole query, aliasing other columns out of the way as necessary.
4068 *
4069 * Because the ensuing re-aliasing is fairly damaging to the readability of
4070 * the query, we don't do this unless we have to. So, we must pre-scan
4071 * the join tree to see if we have to, before starting set_using_names().
4072 */
4073 static bool
4075 {
4077 {
4078 /* nothing to do here */
4079 }
4081 {
4086 {
4089 }
4090 }
4092 {
4095 /* Is it an unnamed JOIN with USING? */
4097 {
4098 /*
4099 * Yes, so check each join alias var to see if any of them are not
4100 * simple references to underlying columns. If so, we have a
4101 * dangerous situation and must pick unique aliases.
4102 */
4105 /* We need only examine the merged columns */
4107 {
4112 }
4113 }
4115 /* Nope, but inspect children */
4120 }
4121 else
4125 }
4127 /*
4128 * set_using_names: select column aliases to be used for merged USING columns
4129 *
4130 * We do this during a recursive descent of the query jointree.
4131 * dpns->unique_using must already be set to determine the global strategy.
4132 *
4133 * Column alias info is saved in the dpns->rtable_columns list, which is
4134 * assumed to be filled with pre-zeroed deparse_columns structs.
4135 *
4136 * parentUsing is a list of all USING aliases assigned in parent joins of
4137 * the current jointree node. (The passed-in list must not be modified.)
4138 */
4139 static void
4141 {
4143 {
4144 /* nothing to do now */
4145 }
4147 {
4153 }
4155 {
4166 /* Get info about the shape of the join */
4171 /* Look up the not-yet-filled-in child deparse_columns structs */
4175 /*
4176 * If this join is unnamed, then we cannot substitute new aliases at
4177 * this level, so any name requirements pushed down to here must be
4178 * pushed down again to the children.
4179 */
4181 {
4183 {
4189 /* Push down to left column, unless it's a system column */
4191 {
4194 }
4196 /* Same on the righthand side */
4198 {
4201 }
4202 }
4203 }
4205 /*
4206 * If there's a USING clause, select the USING column names and push
4207 * those names down to the children. We have two strategies:
4208 *
4209 * If dpns->unique_using is true, we force all USING names to be
4210 * unique across the whole query level. In principle we'd only need
4211 * the names of dangerous USING columns to be globally unique, but to
4212 * safely assign all USING names in a single pass, we have to enforce
4213 * the same uniqueness rule for all of them. However, if a USING
4214 * column's name has been pushed down from the parent, we should use
4215 * it as-is rather than making a uniqueness adjustment. This is
4216 * necessary when we're at an unnamed join, and it creates no risk of
4217 * ambiguity. Also, if there's a user-written output alias for a
4218 * merged column, we prefer to use that rather than the input name;
4219 * this simplifies the logic and seems likely to lead to less aliasing
4220 * overall.
4221 *
4222 * If dpns->unique_using is false, we only need USING names to be
4223 * unique within their own join RTE. We still need to honor
4224 * pushed-down names, though.
4225 *
4226 * Though significantly different in results, these two strategies are
4227 * implemented by the same code, with only the difference of whether
4228 * to put assigned names into dpns->using_names.
4229 */
4231 {
4232 /* Copy the input parentUsing list so we don't modify it */
4235 /* USING names must correspond to the first join output columns */
4239 {
4242 /* Assert it's a merged column */
4245 /* Adopt passed-down name if any, else select unique name */
4248 else
4249 {
4250 /* Prefer user-written output alias if any */
4253 /* Make it appropriately unique */
4257 colname);
4258 /* Save it as output column name, too */
4260 }
4262 /* Remember selected names for use later */
4266 /* Push down to left column, unless it's a system column */
4268 {
4271 }
4273 /* Same on the righthand side */
4275 {
4278 }
4280 i++;
4281 }
4282 }
4284 /* Mark child deparse_columns structs with correct parentUsing info */
4288 /* Now recursively assign USING column names in children */
4291 }
4292 else
4295 }
4297 /*
4298 * set_relation_column_names: select column aliases for a non-join RTE
4299 *
4300 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4301 * If any colnames entries are already filled in, those override local
4302 * choices.
4303 */
4304 static void
4307 {
4315 /*
4316 * Construct an array of the current "real" column names of the RTE.
4317 * real_colnames[] will be indexed by physical column number, with NULL
4318 * entries for dropped columns.
4319 */
4321 {
4322 /* Relation --- look to the system catalogs for up-to-date info */
4323 Relation rel;
4324 TupleDesc tupdesc;
4333 {
4338 else
4340 }
4342 }
4343 else
4344 {
4345 /* Otherwise get the column names from eref or expandRTE() */
4349 /*
4350 * Functions returning composites have the annoying property that some
4351 * of the composite type's columns might have been dropped since the
4352 * query was parsed. If possible, use expandRTE() to handle that
4353 * case, since it has the tedious logic needed to find out about
4354 * dropped columns. However, if we're explaining a plan, then we
4355 * don't have rte->functions because the planner thinks that won't be
4356 * needed later, and that breaks expandRTE(). So in that case we have
4357 * to rely on rte->eref, which may lead us to report a dropped
4358 * column's old name; that seems close enough for EXPLAIN's purposes.
4359 *
4360 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4361 * which should be sufficiently up-to-date: no other RTE types can
4362 * have columns get dropped from under them after parsing.
4363 */
4365 {
4366 /* Since we're not creating Vars, rtindex etc. don't matter */
4369 }
4370 else
4378 {
4379 /*
4380 * If the column name we find here is an empty string, then it's a
4381 * dropped column, so change to NULL.
4382 */
4388 i++;
4389 }
4390 }
4392 /*
4393 * Ensure colinfo->colnames has a slot for each column. (It could be long
4394 * enough already, if we pushed down a name for the last column.) Note:
4395 * it's possible that there are now more columns than there were when the
4396 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4397 * We must assign unique aliases to the new columns too, else there could
4398 * be unresolved conflicts when the view/rule is reloaded.
4399 */
4403 /*
4404 * Make sufficiently large new_colnames and is_new_col arrays, too.
4405 *
4406 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4407 * colname_is_unique will not consult that array, which is fine because it
4408 * would only be duplicate effort.
4409 */
4413 /*
4414 * Scan the columns, select a unique alias for each one, and store it in
4415 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4416 * entries for dropped columns, the latter omits them. Also mark
4417 * new_colnames entries as to whether they are new since parse time; this
4418 * is the case for entries beyond the length of rte->eref->colnames.
4419 */
4424 {
4428 /* Skip dropped columns */
4430 {
4433 }
4435 /* If alias already assigned, that's what to use */
4437 {
4438 /* If user wrote an alias, prefer that over real column name */
4441 else
4444 /* Unique-ify and insert into colinfo */
4448 }
4450 /* Put names of non-dropped columns in new_colnames[] too */
4452 /* And mark them as new or not */
4454 j++;
4456 /* Remember if any assigned aliases differ from "real" name */
4459 }
4461 /*
4462 * Set correct length for new_colnames[] array. (Note: if columns have
4463 * been added, colinfo->num_cols includes them, which is not really quite
4464 * right but is harmless, since any new columns must be at the end where
4465 * they won't affect varattnos of pre-existing columns.)
4466 */
4469 /*
4470 * For a relation RTE, we need only print the alias column names if any
4471 * are different from the underlying "real" names. For a function RTE,
4472 * always emit a complete column alias list; this is to protect against
4473 * possible instability of the default column names (eg, from altering
4474 * parameter names). For tablefunc RTEs, we never print aliases, because
4475 * the column names are part of the clause itself. For other RTE types,
4476 * print if we changed anything OR if there were user-written column
4477 * aliases (since the latter would be part of the underlying "reality").
4478 */
4487 else
4489 }
4491 /*
4492 * set_join_column_names: select column aliases for a join RTE
4493 *
4494 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4495 * If any colnames entries are already filled in, those override local
4496 * choices. Also, names for USING columns were already chosen by
4497 * set_using_names(). We further expect that column alias selection has been
4498 * completed for both input RTEs.
4499 */
4500 static void
4503 {
4516 /* Look up the previously-filled-in child deparse_columns structs */
4520 /*
4521 * Ensure colinfo->colnames has a slot for each column. (It could be long
4522 * enough already, if we pushed down a name for the last column.) Note:
4523 * it's possible that one or both inputs now have more columns than there
4524 * were when the query was parsed, but we'll deal with that below. We
4525 * only need entries in colnames for pre-existing columns.
4526 */
4531 /*
4532 * Scan the join output columns, select an alias for each one, and store
4533 * it in colinfo->colnames. If there are USING columns, set_using_names()
4534 * already selected their names, so we can start the loop at the first
4535 * non-merged column.
4536 */
4539 {
4543 /* Join column must refer to at least one input column */
4546 /* Get the child column name */
4551 else
4552 {
4553 /* We're joining system columns --- use eref name */
4555 }
4557 /* If child col has been dropped, no need to assign a join colname */
4559 {
4562 }
4564 /* In an unnamed join, just report child column names as-is */
4566 {
4569 }
4571 /* If alias already assigned, that's what to use */
4573 {
4574 /* If user wrote an alias, prefer that over real column name */
4577 else
4580 /* Unique-ify and insert into colinfo */
4584 }
4586 /* Remember if any assigned aliases differ from "real" name */
4589 }
4591 /*
4592 * Calculate number of columns the join would have if it were re-parsed
4593 * now, and create storage for the new_colnames and is_new_col arrays.
4594 *
4595 * Note: colname_is_unique will be consulting new_colnames[] during the
4596 * loops below, so its not-yet-filled entries must be zeroes.
4597 */
4604 /*
4605 * Generating the new_colnames array is a bit tricky since any new columns
4606 * added since parse time must be inserted in the right places. This code
4607 * must match the parser, which will order a join's columns as merged
4608 * columns first (in USING-clause order), then non-merged columns from the
4609 * left input (in attnum order), then non-merged columns from the right
4610 * input (ditto). If one of the inputs is itself a join, its columns will
4611 * be ordered according to the same rule, which means newly-added columns
4612 * might not be at the end. We can figure out what's what by consulting
4613 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
4614 *
4615 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
4616 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
4617 * meanings for the current child RTE.
4618 */
4620 /* Handle merged columns; they are first and can't be new */
4625 {
4626 /* column name is already determined and known unique */
4630 /* build bitmapsets of child attnums of merged columns */
4637 }
4639 /* Handle non-merged left-child columns */
4642 {
4646 {
4647 /* Advance ic to next non-dropped old column of left child */
4650 ic++;
4652 ic++;
4653 /* If it is a merged column, we already processed it */
4656 /* Else, advance i to the corresponding existing join column */
4659 i++;
4662 /* Use the already-assigned name of this column */
4664 i++;
4665 }
4666 else
4667 {
4668 /*
4669 * Unique-ify the new child column name and assign, unless we're
4670 * in an unnamed join, in which case just copy
4671 */
4673 {
4679 }
4680 else
4682 }
4685 j++;
4686 }
4688 /* Handle non-merged right-child columns in exactly the same way */
4691 {
4695 {
4696 /* Advance ic to next non-dropped old column of right child */
4699 ic++;
4701 ic++;
4702 /* If it is a merged column, we already processed it */
4705 /* Else, advance i to the corresponding existing join column */
4708 i++;
4711 /* Use the already-assigned name of this column */
4713 i++;
4714 }
4715 else
4716 {
4717 /*
4718 * Unique-ify the new child column name and assign, unless we're
4719 * in an unnamed join, in which case just copy
4720 */
4722 {
4728 }
4729 else
4731 }
4734 j++;
4735 }
4737 /* Assert we processed the right number of columns */
4738 #ifdef USE_ASSERT_CHECKING
4740 i++;
4743 #endif
4745 /*
4746 * For a named join, print column aliases if we changed any from the child
4747 * names. Unnamed joins cannot print aliases.
4748 */
4751 else
4753 }
4755 /*
4756 * colname_is_unique: is colname distinct from already-chosen column names?
4757 *
4758 * dpns is query-wide info, colinfo is for the column's RTE
4759 */
4760 static bool
4763 {
4767 /* Check against already-assigned column aliases within RTE */
4769 {
4774 }
4776 /*
4777 * If we're building a new_colnames array, check that too (this will be
4778 * partially but not completely redundant with the previous checks)
4779 */
4781 {
4786 }
4788 /* Also check against USING-column names that must be globally unique */
4790 {
4795 }
4797 /* Also check against names already assigned for parent-join USING cols */
4799 {
4804 }
4807 }
4809 /*
4810 * make_colname_unique: modify colname if necessary to make it unique
4811 *
4812 * dpns is query-wide info, colinfo is for the column's RTE
4813 */
4817 {
4818 /*
4819 * If the selected name isn't unique, append digits to make it so. For a
4820 * very long input name, we might have to truncate to stay within
4821 * NAMEDATALEN.
4822 */
4824 {
4829 do
4830 {
4831 i++;
4833 {
4838 /* drop chars from colname to keep all the digits */
4841 }
4844 }
4846 }
4848 /*
4849 * expand_colnames_array_to: make colinfo->colnames at least n items long
4850 *
4851 * Any added array entries are initialized to zero.
4852 */
4853 static void
4855 {
4857 {
4860 else
4863 }
4864 }
4866 /*
4867 * identify_join_columns: figure out where columns of a join come from
4868 *
4869 * Fills the join-specific fields of the colinfo struct, except for
4870 * usingNames which is filled later.
4871 */
4872 static void
4875 {
4881 /* Extract left/right child RT indexes */
4886 else
4893 else
4897 /* Assert children will be processed earlier than join in second pass */
4901 /* Initialize result arrays with zeroes */
4907 /*
4908 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
4909 * Recall that the column(s) merged due to USING are the first column(s)
4910 * of the join output. We need not do anything special while scanning
4911 * joinleftcols, but while scanning joinrightcols we must distinguish
4912 * merged from unmerged columns.
4913 */
4916 {
4920 }
4923 {
4928 else
4930 rcolno++;
4931 }
4933 }
4935 /*
4936 * get_rtable_name: convenience function to get a previously assigned RTE alias
4937 *
4938 * The RTE must belong to the topmost namespace level in "context".
4939 */
4942 {
4947 }
4949 /*
4950 * set_deparse_plan: set up deparse_namespace to parse subexpressions
4951 * of a given Plan node
4952 *
4953 * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
4954 * and index_tlist fields. Caller must already have adjusted the ancestors
4955 * list if necessary. Note that the rtable, subplans, and ctes fields do
4956 * not need to change when shifting attention to different plan nodes in a
4957 * single plan tree.
4958 */
4959 static void
4961 {
4964 /*
4965 * We special-case Append and MergeAppend to pretend that the first child
4966 * plan is the OUTER referent; we have to interpret OUTER Vars in their
4967 * tlists according to one of the children, and the first one is the most
4968 * natural choice.
4969 */
4974 else
4979 else
4982 /*
4983 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
4984 * use OUTER because that could someday conflict with the normal meaning.)
4985 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
4986 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
4987 * that as INNER referent.
4988 *
4989 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
4990 * INNER referent. This is the join from the target relation to the data
4991 * source, and all INNER_VAR Vars in other parts of the query refer to its
4992 * targetlist.
4993 *
4994 * For ON CONFLICT .. UPDATE we just need the inner tlist to point to the
4995 * excluded expression's tlist. (Similar to the SubqueryScan we don't want
4996 * to reuse OUTER, it's used for RETURNING in some modify table cases,
4997 * although not INSERT .. CONFLICT).
4998 */
5008 {
5011 else
5013 }
5014 else
5021 else
5024 /* Set up referent for INDEX_VAR Vars, if needed */
5031 else
5033 }
5035 /*
5036 * Locate the ancestor plan node that is the RecursiveUnion generating
5037 * the WorkTableScan's work table. We can match on wtParam, since that
5038 * should be unique within the plan tree.
5039 */
5042 {
5046 {
5052 }
5056 }
5058 /*
5059 * push_child_plan: temporarily transfer deparsing attention to a child plan
5060 *
5061 * When expanding an OUTER_VAR or INNER_VAR reference, we must adjust the
5062 * deparse context in case the referenced expression itself uses
5063 * OUTER_VAR/INNER_VAR. We modify the top stack entry in-place to avoid
5064 * affecting levelsup issues (although in a Plan tree there really shouldn't
5065 * be any).
5066 *
5067 * Caller must provide a local deparse_namespace variable to save the
5068 * previous state for pop_child_plan.
5069 */
5070 static void
5073 {
5074 /* Save state for restoration later */
5077 /* Link current plan node into ancestors list */
5080 /* Set attention on selected child */
5082 }
5084 /*
5085 * pop_child_plan: undo the effects of push_child_plan
5086 */
5087 static void
5089 {
5092 /* Get rid of ancestors list cell added by push_child_plan */
5095 /* Restore fields changed by push_child_plan */
5098 /* Make sure dpns->ancestors is right (may be unnecessary) */
5100 }
5102 /*
5103 * push_ancestor_plan: temporarily transfer deparsing attention to an
5104 * ancestor plan
5105 *
5106 * When expanding a Param reference, we must adjust the deparse context
5107 * to match the plan node that contains the expression being printed;
5108 * otherwise we'd fail if that expression itself contains a Param or
5109 * OUTER_VAR/INNER_VAR/INDEX_VAR variable.
5110 *
5111 * The target ancestor is conveniently identified by the ListCell holding it
5112 * in dpns->ancestors.
5113 *
5114 * Caller must provide a local deparse_namespace variable to save the
5115 * previous state for pop_ancestor_plan.
5116 */
5117 static void
5120 {
5123 /* Save state for restoration later */
5126 /* Build a new ancestor list with just this node's ancestors */
5131 /* Set attention on selected ancestor */
5133 }
5135 /*
5136 * pop_ancestor_plan: undo the effects of push_ancestor_plan
5137 */
5138 static void
5140 {
5141 /* Free the ancestor list made in push_ancestor_plan */
5144 /* Restore fields changed by push_ancestor_plan */
5146 }
5149 /* ----------
5150 * make_ruledef - reconstruct the CREATE RULE command
5151 * for a given pg_rewrite tuple
5152 * ----------
5153 */
5154 static void
5157 {
5160 Oid ev_class;
5165 Relation ev_relation;
5168 Datum dat;
5171 /*
5172 * Get the attribute values from the rules tuple
5173 */
5207 /*
5208 * Build the rules definition text
5209 */
5215 else
5218 /* The event the rule is fired for */
5220 {
5244 }
5246 /* The relation the rule is fired on */
5252 /* If the rule has an event qualification, add it */
5254 {
5257 deparse_context context;
5258 deparse_namespace dpns;
5266 /*
5267 * We need to make a context for recognizing any Vars in the qual
5268 * (which can only be references to OLD and NEW). Use the rtable of
5269 * the first query in the action list for this purpose.
5270 */
5273 /*
5274 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5275 * into the SELECT, and that's what we need to look at. (Ugly kluge
5276 * ... try to fix this when we redesign querytrees.)
5277 */
5280 /* Must acquire locks right away; see notes in get_query_def() */
5300 }
5304 /* The INSTEAD keyword (if so) */
5308 /* Finally the rules actions */
5310 {
5316 {
5322 else
5324 }
5326 }
5327 else
5328 {
5335 }
5338 }
5341 /* ----------
5342 * make_viewdef - reconstruct the SELECT part of a
5343 * view rewrite rule
5344 * ----------
5345 */
5346 static void
5349 {
5352 Oid ev_class;
5357 Relation ev_relation;
5359 Datum dat;
5362 /*
5363 * Get the attribute values from the rules tuple
5364 */
5390 {
5391 /* keep output buffer empty and leave */
5393 }
5399 {
5400 /* keep output buffer empty and leave */
5402 }
5411 }
5414 /* ----------
5415 * get_query_def - Parse back one query parsetree
5416 *
5417 * query: parsetree to be displayed
5418 * buf: output text is appended to buf
5419 * parentnamespace: list (initially empty) of outer-level deparse_namespace's
5420 * resultDesc: if not NULL, the output tuple descriptor for the view
5421 * represented by a SELECT query. We use the column names from it
5422 * to label SELECT output columns, in preference to names in the query
5423 * colNamesVisible: true if the surrounding context cares about the output
5424 * column names at all (as, for example, an EXISTS() context does not);
5425 * when false, we can suppress dummy column labels such as "?column?"
5426 * prettyFlags: bitmask of PRETTYFLAG_XXX options
5427 * wrapColumn: maximum line length, or -1 to disable wrapping
5428 * startIndent: initial indentation amount
5429 * ----------
5430 */
5431 static void
5435 {
5436 deparse_context context;
5437 deparse_namespace dpns;
5439 /* Guard against excessively long or deeply-nested queries */
5443 /*
5444 * Before we begin to examine the query, acquire locks on referenced
5445 * relations, and fix up deleted columns in JOIN RTEs. This ensures
5446 * consistent results. Note we assume it's OK to scribble on the passed
5447 * querytree!
5448 *
5449 * We are only deparsing the query (we are not about to execute it), so we
5450 * only need AccessShareLock on the relations it mentions.
5451 */
5472 {
5474 /* We set context.resultDesc only if it's a SELECT */
5507 }
5508 }
5510 /* ----------
5511 * get_values_def - Parse back a VALUES list
5512 * ----------
5513 */
5514 static void
5516 {
5524 {
5531 else
5536 {
5541 else
5544 /*
5545 * Print the value. Whole-row Vars need special treatment.
5546 */
5548 }
5550 }
5551 }
5553 /* ----------
5554 * get_with_clause - Parse back a WITH clause
5555 * ----------
5556 */
5557 static void
5559 {
5568 {
5571 }
5575 else
5578 {
5584 {
5590 {
5593 else
5597 }
5599 }
5602 {
5611 }
5624 {
5632 {
5635 else
5639 }
5642 }
5645 {
5652 {
5655 else
5659 }
5663 {
5667 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
5669 {
5674 }
5675 }
5678 }
5681 }
5684 {
5687 }
5688 else
5690 }
5692 /* ----------
5693 * get_select_query_def - Parse back a SELECT parsetree
5694 * ----------
5695 */
5696 static void
5698 {
5703 /* Insert the WITH clause if given */
5706 /* Subroutines may need to consult the SELECT targetlist and windowClause */
5710 /*
5711 * If the Query node has a setOperations tree, then it's the top level of
5712 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
5713 * fields are interesting in the top query itself.
5714 */
5716 {
5718 /* ORDER BY clauses must be simple in this case */
5720 }
5721 else
5722 {
5725 }
5727 /* Add the ORDER BY clause if given */
5729 {
5734 }
5736 /*
5737 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
5738 * standard spelling of LIMIT.
5739 */
5741 {
5745 }
5747 {
5749 {
5754 }
5755 else
5756 {
5762 else
5764 }
5765 }
5767 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
5769 {
5771 {
5774 /* don't print implicit clauses */
5779 {
5781 /* we intentionally throw an error for LCS_NONE */
5801 }
5805 context)));
5810 }
5811 }
5812 }
5814 /*
5815 * Detect whether query looks like SELECT ... FROM VALUES(),
5816 * with no need to rename the output columns of the VALUES RTE.
5817 * If so, return the VALUES RTE. Otherwise return NULL.
5818 */
5821 {
5825 /*
5826 * We want to detect a match even if the Query also contains OLD or NEW
5827 * rule RTEs. So the idea is to scan the rtable and see if there is only
5828 * one inFromCl RTE that is a VALUES RTE.
5829 */
5831 {
5835 {
5839 }
5842 else
5844 }
5846 /*
5847 * We don't need to check the targetlist in any great detail, because
5848 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
5849 * appear inside auto-generated sub-queries with very restricted
5850 * structure. However, DefineView might have modified the tlist by
5851 * injecting new column aliases, or we might have some other column
5852 * aliases forced by a resultDesc. We can only simplify if the RTE's
5853 * column names match the names that get_target_list() would select.
5854 */
5856 {
5864 {
5872 /* compute name that get_target_list would use for column */
5873 colno++;
5876 else
5879 /* does it match the VALUES RTE? */
5882 }
5883 }
5886 }
5888 static void
5890 {
5897 {
5900 }
5902 /*
5903 * If the query looks like SELECT * FROM (VALUES ...), then print just the
5904 * VALUES part. This reverses what transformValuesClause() did at parse
5905 * time.
5906 */
5909 {
5912 }
5914 /*
5915 * Build up the query string - first we say SELECT
5916 */
5919 else
5922 /* Add the DISTINCT clause if given */
5924 {
5926 {
5930 {
5937 }
5939 }
5940 else
5942 }
5944 /* Then we tell what to select (the targetlist) */
5947 /* Add the FROM clause if needed */
5950 /* Add the WHERE clause if given */
5952 {
5956 }
5958 /* Add the GROUP BY clause if given */
5960 {
5972 {
5975 {
5982 }
5983 }
5984 else
5985 {
5988 {
5994 }
5995 }
5998 }
6000 /* Add the HAVING clause if given */
6002 {
6006 }
6008 /* Add the WINDOW clause if needed */
6011 }
6013 /* ----------
6014 * get_target_list - Parse back a SELECT target list
6015 *
6016 * This is also used for RETURNING lists in INSERT/UPDATE/DELETE/MERGE.
6017 * ----------
6018 */
6019 static void
6021 {
6023 StringInfoData targetbuf;
6029 /* we use targetbuf to hold each TLE's text temporarily */
6035 {
6045 colno++;
6047 /*
6048 * Put the new field text into targetbuf so we can decide after we've
6049 * got it whether or not it needs to go on a new line.
6050 */
6054 /*
6055 * We special-case Var nodes rather than using get_rule_expr. This is
6056 * needed because get_rule_expr will display a whole-row Var as
6057 * "foo.*", which is the preferred notation in most contexts, but at
6058 * the top level of a SELECT list it's not right (the parser will
6059 * expand that notation into multiple columns, yielding behavior
6060 * different from a whole-row Var). We need to call get_variable
6061 * directly so that we can tell it to do the right thing, and so that
6062 * we can get the attribute name which is the default AS label.
6063 */
6065 {
6067 }
6068 else
6069 {
6072 /*
6073 * When colNamesVisible is true, we should always show the
6074 * assigned column name explicitly. Otherwise, show it only if
6075 * it's not FigureColname's fallback.
6076 */
6078 }
6080 /*
6081 * Figure out what the result column should be called. In the context
6082 * of a view, use the view's tuple descriptor (so as to pick up the
6083 * effects of any column RENAME that's been done on the view).
6084 * Otherwise, just use what we can find in the TLE.
6085 */
6089 else
6092 /* Show AS unless the column's name is correct as-is */
6094 {
6097 }
6099 /* Restore context's output buffer */
6102 /* Consider line-wrapping if enabled */
6104 {
6107 /* Does the new field start with a new line? */
6110 else
6113 /* If so, we shouldn't add anything */
6115 {
6116 /* instead, remove any trailing spaces currently in buf */
6118 }
6119 else
6120 {
6123 /* Locate the start of the current line in the output buffer */
6127 else
6128 trailing_nl++;
6130 /*
6131 * Add a newline, plus some indentation, if the new field is
6132 * not the first and either the new field would cause an
6133 * overflow or the last field used more than one line.
6134 */
6137 last_was_multiline))
6140 }
6142 /* Remember this field's multiline status for next iteration */
6143 last_was_multiline =
6145 }
6147 /* Add the new field */
6149 }
6151 /* clean up */
6153 }
6155 static void
6157 {
6161 /* Guard against excessively long or deeply-nested queries */
6166 {
6173 /* Need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y */
6187 }
6189 {
6194 /*
6195 * We force parens when nesting two SetOperationStmts, except when the
6196 * lefthand input is another setop of the same kind. Syntactically,
6197 * we could omit parens in rather more cases, but it seems best to use
6198 * parens to flag cases where the setop operator changes. If we use
6199 * parens, we also increase the indentation level for the child query.
6200 *
6201 * There are some cases in which parens are needed around a leaf query
6202 * too, but those are more easily handled at the next level down (see
6203 * code above).
6204 */
6206 {
6211 else
6213 }
6214 else
6218 {
6222 }
6223 else
6232 else
6236 {
6249 }
6253 /* Always parenthesize if RHS is another setop */
6256 /*
6257 * The indentation code here is deliberately a bit different from that
6258 * for the lefthand input, because we want the line breaks in
6259 * different places.
6260 */
6262 {
6265 }
6266 else
6270 /*
6271 * The output column names of the RHS sub-select don't matter.
6272 */
6284 }
6285 else
6286 {
6289 }
6290 }
6292 /*
6293 * Display a sort/group clause.
6294 *
6295 * Also returns the expression tree, so caller need not find it again.
6296 */
6300 {
6308 /*
6309 * Use column-number form if requested by caller. Otherwise, if
6310 * expression is a constant, force it to be dumped with an explicit cast
6311 * as decoration --- this is because a simple integer constant is
6312 * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
6313 * we dump it without any decoration. Similarly, if it's just a Var,
6314 * there is risk of misinterpretation if the column name is reassigned in
6315 * the SELECT list, so we may need to force table qualification. And, if
6316 * it's anything more complex than a simple Var, then force extra parens
6317 * around it, to ensure it can't be misinterpreted as a cube() or rollup()
6318 * construct.
6319 */
6321 {
6324 }
6330 {
6331 /* Tell get_variable to check for name conflict */
6337 }
6338 else
6339 {
6340 /*
6341 * We must force parens for function-like expressions even if
6342 * PRETTY_PAREN is off, since those are the ones in danger of
6343 * misparsing. For other expressions we need to force them only if
6344 * PRETTY_PAREN is on, since otherwise the expression will output them
6345 * itself. (We can't skip the parens.)
6346 */
6358 }
6361 }
6363 /*
6364 * Display a GroupingSet
6365 */
6366 static void
6369 {
6376 {
6382 {
6387 {
6394 }
6398 }
6411 }
6414 {
6418 }
6421 }
6423 /*
6424 * Display an ORDER BY list.
6425 */
6426 static void
6429 {
6436 {
6439 Oid sortcoltype;
6446 /* See whether operator is default < or > for datatype */
6450 {
6451 /* ASC is default, so emit nothing for it */
6454 }
6456 {
6458 /* DESC defaults to NULLS FIRST */
6461 }
6462 else
6463 {
6466 sortcoltype,
6467 sortcoltype));
6468 /* be specific to eliminate ambiguity */
6471 else
6473 }
6475 }
6476 }
6478 /*
6479 * Display a WINDOW clause.
6480 *
6481 * Note that the windowClause list might contain only anonymous window
6482 * specifications, in which case we should print nothing here.
6483 */
6484 static void
6486 {
6493 {
6502 else
6510 }
6511 }
6513 /*
6514 * Display a window definition
6515 */
6516 static void
6519 {
6527 {
6530 }
6531 /* partition clauses are always inherited, so only print if no refname */
6533 {
6539 {
6546 }
6548 }
6549 /* print ordering clause only if not inherited */
6551 {
6557 }
6558 /* framing clause is never inherited, so print unless it's default */
6560 {
6569 else
6578 {
6584 else
6586 }
6587 else
6590 {
6597 {
6603 else
6605 }
6606 else
6608 }
6615 /* we will now have a trailing space; remove it */
6617 }
6619 }
6621 /* ----------
6622 * get_insert_query_def - Parse back an INSERT parsetree
6623 * ----------
6624 */
6625 static void
6627 {
6636 /* Insert the WITH clause if given */
6639 /*
6640 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
6641 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
6642 */
6644 {
6648 {
6652 }
6655 {
6659 }
6660 }
6664 /*
6665 * Start the query with INSERT INTO relname
6666 */
6671 {
6674 }
6678 /* Print the relation alias, if needed; INSERT requires explicit AS */
6681 /* always want a space here */
6684 /*
6685 * Add the insert-column-names list. Any indirection decoration needed on
6686 * the column names can be inferred from the top targetlist.
6687 */
6693 {
6702 /*
6703 * Put out name of target column; look in the catalogs, not at
6704 * tle->resname, since resname will fail to track RENAME.
6705 */
6711 /*
6712 * Print any indirection needed (subfields or subscripts), and strip
6713 * off the top-level nodes representing the indirection assignments.
6714 * Add the stripped expressions to strippedexprs. (If it's a
6715 * single-VALUES statement, the stripped expressions are the VALUES to
6716 * print below. Otherwise they're just Vars and not really
6717 * interesting.)
6718 */
6721 context));
6722 }
6727 {
6732 }
6735 {
6736 /* Add the SELECT */
6741 }
6743 {
6744 /* Add the multi-VALUES expression lists */
6746 }
6748 {
6749 /* Add the single-VALUES expression list */
6754 }
6755 else
6756 {
6757 /* No expressions, so it must be DEFAULT VALUES */
6759 }
6761 /* Add ON CONFLICT if present */
6763 {
6769 {
6770 /* Add the single-VALUES expression list */
6775 /* Add a WHERE clause (for partial indexes) if given */
6777 {
6780 /*
6781 * Force non-prefixing of Vars, since parser assumes that they
6782 * belong to target relation. WHERE clause does not use
6783 * InferenceElem, so this is separately required.
6784 */
6793 }
6794 }
6796 {
6804 }
6807 {
6809 }
6810 else
6811 {
6813 /* Deparse targetlist */
6817 /* Add a WHERE clause if given */
6819 {
6823 }
6824 }
6825 }
6827 /* Add RETURNING if present */
6829 {
6833 }
6834 }
6837 /* ----------
6838 * get_update_query_def - Parse back an UPDATE parsetree
6839 * ----------
6840 */
6841 static void
6843 {
6847 /* Insert the WITH clause if given */
6850 /*
6851 * Start the query with UPDATE relname SET
6852 */
6856 {
6859 }
6864 /* Print the relation alias, if needed */
6869 /* Deparse targetlist */
6872 /* Add the FROM clause if needed */
6875 /* Add a WHERE clause if given */
6877 {
6881 }
6883 /* Add RETURNING if present */
6885 {
6889 }
6890 }
6893 /* ----------
6894 * get_update_query_targetlist_def - Parse back an UPDATE targetlist
6895 * ----------
6896 */
6897 static void
6900 {
6909 /*
6910 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
6911 * into a list. We expect them to appear, in ID order, in resjunk tlist
6912 * entries.
6913 */
6916 {
6918 {
6922 {
6926 {
6929 }
6930 }
6931 }
6932 }
6937 /* Add the comma separated list of 'attname = value' */
6940 {
6947 /* Emit separator (OK whether we're in multiassignment or not) */
6951 /*
6952 * Check to see if we're starting a multiassignment group: if so,
6953 * output a left paren.
6954 */
6956 {
6957 /*
6958 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
6959 * Param. That could be buried under FieldStores and
6960 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
6961 * and underneath those there could be an implicit type coercion.
6962 * Because we would ignore implicit type coercions anyway, we
6963 * don't need to be as careful as processIndirection() is about
6964 * descending past implicit CoerceToDomains.
6965 */
6968 {
6970 {
6974 }
6976 {
6983 }
6985 {
6991 }
6992 else
6994 }
6999 {
7002 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
7006 }
7007 }
7009 /*
7010 * Put out name of target column; look in the catalogs, not at
7011 * tle->resname, since resname will fail to track RENAME.
7012 */
7018 /*
7019 * Print any indirection needed (subfields or subscripts), and strip
7020 * off the top-level nodes representing the indirection assignments.
7021 */
7024 /*
7025 * If we're in a multiassignment, skip printing anything more, unless
7026 * this is the last column; in which case, what we print should be the
7027 * sublink, not the Param.
7028 */
7030 {
7036 }
7041 }
7042 }
7045 /* ----------
7046 * get_delete_query_def - Parse back a DELETE parsetree
7047 * ----------
7048 */
7049 static void
7051 {
7055 /* Insert the WITH clause if given */
7058 /*
7059 * Start the query with DELETE FROM relname
7060 */
7064 {
7067 }
7072 /* Print the relation alias, if needed */
7075 /* Add the USING clause if given */
7078 /* Add a WHERE clause if given */
7080 {
7084 }
7086 /* Add RETURNING if present */
7088 {
7092 }
7093 }
7096 /* ----------
7097 * get_merge_query_def - Parse back a MERGE parsetree
7098 * ----------
7099 */
7100 static void
7102 {
7108 /* Insert the WITH clause if given */
7111 /*
7112 * Start the query with MERGE INTO relname
7113 */
7117 {
7120 }
7125 /* Print the relation alias, if needed */
7128 /* Print the source relation and join clause */
7134 /*
7135 * Test for any NOT MATCHED BY SOURCE actions. If there are none, then
7136 * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
7137 * SQL standard. Otherwise, we have a non-SQL-standard query, so output
7138 * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
7139 * more explicit.
7140 */
7143 {
7147 {
7150 }
7151 }
7153 /* Print each merge action */
7155 {
7161 {
7171 else
7177 }
7180 {
7184 }
7189 {
7190 /* This generally matches get_insert_query_def() */
7200 {
7214 context));
7215 }
7220 {
7225 }
7228 {
7233 }
7234 else
7236 }
7238 {
7242 }
7247 }
7249 /* Add RETURNING if present */
7251 {
7255 }
7256 }
7259 /* ----------
7260 * get_utility_query_def - Parse back a UTILITY parsetree
7261 * ----------
7262 */
7263 static void
7265 {
7269 {
7277 {
7280 }
7281 }
7282 else
7283 {
7284 /* Currently only NOTIFY utility commands can appear in rules */
7286 }
7287 }
7289 /*
7290 * Display a Var appropriately.
7291 *
7292 * In some cases (currently only when recursing into an unnamed join)
7293 * the Var's varlevelsup has to be interpreted with respect to a context
7294 * above the current one; levelsup indicates the offset.
7295 *
7296 * If istoplevel is true, the Var is at the top level of a SELECT's
7297 * targetlist, which means we need special treatment of whole-row Vars.
7298 * Instead of the normal "tab.*", we'll print "tab.*::typename", which is a
7299 * dirty hack to prevent "tab.*" from being expanded into multiple columns.
7300 * (The parser will strip the useless coercion, so no inefficiency is added in
7301 * dump and reload.) We used to print just "tab" in such cases, but that is
7302 * ambiguous and will yield the wrong result if "tab" is also a plain column
7303 * name in the query.
7304 *
7305 * Returns the attname of the Var, or NULL if the Var has no attname (because
7306 * it is a whole-row Var or a subplan output reference).
7307 */
7310 {
7313 AttrNumber attnum;
7317 AttrNumber varattno;
7323 /* Find appropriate nesting depth */
7329 netlevelsup);
7331 /*
7332 * If we have a syntactic referent for the Var, and we're working from a
7333 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7334 * on the semantic referent. (Forcing use of the semantic referent when
7335 * printing plan trees is a design choice that's perhaps more motivated by
7336 * backwards compatibility than anything else. But it does have the
7337 * advantage of making plans more explicit.)
7338 */
7340 {
7343 }
7344 else
7345 {
7348 }
7350 /*
7351 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7352 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7353 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
7354 * find the aliases previously assigned for this RTE.
7355 */
7357 {
7358 /*
7359 * We might have been asked to map child Vars to some parent relation.
7360 */
7362 {
7368 /* Only map up to inheritance parents, not UNION ALL appendrels */
7372 {
7375 {
7381 }
7386 /* If the parent is itself a child, continue up. */
7389 }
7391 /*
7392 * If we found an ancestral rel, and that rel is included in
7393 * appendparents, print that column not the original one.
7394 */
7396 {
7399 }
7400 }
7406 }
7407 else
7408 {
7412 }
7414 /*
7415 * The planner will sometimes emit Vars referencing resjunk elements of a
7416 * subquery's target list (this is currently only possible if it chooses
7417 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
7418 * Although we prefer to print subquery-referencing Vars using the
7419 * subquery's alias, that's not possible for resjunk items since they have
7420 * no alias. So in that case, drill down to the subplan and print the
7421 * contents of the referenced tlist item. This works because in a plan
7422 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
7423 * we'll have set dpns->inner_plan to reference the child plan node.
7424 */
7428 {
7430 deparse_namespace save_dpns;
7440 /*
7441 * Force parentheses because our caller probably assumed a Var is a
7442 * simple expression.
7443 */
7452 }
7454 /*
7455 * If it's an unnamed join, look at the expansion of the alias variable.
7456 * If it's a simple reference to one of the input vars, then recursively
7457 * print the name of that var instead. When it's not a simple reference,
7458 * we have to just print the unqualified join column name. (This can only
7459 * happen with "dangerous" merged columns in a JOIN USING; we took pains
7460 * previously to make the unqualified column name unique in such cases.)
7461 *
7462 * This wouldn't work in decompiling plan trees, because we don't store
7463 * joinaliasvars lists after planning; but a plan tree should never
7464 * contain a join alias variable.
7465 */
7467 {
7471 {
7475 /* we intentionally don't strip implicit coercions here */
7477 {
7480 }
7481 }
7483 /*
7484 * Unnamed join has no refname. (Note: since it's unnamed, there is
7485 * no way the user could have referenced it to create a whole-row Var
7486 * for it. So we don't have to cover that case below.)
7487 */
7489 }
7494 {
7495 /* Get column name to use from the colinfo struct */
7501 /*
7502 * If we find a Var referencing a dropped column, it seems better to
7503 * print something (anything) than to fail. In general this should
7504 * not happen, but it used to be possible for some cases involving
7505 * functions returning named composite types, and perhaps there are
7506 * still bugs out there.
7507 */
7510 }
7511 else
7512 {
7513 /* System column - name is fixed, get it from the catalog */
7515 }
7519 /*
7520 * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
7521 * clause, we may need to add a table-name prefix to prevent
7522 * findTargetlistEntrySQL92 from misinterpreting the name as an
7523 * output-column name. To avoid cluttering the output with unnecessary
7524 * prefixes, do so only if there is a name match to a SELECT tlist item
7525 * that is different from the Var.
7526 */
7528 {
7532 {
7537 colno++;
7539 /* This must match colname-choosing logic in get_target_list() */
7543 else
7548 {
7551 }
7552 }
7553 }
7556 {
7559 }
7562 else
7563 {
7569 }
7572 }
7574 /*
7575 * Deparse a Var which references OUTER_VAR, INNER_VAR, or INDEX_VAR. This
7576 * routine is actually a callback for resolve_special_varno, which handles
7577 * finding the correct TargetEntry. We get the expression contained in that
7578 * TargetEntry and just need to deparse it, a job we can throw back on
7579 * get_rule_expr.
7580 */
7581 static void
7583 {
7586 /*
7587 * For a non-Var referent, force parentheses because our caller probably
7588 * assumed a Var is a simple expression.
7589 */
7595 }
7597 /*
7598 * Chase through plan references to special varnos (OUTER_VAR, INNER_VAR,
7599 * INDEX_VAR) until we find a real Var or some kind of non-Var node; then,
7600 * invoke the callback provided.
7601 */
7602 static void
7605 {
7609 /* This function is recursive, so let's be paranoid. */
7612 /* If it's not a Var, invoke the callback. */
7614 {
7617 }
7619 /* Find appropriate nesting depth */
7624 /*
7625 * If varno is special, recurse. (Don't worry about varnosyn; if we're
7626 * here, we already decided not to use that.)
7627 */
7629 {
7631 deparse_namespace save_dpns;
7638 /*
7639 * If we're descending to the first child of an Append or MergeAppend,
7640 * update appendparents. This will affect deparsing of all Vars
7641 * appearing within the eventually-resolved subexpression.
7642 */
7658 }
7660 {
7662 deparse_namespace save_dpns;
7673 }
7675 {
7685 }
7689 /* Not special. Just invoke the callback. */
7691 }
7693 /*
7694 * Get the name of a field of an expression of composite type. The
7695 * expression is usually a Var, but we handle other cases too.
7696 *
7697 * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
7698 *
7699 * This is fairly straightforward when the expression has a named composite
7700 * type; we need only look up the type in the catalogs. However, the type
7701 * could also be RECORD. Since no actual table or view column is allowed to
7702 * have type RECORD, a Var of type RECORD must refer to a JOIN or FUNCTION RTE
7703 * or to a subquery output. We drill down to find the ultimate defining
7704 * expression and attempt to infer the field name from it. We ereport if we
7705 * can't determine the name.
7706 *
7707 * Similarly, a PARAM of type RECORD has to refer to some expression of
7708 * a determinable composite type.
7709 */
7713 {
7715 AttrNumber attnum;
7719 AttrNumber varattno;
7720 TupleDesc tupleDesc;
7723 /*
7724 * If it's a RowExpr that was expanded from a whole-row Var, use the
7725 * column names attached to it. (We could let get_expr_result_tupdesc()
7726 * handle this, but it's much cheaper to just pull out the name we need.)
7727 */
7729 {
7734 }
7736 /*
7737 * If it's a Param of type RECORD, try to find what the Param refers to.
7738 */
7740 {
7746 {
7747 /* Found a match, so recurse to decipher the field name */
7748 deparse_namespace save_dpns;
7756 }
7757 }
7759 /*
7760 * If it's a Var of type RECORD, we have to find what the Var refers to;
7761 * if not, we can use get_expr_result_tupdesc().
7762 */
7765 {
7767 /* Got the tupdesc, so we can extract the field name */
7770 }
7772 /* Find appropriate nesting depth */
7778 netlevelsup);
7780 /*
7781 * If we have a syntactic referent for the Var, and we're working from a
7782 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7783 * on the semantic referent. (See comments in get_variable().)
7784 */
7786 {
7789 }
7790 else
7791 {
7794 }
7796 /*
7797 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7798 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7799 * down into the subplans, or INDEX_VAR, which is resolved similarly.
7800 *
7801 * Note: unlike get_variable and resolve_special_varno, we need not worry
7802 * about inheritance mapping: a child Var should have the same datatype as
7803 * its parent, and here we're really only interested in the Var's type.
7804 */
7806 {
7809 }
7811 {
7813 deparse_namespace save_dpns;
7828 }
7830 {
7832 deparse_namespace save_dpns;
7847 }
7849 {
7863 }
7864 else
7865 {
7868 }
7871 {
7872 /* Var is whole-row reference to RTE, so select the right field */
7874 }
7876 /*
7877 * This part has essentially the same logic as the parser's
7878 * expandRecordVariable() function, but we are dealing with a different
7879 * representation of the input context, and we only need one field name
7880 * not a TupleDesc. Also, we need special cases for finding subquery and
7881 * CTE subplans when deparsing Plan trees.
7882 */
7886 {
7892 /*
7893 * This case should not occur: a column of a table, values list,
7894 * or ENR shouldn't have type RECORD. Fall through and fail (most
7895 * likely) at the bottom.
7896 */
7899 /* Subselect-in-FROM: examine sub-select's output expr */
7900 {
7902 {
7904 attnum);
7911 {
7912 /*
7913 * Recurse into the sub-select to see what its Var
7914 * refers to. We have to build an additional level of
7915 * namespace to keep in step with varlevelsup in the
7916 * subselect; furthermore, the subquery RTE might be
7917 * from an outer query level, in which case the
7918 * namespace for the subselect must have that outer
7919 * level as parent namespace.
7920 */
7923 deparse_namespace mydpns;
7927 netlevelsup);
7930 parent_namespaces);
7940 }
7941 /* else fall through to inspect the expression */
7942 }
7943 else
7944 {
7945 /*
7946 * We're deparsing a Plan tree so we don't have complete
7947 * RTE entries (in particular, rte->subquery is NULL). But
7948 * the only place we'd normally see a Var directly
7949 * referencing a SUBQUERY RTE is in a SubqueryScan plan
7950 * node, and we can look into the child plan's tlist
7951 * instead. An exception occurs if the subquery was
7952 * proven empty and optimized away: then we'd find such a
7953 * Var in a childless Result node, and there's nothing in
7954 * the plan tree that would let us figure out what it had
7955 * originally referenced. In that case, fall back on
7956 * printing "fN", analogously to the default column names
7957 * for RowExprs.
7958 */
7960 deparse_namespace save_dpns;
7964 {
7970 }
7976 attnum);
7985 }
7986 }
7989 /* Join RTE --- recursively inspect the alias variable */
7995 /* we intentionally don't strip implicit coercions here */
7999 context);
8000 /* else fall through to inspect the expression */
8005 /*
8006 * We couldn't get here unless a function is declared with one of
8007 * its result columns as RECORD, which is not allowed.
8008 */
8011 /* CTE reference: examine subquery's output expr */
8012 {
8014 Index ctelevelsup;
8017 /*
8018 * Try to find the referenced CTE using the namespace stack.
8019 */
8023 else
8024 {
8030 {
8034 }
8035 }
8037 {
8040 attnum);
8047 {
8048 /*
8049 * Recurse into the CTE to see what its Var refers to.
8050 * We have to build an additional level of namespace
8051 * to keep in step with varlevelsup in the CTE;
8052 * furthermore it could be an outer CTE (compare
8053 * SUBQUERY case above).
8054 */
8057 deparse_namespace mydpns;
8061 ctelevelsup);
8064 parent_namespaces);
8074 }
8075 /* else fall through to inspect the expression */
8076 }
8077 else
8078 {
8079 /*
8080 * We're deparsing a Plan tree so we don't have a CTE
8081 * list. But the only places we'd normally see a Var
8082 * directly referencing a CTE RTE are in CteScan or
8083 * WorkTableScan plan nodes. For those cases,
8084 * set_deparse_plan arranged for dpns->inner_plan to be
8085 * the plan node that emits the CTE or RecursiveUnion
8086 * result, and we can look at its tlist instead. As
8087 * above, this can fail if the CTE has been proven empty,
8088 * in which case fall back to "fN".
8089 */
8091 deparse_namespace save_dpns;
8095 {
8101 }
8108 attnum);
8117 }
8118 }
8120 }
8122 /*
8123 * We now have an expression we can't expand any more, so see if
8124 * get_expr_result_tupdesc() can do anything with it.
8125 */
8127 /* Got the tupdesc, so we can extract the field name */
8130 }
8132 /*
8133 * Try to find the referenced expression for a PARAM_EXEC Param that might
8134 * reference a parameter supplied by an upper NestLoop or SubPlan plan node.
8135 *
8136 * If successful, return the expression and set *dpns_p and *ancestor_cell_p
8137 * appropriately for calling push_ancestor_plan(). If no referent can be
8138 * found, return NULL.
8139 */
8143 {
8144 /* Initialize output parameters to prevent compiler warnings */
8148 /*
8149 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
8150 * SubPlan argument. This will necessarily be in some ancestor of the
8151 * current expression's Plan node.
8152 */
8154 {
8163 {
8167 /*
8168 * NestLoops transmit params to their inner child only.
8169 */
8172 {
8176 {
8180 {
8181 /* Found a match, so return it */
8185 }
8186 }
8187 }
8189 /*
8190 * If ancestor is a SubPlan, check the arguments it provides.
8191 */
8193 {
8199 {
8204 {
8205 /*
8206 * Found a match, so return it. But, since Vars in
8207 * the arg are to be evaluated in the surrounding
8208 * context, we have to point to the next ancestor item
8209 * that is *not* a SubPlan.
8210 */
8215 {
8219 {
8223 }
8224 }
8226 }
8227 }
8229 /* SubPlan isn't a kind of Plan, so skip the rest */
8231 }
8233 /*
8234 * We need not consider the ancestor's initPlan list, since
8235 * initplans never have any parParams.
8236 */
8238 /* No luck, crawl up to next ancestor */
8240 }
8241 }
8243 /* No referent found */
8245 }
8247 /*
8248 * Try to find a subplan/initplan that emits the value for a PARAM_EXEC Param.
8249 *
8250 * If successful, return the generating subplan/initplan and set *column_p
8251 * to the subplan's 0-based output column number.
8252 * Otherwise, return NULL.
8253 */
8256 {
8257 /* Initialize output parameter to prevent compiler warnings */
8260 /*
8261 * If it's a PARAM_EXEC parameter, search the current plan node as well as
8262 * ancestor nodes looking for a subplan or initplan that emits the value
8263 * for the Param. It could appear in the setParams of an initplan or
8264 * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
8265 */
8267 {
8274 /* First check the innermost plan node's initplans */
8279 /*
8280 * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
8281 * which can be referenced by Params elsewhere in the targetlist.
8282 * (Such Params should always be in the same targetlist, so there's no
8283 * need to do this work at upper plan nodes.)
8284 */
8286 {
8288 {
8292 {
8294 {
8296 {
8297 /* Found a match, so return it. */
8300 }
8301 }
8302 }
8303 }
8304 }
8306 /* No luck, so check the ancestor nodes */
8308 {
8311 /*
8312 * If ancestor is a SubPlan, check the paramIds it provides.
8313 */
8315 {
8319 {
8321 {
8322 /* Found a match, so return it. */
8325 }
8326 }
8328 /* SubPlan isn't a kind of Plan, so skip the rest */
8330 }
8332 /*
8333 * Otherwise, it's some kind of Plan node, so check its initplans.
8334 */
8336 column_p);
8340 /* No luck, crawl up to next ancestor */
8341 }
8342 }
8344 /* No generator found */
8346 }
8348 /*
8349 * Subroutine for find_param_generator: search one Plan node's initplans
8350 */
8353 {
8355 {
8357 {
8359 {
8360 /* Found a match, so return it. */
8363 }
8364 }
8365 }
8367 }
8369 /*
8370 * Display a Param appropriately.
8371 */
8372 static void
8374 {
8381 /*
8382 * If it's a PARAM_EXEC parameter, try to locate the expression from which
8383 * the parameter was computed. This stanza handles only cases in which
8384 * the Param represents an input to the subplan we are currently in.
8385 */
8388 {
8389 /* Found a match, so print it */
8390 deparse_namespace save_dpns;
8394 /* Switch attention to the ancestor plan node */
8397 /*
8398 * Force prefixing of Vars, since they won't belong to the relation
8399 * being scanned in the original plan node.
8400 */
8404 /*
8405 * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
8406 * upper-level Param, which wouldn't need extra parentheses.
8407 * Otherwise, insert parens to ensure the expression looks atomic.
8408 */
8426 }
8428 /*
8429 * Alternatively, maybe it's a subplan output, which we print as a
8430 * reference to the subplan. (We could drill down into the subplan and
8431 * print the relevant targetlist expression, but that has been deemed too
8432 * confusing since it would violate normal SQL scope rules. Also, we're
8433 * relying on this reference to show that the testexpr containing the
8434 * Param has anything to do with that subplan at all.)
8435 */
8438 {
8444 }
8446 /*
8447 * If it's an external parameter, see if the outermost namespace provides
8448 * function argument names.
8449 */
8451 {
8456 {
8460 {
8464 /*
8465 * Qualify the parameter name if there are any other deparse
8466 * namespaces with range tables. This avoids qualifying in
8467 * trivial cases like "RETURN a + b", but makes it safe in all
8468 * other cases.
8469 */
8471 {
8475 {
8478 }
8479 }
8481 {
8484 }
8488 }
8489 }
8490 }
8492 /*
8493 * Not PARAM_EXEC, or couldn't find referent: just print $N.
8494 *
8495 * It's a bug if we get here for anything except PARAM_EXTERN Params, but
8496 * in production builds printing $N seems more useful than failing.
8497 */
8501 }
8503 /*
8504 * get_simple_binary_op_name
8505 *
8506 * helper function for isSimpleNode
8507 * will return single char binary operator name, or NULL if it's not
8508 */
8511 {
8515 {
8516 /* binary operator */
8524 }
8526 }
8529 /*
8530 * isSimpleNode - check if given node is simple (doesn't need parenthesizing)
8531 *
8532 * true : simple in the context of parent node's type
8533 * false : not simple
8534 */
8535 static bool
8537 {
8542 {
8549 /* single words: always simple */
8568 /* function-like: name(..) or name[..] */
8571 /* CASE keywords act as parentheses */
8577 /*
8578 * appears simple since . has top precedence, unless parent is
8579 * T_FieldSelect itself!
8580 */
8585 /*
8586 * treat like FieldSelect (probably doesn't matter)
8587 */
8591 /* maybe simple, check args */
8608 {
8609 /* depends on parent node type; needs further checking */
8611 {
8623 /* We know only the basic operators + - and * / % */
8644 /*
8645 * Operators are same priority --- can skip parens only if
8646 * we have (a - b) - c, not a - (b - c).
8647 */
8652 }
8653 /* else do the same stuff as for T_SubLink et al. */
8654 }
8655 /* FALLTHROUGH */
8663 {
8665 {
8666 /* special handling for casts and COERCE_SQL_SYNTAX */
8674 }
8690 }
8694 {
8697 {
8698 BoolExprType type;
8699 BoolExprType parentType;
8704 {
8714 }
8715 }
8718 {
8719 /* special handling for casts and COERCE_SQL_SYNTAX */
8727 }
8743 }
8746 /* maybe simple, check args */
8752 }
8753 /* those we don't know: in dubio complexo */
8755 }
8758 /*
8759 * appendContextKeyword - append a keyword to buffer
8760 *
8761 * If prettyPrint is enabled, perform a line break, and adjust indentation.
8762 * Otherwise, just append the keyword.
8763 */
8764 static void
8767 {
8771 {
8776 /* remove any trailing spaces currently in the buffer ... */
8778 /* ... then add a newline and some spaces */
8783 else
8784 {
8785 /*
8786 * If we're indented more than PRETTYINDENT_LIMIT characters, try
8787 * to conserve horizontal space by reducing the per-level
8788 * indentation. For best results the scale factor here should
8789 * divide all the indent amounts that get added to indentLevel
8790 * (PRETTYINDENT_STD, etc). It's important that the indentation
8791 * not grow unboundedly, else deeply-nested trees use O(N^2)
8792 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
8793 */
8798 /* scale/wrap logic affects indentLevel, but not indentPlus */
8800 }
8808 }
8809 else
8811 }
8813 /*
8814 * removeStringInfoSpaces - delete trailing spaces from a buffer.
8815 *
8816 * Possibly this should move to stringinfo.c at some point.
8817 */
8818 static void
8820 {
8823 }
8826 /*
8827 * get_rule_expr_paren - deparse expr using get_rule_expr,
8828 * embracing the string with parentheses if necessary for prettyPrint.
8829 *
8830 * Never embrace if prettyFlags=0, because it's done in the calling node.
8831 *
8832 * Any node that does *not* embrace its argument node by sql syntax (with
8833 * parentheses, non-operator keywords like CASE/WHEN/ON, or comma etc) should
8834 * use get_rule_expr_paren instead of get_rule_expr so parentheses can be
8835 * added.
8836 */
8837 static void
8840 {
8853 }
8855 static void
8858 {
8859 /*
8860 * The order of array elements must correspond to the order of
8861 * JsonBehaviorType members.
8862 */
8864 {
8873 " DEFAULT "
8874 };
8885 }
8887 /*
8888 * get_json_expr_options
8889 *
8890 * Parse back common options for JSON_QUERY, JSON_VALUE, JSON_EXISTS and
8891 * JSON_TABLE columns.
8892 */
8893 static void
8895 JsonBehaviorType default_behavior)
8896 {
8898 {
8903 /* The default */
8909 /* The default */
8910 else
8912 }
8919 }
8921 /* ----------
8922 * get_rule_expr - Parse back an expression
8923 *
8924 * Note: showimplicit determines whether we display any implicit cast that
8925 * is present at the top of the expression tree. It is a passed argument,
8926 * not a field of the context struct, because we change the value as we
8927 * recurse down into the expression. In general we suppress implicit casts
8928 * when the result type is known with certainty (eg, the arguments of an
8929 * OR must be boolean). We display implicit casts for arguments of functions
8930 * and operators, since this is needed to be certain that the same function
8931 * or operator will be chosen when the expression is re-parsed.
8932 * ----------
8933 */
8934 static void
8937 {
8943 /* Guard against excessively long or deeply-nested queries */
8947 /*
8948 * Each level of get_rule_expr must emit an indivisible term
8949 * (parenthesized if necessary) to ensure result is reparsed into the same
8950 * expression tree. The only exception is that when the input is a List,
8951 * we emit the component items comma-separated with no surrounding
8952 * decoration; this is convenient for most callers.
8953 */
8955 {
8973 {
8979 }
8991 {
8995 /*
8996 * If the argument is a CaseTestExpr, we must be inside a
8997 * FieldStore, ie, we are assigning to an element of an array
8998 * within a composite column. Since we already punted on
8999 * displaying the FieldStore's target information, just punt
9000 * here too, and display only the assignment source
9001 * expression.
9002 */
9004 {
9009 }
9011 /*
9012 * Parenthesize the argument unless it's a simple Var or a
9013 * FieldSelect. (In particular, if it's another
9014 * SubscriptingRef, we *must* parenthesize to avoid
9015 * confusion.)
9016 */
9025 /*
9026 * If there's a refassgnexpr, we want to print the node in the
9027 * format "container[subscripts] := refassgnexpr". This is
9028 * not legal SQL, so decompilation of INSERT or UPDATE
9029 * statements should always use processIndirection as part of
9030 * the statement-level syntax. We should only see this when
9031 * EXPLAIN tries to print the targetlist of a plan resulting
9032 * from such a statement.
9033 */
9035 {
9038 /*
9039 * Use processIndirection to print this node's subscripts
9040 * as well as any additional field selections or
9041 * subscripting in immediate descendants. It returns the
9042 * RHS expr that is actually being "assigned".
9043 */
9047 }
9048 else
9049 {
9050 /* Just an ordinary container fetch, so print subscripts */
9052 }
9053 }
9061 {
9066 }
9074 {
9087 }
9091 {
9097 }
9101 {
9117 /*
9118 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
9119 * a bare sub-SELECT. Since we're here, the sub-SELECT must
9120 * be meant as a scalar sub-SELECT yielding an array value to
9121 * be used in ScalarArrayOpExpr; but the grammar will
9122 * preferentially interpret such a construct as an ANY/ALL
9123 * SubLink. To prevent misparsing the output that way, insert
9124 * a dummy coercion (which will be stripped by parse analysis,
9125 * so no inefficiency is added in dump and reload). This is
9126 * indeed most likely what the user wrote to get the construct
9127 * accepted in the first place.
9128 */
9137 }
9141 {
9147 {
9154 {
9158 }
9169 {
9173 }
9191 }
9192 }
9200 {
9203 /*
9204 * We cannot see an already-planned subplan in rule deparsing,
9205 * only while EXPLAINing a query plan. We don't try to
9206 * reconstruct the original SQL, just reference the subplan
9207 * that appears elsewhere in EXPLAIN's result. It does seem
9208 * useful to show the subLinkType and testexpr (if any), and
9209 * we also note whether the subplan will be hashed.
9210 */
9212 {
9226 /* Parenthesizing the testexpr seems sufficient */
9231 /* No need to decorate these subplan references */
9236 /* MULTIEXPR isn't executed in the normal way */
9245 /* This case is unreachable within expressions */
9249 }
9252 {
9255 /*
9256 * Push SubPlan into ancestors list while deparsing
9257 * testexpr, so that we can handle PARAM_EXEC references
9258 * to the SubPlan's paramIds. (This makes it look like
9259 * the SubPlan is an "ancestor" of the current plan node,
9260 * which is a little weird, but it does no harm.) In this
9261 * path, we don't need to mention the SubPlan explicitly,
9262 * because the referencing Params will show its existence.
9263 */
9271 }
9272 else
9273 {
9274 /* No referencing Params, so show the SubPlan's name */
9277 else
9279 }
9280 }
9284 {
9288 /*
9289 * This case cannot be reached in normal usage, since no
9290 * AlternativeSubPlan can appear either in parsetrees or
9291 * finished plan trees. We keep it just in case somebody
9292 * wants to use this code to print planner data structures.
9293 */
9296 {
9301 else
9305 }
9307 }
9311 {
9318 /*
9319 * Parenthesize the argument unless it's an SubscriptingRef or
9320 * another FieldSelect. Note in particular that it would be
9321 * WRONG to not parenthesize a Var argument; simplicity is not
9322 * the issue here, having the right number of names is.
9323 */
9332 /*
9333 * Get and print the field name.
9334 */
9338 }
9342 {
9346 /*
9347 * There is no good way to represent a FieldStore as real SQL,
9348 * so decompilation of INSERT or UPDATE statements should
9349 * always use processIndirection as part of the
9350 * statement-level syntax. We should only get here when
9351 * EXPLAIN tries to print the targetlist of a plan resulting
9352 * from such a statement. The plan case is even harder than
9353 * ordinary rules would be, because the planner tries to
9354 * collapse multiple assignments to the same field or subfield
9355 * into one FieldStore; so we can see a list of target fields
9356 * not just one, and the arguments could be FieldStores
9357 * themselves. We don't bother to try to print the target
9358 * field names; we just print the source arguments, with a
9359 * ROW() around them if there's more than one. This isn't
9360 * terribly complete, but it's probably good enough for
9361 * EXPLAIN's purposes; especially since anything more would be
9362 * either hopelessly confusing or an even poorer
9363 * representation of what the plan is actually doing.
9364 */
9371 }
9375 {
9381 {
9382 /* don't show the implicit cast */
9384 }
9385 else
9386 {
9390 node);
9391 }
9392 }
9396 {
9402 {
9403 /* don't show the implicit cast */
9405 }
9406 else
9407 {
9411 node);
9412 }
9413 }
9417 {
9423 {
9424 /* don't show the implicit cast */
9426 }
9427 else
9428 {
9432 node);
9433 }
9434 }
9438 {
9444 {
9445 /* don't show the implicit cast */
9447 }
9448 else
9449 {
9452 node);
9453 }
9454 }
9458 {
9469 }
9473 {
9480 {
9483 }
9485 {
9490 {
9491 /*
9492 * The parser should have produced WHEN clauses of the
9493 * form "CaseTestExpr = RHS", possibly with an
9494 * implicit coercion inserted above the CaseTestExpr.
9495 * For accurate decompilation of rules it's essential
9496 * that we show just the RHS. However in an
9497 * expression that's been through the optimizer, the
9498 * WHEN clause could be almost anything (since the
9499 * equality operator could have been expanded into an
9500 * inline function). If we don't recognize the form
9501 * of the WHEN clause, just punt and display it as-is.
9502 */
9504 {
9509 CaseTestExpr))
9511 }
9512 }
9521 }
9531 }
9535 {
9536 /*
9537 * Normally we should never get here, since for expressions
9538 * that can contain this node type we attempt to avoid
9539 * recursing to it. But in an optimized expression we might
9540 * be unable to avoid that (see comments for CaseExpr). If we
9541 * do see one, print it as CASE_TEST_EXPR.
9542 */
9544 }
9548 {
9555 /*
9556 * If the array isn't empty, we assume its elements are
9557 * coerced to the desired type. If it's empty, though, we
9558 * need an explicit coercion to the array type.
9559 */
9563 }
9567 {
9574 /*
9575 * If it's a named type and not RECORD, we may have to skip
9576 * dropped columns and/or claim there are NULLs for added
9577 * columns.
9578 */
9580 {
9583 }
9585 /*
9586 * SQL99 allows "ROW" to be omitted when there is more than
9587 * one column, but for simplicity we always print it.
9588 */
9593 {
9598 {
9600 /* Whole-row Vars need special treatment here */
9603 }
9604 i++;
9605 }
9607 {
9609 {
9611 {
9615 }
9616 i++;
9617 }
9620 }
9625 }
9629 {
9632 /*
9633 * SQL99 allows "ROW" to be omitted when there is more than
9634 * one column, but for simplicity we always print it. Within
9635 * a ROW expression, whole-row Vars need special treatment, so
9636 * use get_rule_list_toplevel.
9637 */
9641 /*
9642 * We assume that the name of the first-column operator will
9643 * do for all the rest too. This is definitely open to
9644 * failure, eg if some but not all operators were renamed
9645 * since the construct was parsed, but there seems no way to
9646 * be perfect.
9647 */
9654 }
9658 {
9664 }
9668 {
9672 {
9679 }
9682 }
9686 {
9689 /*
9690 * Note: this code knows that typmod for time, timestamp, and
9691 * timestamptz just prints as integer.
9692 */
9694 {
9742 }
9743 }
9747 {
9755 {
9779 }
9781 {
9784 else
9786 }
9788 {
9792 }
9794 {
9796 {
9801 }
9803 {
9813 }
9816 }
9818 {
9822 {
9828 /* no extra decoration needed */
9842 else
9857 else
9863 else
9864 {
9866 {
9881 }
9882 }
9887 }
9888 }
9895 else
9897 }
9901 {
9908 /*
9909 * For scalar inputs, we prefer to print as IS [NOT] NULL,
9910 * which is shorter and traditional. If it's a rowtype input
9911 * but we're applying a scalar test, must print IS [NOT]
9912 * DISTINCT FROM NULL to be semantically correct.
9913 */
9916 {
9918 {
9928 }
9929 }
9930 else
9931 {
9933 {
9943 }
9944 }
9947 }
9951 {
9958 {
9980 }
9983 }
9987 {
9993 {
9994 /* don't show the implicit cast */
9996 }
9997 else
9998 {
10002 node);
10003 }
10004 }
10016 {
10022 else
10025 }
10029 {
10032 /*
10033 * This isn't exactly nextval(), but that seems close enough
10034 * for EXPLAIN's purposes.
10035 */
10039 NIL));
10041 }
10045 {
10050 /*
10051 * InferenceElem can only refer to target relation, so a
10052 * prefix is not useful, and indeed would cause parse errors.
10053 */
10057 /*
10058 * Parenthesize the element unless it's a simple Var or a bare
10059 * function call. Follows pg_get_indexdef_worker().
10060 */
10064 COERCE_EXPLICIT_CALL)
10080 /* Add the operator class name, if not default */
10082 {
10087 }
10088 }
10092 {
10098 {
10101 }
10104 {
10120 {
10126 }
10146 }
10147 }
10151 {
10156 }
10164 {
10174 /* TODO: handle FORMAT clause */
10177 {
10189 }
10196 }
10200 {
10204 {
10217 }
10226 {
10235 {
10243 }
10244 }
10253 JSON_BEHAVIOR_NULL :
10254 JSON_BEHAVIOR_FALSE);
10257 }
10261 {
10267 {
10271 }
10272 }
10282 }
10283 }
10285 /*
10286 * get_rule_expr_toplevel - Parse back a toplevel expression
10287 *
10288 * Same as get_rule_expr(), except that if the expr is just a Var, we pass
10289 * istoplevel = true not false to get_variable(). This causes whole-row Vars
10290 * to get printed with decoration that will prevent expansion of "*".
10291 * We need to use this in contexts such as ROW() and VALUES(), where the
10292 * parser would expand "foo.*" appearing at top level. (In principle we'd
10293 * use this in get_target_list() too, but that has additional worries about
10294 * whether to print AS, so it needs to invoke get_variable() directly anyway.)
10295 */
10296 static void
10299 {
10302 else
10304 }
10306 /*
10307 * get_rule_list_toplevel - Parse back a list of toplevel expressions
10308 *
10309 * Apply get_rule_expr_toplevel() to each element of a List.
10310 *
10311 * This adds commas between the expressions, but caller is responsible
10312 * for printing surrounding decoration.
10313 */
10314 static void
10317 {
10323 {
10329 }
10330 }
10332 /*
10333 * get_rule_expr_funccall - Parse back a function-call expression
10334 *
10335 * Same as get_rule_expr(), except that we guarantee that the output will
10336 * look like a function call, or like one of the things the grammar treats as
10337 * equivalent to a function call (see the func_expr_windowless production).
10338 * This is needed in places where the grammar uses func_expr_windowless and
10339 * you can't substitute a parenthesized a_expr. If what we have isn't going
10340 * to look like a function call, wrap it in a dummy CAST() expression, which
10341 * will satisfy the grammar --- and, indeed, is likely what the user wrote to
10342 * produce such a thing.
10343 */
10344 static void
10347 {
10350 else
10351 {
10355 /* no point in showing any top-level implicit cast */
10360 }
10361 }
10363 /*
10364 * Helper function to identify node types that satisfy func_expr_windowless.
10365 * If in doubt, "false" is always a safe answer.
10366 */
10367 static bool
10369 {
10373 {
10375 /* OK, unless it's going to deparse as a cast */
10384 /* these are all accepted by func_expr_common_subexpr */
10388 }
10390 }
10393 /*
10394 * get_oper_expr - Parse back an OpExpr node
10395 */
10396 static void
10398 {
10406 {
10407 /* binary operator */
10417 }
10418 else
10419 {
10420 /* prefix operator */
10425 InvalidOid,
10428 }
10431 }
10433 /*
10434 * get_func_expr - Parse back a FuncExpr node
10435 */
10436 static void
10439 {
10448 /*
10449 * If the function call came from an implicit coercion, then just show the
10450 * first argument --- unless caller wants to see implicit coercions.
10451 */
10453 {
10457 }
10459 /*
10460 * If the function call came from a cast, then show the first argument
10461 * plus an explicit cast operation.
10462 */
10465 {
10468 int32 coercedTypmod;
10470 /* Get the typmod if this is a length-coercion function */
10478 }
10480 /*
10481 * If the function was called using one of the SQL spec's random special
10482 * syntaxes, try to reproduce that. If we don't recognize the function,
10483 * fall through.
10484 */
10486 {
10489 }
10491 /*
10492 * Normal function: display as proname(args). First we need to extract
10493 * the argument datatypes.
10494 */
10502 {
10508 nargs++;
10509 }
10519 {
10525 }
10527 }
10529 /*
10530 * get_agg_expr - Parse back an Aggref node
10531 */
10532 static void
10535 {
10538 }
10540 /*
10541 * get_agg_expr_helper - subroutine for get_agg_expr and
10542 * get_json_agg_constructor
10543 */
10544 static void
10548 {
10554 /*
10555 * For a combining aggregate, we look up and deparse the corresponding
10556 * partial aggregate instead. This is necessary because our input
10557 * argument list has been replaced; the new argument list always has just
10558 * one element, which will point to a partial Aggref that supplies us with
10559 * transition states to combine.
10560 */
10562 {
10570 }
10572 /*
10573 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
10574 * to avoid printing this when recursing from the code just above.
10575 */
10579 /* Extract the argument types as seen by the parser */
10588 /* Print the aggregate name, schema-qualified if needed */
10593 {
10594 /*
10595 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
10596 * worry about inserting VARIADIC. So we can just dump the direct
10597 * args as-is.
10598 */
10604 }
10605 else
10606 {
10607 /* aggstar can be set only in zero-argument aggregates */
10610 else
10611 {
10617 {
10625 {
10627 {
10628 /*
10629 * the ABSENT ON NULL and WITH UNIQUE args are printed
10630 * separately, so ignore them here
10631 */
10636 }
10637 else
10639 }
10643 }
10644 }
10647 {
10650 }
10651 }
10657 {
10660 }
10663 }
10665 /*
10666 * This is a helper function for get_agg_expr(). It's used when we deparse
10667 * a combining Aggref; resolve_special_varno locates the corresponding partial
10668 * Aggref and then calls this.
10669 */
10670 static void
10672 {
10681 }
10683 /*
10684 * get_windowfunc_expr - Parse back a WindowFunc node
10685 */
10686 static void
10688 {
10690 }
10693 /*
10694 * get_windowfunc_expr_helper - subroutine for get_windowfunc_expr and
10695 * get_json_agg_constructor
10696 */
10697 static void
10701 {
10715 {
10721 nargs++;
10722 }
10731 /* winstar can be set only in zero-argument aggregates */
10734 else
10735 {
10737 {
10741 }
10742 else
10744 }
10750 {
10753 }
10758 {
10762 {
10765 else
10768 }
10769 }
10771 {
10776 /*
10777 * In EXPLAIN, we don't have window context information available, so
10778 * we have to settle for this:
10779 */
10781 }
10782 }
10784 /*
10785 * get_func_sql_syntax - Parse back a SQL-syntax function call
10786 *
10787 * Returns true if we successfully deparsed, false if we did not
10788 * recognize the function.
10789 */
10790 static bool
10792 {
10797 {
10804 /* AT TIME ZONE ... note reversed argument order */
10817 /* AT LOCAL */
10837 /* (x1, x2) OVERLAPS (y1, y2) */
10855 /* EXTRACT (x FROM y) */
10857 {
10864 }
10871 /* IS xxx NORMALIZED */
10877 {
10885 }
10890 /* COLLATION FOR */
10897 /* NORMALIZE() */
10901 {
10909 }
10919 /* OVERLAY() */
10927 {
10930 }
10937 /* POSITION() ... extra parens since args are b_expr not a_expr */
10951 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
10957 {
10960 }
10965 /* SUBSTRING SIMILAR/ESCAPE */
10978 /* TRIM() */
10981 {
10984 }
10993 /* TRIM() */
10996 {
10999 }
11008 /* TRIM() */
11011 {
11014 }
11025 /* XMLEXISTS ... extra parens because args are c_expr */
11032 }
11034 }
11036 /* ----------
11037 * get_coercion_expr
11038 *
11039 * Make a string representation of a value coerced to a specific type
11040 * ----------
11041 */
11042 static void
11046 {
11049 /*
11050 * Since parse_coerce.c doesn't immediately collapse application of
11051 * length-coercion functions to constants, what we'll typically see in
11052 * such cases is a Const with typmod -1 and a length-coercion function
11053 * right above it. Avoid generating redundant output. However, beware of
11054 * suppressing casts when the user actually wrote something like
11055 * 'foo'::text::char(3).
11056 *
11057 * Note: it might seem that we are missing the possibility of needing to
11058 * print a COLLATE clause for such a Const. However, a Const could only
11059 * have nondefault collation in a post-constant-folding tree, in which the
11060 * length coercion would have been folded too. See also the special
11061 * handling of CollateExpr in coerce_to_target_type(): any collation
11062 * marking will be above the coercion node, not below it.
11063 */
11067 {
11068 /* Show the constant without normal ::typename decoration */
11070 }
11071 else
11072 {
11078 }
11080 /*
11081 * Never emit resulttype(arg) functional notation. A pg_proc entry could
11082 * take precedence, and a resulttype in pg_temp would require schema
11083 * qualification that format_type_with_typemod() would usually omit. We've
11084 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
11085 * would work fine.
11086 */
11089 }
11091 /* ----------
11092 * get_const_expr
11093 *
11094 * Make a string representation of a Const
11095 *
11096 * showtype can be -1 to never show "::typename" decoration, or +1 to always
11097 * show it, or 0 to show it only if the constant wouldn't be assumed to be
11098 * the right type by default.
11099 *
11100 * If the Const's collation isn't default for its type, show that too.
11101 * We mustn't do this when showtype is -1 (since that means the caller will
11102 * print "::typename", and we can't put a COLLATE clause in between). It's
11103 * caller's responsibility that collation isn't missed in such cases.
11104 * ----------
11105 */
11106 static void
11108 {
11110 Oid typoutput;
11116 {
11117 /*
11118 * Always label the type of a NULL constant to prevent misdecisions
11119 * about type when reparsing.
11120 */
11123 {
11128 }
11130 }
11138 {
11141 /*
11142 * INT4 can be printed without any decoration, unless it is
11143 * negative; in that case print it as '-nnn'::integer to ensure
11144 * that the output will re-parse as a constant, not as a constant
11145 * plus operator. In most cases we could get away with printing
11146 * (-nnn) instead, because of the way that gram.y handles negative
11147 * literals; but that doesn't work for INT_MIN, and it doesn't
11148 * seem that much prettier anyway.
11149 */
11152 else
11153 {
11156 }
11161 /*
11162 * NUMERIC can be printed without quotes if it looks like a float
11163 * constant (not an integer, and not Infinity or NaN) and doesn't
11164 * have a leading sign (for the same reason as for INT4).
11165 */
11168 {
11170 }
11171 else
11172 {
11175 }
11181 else
11188 }
11195 /*
11196 * For showtype == 0, append ::typename unless the constant will be
11197 * implicitly typed as the right type when it is read in.
11198 *
11199 * XXX this code has to be kept in sync with the behavior of the parser,
11200 * especially make_const.
11201 */
11203 {
11206 /* These types can be left unlabeled */
11210 /* We determined above whether a label is needed */
11214 /*
11215 * Float-looking constants will be typed as numeric, which we
11216 * checked above; but if there's a nondefault typmod we need to
11217 * show it.
11218 */
11224 }
11231 }
11233 /*
11234 * helper for get_const_expr: append COLLATE if needed
11235 */
11236 static void
11238 {
11242 {
11246 {
11249 }
11250 }
11251 }
11253 /*
11254 * get_json_path_spec - Parse back a JSON path specification
11255 */
11256 static void
11258 {
11261 else
11263 }
11265 /*
11266 * get_json_format - Parse back a JsonFormat node
11267 */
11268 static void
11270 {
11279 {
11282 encoding =
11287 }
11288 }
11290 /*
11291 * get_json_returning - Parse back a JsonReturning structure
11292 */
11293 static void
11296 {
11308 }
11310 /*
11311 * get_json_constructor - Parse back a JsonConstructorExpr node
11312 */
11313 static void
11316 {
11324 {
11327 }
11329 {
11332 }
11335 {
11353 }
11359 {
11362 {
11367 }
11370 }
11374 }
11376 /*
11377 * Append options, if any, to the JSON constructor being deparsed
11378 */
11379 static void
11381 {
11383 {
11387 }
11388 else
11389 {
11393 }
11398 /*
11399 * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
11400 * support one.
11401 */
11404 }
11406 /*
11407 * get_json_agg_constructor - Parse back an aggregate JsonConstructorExpr node
11408 */
11409 static void
11412 {
11413 StringInfoData options;
11425 is_json_objectagg);
11426 else
11429 }
11431 /*
11432 * simple_quote_literal - Format a string as a SQL literal, append to buf
11433 */
11434 static void
11436 {
11439 /*
11440 * We form the string literal according to the prevailing setting of
11441 * standard_conforming_strings; we never use E''. User is responsible for
11442 * making sure result is used correctly.
11443 */
11446 {
11452 }
11454 }
11457 /* ----------
11458 * get_sublink_expr - Parse back a sublink
11459 * ----------
11460 */
11461 static void
11463 {
11471 else
11474 /*
11475 * Note that we print the name of only the first operator, when there are
11476 * multiple combining operators. This is an approximation that could go
11477 * wrong in various scenarios (operators in different schemas, renamed
11478 * operators, etc) but there is not a whole lot we can do about it, since
11479 * the syntax allows only one operator to be shown.
11480 */
11482 {
11484 {
11485 /* single combining operator */
11492 }
11494 {
11495 /* multiple combining operators, = or <> cases */
11502 {
11512 }
11514 }
11516 {
11517 /* multiple combining operators, < <= > >= cases */
11526 }
11527 else
11530 }
11535 {
11543 else
11566 }
11577 else
11579 }
11582 /* ----------
11583 * get_xmltable - Parse back a XMLTABLE function
11584 * ----------
11585 */
11586 static void
11588 {
11594 {
11601 {
11607 else
11611 {
11614 }
11615 else
11616 {
11619 }
11620 }
11622 }
11631 {
11642 {
11653 colnum++;
11662 {
11666 }
11668 {
11672 }
11675 }
11676 }
11679 }
11681 /*
11682 * get_json_table_nested_columns - Parse back nested JSON_TABLE columns
11683 */
11684 static void
11688 {
11690 {
11701 }
11703 {
11707 needcomma);
11710 }
11711 }
11713 /*
11714 * get_json_table_columns - Parse back JSON_TABLE columns
11715 */
11716 static void
11720 {
11739 {
11742 Oid typid;
11743 int32 typmod;
11745 JsonBehaviorType default_behavior;
11751 /* Skip columns that don't belong to this scan. */
11753 {
11754 colnum++;
11756 }
11763 colnum++;
11776 {
11779 }
11780 else
11781 {
11783 {
11793 }
11796 }
11806 }
11816 }
11818 /* ----------
11819 * get_json_table - Parse back a JSON_TABLE function
11820 * ----------
11821 */
11822 static void
11824 {
11845 {
11858 {
11868 );
11869 }
11873 }
11876 showimplicit);
11885 }
11887 /* ----------
11888 * get_tablefunc - Parse back a table function
11889 * ----------
11890 */
11891 static void
11893 {
11894 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
11900 }
11902 /* ----------
11903 * get_from_clause - Parse back a FROM clause
11904 *
11905 * "prefix" is the keyword that denotes the start of the list of FROM
11906 * elements. It is FROM when used to parse back SELECT and UPDATE, but
11907 * is USING when parsing back DELETE.
11908 * ----------
11909 */
11910 static void
11912 {
11917 /*
11918 * We use the query's jointree as a guide to what to print. However, we
11919 * must ignore auto-added RTEs that are marked not inFromCl. (These can
11920 * only appear at the top level of the jointree, so it's sufficient to
11921 * check here.) This check also ensures we ignore the rule pseudo-RTEs
11922 * for NEW and OLD.
11923 */
11925 {
11929 {
11935 }
11938 {
11944 }
11945 else
11946 {
11947 StringInfoData itembuf;
11951 /*
11952 * Put the new FROM item's text into itembuf so we can decide
11953 * after we've got it whether or not it needs to go on a new line.
11954 */
11960 /* Restore context's output buffer */
11963 /* Consider line-wrapping if enabled */
11965 {
11966 /* Does the new item start with a new line? */
11968 {
11969 /* If so, we shouldn't add anything */
11970 /* instead, remove any trailing spaces currently in buf */
11972 }
11973 else
11974 {
11977 /* Locate the start of the current line in the buffer */
11981 else
11982 trailing_nl++;
11984 /*
11985 * Add a newline, plus some indentation, if the new item
11986 * would cause an overflow.
11987 */
11990 PRETTYINDENT_STD,
11991 PRETTYINDENT_VAR);
11992 }
11993 }
11995 /* Add the new item */
11998 /* clean up */
12000 }
12001 }
12002 }
12004 static void
12006 {
12011 {
12020 /* Print the FROM item proper */
12022 {
12024 /* Normal relation RTE */
12031 /* Subquery RTE */
12040 /* Function RTE */
12043 /*
12044 * Omit ROWS FROM() syntax for just one function, unless it
12045 * has both a coldeflist and WITH ORDINALITY. If it has both,
12046 * we must use ROWS FROM() syntax to avoid ambiguity about
12047 * whether the coldeflist includes the ordinality column.
12048 */
12051 {
12053 /* we'll print the coldeflist below, if it has one */
12054 }
12055 else
12056 {
12060 /*
12061 * If all the function calls in the list are to unnest,
12062 * and none need a coldeflist, then collapse the list back
12063 * down to UNNEST(args). (If we had more than one
12064 * built-in unnest function, this would get more
12065 * difficult.)
12066 *
12067 * XXX This is pretty ugly, since it makes not-terribly-
12068 * future-proof assumptions about what the parser would do
12069 * with the output; but the alternative is to emit our
12070 * nonstandard ROWS FROM() notation for what might have
12071 * been a perfectly spec-compliant multi-argument
12072 * UNNEST().
12073 */
12076 {
12082 {
12085 }
12086 }
12089 {
12093 {
12098 }
12103 }
12104 else
12105 {
12110 {
12117 {
12118 /* Reconstruct the column definition list */
12121 NULL,
12122 context);
12123 }
12124 funcno++;
12125 }
12127 }
12128 /* prevent printing duplicate coldeflist below */
12130 }
12138 /* Values list RTE */
12149 }
12151 /* Print the relation alias, if needed */
12154 /* Print the column definitions or aliases, if needed */
12156 {
12157 /* Reconstruct the columndef list, which is also the aliases */
12159 }
12160 else
12161 {
12162 /* Else print column aliases as needed */
12164 }
12166 /* Tablesample clause must go after any alias */
12169 }
12171 {
12186 {
12191 PRETTYINDENT_STD,
12192 PRETTYINDENT_JOIN);
12193 else
12196 PRETTYINDENT_STD,
12197 PRETTYINDENT_JOIN);
12202 PRETTYINDENT_STD,
12203 PRETTYINDENT_JOIN);
12208 PRETTYINDENT_STD,
12209 PRETTYINDENT_JOIN);
12214 PRETTYINDENT_STD,
12215 PRETTYINDENT_JOIN);
12220 }
12229 {
12234 /* Use the assigned names, not what's in usingClause */
12236 {
12241 else
12244 }
12250 }
12252 {
12259 }
12261 {
12262 /* If we didn't say CROSS JOIN above, we must provide an ON */
12264 }
12269 /* Yes, it's correct to put alias after the right paren ... */
12271 {
12272 /*
12273 * Note that it's correct to emit an alias clause if and only if
12274 * there was one originally. Otherwise we'd be converting a named
12275 * join to unnamed or vice versa, which creates semantic
12276 * subtleties we don't want. However, we might print a different
12277 * alias name than was there originally.
12278 */
12281 context)));
12283 }
12284 }
12285 else
12288 }
12290 /*
12291 * get_rte_alias - print the relation's alias, if needed
12292 *
12293 * If printed, the alias is preceded by a space, or by " AS " if use_as is true.
12294 */
12295 static void
12298 {
12305 {
12306 /* Always print alias if user provided one */
12308 }
12310 {
12311 /* Always print alias if we need to print column aliases */
12313 }
12315 {
12316 /*
12317 * No need to print alias if it's same as relation name (this would
12318 * normally be the case, but not if set_rtable_names had to resolve a
12319 * conflict).
12320 */
12323 }
12325 {
12326 /*
12327 * For a function RTE, always print alias. This covers possible
12328 * renaming of the function and/or instability of the FigureColname
12329 * rules for things that aren't simple functions. Note we'd need to
12330 * force it anyway for the columndef list case.
12331 */
12333 }
12336 {
12337 /*
12338 * For a subquery, always print alias. This makes the output
12339 * SQL-spec-compliant, even though we allow such aliases to be omitted
12340 * on input.
12341 */
12343 }
12345 {
12346 /*
12347 * No need to print alias if it's same as CTE name (this would
12348 * normally be the case, but not if set_rtable_names had to resolve a
12349 * conflict).
12350 */
12353 }
12359 }
12361 /*
12362 * get_column_alias_list - print column alias list for an RTE
12363 *
12364 * Caller must already have printed the relation's alias name.
12365 */
12366 static void
12368 {
12373 /* Don't print aliases if not needed */
12378 {
12382 {
12385 }
12386 else
12389 }
12392 }
12394 /*
12395 * get_from_clause_coldeflist - reproduce FROM clause coldeflist
12396 *
12397 * When printing a top-level coldeflist (which is syntactically also the
12398 * relation's column alias list), use column names from colinfo. But when
12399 * printing a coldeflist embedded inside ROWS FROM(), we prefer to use the
12400 * original coldeflist's names, which are available in rtfunc->funccolnames.
12401 * Pass NULL for colinfo to select the latter behavior.
12402 *
12403 * The coldeflist is appended immediately (no space) to buf. Caller is
12404 * responsible for ensuring that an alias or AS is present before it.
12405 */
12406 static void
12410 {
12425 {
12433 else
12448 i++;
12449 }
12452 }
12454 /*
12455 * get_tablesample_def - print a TableSampleClause
12456 */
12457 static void
12459 {
12465 /*
12466 * We should qualify the handler's function name if it wouldn't be
12467 * resolved by lookup in the current search path.
12468 */
12477 {
12481 }
12485 {
12489 }
12490 }
12492 /*
12493 * get_opclass_name - fetch name of an index operator class
12494 *
12495 * The opclass name is appended (after a space) to buf.
12496 *
12497 * Output is suppressed if the opclass is the default for the given
12498 * actual_datatype. (If you don't want this behavior, just pass
12499 * InvalidOid for actual_datatype.)
12500 */
12501 static void
12503 StringInfo buf)
12504 {
12505 HeapTuple ht_opc;
12506 Form_pg_opclass opcrec;
12517 {
12518 /* Okay, we need the opclass name. Do we need to qualify it? */
12522 else
12523 {
12528 }
12529 }
12531 }
12533 /*
12534 * generate_opclass_name
12535 * Compute the name to display for an opclass specified by OID
12536 *
12537 * The result includes all necessary quoting and schema-prefixing.
12538 */
12541 {
12542 StringInfoData buf;
12548 }
12550 /*
12551 * processIndirection - take care of array and subfield assignment
12552 *
12553 * We strip any top-level FieldStore or assignment SubscriptingRef nodes that
12554 * appear in the input, printing them as decoration for the base column
12555 * name (which we assume the caller just printed). We might also need to
12556 * strip CoerceToDomain nodes, but only ones that appear above assignment
12557 * nodes.
12558 *
12559 * Returns the subexpression that's to be assigned.
12560 */
12563 {
12568 {
12572 {
12574 Oid typrelid;
12577 /* lookup tuple type */
12583 /*
12584 * Print the field name. There should only be one target field in
12585 * stored rules. There could be more than that in executable
12586 * target lists, but this function cannot be used for that case.
12587 */
12593 /*
12594 * We ignore arg since it should be an uninteresting reference to
12595 * the target column or subcolumn.
12596 */
12598 }
12600 {
12608 /*
12609 * We ignore refexpr since it should be an uninteresting reference
12610 * to the target column or subcolumn.
12611 */
12613 }
12615 {
12617 /* If it's an explicit domain coercion, we're done */
12620 /* Tentatively descend past the CoerceToDomain */
12622 }
12623 else
12625 }
12627 /*
12628 * If we descended past a CoerceToDomain whose argument turned out not to
12629 * be a FieldStore or array assignment, back up to the CoerceToDomain.
12630 * (This is not enough to be fully correct if there are nested implicit
12631 * CoerceToDomains, but such cases shouldn't ever occur.)
12632 */
12637 }
12639 static void
12641 {
12648 {
12651 {
12652 /* If subexpression is NULL, get_rule_expr prints nothing */
12656 }
12657 /* If subexpression is NULL, get_rule_expr prints nothing */
12660 }
12661 }
12663 /*
12664 * quote_identifier - Quote an identifier only if needed
12665 *
12666 * When quotes are needed, we palloc the required space; slightly
12667 * space-wasteful but well worth it for notational simplicity.
12668 */
12671 {
12672 /*
12673 * Can avoid quoting if ident starts with a lowercase letter or underscore
12674 * and contains only lowercase letters, digits, and underscores, *and* is
12675 * not any SQL keyword. Otherwise, supply quotes.
12676 */
12683 /*
12684 * would like to use <ctype.h> macros here, but they might yield unwanted
12685 * locale-specific results...
12686 */
12690 {
12696 {
12697 /* okay */
12698 }
12699 else
12700 {
12703 nquotes++;
12704 }
12705 }
12711 {
12712 /*
12713 * Check for keyword. We quote keywords except for unreserved ones.
12714 * (In some cases we could avoid quoting a col_name or type_func_name
12715 * keyword, but it seems much harder than it's worth to tell that.)
12716 *
12717 * Note: ScanKeywordLookup() does case-insensitive comparison, but
12718 * that's fine, since we already know we have all-lower-case.
12719 */
12724 }
12734 {
12740 }
12745 }
12747 /*
12748 * quote_qualified_identifier - Quote a possibly-qualified identifier
12749 *
12750 * Return a name of the form qualifier.ident, or just ident if qualifier
12751 * is NULL, quoting each component if necessary. The result is palloc'd.
12752 */
12756 {
12757 StringInfoData buf;
12764 }
12766 /*
12767 * get_relation_name
12768 * Get the unqualified name of a relation specified by OID
12769 *
12770 * This differs from the underlying get_rel_name() function in that it will
12771 * throw error instead of silently returning NULL if the OID is bad.
12772 */
12775 {
12781 }
12783 /*
12784 * generate_relation_name
12785 * Compute the name to display for a relation specified by OID
12786 *
12787 * The result includes all necessary quoting and schema-prefixing.
12788 *
12789 * If namespaces isn't NIL, it must be a list of deparse_namespace nodes.
12790 * We will forcibly qualify the relation name if it equals any CTE name
12791 * visible in the namespace list.
12792 */
12795 {
12796 HeapTuple tp;
12797 Form_pg_class reltup;
12810 /* Check for conflicting CTE name */
12813 {
12818 {
12822 {
12825 }
12826 }
12829 }
12831 /* Otherwise, qualify the name if not visible in search path */
12837 else
12845 }
12847 /*
12848 * generate_qualified_relation_name
12849 * Compute the name to display for a relation specified by OID
12850 *
12851 * As above, but unconditionally schema-qualify the name.
12852 */
12855 {
12856 HeapTuple tp;
12857 Form_pg_class reltup;
12878 }
12880 /*
12881 * generate_function_name
12882 * Compute the name to display for a function specified by OID,
12883 * given that it is being called with the specified actual arg names and
12884 * types. (Those matter because of ambiguous-function resolution rules.)
12885 *
12886 * If we're dealing with a potentially variadic function (in practice, this
12887 * means a FuncExpr or Aggref, not some other way of calling a function), then
12888 * has_variadic must specify whether variadic arguments have been merged,
12889 * and *use_variadic_p will be set to indicate whether to print VARIADIC in
12890 * the output. For non-FuncExpr cases, has_variadic should be false and
12891 * use_variadic_p can be NULL.
12892 *
12893 * inGroupBy must be true if we're deparsing a GROUP BY clause.
12894 *
12895 * The result includes all necessary quoting and schema-prefixing.
12896 */
12901 {
12903 HeapTuple proctup;
12904 Form_pg_proc procform;
12908 FuncDetailCode p_result;
12909 Oid p_funcid;
12910 Oid p_rettype;
12913 Oid p_vatype;
12923 /*
12924 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
12925 * qualification of some function names within GROUP BY.
12926 */
12928 {
12931 }
12933 /*
12934 * Determine whether VARIADIC should be printed. We must do this first
12935 * since it affects the lookup rules in func_get_detail().
12936 *
12937 * We always print VARIADIC if the function has a merged variadic-array
12938 * argument. Note that this is always the case for functions taking a
12939 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
12940 * and printed the array elements as separate arguments, the call could
12941 * match a newer non-VARIADIC function.
12942 */
12944 {
12945 /* Parser should not have set funcvariadic unless fn is variadic */
12949 }
12950 else
12951 {
12954 }
12956 /*
12957 * The idea here is to schema-qualify only if the parser would fail to
12958 * resolve the correct function given the unqualified func name with the
12959 * specified argtypes and VARIADIC flag. But if we already decided to
12960 * force qualification, then we can skip the lookup and pretend we didn't
12961 * find it.
12962 */
12970 else
12971 {
12974 }
12981 else
12989 }
12991 /*
12992 * generate_operator_name
12993 * Compute the name to display for an operator specified by OID,
12994 * given that it is being called with the specified actual arg types.
12995 * (Arg types matter because of ambiguous-operator resolution rules.
12996 * Pass InvalidOid for unused arg of a unary operator.)
12997 *
12998 * The result includes all necessary quoting and schema-prefixing,
12999 * plus the OPERATOR() decoration needed to use a qualified operator name
13000 * in an expression.
13001 */
13004 {
13005 StringInfoData buf;
13006 HeapTuple opertup;
13007 Form_pg_operator operform;
13010 Operator p_result;
13020 /*
13021 * The idea here is to schema-qualify only if the parser would fail to
13022 * resolve the correct operator given the unqualified op name with the
13023 * specified argtypes.
13024 */
13026 {
13039 }
13043 else
13044 {
13047 }
13060 }
13062 /*
13063 * generate_operator_clause --- generate a binary-operator WHERE clause
13064 *
13065 * This is used for internally-generated-and-executed SQL queries, where
13066 * precision is essential and readability is secondary. The basic
13067 * requirement is to append "leftop op rightop" to buf, where leftop and
13068 * rightop are given as strings and are assumed to yield types leftoptype
13069 * and rightoptype; the operator is identified by OID. The complexity
13070 * comes from needing to be sure that the parser will select the desired
13071 * operator when the query is parsed. We always name the operator using
13072 * OPERATOR(schema.op) syntax, so as to avoid search-path uncertainties.
13073 * We have to emit casts too, if either input isn't already the input type
13074 * of the operator; else we are at the mercy of the parser's heuristics for
13075 * ambiguous-operator resolution. The caller must ensure that leftop and
13076 * rightop are suitable arguments for a cast operation; it's best to insert
13077 * parentheses if they aren't just variables or parameters.
13078 */
13079 void
13082 Oid opoid,
13084 {
13085 HeapTuple opertup;
13086 Form_pg_operator operform;
13109 }
13111 /*
13112 * Add a cast specification to buf. We spell out the type name the hard way,
13113 * intentionally not using format_type_be(). This is to avoid corner cases
13114 * for CHARACTER, BIT, and perhaps other types, where specifying the type
13115 * using SQL-standard syntax results in undesirable data truncation. By
13116 * doing it this way we can be certain that the cast will have default (-1)
13117 * target typmod.
13118 */
13119 static void
13121 {
13122 HeapTuple typetup;
13123 Form_pg_type typform;
13139 }
13141 /*
13142 * generate_qualified_type_name
13143 * Compute the name to display for a type specified by OID
13144 *
13145 * This is different from format_type_be() in that we unconditionally
13146 * schema-qualify the name. That also means no special syntax for
13147 * SQL-standard type names ... although in current usage, this should
13148 * only get used for domains, so such cases wouldn't occur anyway.
13149 */
13152 {
13153 HeapTuple tp;
13154 Form_pg_type typtup;
13175 }
13177 /*
13178 * generate_collation_name
13179 * Compute the name to display for a collation specified by OID
13180 *
13181 * The result includes all necessary quoting and schema-prefixing.
13182 */
13185 {
13186 HeapTuple tp;
13187 Form_pg_collation colltup;
13200 else
13208 }
13210 /*
13211 * Given a C string, produce a TEXT datum.
13212 *
13213 * We assume that the input was palloc'd and may be freed.
13214 */
13217 {
13223 }
13225 /*
13226 * Generate a C string representing a relation options from text[] datum.
13227 */
13228 static void
13230 {
13239 {
13245 /*
13246 * Each array element should have the form name=value. If the "=" is
13247 * missing for some reason, treat it like an empty value.
13248 */
13252 {
13255 }
13256 else
13263 /*
13264 * In general we need to quote the value; but to avoid unnecessary
13265 * clutter, do not quote if it is an identifier that would not need
13266 * quoting. (We could also allow numbers, but that is a bit trickier
13267 * than it looks --- for example, are leading zeroes significant? We
13268 * don't want to assume very much here about what custom reloptions
13269 * might mean.)
13270 */
13273 else
13277 }
13278 }
13280 /*
13281 * Generate a C string representing a relation's reloptions, or NULL if none.
13282 */
13285 {
13287 HeapTuple tuple;
13288 Datum reloptions;
13298 {
13299 StringInfoData buf;
13305 }
13310 }
13312 /*
13313 * get_range_partbound_string
13314 * A C string representation of one range partition bound
13315 */
13318 {
13319 deparse_context context;
13330 {
13339 else
13340 {
13344 }
13346 }
13350 }