| blob | db2182fd905acd41665a8dfcd0b50b8a3f51ff5f |
1 /*-------------------------------------------------------------------------
2 *
3 * ruleutils.c
4 * Functions to convert stored expressions/querytrees back to
5 * source text
6 *
7 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 *
11 * IDENTIFICATION
12 * $PostgreSQL$
13 *
14 *-------------------------------------------------------------------------
15 */
18 #include <unistd.h>
19 #include <fcntl.h>
60 /* ----------
61 * Pretty formatting constants
62 * ----------
63 */
65 /* Indent counts */
66 #define PRETTYINDENT_STD 8
67 #define PRETTYINDENT_JOIN 13
68 #define PRETTYINDENT_JOIN_ON (PRETTYINDENT_JOIN-PRETTYINDENT_STD)
69 #define PRETTYINDENT_VAR 4
71 /* Pretty flags */
72 #define PRETTYFLAG_PAREN 1
73 #define PRETTYFLAG_INDENT 2
75 /* macro to test if pretty action needed */
76 #define PRETTY_PAREN(context) ((context)->prettyFlags & PRETTYFLAG_PAREN)
77 #define PRETTY_INDENT(context) ((context)->prettyFlags & PRETTYFLAG_INDENT)
80 /* ----------
81 * Local data types
82 * ----------
83 */
85 /* Context info needed for invoking a recursive querytree display routine */
87 {
97 /*
98 * Each level of query context around a subtree needs a level of Var namespace.
99 * A Var having varlevelsup=N refers to the N'th item (counting from 0) in
100 * the current context's namespaces list.
101 *
102 * The rangetable is the list of actual RTEs from the query tree, and the
103 * cte list is the list of actual CTEs.
104 *
105 * For deparsing plan trees, we provide for outer and inner subplan nodes.
106 * The tlists of these nodes are used to resolve OUTER and INNER varnos.
107 * Also, in the plan-tree case we don't have access to the parse-time CTE
108 * list, so we need a list of subplans instead.
109 */
111 {
120 /* ----------
121 * Global data
122 * ----------
123 */
127 static const char *query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";
130 /* ----------
131 * Local functions
132 *
133 * Most of these functions used to use fixed-size buffers to build their
134 * results. Now, they take an (already initialized) StringInfo object
135 * as a parameter, and append their text output to its contents.
136 * ----------
137 */
143 StringInfo buf);
163 TupleDesc resultDesc);
169 TupleDesc resultDesc);
171 TupleDesc resultDesc);
174 TupleDesc resultDesc);
216 StringInfo buf);
230 /* ----------
231 * get_ruledef - Do it all and return a text
232 * that could be used as a statement
233 * to recreate the rule
234 * ----------
235 */
236 Datum
238 {
242 }
245 Datum
247 {
254 }
259 {
263 HeapTuple ruletup;
264 TupleDesc rulettc;
265 StringInfoData buf;
267 /*
268 * Do this first so that string is alloc'd in outer context not SPI's.
269 */
272 /*
273 * Connect to SPI manager
274 */
278 /*
279 * On the first call prepare the plan to lookup pg_rewrite. We read
280 * pg_rewrite over the SPI manager instead of using the syscache to be
281 * checked for read access on pg_rewrite.
282 */
284 {
286 SPIPlanPtr plan;
293 }
295 /*
296 * Get the pg_rewrite tuple for this rule
297 */
305 else
306 {
307 /*
308 * Get the rule's definition and put it into executor's memory
309 */
313 }
315 /*
316 * Disconnect from SPI manager
317 */
322 }
325 /* ----------
326 * get_viewdef - Mainly the same thing, but we
327 * only return the SELECT part of a view
328 * ----------
329 */
330 Datum
332 {
333 /* By OID */
337 }
340 Datum
342 {
343 /* By OID */
350 }
352 Datum
354 {
355 /* By qualified name */
358 Oid viewoid;
364 }
367 Datum
369 {
370 /* By qualified name */
375 Oid viewoid;
382 }
384 /*
385 * Common code for by-OID and by-name variants of pg_get_viewdef
386 */
389 {
393 HeapTuple ruletup;
394 TupleDesc rulettc;
395 StringInfoData buf;
397 /*
398 * Do this first so that string is alloc'd in outer context not SPI's.
399 */
402 /*
403 * Connect to SPI manager
404 */
408 /*
409 * On the first call prepare the plan to lookup pg_rewrite. We read
410 * pg_rewrite over the SPI manager instead of using the syscache to be
411 * checked for read access on pg_rewrite.
412 */
414 {
416 SPIPlanPtr plan;
424 }
426 /*
427 * Get the pg_rewrite tuple for the view's SELECT rule
428 */
438 else
439 {
440 /*
441 * Get the rule's definition and put it into executor's memory
442 */
446 }
448 /*
449 * Disconnect from SPI manager
450 */
455 }
457 /* ----------
458 * get_triggerdef - Get the definition of a trigger
459 * ----------
460 */
461 Datum
463 {
465 HeapTuple ht_trig;
466 Form_pg_trigger trigrec;
467 StringInfoData buf;
468 Relation tgrel;
470 SysScanDesc tgscan;
474 /*
475 * Fetch the pg_trigger tuple by the Oid of the trigger
476 */
480 ObjectIdAttributeNumber,
494 /*
495 * Start the trigger definition. Note that the trigger's name should never
496 * be schema-qualified, but the trigger rel's name may be.
497 */
507 else
510 {
512 findx++;
513 }
515 {
518 else
520 findx++;
521 }
523 {
526 else
528 }
530 {
533 else
535 }
540 {
544 NIL));
550 else
553 }
557 else
564 {
571 Anum_pg_trigger_tgargs,
577 {
581 /* advance p to next string embedded in tgargs */
583 p++;
584 p++;
585 }
586 }
588 /* We deliberately do not put semi-colon at end */
591 /* Clean up */
597 }
599 /* ----------
600 * get_indexdef - Get the definition of an index
601 *
602 * In the extended version, there is a colno argument as well as pretty bool.
603 * if colno == 0, we want a complete index definition.
604 * if colno > 0, we only want the Nth index key's variable or expression.
605 *
606 * Note that the SQL-function versions of this omit any info about the
607 * index tablespace; this is intentional because pg_dump wants it that way.
608 * However pg_get_indexdef_string() includes index tablespace if not default.
609 * ----------
610 */
611 Datum
613 {
618 }
620 Datum
622 {
631 }
633 /* Internal version that returns a palloc'd C string */
636 {
638 }
643 {
644 HeapTuple ht_idx;
645 HeapTuple ht_idxrel;
646 HeapTuple ht_am;
647 Form_pg_index idxrec;
648 Form_pg_class idxrelrec;
649 Form_pg_am amrec;
653 Oid indrelid;
655 Oid keycoltype;
656 Datum indclassDatum;
657 Datum indoptionDatum;
661 StringInfoData buf;
665 /*
666 * Fetch the pg_index tuple by the Oid of the index
667 */
678 /* Must get indclass and indoption the hard way */
688 /*
689 * Fetch the pg_class tuple of the index relation
690 */
698 /*
699 * Fetch the pg_am tuple of the index' access method
700 */
709 /*
710 * Get the index expressions, if any. (NOTE: we do not use the relcache
711 * versions of the expressions and predicate, because we want to display
712 * non-const-folded expressions.)
713 */
715 {
716 Datum exprsDatum;
726 }
727 else
734 /*
735 * Start the index definition. Note that the index's name should never be
736 * schema-qualified, but the indexed rel's name may be.
737 */
747 /*
748 * Report the indexed attributes
749 */
752 {
761 {
762 /* Simple index column */
769 }
770 else
771 {
772 /* expressional index */
779 /* Deparse */
783 {
784 /* Need parens if it's not a bare function call */
788 else
790 }
792 }
794 /* Provide decoration only in the colno=0 case */
796 {
797 /* Add the operator class name, if not default */
800 /* Add options if relevant */
802 {
803 /* if it supports sort ordering, report DESC and NULLS opts */
805 {
807 /* NULLS FIRST is the default in this case */
810 }
811 else
812 {
815 }
816 }
817 }
818 }
821 {
824 /*
825 * If it has options, append "WITH (options)"
826 */
829 {
832 }
834 /*
835 * If it's in a nondefault tablespace, say so, but only if requested
836 */
838 {
839 Oid tblspc;
845 }
847 /*
848 * If it's a partial index, decompile and append the predicate
849 */
851 {
853 Datum predDatum;
857 /* Convert text string to node tree */
865 /* Deparse */
869 }
870 }
872 /* Clean up */
878 }
881 /*
882 * pg_get_constraintdef
883 *
884 * Returns the definition for the constraint, ie, everything that needs to
885 * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
886 */
887 Datum
889 {
894 }
896 Datum
898 {
906 }
908 /* Internal version that returns a palloc'd C string */
911 {
913 }
918 {
919 HeapTuple tup;
920 Form_pg_constraint conForm;
921 StringInfoData buf;
933 {
937 }
940 {
942 {
943 Datum val;
947 /* Start off the constraint definition */
950 /* Fetch and build referencing-column list */
955 constraintId);
959 /* add foreign relation name */
962 NIL));
964 /* Fetch and build referenced-column list */
969 constraintId);
975 /* Add match type */
977 {
992 }
995 /* Add ON UPDATE and ON DELETE clauses, if needed */
997 {
1018 }
1023 {
1044 }
1054 }
1057 {
1058 Datum val;
1060 Oid indexId;
1062 /* Start off the constraint definition */
1065 else
1068 /* Fetch and build target column list */
1073 constraintId);
1081 /* XXX why do we only print these bits if fullCommand? */
1083 {
1085 Oid tblspc;
1088 {
1091 }
1097 }
1100 }
1102 {
1103 Datum val;
1110 /* Fetch constraint expression in parsetree form */
1115 constraintId);
1120 /* Set up deparsing context for Var nodes in constraint */
1122 {
1123 /* relation constraint */
1126 }
1127 else
1128 {
1129 /* domain constraint --- can't have Vars */
1131 }
1136 /*
1137 * Now emit the constraint definition. There are cases where
1138 * the constraint expression will be fully parenthesized and
1139 * we don't need the outer parens ... but there are other
1140 * cases where we do need 'em. Be conservative for now.
1141 *
1142 * Note that simply checking for leading '(' and trailing ')'
1143 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
1144 */
1148 }
1152 }
1154 /* Cleanup */
1158 }
1161 /*
1162 * Convert an int16[] Datum into a comma-separated list of column names
1163 * for the indicated relation; append the list to buf.
1164 */
1165 static void
1167 StringInfo buf)
1168 {
1173 /* Extract data from array of int16 */
1179 {
1186 else
1188 }
1189 }
1192 /* ----------
1193 * get_expr - Decompile an expression tree
1194 *
1195 * Input: an expression tree in nodeToString form, and a relation OID
1196 *
1197 * Output: reverse-listed expression
1198 *
1199 * Currently, the expression can only refer to a single relation, namely
1200 * the one specified by the second parameter. This is sufficient for
1201 * partial indexes, column default expressions, etc. We also support
1202 * Var-free expressions, for which the OID can be InvalidOid.
1203 * ----------
1204 */
1205 Datum
1207 {
1213 {
1214 /* Get the name for the relation */
1217 /*
1218 * If the OID isn't actually valid, don't throw an error, just return
1219 * NULL. This is a bit questionable, but it's what we've done
1220 * historically, and it can help avoid unwanted failures when
1221 * examining catalog entries for just-deleted relations.
1222 */
1225 }
1226 else
1230 }
1232 Datum
1234 {
1244 {
1245 /* Get the name for the relation */
1247 /* See notes above */
1250 }
1251 else
1255 }
1259 {
1265 /* Convert input TEXT object to C string */
1268 /* Convert expression to node tree */
1273 /* Prepare deparse context if needed */
1276 else
1279 /* Deparse */
1284 }
1287 /* ----------
1288 * get_userbyid - Get a user name by roleid and
1289 * fallback to 'unknown (OID=n)'
1290 * ----------
1291 */
1292 Datum
1294 {
1296 Name result;
1297 HeapTuple roletup;
1298 Form_pg_authid role_rec;
1300 /*
1301 * Allocate space for the result
1302 */
1306 /*
1307 * Get the pg_authid entry and print the result
1308 */
1313 {
1317 }
1318 else
1322 }
1325 /*
1326 * pg_get_serial_sequence
1327 * Get the name of the sequence used by a serial column,
1328 * formatted suitably for passing to setval, nextval or currval.
1329 * First parameter is not treated as double-quoted, second parameter
1330 * is --- see documentation for reason.
1331 */
1332 Datum
1334 {
1338 Oid tableOid;
1340 AttrNumber attnum;
1342 Relation depRel;
1344 SysScanDesc scan;
1345 HeapTuple tup;
1347 /* Get the OID of the table */
1351 /* Get the number of the column */
1361 /* Search the dependency table for the dependent sequence */
1365 Anum_pg_depend_refclassid,
1369 Anum_pg_depend_refobjid,
1373 Anum_pg_depend_refobjsubid,
1381 {
1384 /*
1385 * We assume any auto dependency of a sequence on a column must be
1386 * what we are looking for. (We need the relkind test because indexes
1387 * can also have auto dependencies on columns.)
1388 */
1393 {
1396 }
1397 }
1403 {
1404 HeapTuple classtup;
1405 Form_pg_class classtuple;
1409 /* Get the sequence's pg_class entry */
1417 /* Get the namespace */
1423 /* And construct the result string */
1430 }
1433 }
1436 /*
1437 * pg_get_functiondef
1438 * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
1439 * the specified function.
1440 */
1441 Datum
1443 {
1445 StringInfoData buf;
1446 StringInfoData dq;
1447 HeapTuple proctup;
1448 HeapTuple langtup;
1449 Form_pg_proc proc;
1450 Form_pg_language lang;
1451 Datum tmp;
1456 float4 procost;
1461 /* Look up the function */
1475 /* Need its pg_language tuple for the language name */
1483 /*
1484 * We always qualify the function name, to ensure the right function
1485 * gets replaced.
1486 */
1496 /* Emit some miscellaneous options on one line */
1502 {
1511 }
1517 /* This code for the default cost and rows should match functioncmds.c */
1521 else
1532 /* Emit any proconfig options, one per line */
1535 {
1544 {
1545 Datum d;
1554 {
1566 /*
1567 * Some GUC variable names are 'LIST' type and hence must not
1568 * be quoted.
1569 */
1573 else
1576 }
1577 }
1578 }
1580 /* And finally the function definition ... */
1585 {
1588 }
1595 /*
1596 * We always use dollar quoting. Figure out a suitable delimiter.
1597 *
1598 * Since the user is likely to be editing the function body string,
1599 * we shouldn't use a short delimiter that he might easily create a
1600 * conflict with. Hence prefer "$function$", but extend if needed.
1601 */
1618 }
1620 /*
1621 * pg_get_function_arguments
1622 * Get a nicely-formatted list of arguments for a function.
1623 * This is everything that would go between the parentheses in
1624 * CREATE FUNCTION.
1625 */
1626 Datum
1628 {
1630 StringInfoData buf;
1631 HeapTuple proctup;
1646 }
1648 /*
1649 * pg_get_function_identity_arguments
1650 * Get a formatted list of arguments for a function.
1651 * This is everything that would go between the parentheses in
1652 * ALTER FUNCTION, etc. In particular, don't print defaults.
1653 */
1654 Datum
1656 {
1658 StringInfoData buf;
1659 HeapTuple proctup;
1674 }
1676 /*
1677 * pg_get_function_result
1678 * Get a nicely-formatted version of the result type of a function.
1679 * This is what would appear after RETURNS in CREATE FUNCTION.
1680 */
1681 Datum
1683 {
1685 StringInfoData buf;
1686 HeapTuple proctup;
1701 }
1703 /*
1704 * Guts of pg_get_function_result: append the function's return type
1705 * to the specified buffer.
1706 */
1707 static void
1709 {
1712 StringInfoData rbuf;
1717 {
1718 /* It might be a table function; try to print the arguments */
1723 else
1725 }
1728 {
1729 /* Not a table function, so do the normal thing */
1733 }
1736 }
1738 /*
1739 * Common code for pg_get_function_arguments and pg_get_function_result:
1740 * append the desired subset of arguments to buf. We print only TABLE
1741 * arguments when print_table_args is true, and all the others when it's false.
1742 * We print argument defaults only if print_defaults is true.
1743 * Function return value is the number of arguments printed.
1744 */
1745 static int
1748 {
1765 {
1766 Datum proargdefaults;
1770 Anum_pg_proc_proargdefaults,
1773 {
1782 /* nlackdefaults counts only *input* arguments lacking defaults */
1784 }
1785 }
1790 {
1798 {
1824 }
1838 {
1847 }
1848 argsprinted++;
1849 }
1852 }
1855 /*
1856 * deparse_expression - General utility for deparsing expressions
1857 *
1858 * calls deparse_expression_pretty with all prettyPrinting disabled
1859 */
1863 {
1866 }
1868 /* ----------
1869 * deparse_expression_pretty - General utility for deparsing expressions
1870 *
1871 * expr is the node tree to be deparsed. It must be a transformed expression
1872 * tree (ie, not the raw output of gram.y).
1873 *
1874 * dpcontext is a list of deparse_namespace nodes representing the context
1875 * for interpreting Vars in the node tree.
1876 *
1877 * forceprefix is TRUE to force all Vars to be prefixed with their table names.
1878 *
1879 * showimplicit is TRUE to force all implicit casts to be shown explicitly.
1880 *
1881 * tries to pretty up the output according to prettyFlags and startIndent.
1882 *
1883 * The result is a palloc'd string.
1884 * ----------
1885 */
1890 {
1891 StringInfoData buf;
1892 deparse_context context;
1906 }
1908 /* ----------
1909 * deparse_context_for - Build deparse context for a single relation
1910 *
1911 * Given the reference name (alias) and OID of a relation, build deparsing
1912 * context for an expression referencing only that relation (as varno 1,
1913 * varlevelsup 0). This is sufficient for many uses of deparse_expression.
1914 * ----------
1915 */
1916 List *
1918 {
1924 /* Build a minimal RTE for the rel */
1932 /* Build one-element rtable */
1938 /* Return a one-deep namespace stack */
1940 }
1942 /*
1943 * deparse_context_for_plan - Build deparse context for a plan node
1944 *
1945 * When deparsing an expression in a Plan tree, we might have to resolve
1946 * OUTER or INNER references. To do this, the caller must provide the
1947 * parent Plan node. In the normal case of a join plan node, OUTER and
1948 * INNER references can be resolved by drilling down into the left and
1949 * right child plans. A special case is that a nestloop inner indexscan
1950 * might have OUTER Vars, but the outer side of the join is not a child
1951 * plan node. To handle such cases the outer plan node must be passed
1952 * separately. (Pass NULL for outer_plan otherwise.)
1953 *
1954 * Note: plan and outer_plan really ought to be declared as "Plan *", but
1955 * we use "Node *" to avoid having to include plannodes.h in builtins.h.
1956 *
1957 * The plan's rangetable list must also be passed. We actually prefer to use
1958 * the rangetable to resolve simple Vars, but the plan inputs are necessary
1959 * for Vars that reference expressions computed in subplan target lists.
1960 *
1961 * We also need the list of subplans associated with the Plan tree; this
1962 * is for resolving references to CTE subplans.
1963 */
1964 List *
1967 {
1976 /*
1977 * Set up outer_plan and inner_plan from the Plan node (this includes
1978 * various special cases for particular Plan types).
1979 */
1982 /*
1983 * If outer_plan is given, that overrides whatever we got from the plan.
1984 */
1988 /* Return a one-deep namespace stack */
1990 }
1992 /* ----------
1993 * make_ruledef - reconstruct the CREATE RULE command
1994 * for a given pg_rewrite tuple
1995 * ----------
1996 */
1997 static void
2000 {
2003 Oid ev_class;
2004 int2 ev_attr;
2010 Datum dat;
2013 /*
2014 * Get the attribute values from the rules tuple
2015 */
2041 /* these could be nulls */
2050 /*
2051 * Build the rules definition text
2052 */
2058 else
2061 /* The event the rule is fired for */
2063 {
2086 }
2088 /* The relation the rule is fired on */
2093 ev_attr)));
2095 /* If the rule has an event qualification, add it */
2099 {
2102 deparse_context context;
2103 deparse_namespace dpns;
2111 /*
2112 * We need to make a context for recognizing any Vars in the qual
2113 * (which can only be references to OLD and NEW). Use the rtable of
2114 * the first query in the action list for this purpose.
2115 */
2118 /*
2119 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
2120 * into the SELECT, and that's what we need to look at. (Ugly kluge
2121 * ... try to fix this when we redesign querytrees.)
2122 */
2125 /* Must acquire locks right away; see notes in get_query_def() */
2141 }
2145 /* The INSTEAD keyword (if so) */
2149 /* Finally the rules actions */
2151 {
2157 {
2162 else
2164 }
2166 }
2168 {
2170 }
2171 else
2172 {
2178 }
2179 }
2182 /* ----------
2183 * make_viewdef - reconstruct the SELECT part of a
2184 * view rewrite rule
2185 * ----------
2186 */
2187 static void
2190 {
2193 Oid ev_class;
2194 int2 ev_attr;
2199 Relation ev_relation;
2203 /*
2204 * Get the attribute values from the rules tuple
2205 */
2227 {
2230 }
2236 {
2239 }
2248 }
2251 /* ----------
2252 * get_query_def - Parse back one query parsetree
2253 *
2254 * If resultDesc is not NULL, then it is the output tuple descriptor for
2255 * the view represented by a SELECT query.
2256 * ----------
2257 */
2258 static void
2261 {
2262 deparse_context context;
2263 deparse_namespace dpns;
2265 /*
2266 * Before we begin to examine the query, acquire locks on referenced
2267 * relations, and fix up deleted columns in JOIN RTEs. This ensures
2268 * consistent results. Note we assume it's OK to scribble on the passed
2269 * querytree!
2270 */
2288 {
2317 }
2318 }
2320 /* ----------
2321 * get_values_def - Parse back a VALUES list
2322 * ----------
2323 */
2324 static void
2326 {
2334 {
2341 else
2346 {
2351 else
2354 /*
2355 * Strip any top-level nodes representing indirection assignments,
2356 * then print the result.
2357 */
2360 }
2362 }
2363 }
2365 /* ----------
2366 * get_with_clause - Parse back a WITH clause
2367 * ----------
2368 */
2369 static void
2371 {
2380 {
2383 }
2387 else
2390 {
2396 {
2402 {
2405 else
2409 }
2411 }
2421 }
2424 {
2427 }
2428 else
2430 }
2432 /* ----------
2433 * get_select_query_def - Parse back a SELECT parsetree
2434 * ----------
2435 */
2436 static void
2438 TupleDesc resultDesc)
2439 {
2446 /* Insert the WITH clause if given */
2449 /* Set up context for possible window functions */
2455 /*
2456 * If the Query node has a setOperations tree, then it's the top level of
2457 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
2458 * fields are interesting in the top query itself.
2459 */
2461 {
2463 /* ORDER BY clauses must be simple in this case */
2465 }
2466 else
2467 {
2470 }
2472 /* Add the ORDER BY clause if given */
2474 {
2479 }
2481 /* Add the LIMIT clause if given */
2483 {
2487 }
2489 {
2495 else
2497 }
2499 /* Add FOR UPDATE/SHARE clauses if present */
2501 {
2508 else
2515 }
2519 }
2521 static void
2523 TupleDesc resultDesc)
2524 {
2530 {
2533 }
2535 /*
2536 * If the query looks like SELECT * FROM (VALUES ...), then print just the
2537 * VALUES part. This reverses what transformValuesClause() did at parse
2538 * time. If the jointree contains just a single VALUES RTE, we assume
2539 * this case applies (without looking at the targetlist...)
2540 */
2542 {
2546 {
2550 {
2553 }
2554 }
2555 }
2557 /*
2558 * Build up the query string - first we say SELECT
2559 */
2562 /* Add the DISTINCT clause if given */
2564 {
2566 {
2570 {
2577 }
2579 }
2580 else
2582 }
2584 /* Then we tell what to select (the targetlist) */
2587 /* Add the FROM clause if needed */
2590 /* Add the WHERE clause if given */
2592 {
2596 }
2598 /* Add the GROUP BY clause if given */
2600 {
2605 {
2612 }
2613 }
2615 /* Add the HAVING clause if given */
2617 {
2621 }
2623 /* Add the WINDOW clause if needed */
2626 }
2628 /* ----------
2629 * get_target_list - Parse back a SELECT target list
2630 *
2631 * This is also used for RETURNING lists in INSERT/UPDATE/DELETE.
2632 * ----------
2633 */
2634 static void
2636 TupleDesc resultDesc)
2637 {
2646 {
2656 colno++;
2658 /*
2659 * We special-case Var nodes rather than using get_rule_expr. This is
2660 * needed because get_rule_expr will display a whole-row Var as
2661 * "foo.*", which is the preferred notation in most contexts, but at
2662 * the top level of a SELECT list it's not right (the parser will
2663 * expand that notation into multiple columns, yielding behavior
2664 * different from a whole-row Var). We want just "foo", instead.
2665 */
2667 {
2669 }
2670 else
2671 {
2673 /* We'll show the AS name unless it's this: */
2675 }
2677 /*
2678 * Figure out what the result column should be called. In the context
2679 * of a view, use the view's tuple descriptor (so as to pick up the
2680 * effects of any column RENAME that's been done on the view).
2681 * Otherwise, just use what we can find in the TLE.
2682 */
2685 else
2688 /* Show AS unless the column's name is correct as-is */
2690 {
2693 }
2694 }
2695 }
2697 static void
2699 TupleDesc resultDesc)
2700 {
2705 {
2712 /* Need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y */
2724 }
2726 {
2730 {
2733 }
2735 /*
2736 * We force parens whenever nesting two SetOperationStmts. There are
2737 * some cases in which parens are needed around a leaf query too, but
2738 * those are more easily handled at the next level down (see code
2739 * above).
2740 */
2752 {
2768 }
2785 }
2786 else
2787 {
2790 }
2791 }
2793 /*
2794 * Display a sort/group clause.
2795 *
2796 * Also returns the expression tree, so caller need not find it again.
2797 */
2801 {
2809 /*
2810 * Use column-number form if requested by caller. Otherwise, if
2811 * expression is a constant, force it to be dumped with an explicit
2812 * cast as decoration --- this is because a simple integer constant
2813 * is ambiguous (and will be misinterpreted by findTargetlistEntry())
2814 * if we dump it without any decoration. Otherwise, just dump the
2815 * expression normally.
2816 */
2818 {
2821 }
2824 else
2828 }
2830 /*
2831 * Display an ORDER BY list.
2832 */
2833 static void
2836 {
2843 {
2846 Oid sortcoltype;
2853 /* See whether operator is default < or > for datatype */
2857 {
2858 /* ASC is default, so emit nothing for it */
2861 }
2863 {
2865 /* DESC defaults to NULLS FIRST */
2868 }
2869 else
2870 {
2873 sortcoltype,
2874 sortcoltype));
2875 /* be specific to eliminate ambiguity */
2878 else
2880 }
2882 }
2883 }
2885 /*
2886 * Display a WINDOW clause.
2887 *
2888 * Note that the windowClause list might contain only anonymous window
2889 * specifications, in which case we should print nothing here.
2890 */
2891 static void
2893 {
2900 {
2909 else
2917 }
2918 }
2920 /*
2921 * Display a window definition
2922 */
2923 static void
2926 {
2934 {
2937 }
2938 /* partition clauses are always inherited, so only print if no refname */
2940 {
2946 {
2953 }
2955 }
2956 /* print ordering clause only if not inherited */
2958 {
2964 }
2965 /* framing clause is never inherited, so print unless it's default */
2967 {
2974 else
2982 else
2985 {
2991 else
2993 }
2994 /* we will now have a trailing space; remove it */
2996 }
2998 }
3000 /* ----------
3001 * get_insert_query_def - Parse back an INSERT parsetree
3002 * ----------
3003 */
3004 static void
3006 {
3016 /*
3017 * If it's an INSERT ... SELECT or VALUES (...), (...), ... there will be
3018 * a single RTE for the SELECT or VALUES.
3019 */
3021 {
3025 {
3029 }
3032 {
3036 }
3037 }
3041 /*
3042 * Start the query with INSERT INTO relname
3043 */
3048 {
3051 }
3055 /*
3056 * Add the insert-column-names list. To handle indirection properly, we
3057 * need to look for indirection nodes in the top targetlist (if it's
3058 * INSERT ... SELECT or INSERT ... single VALUES), or in the first
3059 * expression list of the VALUES RTE (if it's INSERT ... multi VALUES). We
3060 * assume that all the expression lists will have similar indirection in
3061 * the latter case.
3062 */
3065 else
3070 {
3079 /*
3080 * Put out name of target column; look in the catalogs, not at
3081 * tle->resname, since resname will fail to track RENAME.
3082 */
3087 /*
3088 * Print any indirection needed (subfields or subscripts), and strip
3089 * off the top-level nodes representing the indirection assignments.
3090 */
3092 {
3093 /* we discard the stripped expression in this case */
3096 }
3097 else
3098 {
3099 /* we keep a list of the stripped expressions in this case */
3103 }
3104 }
3108 {
3109 /* Add the SELECT */
3112 }
3114 {
3115 /* A WITH clause is possible here */
3117 /* Add the multi-VALUES expression lists */
3119 }
3120 else
3121 {
3122 /* A WITH clause is possible here */
3124 /* Add the single-VALUES expression list */
3129 }
3131 /* Add RETURNING if present */
3133 {
3137 }
3138 }
3141 /* ----------
3142 * get_update_query_def - Parse back an UPDATE parsetree
3143 * ----------
3144 */
3145 static void
3147 {
3153 /*
3154 * Start the query with UPDATE relname SET
3155 */
3159 {
3162 }
3171 /* Add the comma separated list of 'attname = value' */
3174 {
3184 /*
3185 * Put out name of target column; look in the catalogs, not at
3186 * tle->resname, since resname will fail to track RENAME.
3187 */
3192 /*
3193 * Print any indirection needed (subfields or subscripts), and strip
3194 * off the top-level nodes representing the indirection assignments.
3195 */
3201 }
3203 /* Add the FROM clause if needed */
3206 /* Add a WHERE clause if given */
3208 {
3212 }
3214 /* Add RETURNING if present */
3216 {
3220 }
3221 }
3224 /* ----------
3225 * get_delete_query_def - Parse back a DELETE parsetree
3226 * ----------
3227 */
3228 static void
3230 {
3234 /*
3235 * Start the query with DELETE FROM relname
3236 */
3240 {
3243 }
3251 /* Add the USING clause if given */
3254 /* Add a WHERE clause if given */
3256 {
3260 }
3262 /* Add RETURNING if present */
3264 {
3268 }
3269 }
3272 /* ----------
3273 * get_utility_query_def - Parse back a UTILITY parsetree
3274 * ----------
3275 */
3276 static void
3278 {
3282 {
3289 }
3290 else
3291 {
3292 /* Currently only NOTIFY utility commands can appear in rules */
3294 }
3295 }
3298 /*
3299 * push_plan: set up deparse_namespace to recurse into the tlist of a subplan
3300 *
3301 * When expanding an OUTER or INNER reference, we must push new outer/inner
3302 * subplans in case the referenced expression itself uses OUTER/INNER. We
3303 * modify the top stack entry in-place to avoid affecting levelsup issues
3304 * (although in a Plan tree there really shouldn't be any).
3305 *
3306 * Caller must save and restore outer_plan and inner_plan around this.
3307 *
3308 * We also use this to initialize the fields during deparse_context_for_plan.
3309 */
3310 static void
3312 {
3313 /*
3314 * We special-case Append to pretend that the first child plan is the
3315 * OUTER referent; otherwise normal.
3316 */
3319 else
3322 /*
3323 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
3324 * use OUTER because that could someday conflict with the normal meaning.)
3325 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
3326 */
3330 {
3335 else
3337 }
3338 else
3340 }
3343 /*
3344 * Display a Var appropriately.
3345 *
3346 * In some cases (currently only when recursing into an unnamed join)
3347 * the Var's varlevelsup has to be interpreted with respect to a context
3348 * above the current one; levelsup indicates the offset.
3349 *
3350 * If showstar is TRUE, whole-row Vars are displayed as "foo.*";
3351 * if FALSE, merely as "foo".
3352 *
3353 * Returns the attname of the Var, or NULL if not determinable.
3354 */
3357 {
3360 AttrNumber attnum;
3367 /* Find appropriate nesting depth */
3373 netlevelsup);
3375 /*
3376 * Try to find the relevant RTE in this rtable. In a plan tree, it's
3377 * likely that varno is OUTER or INNER, in which case we must dig down
3378 * into the subplans.
3379 */
3381 {
3384 }
3386 {
3400 /*
3401 * Force parentheses because our caller probably assumed a Var is a
3402 * simple expression.
3403 */
3413 }
3415 {
3429 /*
3430 * Force parentheses because our caller probably assumed a Var is a
3431 * simple expression.
3432 */
3442 }
3443 else
3444 {
3447 }
3449 /* Identify names to use */
3453 /* Exceptions occur only if the RTE is alias-less */
3455 {
3457 {
3458 /*
3459 * It's possible that use of the bare refname would find another
3460 * more-closely-nested RTE, or be ambiguous, in which case we need
3461 * to specify the schemaname to avoid these errors.
3462 */
3465 }
3467 {
3468 /*
3469 * If it's an unnamed join, look at the expansion of the alias
3470 * variable. If it's a simple reference to one of the input vars
3471 * then recursively print the name of that var, instead. (This
3472 * allows correct decompiling of cases where there are identically
3473 * named columns on both sides of the join.) When it's not a
3474 * simple reference, we have to just print the unqualified
3475 * variable name (this can only happen with columns that were
3476 * merged by USING or NATURAL clauses).
3477 *
3478 * This wouldn't work in decompiling plan trees, because we don't
3479 * store joinaliasvars lists after planning; but a plan tree
3480 * should never contain a join alias variable.
3481 */
3485 {
3490 {
3493 }
3494 }
3495 /* Unnamed join has neither schemaname nor refname */
3497 }
3498 }
3502 else
3506 {
3515 else
3520 }
3527 }
3530 /*
3531 * Get the name of a field of an expression of composite type.
3532 *
3533 * This is fairly straightforward except for the case of a Var of type RECORD.
3534 * Since no actual table or view column is allowed to have type RECORD, such
3535 * a Var must refer to a JOIN or FUNCTION RTE or to a subquery output. We
3536 * drill down to find the ultimate defining expression and attempt to infer
3537 * the field name from it. We ereport if we can't determine the name.
3538 *
3539 * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
3540 */
3544 {
3546 AttrNumber attnum;
3549 TupleDesc tupleDesc;
3552 /*
3553 * If it's a RowExpr that was expanded from a whole-row Var, use the
3554 * column names attached to it.
3555 */
3557 {
3562 }
3564 /*
3565 * If it's a Var of type RECORD, we have to find what the Var refers to;
3566 * if not, we can use get_expr_result_type. If that fails, we try
3567 * lookup_rowtype_tupdesc, which will probably fail too, but will ereport
3568 * an acceptable message.
3569 */
3572 {
3577 /* Got the tupdesc, so we can extract the field name */
3580 }
3582 /* Find appropriate nesting depth */
3588 netlevelsup);
3590 /*
3591 * Try to find the relevant RTE in this rtable. In a plan tree, it's
3592 * likely that varno is OUTER or INNER, in which case we must dig down
3593 * into the subplans.
3594 */
3596 {
3599 }
3601 {
3622 }
3624 {
3645 }
3646 else
3647 {
3650 }
3653 {
3654 /* Var is whole-row reference to RTE, so select the right field */
3656 }
3658 /*
3659 * This part has essentially the same logic as the parser's
3660 * expandRecordVariable() function, but we are dealing with a different
3661 * representation of the input context, and we only need one field name
3662 * not a TupleDesc. Also, we need special cases for finding subquery
3663 * and CTE subplans when deparsing Plan trees.
3664 */
3668 {
3673 /*
3674 * This case should not occur: a column of a table or values list
3675 * shouldn't have type RECORD. Fall through and fail (most
3676 * likely) at the bottom.
3677 */
3680 /* Subselect-in-FROM: examine sub-select's output expr */
3681 {
3683 {
3685 attnum);
3692 {
3693 /*
3694 * Recurse into the sub-select to see what its Var
3695 * refers to. We have to build an additional level of
3696 * namespace to keep in step with varlevelsup in the
3697 * subselect.
3698 */
3699 deparse_namespace mydpns;
3717 }
3718 /* else fall through to inspect the expression */
3719 }
3720 else
3721 {
3722 /*
3723 * We're deparsing a Plan tree so we don't have complete
3724 * RTE entries (in particular, rte->subquery is NULL).
3725 * But the only place we'd see a Var directly referencing
3726 * a SUBQUERY RTE is in a SubqueryScan plan node, and we
3727 * can look into the child plan's tlist instead.
3728 */
3738 attnum);
3741 attnum);
3753 }
3754 }
3757 /* Join RTE --- recursively inspect the alias variable */
3765 context);
3766 /* else fall through to inspect the expression */
3770 /*
3771 * We couldn't get here unless a function is declared with one of
3772 * its result columns as RECORD, which is not allowed.
3773 */
3776 /* CTE reference: examine subquery's output expr */
3777 {
3779 Index ctelevelsup;
3782 /*
3783 * Try to find the referenced CTE using the namespace stack.
3784 */
3788 else
3789 {
3795 {
3799 }
3800 }
3802 {
3805 attnum);
3812 {
3813 /*
3814 * Recurse into the CTE to see what its Var refers
3815 * to. We have to build an additional level of
3816 * namespace to keep in step with varlevelsup in the
3817 * CTE. Furthermore it could be an outer CTE, so
3818 * we may have to delete some levels of namespace.
3819 */
3822 deparse_namespace mydpns;
3831 ctelevelsup);
3840 }
3841 /* else fall through to inspect the expression */
3842 }
3843 else
3844 {
3845 /*
3846 * We're deparsing a Plan tree so we don't have a CTE
3847 * list. But the only place we'd see a Var directly
3848 * referencing a CTE RTE is in a CteScan plan node, and
3849 * we can look into the subplan's tlist instead.
3850 */
3860 attnum);
3863 attnum);
3875 }
3876 }
3878 }
3880 /*
3881 * We now have an expression we can't expand any more, so see if
3882 * get_expr_result_type() can do anything with it. If not, pass to
3883 * lookup_rowtype_tupdesc() which will probably fail, but will give an
3884 * appropriate error message while failing.
3885 */
3890 /* Got the tupdesc, so we can extract the field name */
3893 }
3896 /*
3897 * find_rte_by_refname - look up an RTE by refname in a deparse context
3898 *
3899 * Returns NULL if there is no matching RTE or the refname is ambiguous.
3900 *
3901 * NOTE: this code is not really correct since it does not take account of
3902 * the fact that not all the RTEs in a rangetable may be visible from the
3903 * point where a Var reference appears. For the purposes we need, however,
3904 * the only consequence of a false match is that we might stick a schema
3905 * qualifier on a Var that doesn't really need it. So it seems close
3906 * enough.
3907 */
3910 {
3915 {
3920 {
3924 {
3928 }
3929 }
3932 }
3934 }
3937 /*
3938 * get_simple_binary_op_name
3939 *
3940 * helper function for isSimpleNode
3941 * will return single char binary operator name, or NULL if it's not
3942 */
3945 {
3949 {
3950 /* binary operator */
3958 }
3960 }
3963 /*
3964 * isSimpleNode - check if given node is simple (doesn't need parenthesizing)
3965 *
3966 * true : simple in the context of parent node's type
3967 * false : not simple
3968 */
3969 static bool
3971 {
3976 {
3983 /* single words: always simple */
3996 /* function-like: name(..) or name[..] */
3999 /* CASE keywords act as parentheses */
4005 /*
4006 * appears simple since . has top precedence, unless parent is
4007 * T_FieldSelect itself!
4008 */
4013 /*
4014 * treat like FieldSelect (probably doesn't matter)
4015 */
4019 /* maybe simple, check args */
4036 {
4037 /* depends on parent node type; needs further checking */
4039 {
4051 /* We know only the basic operators + - and * / % */
4072 /*
4073 * Operators are same priority --- can skip parens only if
4074 * we have (a - b) - c, not a - (b - c).
4075 */
4080 }
4081 /* else do the same stuff as for T_SubLink et al. */
4082 /* FALL THROUGH */
4083 }
4090 {
4092 {
4093 /* special handling for casts */
4100 }
4115 }
4119 {
4122 {
4123 BoolExprType type;
4124 BoolExprType parentType;
4129 {
4139 }
4140 }
4143 {
4144 /* special handling for casts */
4151 }
4165 }
4169 }
4170 /* those we don't know: in dubio complexo */
4172 }
4175 /*
4176 * appendStringInfoSpaces - append spaces to buffer
4177 */
4178 static void
4180 {
4183 }
4185 /*
4186 * appendContextKeyword - append a keyword to buffer
4187 *
4188 * If prettyPrint is enabled, perform a line break, and adjust indentation.
4189 * Otherwise, just append the keyword.
4190 */
4191 static void
4194 {
4196 {
4207 }
4208 else
4210 }
4212 /*
4213 * get_rule_expr_paren - deparse expr using get_rule_expr,
4214 * embracing the string with parentheses if necessary for prettyPrint.
4215 *
4216 * Never embrace if prettyFlags=0, because it's done in the calling node.
4217 *
4218 * Any node that does *not* embrace its argument node by sql syntax (with
4219 * parentheses, non-operator keywords like CASE/WHEN/ON, or comma etc) should
4220 * use get_rule_expr_paren instead of get_rule_expr so parentheses can be
4221 * added.
4222 */
4223 static void
4226 {
4239 }
4242 /* ----------
4243 * get_rule_expr - Parse back an expression
4244 *
4245 * Note: showimplicit determines whether we display any implicit cast that
4246 * is present at the top of the expression tree. It is a passed argument,
4247 * not a field of the context struct, because we change the value as we
4248 * recurse down into the expression. In general we suppress implicit casts
4249 * when the result type is known with certainty (eg, the arguments of an
4250 * OR must be boolean). We display implicit casts for arguments of functions
4251 * and operators, since this is needed to be certain that the same function
4252 * or operator will be chosen when the expression is re-parsed.
4253 * ----------
4254 */
4255 static void
4258 {
4264 /*
4265 * Each level of get_rule_expr must emit an indivisible term
4266 * (parenthesized if necessary) to ensure result is reparsed into the same
4267 * expression tree. The only exception is that when the input is a List,
4268 * we emit the component items comma-separated with no surrounding
4269 * decoration; this is convenient for most callers.
4270 */
4272 {
4294 {
4298 /*
4299 * Parenthesize the argument unless it's a simple Var or a
4300 * FieldSelect. (In particular, if it's another ArrayRef, we
4301 * *must* parenthesize to avoid confusion.)
4302 */
4312 /*
4313 * Array assignment nodes should have been handled in
4314 * processIndirection().
4315 */
4318 }
4330 {
4343 }
4347 {
4365 }
4369 {
4375 {
4382 {
4387 }
4398 {
4403 }
4421 }
4422 }
4430 {
4433 /*
4434 * We cannot see an already-planned subplan in rule deparsing,
4435 * only while EXPLAINing a query plan. We don't try to
4436 * reconstruct the original SQL, just reference the subplan
4437 * that appears elsewhere in EXPLAIN's result.
4438 */
4441 else
4443 }
4447 {
4451 /* As above, this can only happen during EXPLAIN */
4454 {
4460 else
4464 }
4466 }
4470 {
4477 /*
4478 * Parenthesize the argument unless it's an ArrayRef or
4479 * another FieldSelect. Note in particular that it would be
4480 * WRONG to not parenthesize a Var argument; simplicity is not
4481 * the issue here, having the right number of names is.
4482 */
4490 /*
4491 * Get and print the field name.
4492 */
4496 }
4501 /*
4502 * We shouldn't see FieldStore here; it should have been stripped
4503 * off by processIndirection().
4504 */
4509 {
4515 {
4516 /* don't show the implicit cast */
4518 }
4519 else
4520 {
4524 node);
4525 }
4526 }
4530 {
4536 {
4537 /* don't show the implicit cast */
4539 }
4540 else
4541 {
4545 node);
4546 }
4547 }
4551 {
4557 {
4558 /* don't show the implicit cast */
4560 }
4561 else
4562 {
4566 node);
4567 }
4568 }
4572 {
4578 {
4579 /* don't show the implicit cast */
4581 }
4582 else
4583 {
4586 node);
4587 }
4588 }
4592 {
4599 {
4602 }
4604 {
4613 {
4614 /*
4615 * The parser should have produced WHEN clauses of the
4616 * form "CaseTestExpr = RHS"; we want to show just the
4617 * RHS. If the user wrote something silly like "CASE
4618 * boolexpr WHEN TRUE THEN ...", then the optimizer's
4619 * simplify_boolean_equality() may have reduced this
4620 * to just "CaseTestExpr" or "NOT CaseTestExpr", for
4621 * which we have to show "TRUE" or "FALSE". Also,
4622 * depending on context the original CaseTestExpr
4623 * might have been reduced to a Const (but we won't
4624 * see "WHEN Const"). We have also to consider the
4625 * possibility that an implicit coercion was inserted
4626 * between the CaseTestExpr and the operator.
4627 */
4629 {
4640 }
4642 CaseTestExpr))
4645 {
4647 CaseTestExpr));
4649 }
4650 else
4653 }
4654 else
4658 }
4668 }
4672 {
4678 /*
4679 * If the array isn't empty, we assume its elements are
4680 * coerced to the desired type. If it's empty, though, we
4681 * need an explicit coercion to the array type.
4682 */
4686 }
4690 {
4697 /*
4698 * If it's a named type and not RECORD, we may have to skip
4699 * dropped columns and/or claim there are NULLs for added
4700 * columns.
4701 */
4703 {
4706 }
4708 /*
4709 * SQL99 allows "ROW" to be omitted when there is more than
4710 * one column, but for simplicity we always print it.
4711 */
4716 {
4721 {
4725 }
4726 i++;
4727 }
4729 {
4731 {
4733 {
4737 }
4738 i++;
4739 }
4742 }
4747 }
4751 {
4756 /*
4757 * SQL99 allows "ROW" to be omitted when there is more than
4758 * one column, but for simplicity we always print it.
4759 */
4763 {
4769 }
4771 /*
4772 * We assume that the name of the first-column operator will
4773 * do for all the rest too. This is definitely open to
4774 * failure, eg if some but not all operators were renamed
4775 * since the construct was parsed, but there seems no way to
4776 * be perfect.
4777 */
4784 {
4790 }
4792 }
4796 {
4802 }
4806 {
4810 {
4817 }
4820 }
4824 {
4832 {
4856 }
4858 {
4861 else
4863 }
4865 {
4869 }
4871 {
4873 {
4878 }
4880 {
4890 }
4893 }
4895 {
4899 {
4905 /* no extra decoration needed */
4920 else
4935 else
4942 else
4943 {
4945 {
4960 }
4961 }
4966 }
4968 }
4974 else
4976 }
4980 {
4986 }
4990 {
4997 {
5007 }
5010 }
5014 {
5021 {
5043 }
5046 }
5050 {
5056 {
5057 /* don't show the implicit cast */
5059 }
5060 else
5061 {
5065 node);
5066 }
5067 }
5079 {
5085 else
5088 }
5092 {
5098 {
5102 }
5103 }
5109 }
5110 }
5113 /*
5114 * get_oper_expr - Parse back an OpExpr node
5115 */
5116 static void
5118 {
5126 {
5127 /* binary operator */
5137 }
5138 else
5139 {
5140 /* unary operator --- but which side? */
5142 HeapTuple tp;
5143 Form_pg_operator optup;
5152 {
5156 InvalidOid,
5165 InvalidOid));
5169 }
5171 }
5174 }
5176 /*
5177 * get_func_expr - Parse back a FuncExpr node
5178 */
5179 static void
5182 {
5190 /*
5191 * If the function call came from an implicit coercion, then just show the
5192 * first argument --- unless caller wants to see implicit coercions.
5193 */
5195 {
5199 }
5201 /*
5202 * If the function call came from a cast, then show the first argument
5203 * plus an explicit cast operation.
5204 */
5207 {
5210 int32 coercedTypmod;
5212 /* Get the typmod if this is a length-coercion function */
5220 }
5222 /*
5223 * Normal function: display as proname(args). First we need to extract
5224 * the argument datatypes.
5225 */
5232 {
5234 nargs++;
5235 }
5242 {
5248 }
5250 }
5252 /*
5253 * get_agg_expr - Parse back an Aggref node
5254 */
5255 static void
5257 {
5269 {
5271 nargs++;
5272 }
5278 /* aggstar can be set only in zero-argument aggregates */
5281 else
5284 }
5286 /*
5287 * get_windowfunc_expr - Parse back a WindowFunc node
5288 */
5289 static void
5291 {
5303 {
5305 nargs++;
5306 }
5311 /* winstar can be set only in zero-argument aggregates */
5314 else
5319 {
5323 {
5326 else
5329 }
5330 }
5332 {
5336 /*
5337 * In EXPLAIN, we don't have window context information available,
5338 * so we have to settle for this:
5339 */
5341 }
5342 }
5344 /* ----------
5345 * get_coercion_expr
5346 *
5347 * Make a string representation of a value coerced to a specific type
5348 * ----------
5349 */
5350 static void
5354 {
5357 /*
5358 * Since parse_coerce.c doesn't immediately collapse application of
5359 * length-coercion functions to constants, what we'll typically see in
5360 * such cases is a Const with typmod -1 and a length-coercion function
5361 * right above it. Avoid generating redundant output. However, beware of
5362 * suppressing casts when the user actually wrote something like
5363 * 'foo'::text::char(3).
5364 */
5368 {
5369 /* Show the constant without normal ::typename decoration */
5371 }
5372 else
5373 {
5379 }
5382 }
5384 /* ----------
5385 * get_const_expr
5386 *
5387 * Make a string representation of a Const
5388 *
5389 * showtype can be -1 to never show "::typename" decoration, or +1 to always
5390 * show it, or 0 to show it only if the constant wouldn't be assumed to be
5391 * the right type by default.
5392 * ----------
5393 */
5394 static void
5396 {
5398 Oid typoutput;
5405 {
5406 /*
5407 * Always label the type of a NULL constant to prevent misdecisions
5408 * about type when reparsing.
5409 */
5416 }
5424 {
5432 {
5433 /*
5434 * These types are printed without quotes unless they contain
5435 * values that aren't accepted by the scanner unquoted (e.g.,
5436 * 'NaN'). Note that strtod() and friends might accept NaN,
5437 * so we can't use that to test.
5438 *
5439 * In reality we only need to defend against infinity and NaN,
5440 * so we need not get too crazy about pattern matching here.
5441 *
5442 * There is a special-case gotcha: if the constant is signed,
5443 * we need to parenthesize it, else the parser might see a
5444 * leading plus/minus as binding less tightly than adjacent
5445 * operators --- particularly, the cast that we might attach
5446 * below.
5447 */
5449 {
5452 else
5456 }
5457 else
5459 }
5470 else
5477 }
5484 /*
5485 * For showtype == 0, append ::typename unless the constant will be
5486 * implicitly typed as the right type when it is read in.
5487 *
5488 * XXX this code has to be kept in sync with the behavior of the parser,
5489 * especially make_const.
5490 */
5492 {
5496 /* These types can be left unlabeled */
5501 /*
5502 * Float-looking constants will be typed as numeric, but if
5503 * there's a specific typmod we need to show it.
5504 */
5510 }
5515 }
5517 /*
5518 * simple_quote_literal - Format a string as a SQL literal, append to buf
5519 */
5520 static void
5522 {
5525 /*
5526 * We form the string literal according to the prevailing setting
5527 * of standard_conforming_strings; we never use E''. User is
5528 * responsible for making sure result is used correctly.
5529 */
5532 {
5538 }
5540 }
5543 /* ----------
5544 * get_sublink_expr - Parse back a sublink
5545 * ----------
5546 */
5547 static void
5549 {
5557 else
5560 /*
5561 * Note that we print the name of only the first operator, when there are
5562 * multiple combining operators. This is an approximation that could go
5563 * wrong in various scenarios (operators in different schemas, renamed
5564 * operators, etc) but there is not a whole lot we can do about it, since
5565 * the syntax allows only one operator to be shown.
5566 */
5568 {
5570 {
5571 /* single combining operator */
5578 }
5580 {
5581 /* multiple combining operators, = or <> cases */
5588 {
5599 }
5601 }
5603 {
5604 /* multiple combining operators, < <= > >= cases */
5613 }
5614 else
5617 }
5622 {
5630 else
5652 }
5662 else
5664 }
5667 /* ----------
5668 * get_from_clause - Parse back a FROM clause
5669 *
5670 * "prefix" is the keyword that denotes the start of the list of FROM
5671 * elements. It is FROM when used to parse back SELECT and UPDATE, but
5672 * is USING when parsing back DELETE.
5673 * ----------
5674 */
5675 static void
5677 {
5682 /*
5683 * We use the query's jointree as a guide to what to print. However, we
5684 * must ignore auto-added RTEs that are marked not inFromCl. (These can
5685 * only appear at the top level of the jointree, so it's sufficient to
5686 * check here.) This check also ensures we ignore the rule pseudo-RTEs
5687 * for NEW and OLD.
5688 */
5690 {
5694 {
5700 }
5703 {
5707 }
5708 else
5712 }
5713 }
5715 static void
5717 {
5721 {
5727 {
5729 /* Normal relation RTE */
5736 /* Subquery RTE */
5743 /* Function RTE */
5747 /* Values list RTE */
5756 }
5759 {
5763 }
5766 {
5767 /*
5768 * Apparently the rel has been renamed since the rule was made.
5769 * Emit a fake alias clause so that variable references will still
5770 * work. This is not a 100% solution but should work in most
5771 * reasonable situations.
5772 */
5776 }
5778 {
5779 /*
5780 * For a function RTE, always give an alias. This covers possible
5781 * renaming of the function and/or instability of the
5782 * FigureColname rules for things that aren't simple functions.
5783 */
5787 }
5790 {
5792 {
5793 /* Function returning RECORD, reconstruct the columndefs */
5799 context);
5800 }
5801 else
5802 {
5803 /*
5804 * For a function RTE, always emit a complete column alias
5805 * list; this is to protect against possible instability of
5806 * the default column names (eg, from altering parameter
5807 * names).
5808 */
5810 }
5811 }
5812 else
5813 {
5814 /*
5815 * For non-function RTEs, just report whatever the user originally
5816 * gave as column aliases.
5817 */
5819 }
5820 }
5822 {
5836 {
5840 {
5864 }
5865 }
5866 else
5867 {
5869 {
5875 else
5898 }
5899 }
5910 {
5912 {
5917 {
5922 }
5924 }
5926 {
5933 }
5934 }
5938 /* Yes, it's correct to put alias after the right paren ... */
5940 {
5945 context);
5946 }
5947 }
5948 else
5951 }
5953 /*
5954 * get_from_clause_alias - reproduce column alias list
5955 *
5956 * This is tricky because we must ignore dropped columns.
5957 */
5958 static void
5961 {
5964 AttrNumber attnum;
5972 {
5973 attnum++;
5977 {
5980 }
5981 else
5985 }
5988 }
5990 /*
5991 * get_from_clause_coldeflist - reproduce FROM clause coldeflist
5992 *
5993 * The coldeflist is appended immediately (no space) to buf. Caller is
5994 * responsible for ensuring that an alias or AS is present before it.
5995 */
5996 static void
5999 {
6011 {
6013 Oid atttypid;
6014 int32 atttypmod;
6026 i++;
6027 }
6030 }
6032 /*
6033 * get_opclass_name - fetch name of an index operator class
6034 *
6035 * The opclass name is appended (after a space) to buf.
6036 *
6037 * Output is suppressed if the opclass is the default for the given
6038 * actual_datatype. (If you don't want this behavior, just pass
6039 * InvalidOid for actual_datatype.)
6040 */
6041 static void
6043 StringInfo buf)
6044 {
6045 HeapTuple ht_opc;
6046 Form_pg_opclass opcrec;
6059 {
6060 /* Okay, we need the opclass name. Do we need to qualify it? */
6064 else
6065 {
6070 }
6071 }
6073 }
6075 /*
6076 * processIndirection - take care of array and subfield assignment
6077 *
6078 * We strip any top-level FieldStore or assignment ArrayRef nodes that
6079 * appear in the input, and return the subexpression that's to be assigned.
6080 * If printit is true, we also print out the appropriate decoration for the
6081 * base column name (that the caller just printed).
6082 */
6085 {
6089 {
6093 {
6095 Oid typrelid;
6098 /* lookup tuple type */
6104 /*
6105 * Print the field name. Note we assume here that there's only
6106 * one field being assigned to. This is okay in stored rules but
6107 * could be wrong in executable target lists. Presently no
6108 * problem since explain.c doesn't print plan targetlists, but
6109 * someday may have to think of something ...
6110 */
6116 /*
6117 * We ignore arg since it should be an uninteresting reference to
6118 * the target column or subcolumn.
6119 */
6121 }
6123 {
6131 /*
6132 * We ignore refexpr since it should be an uninteresting reference
6133 * to the target column or subcolumn.
6134 */
6136 }
6137 else
6139 }
6142 }
6144 static void
6146 {
6153 {
6156 {
6160 }
6163 }
6164 }
6166 /*
6167 * quote_identifier - Quote an identifier only if needed
6168 *
6169 * When quotes are needed, we palloc the required space; slightly
6170 * space-wasteful but well worth it for notational simplicity.
6171 */
6174 {
6175 /*
6176 * Can avoid quoting if ident starts with a lowercase letter or underscore
6177 * and contains only lowercase letters, digits, and underscores, *and* is
6178 * not any SQL keyword. Otherwise, supply quotes.
6179 */
6186 /*
6187 * would like to use <ctype.h> macros here, but they might yield unwanted
6188 * locale-specific results...
6189 */
6193 {
6199 {
6200 /* okay */
6201 }
6202 else
6203 {
6206 nquotes++;
6207 }
6208 }
6211 {
6212 /*
6213 * Check for keyword. We quote keywords except for unreserved ones.
6214 * (In some cases we could avoid quoting a col_name or type_func_name
6215 * keyword, but it seems much harder than it's worth to tell that.)
6216 *
6217 * Note: ScanKeywordLookup() does case-insensitive comparison, but
6218 * that's fine, since we already know we have all-lower-case.
6219 */
6224 }
6234 {
6240 }
6245 }
6247 /*
6248 * quote_qualified_identifier - Quote a possibly-qualified identifier
6249 *
6250 * Return a name of the form namespace.ident, or just ident if namespace
6251 * is NULL, quoting each component if necessary. The result is palloc'd.
6252 */
6256 {
6257 StringInfoData buf;
6264 }
6266 /*
6267 * generate_relation_name
6268 * Compute the name to display for a relation specified by OID
6269 *
6270 * The result includes all necessary quoting and schema-prefixing.
6271 *
6272 * If namespaces isn't NIL, it must be a list of deparse_namespace nodes.
6273 * We will forcibly qualify the relation name if it equals any CTE name
6274 * visible in the namespace list.
6275 */
6278 {
6279 HeapTuple tp;
6280 Form_pg_class reltup;
6295 /* Check for conflicting CTE name */
6298 {
6303 {
6307 {
6310 }
6311 }
6314 }
6316 /* Otherwise, qualify the name if not visible in search path */
6322 else
6330 }
6332 /*
6333 * generate_function_name
6334 * Compute the name to display for a function specified by OID,
6335 * given that it is being called with the specified actual arg types.
6336 * (Arg types matter because of ambiguous-function resolution rules.)
6337 *
6338 * The result includes all necessary quoting and schema-prefixing. We can
6339 * also pass back an indication of whether the function is variadic.
6340 */
6344 {
6345 HeapTuple proctup;
6346 Form_pg_proc procform;
6350 FuncDetailCode p_result;
6351 Oid p_funcid;
6352 Oid p_rettype;
6365 /*
6366 * The idea here is to schema-qualify only if the parser would fail to
6367 * resolve the correct function given the unqualified func name with the
6368 * specified argtypes.
6369 */
6379 else
6384 /* Check variadic-ness if caller cares */
6386 {
6387 /* "any" variadics are not treated as variadics for listing */
6391 else
6393 }
6398 }
6400 /*
6401 * generate_operator_name
6402 * Compute the name to display for an operator specified by OID,
6403 * given that it is being called with the specified actual arg types.
6404 * (Arg types matter because of ambiguous-operator resolution rules.
6405 * Pass InvalidOid for unused arg of a unary operator.)
6406 *
6407 * The result includes all necessary quoting and schema-prefixing,
6408 * plus the OPERATOR() decoration needed to use a qualified operator name
6409 * in an expression.
6410 */
6413 {
6414 StringInfoData buf;
6415 HeapTuple opertup;
6416 Form_pg_operator operform;
6419 Operator p_result;
6431 /*
6432 * The idea here is to schema-qualify only if the parser would fail to
6433 * resolve the correct operator given the unqualified op name with the
6434 * specified argtypes.
6435 */
6437 {
6454 }
6458 else
6459 {
6462 }
6475 }
6477 /*
6478 * Given a C string, produce a TEXT datum.
6479 *
6480 * We assume that the input was palloc'd and may be freed.
6481 */
6484 {
6490 }
6492 /*
6493 * Generate a C string representing a relation's reloptions, or NULL if none.
6494 */
6497 {
6499 HeapTuple tuple;
6500 Datum reloptions;
6512 {
6513 Datum sep,
6514 txt;
6516 /*
6517 * We want to use array_to_text(reloptions, ', ') --- but
6518 * DirectFunctionCall2(array_to_text) does not work, because
6519 * array_to_text() relies on flinfo to be valid. So use
6520 * OidFunctionCall2.
6521 */
6525 }
6530 }