Loading...
Searching...
No Matches
ruleutils.c File Reference
#include "postgres.h"#include <ctype.h>#include <unistd.h>#include <fcntl.h>#include "access/amapi.h"#include "access/htup_details.h"#include "access/relation.h"#include "access/table.h"#include "catalog/pg_aggregate.h"#include "catalog/pg_am.h"#include "catalog/pg_authid.h"#include "catalog/pg_collation.h"#include "catalog/pg_constraint.h"#include "catalog/pg_depend.h"#include "catalog/pg_language.h"#include "catalog/pg_opclass.h"#include "catalog/pg_operator.h"#include "catalog/pg_partitioned_table.h"#include "catalog/pg_proc.h"#include "catalog/pg_statistic_ext.h"#include "catalog/pg_trigger.h"#include "catalog/pg_type.h"#include "commands/defrem.h"#include "commands/tablespace.h"#include "common/keywords.h"#include "executor/spi.h"#include "funcapi.h"#include "mb/pg_wchar.h"#include "miscadmin.h"#include "nodes/makefuncs.h"#include "nodes/nodeFuncs.h"#include "nodes/pathnodes.h"#include "optimizer/optimizer.h"#include "parser/parse_agg.h"#include "parser/parse_func.h"#include "parser/parse_oper.h"#include "parser/parse_relation.h"#include "parser/parser.h"#include "parser/parsetree.h"#include "rewrite/rewriteHandler.h"#include "rewrite/rewriteManip.h"#include "rewrite/rewriteSupport.h"#include "utils/array.h"#include "utils/builtins.h"#include "utils/fmgroids.h"#include "utils/guc.h"#include "utils/hsearch.h"#include "utils/lsyscache.h"#include "utils/partcache.h"#include "utils/rel.h"#include "utils/ruleutils.h"#include "utils/snapmgr.h"#include "utils/syscache.h"#include "utils/typcache.h"#include "utils/varlena.h"#include "utils/xml.h"
Include dependency graph for ruleutils.c:
Go to the source code of this file.
Data Structures | |
| struct | deparse_context |
| struct | deparse_namespace |
| struct | deparse_columns |
| struct | NameHashEntry |
Macros | |
| #define | PRETTYINDENT_STD 8 |
| #define | PRETTYINDENT_JOIN 4 |
| #define | PRETTYINDENT_VAR 4 |
| #define | PRETTYINDENT_LIMIT 40 /* wrap limit */ |
| #define | PRETTYFLAG_PAREN 0x0001 |
| #define | PRETTYFLAG_INDENT 0x0002 |
| #define | PRETTYFLAG_SCHEMA 0x0004 |
| #define | GET_PRETTY_FLAGS(pretty) |
| #define | WRAP_COLUMN_DEFAULT 0 |
| #define | PRETTY_PAREN(context) ((context)->prettyFlags & PRETTYFLAG_PAREN) |
| #define | PRETTY_INDENT(context) ((context)->prettyFlags & PRETTYFLAG_INDENT) |
| #define | PRETTY_SCHEMA(context) ((context)->prettyFlags & PRETTYFLAG_SCHEMA) |
| #define | deparse_columns_fetch(rangetable_index, dpns) ((deparse_columns *) list_nth((dpns)->rtable_columns, (rangetable_index)-1)) |
| #define | only_marker(rte) ((rte)->inh ? "" : "ONLY ") |
Typedefs | |
| typedef void(* | rsv_callback) (Node *node, deparse_context *context, void *callback_arg) |
Variables | |
| static SPIPlanPtr | plan_getrulebyoid = NULL |
| static const char *const | query_getrulebyoid = "SELECT * FROM pg_catalog.pg_rewrite WHERE oid = $1" |
| static SPIPlanPtr | plan_getviewrule = NULL |
| static const char *const | query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2" |
| bool | quote_all_identifiers = false |
Macro Definition Documentation
◆ deparse_columns_fetch
| #define deparse_columns_fetch | ( | rangetable_index, | |
| dpns | |||
| ) | ((deparse_columns *) list_nth((dpns)->rtable_columns, (rangetable_index)-1)) |
Definition at line 312 of file ruleutils.c.
318{
320 int counter; /* Largest addition used so far for name */
321} NameHashEntry;
322
323/* Callback signature for resolve_special_varno() */
325 void *callback_arg);
326
327
328/* ----------
329 * Global data
330 * ----------
331 */
333static const char *const query_getrulebyoid = "SELECT * FROM pg_catalog.pg_rewrite WHERE oid = $1";
335static const char *const query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";
336
337/* GUC parameters */
339
340
341/* ----------
342 * Local functions
343 *
344 * Most of these functions used to use fixed-size buffers to build their
345 * results. Now, they take an (already initialized) StringInfo object
346 * as a parameter, and append their text output to its contents.
347 * ----------
348 */
353 int prettyFlags, int wrapColumn);
362 int prettyFlags, bool missing_ok);
364 bool missing_ok);
368 int prettyFlags, bool missing_ok);
382 List *parentUsing);
411 int prettyFlags);
413 int prettyFlags, int wrapColumn);
423 deparse_context *context,
433 deparse_context *context);
436 deparse_context *context);
443 deparse_context *context);
446 deparse_context *context);
448 deparse_context *context);
450 void *callback_arg);
483 void *callback_arg);
503 deparse_context *context,
511 deparse_context *context);
513 deparse_context *context);
515 deparse_context *context);
517 deparse_context *context);
520 deparse_context *context);
522 deparse_context *context);
533 bool inGroupBy);
543 deparse_context *context,
546 deparse_context *context,
549
550#define only_marker(rte) ((rte)->inh ? "" : "ONLY ")
551
552
553/* ----------
554 * pg_get_ruledef - Do it all and return a text
555 * that could be used as a statement
556 * to recreate the rule
557 * ----------
558 */
559Datum
561{
563 int prettyFlags;
564 char *res;
565
566 prettyFlags = PRETTYFLAG_INDENT;
567
569
571 PG_RETURN_NULL();
572
574}
575
576
577Datum
579{
582 int prettyFlags;
583 char *res;
584
586
588
590 PG_RETURN_NULL();
591
593}
594
595
596static char *
598{
600 char nulls[1];
605
606 /*
607 * Do this first so that string is alloc'd in outer context not SPI's.
608 */
610
611 /*
612 * Connect to SPI manager
613 */
614 SPI_connect();
615
616 /*
617 * On the first call prepare the plan to lookup pg_rewrite. We read
618 * pg_rewrite over the SPI manager instead of using the syscache to be
619 * checked for read access on pg_rewrite.
620 */
622 {
623 Oid argtypes[1];
625
626 argtypes[0] = OIDOID;
632 }
633
634 /*
635 * Get the pg_rewrite tuple for this rule
636 */
638 nulls[0] = ' ';
643 {
644 /*
645 * There is no tuple data available here, just keep the output buffer
646 * empty.
647 */
648 }
649 else
650 {
651 /*
652 * Get the rule's definition and put it into executor's memory
653 */
657 }
658
659 /*
660 * Disconnect from SPI manager
661 */
664
667
669}
670
671
672/* ----------
673 * pg_get_viewdef - Mainly the same thing, but we
674 * only return the SELECT part of a view
675 * ----------
676 */
677Datum
679{
680 /* By OID */
682 int prettyFlags;
683 char *res;
684
685 prettyFlags = PRETTYFLAG_INDENT;
686
688
690 PG_RETURN_NULL();
691
693}
694
695
696Datum
698{
699 /* By OID */
702 int prettyFlags;
703 char *res;
704
706
708
710 PG_RETURN_NULL();
711
713}
714
715Datum
717{
718 /* By OID */
721 int prettyFlags;
722 char *res;
723
724 /* calling this implies we want pretty printing */
726
728
730 PG_RETURN_NULL();
731
733}
734
735Datum
737{
738 /* By qualified name */
740 int prettyFlags;
742 Oid viewoid;
743 char *res;
744
745 prettyFlags = PRETTYFLAG_INDENT;
746
747 /* Look up view name. Can't lock it - we might not have privileges. */
750
752
754 PG_RETURN_NULL();
755
757}
758
759
760Datum
762{
763 /* By qualified name */
766 int prettyFlags;
768 Oid viewoid;
769 char *res;
770
772
773 /* Look up view name. Can't lock it - we might not have privileges. */
776
778
780 PG_RETURN_NULL();
781
783}
784
785/*
786 * Common code for by-OID and by-name variants of pg_get_viewdef
787 */
788static char *
790{
792 char nulls[2];
797
798 /*
799 * Do this first so that string is alloc'd in outer context not SPI's.
800 */
802
803 /*
804 * Connect to SPI manager
805 */
806 SPI_connect();
807
808 /*
809 * On the first call prepare the plan to lookup pg_rewrite. We read
810 * pg_rewrite over the SPI manager instead of using the syscache to be
811 * checked for read access on pg_rewrite.
812 */
814 {
815 Oid argtypes[2];
817
818 argtypes[0] = OIDOID;
819 argtypes[1] = NAMEOID;
825 }
826
827 /*
828 * Get the pg_rewrite tuple for the view's SELECT rule
829 */
832 nulls[0] = ' ';
833 nulls[1] = ' ';
838 {
839 /*
840 * There is no tuple data available here, just keep the output buffer
841 * empty.
842 */
843 }
844 else
845 {
846 /*
847 * Get the rule's definition and put it into executor's memory
848 */
852 }
853
854 /*
855 * Disconnect from SPI manager
856 */
859
862
864}
865
866/* ----------
867 * pg_get_triggerdef - Get the definition of a trigger
868 * ----------
869 */
870Datum
872{
874 char *res;
875
877
879 PG_RETURN_NULL();
880
882}
883
884Datum
886{
889 char *res;
890
892
894 PG_RETURN_NULL();
895
897}
898
899static char *
901{
909 char *tgname;
910 char *tgoldtable;
911 char *tgnewtable;
913 bool isnull;
914
915 /*
916 * Fetch the pg_trigger tuple by the Oid of the trigger
917 */
919
921 Anum_pg_trigger_oid,
924
927
929
931 {
935 }
936
938
939 /*
940 * Start the trigger definition. Note that the trigger's name should never
941 * be schema-qualified, but the trigger rel's name may be.
942 */
944
948 quote_identifier(tgname));
949
956 else
958
960 {
962 findx++;
963 }
965 {
968 else
970 findx++;
971 }
973 {
976 else
978 findx++;
979 /* tgattr is first var-width field, so OK to access directly */
981 {
983
986 {
988
994 }
995 }
996 }
998 {
1001 else
1003 findx++;
1004 }
1005
1006 /*
1007 * In non-pretty mode, always schema-qualify the target table name for
1008 * safety. In pretty mode, schema-qualify only if not visible.
1009 */
1011 pretty ?
1014
1016 {
1025 else
1027 }
1028
1030 tgrel->rd_att, &isnull);
1031 if (!isnull)
1033 else
1034 tgoldtable = NULL;
1036 tgrel->rd_att, &isnull);
1037 if (!isnull)
1039 else
1040 tgnewtable = NULL;
1042 {
1046 quote_identifier(tgoldtable));
1049 quote_identifier(tgnewtable));
1050 }
1051
1054 else
1056
1057 /* If the trigger has a WHEN qualification, add that */
1059 tgrel->rd_att, &isnull);
1060 if (!isnull)
1061 {
1062 Node *qual;
1063 char relkind;
1064 deparse_context context;
1068
1070
1072
1074
1075 /* Build minimal OLD and NEW RTEs for the rel */
1079 oldrte->relkind = relkind;
1086
1090 newrte->relkind = relkind;
1097
1098 /* Build two-element rtable */
1106
1107 /* Set up context with one-deep namespace stack */
1121
1123
1125 }
1126
1131
1133 {
1134 char *p;
1136
1138 tgrel->rd_att, &isnull);
1139 if (isnull)
1143 {
1147 /* advance p to next string embedded in tgargs */
1148 while (*p)
1149 p++;
1150 p++;
1151 }
1152 }
1153
1154 /* We deliberately do not put semi-colon at end */
1156
1157 /* Clean up */
1159
1161
1163}
1164
1165/* ----------
1166 * pg_get_indexdef - Get the definition of an index
1167 *
1168 * In the extended version, there is a colno argument as well as pretty bool.
1169 * if colno == 0, we want a complete index definition.
1170 * if colno > 0, we only want the Nth index key's variable or expression.
1171 *
1172 * Note that the SQL-function versions of this omit any info about the
1173 * index tablespace; this is intentional because pg_dump wants it that way.
1174 * However pg_get_indexdef_string() includes the index tablespace.
1175 * ----------
1176 */
1177Datum
1179{
1181 int prettyFlags;
1182 char *res;
1183
1184 prettyFlags = PRETTYFLAG_INDENT;
1185
1187 false, false,
1188 false, false,
1189 prettyFlags, true);
1190
1192 PG_RETURN_NULL();
1193
1195}
1196
1197Datum
1199{
1203 int prettyFlags;
1204 char *res;
1205
1207
1209 colno != 0, false,
1210 false, false,
1211 prettyFlags, true);
1212
1214 PG_RETURN_NULL();
1215
1217}
1218
1219/*
1220 * Internal version for use by ALTER TABLE.
1221 * Includes a tablespace clause in the result.
1222 * Returns a palloc'd C string; no pretty-printing.
1223 */
1224char *
1226{
1228 false, false,
1229 true, true,
1230 0, false);
1231}
1232
1233/* Internal version that just reports the key-column definitions */
1234char *
1236{
1237 int prettyFlags;
1238
1240
1242 true, true,
1243 false, false,
1244 prettyFlags, false);
1245}
1246
1247/* Internal version, extensible with flags to control its behavior */
1248char *
1250{
1253 int prettyFlags;
1254
1256
1259 false, false,
1260 prettyFlags, false);
1261}
1262
1263/*
1264 * Internal workhorse to decompile an index definition.
1265 *
1266 * This is now used for exclusion constraints as well: if excludeOps is not
1267 * NULL then it points to an array of exclusion operator OIDs.
1268 */
1269static char *
1274 int prettyFlags, bool missing_ok)
1275{
1276 /* might want a separate isConstraint parameter later */
1287 List *context;
1289 int keyno;
1299
1300 /*
1301 * Fetch the pg_index tuple by the Oid of the index
1302 */
1305 {
1306 if (missing_ok)
1309 }
1311
1314
1315 /* Must get indcollation, indclass, and indoption the hard way */
1317 Anum_pg_index_indcollation);
1319
1321 Anum_pg_index_indclass);
1323
1325 Anum_pg_index_indoption);
1327
1328 /*
1329 * Fetch the pg_class tuple of the index relation
1330 */
1335
1336 /*
1337 * Fetch the pg_am tuple of the index' access method
1338 */
1342 idxrelrec->relam);
1344
1345 /* Fetch the index AM's API struct */
1347
1348 /*
1349 * Get the index expressions, if any. (NOTE: we do not use the relcache
1350 * versions of the expressions and predicate, because we want to display
1351 * non-const-folded expressions.)
1352 */
1354 {
1357
1359 Anum_pg_index_indexprs);
1363 }
1364 else
1366
1368
1370
1371 /*
1372 * Start the index definition. Note that the index's name should never be
1373 * schema-qualified, but the indexed rel's name may be.
1374 */
1376
1378 {
1385 (prettyFlags & PRETTYFLAG_SCHEMA) ?
1389 else /* currently, must be EXCLUDE constraint */
1392 }
1393
1394 /*
1395 * Report the indexed attributes
1396 */
1399 {
1403
1404 /*
1405 * Ignore non-key attributes if told to.
1406 */
1408 break;
1409
1410 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1412 {
1415 }
1416
1417 if (!colno)
1420
1422 {
1423 /* Simple index column */
1426
1428 if (!colno || colno == keyno + 1)
1432 &keycolcollation);
1433 }
1434 else
1435 {
1436 /* expressional index */
1438
1443 /* Deparse */
1445 prettyFlags, 0);
1446 if (!colno || colno == keyno + 1)
1447 {
1448 /* Need parens if it's not a bare function call */
1451 else
1453 }
1456 }
1457
1458 /* Print additional decoration for (selected) key columns */
1460 (!colno || colno == keyno + 1))
1461 {
1466
1467 /* Add collation, if not default for column */
1471
1472 /* Add the operator class name, if not default */
1475
1477 {
1481 }
1482
1483 /* Add options if relevant */
1485 {
1486 /* if it supports sort ordering, report DESC and NULLS opts */
1488 {
1490 /* NULLS FIRST is the default in this case */
1493 }
1494 else
1495 {
1498 }
1499 }
1500
1501 /* Add the exclusion operator if relevant */
1505 keycoltype,
1506 keycoltype));
1507 }
1508 }
1509
1511 {
1513
1516
1517 /*
1518 * If it has options, append "WITH (options)"
1519 */
1522 {
1525 }
1526
1527 /*
1528 * Print tablespace, but only if requested
1529 */
1531 {
1533
1536 {
1541 }
1542 }
1543
1544 /*
1545 * If it's a partial index, decompile and append the predicate
1546 */
1548 {
1549 Node *node;
1552
1553 /* Convert text string to node tree */
1555 Anum_pg_index_indpred);
1559
1560 /* Deparse */
1562 prettyFlags, 0);
1565 else
1567 }
1568 }
1569
1570 /* Clean up */
1574
1576}
1577
1578/* ----------
1579 * pg_get_querydef
1580 *
1581 * Public entry point to deparse one query parsetree.
1582 * The pretty flags are determined by GET_PRETTY_FLAGS(pretty).
1583 *
1584 * The result is a palloc'd C string.
1585 * ----------
1586 */
1587char *
1589{
1591 int prettyFlags;
1592
1594
1596
1598 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
1599
1601}
1602
1603/*
1604 * pg_get_statisticsobjdef
1605 * Get the definition of an extended statistics object
1606 */
1607Datum
1609{
1611 char *res;
1612
1614
1616 PG_RETURN_NULL();
1617
1619}
1620
1621/*
1622 * Internal version for use by ALTER TABLE.
1623 * Returns a palloc'd C string; no pretty-printing.
1624 */
1625char *
1627{
1629}
1630
1631/*
1632 * pg_get_statisticsobjdef_columns
1633 * Get columns and expressions for an extended statistics object
1634 */
1635Datum
1637{
1639 char *res;
1640
1642
1644 PG_RETURN_NULL();
1645
1647}
1648
1649/*
1650 * Internal workhorse to decompile an extended statistics object.
1651 */
1652static char *
1654{
1658 int colno;
1660 ArrayType *arr;
1661 char *enabled;
1662 Datum datum;
1667 List *context;
1671 int ncolumns;
1672
1674
1676 {
1677 if (missing_ok)
1680 }
1681
1682 /* has the statistics expressions? */
1684
1686
1687 /*
1688 * Get the statistics expressions, if any. (NOTE: we do not use the
1689 * relcache versions of the expressions, because we want to display
1690 * non-const-folded expressions.)
1691 */
1693 {
1696
1702 }
1703 else
1704 exprs = NIL;
1705
1706 /* count the number of columns (attributes and expressions) */
1708
1710
1712 {
1717
1718 /*
1719 * Decode the stxkind column so that we know which stats types to
1720 * print.
1721 */
1724 arr = DatumGetArrayTypeP(datum);
1726 ARR_HASNULL(arr) ||
1730
1734
1736 {
1743
1744 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
1745 }
1746
1747 /*
1748 * If any option is disabled, then we'll need to append the types
1749 * clause to show which options are enabled. We omit the types clause
1750 * on purpose when all options are enabled, so a pg_dump/pg_restore
1751 * will create all statistics types on a newer postgres version, if
1752 * the statistics had all options enabled on the original version.
1753 *
1754 * But if the statistics is defined on just a single column, it has to
1755 * be an expression statistics. In that case we don't need to specify
1756 * kinds.
1757 */
1759 (ncolumns > 1))
1760 {
1762
1764
1766 {
1769 }
1770
1772 {
1775 }
1776
1779
1781 }
1782
1784 }
1785
1786 /* decode simple column references */
1788 {
1791
1792 if (colno > 0)
1794
1796
1798 }
1799
1801 statextrec->stxrelid);
1802
1804 {
1808
1810 prettyFlags, 0);
1811
1812 if (colno > 0)
1814
1815 /* Need parens if it's not a bare function call */
1818 else
1820
1821 colno++;
1822 }
1823
1827
1829
1831}
1832
1833/*
1834 * Generate text array of expressions for statistics object.
1835 */
1836Datum
1838{
1842 Datum datum;
1843 List *context;
1847 char *tmp;
1849
1851
1853 PG_RETURN_NULL();
1854
1855 /* Does the stats object have expressions? */
1857
1858 /* no expressions? we're done */
1860 {
1862 PG_RETURN_NULL();
1863 }
1864
1866
1867 /*
1868 * Get the statistics expressions, and deparse them into text values.
1869 */
1872 tmp = TextDatumGetCString(datum);
1874 pfree(tmp);
1875
1877 statextrec->stxrelid);
1878
1880 {
1884
1886 prettyFlags, 0);
1887
1888 astate = accumArrayResult(astate,
1890 false,
1891 TEXTOID,
1892 CurrentMemoryContext);
1893 }
1894
1896
1898}
1899
1900/*
1901 * pg_get_partkeydef
1902 *
1903 * Returns the partition key specification, ie, the following:
1904 *
1905 * { RANGE | LIST | HASH } (column opt_collation opt_opclass [, ...])
1906 */
1907Datum
1909{
1911 char *res;
1912
1914
1916 PG_RETURN_NULL();
1917
1919}
1920
1921/* Internal version that just reports the column definitions */
1922char *
1924{
1925 int prettyFlags;
1926
1928
1930}
1931
1932/*
1933 * Internal workhorse to decompile a partition key definition.
1934 */
1935static char *
1938{
1940 HeapTuple tuple;
1942 oidvector *partcollation;
1943 List *partexprs;
1945 List *context;
1946 Datum datum;
1948 int keyno;
1951
1954 {
1955 if (missing_ok)
1958 }
1959
1961
1963
1964 /* Must get partclass and partcollation the hard way */
1968
1972
1973
1974 /*
1975 * Get the expressions, if any. (NOTE: we do not use the relcache
1976 * versions of the expressions, because we want to display
1977 * non-const-folded expressions.)
1978 */
1980 {
1983
1988
1992
1994 }
1995 else
1996 partexprs = NIL;
1997
2000
2002
2004 {
2008 break;
2012 break;
2016 break;
2017 default:
2020 }
2021
2026 {
2031
2035 {
2036 /* Simple attribute reference */
2039
2044 &keycolcollation);
2045 }
2046 else
2047 {
2048 /* Expression */
2050
2055
2056 /* Deparse */
2058 prettyFlags, 0);
2059 /* Need parens if it's not a bare function call */
2062 else
2064
2067 }
2068
2069 /* Add collation, if not default for column */
2074
2075 /* Add the operator class name, if not default */
2078 }
2079
2082
2083 /* Clean up */
2084 ReleaseSysCache(tuple);
2085
2087}
2088
2089/*
2090 * pg_get_partition_constraintdef
2091 *
2092 * Returns partition constraint expression as a string for the input relation
2093 */
2094Datum
2096{
2099 int prettyFlags;
2100 List *context;
2102
2104
2105 /* Quick exit if no partition constraint */
2107 PG_RETURN_NULL();
2108
2109 /*
2110 * Deparse and return the constraint expression.
2111 */
2112 prettyFlags = PRETTYFLAG_INDENT;
2115 false, prettyFlags, 0);
2116
2118}
2119
2120/*
2121 * pg_get_partconstrdef_string
2122 *
2123 * Returns the partition constraint as a C-string for the input relation, with
2124 * the given alias. No pretty-printing.
2125 */
2126char *
2128{
2130 List *context;
2131
2134
2136}
2137
2138/*
2139 * pg_get_constraintdef
2140 *
2141 * Returns the definition for the constraint, ie, everything that needs to
2142 * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
2143 */
2144Datum
2146{
2148 int prettyFlags;
2149 char *res;
2150
2151 prettyFlags = PRETTYFLAG_INDENT;
2152
2154
2156 PG_RETURN_NULL();
2157
2159}
2160
2161Datum
2163{
2166 int prettyFlags;
2167 char *res;
2168
2170
2172
2174 PG_RETURN_NULL();
2175
2177}
2178
2179/*
2180 * Internal version that returns a full ALTER TABLE ... ADD CONSTRAINT command
2181 */
2182char *
2184{
2186}
2187
2188/*
2189 * As of 9.4, we now use an MVCC snapshot for this.
2190 */
2191static char *
2193 int prettyFlags, bool missing_ok)
2194{
2198 SysScanDesc scandesc;
2202
2204 Anum_pg_constraint_oid,
2207
2208 scandesc = systable_beginscan(relation,
2209 ConstraintOidIndexId,
2210 true,
2211 snapshot,
2212 1,
2213 scankey);
2214
2215 /*
2216 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2217 * via SearchSysCache, which works fine.
2218 */
2220
2221 UnregisterSnapshot(snapshot);
2222
2224 {
2225 if (missing_ok)
2226 {
2227 systable_endscan(scandesc);
2230 }
2232 }
2233
2235
2237
2239 {
2241 {
2242 /*
2243 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2244 * constraints, and other types of constraints don't inherit
2245 * anyway so it doesn't matter whether we say ONLY or not. Someday
2246 * we might need to let callers specify whether to put ONLY in the
2247 * command.
2248 */
2252 }
2253 else
2254 {
2255 /* Must be a domain constraint */
2260 }
2261 }
2262
2264 {
2266 {
2268 bool isnull;
2270
2271 /* Start off the constraint definition */
2273
2274 /* Fetch and build referencing-column list */
2276 Anum_pg_constraint_conkey);
2277
2278 /* If it is a temporal foreign key then it uses PERIOD. */
2280
2281 /* add foreign relation name */
2284 NIL));
2285
2286 /* Fetch and build referenced-column list */
2288 Anum_pg_constraint_confkey);
2289
2291
2293
2294 /* Add match type */
2296 {
2298 string = " MATCH FULL";
2299 break;
2301 string = " MATCH PARTIAL";
2302 break;
2304 string = "";
2305 break;
2306 default:
2308 conForm->confmatchtype);
2309 string = ""; /* keep compiler quiet */
2310 break;
2311 }
2313
2314 /* Add ON UPDATE and ON DELETE clauses, if needed */
2316 {
2319 break;
2321 string = "RESTRICT";
2322 break;
2324 string = "CASCADE";
2325 break;
2327 string = "SET NULL";
2328 break;
2330 string = "SET DEFAULT";
2331 break;
2332 default:
2334 conForm->confupdtype);
2336 break;
2337 }
2338 if (string)
2340
2342 {
2345 break;
2347 string = "RESTRICT";
2348 break;
2350 string = "CASCADE";
2351 break;
2353 string = "SET NULL";
2354 break;
2356 string = "SET DEFAULT";
2357 break;
2358 default:
2360 conForm->confdeltype);
2362 break;
2363 }
2364 if (string)
2366
2367 /*
2368 * Add columns specified to SET NULL or SET DEFAULT if
2369 * provided.
2370 */
2372 Anum_pg_constraint_confdelsetcols, &isnull);
2373 if (!isnull)
2374 {
2378 }
2379
2380 break;
2381 }
2384 {
2389
2390 /* Start off the constraint definition */
2393 else
2395
2397
2404
2406
2407 /* Fetch and build target column list */
2409 Anum_pg_constraint_conkey);
2410
2414
2416
2417 /* Build including column list (from pg_index.indkeys) */
2419 Anum_pg_index_indnatts);
2421 {
2422 Datum cols;
2423 Datum *keys;
2424 int nKeys;
2426
2428
2430 Anum_pg_index_indkey);
2431
2433 &keys, NULL, &nKeys);
2434
2436 {
2438
2444 }
2445
2447 }
2449
2450 /* XXX why do we only print these bits if fullCommand? */
2452 {
2455
2457 {
2460 }
2461
2462 /*
2463 * Print the tablespace, unless it's the database default.
2464 * This is to help ALTER TABLE usage of this facility,
2465 * which needs this behavior to recreate exact catalog
2466 * state.
2467 */
2472 }
2473
2474 break;
2475 }
2477 {
2481 Node *expr;
2482 List *context;
2483
2484 /* Fetch constraint expression in parsetree form */
2486 Anum_pg_constraint_conbin);
2487
2490
2491 /* Set up deparsing context for Var nodes in constraint */
2493 {
2494 /* relation constraint */
2496 conForm->conrelid);
2497 }
2498 else
2499 {
2500 /* domain constraint --- can't have Vars */
2501 context = NIL;
2502 }
2503
2505 prettyFlags, 0);
2506
2507 /*
2508 * Now emit the constraint definition, adding NO INHERIT if
2509 * necessary.
2510 *
2511 * There are cases where the constraint expression will be
2512 * fully parenthesized and we don't need the outer parens ...
2513 * but there are other cases where we do need 'em. Be
2514 * conservative for now.
2515 *
2516 * Note that simply checking for leading '(' and trailing ')'
2517 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2518 */
2520 consrc,
2522 break;
2523 }
2525 {
2527 {
2529
2531
2537 }
2539 {
2540 /* conkey is null for domain not-null constraints */
2542 }
2543 break;
2544 }
2545
2547
2548 /*
2549 * There isn't an ALTER TABLE syntax for creating a user-defined
2550 * constraint trigger, but it seems better to print something than
2551 * throw an error; if we throw error then this function couldn't
2552 * safely be applied to all rows of pg_constraint.
2553 */
2555 break;
2557 {
2560 Datum *elems;
2561 int nElems;
2563 Oid *operators;
2564
2565 /* Extract operator OIDs from the pg_constraint tuple */
2567 Anum_pg_constraint_conexclop);
2568
2570 &elems, NULL, &nElems);
2571
2575
2576 /* pg_get_indexdef_worker does the rest */
2577 /* suppress tablespace because pg_dump wants it that way */
2579 pg_get_indexdef_worker(indexOid,
2580 0,
2581 operators,
2582 false,
2583 false,
2584 false,
2585 false,
2586 prettyFlags,
2587 false));
2588 break;
2589 }
2590 default:
2592 break;
2593 }
2594
2599
2600 /* Validated status is irrelevant when the constraint is NOT ENFORCED. */
2605
2606 /* Cleanup */
2607 systable_endscan(scandesc);
2609
2611}
2612
2613
2614/*
2615 * Convert an int16[] Datum into a comma-separated list of column names
2616 * for the indicated relation; append the list to buf. Returns the number
2617 * of keys.
2618 */
2619static int
2622{
2623 Datum *keys;
2624 int nKeys;
2626
2627 /* Extract data from array of int16 */
2629 &keys, NULL, &nKeys);
2630
2632 {
2634
2636
2639 else
2643 }
2644
2645 return nKeys;
2646}
2647
2648
2649/* ----------
2650 * pg_get_expr - Decompile an expression tree
2651 *
2652 * Input: an expression tree in nodeToString form, and a relation OID
2653 *
2654 * Output: reverse-listed expression
2655 *
2656 * Currently, the expression can only refer to a single relation, namely
2657 * the one specified by the second parameter. This is sufficient for
2658 * partial indexes, column default expressions, etc. We also support
2659 * Var-free expressions, for which the OID can be InvalidOid.
2660 *
2661 * If the OID is nonzero but not actually valid, don't throw an error,
2662 * just return NULL. This is a bit questionable, but it's what we've
2663 * done historically, and it can help avoid unwanted failures when
2664 * examining catalog entries for just-deleted relations.
2665 *
2666 * We expect this function to work, or throw a reasonably clean error,
2667 * for any node tree that can appear in a catalog pg_node_tree column.
2668 * Query trees, such as those appearing in pg_rewrite.ev_action, are
2669 * not supported. Nor are expressions in more than one relation, which
2670 * can appear in places like pg_rewrite.ev_qual.
2671 * ----------
2672 */
2673Datum
2675{
2678 text *result;
2679 int prettyFlags;
2680
2681 prettyFlags = PRETTYFLAG_INDENT;
2682
2683 result = pg_get_expr_worker(expr, relid, prettyFlags);
2684 if (result)
2685 PG_RETURN_TEXT_P(result);
2686 else
2687 PG_RETURN_NULL();
2688}
2689
2690Datum
2692{
2696 text *result;
2697 int prettyFlags;
2698
2700
2701 result = pg_get_expr_worker(expr, relid, prettyFlags);
2702 if (result)
2703 PG_RETURN_TEXT_P(result);
2704 else
2705 PG_RETURN_NULL();
2706}
2707
2710{
2711 Node *node;
2713 Relids relids;
2714 List *context;
2718
2719 /* Convert input pg_node_tree (really TEXT) object to C string */
2721
2722 /* Convert expression to node tree */
2724
2726
2727 /*
2728 * Throw error if the input is a querytree rather than an expression tree.
2729 * While we could support queries here, there seems no very good reason
2730 * to. In most such catalog columns, we'll see a List of Query nodes, or
2731 * even nested Lists, so drill down to a non-List node before checking.
2732 */
2733 tst = node;
2740
2741 /*
2742 * Throw error if the expression contains Vars we won't be able to
2743 * deparse.
2744 */
2747 {
2752 }
2753 else
2754 {
2759 }
2760
2761 /*
2762 * Prepare deparse context if needed. If we are deparsing with a relid,
2763 * we need to transiently open and lock the rel, to make sure it won't go
2764 * away underneath us. (set_relation_column_names would lock it anyway,
2765 * so this isn't really introducing any new behavior.)
2766 */
2768 {
2773 }
2774 else
2775 context = NIL;
2776
2777 /* Deparse */
2779 prettyFlags, 0);
2780
2783
2785}
2786
2787
2788/* ----------
2789 * pg_get_userbyid - Get a user name by roleid and
2790 * fallback to 'unknown (OID=n)'
2791 * ----------
2792 */
2793Datum
2795{
2797 Name result;
2800
2801 /*
2802 * Allocate space for the result
2803 */
2806
2807 /*
2808 * Get the pg_authid entry and print the result
2809 */
2812 {
2814 *result = role_rec->rolname;
2816 }
2817 else
2819
2820 PG_RETURN_NAME(result);
2821}
2822
2823
2824/*
2825 * pg_get_serial_sequence
2826 * Get the name of the sequence used by an identity or serial column,
2827 * formatted suitably for passing to setval, nextval or currval.
2828 * First parameter is not treated as double-quoted, second parameter
2829 * is --- see documentation for reason.
2830 */
2831Datum
2833{
2837 Oid tableOid;
2843 SysScanDesc scan;
2845
2846 /* Look up table name. Can't lock it - we might not have privileges. */
2849
2850 /* Get the number of the column */
2852
2859
2860 /* Search the dependency table for the dependent sequence */
2862
2863 ScanKeyInit(&key[0],
2867 ScanKeyInit(&key[1],
2868 Anum_pg_depend_refobjid,
2870 ObjectIdGetDatum(tableOid));
2871 ScanKeyInit(&key[2],
2875
2877 NULL, 3, key);
2878
2880 {
2882
2883 /*
2884 * Look for an auto dependency (serial column) or internal dependency
2885 * (identity column) of a sequence on a column. (We need the relkind
2886 * test because indexes can also have auto dependencies on columns.)
2887 */
2889 deprec->objsubid == 0 &&
2893 {
2895 break;
2896 }
2897 }
2898
2899 systable_endscan(scan);
2901
2903 {
2904 char *result;
2905
2907
2909 }
2910
2911 PG_RETURN_NULL();
2912}
2913
2914
2915/*
2916 * pg_get_functiondef
2917 * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
2918 * the specified function.
2919 *
2920 * Note: if you change the output format of this function, be careful not
2921 * to break psql's rules (in \ef and \sf) for identifying the start of the
2922 * function body. To wit: the function body starts on a line that begins with
2923 * "AS ", "BEGIN ", or "RETURN ", and no preceding line will look like that.
2924 */
2925Datum
2927{
2932 Form_pg_proc proc;
2934 Datum tmp;
2935 bool isnull;
2936 const char *prosrc;
2941
2943
2944 /* Look up the function */
2947 PG_RETURN_NULL();
2948
2951
2956
2958
2959 /*
2960 * We always qualify the function name, to ensure the right function gets
2961 * replaced.
2962 */
2970 {
2974 }
2975
2977
2980
2981 /* Emit some miscellaneous options on one line */
2983
2986 switch (proc->provolatile)
2987 {
2990 break;
2993 break;
2995 break;
2996 }
2997
2998 switch (proc->proparallel)
2999 {
3002 break;
3005 break;
3007 break;
3008 }
3009
3010 if (proc->proisstrict)
3012 if (proc->prosecdef)
3014 if (proc->proleakproof)
3016
3017 /* This code for the default cost and rows should match functioncmds.c */
3019 proc->prolang == ClanguageId)
3020 procost = 1;
3021 else
3022 procost = 100;
3025
3026 if (proc->prorows > 0 && proc->prorows != 1000)
3028
3029 if (proc->prosupport)
3030 {
3031 Oid argtypes[1];
3032
3033 /*
3034 * We should qualify the support function's name if it wouldn't be
3035 * resolved by lookup in the current search path.
3036 */
3037 argtypes[0] = INTERNALOID;
3039 generate_function_name(proc->prosupport, 1,
3040 NIL, argtypes,
3042 }
3043
3046
3047 /* Emit any proconfig options, one per line */
3049 if (!isnull)
3050 {
3053
3057
3059 {
3060 Datum d;
3061
3063 -1 /* varlenarray */ ,
3064 -1 /* TEXT's typlen */ ,
3065 false /* TEXT's typbyval */ ,
3067 &isnull);
3068 if (!isnull)
3069 {
3071 char *pos;
3072
3075 continue;
3076 *pos++ = '\0';
3077
3080
3081 /*
3082 * Variables that are marked GUC_LIST_QUOTE were already fully
3083 * quoted by flatten_set_variable_args() before they were put
3084 * into the proconfig array. However, because the quoting
3085 * rules used there aren't exactly like SQL's, we have to
3086 * break the list value apart and then quote the elements as
3087 * string literals. (The elements may be double-quoted as-is,
3088 * but we can't just feed them to the SQL parser; it would do
3089 * the wrong thing with elements that are zero-length or
3090 * longer than NAMEDATALEN.) Also, we need a special case for
3091 * empty lists.
3092 *
3093 * Variables that are not so marked should just be emitted as
3094 * simple string literals. If the variable is not known to
3095 * guc.c, we'll do that; this makes it unsafe to use
3096 * GUC_LIST_QUOTE for extension variables.
3097 */
3099 {
3102
3103 /* Parse string into list of identifiers */
3105 {
3106 /* this shouldn't fail really */
3108 }
3109 /* Special case: represent an empty list as NULL */
3113 {
3115
3119 }
3120 }
3121 else
3124 }
3125 }
3126 }
3127
3128 /* And finally the function definition ... */
3131 {
3133 }
3134 else
3135 {
3137
3139 if (!isnull)
3140 {
3143 }
3144
3146 prosrc = TextDatumGetCString(tmp);
3147
3148 /*
3149 * We always use dollar quoting. Figure out a suitable delimiter.
3150 *
3151 * Since the user is likely to be editing the function body string, we
3152 * shouldn't use a short delimiter that he might easily create a
3153 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3154 * if needed.
3155 */
3162
3166 }
3167
3169
3171
3173}
3174
3175/*
3176 * pg_get_function_arguments
3177 * Get a nicely-formatted list of arguments for a function.
3178 * This is everything that would go between the parentheses in
3179 * CREATE FUNCTION.
3180 */
3181Datum
3183{
3187
3190 PG_RETURN_NULL();
3191
3193
3195
3197
3199}
3200
3201/*
3202 * pg_get_function_identity_arguments
3203 * Get a formatted list of arguments for a function.
3204 * This is everything that would go between the parentheses in
3205 * ALTER FUNCTION, etc. In particular, don't print defaults.
3206 */
3207Datum
3209{
3213
3216 PG_RETURN_NULL();
3217
3219
3221
3223
3225}
3226
3227/*
3228 * pg_get_function_result
3229 * Get a nicely-formatted version of the result type of a function.
3230 * This is what would appear after RETURNS in CREATE FUNCTION.
3231 */
3232Datum
3234{
3238
3241 PG_RETURN_NULL();
3242
3244 {
3246 PG_RETURN_NULL();
3247 }
3248
3250
3252
3254
3256}
3257
3258/*
3259 * Guts of pg_get_function_result: append the function's return type
3260 * to the specified buffer.
3261 */
3262static void
3264{
3268
3270
3271 if (proc->proretset)
3272 {
3273 /* It might be a table function; try to print the arguments */
3278 else
3280 }
3281
3283 {
3284 /* Not a table function, so do the normal thing */
3285 if (proc->proretset)
3288 }
3289
3291}
3292
3293/*
3294 * Common code for pg_get_function_arguments and pg_get_function_result:
3295 * append the desired subset of arguments to buf. We print only TABLE
3296 * arguments when print_table_args is true, and all the others when it's false.
3297 * We print argument defaults only if print_defaults is true.
3298 * Function return value is the number of arguments printed.
3299 */
3300static int
3303{
3305 int numargs;
3306 Oid *argtypes;
3307 char **argnames;
3316
3318 &argtypes, &argnames, &argmodes);
3319
3320 nlackdefaults = numargs;
3322 {
3324 bool isnull;
3325
3328 &isnull);
3329 if (!isnull)
3330 {
3332
3337 /* nlackdefaults counts only *input* arguments lacking defaults */
3339 }
3340 }
3341
3342 /* Check for special treatment of ordered-set aggregates */
3344 {
3347
3351 proc->oid);
3356 }
3357
3358 argsprinted = 0;
3359 inputargno = 0;
3361 {
3367
3369 {
3371
3372 /*
3373 * For procedures, explicitly mark all argument modes, so as
3374 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3375 */
3378 else
3381 break;
3385 break;
3389 break;
3393 break;
3397 break;
3398 default:
3402 break;
3403 }
3406
3408 continue;
3409
3411 {
3415 }
3418
3420 if (argname && argname[0])
3424 {
3425 Node *expr;
3426
3430
3433 }
3434 argsprinted++;
3435
3436 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3438 {
3439 i--;
3440 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3442 }
3443 }
3444
3446}
3447
3448static bool
3450{
3455}
3456
3457/*
3458 * Append used transformed types to specified buffer
3459 */
3460static void
3462{
3463 Oid *trftypes;
3465
3468 {
3470
3473 {
3477 }
3479 }
3480}
3481
3482/*
3483 * Get textual representation of a function argument's default value. The
3484 * second argument of this function is the argument number among all arguments
3485 * (i.e. proallargtypes, *not* proargtypes), starting with 1, because that's
3486 * how information_schema.sql uses it.
3487 */
3488Datum
3490{
3494 Form_pg_proc proc;
3495 int numargs;
3496 Oid *argtypes;
3497 char **argnames;
3501 Node *node;
3505 bool isnull;
3507
3510 PG_RETURN_NULL();
3511
3514 {
3516 PG_RETURN_NULL();
3517 }
3518
3519 nth_inputarg = 0;
3522 nth_inputarg++;
3523
3526 &isnull);
3527 if (isnull)
3528 {
3530 PG_RETURN_NULL();
3531 }
3532
3536
3538
3539 /*
3540 * Calculate index into proargdefaults: proargdefaults corresponds to the
3541 * last N input arguments, where N = pronargdefaults.
3542 */
3544
3546 {
3548 PG_RETURN_NULL();
3549 }
3552
3554
3556}
3557
3558static void
3560{
3561 int numargs;
3562 Oid *argtypes;
3563 char **argnames;
3566 Datum tmp;
3567 Node *n;
3568
3571 &argtypes, &argnames, &argmodes);
3572 dpns.numargs = numargs;
3573 dpns.argnames = argnames;
3574
3577
3579 {
3580 List *stmts;
3582
3584
3586
3588 {
3590
3591 /* It seems advisable to get at least AccessShareLock on rels */
3597 }
3598
3600 }
3601 else
3602 {
3604
3605 /* It seems advisable to get at least AccessShareLock on rels */
3608 0, WRAP_COLUMN_DEFAULT, 0);
3609 }
3610}
3611
3612Datum
3614{
3618 bool isnull;
3619
3621
3622 /* Look up the function */
3625 PG_RETURN_NULL();
3626
3628 if (isnull)
3629 {
3631 PG_RETURN_NULL();
3632 }
3633
3635
3637
3639}
3640
3641
3642/*
3643 * deparse_expression - General utility for deparsing expressions
3644 *
3645 * calls deparse_expression_pretty with all prettyPrinting disabled
3646 */
3647char *
3650{
3652 showimplicit, 0, 0);
3653}
3654
3655/* ----------
3656 * deparse_expression_pretty - General utility for deparsing expressions
3657 *
3658 * expr is the node tree to be deparsed. It must be a transformed expression
3659 * tree (ie, not the raw output of gram.y).
3660 *
3661 * dpcontext is a list of deparse_namespace nodes representing the context
3662 * for interpreting Vars in the node tree. It can be NIL if no Vars are
3663 * expected.
3664 *
3665 * forceprefix is true to force all Vars to be prefixed with their table names.
3666 *
3667 * showimplicit is true to force all implicit casts to be shown explicitly.
3668 *
3669 * Tries to pretty up the output according to prettyFlags and startIndent.
3670 *
3671 * The result is a palloc'd string.
3672 * ----------
3673 */
3674static char *
3678{
3680 deparse_context context;
3681
3689 context.prettyFlags = prettyFlags;
3696
3698
3700}
3701
3702/* ----------
3703 * deparse_context_for - Build deparse context for a single relation
3704 *
3705 * Given the reference name (alias) and OID of a relation, build deparsing
3706 * context for an expression referencing only that relation (as varno 1,
3707 * varlevelsup 0). This is sufficient for many uses of deparse_expression.
3708 * ----------
3709 */
3710List *
3712{
3715
3717
3718 /* Build a minimal RTE for the rel */
3721 rte->relid = relid;
3729
3730 /* Build one-element rtable */
3737
3738 /* Return a one-deep namespace stack */
3740}
3741
3742/*
3743 * deparse_context_for_plan_tree - Build deparse context for a Plan tree
3744 *
3745 * When deparsing an expression in a Plan tree, we use the plan's rangetable
3746 * to resolve names of simple Vars. The initialization of column names for
3747 * this is rather expensive if the rangetable is large, and it'll be the same
3748 * for every expression in the Plan tree; so we do it just once and re-use
3749 * the result of this function for each expression. (Note that the result
3750 * is not usable until set_deparse_context_plan() is applied to it.)
3751 *
3752 * In addition to the PlannedStmt, pass the per-RTE alias names
3753 * assigned by a previous call to select_rtable_names_for_explain.
3754 */
3755List *
3757{
3759
3761
3762 /* Initialize fields that stay the same across the whole plan tree */
3764 dpns->rtable_names = rtable_names;
3768 {
3769 /* Set up the array, indexed by child relid */
3772
3776 {
3779
3783 }
3784 }
3785 else
3787
3788 /*
3789 * Set up column name aliases, ignoring any join RTEs; they don't matter
3790 * because plan trees don't contain any join alias Vars.
3791 */
3793
3794 /* Return a one-deep namespace stack */
3796}
3797
3798/*
3799 * set_deparse_context_plan - Specify Plan node containing expression
3800 *
3801 * When deparsing an expression in a Plan tree, we might have to resolve
3802 * OUTER_VAR, INNER_VAR, or INDEX_VAR references. To do this, the caller must
3803 * provide the parent Plan node. Then OUTER_VAR and INNER_VAR references
3804 * can be resolved by drilling down into the left and right child plans.
3805 * Similarly, INDEX_VAR references can be resolved by reference to the
3806 * indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
3807 * ForeignScan and CustomScan nodes. (Note that we don't currently support
3808 * deparsing of indexquals in regular IndexScan or BitmapIndexScan nodes;
3809 * for those, we can only deparse the indexqualorig fields, which won't
3810 * contain INDEX_VAR Vars.)
3811 *
3812 * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
3813 * the most-closely-nested first. This is needed to resolve PARAM_EXEC
3814 * Params. Note we assume that all the Plan nodes share the same rtable.
3815 *
3816 * For a ModifyTable plan, we might also need to resolve references to OLD/NEW
3817 * variables in the RETURNING list, so we copy the alias names of the OLD and
3818 * NEW rows from the ModifyTable plan node.
3819 *
3820 * Once this function has been called, deparse_expression() can be called on
3821 * subsidiary expression(s) of the specified Plan node. To deparse
3822 * expressions of a different Plan node in the same Plan tree, re-call this
3823 * function to identify the new parent Plan node.
3824 *
3825 * The result is the same List passed in; this is a notational convenience.
3826 */
3827List *
3829{
3831
3832 /* Should always have one-entry namespace list for Plan deparsing */
3835
3836 /* Set our attention on the specific plan node passed in */
3837 dpns->ancestors = ancestors;
3839
3840 /* For ModifyTable, set aliases for OLD and NEW in RETURNING */
3842 {
3845 }
3846
3848}
3849
3850/*
3851 * select_rtable_names_for_explain - Select RTE aliases for EXPLAIN
3852 *
3853 * Determine the relation aliases we'll use during an EXPLAIN operation.
3854 * This is just a frontend to set_rtable_names. We have to expose the aliases
3855 * to EXPLAIN because EXPLAIN needs to know the right alias names to print.
3856 */
3857List *
3859{
3861
3863 dpns.rtable = rtable;
3868 /* We needn't bother computing column aliases yet */
3869
3871}
3872
3873/*
3874 * set_rtable_names: select RTE aliases to be used in printing a query
3875 *
3876 * We fill in dpns->rtable_names with a list of names that is one-for-one with
3877 * the already-filled dpns->rtable list. Each RTE name is unique among those
3878 * in the new namespace plus any ancestor namespaces listed in
3879 * parent_namespaces.
3880 *
3881 * If rels_used isn't NULL, only RTE indexes listed in it are given aliases.
3882 *
3883 * Note that this function is only concerned with relation names, not column
3884 * names.
3885 */
3886static void
3889{
3891 HTAB *names_hash;
3893 bool found;
3894 int rtindex;
3896
3898 /* nothing more to do if empty rtable */
3900 return;
3901
3902 /*
3903 * We use a hash table to hold known names, so that this process is O(N)
3904 * not O(N^2) for N names.
3905 */
3911 &hash_ctl,
3913
3914 /* Preload the hash table with names appearing in parent_namespaces */
3916 {
3919
3921 {
3923
3925 continue;
3927 oldname,
3928 HASH_ENTER,
3929 &found);
3930 /* we do not complain about duplicate names in parent namespaces */
3931 hentry->counter = 0;
3932 }
3933 }
3934
3935 /* Now we can scan the rtable */
3936 rtindex = 1;
3938 {
3940 char *refname;
3941
3942 /* Just in case this takes an unreasonable amount of time ... */
3943 CHECK_FOR_INTERRUPTS();
3944
3946 {
3947 /* Ignore unreferenced RTE */
3948 refname = NULL;
3949 }
3951 {
3952 /* If RTE has a user-defined alias, prefer that */
3953 refname = rte->alias->aliasname;
3954 }
3956 {
3957 /* Use the current actual name of the relation */
3959 }
3961 {
3962 /* Unnamed join has no refname */
3963 refname = NULL;
3964 }
3965 else
3966 {
3967 /* Otherwise use whatever the parser assigned */
3968 refname = rte->eref->aliasname;
3969 }
3970
3971 /*
3972 * If the selected name isn't unique, append digits to make it so, and
3973 * make a new hash entry for it once we've got a unique name. For a
3974 * very long input name, we might have to truncate to stay within
3975 * NAMEDATALEN.
3976 */
3977 if (refname)
3978 {
3980 refname,
3981 HASH_ENTER,
3982 &found);
3983 if (found)
3984 {
3985 /* Name already in use, must choose a new one */
3989
3990 do
3991 {
3993 for (;;)
3994 {
3998 break;
3999 /* drop chars from refname to keep all the digits */
4001 refnamelen - 1);
4002 }
4004 modname,
4005 HASH_ENTER,
4006 &found);
4007 } while (found);
4009 refname = modname;
4010 }
4011 else
4012 {
4013 /* Name not previously used, need only initialize hentry */
4014 hentry->counter = 0;
4015 }
4016 }
4017
4019 rtindex++;
4020 }
4021
4022 hash_destroy(names_hash);
4023}
4024
4025/*
4026 * set_deparse_for_query: set up deparse_namespace for deparsing a Query tree
4027 *
4028 * For convenience, this is defined to initialize the deparse_namespace struct
4029 * from scratch.
4030 */
4031static void
4034{
4037
4038 /* Initialize *dpns and fill rtable/ctes links */
4044 dpns->ret_old_alias = query->returningOldAlias;
4045 dpns->ret_new_alias = query->returningNewAlias;
4046
4047 /* Assign a unique relation alias to each RTE */
4049
4050 /* Initialize dpns->rtable_columns to contain zeroed structs */
4055
4056 /* If it's a utility query, it won't have a jointree */
4058 {
4059 /* Detect whether global uniqueness of USING names is needed */
4060 dpns->unique_using =
4062
4063 /*
4064 * Select names for columns merged by USING, via a recursive pass over
4065 * the query jointree.
4066 */
4068 }
4069
4070 /*
4071 * Now assign remaining column aliases for each RTE. We do this in a
4072 * linear scan of the rtable, so as to process RTEs whether or not they
4073 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4074 * etc). JOIN RTEs must be processed after their children, but this is
4075 * okay because they appear later in the rtable list than their children
4076 * (cf Asserts in identify_join_columns()).
4077 */
4079 {
4082
4085 else
4087 }
4088}
4089
4090/*
4091 * set_simple_column_names: fill in column aliases for non-query situations
4092 *
4093 * This handles EXPLAIN and cases where we only have relation RTEs. Without
4094 * a join tree, we can't do anything smart about join RTEs, but we don't
4095 * need to, because EXPLAIN should never see join alias Vars anyway.
4096 * If we find a join RTE we'll just skip it, leaving its deparse_columns
4097 * struct all-zero. If somehow we try to deparse a join alias Var, we'll
4098 * error out cleanly because the struct's num_cols will be zero.
4099 */
4100static void
4102{
4105
4106 /* Initialize dpns->rtable_columns to contain zeroed structs */
4111
4112 /* Assign unique column aliases within each non-join RTE */
4114 {
4117
4120 }
4121}
4122
4123/*
4124 * has_dangerous_join_using: search jointree for unnamed JOIN USING
4125 *
4126 * Merged columns of a JOIN USING may act differently from either of the input
4127 * columns, either because they are merged with COALESCE (in a FULL JOIN) or
4128 * because an implicit coercion of the underlying input column is required.
4129 * In such a case the column must be referenced as a column of the JOIN not as
4130 * a column of either input. And this is problematic if the join is unnamed
4131 * (alias-less): we cannot qualify the column's name with an RTE name, since
4132 * there is none. (Forcibly assigning an alias to the join is not a solution,
4133 * since that will prevent legal references to tables below the join.)
4134 * To ensure that every column in the query is unambiguously referenceable,
4135 * we must assign such merged columns names that are globally unique across
4136 * the whole query, aliasing other columns out of the way as necessary.
4137 *
4138 * Because the ensuing re-aliasing is fairly damaging to the readability of
4139 * the query, we don't do this unless we have to. So, we must pre-scan
4140 * the join tree to see if we have to, before starting set_using_names().
4141 */
4142static bool
4144{
4146 {
4147 /* nothing to do here */
4148 }
4150 {
4153
4155 {
4157 return true;
4158 }
4159 }
4161 {
4163
4164 /* Is it an unnamed JOIN with USING? */
4166 {
4167 /*
4168 * Yes, so check each join alias var to see if any of them are not
4169 * simple references to underlying columns. If so, we have a
4170 * dangerous situation and must pick unique aliases.
4171 */
4173
4174 /* We need only examine the merged columns */
4176 {
4178
4180 return true;
4181 }
4182 }
4183
4184 /* Nope, but inspect children */
4186 return true;
4188 return true;
4189 }
4190 else
4193 return false;
4194}
4195
4196/*
4197 * set_using_names: select column aliases to be used for merged USING columns
4198 *
4199 * We do this during a recursive descent of the query jointree.
4200 * dpns->unique_using must already be set to determine the global strategy.
4201 *
4202 * Column alias info is saved in the dpns->rtable_columns list, which is
4203 * assumed to be filled with pre-zeroed deparse_columns structs.
4204 *
4205 * parentUsing is a list of all USING aliases assigned in parent joins of
4206 * the current jointree node. (The passed-in list must not be modified.)
4207 *
4208 * Note that we do not use per-deparse_columns hash tables in this function.
4209 * The number of names that need to be assigned should be small enough that
4210 * we don't need to trouble with that.
4211 */
4212static void
4214{
4216 {
4217 /* nothing to do now */
4218 }
4220 {
4223
4226 }
4228 {
4232 int *leftattnos;
4233 int *rightattnos;
4238
4239 /* Get info about the shape of the join */
4241 leftattnos = colinfo->leftattnos;
4242 rightattnos = colinfo->rightattnos;
4243
4244 /* Look up the not-yet-filled-in child deparse_columns structs */
4247
4248 /*
4249 * If this join is unnamed, then we cannot substitute new aliases at
4250 * this level, so any name requirements pushed down to here must be
4251 * pushed down again to the children.
4252 */
4254 {
4256 {
4258
4260 continue;
4261
4262 /* Push down to left column, unless it's a system column */
4264 {
4267 }
4268
4269 /* Same on the righthand side */
4271 {
4274 }
4275 }
4276 }
4277
4278 /*
4279 * If there's a USING clause, select the USING column names and push
4280 * those names down to the children. We have two strategies:
4281 *
4282 * If dpns->unique_using is true, we force all USING names to be
4283 * unique across the whole query level. In principle we'd only need
4284 * the names of dangerous USING columns to be globally unique, but to
4285 * safely assign all USING names in a single pass, we have to enforce
4286 * the same uniqueness rule for all of them. However, if a USING
4287 * column's name has been pushed down from the parent, we should use
4288 * it as-is rather than making a uniqueness adjustment. This is
4289 * necessary when we're at an unnamed join, and it creates no risk of
4290 * ambiguity. Also, if there's a user-written output alias for a
4291 * merged column, we prefer to use that rather than the input name;
4292 * this simplifies the logic and seems likely to lead to less aliasing
4293 * overall.
4294 *
4295 * If dpns->unique_using is false, we only need USING names to be
4296 * unique within their own join RTE. We still need to honor
4297 * pushed-down names, though.
4298 *
4299 * Though significantly different in results, these two strategies are
4300 * implemented by the same code, with only the difference of whether
4301 * to put assigned names into dpns->using_names.
4302 */
4304 {
4305 /* Copy the input parentUsing list so we don't modify it */
4306 parentUsing = list_copy(parentUsing);
4307
4308 /* USING names must correspond to the first join output columns */
4310 i = 0;
4312 {
4314
4315 /* Assert it's a merged column */
4317
4318 /* Adopt passed-down name if any, else select unique name */
4321 else
4322 {
4323 /* Prefer user-written output alias if any */
4326 /* Make it appropriately unique */
4330 colname);
4331 /* Save it as output column name, too */
4333 }
4334
4335 /* Remember selected names for use later */
4337 parentUsing = lappend(parentUsing, colname);
4338
4339 /* Push down to left column, unless it's a system column */
4341 {
4344 }
4345
4346 /* Same on the righthand side */
4348 {
4351 }
4352
4353 i++;
4354 }
4355 }
4356
4357 /* Mark child deparse_columns structs with correct parentUsing info */
4358 leftcolinfo->parentUsing = parentUsing;
4359 rightcolinfo->parentUsing = parentUsing;
4360
4361 /* Now recursively assign USING column names in children */
4364 }
4365 else
4368}
4369
4370/*
4371 * set_relation_column_names: select column aliases for a non-join RTE
4372 *
4373 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4374 * If any colnames entries are already filled in, those override local
4375 * choices.
4376 */
4377static void
4380{
4381 int ncolumns;
4387
4388 /*
4389 * Construct an array of the current "real" column names of the RTE.
4390 * real_colnames[] will be indexed by physical column number, with NULL
4391 * entries for dropped columns.
4392 */
4394 {
4395 /* Relation --- look to the system catalogs for up-to-date info */
4396 Relation rel;
4397 TupleDesc tupdesc;
4398
4400 tupdesc = RelationGetDescr(rel);
4401
4402 ncolumns = tupdesc->natts;
4404
4406 {
4408
4409 if (attr->attisdropped)
4411 else
4413 }
4415 }
4416 else
4417 {
4418 /* Otherwise get the column names from eref or expandRTE() */
4419 List *colnames;
4421
4422 /*
4423 * Functions returning composites have the annoying property that some
4424 * of the composite type's columns might have been dropped since the
4425 * query was parsed. If possible, use expandRTE() to handle that
4426 * case, since it has the tedious logic needed to find out about
4427 * dropped columns. However, if we're explaining a plan, then we
4428 * don't have rte->functions because the planner thinks that won't be
4429 * needed later, and that breaks expandRTE(). So in that case we have
4430 * to rely on rte->eref, which may lead us to report a dropped
4431 * column's old name; that seems close enough for EXPLAIN's purposes.
4432 *
4433 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4434 * which should be sufficiently up-to-date: no other RTE types can
4435 * have columns get dropped from under them after parsing.
4436 */
4438 {
4439 /* Since we're not creating Vars, rtindex etc. don't matter */
4442 }
4443 else
4444 colnames = rte->eref->colnames;
4445
4446 ncolumns = list_length(colnames);
4448
4449 i = 0;
4451 {
4452 /*
4453 * If the column name we find here is an empty string, then it's a
4454 * dropped column, so change to NULL.
4455 */
4457
4461 i++;
4462 }
4463 }
4464
4465 /*
4466 * Ensure colinfo->colnames has a slot for each column. (It could be long
4467 * enough already, if we pushed down a name for the last column.) Note:
4468 * it's possible that there are now more columns than there were when the
4469 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4470 * We must assign unique aliases to the new columns too, else there could
4471 * be unresolved conflicts when the view/rule is reloaded.
4472 */
4475
4476 /*
4477 * Make sufficiently large new_colnames and is_new_col arrays, too.
4478 *
4479 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4480 * colname_is_unique will not consult that array, which is fine because it
4481 * would only be duplicate effort.
4482 */
4485
4486 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4488
4489 /*
4490 * Scan the columns, select a unique alias for each one, and store it in
4491 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4492 * entries for dropped columns, the latter omits them. Also mark
4493 * new_colnames entries as to whether they are new since parse time; this
4494 * is the case for entries beyond the length of rte->eref->colnames.
4495 */
4498 j = 0;
4500 {
4503
4504 /* Skip dropped columns */
4506 {
4508 continue;
4509 }
4510
4511 /* If alias already assigned, that's what to use */
4513 {
4514 /* If user wrote an alias, prefer that over real column name */
4517 else
4518 colname = real_colname;
4519
4520 /* Unique-ify and insert into colinfo */
4522
4525 }
4526
4527 /* Put names of non-dropped columns in new_colnames[] too */
4529 /* And mark them as new or not */
4531 j++;
4532
4533 /* Remember if any assigned aliases differ from "real" name */
4536 }
4537
4538 /* We're now done needing the colinfo's names_hash */
4540
4541 /*
4542 * Set correct length for new_colnames[] array. (Note: if columns have
4543 * been added, colinfo->num_cols includes them, which is not really quite
4544 * right but is harmless, since any new columns must be at the end where
4545 * they won't affect varattnos of pre-existing columns.)
4546 */
4548
4549 /*
4550 * For a relation RTE, we need only print the alias column names if any
4551 * are different from the underlying "real" names. For a function RTE,
4552 * always emit a complete column alias list; this is to protect against
4553 * possible instability of the default column names (eg, from altering
4554 * parameter names). For tablefunc RTEs, we never print aliases, because
4555 * the column names are part of the clause itself. For other RTE types,
4556 * print if we changed anything OR if there were user-written column
4557 * aliases (since the latter would be part of the underlying "reality").
4558 */
4567 else
4569}
4570
4571/*
4572 * set_join_column_names: select column aliases for a join RTE
4573 *
4574 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4575 * If any colnames entries are already filled in, those override local
4576 * choices. Also, names for USING columns were already chosen by
4577 * set_using_names(). We further expect that column alias selection has been
4578 * completed for both input RTEs.
4579 */
4580static void
4583{
4595
4596 /* Look up the previously-filled-in child deparse_columns structs */
4599
4600 /*
4601 * Ensure colinfo->colnames has a slot for each column. (It could be long
4602 * enough already, if we pushed down a name for the last column.) Note:
4603 * it's possible that one or both inputs now have more columns than there
4604 * were when the query was parsed, but we'll deal with that below. We
4605 * only need entries in colnames for pre-existing columns.
4606 */
4610
4611 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4613
4614 /*
4615 * Scan the join output columns, select an alias for each one, and store
4616 * it in colinfo->colnames. If there are USING columns, set_using_names()
4617 * already selected their names, so we can start the loop at the first
4618 * non-merged column.
4619 */
4622 {
4625
4626 /* Join column must refer to at least one input column */
4628
4629 /* Get the child column name */
4634 else
4635 {
4636 /* We're joining system columns --- use eref name */
4638 }
4639
4640 /* If child col has been dropped, no need to assign a join colname */
4642 {
4644 continue;
4645 }
4646
4647 /* In an unnamed join, just report child column names as-is */
4649 {
4652 continue;
4653 }
4654
4655 /* If alias already assigned, that's what to use */
4657 {
4658 /* If user wrote an alias, prefer that over real column name */
4661 else
4662 colname = real_colname;
4663
4664 /* Unique-ify and insert into colinfo */
4666
4669 }
4670
4671 /* Remember if any assigned aliases differ from "real" name */
4674 }
4675
4676 /*
4677 * Calculate number of columns the join would have if it were re-parsed
4678 * now, and create storage for the new_colnames and is_new_col arrays.
4679 *
4680 * Note: colname_is_unique will be consulting new_colnames[] during the
4681 * loops below, so its not-yet-filled entries must be zeroes.
4682 */
4688
4689 /*
4690 * Generating the new_colnames array is a bit tricky since any new columns
4691 * added since parse time must be inserted in the right places. This code
4692 * must match the parser, which will order a join's columns as merged
4693 * columns first (in USING-clause order), then non-merged columns from the
4694 * left input (in attnum order), then non-merged columns from the right
4695 * input (ditto). If one of the inputs is itself a join, its columns will
4696 * be ordered according to the same rule, which means newly-added columns
4697 * might not be at the end. We can figure out what's what by consulting
4698 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
4699 *
4700 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
4701 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
4702 * meanings for the current child RTE.
4703 */
4704
4705 /* Handle merged columns; they are first and can't be new */
4710 {
4711 /* column name is already determined and known unique */
4714
4715 /* build bitmapsets of child attnums of merged columns */
4720
4722 }
4723
4724 /* Handle non-merged left-child columns */
4725 ic = 0;
4727 {
4729
4731 {
4732 /* Advance ic to next non-dropped old column of left child */
4735 ic++;
4737 ic++;
4738 /* If it is a merged column, we already processed it */
4740 continue;
4741 /* Else, advance i to the corresponding existing join column */
4744 i++;
4747 /* Use the already-assigned name of this column */
4749 i++;
4750 }
4751 else
4752 {
4753 /*
4754 * Unique-ify the new child column name and assign, unless we're
4755 * in an unnamed join, in which case just copy
4756 */
4758 {
4764 }
4765 else
4768 }
4769
4771 j++;
4772 }
4773
4774 /* Handle non-merged right-child columns in exactly the same way */
4775 ic = 0;
4777 {
4779
4781 {
4782 /* Advance ic to next non-dropped old column of right child */
4785 ic++;
4787 ic++;
4788 /* If it is a merged column, we already processed it */
4790 continue;
4791 /* Else, advance i to the corresponding existing join column */
4794 i++;
4797 /* Use the already-assigned name of this column */
4799 i++;
4800 }
4801 else
4802 {
4803 /*
4804 * Unique-ify the new child column name and assign, unless we're
4805 * in an unnamed join, in which case just copy
4806 */
4808 {
4814 }
4815 else
4818 }
4819
4821 j++;
4822 }
4823
4824 /* Assert we processed the right number of columns */
4825#ifdef USE_ASSERT_CHECKING
4827 i++;
4830#endif
4831
4832 /* We're now done needing the colinfo's names_hash */
4834
4835 /*
4836 * For a named join, print column aliases if we changed any from the child
4837 * names. Unnamed joins cannot print aliases.
4838 */
4841 else
4843}
4844
4845/*
4846 * colname_is_unique: is colname distinct from already-chosen column names?
4847 *
4848 * dpns is query-wide info, colinfo is for the column's RTE
4849 */
4850static bool
4853{
4856
4857 /*
4858 * If we have a hash table, consult that instead of linearly scanning the
4859 * colinfo's strings.
4860 */
4862 {
4864 colname,
4865 HASH_FIND,
4867 return false;
4868 }
4869 else
4870 {
4871 /* Check against already-assigned column aliases within RTE */
4873 {
4875
4877 return false;
4878 }
4879
4880 /*
4881 * If we're building a new_colnames array, check that too (this will
4882 * be partially but not completely redundant with the previous checks)
4883 */
4885 {
4887
4889 return false;
4890 }
4891
4892 /*
4893 * Also check against names already assigned for parent-join USING
4894 * cols
4895 */
4897 {
4899
4901 return false;
4902 }
4903 }
4904
4905 /*
4906 * Also check against USING-column names that must be globally unique.
4907 * These are not hashed, but there should be few of them.
4908 */
4910 {
4912
4914 return false;
4915 }
4916
4917 return true;
4918}
4919
4920/*
4921 * make_colname_unique: modify colname if necessary to make it unique
4922 *
4923 * dpns is query-wide info, colinfo is for the column's RTE
4924 */
4925static char *
4928{
4929 /*
4930 * If the selected name isn't unique, append digits to make it so. For a
4931 * very long input name, we might have to truncate to stay within
4932 * NAMEDATALEN.
4933 */
4935 {
4939
4940 do
4941 {
4942 i++;
4943 for (;;)
4944 {
4948 break;
4949 /* drop chars from colname to keep all the digits */
4951 colnamelen - 1);
4952 }
4954 colname = modname;
4955 }
4956 return colname;
4957}
4958
4959/*
4960 * expand_colnames_array_to: make colinfo->colnames at least n items long
4961 *
4962 * Any added array entries are initialized to zero.
4963 */
4964static void
4966{
4968 {
4971 else
4973 colinfo->num_cols = n;
4974 }
4975}
4976
4977/*
4978 * build_colinfo_names_hash: optionally construct a hash table for colinfo
4979 */
4980static void
4982{
4986
4987 /*
4988 * Use a hash table only for RTEs with at least 32 columns. (The cutoff
4989 * is somewhat arbitrary, but let's choose it so that this code does get
4990 * exercised in the regression tests.)
4991 */
4993 return;
4994
4995 /*
4996 * Set up the hash table. The entries are just strings with no other
4997 * payload.
4998 */
5004 &hash_ctl,
5006
5007 /*
5008 * Preload the hash table with any names already present (these would have
5009 * come from set_using_names).
5010 */
5012 {
5014
5017 }
5018
5020 {
5022
5025 }
5026
5028 {
5030
5032 }
5033}
5034
5035/*
5036 * add_to_names_hash: add a string to the names_hash, if we're using one
5037 */
5038static void
5040{
5043 name,
5044 HASH_ENTER,
5045 NULL);
5046}
5047
5048/*
5049 * destroy_colinfo_names_hash: destroy hash table when done with it
5050 */
5051static void
5053{
5055 {
5058 }
5059}
5060
5061/*
5062 * identify_join_columns: figure out where columns of a join come from
5063 *
5064 * Fills the join-specific fields of the colinfo struct, except for
5065 * usingNames which is filled later.
5066 */
5067static void
5070{
5075
5076 /* Extract left/right child RT indexes */
5081 else
5088 else
5091
5092 /* Assert children will be processed earlier than join in second pass */
5095
5096 /* Initialize result arrays with zeroes */
5101
5102 /*
5103 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
5104 * Recall that the column(s) merged due to USING are the first column(s)
5105 * of the join output. We need not do anything special while scanning
5106 * joinleftcols, but while scanning joinrightcols we must distinguish
5107 * merged from unmerged columns.
5108 */
5109 jcolno = 0;
5111 {
5113
5115 }
5116 rcolno = 0;
5118 {
5120
5123 else
5125 rcolno++;
5126 }
5128}
5129
5130/*
5131 * get_rtable_name: convenience function to get a previously assigned RTE alias
5132 *
5133 * The RTE must belong to the topmost namespace level in "context".
5134 */
5135static char *
5137{
5139
5142}
5143
5144/*
5145 * set_deparse_plan: set up deparse_namespace to parse subexpressions
5146 * of a given Plan node
5147 *
5148 * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
5149 * and index_tlist fields. Caller must already have adjusted the ancestors
5150 * list if necessary. Note that the rtable, subplans, and ctes fields do
5151 * not need to change when shifting attention to different plan nodes in a
5152 * single plan tree.
5153 */
5154static void
5156{
5158
5159 /*
5160 * We special-case Append and MergeAppend to pretend that the first child
5161 * plan is the OUTER referent; we have to interpret OUTER Vars in their
5162 * tlists according to one of the children, and the first one is the most
5163 * natural choice.
5164 */
5169 else
5171
5174 else
5176
5177 /*
5178 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
5179 * use OUTER because that could someday conflict with the normal meaning.)
5180 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
5181 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
5182 * that as INNER referent.
5183 *
5184 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
5185 * INNER referent. This is the join from the target relation to the data
5186 * source, and all INNER_VAR Vars in other parts of the query refer to its
5187 * targetlist.
5188 *
5189 * For ON CONFLICT DO SELECT/UPDATE we just need the inner tlist to point
5190 * to the excluded expression's tlist. (Similar to the SubqueryScan we
5191 * don't want to reuse OUTER, it's used for RETURNING in some modify table
5192 * cases, although not INSERT .. CONFLICT).
5193 */
5203 {
5206 else
5208 }
5209 else
5211
5216 else
5218
5219 /* Set up referent for INDEX_VAR Vars, if needed */
5226 else
5228}
5229
5230/*
5231 * Locate the ancestor plan node that is the RecursiveUnion generating
5232 * the WorkTableScan's work table. We can match on wtParam, since that
5233 * should be unique within the plan tree.
5234 */
5237{
5239
5241 {
5243
5247 }
5249 wtscan->wtParam);
5251}
5252
5253/*
5254 * push_child_plan: temporarily transfer deparsing attention to a child plan
5255 *
5256 * When expanding an OUTER_VAR or INNER_VAR reference, we must adjust the
5257 * deparse context in case the referenced expression itself uses
5258 * OUTER_VAR/INNER_VAR. We modify the top stack entry in-place to avoid
5259 * affecting levelsup issues (although in a Plan tree there really shouldn't
5260 * be any).
5261 *
5262 * Caller must provide a local deparse_namespace variable to save the
5263 * previous state for pop_child_plan.
5264 */
5265static void
5268{
5269 /* Save state for restoration later */
5271
5272 /* Link current plan node into ancestors list */
5274
5275 /* Set attention on selected child */
5277}
5278
5279/*
5280 * pop_child_plan: undo the effects of push_child_plan
5281 */
5282static void
5284{
5285 List *ancestors;
5286
5287 /* Get rid of ancestors list cell added by push_child_plan */
5289
5290 /* Restore fields changed by push_child_plan */
5292
5293 /* Make sure dpns->ancestors is right (may be unnecessary) */
5294 dpns->ancestors = ancestors;
5295}
5296
5297/*
5298 * push_ancestor_plan: temporarily transfer deparsing attention to an
5299 * ancestor plan
5300 *
5301 * When expanding a Param reference, we must adjust the deparse context
5302 * to match the plan node that contains the expression being printed;
5303 * otherwise we'd fail if that expression itself contains a Param or
5304 * OUTER_VAR/INNER_VAR/INDEX_VAR variable.
5305 *
5306 * The target ancestor is conveniently identified by the ListCell holding it
5307 * in dpns->ancestors.
5308 *
5309 * Caller must provide a local deparse_namespace variable to save the
5310 * previous state for pop_ancestor_plan.
5311 */
5312static void
5315{
5317
5318 /* Save state for restoration later */
5320
5321 /* Build a new ancestor list with just this node's ancestors */
5322 dpns->ancestors =
5325
5326 /* Set attention on selected ancestor */
5328}
5329
5330/*
5331 * pop_ancestor_plan: undo the effects of push_ancestor_plan
5332 */
5333static void
5335{
5336 /* Free the ancestor list made in push_ancestor_plan */
5338
5339 /* Restore fields changed by push_ancestor_plan */
5341}
5342
5343
5344/* ----------
5345 * make_ruledef - reconstruct the CREATE RULE command
5346 * for a given pg_rewrite tuple
5347 * ----------
5348 */
5349static void
5351 int prettyFlags)
5352{
5353 char *rulename;
5354 char ev_type;
5356 bool is_instead;
5359 List *actions;
5364 bool isnull;
5365
5366 /*
5367 * Get the attribute values from the rules tuple
5368 */
5371 Assert(!isnull);
5373
5376 Assert(!isnull);
5378
5381 Assert(!isnull);
5383
5386 Assert(!isnull);
5388
5392
5399
5401
5402 /*
5403 * Build the rules definition text
5404 */
5406 quote_identifier(rulename));
5407
5410 else
5412
5413 /* The event the rule is fired for */
5414 switch (ev_type)
5415 {
5416 case '1':
5419 break;
5420
5421 case '2':
5423 break;
5424
5425 case '3':
5427 break;
5428
5429 case '4':
5431 break;
5432
5433 default:
5437 rulename, ev_type)));
5438 break;
5439 }
5440
5441 /* The relation the rule is fired on */
5443 (prettyFlags & PRETTYFLAG_SCHEMA) ?
5446
5447 /* If the rule has an event qualification, add it */
5449 {
5450 Node *qual;
5451 Query *query;
5452 deparse_context context;
5454
5458
5460
5461 /*
5462 * We need to make a context for recognizing any Vars in the qual
5463 * (which can only be references to OLD and NEW). Use the rtable of
5464 * the first query in the action list for this purpose.
5465 */
5467
5468 /*
5469 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5470 * into the SELECT, and that's what we need to look at. (Ugly kluge
5471 * ... try to fix this when we redesign querytrees.)
5472 */
5474
5475 /* Must acquire locks right away; see notes in get_query_def() */
5477
5484 context.prettyFlags = prettyFlags;
5491
5493
5495 }
5496
5498
5499 /* The INSTEAD keyword (if so) */
5500 if (is_instead)
5502
5503 /* Finally the rules actions */
5505 {
5507 Query *query;
5508
5510 foreach(action, actions)
5511 {
5514 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5515 if (prettyFlags)
5517 else
5519 }
5521 }
5522 else
5523 {
5524 Query *query;
5525
5528 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5530 }
5531
5533}
5534
5535
5536/* ----------
5537 * make_viewdef - reconstruct the SELECT part of a
5538 * view rewrite rule
5539 * ----------
5540 */
5541static void
5543 int prettyFlags, int wrapColumn)
5544{
5545 Query *query;
5546 char ev_type;
5548 bool is_instead;
5551 List *actions;
5555 bool isnull;
5556
5557 /*
5558 * Get the attribute values from the rules tuple
5559 */
5562 Assert(!isnull);
5564
5567 Assert(!isnull);
5569
5572 Assert(!isnull);
5574
5578
5583
5585 {
5586 /* keep output buffer empty and leave */
5587 return;
5588 }
5589
5591
5592 if (ev_type != '1' || !is_instead ||
5594 {
5595 /* keep output buffer empty and leave */
5596 return;
5597 }
5598
5600
5602 prettyFlags, wrapColumn, 0);
5604
5606}
5607
5608
5609/* ----------
5610 * get_query_def - Parse back one query parsetree
5611 *
5612 * query: parsetree to be displayed
5613 * buf: output text is appended to buf
5614 * parentnamespace: list (initially empty) of outer-level deparse_namespace's
5615 * resultDesc: if not NULL, the output tuple descriptor for the view
5616 * represented by a SELECT query. We use the column names from it
5617 * to label SELECT output columns, in preference to names in the query
5618 * colNamesVisible: true if the surrounding context cares about the output
5619 * column names at all (as, for example, an EXISTS() context does not);
5620 * when false, we can suppress dummy column labels such as "?column?"
5621 * prettyFlags: bitmask of PRETTYFLAG_XXX options
5622 * wrapColumn: maximum line length, or -1 to disable wrapping
5623 * startIndent: initial indentation amount
5624 * ----------
5625 */
5626static void
5630{
5631 deparse_context context;
5633 int rtable_size;
5634
5635 /* Guard against excessively long or deeply-nested queries */
5636 CHECK_FOR_INTERRUPTS();
5637 check_stack_depth();
5638
5639 rtable_size = query->hasGroupRTE ?
5642
5643 /*
5644 * Replace any Vars in the query's targetlist and havingQual that
5645 * reference GROUP outputs with the underlying grouping expressions.
5646 */
5647 if (query->hasGroupRTE)
5648 {
5651 query->havingQual =
5653 }
5654
5655 /*
5656 * Before we begin to examine the query, acquire locks on referenced
5657 * relations, and fix up deleted columns in JOIN RTEs. This ensures
5658 * consistent results. Note we assume it's OK to scribble on the passed
5659 * querytree!
5660 *
5661 * We are only deparsing the query (we are not about to execute it), so we
5662 * only need AccessShareLock on the relations it mentions.
5663 */
5665
5672 rtable_size != 1);
5673 context.prettyFlags = prettyFlags;
5674 context.wrapColumn = wrapColumn;
5676 context.colNamesVisible = colNamesVisible;
5680
5682
5684 {
5686 /* We set context.resultDesc only if it's a SELECT */
5687 context.resultDesc = resultDesc;
5688 get_select_query_def(query, &context);
5689 break;
5690
5692 get_update_query_def(query, &context);
5693 break;
5694
5696 get_insert_query_def(query, &context);
5697 break;
5698
5700 get_delete_query_def(query, &context);
5701 break;
5702
5704 get_merge_query_def(query, &context);
5705 break;
5706
5709 break;
5710
5712 get_utility_query_def(query, &context);
5713 break;
5714
5715 default:
5717 query->commandType);
5718 break;
5719 }
5720}
5721
5722/* ----------
5723 * get_values_def - Parse back a VALUES list
5724 * ----------
5725 */
5726static void
5728{
5732
5734
5736 {
5740
5743 else
5745
5748 {
5750
5753 else
5755
5756 /*
5757 * Print the value. Whole-row Vars need special treatment.
5758 */
5760 }
5762 }
5763}
5764
5765/* ----------
5766 * get_with_clause - Parse back a WITH clause
5767 * ----------
5768 */
5769static void
5771{
5774 ListCell *l;
5775
5777 return;
5778
5780 {
5783 }
5784
5785 if (query->hasRecursive)
5787 else
5790 {
5792
5795 if (cte->aliascolnames)
5796 {
5797 bool first = true;
5799
5802 {
5803 if (first)
5804 first = false;
5805 else
5809 }
5811 }
5814 {
5816 break;
5819 break;
5822 break;
5823 }
5828 true,
5830 context->indentLevel);
5834
5835 if (cte->search_clause)
5836 {
5837 bool first = true;
5839
5841 cte->search_clause->search_breadth_first ? "BREADTH" : "DEPTH");
5842
5844 {
5845 if (first)
5846 first = false;
5847 else
5851 }
5852
5854 }
5855
5856 if (cte->cycle_clause)
5857 {
5858 bool first = true;
5860
5862
5864 {
5865 if (first)
5866 first = false;
5867 else
5871 }
5872
5874
5875 {
5878
5879 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
5881 {
5886 }
5887 }
5888
5890 }
5891
5893 }
5894
5896 {
5899 }
5900 else
5902}
5903
5904/* ----------
5905 * get_select_query_def - Parse back a SELECT parsetree
5906 * ----------
5907 */
5908static void
5910{
5913 ListCell *l;
5914
5915 /* Insert the WITH clause if given */
5916 get_with_clause(query, context);
5917
5918 /* Subroutines may need to consult the SELECT targetlist and windowClause */
5921
5922 /*
5923 * If the Query node has a setOperations tree, then it's the top level of
5924 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
5925 * fields are interesting in the top query itself.
5926 */
5928 {
5930 /* ORDER BY clauses must be simple in this case */
5932 }
5933 else
5934 {
5935 get_basic_select_query(query, context);
5937 }
5938
5939 /* Add the ORDER BY clause if given */
5941 {
5945 force_colno, context);
5946 }
5947
5948 /*
5949 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
5950 * standard spelling of LIMIT.
5951 */
5953 {
5957 }
5959 {
5961 {
5962 /*
5963 * The limitCount arg is a c_expr, so it needs parens. Simple
5964 * literals and function expressions would not need parens, but
5965 * unfortunately it's hard to tell if the expression will be
5966 * printed as a simple literal like 123 or as a typecast
5967 * expression, like '-123'::int4. The grammar accepts the former
5968 * without quoting, but not the latter.
5969 */
5976 }
5977 else
5978 {
5984 else
5986 }
5987 }
5988
5989 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
5990 if (query->hasForUpdate)
5991 {
5993 {
5995
5996 /* don't print implicit clauses */
5998 continue;
5999
6000 appendContextKeyword(context,
6003
6006 context)));
6011 }
6012 }
6013}
6014
6015static char *
6017{
6018 switch (strength)
6019 {
6021 /* we intentionally throw an error for LCS_NONE */
6023 (int) strength);
6024 break;
6026 return " FOR KEY SHARE";
6028 return " FOR SHARE";
6030 return " FOR NO KEY UPDATE";
6032 return " FOR UPDATE";
6033 }
6035}
6036
6037/*
6038 * Detect whether query looks like SELECT ... FROM VALUES(),
6039 * with no need to rename the output columns of the VALUES RTE.
6040 * If so, return the VALUES RTE. Otherwise return NULL.
6041 */
6044{
6047
6048 /*
6049 * We want to detect a match even if the Query also contains OLD or NEW
6050 * rule RTEs. So the idea is to scan the rtable and see if there is only
6051 * one inFromCl RTE that is a VALUES RTE.
6052 */
6054 {
6056
6058 {
6059 if (result)
6061 result = rte;
6062 }
6064 continue; /* ignore rule entries */
6065 else
6067 }
6068
6069 /*
6070 * We don't need to check the targetlist in any great detail, because
6071 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6072 * appear inside auto-generated sub-queries with very restricted
6073 * structure. However, DefineView might have modified the tlist by
6074 * injecting new column aliases, or we might have some other column
6075 * aliases forced by a resultDesc. We can only simplify if the RTE's
6076 * column names match the names that get_target_list() would select.
6077 */
6078 if (result)
6079 {
6081 int colno;
6082
6085 colno = 0;
6087 {
6090 char *colname;
6091
6094
6095 /* compute name that get_target_list would use for column */
6096 colno++;
6099 else
6100 colname = tle->resname;
6101
6102 /* does it match the VALUES RTE? */
6105 }
6106 }
6107
6108 return result;
6109}
6110
6111static void
6113{
6117 ListCell *l;
6118
6120 {
6123 }
6124
6125 /*
6126 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6127 * VALUES part. This reverses what transformValuesClause() did at parse
6128 * time.
6129 */
6132 {
6134 return;
6135 }
6136
6137 /*
6138 * Build up the query string - first we say SELECT
6139 */
6140 if (query->isReturn)
6142 else
6144
6145 /* Add the DISTINCT clause if given */
6147 {
6148 if (query->hasDistinctOn)
6149 {
6153 {
6155
6158 false, context);
6160 }
6162 }
6163 else
6165 }
6166
6167 /* Then we tell what to select (the targetlist) */
6169
6170 /* Add the FROM clause if needed */
6172
6173 /* Add the WHERE clause if given */
6175 {
6179 }
6180
6181 /* Add the GROUP BY clause if given */
6183 {
6185
6190
6193
6197 {
6200 {
6202
6205 false, context);
6207 }
6208 }
6209 else
6210 {
6213 {
6215
6219 }
6220 }
6221
6223 }
6224
6225 /* Add the HAVING clause if given */
6227 {
6231 }
6232
6233 /* Add the WINDOW clause if needed */
6235 get_rule_windowclause(query, context);
6236}
6237
6238/* ----------
6239 * get_target_list - Parse back a SELECT target list
6240 *
6241 * This is also used for RETURNING lists in INSERT/UPDATE/DELETE/MERGE.
6242 * ----------
6243 */
6244static void
6246{
6251 int colno;
6252 ListCell *l;
6253
6254 /* we use targetbuf to hold each TLE's text temporarily */
6256
6258 colno = 0;
6259 foreach(l, targetList)
6260 {
6262 char *colname;
6264
6266 continue; /* ignore junk entries */
6267
6270 colno++;
6271
6272 /*
6273 * Put the new field text into targetbuf so we can decide after we've
6274 * got it whether or not it needs to go on a new line.
6275 */
6278
6279 /*
6280 * We special-case Var nodes rather than using get_rule_expr. This is
6281 * needed because get_rule_expr will display a whole-row Var as
6282 * "foo.*", which is the preferred notation in most contexts, but at
6283 * the top level of a SELECT list it's not right (the parser will
6284 * expand that notation into multiple columns, yielding behavior
6285 * different from a whole-row Var). We need to call get_variable
6286 * directly so that we can tell it to do the right thing, and so that
6287 * we can get the attribute name which is the default AS label.
6288 */
6290 {
6292 }
6293 else
6294 {
6296
6297 /*
6298 * When colNamesVisible is true, we should always show the
6299 * assigned column name explicitly. Otherwise, show it only if
6300 * it's not FigureColname's fallback.
6301 */
6303 }
6304
6305 /*
6306 * Figure out what the result column should be called. In the context
6307 * of a view, use the view's tuple descriptor (so as to pick up the
6308 * effects of any column RENAME that's been done on the view).
6309 * Otherwise, just use what we can find in the TLE.
6310 */
6313 colno - 1)->attname);
6314 else
6315 colname = tle->resname;
6316
6317 /* Show AS unless the column's name is correct as-is */
6318 if (colname) /* resname could be NULL */
6319 {
6322 }
6323
6324 /* Restore context's output buffer */
6326
6327 /* Consider line-wrapping if enabled */
6329 {
6331
6332 /* Does the new field start with a new line? */
6334 leading_nl_pos = 0;
6335 else
6336 leading_nl_pos = -1;
6337
6338 /* If so, we shouldn't add anything */
6340 {
6341 /* instead, remove any trailing spaces currently in buf */
6343 }
6344 else
6345 {
6347
6348 /* Locate the start of the current line in the output buffer */
6352 else
6353 trailing_nl++;
6354
6355 /*
6356 * Add a newline, plus some indentation, if the new field is
6357 * not the first and either the new field would cause an
6358 * overflow or the last field used more than one line.
6359 */
6360 if (colno > 1 &&
6362 last_was_multiline))
6365 }
6366
6367 /* Remember this field's multiline status for next iteration */
6368 last_was_multiline =
6370 }
6371
6372 /* Add the new field */
6374 }
6375
6376 /* clean up */
6378}
6379
6380static void
6382{
6384
6386 {
6388
6391
6392 /* Add WITH (OLD/NEW) options, if they're not the defaults */
6394 {
6396 quote_identifier(query->returningOldAlias));
6398 }
6400 {
6403 quote_identifier(query->returningNewAlias));
6404 else
6405 {
6407 quote_identifier(query->returningNewAlias));
6409 }
6410 }
6413
6414 /* Add the returning expressions themselves */
6416 }
6417}
6418
6419static void
6421{
6424
6425 /* Guard against excessively long or deeply-nested queries */
6426 CHECK_FOR_INTERRUPTS();
6427 check_stack_depth();
6428
6430 {
6434
6436
6437 /*
6438 * We need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y.
6439 * Also add parens if the leaf query contains its own set operations.
6440 * (That shouldn't happen unless one of the other clauses is also
6441 * present, see transformSetOperationTree; but let's be safe.)
6442 */
6444 subquery->sortClause ||
6445 subquery->rowMarks ||
6446 subquery->limitOffset ||
6447 subquery->limitCount ||
6448 subquery->setOperations);
6454 context->indentLevel);
6457 }
6459 {
6463
6464 /*
6465 * We force parens when nesting two SetOperationStmts, except when the
6466 * lefthand input is another setop of the same kind. Syntactically,
6467 * we could omit parens in rather more cases, but it seems best to use
6468 * parens to flag cases where the setop operator changes. If we use
6469 * parens, we also increase the indentation level for the child query.
6470 *
6471 * There are some cases in which parens are needed around a leaf query
6472 * too, but those are more easily handled at the next level down (see
6473 * code above).
6474 */
6476 {
6478
6481 else
6483 }
6484 else
6486
6488 {
6492 }
6493 else
6494 subindent = 0;
6495
6497
6502 else
6504
6506 {
6509 break;
6512 break;
6515 break;
6516 default:
6519 }
6522
6523 /* Always parenthesize if RHS is another setop */
6525
6526 /*
6527 * The indentation code here is deliberately a bit different from that
6528 * for the lefthand input, because we want the line breaks in
6529 * different places.
6530 */
6532 {
6535 }
6536 else
6537 subindent = 0;
6539
6540 /*
6541 * The output column names of the RHS sub-select don't matter.
6542 */
6545
6547
6549
6554 }
6555 else
6556 {
6559 }
6560}
6561
6562/*
6563 * Display a sort/group clause.
6564 *
6565 * Also returns the expression tree, so caller need not find it again.
6566 */
6569 deparse_context *context)
6570{
6573 Node *expr;
6574
6577
6578 /*
6579 * Use column-number form if requested by caller. Otherwise, if
6580 * expression is a constant, force it to be dumped with an explicit cast
6581 * as decoration --- this is because a simple integer constant is
6582 * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
6583 * we dump it without any decoration. Similarly, if it's just a Var,
6584 * there is risk of misinterpretation if the column name is reassigned in
6585 * the SELECT list, so we may need to force table qualification. And, if
6586 * it's anything more complex than a simple Var, then force extra parens
6587 * around it, to ensure it can't be misinterpreted as a cube() or rollup()
6588 * construct.
6589 */
6591 {
6594 }
6595 else if (!expr)
6596 /* do nothing, probably can't happen */ ;
6600 {
6601 /* Tell get_variable to check for name conflict */
6603
6607 }
6608 else
6609 {
6610 /*
6611 * We must force parens for function-like expressions even if
6612 * PRETTY_PAREN is off, since those are the ones in danger of
6613 * misparsing. For other expressions we need to force them only if
6614 * PRETTY_PAREN is on, since otherwise the expression will output them
6615 * itself. (We can't skip the parens.)
6616 */
6622
6628 }
6629
6630 return expr;
6631}
6632
6633/*
6634 * Display a GroupingSet
6635 */
6636static void
6639{
6640 ListCell *l;
6644
6646 {
6649 return;
6650
6652 {
6655
6657 {
6659
6662 false, context);
6664 }
6665
6668 }
6669 return;
6670
6673 break;
6676 break;
6680 break;
6681 }
6682
6684 {
6688 }
6689
6691}
6692
6693/*
6694 * Display an ORDER BY list.
6695 */
6696static void
6699{
6702 ListCell *l;
6703
6706 {
6710 TypeCacheEntry *typentry;
6711
6714 force_colno, context);
6716 /* See whether operator is default < or > for datatype */
6720 {
6721 /* ASC is default, so emit nothing for it */
6724 }
6726 {
6728 /* DESC defaults to NULLS FIRST */
6731 }
6732 else
6733 {
6736 sortcoltype,
6737 sortcoltype));
6738 /* be specific to eliminate ambiguity */
6741 else
6743 }
6745 }
6746}
6747
6748/*
6749 * Display a WINDOW clause.
6750 *
6751 * Note that the windowClause list might contain only anonymous window
6752 * specifications, in which case we should print nothing here.
6753 */
6754static void
6756{
6759 ListCell *l;
6760
6763 {
6765
6767 continue; /* ignore anonymous windows */
6768
6772 else
6774
6776
6778
6780 }
6781}
6782
6783/*
6784 * Display a window definition
6785 */
6786static void
6788 deparse_context *context)
6789{
6793 ListCell *l;
6794
6796 if (wc->refname)
6797 {
6800 }
6801 /* partition clauses are always inherited, so only print if no refname */
6803 {
6809 {
6811
6814 false, context);
6816 }
6818 }
6819 /* print ordering clause only if not inherited */
6821 {
6827 }
6828 /* framing clause is never inherited, so print unless it's default */
6830 {
6835 context);
6836 }
6838}
6839
6840/*
6841 * Append the description of a window's framing options to context->buf
6842 */
6843static void
6846 deparse_context *context)
6847{
6849
6851 {
6858 else
6867 {
6873 else
6875 }
6876 else
6879 {
6886 {
6892 else
6894 }
6895 else
6897 }
6904 /* we will now have a trailing space; remove it */
6906 }
6907}
6908
6909/*
6910 * Return the description of a window's framing options as a palloc'd string
6911 */
6912char *
6916{
6918 deparse_context context;
6919
6927 context.prettyFlags = 0;
6929 context.indentLevel = 0;
6934
6935 get_window_frame_options(frameOptions, startOffset, endOffset, &context);
6936
6938}
6939
6940/* ----------
6941 * get_insert_query_def - Parse back an INSERT parsetree
6942 * ----------
6943 */
6944static void
6946{
6952 ListCell *l;
6954
6955 /* Insert the WITH clause if given */
6956 get_with_clause(query, context);
6957
6958 /*
6959 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
6960 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
6961 */
6963 {
6965
6967 {
6971 }
6972
6974 {
6978 }
6979 }
6982
6983 /*
6984 * Start the query with INSERT INTO relname
6985 */
6988
6990 {
6993 }
6996
6997 /* Print the relation alias, if needed; INSERT requires explicit AS */
6999
7000 /* always want a space here */
7002
7003 /*
7004 * Add the insert-column-names list. Any indirection decoration needed on
7005 * the column names can be inferred from the top targetlist.
7006 */
7012 {
7014
7016 continue; /* ignore junk entries */
7017
7020
7021 /*
7022 * Put out name of target column; look in the catalogs, not at
7023 * tle->resname, since resname will fail to track RENAME.
7024 */
7027 tle->resno,
7028 false)));
7029
7030 /*
7031 * Print any indirection needed (subfields or subscripts), and strip
7032 * off the top-level nodes representing the indirection assignments.
7033 * Add the stripped expressions to strippedexprs. (If it's a
7034 * single-VALUES statement, the stripped expressions are the VALUES to
7035 * print below. Otherwise they're just Vars and not really
7036 * interesting.)
7037 */
7040 context));
7041 }
7044
7045 if (query->override)
7046 {
7051 }
7052
7054 {
7055 /* Add the SELECT */
7057 false,
7059 context->indentLevel);
7060 }
7062 {
7063 /* Add the multi-VALUES expression lists */
7065 }
7067 {
7068 /* Add the single-VALUES expression list */
7073 }
7074 else
7075 {
7076 /* No expressions, so it must be DEFAULT VALUES */
7078 }
7079
7080 /* Add ON CONFLICT if present */
7082 {
7084
7086
7088 {
7089 /* Add the single-VALUES expression list */
7093
7094 /* Add a WHERE clause (for partial indexes) if given */
7096 {
7098
7099 /*
7100 * Force non-prefixing of Vars, since parser assumes that they
7101 * belong to target relation. WHERE clause does not use
7102 * InferenceElem, so this is separately required.
7103 */
7106
7110
7112 }
7113 }
7115 {
7117
7118 if (!constraint)
7120 confl->constraint);
7122 quote_identifier(constraint));
7123 }
7124
7126 {
7128 }
7130 {
7132 /* Deparse targetlist */
7134 context, rte);
7135
7136 /* Add a WHERE clause if given */
7138 {
7142 }
7143 }
7144 else
7145 {
7148
7149 /* Add FOR [KEY] UPDATE/SHARE clause if present */
7152
7153 /* Add a WHERE clause if given */
7155 {
7159 }
7160 }
7161 }
7162
7163 /* Add RETURNING if present */
7165 get_returning_clause(query, context);
7166}
7167
7168
7169/* ----------
7170 * get_update_query_def - Parse back an UPDATE parsetree
7171 * ----------
7172 */
7173static void
7175{
7178
7179 /* Insert the WITH clause if given */
7180 get_with_clause(query, context);
7181
7182 /*
7183 * Start the query with UPDATE relname SET
7184 */
7188 {
7191 }
7195
7196 /* Print the relation alias, if needed */
7198
7200
7201 /* Deparse targetlist */
7203
7204 /* Add the FROM clause if needed */
7206
7207 /* Add a WHERE clause if given */
7209 {
7213 }
7214
7215 /* Add RETURNING if present */
7217 get_returning_clause(query, context);
7218}
7219
7220
7221/* ----------
7222 * get_update_query_targetlist_def - Parse back an UPDATE targetlist
7223 * ----------
7224 */
7225static void
7228{
7230 ListCell *l;
7236
7237 /*
7238 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
7239 * into a list. We expect them to appear, in ID order, in resjunk tlist
7240 * entries.
7241 */
7243 if (query->hasSubLinks) /* else there can't be any */
7244 {
7245 foreach(l, targetList)
7246 {
7248
7250 {
7252
7254 {
7257 }
7258 }
7259 }
7260 }
7263 remaining_ma_columns = 0;
7264
7265 /* Add the comma separated list of 'attname = value' */
7267 foreach(l, targetList)
7268 {
7270 Node *expr;
7271
7273 continue; /* ignore junk entries */
7274
7275 /* Emit separator (OK whether we're in multiassignment or not) */
7278
7279 /*
7280 * Check to see if we're starting a multiassignment group: if so,
7281 * output a left paren.
7282 */
7284 {
7285 /*
7286 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
7287 * Param. That could be buried under FieldStores and
7288 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
7289 * and underneath those there could be an implicit type coercion.
7290 * Because we would ignore implicit type coercions anyway, we
7291 * don't need to be as careful as processIndirection() is about
7292 * descending past implicit CoerceToDomains.
7293 */
7295 while (expr)
7296 {
7298 {
7300
7302 }
7304 {
7306
7308 break;
7309
7311 }
7313 {
7315
7317 break;
7319 }
7320 else
7321 break;
7322 }
7323 expr = strip_implicit_coercions(expr);
7324
7327 {
7330 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
7332 ((cur_ma_sublink->subLinkId << 16) | 1));
7334 }
7335 }
7336
7337 /*
7338 * Put out name of target column; look in the catalogs, not at
7339 * tle->resname, since resname will fail to track RENAME.
7340 */
7343 tle->resno,
7344 false)));
7345
7346 /*
7347 * Print any indirection needed (subfields or subscripts), and strip
7348 * off the top-level nodes representing the indirection assignments.
7349 */
7351
7352 /*
7353 * If we're in a multiassignment, skip printing anything more, unless
7354 * this is the last column; in which case, what we print should be the
7355 * sublink, not the Param.
7356 */
7358 {
7360 continue; /* not the last column of multiassignment */
7364 }
7365
7367
7369 }
7370}
7371
7372
7373/* ----------
7374 * get_delete_query_def - Parse back a DELETE parsetree
7375 * ----------
7376 */
7377static void
7379{
7382
7383 /* Insert the WITH clause if given */
7384 get_with_clause(query, context);
7385
7386 /*
7387 * Start the query with DELETE FROM relname
7388 */
7392 {
7395 }
7399
7400 /* Print the relation alias, if needed */
7402
7403 /* Add the USING clause if given */
7405
7406 /* Add a WHERE clause if given */
7408 {
7412 }
7413
7414 /* Add RETURNING if present */
7416 get_returning_clause(query, context);
7417}
7418
7419
7420/* ----------
7421 * get_merge_query_def - Parse back a MERGE parsetree
7422 * ----------
7423 */
7424static void
7426{
7431
7432 /* Insert the WITH clause if given */
7433 get_with_clause(query, context);
7434
7435 /*
7436 * Start the query with MERGE INTO relname
7437 */
7441 {
7444 }
7448
7449 /* Print the relation alias, if needed */
7451
7452 /* Print the source relation and join clause */
7457
7458 /*
7459 * Test for any NOT MATCHED BY SOURCE actions. If there are none, then
7460 * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
7461 * SQL standard. Otherwise, we have a non-SQL-standard query, so output
7462 * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
7463 * more explicit.
7464 */
7467 {
7469
7471 {
7473 break;
7474 }
7475 }
7476
7477 /* Print each merge action */
7479 {
7481
7485 {
7488 break;
7491 break;
7495 else
7497 break;
7498 default:
7501 }
7502
7504 {
7508 }
7511
7513 {
7514 /* This generally matches get_insert_query_def() */
7518
7520
7524 {
7526
7528
7531
7534 tle->resno,
7535 false)));
7538 context));
7539 }
7542
7544 {
7549 }
7550
7552 {
7557 }
7558 else
7560 }
7562 {
7565 context, rte);
7566 }
7571 }
7572
7573 /* Add RETURNING if present */
7575 get_returning_clause(query, context);
7576}
7577
7578
7579/* ----------
7580 * get_utility_query_def - Parse back a UTILITY parsetree
7581 * ----------
7582 */
7583static void
7585{
7587
7589 {
7591
7593 0, PRETTYINDENT_STD, 1);
7597 {
7600 }
7601 }
7602 else
7603 {
7604 /* Currently only NOTIFY utility commands can appear in rules */
7606 }
7607}
7608
7609/*
7610 * Display a Var appropriately.
7611 *
7612 * In some cases (currently only when recursing into an unnamed join)
7613 * the Var's varlevelsup has to be interpreted with respect to a context
7614 * above the current one; levelsup indicates the offset.
7615 *
7616 * If istoplevel is true, the Var is at the top level of a SELECT's
7617 * targetlist, which means we need special treatment of whole-row Vars.
7618 * Instead of the normal "tab.*", we'll print "tab.*::typename", which is a
7619 * dirty hack to prevent "tab.*" from being expanded into multiple columns.
7620 * (The parser will strip the useless coercion, so no inefficiency is added in
7621 * dump and reload.) We used to print just "tab" in such cases, but that is
7622 * ambiguous and will yield the wrong result if "tab" is also a plain column
7623 * name in the query.
7624 *
7625 * Returns the attname of the Var, or NULL if the Var has no attname (because
7626 * it is a whole-row Var or a subplan output reference).
7627 */
7628static char *
7630{
7636 int varno;
7637 AttrNumber varattno;
7639 char *refname;
7642
7643 /* Find appropriate nesting depth */
7647 var->varlevelsup, levelsup);
7649 netlevelsup);
7650
7651 /*
7652 * If we have a syntactic referent for the Var, and we're working from a
7653 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7654 * on the semantic referent. (Forcing use of the semantic referent when
7655 * printing plan trees is a design choice that's perhaps more motivated by
7656 * backwards compatibility than anything else. But it does have the
7657 * advantage of making plans more explicit.)
7658 */
7660 {
7661 varno = var->varnosyn;
7662 varattno = var->varattnosyn;
7663 }
7664 else
7665 {
7666 varno = var->varno;
7667 varattno = var->varattno;
7668 }
7669
7670 /*
7671 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7672 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7673 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
7674 * find the aliases previously assigned for this RTE.
7675 */
7677 {
7678 /*
7679 * We might have been asked to map child Vars to some parent relation.
7680 */
7682 {
7686 bool found = false;
7687
7688 /* Only map up to inheritance parents, not UNION ALL appendrels */
7692 {
7693 found = false;
7695 {
7697 break; /* safety check */
7700 break; /* Var is local to child */
7701 }
7702
7704 found = true;
7705
7706 /* If the parent is itself a child, continue up. */
7709 }
7710
7711 /*
7712 * If we found an ancestral rel, and that rel is included in
7713 * appendparents, print that column not the original one.
7714 */
7716 {
7717 varno = pvarno;
7718 varattno = pvarattno;
7719 }
7720 }
7721
7723
7724 /* might be returning old/new column value */
7726 refname = dpns->ret_old_alias;
7728 refname = dpns->ret_new_alias;
7729 else
7731
7733 attnum = varattno;
7734 }
7735 else
7736 {
7740 }
7741
7742 /*
7743 * The planner will sometimes emit Vars referencing resjunk elements of a
7744 * subquery's target list (this is currently only possible if it chooses
7745 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
7746 * Although we prefer to print subquery-referencing Vars using the
7747 * subquery's alias, that's not possible for resjunk items since they have
7748 * no alias. So in that case, drill down to the subplan and print the
7749 * contents of the referenced tlist item. This works because in a plan
7750 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
7751 * we'll have set dpns->inner_plan to reference the child plan node.
7752 */
7755 dpns->inner_plan)
7756 {
7759
7764
7767
7768 /*
7769 * Force parentheses because our caller probably assumed a Var is a
7770 * simple expression.
7771 */
7777
7780 }
7781
7782 /*
7783 * If it's an unnamed join, look at the expansion of the alias variable.
7784 * If it's a simple reference to one of the input vars, then recursively
7785 * print the name of that var instead. When it's not a simple reference,
7786 * we have to just print the unqualified join column name. (This can only
7787 * happen with "dangerous" merged columns in a JOIN USING; we took pains
7788 * previously to make the unqualified column name unique in such cases.)
7789 *
7790 * This wouldn't work in decompiling plan trees, because we don't store
7791 * joinaliasvars lists after planning; but a plan tree should never
7792 * contain a join alias variable.
7793 */
7795 {
7799 {
7801
7803 /* we intentionally don't strip implicit coercions here */
7805 {
7807 istoplevel, context);
7808 }
7809 }
7810
7811 /*
7812 * Unnamed join has no refname. (Note: since it's unnamed, there is
7813 * no way the user could have referenced it to create a whole-row Var
7814 * for it. So we don't have to cover that case below.)
7815 */
7817 }
7818
7822 {
7823 /* Get column name to use from the colinfo struct */
7828
7829 /*
7830 * If we find a Var referencing a dropped column, it seems better to
7831 * print something (anything) than to fail. In general this should
7832 * not happen, but it used to be possible for some cases involving
7833 * functions returning named composite types, and perhaps there are
7834 * still bugs out there.
7835 */
7838 }
7839 else
7840 {
7841 /* System column - name is fixed, get it from the catalog */
7843 }
7844
7847
7848 /*
7849 * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
7850 * clause, we may need to add a table-name prefix to prevent
7851 * findTargetlistEntrySQL92 from misinterpreting the name as an
7852 * output-column name. To avoid cluttering the output with unnecessary
7853 * prefixes, do so only if there is a name match to a SELECT tlist item
7854 * that is different from the Var.
7855 */
7857 {
7858 int colno = 0;
7859
7861 {
7862 char *colname;
7863
7865 continue; /* ignore junk entries */
7866 colno++;
7867
7868 /* This must match colname-choosing logic in get_target_list() */
7871 colno - 1)->attname);
7872 else
7873 colname = tle->resname;
7874
7877 {
7879 break;
7880 }
7881 }
7882 }
7883
7885 {
7888 }
7891 else
7892 {
7896 format_type_with_typemod(var->vartype,
7897 var->vartypmod));
7898 }
7899
7901}
7902
7903/*
7904 * Deparse a Var which references OUTER_VAR, INNER_VAR, or INDEX_VAR. This
7905 * routine is actually a callback for resolve_special_varno, which handles
7906 * finding the correct TargetEntry. We get the expression contained in that
7907 * TargetEntry and just need to deparse it, a job we can throw back on
7908 * get_rule_expr.
7909 */
7910static void
7912{
7914
7915 /*
7916 * For a non-Var referent, force parentheses because our caller probably
7917 * assumed a Var is a simple expression.
7918 */
7924}
7925
7926/*
7927 * Chase through plan references to special varnos (OUTER_VAR, INNER_VAR,
7928 * INDEX_VAR) until we find a real Var or some kind of non-Var node; then,
7929 * invoke the callback provided.
7930 */
7931static void
7934{
7935 Var *var;
7937
7938 /* This function is recursive, so let's be paranoid. */
7939 check_stack_depth();
7940
7941 /* If it's not a Var, invoke the callback. */
7943 {
7944 (*callback) (node, context, callback_arg);
7945 return;
7946 }
7947
7948 /* Find appropriate nesting depth */
7949 var = (Var *) node;
7951 var->varlevelsup);
7952
7953 /*
7954 * If varno is special, recurse. (Don't worry about varnosyn; if we're
7955 * here, we already decided not to use that.)
7956 */
7958 {
7962
7966
7967 /*
7968 * If we're descending to the first child of an Append or MergeAppend,
7969 * update appendparents. This will affect deparsing of all Vars
7970 * appearing within the eventually-resolved subexpression.
7971 */
7973
7980
7983 callback, callback_arg);
7986 return;
7987 }
7989 {
7992
7996
7999 callback, callback_arg);
8001 return;
8002 }
8004 {
8006
8010
8012 callback, callback_arg);
8013 return;
8014 }
8017
8018 /* Not special. Just invoke the callback. */
8019 (*callback) (node, context, callback_arg);
8020}
8021
8022/*
8023 * Get the name of a field of an expression of composite type. The
8024 * expression is usually a Var, but we handle other cases too.
8025 *
8026 * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
8027 *
8028 * This is fairly straightforward when the expression has a named composite
8029 * type; we need only look up the type in the catalogs. However, the type
8030 * could also be RECORD. Since no actual table or view column is allowed to
8031 * have type RECORD, a Var of type RECORD must refer to a JOIN or FUNCTION RTE
8032 * or to a subquery output. We drill down to find the ultimate defining
8033 * expression and attempt to infer the field name from it. We ereport if we
8034 * can't determine the name.
8035 *
8036 * Similarly, a PARAM of type RECORD has to refer to some expression of
8037 * a determinable composite type.
8038 */
8039static const char *
8042{
8047 int varno;
8048 AttrNumber varattno;
8050 Node *expr;
8051
8052 /*
8053 * If it's a RowExpr that was expanded from a whole-row Var, use the
8054 * column names attached to it. (We could let get_expr_result_tupdesc()
8055 * handle this, but it's much cheaper to just pull out the name we need.)
8056 */
8058 {
8060
8063 }
8064
8065 /*
8066 * If it's a Param of type RECORD, try to find what the Param refers to.
8067 */
8069 {
8072
8074 if (expr)
8075 {
8076 /* Found a match, so recurse to decipher the field name */
8078 const char *result;
8079
8082 0, context);
8084 return result;
8085 }
8086 }
8087
8088 /*
8089 * If it's a Var of type RECORD, we have to find what the Var refers to;
8090 * if not, we can use get_expr_result_tupdesc().
8091 */
8093 var->vartype != RECORDOID)
8094 {
8096 /* Got the tupdesc, so we can extract the field name */
8099 }
8100
8101 /* Find appropriate nesting depth */
8105 var->varlevelsup, levelsup);
8107 netlevelsup);
8108
8109 /*
8110 * If we have a syntactic referent for the Var, and we're working from a
8111 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8112 * on the semantic referent. (See comments in get_variable().)
8113 */
8115 {
8116 varno = var->varnosyn;
8117 varattno = var->varattnosyn;
8118 }
8119 else
8120 {
8121 varno = var->varno;
8122 varattno = var->varattno;
8123 }
8124
8125 /*
8126 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8127 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8128 * down into the subplans, or INDEX_VAR, which is resolved similarly.
8129 *
8130 * Note: unlike get_variable and resolve_special_varno, we need not worry
8131 * about inheritance mapping: a child Var should have the same datatype as
8132 * its parent, and here we're really only interested in the Var's type.
8133 */
8135 {
8137 attnum = varattno;
8138 }
8140 {
8143 const char *result;
8144
8148
8151
8153 levelsup, context);
8154
8156 return result;
8157 }
8159 {
8162 const char *result;
8163
8167
8170
8172 levelsup, context);
8173
8175 return result;
8176 }
8178 {
8180 const char *result;
8181
8185
8187
8189 levelsup, context);
8190
8191 return result;
8192 }
8193 else
8194 {
8197 }
8198
8200 {
8201 /* Var is whole-row reference to RTE, so select the right field */
8203 }
8204
8205 /*
8206 * This part has essentially the same logic as the parser's
8207 * expandRecordVariable() function, but we are dealing with a different
8208 * representation of the input context, and we only need one field name
8209 * not a TupleDesc. Also, we need special cases for finding subquery and
8210 * CTE subplans when deparsing Plan trees.
8211 */
8213
8215 {
8220
8221 /*
8222 * This case should not occur: a column of a table, values list,
8223 * or ENR shouldn't have type RECORD. Fall through and fail (most
8224 * likely) at the bottom.
8225 */
8226 break;
8228 /* Subselect-in-FROM: examine sub-select's output expr */
8229 {
8231 {
8233 attnum);
8234
8240 {
8241 /*
8242 * Recurse into the sub-select to see what its Var
8243 * refers to. We have to build an additional level of
8244 * namespace to keep in step with varlevelsup in the
8245 * subselect; furthermore, the subquery RTE might be
8246 * from an outer query level, in which case the
8247 * namespace for the subselect must have that outer
8248 * level as parent namespace.
8249 */
8253 const char *result;
8254
8256 netlevelsup);
8257
8259 parent_namespaces);
8260
8262
8264 0, context);
8265
8267
8268 return result;
8269 }
8270 /* else fall through to inspect the expression */
8271 }
8272 else
8273 {
8274 /*
8275 * We're deparsing a Plan tree so we don't have complete
8276 * RTE entries (in particular, rte->subquery is NULL). But
8277 * the only place we'd normally see a Var directly
8278 * referencing a SUBQUERY RTE is in a SubqueryScan plan
8279 * node, and we can look into the child plan's tlist
8280 * instead. An exception occurs if the subquery was
8281 * proven empty and optimized away: then we'd find such a
8282 * Var in a childless Result node, and there's nothing in
8283 * the plan tree that would let us figure out what it had
8284 * originally referenced. In that case, fall back on
8285 * printing "fN", analogously to the default column names
8286 * for RowExprs.
8287 */
8290 const char *result;
8291
8293 {
8295
8299 }
8301
8305 attnum);
8308
8310 levelsup, context);
8311
8313 return result;
8314 }
8315 }
8316 break;
8318 /* Join RTE --- recursively inspect the alias variable */
8324 /* we intentionally don't strip implicit coercions here */
8327 var->varlevelsup + levelsup,
8328 context);
8329 /* else fall through to inspect the expression */
8330 break;
8333
8334 /*
8335 * We couldn't get here unless a function is declared with one of
8336 * its result columns as RECORD, which is not allowed.
8337 */
8338 break;
8340 /* CTE reference: examine subquery's output expr */
8341 {
8343 Index ctelevelsup;
8345
8346 /*
8347 * Try to find the referenced CTE using the namespace stack.
8348 */
8352 else
8353 {
8355
8359 {
8362 break;
8363 }
8364 }
8366 {
8369 attnum);
8370
8376 {
8377 /*
8378 * Recurse into the CTE to see what its Var refers to.
8379 * We have to build an additional level of namespace
8380 * to keep in step with varlevelsup in the CTE;
8381 * furthermore it could be an outer CTE (compare
8382 * SUBQUERY case above).
8383 */
8387 const char *result;
8388
8390 ctelevelsup);
8391
8393 parent_namespaces);
8394
8396
8398 0, context);
8399
8401
8402 return result;
8403 }
8404 /* else fall through to inspect the expression */
8405 }
8406 else
8407 {
8408 /*
8409 * We're deparsing a Plan tree so we don't have a CTE
8410 * list. But the only places we'd normally see a Var
8411 * directly referencing a CTE RTE are in CteScan or
8412 * WorkTableScan plan nodes. For those cases,
8413 * set_deparse_plan arranged for dpns->inner_plan to be
8414 * the plan node that emits the CTE or RecursiveUnion
8415 * result, and we can look at its tlist instead. As
8416 * above, this can fail if the CTE has been proven empty,
8417 * in which case fall back to "fN".
8418 */
8421 const char *result;
8422
8424 {
8426
8430 }
8433
8437 attnum);
8440
8442 levelsup, context);
8443
8445 return result;
8446 }
8447 }
8448 break;
8450
8451 /*
8452 * We couldn't get here: any Vars that reference the RTE_GROUP RTE
8453 * should have been replaced with the underlying grouping
8454 * expressions.
8455 */
8456 break;
8457 }
8458
8459 /*
8460 * We now have an expression we can't expand any more, so see if
8461 * get_expr_result_tupdesc() can do anything with it.
8462 */
8464 /* Got the tupdesc, so we can extract the field name */
8467}
8468
8469/*
8470 * Try to find the referenced expression for a PARAM_EXEC Param that might
8471 * reference a parameter supplied by an upper NestLoop or SubPlan plan node.
8472 *
8473 * If successful, return the expression and set *dpns_p and *ancestor_cell_p
8474 * appropriately for calling push_ancestor_plan(). If no referent can be
8475 * found, return NULL.
8476 */
8480{
8481 /* Initialize output parameters to prevent compiler warnings */
8484
8485 /*
8486 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
8487 * SubPlan argument. This will necessarily be in some ancestor of the
8488 * current expression's Plan node.
8489 */
8491 {
8495
8498
8500 {
8503
8504 /*
8505 * NestLoops transmit params to their inner child only.
8506 */
8509 {
8511
8513 {
8515
8517 {
8518 /* Found a match, so return it */
8522 }
8523 }
8524 }
8525
8526 /*
8527 * If ancestor is a SubPlan, check the arguments it provides.
8528 */
8530 {
8534
8536 {
8539
8541 {
8542 /*
8543 * Found a match, so return it. But, since Vars in
8544 * the arg are to be evaluated in the surrounding
8545 * context, we have to point to the next ancestor item
8546 * that is *not* a SubPlan.
8547 */
8549
8552 {
8554
8556 {
8560 }
8561 }
8563 }
8564 }
8565
8566 /* SubPlan isn't a kind of Plan, so skip the rest */
8567 continue;
8568 }
8569
8570 /*
8571 * We need not consider the ancestor's initPlan list, since
8572 * initplans never have any parParams.
8573 */
8574
8575 /* No luck, crawl up to next ancestor */
8577 }
8578 }
8579
8580 /* No referent found */
8582}
8583
8584/*
8585 * Try to find a subplan/initplan that emits the value for a PARAM_EXEC Param.
8586 *
8587 * If successful, return the generating subplan/initplan and set *column_p
8588 * to the subplan's 0-based output column number.
8589 * Otherwise, return NULL.
8590 */
8593{
8594 /* Initialize output parameter to prevent compiler warnings */
8595 *column_p = 0;
8596
8597 /*
8598 * If it's a PARAM_EXEC parameter, search the current plan node as well as
8599 * ancestor nodes looking for a subplan or initplan that emits the value
8600 * for the Param. It could appear in the setParams of an initplan or
8601 * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
8602 */
8604 {
8605 SubPlan *result;
8608
8610
8611 /* First check the innermost plan node's initplans */
8613 if (result)
8614 return result;
8615
8616 /*
8617 * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
8618 * which can be referenced by Params elsewhere in the targetlist.
8619 * (Such Params should always be in the same targetlist, so there's no
8620 * need to do this work at upper plan nodes.)
8621 */
8623 {
8625 {
8627
8629 {
8631 {
8633 {
8634 /* Found a match, so return it. */
8636 return subplan;
8637 }
8638 }
8639 }
8640 }
8641 }
8642
8643 /* No luck, so check the ancestor nodes */
8645 {
8647
8648 /*
8649 * If ancestor is a SubPlan, check the paramIds it provides.
8650 */
8652 {
8654
8656 {
8658 {
8659 /* Found a match, so return it. */
8661 return subplan;
8662 }
8663 }
8664
8665 /* SubPlan isn't a kind of Plan, so skip the rest */
8666 continue;
8667 }
8668
8669 /*
8670 * Otherwise, it's some kind of Plan node, so check its initplans.
8671 */
8673 column_p);
8674 if (result)
8675 return result;
8676
8677 /* No luck, crawl up to next ancestor */
8678 }
8679 }
8680
8681 /* No generator found */
8683}
8684
8685/*
8686 * Subroutine for find_param_generator: search one Plan node's initplans
8687 */
8690{
8692 {
8694 {
8696 {
8697 /* Found a match, so return it. */
8699 return subplan;
8700 }
8701 }
8702 }
8704}
8705
8706/*
8707 * Display a Param appropriately.
8708 */
8709static void
8711{
8712 Node *expr;
8715 SubPlan *subplan;
8717
8718 /*
8719 * If it's a PARAM_EXEC parameter, try to locate the expression from which
8720 * the parameter was computed. This stanza handles only cases in which
8721 * the Param represents an input to the subplan we are currently in.
8722 */
8724 if (expr)
8725 {
8726 /* Found a match, so print it */
8730
8731 /* Switch attention to the ancestor plan node */
8733
8734 /*
8735 * Force prefixing of Vars, since they won't belong to the relation
8736 * being scanned in the original plan node.
8737 */
8740
8741 /*
8742 * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
8743 * upper-level Param, which wouldn't need extra parentheses.
8744 * Otherwise, insert parens to ensure the expression looks atomic.
8745 */
8752
8754
8757
8759
8761
8762 return;
8763 }
8764
8765 /*
8766 * Alternatively, maybe it's a subplan output, which we print as a
8767 * reference to the subplan. (We could drill down into the subplan and
8768 * print the relevant targetlist expression, but that has been deemed too
8769 * confusing since it would violate normal SQL scope rules. Also, we're
8770 * relying on this reference to show that the testexpr containing the
8771 * Param has anything to do with that subplan at all.)
8772 */
8774 if (subplan)
8775 {
8777
8780 else
8782
8785 nameprefix,
8786 subplan->plan_name, column + 1);
8787
8788 return;
8789 }
8790
8791 /*
8792 * If it's an external parameter, see if the outermost namespace provides
8793 * function argument names.
8794 */
8796 {
8799 param->paramid > 0 &&
8801 {
8803
8804 if (argname)
8805 {
8808
8809 /*
8810 * Qualify the parameter name if there are any other deparse
8811 * namespaces with range tables. This avoids qualifying in
8812 * trivial cases like "RETURN a + b", but makes it safe in all
8813 * other cases.
8814 */
8816 {
8818
8820 {
8822 break;
8823 }
8824 }
8826 {
8829 }
8830
8832 return;
8833 }
8834 }
8835 }
8836
8837 /*
8838 * Not PARAM_EXEC, or couldn't find referent: just print $N.
8839 *
8840 * It's a bug if we get here for anything except PARAM_EXTERN Params, but
8841 * in production builds printing $N seems more useful than failing.
8842 */
8844
8846}
8847
8848/*
8849 * get_simple_binary_op_name
8850 *
8851 * helper function for isSimpleNode
8852 * will return single char binary operator name, or NULL if it's not
8853 */
8854static const char *
8856{
8858
8860 {
8861 /* binary operator */
8864 const char *op;
8865
8868 return op;
8869 }
8871}
8872
8873
8874/*
8875 * isSimpleNode - check if given node is simple (doesn't need parenthesizing)
8876 *
8877 * true : simple in the context of parent node's type
8878 * false : not simple
8879 */
8880static bool
8882{
8883 if (!node)
8884 return false;
8885
8887 {
8894 /* single words: always simple */
8895 return true;
8896
8913 /* function-like: name(..) or name[..] */
8914 return true;
8915
8916 /* CASE keywords act as parentheses */
8918 return true;
8919
8921
8922 /*
8923 * appears simple since . has top precedence, unless parent is
8924 * T_FieldSelect itself!
8925 */
8927
8929
8930 /*
8931 * treat like FieldSelect (probably doesn't matter)
8932 */
8934
8936 /* maybe simple, check args */
8938 node, prettyFlags);
8941 node, prettyFlags);
8944 node, prettyFlags);
8947 node, prettyFlags);
8950 node, prettyFlags);
8953 node, prettyFlags);
8954
8956 {
8957 /* depends on parent node type; needs further checking */
8959 {
8960 const char *op;
8966
8968 if (!op)
8969 return false;
8970
8971 /* We know only the basic operators + - and * / % */
8975 return false;
8976
8979 return false;
8980
8984 return false;
8985
8987 return true; /* op binds tighter than parent */
8988
8990 return false;
8991
8992 /*
8993 * Operators are same priority --- can skip parens only if
8994 * we have (a - b) - c, not a - (b - c).
8995 */
8997 return true;
8998
8999 return false;
9000 }
9001 /* else do the same stuff as for T_SubLink et al. */
9002 }
9003 pg_fallthrough;
9004
9011 {
9013 {
9014 /* special handling for casts and COERCE_SQL_SYNTAX */
9016
9020 return false;
9021 return true; /* own parentheses */
9022 }
9035 return true;
9036 default:
9037 return false;
9038 }
9039
9042 {
9045 {
9048
9052 {
9056 return true;
9057 break;
9060 return true;
9061 break;
9062 }
9063 }
9064 return false;
9066 {
9067 /* special handling for casts and COERCE_SQL_SYNTAX */
9069
9073 return false;
9074 return true; /* own parentheses */
9075 }
9088 return true;
9089 default:
9090 return false;
9091 }
9092
9094 /* maybe simple, check args */
9096 node, prettyFlags);
9097
9098 default:
9099 break;
9100 }
9101 /* those we don't know: in dubio complexo */
9102 return false;
9103}
9104
9105
9106/*
9107 * appendContextKeyword - append a keyword to buffer
9108 *
9109 * If prettyPrint is enabled, perform a line break, and adjust indentation.
9110 * Otherwise, just append the keyword.
9111 */
9112static void
9115{
9117
9119 {
9121
9123
9124 /* remove any trailing spaces currently in the buffer ... */
9126 /* ... then add a newline and some spaces */
9128
9131 else
9132 {
9133 /*
9134 * If we're indented more than PRETTYINDENT_LIMIT characters, try
9135 * to conserve horizontal space by reducing the per-level
9136 * indentation. For best results the scale factor here should
9137 * divide all the indent amounts that get added to indentLevel
9138 * (PRETTYINDENT_STD, etc). It's important that the indentation
9139 * not grow unboundedly, else deeply-nested trees use O(N^2)
9140 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
9141 */
9144 (PRETTYINDENT_STD / 2);
9146 /* scale/wrap logic affects indentLevel, but not indentPlus */
9148 }
9150
9152
9155 context->indentLevel = 0;
9156 }
9157 else
9159}
9160
9161/*
9162 * removeStringInfoSpaces - delete trailing spaces from a buffer.
9163 *
9164 * Possibly this should move to stringinfo.c at some point.
9165 */
9166static void
9168{
9171}
9172
9173
9174/*
9175 * get_rule_expr_paren - deparse expr using get_rule_expr,
9176 * embracing the string with parentheses if necessary for prettyPrint.
9177 *
9178 * Never embrace if prettyFlags=0, because it's done in the calling node.
9179 *
9180 * Any node that does *not* embrace its argument node by sql syntax (with
9181 * parentheses, non-operator keywords like CASE/WHEN/ON, or comma etc) should
9182 * use get_rule_expr_paren instead of get_rule_expr so parentheses can be
9183 * added.
9184 */
9185static void
9188{
9190
9193
9196
9198
9201}
9202
9203static void
9206{
9207 /*
9208 * The order of array elements must correspond to the order of
9209 * JsonBehaviorType members.
9210 */
9212 {
9213 " NULL",
9214 " ERROR",
9215 " EMPTY",
9216 " TRUE",
9217 " FALSE",
9218 " UNKNOWN",
9219 " EMPTY ARRAY",
9220 " EMPTY OBJECT",
9221 " DEFAULT "
9222 };
9223
9226
9228
9231
9233}
9234
9235/*
9236 * get_json_expr_options
9237 *
9238 * Parse back common options for JSON_QUERY, JSON_VALUE, JSON_EXISTS and
9239 * JSON_TABLE columns.
9240 */
9241static void
9244{
9246 {
9251 /* The default */
9254
9257 /* The default */
9258 else
9260 }
9261
9264
9267}
9268
9269/* ----------
9270 * get_rule_expr - Parse back an expression
9271 *
9272 * Note: showimplicit determines whether we display any implicit cast that
9273 * is present at the top of the expression tree. It is a passed argument,
9274 * not a field of the context struct, because we change the value as we
9275 * recurse down into the expression. In general we suppress implicit casts
9276 * when the result type is known with certainty (eg, the arguments of an
9277 * OR must be boolean). We display implicit casts for arguments of functions
9278 * and operators, since this is needed to be certain that the same function
9279 * or operator will be chosen when the expression is re-parsed.
9280 * ----------
9281 */
9282static void
9285{
9287
9289 return;
9290
9291 /* Guard against excessively long or deeply-nested queries */
9292 CHECK_FOR_INTERRUPTS();
9293 check_stack_depth();
9294
9295 /*
9296 * Each level of get_rule_expr must emit an indivisible term
9297 * (parenthesized if necessary) to ensure result is reparsed into the same
9298 * expression tree. The only exception is that when the input is a List,
9299 * we emit the component items comma-separated with no surrounding
9300 * decoration; this is convenient for most callers.
9301 */
9303 {
9306 break;
9307
9310 break;
9311
9314 break;
9315
9318 break;
9319
9321 {
9323
9327 }
9328 break;
9329
9332 break;
9333
9336 break;
9337
9339 {
9342
9343 /*
9344 * If the argument is a CaseTestExpr, we must be inside a
9345 * FieldStore, ie, we are assigning to an element of an array
9346 * within a composite column. Since we already punted on
9347 * displaying the FieldStore's target information, just punt
9348 * here too, and display only the assignment source
9349 * expression.
9350 */
9352 {
9355 context, showimplicit);
9356 break;
9357 }
9358
9359 /*
9360 * Parenthesize the argument unless it's a simple Var or a
9361 * FieldSelect. (In particular, if it's another
9362 * SubscriptingRef, we *must* parenthesize to avoid
9363 * confusion.)
9364 */
9372
9373 /*
9374 * If there's a refassgnexpr, we want to print the node in the
9375 * format "container[subscripts] := refassgnexpr". This is
9376 * not legal SQL, so decompilation of INSERT or UPDATE
9377 * statements should always use processIndirection as part of
9378 * the statement-level syntax. We should only see this when
9379 * EXPLAIN tries to print the targetlist of a plan resulting
9380 * from such a statement.
9381 */
9383 {
9384 Node *refassgnexpr;
9385
9386 /*
9387 * Use processIndirection to print this node's subscripts
9388 * as well as any additional field selections or
9389 * subscripting in immediate descendants. It returns the
9390 * RHS expr that is actually being "assigned".
9391 */
9392 refassgnexpr = processIndirection(node, context);
9395 }
9396 else
9397 {
9398 /* Just an ordinary container fetch, so print subscripts */
9399 printSubscripts(sbsref, context);
9400 }
9401 }
9402 break;
9403
9406 break;
9407
9409 {
9411
9414 }
9415 break;
9416
9419 break;
9420
9422 {
9427
9435 }
9436 break;
9437
9439 {
9441
9445 }
9446 break;
9447
9449 {
9454
9464
9465 /*
9466 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
9467 * a bare sub-SELECT. Since we're here, the sub-SELECT must
9468 * be meant as a scalar sub-SELECT yielding an array value to
9469 * be used in ScalarArrayOpExpr; but the grammar will
9470 * preferentially interpret such a construct as an ANY/ALL
9471 * SubLink. To prevent misparsing the output that way, insert
9472 * a dummy coercion (which will be stripped by parse analysis,
9473 * so no inefficiency is added in dump and reload). This is
9474 * indeed most likely what the user wrote to get the construct
9475 * accepted in the first place.
9476 */
9485 }
9486 break;
9487
9489 {
9493
9495 {
9500 false, node);
9502 {
9505 false, node);
9506 }
9509 break;
9510
9515 false, node);
9517 {
9520 false, node);
9521 }
9524 break;
9525
9531 false, node);
9534 break;
9535
9536 default:
9539 }
9540 }
9541 break;
9542
9545 break;
9546
9548 {
9550
9551 /*
9552 * We cannot see an already-planned subplan in rule deparsing,
9553 * only while EXPLAINing a query plan. We don't try to
9554 * reconstruct the original SQL, just reference the subplan
9555 * that appears elsewhere in EXPLAIN's result. It does seem
9556 * useful to show the subLinkType and testexpr (if any), and
9557 * we also note whether the subplan will be hashed.
9558 */
9560 {
9564 break;
9568 break;
9572 break;
9574 /* Parenthesizing the testexpr seems sufficient */
9577 break;
9579 /* No need to decorate these subplan references */
9582 break;
9584 /* MULTIEXPR isn't executed in the normal way */
9587 break;
9591 break;
9593 /* This case is unreachable within expressions */
9596 break;
9597 }
9598
9600 {
9602
9603 /*
9604 * Push SubPlan into ancestors list while deparsing
9605 * testexpr, so that we can handle PARAM_EXEC references
9606 * to the SubPlan's paramIds. (This makes it look like
9607 * the SubPlan is an "ancestor" of the current plan node,
9608 * which is a little weird, but it does no harm.) In this
9609 * path, we don't need to mention the SubPlan explicitly,
9610 * because the referencing Params will show its existence.
9611 */
9614
9617
9619 }
9620 else
9621 {
9623
9624 /* No referencing Params, so show the SubPlan's name */
9627 else
9632 else
9635 }
9636 }
9637 break;
9638
9640 {
9643
9644 /*
9645 * This case cannot be reached in normal usage, since no
9646 * AlternativeSubPlan can appear either in parsetrees or
9647 * finished plan trees. We keep it just in case somebody
9648 * wants to use this code to print planner data structures.
9649 */
9652 {
9655
9658 else
9662 splan->plan_name);
9663 else
9665 splan->plan_name);
9668 }
9670 }
9671 break;
9672
9674 {
9678 const char *fieldname;
9680
9681 /*
9682 * Parenthesize the argument unless it's a SubscriptingRef or
9683 * another FieldSelect. Note in particular that it would be
9684 * WRONG to not parenthesize a Var argument; simplicity is not
9685 * the issue here, having the right number of names is.
9686 */
9694
9695 /*
9696 * Get and print the field name.
9697 */
9699 0, context);
9701 }
9702 break;
9703
9705 {
9708
9709 /*
9710 * There is no good way to represent a FieldStore as real SQL,
9711 * so decompilation of INSERT or UPDATE statements should
9712 * always use processIndirection as part of the
9713 * statement-level syntax. We should only get here when
9714 * EXPLAIN tries to print the targetlist of a plan resulting
9715 * from such a statement. The plan case is even harder than
9716 * ordinary rules would be, because the planner tries to
9717 * collapse multiple assignments to the same field or subfield
9718 * into one FieldStore; so we can see a list of target fields
9719 * not just one, and the arguments could be FieldStores
9720 * themselves. We don't bother to try to print the target
9721 * field names; we just print the source arguments, with a
9722 * ROW() around them if there's more than one. This isn't
9723 * terribly complete, but it's probably good enough for
9724 * EXPLAIN's purposes; especially since anything more would be
9725 * either hopelessly confusing or an even poorer
9726 * representation of what the plan is actually doing.
9727 */
9734 }
9735 break;
9736
9738 {
9741
9743 !showimplicit)
9744 {
9745 /* don't show the implicit cast */
9747 }
9748 else
9749 {
9751 relabel->resulttype,
9752 relabel->resulttypmod,
9753 node);
9754 }
9755 }
9756 break;
9757
9759 {
9762
9764 !showimplicit)
9765 {
9766 /* don't show the implicit cast */
9768 }
9769 else
9770 {
9772 iocoerce->resulttype,
9773 -1,
9774 node);
9775 }
9776 }
9777 break;
9778
9780 {
9783
9785 !showimplicit)
9786 {
9787 /* don't show the implicit cast */
9789 }
9790 else
9791 {
9793 acoerce->resulttype,
9794 acoerce->resulttypmod,
9795 node);
9796 }
9797 }
9798 break;
9799
9801 {
9804
9806 !showimplicit)
9807 {
9808 /* don't show the implicit cast */
9810 }
9811 else
9812 {
9814 convert->resulttype, -1,
9815 node);
9816 }
9817 }
9818 break;
9819
9821 {
9824
9829 generate_collation_name(collate->collOid));
9832 }
9833 break;
9834
9836 {
9839
9841 0, PRETTYINDENT_VAR, 0);
9843 {
9846 }
9848 {
9851
9853 {
9854 /*
9855 * The parser should have produced WHEN clauses of the
9856 * form "CaseTestExpr = RHS", possibly with an
9857 * implicit coercion inserted above the CaseTestExpr.
9858 * For accurate decompilation of rules it's essential
9859 * that we show just the RHS. However in an
9860 * expression that's been through the optimizer, the
9861 * WHEN clause could be almost anything (since the
9862 * equality operator could have been expanded into an
9863 * inline function). If we don't recognize the form
9864 * of the WHEN clause, just punt and display it as-is.
9865 */
9867 {
9869
9872 CaseTestExpr))
9874 }
9875 }
9876
9880 0, 0, 0);
9884 }
9888 0, 0, 0);
9893 -PRETTYINDENT_VAR, 0, 0);
9894 }
9895 break;
9896
9898 {
9899 /*
9900 * Normally we should never get here, since for expressions
9901 * that can contain this node type we attempt to avoid
9902 * recursing to it. But in an optimized expression we might
9903 * be unable to avoid that (see comments for CaseExpr). If we
9904 * do see one, print it as CASE_TEST_EXPR.
9905 */
9907 }
9908 break;
9909
9911 {
9913
9917
9918 /*
9919 * If the array isn't empty, we assume its elements are
9920 * coerced to the desired type. If it's empty, though, we
9921 * need an explicit coercion to the array type.
9922 */
9925 format_type_with_typemod(arrayexpr->array_typeid, -1));
9926 }
9927 break;
9928
9930 {
9936
9937 /*
9938 * If it's a named type and not RECORD, we may have to skip
9939 * dropped columns and/or claim there are NULLs for added
9940 * columns.
9941 */
9943 {
9944 tupdesc = lookup_rowtype_tupdesc(rowexpr->row_typeid, -1);
9946 }
9947
9948 /*
9949 * SQL99 allows "ROW" to be omitted when there is more than
9950 * one column, but for simplicity we always print it.
9951 */
9954 i = 0;
9956 {
9958
9961 {
9963 /* Whole-row Vars need special treatment here */
9966 }
9967 i++;
9968 }
9970 {
9972 {
9974 {
9978 }
9979 i++;
9980 }
9981
9982 ReleaseTupleDesc(tupdesc);
9983 }
9987 format_type_with_typemod(rowexpr->row_typeid, -1));
9988 }
9989 break;
9990
9992 {
9994
9995 /*
9996 * SQL99 allows "ROW" to be omitted when there is more than
9997 * one column, but for simplicity we always print it. Within
9998 * a ROW expression, whole-row Vars need special treatment, so
9999 * use get_rule_list_toplevel.
10000 */
10003
10004 /*
10005 * We assume that the name of the first-column operator will
10006 * do for all the rest too. This is definitely open to
10007 * failure, eg if some but not all operators were renamed
10008 * since the construct was parsed, but there seems no way to
10009 * be perfect.
10010 */
10017 }
10018 break;
10019
10021 {
10023
10027 }
10028 break;
10029
10031 {
10033
10035 {
10038 break;
10041 break;
10042 }
10045 }
10046 break;
10047
10049 {
10051
10052 /*
10053 * Note: this code knows that typmod for time, timestamp, and
10054 * timestamptz just prints as integer.
10055 */
10057 {
10060 break;
10063 break;
10066 break;
10069 break;
10072 svf->typmod);
10073 break;
10076 break;
10079 break;
10082 break;
10085 svf->typmod);
10086 break;
10089 break;
10092 break;
10095 break;
10098 break;
10101 break;
10104 break;
10105 }
10106 }
10107 break;
10108
10110 {
10115 Const *con;
10116
10118 {
10121 break;
10124 break;
10127 break;
10130 break;
10133 break;
10136 break;
10139 break;
10141 break;
10142 }
10144 {
10147 else
10149 }
10150 if (xexpr->name)
10151 {
10155 }
10157 {
10159 {
10164 }
10166 {
10169
10176 }
10179 }
10181 {
10185 {
10191 /* no extra decoration needed */
10193 break;
10196
10198 context, true);
10199
10201 Assert(!con->constisnull);
10204 " PRESERVE WHITESPACE");
10205 else
10207 " STRIP WHITESPACE");
10208 break;
10211
10213 context, true);
10214
10218 con->constisnull)
10220 else
10222
10224 if (con->constisnull)
10225 /* suppress STANDALONE NO VALUE */ ;
10226 else
10227 {
10229 {
10232 ", STANDALONE YES");
10233 break;
10236 ", STANDALONE NO");
10237 break;
10240 ", STANDALONE NO VALUE");
10241 break;
10242 default:
10243 break;
10244 }
10245 }
10246 break;
10249 break;
10250 }
10251 }
10253 {
10255 format_type_with_typemod(xexpr->type,
10256 xexpr->typmod));
10259 else
10261 }
10262
10265 else
10267 }
10268 break;
10269
10271 {
10273
10277
10278 /*
10279 * For scalar inputs, we prefer to print as IS [NOT] NULL,
10280 * which is shorter and traditional. If it's a rowtype input
10281 * but we're applying a scalar test, must print IS [NOT]
10282 * DISTINCT FROM NULL to be semantically correct.
10283 */
10286 {
10288 {
10291 break;
10294 break;
10295 default:
10298 }
10299 }
10300 else
10301 {
10303 {
10306 break;
10309 break;
10310 default:
10313 }
10314 }
10317 }
10318 break;
10319
10321 {
10323
10328 {
10331 break;
10334 break;
10337 break;
10340 break;
10343 break;
10346 break;
10347 default:
10350 }
10353 }
10354 break;
10355
10357 {
10360
10362 !showimplicit)
10363 {
10364 /* don't show the implicit cast */
10366 }
10367 else
10368 {
10370 ctest->resulttype,
10371 ctest->resulttypmod,
10372 node);
10373 }
10374 }
10375 break;
10376
10379 break;
10380
10383 break;
10384
10386 {
10388
10392 else
10394 cexpr->cursor_param);
10395 }
10396 break;
10397
10399 {
10401
10402 /*
10403 * This isn't exactly nextval(), but that seems close enough
10404 * for EXPLAIN's purposes.
10405 */
10409 NIL));
10411 }
10412 break;
10413
10415 {
10419
10420 /*
10421 * InferenceElem can only refer to target relation, so a
10422 * prefix is not useful, and indeed would cause parse errors.
10423 */
10426
10427 /*
10428 * Parenthesize the element unless it's a simple Var or a bare
10429 * function call. Follows pg_get_indexdef_worker().
10430 */
10434 COERCE_EXPLICIT_CALL)
10436
10440 context, false);
10443
10445
10449
10450 /* Add the operator class name, if not default */
10452 {
10455
10457 }
10458 }
10459 break;
10460
10462 {
10464
10465 /*
10466 * We cannot see a ReturningExpr in rule deparsing, only while
10467 * EXPLAINing a query plan (ReturningExpr nodes are only ever
10468 * adding during query rewriting). Just display the expression
10469 * returned (an expanded view column).
10470 */
10472 }
10473 break;
10474
10476 {
10478 ListCell *cell;
10480
10482 {
10484 break;
10485 }
10486
10488 {
10492
10496 break;
10497
10500
10504 {
10506
10510 }
10511
10513 break;
10514
10520
10524 break;
10525
10526 default:
10529 break;
10530 }
10531 }
10532 break;
10533
10535 {
10537
10540 }
10541 break;
10542
10545 break;
10546
10548 {
10550
10553
10555
10557
10558 /* TODO: handle FORMAT clause */
10559
10561 {
10564 break;
10567 break;
10570 break;
10571 default:
10572 break;
10573 }
10574
10577
10580 }
10581 break;
10582
10584 {
10586
10588 {
10591 break;
10594 break;
10597 break;
10598 default:
10601 }
10602
10604
10606
10608
10610 {
10612 *lc2;
10614
10616
10619 {
10623
10627 }
10628 }
10629
10634
10637 JSON_BEHAVIOR_NULL :
10638 JSON_BEHAVIOR_FALSE);
10639
10641 }
10642 break;
10643
10645 {
10647 ListCell *l;
10648
10651 {
10655 }
10656 }
10657 break;
10658
10661 break;
10662
10663 default:
10665 break;
10666 }
10667}
10668
10669/*
10670 * get_rule_expr_toplevel - Parse back a toplevel expression
10671 *
10672 * Same as get_rule_expr(), except that if the expr is just a Var, we pass
10673 * istoplevel = true not false to get_variable(). This causes whole-row Vars
10674 * to get printed with decoration that will prevent expansion of "*".
10675 * We need to use this in contexts such as ROW() and VALUES(), where the
10676 * parser would expand "foo.*" appearing at top level. (In principle we'd
10677 * use this in get_target_list() too, but that has additional worries about
10678 * whether to print AS, so it needs to invoke get_variable() directly anyway.)
10679 */
10680static void
10683{
10686 else
10688}
10689
10690/*
10691 * get_rule_list_toplevel - Parse back a list of toplevel expressions
10692 *
10693 * Apply get_rule_expr_toplevel() to each element of a List.
10694 *
10695 * This adds commas between the expressions, but caller is responsible
10696 * for printing surrounding decoration.
10697 */
10698static void
10701{
10704
10707 {
10709
10713 }
10714}
10715
10716/*
10717 * get_rule_expr_funccall - Parse back a function-call expression
10718 *
10719 * Same as get_rule_expr(), except that we guarantee that the output will
10720 * look like a function call, or like one of the things the grammar treats as
10721 * equivalent to a function call (see the func_expr_windowless production).
10722 * This is needed in places where the grammar uses func_expr_windowless and
10723 * you can't substitute a parenthesized a_expr. If what we have isn't going
10724 * to look like a function call, wrap it in a dummy CAST() expression, which
10725 * will satisfy the grammar --- and, indeed, is likely what the user wrote to
10726 * produce such a thing.
10727 */
10728static void
10731{
10734 else
10735 {
10737
10739 /* no point in showing any top-level implicit cast */
10743 exprTypmod(node)));
10744 }
10745}
10746
10747/*
10748 * Helper function to identify node types that satisfy func_expr_windowless.
10749 * If in doubt, "false" is always a safe answer.
10750 */
10751static bool
10753{
10755 return false; /* probably shouldn't happen */
10757 {
10759 /* OK, unless it's going to deparse as a cast */
10768 /* these are all accepted by func_expr_common_subexpr */
10769 return true;
10770 default:
10771 break;
10772 }
10773 return false;
10774}
10775
10776
10777/*
10778 * get_oper_expr - Parse back an OpExpr node
10779 */
10780static void
10782{
10786
10790 {
10791 /* binary operator */
10794
10797 generate_operator_name(opno,
10801 }
10802 else
10803 {
10804 /* prefix operator */
10806
10808 generate_operator_name(opno,
10809 InvalidOid,
10812 }
10815}
10816
10817/*
10818 * get_func_expr - Parse back a FuncExpr node
10819 */
10820static void
10823{
10827 int nargs;
10828 List *argnames;
10830 ListCell *l;
10831
10832 /*
10833 * If the function call came from an implicit coercion, then just show the
10834 * first argument --- unless caller wants to see implicit coercions.
10835 */
10837 {
10840 return;
10841 }
10842
10843 /*
10844 * If the function call came from a cast, then show the first argument
10845 * plus an explicit cast operation.
10846 */
10848 expr->funcformat == COERCE_IMPLICIT_CAST)
10849 {
10851 Oid rettype = expr->funcresulttype;
10853
10854 /* Get the typmod if this is a length-coercion function */
10856
10858 rettype, coercedTypmod,
10859 (Node *) expr);
10860
10861 return;
10862 }
10863
10864 /*
10865 * If the function was called using one of the SQL spec's random special
10866 * syntaxes, try to reproduce that. If we don't recognize the function,
10867 * fall through.
10868 */
10870 {
10872 return;
10873 }
10874
10875 /*
10876 * Normal function: display as proname(args). First we need to extract
10877 * the argument datatypes.
10878 */
10883 nargs = 0;
10884 argnames = NIL;
10886 {
10888
10892 nargs++;
10893 }
10894
10897 argnames, argtypes,
10898 expr->funcvariadic,
10899 &use_variadic,
10900 context->inGroupBy));
10901 nargs = 0;
10903 {
10904 if (nargs++ > 0)
10909 }
10911}
10912
10913/*
10914 * get_agg_expr - Parse back an Aggref node
10915 */
10916static void
10919{
10921 false);
10922}
10923
10924/*
10925 * get_agg_expr_helper - subroutine for get_agg_expr and
10926 * get_json_agg_constructor
10927 */
10928static void
10932{
10935 int nargs;
10937
10938 /*
10939 * For a combining aggregate, we look up and deparse the corresponding
10940 * partial aggregate instead. This is necessary because our input
10941 * argument list has been replaced; the new argument list always has just
10942 * one element, which will point to a partial Aggref that supplies us with
10943 * transition states to combine.
10944 */
10946 {
10948
10953 return;
10954 }
10955
10956 /*
10957 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
10958 * to avoid printing this when recursing from the code just above.
10959 */
10962
10963 /* Extract the argument types as seen by the parser */
10964 nargs = get_aggregate_argtypes(aggref, argtypes);
10965
10968 argtypes, aggref->aggvariadic,
10969 &use_variadic,
10970 context->inGroupBy);
10971
10972 /* Print the aggregate name, schema-qualified if needed */
10975
10977 {
10978 /*
10979 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
10980 * worry about inserting VARIADIC. So we can just dump the direct
10981 * args as-is.
10982 */
10983 Assert(!aggref->aggvariadic);
10988 }
10989 else
10990 {
10991 /* aggstar can be set only in zero-argument aggregates */
10992 if (aggref->aggstar)
10994 else
10995 {
10996 ListCell *l;
10998
10999 i = 0;
11001 {
11004
11007 continue;
11009 {
11011 {
11012 /*
11013 * the ABSENT ON NULL and WITH UNIQUE args are printed
11014 * separately, so ignore them here
11015 */
11017 break;
11018
11020 }
11021 else
11023 }
11027 }
11028 }
11029
11031 {
11034 }
11035 }
11036
11039
11041 {
11044 }
11045
11047}
11048
11049/*
11050 * This is a helper function for get_agg_expr(). It's used when we deparse
11051 * a combining Aggref; resolve_special_varno locates the corresponding partial
11052 * Aggref and then calls this.
11053 */
11054static void
11056{
11057 Aggref *aggref;
11059
11062
11063 aggref = (Aggref *) node;
11065}
11066
11067/*
11068 * get_windowfunc_expr - Parse back a WindowFunc node
11069 */
11070static void
11072{
11074}
11075
11076
11077/*
11078 * get_windowfunc_expr_helper - subroutine for get_windowfunc_expr and
11079 * get_json_agg_constructor
11080 */
11081static void
11085{
11088 int nargs;
11089 List *argnames;
11090 ListCell *l;
11091
11096 nargs = 0;
11097 argnames = NIL;
11099 {
11101
11105 nargs++;
11106 }
11107
11111 context->inGroupBy);
11112
11114
11115 /* winstar can be set only in zero-argument aggregates */
11116 if (wfunc->winstar)
11118 else
11119 {
11121 {
11125 }
11126 else
11128 }
11129
11132
11134 {
11137 }
11138
11140
11143
11145
11147 {
11148 /* Query-decompilation case: search the windowClause list */
11150 {
11152
11154 {
11155 if (wc->name)
11157 else
11159 break;
11160 }
11161 }
11164 wfunc->winref);
11165 }
11166 else
11167 {
11168 /*
11169 * In EXPLAIN, search the namespace stack for a matching WindowAgg
11170 * node (probably it's always the first entry), and print winname.
11171 */
11173 {
11175
11177 {
11179
11181 {
11183 break;
11184 }
11185 }
11186 }
11189 wfunc->winref);
11190 }
11191}
11192
11193/*
11194 * get_func_sql_syntax - Parse back a SQL-syntax function call
11195 *
11196 * Returns true if we successfully deparsed, false if we did not
11197 * recognize the function.
11198 */
11199static bool
11201{
11204
11206 {
11213 /* AT TIME ZONE ... note reversed argument order */
11216 (Node *) expr);
11219 (Node *) expr);
11221 return true;
11222
11226 /* AT LOCAL */
11229 (Node *) expr);
11231 return true;
11232
11246 /* (x1, x2) OVERLAPS (y1, y2) */
11256 return true;
11257
11264 /* EXTRACT (x FROM y) */
11266 {
11268
11271 !con->constisnull);
11273 }
11277 return true;
11278
11280 /* IS xxx NORMALIZED */
11283 (Node *) expr);
11286 {
11288
11291 !con->constisnull);
11293 TextDatumGetCString(con->constvalue));
11294 }
11296 return true;
11297
11299 /* COLLATION FOR */
11303 return true;
11304
11306 /* NORMALIZE() */
11310 {
11312
11315 !con->constisnull);
11317 TextDatumGetCString(con->constvalue));
11318 }
11320 return true;
11321
11328 /* OVERLAY() */
11336 {
11339 }
11341 return true;
11342
11346 /* POSITION() ... extra parens since args are b_expr not a_expr */
11352 return true;
11353
11360 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
11366 {
11369 }
11371 return true;
11372
11374 /* SUBSTRING SIMILAR/ESCAPE */
11382 return true;
11383
11387 /* TRIM() */
11390 {
11393 }
11397 return true;
11398
11402 /* TRIM() */
11405 {
11408 }
11412 return true;
11413
11417 /* TRIM() */
11420 {
11423 }
11427 return true;
11428
11431 return true;
11432
11434 /* XMLEXISTS ... extra parens because args are c_expr */
11440 return true;
11441 }
11442 return false;
11443}
11444
11445/* ----------
11446 * get_coercion_expr
11447 *
11448 * Make a string representation of a value coerced to a specific type
11449 * ----------
11450 */
11451static void
11455{
11457
11458 /*
11459 * Since parse_coerce.c doesn't immediately collapse application of
11460 * length-coercion functions to constants, what we'll typically see in
11461 * such cases is a Const with typmod -1 and a length-coercion function
11462 * right above it. Avoid generating redundant output. However, beware of
11463 * suppressing casts when the user actually wrote something like
11464 * 'foo'::text::char(3).
11465 *
11466 * Note: it might seem that we are missing the possibility of needing to
11467 * print a COLLATE clause for such a Const. However, a Const could only
11468 * have nondefault collation in a post-constant-folding tree, in which the
11469 * length coercion would have been folded too. See also the special
11470 * handling of CollateExpr in coerce_to_target_type(): any collation
11471 * marking will be above the coercion node, not below it.
11472 */
11476 {
11477 /* Show the constant without normal ::typename decoration */
11479 }
11480 else
11481 {
11487 }
11488
11489 /*
11490 * Never emit resulttype(arg) functional notation. A pg_proc entry could
11491 * take precedence, and a resulttype in pg_temp would require schema
11492 * qualification that format_type_with_typemod() would usually omit. We've
11493 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
11494 * would work fine.
11495 */
11498}
11499
11500/* ----------
11501 * get_const_expr
11502 *
11503 * Make a string representation of a Const
11504 *
11505 * showtype can be -1 to never show "::typename" decoration, or +1 to always
11506 * show it, or 0 to show it only if the constant wouldn't be assumed to be
11507 * the right type by default.
11508 *
11509 * If the Const's collation isn't default for its type, show that too.
11510 * We mustn't do this when showtype is -1 (since that means the caller will
11511 * print "::typename", and we can't put a COLLATE clause in between). It's
11512 * caller's responsibility that collation isn't missed in such cases.
11513 * ----------
11514 */
11515static void
11517{
11519 Oid typoutput;
11523
11524 if (constval->constisnull)
11525 {
11526 /*
11527 * Always label the type of a NULL constant to prevent misdecisions
11528 * about type when reparsing.
11529 */
11532 {
11535 constval->consttypmod));
11536 get_const_collation(constval, context);
11537 }
11538 return;
11539 }
11540
11542 &typoutput, &typIsVarlena);
11543
11545
11547 {
11549
11550 /*
11551 * INT4 can be printed without any decoration, unless it is
11552 * negative; in that case print it as '-nnn'::integer to ensure
11553 * that the output will re-parse as a constant, not as a constant
11554 * plus operator. In most cases we could get away with printing
11555 * (-nnn) instead, because of the way that gram.y handles negative
11556 * literals; but that doesn't work for INT_MIN, and it doesn't
11557 * seem that much prettier anyway.
11558 */
11561 else
11562 {
11565 }
11566 break;
11567
11569
11570 /*
11571 * NUMERIC can be printed without quotes if it looks like a float
11572 * constant (not an integer, and not Infinity or NaN) and doesn't
11573 * have a leading sign (for the same reason as for INT4).
11574 */
11577 {
11579 }
11580 else
11581 {
11584 }
11585 break;
11586
11590 else
11592 break;
11593
11594 default:
11596 break;
11597 }
11598
11600
11602 return;
11603
11604 /*
11605 * For showtype == 0, append ::typename unless the constant will be
11606 * implicitly typed as the right type when it is read in.
11607 *
11608 * XXX this code has to be kept in sync with the behavior of the parser,
11609 * especially make_const.
11610 */
11612 {
11615 /* These types can be left unlabeled */
11617 break;
11619 /* We determined above whether a label is needed */
11620 break;
11622
11623 /*
11624 * Float-looking constants will be typed as numeric, which we
11625 * checked above; but if there's a nondefault typmod we need to
11626 * show it.
11627 */
11628 needlabel |= (constval->consttypmod >= 0);
11629 break;
11630 default:
11632 break;
11633 }
11637 constval->consttypmod));
11638
11639 get_const_collation(constval, context);
11640}
11641
11642/*
11643 * helper for get_const_expr: append COLLATE if needed
11644 */
11645static void
11647{
11649
11651 {
11653
11654 if (constval->constcollid != typcollation)
11655 {
11657 generate_collation_name(constval->constcollid));
11658 }
11659 }
11660}
11661
11662/*
11663 * get_json_path_spec - Parse back a JSON path specification
11664 */
11665static void
11667{
11670 else
11672}
11673
11674/*
11675 * get_json_format - Parse back a JsonFormat node
11676 */
11677static void
11679{
11681 return;
11682
11685 " FORMAT JSONB" : " FORMAT JSON");
11686
11688 {
11690
11691 encoding =
11694
11696 }
11697}
11698
11699/*
11700 * get_json_returning - Parse back a JsonReturning structure
11701 */
11702static void
11705{
11707 return;
11708
11711 returning->typmod));
11712
11717}
11718
11719/*
11720 * get_json_constructor - Parse back a JsonConstructorExpr node
11721 */
11722static void
11725{
11731
11733 {
11735 return;
11736 }
11738 {
11740 return;
11741 }
11742
11744 {
11747 break;
11750 break;
11753 break;
11756 break;
11759 break;
11760 default:
11762 }
11763
11765
11768 {
11771 {
11773
11776 }
11777
11779 }
11780
11783}
11784
11785/*
11786 * Append options, if any, to the JSON constructor being deparsed
11787 */
11788static void
11790{
11792 {
11796 }
11797 else
11798 {
11802 }
11803
11806
11807 /*
11808 * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
11809 * support one.
11810 */
11813}
11814
11815/*
11816 * get_json_agg_constructor - Parse back an aggregate JsonConstructorExpr node
11817 */
11818static void
11821{
11823
11826
11834 is_json_objectagg);
11835 else
11838}
11839
11840/*
11841 * simple_quote_literal - Format a string as a SQL literal, append to buf
11842 */
11843static void
11845{
11847
11848 /*
11849 * We always form the string literal according to standard SQL rules.
11850 */
11853 {
11855
11859 }
11861}
11862
11863
11864/* ----------
11865 * get_sublink_expr - Parse back a sublink
11866 * ----------
11867 */
11868static void
11870{
11875
11878 else
11880
11881 /*
11882 * Note that we print the name of only the first operator, when there are
11883 * multiple combining operators. This is an approximation that could go
11884 * wrong in various scenarios (operators in different schemas, renamed
11885 * operators, etc) but there is not a whole lot we can do about it, since
11886 * the syntax allows only one operator to be shown.
11887 */
11889 {
11891 {
11892 /* single combining operator */
11894
11899 }
11901 {
11902 /* multiple combining operators, = or <> cases */
11904 ListCell *l;
11905
11909 {
11911
11919 }
11921 }
11923 {
11924 /* multiple combining operators, < <= > >= cases */
11926
11933 }
11934 else
11937 }
11938
11940
11942 {
11945 break;
11946
11950 else
11952 break;
11953
11956 break;
11957
11960 break;
11961
11966 break;
11967
11969 default:
11972 break;
11973 }
11974
11977
11980 context->indentLevel);
11981
11984 else
11986}
11987
11988
11989/* ----------
11990 * get_xmltable - Parse back a XMLTABLE function
11991 * ----------
11992 */
11993static void
11995{
11997
11999
12001 {
12003 *lc2;
12004 bool first = true;
12005
12008 {
12011
12012 if (!first)
12014 else
12015 first = false;
12016
12018 {
12022 }
12023 else
12024 {
12027 }
12028 }
12030 }
12031
12037
12039 {
12040 ListCell *l1;
12041 ListCell *l2;
12042 ListCell *l3;
12043 ListCell *l4;
12044 ListCell *l5;
12045 int colnum = 0;
12046
12048 forfive(l1, tf->colnames, l2, tf->coltypes, l3, tf->coltypmods,
12049 l4, tf->colexprs, l5, tf->coldefexprs)
12050 {
12056 bool ordinality = (tf->ordinalitycol == colnum);
12058
12059 if (colnum > 0)
12061 colnum++;
12062
12064 ordinality ? "FOR ORDINALITY" :
12065 format_type_with_typemod(typid, typmod));
12066 if (ordinality)
12067 continue;
12068
12070 {
12074 }
12076 {
12080 }
12081 if (notnull)
12083 }
12084 }
12085
12087}
12088
12089/*
12090 * get_json_table_nested_columns - Parse back nested JSON_TABLE columns
12091 */
12092static void
12096{
12098 {
12100
12103
12109 }
12111 {
12113
12115 needcomma);
12117 true);
12118 }
12119}
12120
12121/*
12122 * get_json_table_columns - Parse back JSON_TABLE columns
12123 */
12124static void
12126 deparse_context *context,
12128{
12134 int colnum = 0;
12135
12138
12141
12143 lc_coltype, tf->coltypes,
12144 lc_coltypmod, tf->coltypmods,
12145 lc_colvalexpr, tf->colvalexprs)
12146 {
12148 JsonExpr *colexpr;
12149 Oid typid;
12150 int32 typmod;
12151 bool ordinality;
12153
12157
12158 /* Skip columns that don't belong to this scan. */
12160 {
12161 colnum++;
12162 continue;
12163 }
12165 break;
12166
12169
12170 colnum++;
12171
12172 ordinality = !colexpr;
12173
12175
12177 ordinality ? "FOR ORDINALITY" :
12178 format_type_with_typemod(typid, typmod));
12179 if (ordinality)
12180 continue;
12181
12182 /*
12183 * Set default_behavior to guide get_json_expr_options() on whether to
12184 * emit the ON ERROR / EMPTY clauses.
12185 */
12187 {
12190 }
12191 else
12192 {
12194 {
12197
12199
12203 " FORMAT JSONB" : " FORMAT JSON");
12204 }
12205
12207 }
12208
12210
12212
12214 }
12215
12218 scan->colMin >= 0);
12219
12222
12224}
12225
12226/* ----------
12227 * get_json_table - Parse back a JSON_TABLE function
12228 * ----------
12229 */
12230static void
12232{
12236
12238
12241
12243
12245
12247
12249
12251
12253 {
12255 *lc2;
12257
12260
12263
12266 {
12270
12272
12276 );
12277 }
12278
12281 }
12282
12284 showimplicit);
12285
12288
12291
12293}
12294
12295/* ----------
12296 * get_tablefunc - Parse back a table function
12297 * ----------
12298 */
12299static void
12301{
12302 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12303
12308}
12309
12310/* ----------
12311 * get_from_clause - Parse back a FROM clause
12312 *
12313 * "prefix" is the keyword that denotes the start of the list of FROM
12314 * elements. It is FROM when used to parse back SELECT and UPDATE, but
12315 * is USING when parsing back DELETE.
12316 * ----------
12317 */
12318static void
12320{
12322 bool first = true;
12323 ListCell *l;
12324
12325 /*
12326 * We use the query's jointree as a guide to what to print. However, we
12327 * must ignore auto-added RTEs that are marked not inFromCl. (These can
12328 * only appear at the top level of the jointree, so it's sufficient to
12329 * check here.) This check also ensures we ignore the rule pseudo-RTEs
12330 * for NEW and OLD.
12331 */
12333 {
12335
12337 {
12340
12342 continue;
12343 }
12344
12345 if (first)
12346 {
12347 appendContextKeyword(context, prefix,
12349 first = false;
12350
12351 get_from_clause_item(jtnode, query, context);
12352 }
12353 else
12354 {
12356
12358
12359 /*
12360 * Put the new FROM item's text into itembuf so we can decide
12361 * after we've got it whether or not it needs to go on a new line.
12362 */
12365
12366 get_from_clause_item(jtnode, query, context);
12367
12368 /* Restore context's output buffer */
12370
12371 /* Consider line-wrapping if enabled */
12373 {
12374 /* Does the new item start with a new line? */
12376 {
12377 /* If so, we shouldn't add anything */
12378 /* instead, remove any trailing spaces currently in buf */
12380 }
12381 else
12382 {
12384
12385 /* Locate the start of the current line in the buffer */
12389 else
12390 trailing_nl++;
12391
12392 /*
12393 * Add a newline, plus some indentation, if the new item
12394 * would cause an overflow.
12395 */
12398 PRETTYINDENT_STD,
12399 PRETTYINDENT_VAR);
12400 }
12401 }
12402
12403 /* Add the new item */
12405
12406 /* clean up */
12408 }
12409 }
12410}
12411
12412static void
12414{
12417
12419 {
12424
12427
12428 /* Print the FROM item proper */
12430 {
12432 /* Normal relation RTE */
12436 context->namespaces));
12437 break;
12439 /* Subquery RTE */
12442 true,
12444 context->indentLevel);
12446 break;
12448 /* Function RTE */
12450
12451 /*
12452 * Omit ROWS FROM() syntax for just one function, unless it
12453 * has both a coldeflist and WITH ORDINALITY. If it has both,
12454 * we must use ROWS FROM() syntax to avoid ambiguity about
12455 * whether the coldeflist includes the ordinality column.
12456 */
12459 {
12461 /* we'll print the coldeflist below, if it has one */
12462 }
12463 else
12464 {
12467
12468 /*
12469 * If all the function calls in the list are to unnest,
12470 * and none need a coldeflist, then collapse the list back
12471 * down to UNNEST(args). (If we had more than one
12472 * built-in unnest function, this would get more
12473 * difficult.)
12474 *
12475 * XXX This is pretty ugly, since it makes not-terribly-
12476 * future-proof assumptions about what the parser would do
12477 * with the output; but the alternative is to emit our
12478 * nonstandard ROWS FROM() notation for what might have
12479 * been a perfectly spec-compliant multi-argument
12480 * UNNEST().
12481 */
12484 {
12486
12489 rtfunc->funccolnames != NIL)
12490 {
12492 break;
12493 }
12494 }
12495
12497 {
12499
12501 {
12504
12506 }
12507
12511 }
12512 else
12513 {
12515
12518 {
12520
12525 {
12526 /* Reconstruct the column definition list */
12528 get_from_clause_coldeflist(rtfunc,
12529 NULL,
12530 context);
12531 }
12532 funcno++;
12533 }
12535 }
12536 /* prevent printing duplicate coldeflist below */
12538 }
12541 break;
12544 break;
12546 /* Values list RTE */
12550 break;
12553 break;
12554 default:
12556 break;
12557 }
12558
12559 /* Print the relation alias, if needed */
12561
12562 /* Print the column definitions or aliases, if needed */
12564 {
12565 /* Reconstruct the columndef list, which is also the aliases */
12567 }
12568 else
12569 {
12570 /* Else print column aliases as needed */
12572 }
12573
12574 /* Tablesample clause must go after any alias */
12577 }
12579 {
12583
12587
12590
12592
12594 {
12598 -PRETTYINDENT_STD,
12599 PRETTYINDENT_STD,
12600 PRETTYINDENT_JOIN);
12601 else
12603 -PRETTYINDENT_STD,
12604 PRETTYINDENT_STD,
12605 PRETTYINDENT_JOIN);
12606 break;
12609 -PRETTYINDENT_STD,
12610 PRETTYINDENT_STD,
12611 PRETTYINDENT_JOIN);
12612 break;
12615 -PRETTYINDENT_STD,
12616 PRETTYINDENT_STD,
12617 PRETTYINDENT_JOIN);
12618 break;
12621 -PRETTYINDENT_STD,
12622 PRETTYINDENT_STD,
12623 PRETTYINDENT_JOIN);
12624 break;
12625 default:
12628 }
12629
12635
12637 {
12639 bool first = true;
12640
12642 /* Use the assigned names, not what's in usingClause */
12644 {
12646
12647 if (first)
12648 first = false;
12649 else
12652 }
12654
12658 }
12660 {
12667 }
12669 {
12670 /* If we didn't say CROSS JOIN above, we must provide an ON */
12672 }
12673
12676
12677 /* Yes, it's correct to put alias after the right paren ... */
12679 {
12680 /*
12681 * Note that it's correct to emit an alias clause if and only if
12682 * there was one originally. Otherwise we'd be converting a named
12683 * join to unnamed or vice versa, which creates semantic
12684 * subtleties we don't want. However, we might print a different
12685 * alias name than was there originally.
12686 */
12689 context)));
12691 }
12692 }
12693 else
12696}
12697
12698/*
12699 * get_rte_alias - print the relation's alias, if needed
12700 *
12701 * If printed, the alias is preceded by a space, or by " AS " if use_as is true.
12702 */
12703static void
12705 deparse_context *context)
12706{
12711
12713 {
12714 /* Always print alias if user provided one */
12716 }
12718 {
12719 /* Always print alias if we need to print column aliases */
12721 }
12723 {
12724 /*
12725 * No need to print alias if it's same as relation name (this would
12726 * normally be the case, but not if set_rtable_names had to resolve a
12727 * conflict).
12728 */
12731 }
12733 {
12734 /*
12735 * For a function RTE, always print alias. This covers possible
12736 * renaming of the function and/or instability of the FigureColname
12737 * rules for things that aren't simple functions. Note we'd need to
12738 * force it anyway for the columndef list case.
12739 */
12741 }
12744 {
12745 /*
12746 * For a subquery, always print alias. This makes the output
12747 * SQL-spec-compliant, even though we allow such aliases to be omitted
12748 * on input.
12749 */
12751 }
12753 {
12754 /*
12755 * No need to print alias if it's same as CTE name (this would
12756 * normally be the case, but not if set_rtable_names had to resolve a
12757 * conflict).
12758 */
12761 }
12762
12766 quote_identifier(refname));
12767}
12768
12769/*
12770 * get_column_alias_list - print column alias list for an RTE
12771 *
12772 * Caller must already have printed the relation's alias name.
12773 */
12774static void
12776{
12779 bool first = true;
12780
12781 /* Don't print aliases if not needed */
12783 return;
12784
12786 {
12788
12789 if (first)
12790 {
12792 first = false;
12793 }
12794 else
12797 }
12798 if (!first)
12800}
12801
12802/*
12803 * get_from_clause_coldeflist - reproduce FROM clause coldeflist
12804 *
12805 * When printing a top-level coldeflist (which is syntactically also the
12806 * relation's column alias list), use column names from colinfo. But when
12807 * printing a coldeflist embedded inside ROWS FROM(), we prefer to use the
12808 * original coldeflist's names, which are available in rtfunc->funccolnames.
12809 * Pass NULL for colinfo to select the latter behavior.
12810 *
12811 * The coldeflist is appended immediately (no space) to buf. Caller is
12812 * responsible for ensuring that an alias or AS is present before it.
12813 */
12814static void
12817 deparse_context *context)
12818{
12820 ListCell *l1;
12821 ListCell *l2;
12822 ListCell *l3;
12823 ListCell *l4;
12825
12827
12828 i = 0;
12829 forfour(l1, rtfunc->funccoltypes,
12830 l2, rtfunc->funccoltypmods,
12831 l3, rtfunc->funccolcollations,
12832 l4, rtfunc->funccolnames)
12833 {
12838
12841 else
12843
12845
12854 generate_collation_name(attcollation));
12855
12856 i++;
12857 }
12858
12860}
12861
12862/*
12863 * get_tablesample_def - print a TableSampleClause
12864 */
12865static void
12867{
12869 Oid argtypes[1];
12870 int nargs;
12871 ListCell *l;
12872
12873 /*
12874 * We should qualify the handler's function name if it wouldn't be
12875 * resolved by lookup in the current search path.
12876 */
12877 argtypes[0] = INTERNALOID;
12880 NIL, argtypes,
12882
12883 nargs = 0;
12885 {
12886 if (nargs++ > 0)
12889 }
12891
12893 {
12897 }
12898}
12899
12900/*
12901 * get_opclass_name - fetch name of an index operator class
12902 *
12903 * The opclass name is appended (after a space) to buf.
12904 *
12905 * Output is suppressed if the opclass is the default for the given
12906 * actual_datatype. (If you don't want this behavior, just pass
12907 * InvalidOid for actual_datatype.)
12908 */
12909static void
12912{
12916 char *nspname;
12917
12922
12925 {
12926 /* Okay, we need the opclass name. Do we need to qualify it? */
12930 else
12931 {
12934 quote_identifier(nspname),
12936 }
12937 }
12939}
12940
12941/*
12942 * generate_opclass_name
12943 * Compute the name to display for an opclass specified by OID
12944 *
12945 * The result includes all necessary quoting and schema-prefixing.
12946 */
12947char *
12949{
12951
12954
12956}
12957
12958/*
12959 * processIndirection - take care of array and subfield assignment
12960 *
12961 * We strip any top-level FieldStore or assignment SubscriptingRef nodes that
12962 * appear in the input, printing them as decoration for the base column
12963 * name (which we assume the caller just printed). We might also need to
12964 * strip CoerceToDomain nodes, but only ones that appear above assignment
12965 * nodes.
12966 *
12967 * Returns the subexpression that's to be assigned.
12968 */
12971{
12974
12975 for (;;)
12976 {
12978 break;
12980 {
12982 Oid typrelid;
12983 char *fieldname;
12984
12985 /* lookup tuple type */
12986 typrelid = get_typ_typrelid(fstore->resulttype);
12989 format_type_be(fstore->resulttype));
12990
12991 /*
12992 * Print the field name. There should only be one target field in
12993 * stored rules. There could be more than that in executable
12994 * target lists, but this function cannot be used for that case.
12995 */
12997 fieldname = get_attname(typrelid,
13000
13001 /*
13002 * We ignore arg since it should be an uninteresting reference to
13003 * the target column or subcolumn.
13004 */
13006 }
13008 {
13010
13012 break;
13013
13014 printSubscripts(sbsref, context);
13015
13016 /*
13017 * We ignore refexpr since it should be an uninteresting reference
13018 * to the target column or subcolumn.
13019 */
13021 }
13023 {
13025 /* If it's an explicit domain coercion, we're done */
13027 break;
13028 /* Tentatively descend past the CoerceToDomain */
13030 }
13031 else
13032 break;
13033 }
13034
13035 /*
13036 * If we descended past a CoerceToDomain whose argument turned out not to
13037 * be a FieldStore or array assignment, back up to the CoerceToDomain.
13038 * (This is not enough to be fully correct if there are nested implicit
13039 * CoerceToDomains, but such cases shouldn't ever occur.)
13040 */
13043
13044 return node;
13045}
13046
13047static void
13049{
13053
13056 {
13059 {
13060 /* If subexpression is NULL, get_rule_expr prints nothing */
13064 }
13065 /* If subexpression is NULL, get_rule_expr prints nothing */
13068 }
13069}
13070
13071/*
13072 * quote_identifier - Quote an identifier only if needed
13073 *
13074 * When quotes are needed, we palloc the required space; slightly
13075 * space-wasteful but well worth it for notational simplicity.
13076 */
13077const char *
13079{
13080 /*
13081 * Can avoid quoting if ident starts with a lowercase letter or underscore
13082 * and contains only lowercase letters, digits, and underscores, *and* is
13083 * not any SQL keyword. Otherwise, supply quotes.
13084 */
13087 const char *ptr;
13088 char *result;
13090
13091 /*
13092 * would like to use <ctype.h> macros here, but they might yield unwanted
13093 * locale-specific results...
13094 */
13096
13098 {
13100
13104 {
13105 /* okay */
13106 }
13107 else
13108 {
13111 nquotes++;
13112 }
13113 }
13114
13117
13119 {
13120 /*
13121 * Check for keyword. We quote keywords except for unreserved ones.
13122 * (In some cases we could avoid quoting a col_name or type_func_name
13123 * keyword, but it seems much harder than it's worth to tell that.)
13124 *
13125 * Note: ScanKeywordLookup() does case-insensitive comparison, but
13126 * that's fine, since we already know we have all-lower-case.
13127 */
13129
13132 }
13133
13136
13138
13139 optr = result;
13142 {
13144
13148 }
13151
13152 return result;
13153}
13154
13155/*
13156 * quote_qualified_identifier - Quote a possibly-qualified identifier
13157 *
13158 * Return a name of the form qualifier.ident, or just ident if qualifier
13159 * is NULL, quoting each component if necessary. The result is palloc'd.
13160 */
13161char *
13164{
13166
13172}
13173
13174/*
13175 * get_relation_name
13176 * Get the unqualified name of a relation specified by OID
13177 *
13178 * This differs from the underlying get_rel_name() function in that it will
13179 * throw error instead of silently returning NULL if the OID is bad.
13180 */
13181static char *
13183{
13185
13189}
13190
13191/*
13192 * generate_relation_name
13193 * Compute the name to display for a relation specified by OID
13194 *
13195 * The result includes all necessary quoting and schema-prefixing.
13196 *
13197 * If namespaces isn't NIL, it must be a list of deparse_namespace nodes.
13198 * We will forcibly qualify the relation name if it equals any CTE name
13199 * visible in the namespace list.
13200 */
13201static char *
13203{
13204 HeapTuple tp;
13209 char *nspname;
13210 char *result;
13211
13217
13218 /* Check for conflicting CTE name */
13221 {
13224
13226 {
13228
13230 {
13232 break;
13233 }
13234 }
13236 break;
13237 }
13238
13239 /* Otherwise, qualify the name if not visible in search path */
13242
13245 else
13246 nspname = NULL;
13247
13249
13250 ReleaseSysCache(tp);
13251
13252 return result;
13253}
13254
13255/*
13256 * generate_qualified_relation_name
13257 * Compute the name to display for a relation specified by OID
13258 *
13259 * As above, but unconditionally schema-qualify the name.
13260 */
13261static char *
13263{
13264 HeapTuple tp;
13267 char *nspname;
13268 char *result;
13269
13275
13277 if (!nspname)
13279 reltup->relnamespace);
13280
13282
13283 ReleaseSysCache(tp);
13284
13285 return result;
13286}
13287
13288/*
13289 * generate_function_name
13290 * Compute the name to display for a function specified by OID,
13291 * given that it is being called with the specified actual arg names and
13292 * types. (Those matter because of ambiguous-function resolution rules.)
13293 *
13294 * If we're dealing with a potentially variadic function (in practice, this
13295 * means a FuncExpr or Aggref, not some other way of calling a function), then
13296 * has_variadic must specify whether variadic arguments have been merged,
13297 * and *use_variadic_p will be set to indicate whether to print VARIADIC in
13298 * the output. For non-FuncExpr cases, has_variadic should be false and
13299 * use_variadic_p can be NULL.
13300 *
13301 * inGroupBy must be true if we're deparsing a GROUP BY clause.
13302 *
13303 * The result includes all necessary quoting and schema-prefixing.
13304 */
13305static char *
13308 bool inGroupBy)
13309{
13310 char *result;
13315 char *nspname;
13325
13331
13332 /*
13333 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
13334 * qualification of some function names within GROUP BY.
13335 */
13336 if (inGroupBy)
13337 {
13340 }
13341
13342 /*
13343 * Determine whether VARIADIC should be printed. We must do this first
13344 * since it affects the lookup rules in func_get_detail().
13345 *
13346 * We always print VARIADIC if the function has a merged variadic-array
13347 * argument. Note that this is always the case for functions taking a
13348 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
13349 * and printed the array elements as separate arguments, the call could
13350 * match a newer non-VARIADIC function.
13351 */
13353 {
13354 /* Parser should not have set funcvariadic unless fn is variadic */
13358 }
13359 else
13360 {
13363 }
13364
13365 /*
13366 * The idea here is to schema-qualify only if the parser would fail to
13367 * resolve the correct function given the unqualified func name with the
13368 * specified argtypes and VARIADIC flag. But if we already decided to
13369 * force qualification, then we can skip the lookup and pretend we didn't
13370 * find it.
13371 */
13374 NIL, argnames, nargs, argtypes,
13376 &fgc_flags,
13380 else
13381 {
13384 }
13385
13389 p_funcid == funcid)
13390 nspname = NULL;
13391 else
13393
13395
13397
13398 return result;
13399}
13400
13401/*
13402 * generate_operator_name
13403 * Compute the name to display for an operator specified by OID,
13404 * given that it is being called with the specified actual arg types.
13405 * (Arg types matter because of ambiguous-operator resolution rules.
13406 * Pass InvalidOid for unused arg of a unary operator.)
13407 *
13408 * The result includes all necessary quoting and schema-prefixing,
13409 * plus the OPERATOR() decoration needed to use a qualified operator name
13410 * in an expression.
13411 */
13412static char *
13414{
13418 char *oprname;
13419 char *nspname;
13421
13423
13429
13430 /*
13431 * The idea here is to schema-qualify only if the parser would fail to
13432 * resolve the correct operator given the unqualified op name with the
13433 * specified argtypes.
13434 */
13436 {
13437 case 'b':
13439 true, -1);
13440 break;
13441 case 'l':
13443 true, -1);
13444 break;
13445 default:
13448 break;
13449 }
13450
13452 nspname = NULL;
13453 else
13454 {
13457 }
13458
13460
13461 if (nspname)
13463
13466
13468
13470}
13471
13472/*
13473 * generate_operator_clause --- generate a binary-operator WHERE clause
13474 *
13475 * This is used for internally-generated-and-executed SQL queries, where
13476 * precision is essential and readability is secondary. The basic
13477 * requirement is to append "leftop op rightop" to buf, where leftop and
13478 * rightop are given as strings and are assumed to yield types leftoptype
13479 * and rightoptype; the operator is identified by OID. The complexity
13480 * comes from needing to be sure that the parser will select the desired
13481 * operator when the query is parsed. We always name the operator using
13482 * OPERATOR(schema.op) syntax, so as to avoid search-path uncertainties.
13483 * We have to emit casts too, if either input isn't already the input type
13484 * of the operator; else we are at the mercy of the parser's heuristics for
13485 * ambiguous-operator resolution. The caller must ensure that leftop and
13486 * rightop are suitable arguments for a cast operation; it's best to insert
13487 * parentheses if they aren't just variables or parameters.
13488 */
13489void
13494{
13497 char *oprname;
13498 char *nspname;
13499
13506
13508
13517
13519}
13520
13521/*
13522 * Add a cast specification to buf. We spell out the type name the hard way,
13523 * intentionally not using format_type_be(). This is to avoid corner cases
13524 * for CHARACTER, BIT, and perhaps other types, where specifying the type
13525 * using SQL-standard syntax results in undesirable data truncation. By
13526 * doing it this way we can be certain that the cast will have default (-1)
13527 * target typmod.
13528 */
13529static void
13531{
13535 char *nspname;
13536
13541
13544
13547
13549}
13550
13551/*
13552 * generate_qualified_type_name
13553 * Compute the name to display for a type specified by OID
13554 *
13555 * This is different from format_type_be() in that we unconditionally
13556 * schema-qualify the name. That also means no special syntax for
13557 * SQL-standard type names ... although in current usage, this should
13558 * only get used for domains, so such cases wouldn't occur anyway.
13559 */
13560static char *
13562{
13563 HeapTuple tp;
13566 char *nspname;
13567 char *result;
13568
13574
13576 if (!nspname)
13578 typtup->typnamespace);
13579
13581
13582 ReleaseSysCache(tp);
13583
13584 return result;
13585}
13586
13587/*
13588 * generate_collation_name
13589 * Compute the name to display for a collation specified by OID
13590 *
13591 * The result includes all necessary quoting and schema-prefixing.
13592 */
13593char *
13595{
13596 HeapTuple tp;
13598 char *collname;
13599 char *nspname;
13600 char *result;
13601
13607
13610 else
13611 nspname = NULL;
13612
13613 result = quote_qualified_identifier(nspname, collname);
13614
13615 ReleaseSysCache(tp);
13616
13617 return result;
13618}
13619
13620/*
13621 * Given a C string, produce a TEXT datum.
13622 *
13623 * We assume that the input was palloc'd and may be freed.
13624 */
13627{
13628 text *result;
13629
13632 return result;
13633}
13634
13635/*
13636 * Generate a C string representing a relation options from text[] datum.
13637 */
13638static void
13640{
13644
13647
13649 {
13654
13655 /*
13656 * Each array element should have the form name=value. If the "=" is
13657 * missing for some reason, treat it like an empty value.
13658 */
13662 {
13665 }
13666 else
13668
13672
13673 /*
13674 * In general we need to quote the value; but to avoid unnecessary
13675 * clutter, do not quote if it is an identifier that would not need
13676 * quoting. (We could also allow numbers, but that is a bit trickier
13677 * than it looks --- for example, are leading zeroes significant? We
13678 * don't want to assume very much here about what custom reloptions
13679 * might mean.)
13680 */
13683 else
13685
13687 }
13688}
13689
13690/*
13691 * Generate a C string representing a relation's reloptions, or NULL if none.
13692 */
13693static char *
13695{
13697 HeapTuple tuple;
13698 Datum reloptions;
13699 bool isnull;
13700
13704
13706 Anum_pg_class_reloptions, &isnull);
13707 if (!isnull)
13708 {
13710
13713
13714 result = buf.data;
13715 }
13716
13717 ReleaseSysCache(tuple);
13718
13719 return result;
13720}
13721
13722/*
13723 * get_range_partbound_string
13724 * A C string representation of one range partition bound
13725 */
13726char *
13728{
13729 deparse_context context;
13731 ListCell *cell;
13733
13737
13741 {
13742 PartitionRangeDatum *datum =
13744
13750 else
13751 {
13753
13755 }
13757 }
13759
13761}
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition arrayfuncs.c:5365
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition arrayfuncs.c:3151
void deconstruct_array_builtin(const ArrayType *array, Oid elmtype, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition arrayfuncs.c:3705
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition arrayfuncs.c:5435
const uint8 ScanKeywordCategories[SCANKEYWORDS_NUM_KEYWORDS]
Definition keywords.c:29
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition dynahash.c:952
HTAB * hash_create(const char *tabname, int64 nelem, const HASHCTL *info, int flags)
Definition dynahash.c:358
char * format_type_with_typemod(Oid type_oid, int32 typemod)
Definition format_type.c:362
int get_func_trftypes(HeapTuple procTup, Oid **p_trftypes)
Definition funcapi.c:1475
int get_func_arg_info(HeapTuple procTup, Oid **p_argtypes, char ***p_argnames, char **p_argmodes)
Definition funcapi.c:1379
TupleDesc get_expr_result_tupdesc(Node *expr, bool noError)
Definition funcapi.c:551
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition genam.c:388
int GetConfigOptionFlags(const char *name, bool missing_ok)
Definition guc.c:4316
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
Definition heaptuple.c:456
static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition htup_details.h:847
static struct @174 value
PGDLLIMPORT const ScanKeywordList ScanKeywords
int ScanKeywordLookup(const char *str, const ScanKeywordList *keywords)
Definition kwlookup.c:38
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition lsyscache.c:3059
char * get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
Definition lsyscache.c:903
void get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
Definition lsyscache.c:2862
void get_atttypetypmodcoll(Oid relid, AttrNumber attnum, Oid *typid, int32 *typmod, Oid *collid)
Definition lsyscache.c:1019
RangeVar * makeRangeVarFromNameList(const List *names)
Definition namespace.c:3626
bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
Definition nodeFuncs.c:557
int get_aggregate_argtypes(Aggref *aggref, Oid *inputTypes)
Definition parse_agg.c:2052
FuncDetailCode func_get_detail(List *funcname, List *fargs, List *fargnames, int nargs, Oid *argtypes, bool expand_variadic, bool expand_defaults, bool include_out_arguments, int *fgc_flags, Oid *funcid, Oid *rettype, bool *retset, int *nvargs, Oid *vatype, Oid **true_typeids, List **argdefaults)
Definition parse_func.c:1513
Operator left_oper(ParseState *pstate, List *op, Oid arg, bool noError, int location)
Definition parse_oper.c:522
Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
Definition parse_oper.c:372
char * get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum)
Definition parse_relation.c:3346
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
Definition parse_relation.c:3533
void expandRTE(RangeTblEntry *rte, int rtindex, int sublevels_up, VarReturningType returning_type, int location, bool include_dropped, List **colnames, List **colvars)
Definition parse_relation.c:2739
#define FRAMEOPTION_START_UNBOUNDED_PRECEDING
Definition parsenodes.h:614
#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING
Definition parsenodes.h:617
#define FRAMEOPTION_START_OFFSET_PRECEDING
Definition parsenodes.h:620
#define FRAMEOPTION_START_OFFSET_FOLLOWING
Definition parsenodes.h:622
END_CATALOG_STRUCT typedef FormData_pg_aggregate * Form_pg_aggregate
Definition pg_aggregate.h:113
END_CATALOG_STRUCT typedef FormData_pg_authid * Form_pg_authid
Definition pg_authid.h:60
END_CATALOG_STRUCT typedef FormData_pg_collation * Form_pg_collation
Definition pg_collation.h:62
AttrNumber extractNotNullColumn(HeapTuple constrTup)
Definition pg_constraint.c:702
END_CATALOG_STRUCT typedef FormData_pg_constraint * Form_pg_constraint
Definition pg_constraint.h:179
END_CATALOG_STRUCT typedef FormData_pg_depend * Form_pg_depend
Definition pg_depend.h:76
#define forfour(cell1, list1, cell2, list2, cell3, list3, cell4, list4)
Definition pg_list.h:575
#define forfive(cell1, list1, cell2, list2, cell3, list3, cell4, list4, cell5, list5)
Definition pg_list.h:588
static int list_cell_number(const List *l, const ListCell *c)
Definition pg_list.h:333
END_CATALOG_STRUCT typedef FormData_pg_opclass * Form_pg_opclass
Definition pg_opclass.h:87
END_CATALOG_STRUCT typedef FormData_pg_operator * Form_pg_operator
Definition pg_operator.h:87
END_CATALOG_STRUCT typedef FormData_pg_partitioned_table * Form_pg_partitioned_table
Definition pg_partitioned_table.h:69
END_CATALOG_STRUCT typedef FormData_pg_statistic_ext * Form_pg_statistic_ext
Definition pg_statistic_ext.h:73
END_CATALOG_STRUCT typedef FormData_pg_trigger * Form_pg_trigger
Definition pg_trigger.h:84
void AcquireRewriteLocks(Query *parsetree, bool forExecute, bool forUpdatePushedDown)
Definition rewriteHandler.c:148
Query * getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
Definition rewriteManip.c:1090
static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags, int wrapColumn)
Definition ruleutils.c:5543
Datum pg_get_partition_constraintdef(PG_FUNCTION_ARGS)
Definition ruleutils.c:2096
static char * get_rtable_name(int rtindex, deparse_context *context)
Definition ruleutils.c:5137
static int decompile_column_index_array(Datum column_index_array, Oid relId, bool withPeriod, StringInfo buf)
Definition ruleutils.c:2621
static void set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition ruleutils.c:4379
static void appendContextKeyword(deparse_context *context, const char *str, int indentBefore, int indentAfter, int indentPlus)
Definition ruleutils.c:9114
List * deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names)
Definition ruleutils.c:3757
char * pg_get_statisticsobjdef_string(Oid statextid)
Definition ruleutils.c:1627
static void set_using_names(deparse_namespace *dpns, Node *jtnode, List *parentUsing)
Definition ruleutils.c:4214
static Plan * find_recursive_union(deparse_namespace *dpns, WorkTableScan *wtscan)
Definition ruleutils.c:5237
static void get_values_def(List *values_lists, deparse_context *context)
Definition ruleutils.c:5728
static char * make_colname_unique(char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition ruleutils.c:4927
static void get_json_behavior(JsonBehavior *behavior, deparse_context *context, const char *on)
Definition ruleutils.c:9205
static const char * get_simple_binary_op_name(OpExpr *expr)
Definition ruleutils.c:8856
static void get_json_agg_constructor(JsonConstructorExpr *ctor, deparse_context *context, const char *funcname, bool is_json_objectagg)
Definition ruleutils.c:11820
static void set_deparse_for_query(deparse_namespace *dpns, Query *query, List *parent_namespaces)
Definition ruleutils.c:4033
static void print_function_trftypes(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3462
void(* rsv_callback)(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:325
char * quote_qualified_identifier(const char *qualifier, const char *ident)
Definition ruleutils.c:13163
static void get_setop_query(Node *setOp, Query *query, deparse_context *context)
Definition ruleutils.c:6421
static bool is_input_argument(int nth, const char *argmodes)
Definition ruleutils.c:3450
static void get_query_def(Query *query, StringInfo buf, List *parentnamespace, TupleDesc resultDesc, bool colNamesVisible, int prettyFlags, int wrapColumn, int startIndent)
Definition ruleutils.c:5628
static void get_tablesample_def(TableSampleClause *tablesample, deparse_context *context)
Definition ruleutils.c:12867
static void get_sublink_expr(SubLink *sublink, deparse_context *context)
Definition ruleutils.c:11870
static const char * get_name_for_var_field(Var *var, int fieldno, int levelsup, deparse_context *context)
Definition ruleutils.c:8041
static char * get_lock_clause_strength(LockClauseStrength strength)
Definition ruleutils.c:6017
static void get_rte_alias(RangeTblEntry *rte, int varno, bool use_as, deparse_context *context)
Definition ruleutils.c:12705
Datum pg_get_function_arg_default(PG_FUNCTION_ARGS)
Definition ruleutils.c:3490
static void get_parameter(Param *param, deparse_context *context)
Definition ruleutils.c:8711
static void build_colinfo_names_hash(deparse_columns *colinfo)
Definition ruleutils.c:4982
Datum pg_get_statisticsobjdef_expressions(PG_FUNCTION_ARGS)
Definition ruleutils.c:1838
static void get_delete_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7379
static void get_json_table_columns(TableFunc *tf, JsonTablePathScan *scan, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12126
static void get_column_alias_list(deparse_columns *colinfo, deparse_context *context)
Definition ruleutils.c:12776
Datum pg_get_statisticsobjdef_columns(PG_FUNCTION_ARGS)
Definition ruleutils.c:1637
static void add_to_names_hash(deparse_columns *colinfo, const char *name)
Definition ruleutils.c:5040
static void simple_quote_literal(StringInfo buf, const char *val)
Definition ruleutils.c:11845
static bool colname_is_unique(const char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition ruleutils.c:4852
static void get_from_clause_coldeflist(RangeTblFunction *rtfunc, deparse_columns *colinfo, deparse_context *context)
Definition ruleutils.c:12816
char * pg_get_partkeydef_columns(Oid relid, bool pretty)
Definition ruleutils.c:1924
static void get_from_clause(Query *query, const char *prefix, deparse_context *context)
Definition ruleutils.c:12320
List * deparse_context_for(const char *aliasname, Oid relid)
Definition ruleutils.c:3712
static bool get_func_sql_syntax(FuncExpr *expr, deparse_context *context)
Definition ruleutils.c:11201
static char * generate_qualified_relation_name(Oid relid)
Definition ruleutils.c:13263
static void set_simple_column_names(deparse_namespace *dpns)
Definition ruleutils.c:4102
static void get_json_expr_options(JsonExpr *jsexpr, deparse_context *context, JsonBehaviorType default_behavior)
Definition ruleutils.c:9243
char * pg_get_indexdef_columns(Oid indexrelid, bool pretty)
Definition ruleutils.c:1236
static void get_rule_groupingset(GroupingSet *gset, List *targetlist, bool omit_parens, deparse_context *context)
Definition ruleutils.c:6638
char * pg_get_indexdef_columns_extended(Oid indexrelid, bits16 flags)
Definition ruleutils.c:1250
static char * pg_get_indexdef_worker(Oid indexrelid, int colno, const Oid *excludeOps, bool attrsOnly, bool keysOnly, bool showTblSpc, bool inherits, int prettyFlags, bool missing_ok)
Definition ruleutils.c:1271
static char * pg_get_constraintdef_worker(Oid constraintId, bool fullCommand, int prettyFlags, bool missing_ok)
Definition ruleutils.c:2193
static void get_rule_expr_funccall(Node *node, deparse_context *context, bool showimplicit)
Definition ruleutils.c:10730
static char * generate_function_name(Oid funcid, int nargs, List *argnames, Oid *argtypes, bool has_variadic, bool *use_variadic_p, bool inGroupBy)
Definition ruleutils.c:13307
static void expand_colnames_array_to(deparse_columns *colinfo, int n)
Definition ruleutils.c:4966
static void get_returning_clause(Query *query, deparse_context *context)
Definition ruleutils.c:6382
List * set_deparse_context_plan(List *dpcontext, Plan *plan, List *ancestors)
Definition ruleutils.c:3829
static SubPlan * find_param_generator(Param *param, deparse_context *context, int *column_p)
Definition ruleutils.c:8593
static void get_special_variable(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:7912
static void get_windowfunc_expr_helper(WindowFunc *wfunc, deparse_context *context, const char *funcname, const char *options, bool is_json_objectagg)
Definition ruleutils.c:11083
static void get_rule_list_toplevel(List *lst, deparse_context *context, bool showimplicit)
Definition ruleutils.c:10700
static char * pg_get_statisticsobj_worker(Oid statextid, bool columns_only, bool missing_ok)
Definition ruleutils.c:1654
#define deparse_columns_fetch(rangetable_index, dpns)
Definition ruleutils.c:312
static void get_json_constructor(JsonConstructorExpr *ctor, deparse_context *context, bool showimplicit)
Definition ruleutils.c:11724
static void get_json_path_spec(Node *path_spec, deparse_context *context, bool showimplicit)
Definition ruleutils.c:11667
static void printSubscripts(SubscriptingRef *sbsref, deparse_context *context)
Definition ruleutils.c:13049
static SubPlan * find_param_generator_initplan(Param *param, Plan *plan, int *column_p)
Definition ruleutils.c:8690
static void pop_ancestor_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
Definition ruleutils.c:5335
static void get_window_frame_options(int frameOptions, Node *startOffset, Node *endOffset, deparse_context *context)
Definition ruleutils.c:6845
static void get_rule_expr_paren(Node *node, deparse_context *context, bool showimplicit, Node *parentNode)
Definition ruleutils.c:9187
static void get_agg_expr(Aggref *aggref, deparse_context *context, Aggref *original_aggref)
Definition ruleutils.c:10918
static void get_const_collation(Const *constval, deparse_context *context)
Definition ruleutils.c:11647
static void get_target_list(List *targetList, deparse_context *context)
Definition ruleutils.c:6246
static void get_json_table_nested_columns(TableFunc *tf, JsonTablePlan *plan, deparse_context *context, bool showimplicit, bool needcomma)
Definition ruleutils.c:12094
static char * deparse_expression_pretty(Node *expr, List *dpcontext, bool forceprefix, bool showimplicit, int prettyFlags, int startIndent)
Definition ruleutils.c:3676
static void get_insert_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:6946
static void print_function_sqlbody(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3560
static bool has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode)
Definition ruleutils.c:4144
static Node * get_rule_sortgroupclause(Index ref, List *tlist, bool force_colno, deparse_context *context)
Definition ruleutils.c:6569
static char * pg_get_viewdef_worker(Oid viewoid, int prettyFlags, int wrapColumn)
Definition ruleutils.c:790
static void push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell, deparse_namespace *save_dpns)
Definition ruleutils.c:5314
static text * pg_get_expr_worker(text *expr, Oid relid, int prettyFlags)
Definition ruleutils.c:2710
static Node * processIndirection(Node *node, deparse_context *context)
Definition ruleutils.c:12971
static void get_agg_combine_expr(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:11056
List * select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used)
Definition ruleutils.c:3859
static char * generate_qualified_type_name(Oid typid)
Definition ruleutils.c:13562
static void get_xmltable(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:11995
static void get_utility_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7585
static void get_rule_windowclause(Query *query, deparse_context *context)
Definition ruleutils.c:6756
static void get_rule_windowspec(WindowClause *wc, List *targetList, deparse_context *context)
Definition ruleutils.c:6788
static void get_json_returning(JsonReturning *returning, StringInfo buf, bool json_format_by_default)
Definition ruleutils.c:11704
static Node * find_param_referent(Param *param, deparse_context *context, deparse_namespace **dpns_p, ListCell **ancestor_cell_p)
Definition ruleutils.c:8479
static void get_rule_orderby(List *orderList, List *targetList, bool force_colno, deparse_context *context)
Definition ruleutils.c:6698
static void pop_child_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
Definition ruleutils.c:5284
char * pg_get_constraintdef_command(Oid constraintId)
Definition ruleutils.c:2184
char * pg_get_partconstrdef_string(Oid partitionId, char *aliasname)
Definition ruleutils.c:2128
static void set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition ruleutils.c:4582
static void set_rtable_names(deparse_namespace *dpns, List *parent_namespaces, Bitmapset *rels_used)
Definition ruleutils.c:3888
char * get_window_frame_options_for_explain(int frameOptions, Node *startOffset, Node *endOffset, List *dpcontext, bool forceprefix)
Definition ruleutils.c:6914
static void get_update_query_targetlist_def(Query *query, List *targetList, deparse_context *context, RangeTblEntry *rte)
Definition ruleutils.c:7227
static void get_rule_expr(Node *node, deparse_context *context, bool showimplicit)
Definition ruleutils.c:9284
static char * pg_get_partkeydef_worker(Oid relid, int prettyFlags, bool attrsOnly, bool missing_ok)
Definition ruleutils.c:1937
static void get_oper_expr(OpExpr *expr, deparse_context *context)
Definition ruleutils.c:10782
Datum pg_get_function_identity_arguments(PG_FUNCTION_ARGS)
Definition ruleutils.c:3209
static char * pg_get_triggerdef_worker(Oid trigid, bool pretty)
Definition ruleutils.c:901
static void get_reloptions(StringInfo buf, Datum reloptions)
Definition ruleutils.c:13640
static void get_func_expr(FuncExpr *expr, deparse_context *context, bool showimplicit)
Definition ruleutils.c:10822
static void get_const_expr(Const *constval, deparse_context *context, int showtype)
Definition ruleutils.c:11517
char * deparse_expression(Node *expr, List *dpcontext, bool forceprefix, bool showimplicit)
Definition ruleutils.c:3649
void generate_operator_clause(StringInfo buf, const char *leftop, Oid leftoptype, Oid opoid, const char *rightop, Oid rightoptype)
Definition ruleutils.c:13491
static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags)
Definition ruleutils.c:5351
static char * pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)
Definition ruleutils.c:598
static int print_function_arguments(StringInfo buf, HeapTuple proctup, bool print_table_args, bool print_defaults)
Definition ruleutils.c:3302
static void identify_join_columns(JoinExpr *j, RangeTblEntry *jrte, deparse_columns *colinfo)
Definition ruleutils.c:5069
static void print_function_rettype(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3264
static void set_deparse_plan(deparse_namespace *dpns, Plan *plan)
Definition ruleutils.c:5156
static void get_merge_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7426
static void resolve_special_varno(Node *node, deparse_context *context, rsv_callback callback, void *callback_arg)
Definition ruleutils.c:7933
static void get_json_format(JsonFormat *format, StringInfo buf)
Definition ruleutils.c:11679
char * get_range_partbound_string(List *bound_datums)
Definition ruleutils.c:13728
static void get_tablefunc(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12301
static void get_rule_expr_toplevel(Node *node, deparse_context *context, bool showimplicit)
Definition ruleutils.c:10682
static RangeTblEntry * get_simple_values_rte(Query *query, TupleDesc resultDesc)
Definition ruleutils.c:6044
static void get_coercion_expr(Node *arg, deparse_context *context, Oid resulttype, int32 resulttypmod, Node *parentNode)
Definition ruleutils.c:11453
static void push_child_plan(deparse_namespace *dpns, Plan *plan, deparse_namespace *save_dpns)
Definition ruleutils.c:5267
static void get_update_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7175
static void get_json_constructor_options(JsonConstructorExpr *ctor, StringInfo buf)
Definition ruleutils.c:11790
static void get_basic_select_query(Query *query, deparse_context *context)
Definition ruleutils.c:6113
static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags)
Definition ruleutils.c:8882
static void get_with_clause(Query *query, deparse_context *context)
Definition ruleutils.c:5771
static void destroy_colinfo_names_hash(deparse_columns *colinfo)
Definition ruleutils.c:5053
static char * generate_relation_name(Oid relid, List *namespaces)
Definition ruleutils.c:13203
static void get_windowfunc_expr(WindowFunc *wfunc, deparse_context *context)
Definition ruleutils.c:11072
static char * get_variable(Var *var, int levelsup, bool istoplevel, deparse_context *context)
Definition ruleutils.c:7630
static char * generate_operator_name(Oid operid, Oid arg1, Oid arg2)
Definition ruleutils.c:13414
static void get_from_clause_item(Node *jtnode, Query *query, deparse_context *context)
Definition ruleutils.c:12414
Datum pg_get_function_arguments(PG_FUNCTION_ARGS)
Definition ruleutils.c:3183
static void get_json_table(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12232
static void get_select_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:5910
static void get_opclass_name(Oid opclass, Oid actual_datatype, StringInfo buf)
Definition ruleutils.c:12911
static void get_agg_expr_helper(Aggref *aggref, deparse_context *context, Aggref *original_aggref, const char *funcname, const char *options, bool is_json_objectagg)
Definition ruleutils.c:10930
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition scankey.c:76
int SPI_execute_plan(SPIPlanPtr plan, const Datum *Values, const char *Nulls, bool read_only, long tcount)
Definition spi.c:672
char * SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber)
Definition spi.c:1220
Datum SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull)
Definition spi.c:1252
Relation try_relation_open(Oid relationId, LOCKMODE lockmode)
Definition relation.c:88
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition stringinfo.c:145
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
Definition stringinfo.c:281
void appendStringInfoSpaces(StringInfo str, int count)
Definition stringinfo.c:260
void appendStringInfoString(StringInfo str, const char *s)
Definition stringinfo.c:230
Definition primnodes.h:460
Definition primnodes.h:1143
Definition pathnodes.h:3275
Definition plannodes.h:397
Definition array.h:188
Definition primnodes.h:1265
Definition primnodes.h:1405
Definition array.h:93
Definition bitmapset.h:50
Definition primnodes.h:968
Definition primnodes.h:2006
Definition primnodes.h:1341
Definition primnodes.h:1387
Definition primnodes.h:1357
Definition primnodes.h:1511
Definition primnodes.h:2052
Definition primnodes.h:1239
Definition primnodes.h:1311
Definition parsenodes.h:1729
Definition primnodes.h:325
Definition primnodes.h:1293
Definition plannodes.h:818
Definition primnodes.h:2121
Definition plannodes.h:931
Definition primnodes.h:190
Definition primnodes.h:1160
Definition primnodes.h:1191
Definition plannodes.h:889
Definition primnodes.h:2356
Definition primnodes.h:780
Definition primnodes.h:558
Definition parsenodes.h:1566
Definition hsearch.h:66
Definition dynahash.c:222
Definition htup.h:63
Definition amapi.h:233
Definition plannodes.h:653
Definition primnodes.h:2150
Definition primnodes.h:2328
Definition primnodes.h:1813
Definition primnodes.h:1730
Definition primnodes.h:1840
Definition primnodes.h:1675
Definition primnodes.h:1759
Definition primnodes.h:1687
Definition primnodes.h:1920
Definition primnodes.h:1909
Definition primnodes.h:1950
Definition primnodes.h:1707
Definition pg_list.h:54
Definition primnodes.h:2030
Definition plannodes.h:432
Definition primnodes.h:1533
Definition plannodes.h:337
Definition ruleutils.c:319
Definition primnodes.h:821
Definition plannodes.h:1012
Definition plannodes.h:1005
Definition primnodes.h:2136
Definition nodes.h:135
Definition parsenodes.h:3790
Definition primnodes.h:1982
Definition primnodes.h:2372
Definition primnodes.h:847
Definition primnodes.h:392
Definition parsenodes.h:926
Definition parsenodes.h:959
Definition plannodes.h:192
Definition plannodes.h:62
Definition parsenodes.h:118
Definition parsenodes.h:1085
Definition parsenodes.h:1375
Definition primnodes.h:2294
Definition primnodes.h:74
Definition plannodes.h:478
Definition primnodes.h:1216
Definition rel.h:56
Definition plannodes.h:302
Definition primnodes.h:2174
Definition primnodes.h:1490
Definition primnodes.h:1447
Definition parsenodes.h:1636
Definition primnodes.h:1580
Definition primnodes.h:927
Definition skey.h:65
Definition parsenodes.h:2282
Definition snapshot.h:139
Definition parsenodes.h:1495
Definition stringinfo.h:47
Definition value.h:64
Definition primnodes.h:1042
Definition primnodes.h:1093
Definition plannodes.h:772
Definition primnodes.h:713
Definition relscan.h:209
Definition primnodes.h:112
Definition parsenodes.h:1402
Definition primnodes.h:2237
Definition tupdesc.h:136
Definition typcache.h:32
Definition primnodes.h:263
Definition plannodes.h:1250
Definition parsenodes.h:1596
Definition primnodes.h:595
Definition plannodes.h:842
Definition primnodes.h:1623
Definition spi_priv.h:91
Definition regc_locale.c:56
Definition ruleutils.c:235
Definition ruleutils.c:113
Definition ruleutils.c:163
Definition c.h:767
Definition getopt_long.h:18
Definition oid2name.c:30
Definition print.h:106
Datum SysCacheGetAttrNotNull(SysCacheIdentifier cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition syscache.c:625
HeapTuple SearchSysCache1(SysCacheIdentifier cacheId, Datum key1)
Definition syscache.c:220
Datum SysCacheGetAttr(SysCacheIdentifier cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition syscache.c:595
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition test_ifaddrs.c:46
TargetEntry * get_sortgroupref_tle(Index sortref, List *targetList)
Definition tlist.c:354
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:160
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:175
TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
Definition typcache.c:1924
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition typcache.c:389
Definition pg_list.h:46
Node * flatten_group_exprs(PlannerInfo *root, Query *query, Node *node)
Definition var.c:972
text * cstring_to_text_with_len(const char *s, int len)
Definition varlena.c:194
bool SplitGUCList(char *rawstring, char separator, List **namelist)
Definition varlena.c:3023
char * map_xml_name_to_sql_identifier(const char *name)
Definition xml.c:2474
◆ GET_PRETTY_FLAGS
◆ only_marker
Definition at line 551 of file ruleutils.c.
◆ PRETTY_INDENT
| #define PRETTY_INDENT | ( | context | ) | ((context)->prettyFlags & PRETTYFLAG_INDENT) |
Definition at line 102 of file ruleutils.c.
◆ PRETTY_PAREN
| #define PRETTY_PAREN | ( | context | ) | ((context)->prettyFlags & PRETTYFLAG_PAREN) |
Definition at line 101 of file ruleutils.c.
◆ PRETTY_SCHEMA
| #define PRETTY_SCHEMA | ( | context | ) | ((context)->prettyFlags & PRETTYFLAG_SCHEMA) |
Definition at line 103 of file ruleutils.c.
◆ PRETTYFLAG_INDENT
| #define PRETTYFLAG_INDENT 0x0002 |
Definition at line 89 of file ruleutils.c.
◆ PRETTYFLAG_PAREN
| #define PRETTYFLAG_PAREN 0x0001 |
Definition at line 88 of file ruleutils.c.
◆ PRETTYFLAG_SCHEMA
| #define PRETTYFLAG_SCHEMA 0x0004 |
Definition at line 90 of file ruleutils.c.
◆ PRETTYINDENT_JOIN
| #define PRETTYINDENT_JOIN 4 |
Definition at line 82 of file ruleutils.c.
◆ PRETTYINDENT_LIMIT
Definition at line 85 of file ruleutils.c.
◆ PRETTYINDENT_STD
| #define PRETTYINDENT_STD 8 |
Definition at line 81 of file ruleutils.c.
◆ PRETTYINDENT_VAR
| #define PRETTYINDENT_VAR 4 |
Definition at line 83 of file ruleutils.c.
◆ WRAP_COLUMN_DEFAULT
| #define WRAP_COLUMN_DEFAULT 0 |
Definition at line 98 of file ruleutils.c.
Typedef Documentation
◆ rsv_callback
| typedef void(* rsv_callback) (Node *node, deparse_context *context, void *callback_arg) |
Definition at line 325 of file ruleutils.c.
Function Documentation
◆ add_cast_to()
|
static |
Definition at line 13531 of file ruleutils.c.
13532{
13536 char *nspname;
13537
13542
13545
13548
13550}
References appendStringInfo(), buf, elog, ERROR, fb(), Form_pg_type, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_identifier(), ReleaseSysCache(), SearchSysCache1(), and typname.
Referenced by generate_operator_clause().
◆ add_to_names_hash()
|
static |
Definition at line 5040 of file ruleutils.c.
References fb(), HASH_ENTER, hash_search(), and name.
Referenced by build_colinfo_names_hash(), set_join_column_names(), and set_relation_column_names().
◆ appendContextKeyword()
|
static |
Definition at line 9114 of file ruleutils.c.
9116{
9118
9120 {
9122
9124
9125 /* remove any trailing spaces currently in the buffer ... */
9127 /* ... then add a newline and some spaces */
9129
9132 else
9133 {
9134 /*
9135 * If we're indented more than PRETTYINDENT_LIMIT characters, try
9136 * to conserve horizontal space by reducing the per-level
9137 * indentation. For best results the scale factor here should
9138 * divide all the indent amounts that get added to indentLevel
9139 * (PRETTYINDENT_STD, etc). It's important that the indentation
9140 * not grow unboundedly, else deeply-nested trees use O(N^2)
9141 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
9142 */
9145 (PRETTYINDENT_STD / 2);
9147 /* scale/wrap logic affects indentLevel, but not indentPlus */
9149 }
9151
9153
9156 context->indentLevel = 0;
9157 }
9158 else
9160}
References appendStringInfoChar(), appendStringInfoSpaces(), appendStringInfoString(), deparse_context::buf, buf, fb(), deparse_context::indentLevel, Max, PRETTY_INDENT, PRETTYINDENT_LIMIT, PRETTYINDENT_STD, removeStringInfoSpaces(), and str.
Referenced by get_basic_select_query(), get_delete_query_def(), get_from_clause(), get_from_clause_item(), get_insert_query_def(), get_json_table(), get_json_table_columns(), get_json_table_nested_columns(), get_merge_query_def(), get_returning_clause(), get_rule_expr(), get_rule_windowclause(), get_select_query_def(), get_setop_query(), get_target_list(), get_update_query_def(), get_utility_query_def(), and get_with_clause().
◆ build_colinfo_names_hash()
|
static |
Definition at line 4982 of file ruleutils.c.
4983{
4987
4988 /*
4989 * Use a hash table only for RTEs with at least 32 columns. (The cutoff
4990 * is somewhat arbitrary, but let's choose it so that this code does get
4991 * exercised in the regression tests.)
4992 */
4994 return;
4995
4996 /*
4997 * Set up the hash table. The entries are just strings with no other
4998 * payload.
4999 */
5005 &hash_ctl,
5007
5008 /*
5009 * Preload the hash table with any names already present (these would have
5010 * come from set_using_names).
5011 */
5013 {
5015
5018 }
5019
5021 {
5023
5026 }
5027
5029 {
5031
5033 }
5034}
References add_to_names_hash(), CurrentMemoryContext, fb(), HASH_CONTEXT, hash_create(), HASH_ELEM, HASH_STRINGS, i, lfirst, and NAMEDATALEN.
Referenced by set_join_column_names(), and set_relation_column_names().
◆ colname_is_unique()
|
static |
Definition at line 4852 of file ruleutils.c.
4854{
4857
4858 /*
4859 * If we have a hash table, consult that instead of linearly scanning the
4860 * colinfo's strings.
4861 */
4863 {
4865 colname,
4866 HASH_FIND,
4868 return false;
4869 }
4870 else
4871 {
4872 /* Check against already-assigned column aliases within RTE */
4874 {
4876
4878 return false;
4879 }
4880
4881 /*
4882 * If we're building a new_colnames array, check that too (this will
4883 * be partially but not completely redundant with the previous checks)
4884 */
4886 {
4888
4890 return false;
4891 }
4892
4893 /*
4894 * Also check against names already assigned for parent-join USING
4895 * cols
4896 */
4898 {
4900
4902 return false;
4903 }
4904 }
4905
4906 /*
4907 * Also check against USING-column names that must be globally unique.
4908 * These are not hashed, but there should be few of them.
4909 */
4911 {
4913
4915 return false;
4916 }
4917
4918 return true;
4919}
References fb(), HASH_FIND, hash_search(), i, and lfirst.
Referenced by make_colname_unique().
◆ decompile_column_index_array()
|
static |
Definition at line 2621 of file ruleutils.c.
2623{
2624 Datum *keys;
2625 int nKeys;
2627
2628 /* Extract data from array of int16 */
2630 &keys, NULL, &nKeys);
2631
2633 {
2635
2637
2640 else
2644 }
2645
2646 return nKeys;
2647}
References appendStringInfo(), appendStringInfoString(), buf, DatumGetArrayTypeP, DatumGetInt16(), deconstruct_array_builtin(), fb(), get_attname(), j, and quote_identifier().
Referenced by pg_get_constraintdef_worker().
◆ deparse_context_for()
Definition at line 3712 of file ruleutils.c.
3713{
3716
3718
3719 /* Build a minimal RTE for the rel */
3722 rte->relid = relid;
3730
3731 /* Build one-element rtable */
3738
3739 /* Return a one-deep namespace stack */
3741}
References AccessShareLock, fb(), list_make1, makeAlias(), makeNode, NIL, palloc0_object, RTE_RELATION, set_rtable_names(), and set_simple_column_names().
Referenced by pg_get_constraintdef_worker(), pg_get_expr_worker(), pg_get_indexdef_worker(), pg_get_partconstrdef_string(), pg_get_partition_constraintdef(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), pg_get_statisticsobjdef_expressions(), transformPartitionBound(), and transformPartitionRangeBounds().
◆ deparse_context_for_plan_tree()
| List * deparse_context_for_plan_tree | ( | PlannedStmt * | pstmt, |
| List * | rtable_names | ||
| ) |
Definition at line 3757 of file ruleutils.c.
3758{
3760
3762
3763 /* Initialize fields that stay the same across the whole plan tree */
3765 dpns->rtable_names = rtable_names;
3769 {
3770 /* Set up the array, indexed by child relid */
3773
3777 {
3780
3784 }
3785 }
3786 else
3788
3789 /*
3790 * Set up column name aliases, ignoring any join RTEs; they don't matter
3791 * because plan trees don't contain any join alias Vars.
3792 */
3794
3795 /* Return a one-deep namespace stack */
3797}
References PlannedStmt::appendRelations, Assert, fb(), lfirst_node, list_length(), list_make1, NIL, palloc0(), palloc0_object, PlannedStmt::rtable, set_simple_column_names(), and PlannedStmt::subplans.
Referenced by ExplainPrintPlan().
◆ deparse_expression()
Definition at line 3649 of file ruleutils.c.
References deparse_expression_pretty(), and fb().
Referenced by AlterDomainDefault(), check_parent_values_in_new_partitions(), DefineDomain(), pg_get_function_arg_default(), pg_get_partconstrdef_string(), print_function_arguments(), show_expression(), show_grouping_set_keys(), show_memoize_info(), show_plan_tlist(), show_sort_group_keys(), show_tablesample(), show_window_keys(), transformPartitionBound(), and transformPartitionRangeBounds().
◆ deparse_expression_pretty()
|
static |
Definition at line 3676 of file ruleutils.c.
References deparse_context::appendparents, deparse_context::buf, buf, deparse_context::colNamesVisible, fb(), get_rule_expr(), deparse_context::indentLevel, deparse_context::inGroupBy, initStringInfo(), deparse_context::namespaces, NIL, deparse_context::prettyFlags, deparse_context::resultDesc, deparse_context::targetList, deparse_context::varInOrderBy, deparse_context::varprefix, deparse_context::windowClause, WRAP_COLUMN_DEFAULT, and deparse_context::wrapColumn.
Referenced by deparse_expression(), pg_get_constraintdef_worker(), pg_get_expr_worker(), pg_get_indexdef_worker(), pg_get_partition_constraintdef(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), and pg_get_statisticsobjdef_expressions().
◆ destroy_colinfo_names_hash()
|
static |
Definition at line 5053 of file ruleutils.c.
5054{
5056 {
5059 }
5060}
References fb(), and hash_destroy().
Referenced by set_join_column_names(), and set_relation_column_names().
◆ expand_colnames_array_to()
|
static |
Definition at line 4966 of file ruleutils.c.
References fb(), palloc0_array, and repalloc0_array.
Referenced by set_join_column_names(), set_relation_column_names(), and set_using_names().
◆ find_param_generator()
|
static |
Definition at line 8593 of file ruleutils.c.
8594{
8595 /* Initialize output parameter to prevent compiler warnings */
8596 *column_p = 0;
8597
8598 /*
8599 * If it's a PARAM_EXEC parameter, search the current plan node as well as
8600 * ancestor nodes looking for a subplan or initplan that emits the value
8601 * for the Param. It could appear in the setParams of an initplan or
8602 * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
8603 */
8605 {
8606 SubPlan *result;
8609
8611
8612 /* First check the innermost plan node's initplans */
8614 if (result)
8615 return result;
8616
8617 /*
8618 * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
8619 * which can be referenced by Params elsewhere in the targetlist.
8620 * (Such Params should always be in the same targetlist, so there's no
8621 * need to do this work at upper plan nodes.)
8622 */
8624 {
8626 {
8628
8630 {
8631 foreach_int(paramid, subplan->setParam)
8632 {
8634 {
8635 /* Found a match, so return it. */
8637 return subplan;
8638 }
8639 }
8640 }
8641 }
8642 }
8643
8644 /* No luck, so check the ancestor nodes */
8646 {
8648
8649 /*
8650 * If ancestor is a SubPlan, check the paramIds it provides.
8651 */
8653 {
8655
8657 {
8659 {
8660 /* Found a match, so return it. */
8662 return subplan;
8663 }
8664 }
8665
8666 /* SubPlan isn't a kind of Plan, so skip the rest */
8667 continue;
8668 }
8669
8670 /*
8671 * Otherwise, it's some kind of Plan node, so check its initplans.
8672 */
8674 column_p);
8675 if (result)
8676 return result;
8677
8678 /* No luck, crawl up to next ancestor */
8679 }
8680 }
8681
8682 /* No generator found */
8684}
References fb(), find_param_generator_initplan(), foreach_current_index, foreach_int, foreach_node, IsA, lfirst, linitial, MULTIEXPR_SUBLINK, deparse_context::namespaces, PARAM_EXEC, Param::paramid, SubPlan::paramIds, Param::paramkind, SubPlan::setParam, and SubPlan::subLinkType.
Referenced by get_parameter().
◆ find_param_generator_initplan()
|
static |
Definition at line 8690 of file ruleutils.c.
8691{
8693 {
8694 foreach_int(paramid, subplan->setParam)
8695 {
8697 {
8698 /* Found a match, so return it. */
8700 return subplan;
8701 }
8702 }
8703 }
8705}
References fb(), foreach_current_index, foreach_int, foreach_node, Param::paramid, and plan.
Referenced by find_param_generator().
◆ find_param_referent()
|
static |
Definition at line 8479 of file ruleutils.c.
8481{
8482 /* Initialize output parameters to prevent compiler warnings */
8485
8486 /*
8487 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
8488 * SubPlan argument. This will necessarily be in some ancestor of the
8489 * current expression's Plan node.
8490 */
8492 {
8496
8499
8501 {
8504
8505 /*
8506 * NestLoops transmit params to their inner child only.
8507 */
8510 {
8512
8514 {
8516
8518 {
8519 /* Found a match, so return it */
8523 }
8524 }
8525 }
8526
8527 /*
8528 * If ancestor is a SubPlan, check the arguments it provides.
8529 */
8531 {
8535
8537 {
8540
8542 {
8543 /*
8544 * Found a match, so return it. But, since Vars in
8545 * the arg are to be evaluated in the surrounding
8546 * context, we have to point to the next ancestor item
8547 * that is *not* a SubPlan.
8548 */
8550
8553 {
8555
8557 {
8561 }
8562 }
8564 }
8565 }
8566
8567 /* SubPlan isn't a kind of Plan, so skip the rest */
8568 continue;
8569 }
8570
8571 /*
8572 * We need not consider the ancestor's initPlan list, since
8573 * initplans never have any parParams.
8574 */
8575
8576 /* No luck, crawl up to next ancestor */
8578 }
8579 }
8580
8581 /* No referent found */
8583}
References arg, SubPlan::args, elog, ERROR, fb(), for_each_cell, forboth, innerPlan, IsA, lfirst, lfirst_int, linitial, lnext(), deparse_context::namespaces, PARAM_EXEC, Param::paramid, Param::paramkind, NestLoopParam::paramval, and SubPlan::parParam.
Referenced by get_name_for_var_field(), and get_parameter().
◆ find_recursive_union()
|
static |
Definition at line 5237 of file ruleutils.c.
References elog, ERROR, fb(), IsA, and lfirst.
Referenced by set_deparse_plan().
◆ flatten_reloptions()
Definition at line 13695 of file ruleutils.c.
13696{
13698 HeapTuple tuple;
13699 Datum reloptions;
13700 bool isnull;
13701
13705
13707 Anum_pg_class_reloptions, &isnull);
13708 if (!isnull)
13709 {
13711
13714
13715 result = buf.data;
13716 }
13717
13718 ReleaseSysCache(tuple);
13719
13720 return result;
13721}
References buf, elog, ERROR, fb(), get_reloptions(), HeapTupleIsValid, initStringInfo(), ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), and SysCacheGetAttr().
Referenced by pg_get_constraintdef_worker(), and pg_get_indexdef_worker().
◆ generate_collation_name()
Definition at line 13595 of file ruleutils.c.
13596{
13597 HeapTuple tp;
13599 char *collname;
13600 char *nspname;
13601 char *result;
13602
13608
13611 else
13612 nspname = NULL;
13613
13614 result = quote_qualified_identifier(nspname, collname);
13615
13616 ReleaseSysCache(tp);
13617
13618 return result;
13619}
References CollationIsVisible(), collid, elog, ERROR, fb(), Form_pg_collation, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), ReleaseSysCache(), and SearchSysCache1().
Referenced by get_const_collation(), get_from_clause_coldeflist(), get_rule_expr(), pg_collation_for(), pg_get_indexdef_worker(), and pg_get_partkeydef_worker().
◆ generate_function_name()
|
static |
Definition at line 13307 of file ruleutils.c.
13310{
13311 char *result;
13316 char *nspname;
13326
13332
13333 /*
13334 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
13335 * qualification of some function names within GROUP BY.
13336 */
13337 if (inGroupBy)
13338 {
13341 }
13342
13343 /*
13344 * Determine whether VARIADIC should be printed. We must do this first
13345 * since it affects the lookup rules in func_get_detail().
13346 *
13347 * We always print VARIADIC if the function has a merged variadic-array
13348 * argument. Note that this is always the case for functions taking a
13349 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
13350 * and printed the array elements as separate arguments, the call could
13351 * match a newer non-VARIADIC function.
13352 */
13354 {
13355 /* Parser should not have set funcvariadic unless fn is variadic */
13359 }
13360 else
13361 {
13364 }
13365
13366 /*
13367 * The idea here is to schema-qualify only if the parser would fail to
13368 * resolve the correct function given the unqualified func name with the
13369 * specified argtypes and VARIADIC flag. But if we already decided to
13370 * force qualification, then we can skip the lookup and pretend we didn't
13371 * find it.
13372 */
13375 NIL, argnames, nargs, argtypes,
13377 &fgc_flags,
13381 else
13382 {
13385 }
13386
13390 p_funcid == funcid)
13391 nspname = NULL;
13392 else
13394
13396
13398
13399 return result;
13400}
References Assert, elog, ERROR, fb(), Form_pg_proc, func_get_detail(), FUNCDETAIL_AGGREGATE, FUNCDETAIL_NORMAL, FUNCDETAIL_NOTFOUND, FUNCDETAIL_WINDOWFUNC, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, list_make1, makeString(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, proname, quote_qualified_identifier(), ReleaseSysCache(), and SearchSysCache1().
Referenced by get_agg_expr_helper(), get_func_expr(), get_tablesample_def(), get_windowfunc_expr_helper(), pg_get_functiondef(), and pg_get_triggerdef_worker().
◆ generate_opclass_name()
Definition at line 12949 of file ruleutils.c.
12950{
12952
12955
12957}
References buf, get_opclass_name(), initStringInfo(), and InvalidOid.
Referenced by index_opclass_options().
◆ generate_operator_clause()
| void generate_operator_clause | ( | StringInfo | buf, |
| const char * | leftop, | ||
| Oid | leftoptype, | ||
| Oid | opoid, | ||
| const char * | rightop, | ||
| Oid | rightoptype | ||
| ) |
Definition at line 13491 of file ruleutils.c.
13495{
13498 char *oprname;
13499 char *nspname;
13500
13507
13509
13518
13520}
References add_cast_to(), appendStringInfo(), appendStringInfoString(), Assert, buf, elog, ERROR, fb(), Form_pg_operator, get_namespace_name(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_identifier(), ReleaseSysCache(), and SearchSysCache1().
Referenced by refresh_by_match_merge(), and ri_GenerateQual().
◆ generate_operator_name()
Definition at line 13414 of file ruleutils.c.
13415{
13419 char *oprname;
13420 char *nspname;
13422
13424
13430
13431 /*
13432 * The idea here is to schema-qualify only if the parser would fail to
13433 * resolve the correct operator given the unqualified op name with the
13434 * specified argtypes.
13435 */
13437 {
13438 case 'b':
13440 true, -1);
13441 break;
13442 case 'l':
13444 true, -1);
13445 break;
13446 default:
13449 break;
13450 }
13451
13453 nspname = NULL;
13454 else
13455 {
13458 }
13459
13461
13462 if (nspname)
13464
13467
13469
13471}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, elog, ERROR, fb(), Form_pg_operator, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, initStringInfo(), left_oper(), list_make1, makeString(), NameStr, ObjectIdGetDatum(), oper(), oprid(), quote_identifier(), ReleaseSysCache(), and SearchSysCache1().
Referenced by get_oper_expr(), get_rule_expr(), get_rule_orderby(), get_simple_binary_op_name(), get_sublink_expr(), and pg_get_indexdef_worker().
◆ generate_qualified_relation_name()
Definition at line 13263 of file ruleutils.c.
13264{
13265 HeapTuple tp;
13268 char *nspname;
13269 char *result;
13270
13276
13278 if (!nspname)
13280 reltup->relnamespace);
13281
13283
13284 ReleaseSysCache(tp);
13285
13286 return result;
13287}
References elog, ERROR, fb(), get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), ReleaseSysCache(), relname, and SearchSysCache1().
Referenced by make_ruledef(), pg_get_constraintdef_worker(), pg_get_indexdef_worker(), pg_get_serial_sequence(), and pg_get_triggerdef_worker().
◆ generate_qualified_type_name()
Definition at line 13562 of file ruleutils.c.
13563{
13564 HeapTuple tp;
13567 char *nspname;
13568 char *result;
13569
13575
13577 if (!nspname)
13579 typtup->typnamespace);
13580
13582
13583 ReleaseSysCache(tp);
13584
13585 return result;
13586}
References elog, ERROR, fb(), Form_pg_type, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), and typname.
Referenced by pg_get_constraintdef_worker().
◆ generate_relation_name()
Definition at line 13203 of file ruleutils.c.
13204{
13205 HeapTuple tp;
13210 char *nspname;
13211 char *result;
13212
13218
13219 /* Check for conflicting CTE name */
13222 {
13225
13227 {
13229
13231 {
13233 break;
13234 }
13235 }
13237 break;
13238 }
13239
13240 /* Otherwise, qualify the name if not visible in search path */
13243
13246 else
13247 nspname = NULL;
13248
13250
13251 ReleaseSysCache(tp);
13252
13253 return result;
13254}
References CommonTableExpr::ctename, elog, ERROR, fb(), get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, lfirst, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), RelationIsVisible(), ReleaseSysCache(), relname, and SearchSysCache1().
Referenced by get_delete_query_def(), get_from_clause_item(), get_insert_query_def(), get_merge_query_def(), get_rule_expr(), get_update_query_def(), make_ruledef(), pg_get_constraintdef_worker(), pg_get_indexdef_worker(), pg_get_statisticsobj_worker(), and pg_get_triggerdef_worker().
◆ get_agg_combine_expr()
|
static |
Definition at line 11056 of file ruleutils.c.
References elog, ERROR, fb(), get_agg_expr(), and IsA.
Referenced by get_agg_expr_helper().
◆ get_agg_expr()
|
static |
Definition at line 10918 of file ruleutils.c.
References fb(), and get_agg_expr_helper().
Referenced by get_agg_combine_expr(), and get_rule_expr().
◆ get_agg_expr_helper()
|
static |
Definition at line 10930 of file ruleutils.c.
10933{
10936 int nargs;
10938
10939 /*
10940 * For a combining aggregate, we look up and deparse the corresponding
10941 * partial aggregate instead. This is necessary because our input
10942 * argument list has been replaced; the new argument list always has just
10943 * one element, which will point to a partial Aggref that supplies us with
10944 * transition states to combine.
10945 */
10947 {
10949
10954 return;
10955 }
10956
10957 /*
10958 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
10959 * to avoid printing this when recursing from the code just above.
10960 */
10963
10964 /* Extract the argument types as seen by the parser */
10965 nargs = get_aggregate_argtypes(aggref, argtypes);
10966
10969 argtypes, aggref->aggvariadic,
10970 &use_variadic,
10971 context->inGroupBy);
10972
10973 /* Print the aggregate name, schema-qualified if needed */
10976
10978 {
10979 /*
10980 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
10981 * worry about inserting VARIADIC. So we can just dump the direct
10982 * args as-is.
10983 */
10984 Assert(!aggref->aggvariadic);
10989 }
10990 else
10991 {
10992 /* aggstar can be set only in zero-argument aggregates */
10993 if (aggref->aggstar)
10995 else
10996 {
10997 ListCell *l;
10999
11000 i = 0;
11002 {
11005
11008 continue;
11010 {
11012 {
11013 /*
11014 * the ABSENT ON NULL and WITH UNIQUE args are printed
11015 * separately, so ignore them here
11016 */
11018 break;
11019
11021 }
11022 else
11024 }
11028 }
11029 }
11030
11032 {
11035 }
11036 }
11037
11040
11042 {
11045 }
11046
11048}
References Aggref::aggdirectargs, Aggref::aggdistinct, Aggref::aggfilter, Aggref::aggfnoid, Aggref::aggorder, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), arg, Aggref::args, Assert, deparse_context::buf, buf, DO_AGGSPLIT_COMBINE, DO_AGGSPLIT_SKIPFINAL, fb(), FUNC_MAX_ARGS, funcname, generate_function_name(), get_agg_combine_expr(), get_aggregate_argtypes(), get_rule_expr(), get_rule_orderby(), i, deparse_context::inGroupBy, IsA, lfirst, linitial_node, list_length(), NIL, and resolve_special_varno().
Referenced by get_agg_expr(), and get_json_agg_constructor().
◆ get_basic_select_query()
|
static |
Definition at line 6113 of file ruleutils.c.
6114{
6118 ListCell *l;
6119
6121 {
6124 }
6125
6126 /*
6127 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6128 * VALUES part. This reverses what transformValuesClause() did at parse
6129 * time.
6130 */
6133 {
6135 return;
6136 }
6137
6138 /*
6139 * Build up the query string - first we say SELECT
6140 */
6141 if (query->isReturn)
6143 else
6145
6146 /* Add the DISTINCT clause if given */
6148 {
6149 if (query->hasDistinctOn)
6150 {
6154 {
6156
6159 false, context);
6161 }
6163 }
6164 else
6166 }
6167
6168 /* Then we tell what to select (the targetlist) */
6170
6171 /* Add the FROM clause if needed */
6173
6174 /* Add the WHERE clause if given */
6176 {
6180 }
6181
6182 /* Add the GROUP BY clause if given */
6184 {
6186
6191
6194
6198 {
6201 {
6203
6206 false, context);
6208 }
6209 }
6210 else
6211 {
6214 {
6216
6220 }
6221 }
6222
6224 }
6225
6226 /* Add the HAVING clause if given */
6228 {
6232 }
6233
6234 /* Add the WINDOW clause if needed */
6236 get_rule_windowclause(query, context);
6237}
References appendContextKeyword(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, Query::distinctClause, fb(), get_from_clause(), get_rule_expr(), get_rule_groupingset(), get_rule_sortgroupclause(), get_rule_windowclause(), get_simple_values_rte(), get_target_list(), get_values_def(), Query::groupByAll, Query::groupClause, Query::groupDistinct, Query::groupingSets, Query::havingQual, deparse_context::indentLevel, deparse_context::inGroupBy, Query::jointree, lfirst, NIL, PRETTY_INDENT, PRETTYINDENT_STD, FromExpr::quals, deparse_context::resultDesc, Query::targetList, and Query::windowClause.
Referenced by get_select_query_def().
◆ get_coercion_expr()
|
static |
Definition at line 11453 of file ruleutils.c.
11456{
11458
11459 /*
11460 * Since parse_coerce.c doesn't immediately collapse application of
11461 * length-coercion functions to constants, what we'll typically see in
11462 * such cases is a Const with typmod -1 and a length-coercion function
11463 * right above it. Avoid generating redundant output. However, beware of
11464 * suppressing casts when the user actually wrote something like
11465 * 'foo'::text::char(3).
11466 *
11467 * Note: it might seem that we are missing the possibility of needing to
11468 * print a COLLATE clause for such a Const. However, a Const could only
11469 * have nondefault collation in a post-constant-folding tree, in which the
11470 * length coercion would have been folded too. See also the special
11471 * handling of CollateExpr in coerce_to_target_type(): any collation
11472 * marking will be above the coercion node, not below it.
11473 */
11477 {
11478 /* Show the constant without normal ::typename decoration */
11480 }
11481 else
11482 {
11488 }
11489
11490 /*
11491 * Never emit resulttype(arg) functional notation. A pg_proc entry could
11492 * take precedence, and a resulttype in pg_temp would require schema
11493 * qualification that format_type_with_typemod() would usually omit. We've
11494 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
11495 * would work fine.
11496 */
11499}
References appendStringInfo(), appendStringInfoChar(), arg, deparse_context::buf, buf, fb(), format_type_with_typemod(), get_const_expr(), get_rule_expr_paren(), IsA, and PRETTY_PAREN.
Referenced by get_func_expr(), and get_rule_expr().
◆ get_column_alias_list()
|
static |
Definition at line 12776 of file ruleutils.c.
12777{
12780 bool first = true;
12781
12782 /* Don't print aliases if not needed */
12784 return;
12785
12787 {
12789
12790 if (first)
12791 {
12793 first = false;
12794 }
12795 else
12798 }
12799 if (!first)
12801}
References appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, fb(), i, and quote_identifier().
Referenced by get_from_clause_item().
◆ get_const_collation()
|
static |
Definition at line 11647 of file ruleutils.c.
11648{
11650
11652 {
11654
11655 if (constval->constcollid != typcollation)
11656 {
11658 generate_collation_name(constval->constcollid));
11659 }
11660 }
11661}
References appendStringInfo(), deparse_context::buf, buf, Const::consttype, generate_collation_name(), get_typcollation(), and OidIsValid.
Referenced by get_const_expr().
◆ get_const_expr()
|
static |
Definition at line 11517 of file ruleutils.c.
11518{
11520 Oid typoutput;
11524
11525 if (constval->constisnull)
11526 {
11527 /*
11528 * Always label the type of a NULL constant to prevent misdecisions
11529 * about type when reparsing.
11530 */
11533 {
11536 constval->consttypmod));
11537 get_const_collation(constval, context);
11538 }
11539 return;
11540 }
11541
11543 &typoutput, &typIsVarlena);
11544
11546
11548 {
11550
11551 /*
11552 * INT4 can be printed without any decoration, unless it is
11553 * negative; in that case print it as '-nnn'::integer to ensure
11554 * that the output will re-parse as a constant, not as a constant
11555 * plus operator. In most cases we could get away with printing
11556 * (-nnn) instead, because of the way that gram.y handles negative
11557 * literals; but that doesn't work for INT_MIN, and it doesn't
11558 * seem that much prettier anyway.
11559 */
11562 else
11563 {
11566 }
11567 break;
11568
11570
11571 /*
11572 * NUMERIC can be printed without quotes if it looks like a float
11573 * constant (not an integer, and not Infinity or NaN) and doesn't
11574 * have a leading sign (for the same reason as for INT4).
11575 */
11578 {
11580 }
11581 else
11582 {
11585 }
11586 break;
11587
11591 else
11593 break;
11594
11595 default:
11597 break;
11598 }
11599
11601
11603 return;
11604
11605 /*
11606 * For showtype == 0, append ::typename unless the constant will be
11607 * implicitly typed as the right type when it is read in.
11608 *
11609 * XXX this code has to be kept in sync with the behavior of the parser,
11610 * especially make_const.
11611 */
11613 {
11616 /* These types can be left unlabeled */
11618 break;
11620 /* We determined above whether a label is needed */
11621 break;
11623
11624 /*
11625 * Float-looking constants will be typed as numeric, which we
11626 * checked above; but if there's a nondefault typmod we need to
11627 * show it.
11628 */
11629 needlabel |= (constval->consttypmod >= 0);
11630 break;
11631 default:
11633 break;
11634 }
11638 constval->consttypmod));
11639
11640 get_const_collation(constval, context);
11641}
References appendStringInfo(), appendStringInfoString(), deparse_context::buf, buf, Const::consttype, fb(), format_type_with_typemod(), get_const_collation(), getTypeOutputInfo(), OidOutputFunctionCall(), pfree(), and simple_quote_literal().
Referenced by get_coercion_expr(), get_json_path_spec(), get_json_table(), get_json_table_nested_columns(), get_range_partbound_string(), get_rule_expr(), and get_rule_sortgroupclause().
◆ get_delete_query_def()
|
static |
Definition at line 7379 of file ruleutils.c.
7380{
7383
7384 /* Insert the WITH clause if given */
7385 get_with_clause(query, context);
7386
7387 /*
7388 * Start the query with DELETE FROM relname
7389 */
7393 {
7396 }
7400
7401 /* Print the relation alias, if needed */
7403
7404 /* Add the USING clause if given */
7406
7407 /* Add a WHERE clause if given */
7409 {
7413 }
7414
7415 /* Add RETURNING if present */
7417 get_returning_clause(query, context);
7418}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), Assert, deparse_context::buf, buf, fb(), generate_relation_name(), get_from_clause(), get_returning_clause(), get_rte_alias(), get_rule_expr(), get_with_clause(), deparse_context::indentLevel, Query::jointree, NIL, only_marker, PRETTY_INDENT, PRETTYINDENT_STD, FromExpr::quals, Query::returningList, rt_fetch, Query::rtable, and RTE_RELATION.
Referenced by get_query_def().
◆ get_from_clause()
|
static |
Definition at line 12320 of file ruleutils.c.
12321{
12323 bool first = true;
12324 ListCell *l;
12325
12326 /*
12327 * We use the query's jointree as a guide to what to print. However, we
12328 * must ignore auto-added RTEs that are marked not inFromCl. (These can
12329 * only appear at the top level of the jointree, so it's sufficient to
12330 * check here.) This check also ensures we ignore the rule pseudo-RTEs
12331 * for NEW and OLD.
12332 */
12334 {
12336
12338 {
12341
12343 continue;
12344 }
12345
12346 if (first)
12347 {
12348 appendContextKeyword(context, prefix,
12350 first = false;
12351
12352 get_from_clause_item(jtnode, query, context);
12353 }
12354 else
12355 {
12357
12359
12360 /*
12361 * Put the new FROM item's text into itembuf so we can decide
12362 * after we've got it whether or not it needs to go on a new line.
12363 */
12366
12367 get_from_clause_item(jtnode, query, context);
12368
12369 /* Restore context's output buffer */
12371
12372 /* Consider line-wrapping if enabled */
12374 {
12375 /* Does the new item start with a new line? */
12377 {
12378 /* If so, we shouldn't add anything */
12379 /* instead, remove any trailing spaces currently in buf */
12381 }
12382 else
12383 {
12385
12386 /* Locate the start of the current line in the buffer */
12390 else
12391 trailing_nl++;
12392
12393 /*
12394 * Add a newline, plus some indentation, if the new item
12395 * would cause an overflow.
12396 */
12399 PRETTYINDENT_STD,
12400 PRETTYINDENT_VAR);
12401 }
12402 }
12403
12404 /* Add the new item */
12406
12407 /* clean up */
12409 }
12410 }
12411}
References appendBinaryStringInfo(), appendContextKeyword(), appendStringInfoString(), deparse_context::buf, buf, fb(), FromExpr::fromlist, get_from_clause_item(), initStringInfo(), IsA, Query::jointree, lfirst, pfree(), PRETTY_INDENT, PRETTYINDENT_STD, PRETTYINDENT_VAR, removeStringInfoSpaces(), rt_fetch, Query::rtable, and deparse_context::wrapColumn.
Referenced by get_basic_select_query(), get_delete_query_def(), get_merge_query_def(), and get_update_query_def().
◆ get_from_clause_coldeflist()
|
static |
Definition at line 12816 of file ruleutils.c.
12819{
12821 ListCell *l1;
12822 ListCell *l2;
12823 ListCell *l3;
12824 ListCell *l4;
12826
12828
12829 i = 0;
12830 forfour(l1, rtfunc->funccoltypes,
12831 l2, rtfunc->funccoltypmods,
12832 l3, rtfunc->funccolcollations,
12833 l4, rtfunc->funccolnames)
12834 {
12839
12842 else
12844
12846
12855 generate_collation_name(attcollation));
12856
12857 i++;
12858 }
12859
12861}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attname, deparse_context::buf, buf, fb(), forfour, format_type_with_typemod(), generate_collation_name(), get_typcollation(), i, lfirst, lfirst_int, lfirst_oid, OidIsValid, quote_identifier(), and strVal.
Referenced by get_from_clause_item().
◆ get_from_clause_item()
|
static |
Definition at line 12414 of file ruleutils.c.
12415{
12418
12420 {
12425
12428
12429 /* Print the FROM item proper */
12431 {
12433 /* Normal relation RTE */
12437 context->namespaces));
12438 break;
12440 /* Subquery RTE */
12443 true,
12445 context->indentLevel);
12447 break;
12449 /* Function RTE */
12451
12452 /*
12453 * Omit ROWS FROM() syntax for just one function, unless it
12454 * has both a coldeflist and WITH ORDINALITY. If it has both,
12455 * we must use ROWS FROM() syntax to avoid ambiguity about
12456 * whether the coldeflist includes the ordinality column.
12457 */
12460 {
12462 /* we'll print the coldeflist below, if it has one */
12463 }
12464 else
12465 {
12468
12469 /*
12470 * If all the function calls in the list are to unnest,
12471 * and none need a coldeflist, then collapse the list back
12472 * down to UNNEST(args). (If we had more than one
12473 * built-in unnest function, this would get more
12474 * difficult.)
12475 *
12476 * XXX This is pretty ugly, since it makes not-terribly-
12477 * future-proof assumptions about what the parser would do
12478 * with the output; but the alternative is to emit our
12479 * nonstandard ROWS FROM() notation for what might have
12480 * been a perfectly spec-compliant multi-argument
12481 * UNNEST().
12482 */
12485 {
12487
12490 rtfunc->funccolnames != NIL)
12491 {
12493 break;
12494 }
12495 }
12496
12498 {
12500
12502 {
12505
12507 }
12508
12512 }
12513 else
12514 {
12516
12519 {
12521
12526 {
12527 /* Reconstruct the column definition list */
12529 get_from_clause_coldeflist(rtfunc,
12530 NULL,
12531 context);
12532 }
12533 funcno++;
12534 }
12536 }
12537 /* prevent printing duplicate coldeflist below */
12539 }
12542 break;
12545 break;
12547 /* Values list RTE */
12551 break;
12554 break;
12555 default:
12557 break;
12558 }
12559
12560 /* Print the relation alias, if needed */
12562
12563 /* Print the column definitions or aliases, if needed */
12565 {
12566 /* Reconstruct the columndef list, which is also the aliases */
12568 }
12569 else
12570 {
12571 /* Else print column aliases as needed */
12573 }
12574
12575 /* Tablesample clause must go after any alias */
12578 }
12580 {
12584
12588
12591
12593
12595 {
12599 -PRETTYINDENT_STD,
12600 PRETTYINDENT_STD,
12601 PRETTYINDENT_JOIN);
12602 else
12604 -PRETTYINDENT_STD,
12605 PRETTYINDENT_STD,
12606 PRETTYINDENT_JOIN);
12607 break;
12610 -PRETTYINDENT_STD,
12611 PRETTYINDENT_STD,
12612 PRETTYINDENT_JOIN);
12613 break;
12616 -PRETTYINDENT_STD,
12617 PRETTYINDENT_STD,
12618 PRETTYINDENT_JOIN);
12619 break;
12622 -PRETTYINDENT_STD,
12623 PRETTYINDENT_STD,
12624 PRETTYINDENT_JOIN);
12625 break;
12626 default:
12629 }
12630
12636
12638 {
12640 bool first = true;
12641
12643 /* Use the assigned names, not what's in usingClause */
12645 {
12647
12648 if (first)
12649 first = false;
12650 else
12653 }
12655
12659 }
12661 {
12668 }
12670 {
12671 /* If we didn't say CROSS JOIN above, we must provide an ON */
12673 }
12674
12677
12678 /* Yes, it's correct to put alias after the right paren ... */
12680 {
12681 /*
12682 * Note that it's correct to emit an alias clause if and only if
12683 * there was one originally. Otherwise we'd be converting a named
12684 * join to unnamed or vice versa, which creates semantic
12685 * subtleties we don't want. However, we might print a different
12686 * alias name than was there originally.
12687 */
12690 context)));
12692 }
12693 }
12694 else
12697}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, deparse_columns_fetch, elog, ERROR, fb(), RangeTblFunction::funcexpr, generate_relation_name(), get_column_alias_list(), get_from_clause_coldeflist(), get_from_clause_item(), get_query_def(), get_rtable_name(), get_rte_alias(), get_rule_expr(), get_rule_expr_funccall(), get_tablefunc(), get_tablesample_def(), get_values_def(), deparse_context::indentLevel, IsA, j, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, lfirst, linitial, list_concat(), list_length(), deparse_context::namespaces, NIL, nodeTag, only_marker, PRETTY_PAREN, deparse_context::prettyFlags, PRETTYINDENT_JOIN, PRETTYINDENT_STD, quote_identifier(), rt_fetch, Query::rtable, RTE_CTE, RTE_FUNCTION, RTE_RELATION, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, and deparse_context::wrapColumn.
Referenced by get_from_clause(), and get_from_clause_item().
◆ get_func_expr()
|
static |
Definition at line 10822 of file ruleutils.c.
10824{
10828 int nargs;
10829 List *argnames;
10831 ListCell *l;
10832
10833 /*
10834 * If the function call came from an implicit coercion, then just show the
10835 * first argument --- unless caller wants to see implicit coercions.
10836 */
10838 {
10841 return;
10842 }
10843
10844 /*
10845 * If the function call came from a cast, then show the first argument
10846 * plus an explicit cast operation.
10847 */
10849 expr->funcformat == COERCE_IMPLICIT_CAST)
10850 {
10852 Oid rettype = expr->funcresulttype;
10854
10855 /* Get the typmod if this is a length-coercion function */
10857
10859 rettype, coercedTypmod,
10860 (Node *) expr);
10861
10862 return;
10863 }
10864
10865 /*
10866 * If the function was called using one of the SQL spec's random special
10867 * syntaxes, try to reproduce that. If we don't recognize the function,
10868 * fall through.
10869 */
10871 {
10873 return;
10874 }
10875
10876 /*
10877 * Normal function: display as proname(args). First we need to extract
10878 * the argument datatypes.
10879 */
10884 nargs = 0;
10885 argnames = NIL;
10887 {
10889
10893 nargs++;
10894 }
10895
10898 argnames, argtypes,
10899 expr->funcvariadic,
10900 &use_variadic,
10901 context->inGroupBy));
10902 nargs = 0;
10904 {
10905 if (nargs++ > 0)
10910 }
10912}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), arg, FuncExpr::args, deparse_context::buf, buf, COERCE_EXPLICIT_CAST, COERCE_IMPLICIT_CAST, COERCE_SQL_SYNTAX, ereport, errcode(), errmsg(), ERROR, exprIsLengthCoercion(), exprType(), fb(), FUNC_MAX_ARGS, FuncExpr::funcid, generate_function_name(), get_coercion_expr(), get_func_sql_syntax(), get_rule_expr(), get_rule_expr_paren(), deparse_context::inGroupBy, IsA, lappend(), lfirst, linitial, list_length(), lnext(), and NIL.
Referenced by get_rule_expr().
◆ get_func_sql_syntax()
|
static |
Definition at line 11201 of file ruleutils.c.
11202{
11205
11207 {
11214 /* AT TIME ZONE ... note reversed argument order */
11217 (Node *) expr);
11220 (Node *) expr);
11222 return true;
11223
11227 /* AT LOCAL */
11230 (Node *) expr);
11232 return true;
11233
11247 /* (x1, x2) OVERLAPS (y1, y2) */
11257 return true;
11258
11265 /* EXTRACT (x FROM y) */
11267 {
11269
11272 !con->constisnull);
11274 }
11278 return true;
11279
11281 /* IS xxx NORMALIZED */
11284 (Node *) expr);
11287 {
11289
11292 !con->constisnull);
11294 TextDatumGetCString(con->constvalue));
11295 }
11297 return true;
11298
11300 /* COLLATION FOR */
11304 return true;
11305
11307 /* NORMALIZE() */
11311 {
11313
11316 !con->constisnull);
11318 TextDatumGetCString(con->constvalue));
11319 }
11321 return true;
11322
11329 /* OVERLAY() */
11337 {
11340 }
11342 return true;
11343
11347 /* POSITION() ... extra parens since args are b_expr not a_expr */
11353 return true;
11354
11361 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
11367 {
11370 }
11372 return true;
11373
11375 /* SUBSTRING SIMILAR/ESCAPE */
11383 return true;
11384
11388 /* TRIM() */
11391 {
11394 }
11398 return true;
11399
11403 /* TRIM() */
11406 {
11409 }
11413 return true;
11414
11418 /* TRIM() */
11421 {
11424 }
11428 return true;
11429
11432 return true;
11433
11435 /* XMLEXISTS ... extra parens because args are c_expr */
11441 return true;
11442 }
11443 return false;
11444}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), FuncExpr::args, Assert, deparse_context::buf, buf, Const::consttype, fb(), FuncExpr::funcid, get_rule_expr(), get_rule_expr_paren(), IsA, lfourth, linitial, list_length(), lsecond, lthird, and TextDatumGetCString.
Referenced by get_func_expr().
◆ get_insert_query_def()
|
static |
Definition at line 6946 of file ruleutils.c.
6947{
6953 ListCell *l;
6955
6956 /* Insert the WITH clause if given */
6957 get_with_clause(query, context);
6958
6959 /*
6960 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
6961 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
6962 */
6964 {
6966
6968 {
6972 }
6973
6975 {
6979 }
6980 }
6983
6984 /*
6985 * Start the query with INSERT INTO relname
6986 */
6989
6991 {
6994 }
6997
6998 /* Print the relation alias, if needed; INSERT requires explicit AS */
7000
7001 /* always want a space here */
7003
7004 /*
7005 * Add the insert-column-names list. Any indirection decoration needed on
7006 * the column names can be inferred from the top targetlist.
7007 */
7013 {
7015
7017 continue; /* ignore junk entries */
7018
7021
7022 /*
7023 * Put out name of target column; look in the catalogs, not at
7024 * tle->resname, since resname will fail to track RENAME.
7025 */
7028 tle->resno,
7029 false)));
7030
7031 /*
7032 * Print any indirection needed (subfields or subscripts), and strip
7033 * off the top-level nodes representing the indirection assignments.
7034 * Add the stripped expressions to strippedexprs. (If it's a
7035 * single-VALUES statement, the stripped expressions are the VALUES to
7036 * print below. Otherwise they're just Vars and not really
7037 * interesting.)
7038 */
7041 context));
7042 }
7045
7046 if (query->override)
7047 {
7052 }
7053
7055 {
7056 /* Add the SELECT */
7058 false,
7060 context->indentLevel);
7061 }
7063 {
7064 /* Add the multi-VALUES expression lists */
7066 }
7068 {
7069 /* Add the single-VALUES expression list */
7074 }
7075 else
7076 {
7077 /* No expressions, so it must be DEFAULT VALUES */
7079 }
7080
7081 /* Add ON CONFLICT if present */
7083 {
7085
7087
7089 {
7090 /* Add the single-VALUES expression list */
7094
7095 /* Add a WHERE clause (for partial indexes) if given */
7097 {
7099
7100 /*
7101 * Force non-prefixing of Vars, since parser assumes that they
7102 * belong to target relation. WHERE clause does not use
7103 * InferenceElem, so this is separately required.
7104 */
7107
7111
7113 }
7114 }
7116 {
7118
7119 if (!constraint)
7121 confl->constraint);
7123 quote_identifier(constraint));
7124 }
7125
7127 {
7129 }
7131 {
7133 /* Deparse targetlist */
7135 context, rte);
7136
7137 /* Add a WHERE clause if given */
7139 {
7143 }
7144 }
7145 else
7146 {
7149
7150 /* Add FOR [KEY] UPDATE/SHARE clause if present */
7153
7154 /* Add a WHERE clause if given */
7156 {
7160 }
7161 }
7162 }
7163
7164 /* Add RETURNING if present */
7166 get_returning_clause(query, context);
7167}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, elog, ERROR, fb(), generate_relation_name(), get_attname(), get_constraint_name(), get_lock_clause_strength(), get_query_def(), get_returning_clause(), get_rte_alias(), get_rule_expr(), get_rule_list_toplevel(), get_update_query_targetlist_def(), get_values_def(), get_with_clause(), deparse_context::indentLevel, lappend(), LCS_NONE, lfirst, deparse_context::namespaces, NIL, OidIsValid, Query::onConflict, ONCONFLICT_NOTHING, ONCONFLICT_SELECT, ONCONFLICT_UPDATE, OVERRIDING_SYSTEM_VALUE, OVERRIDING_USER_VALUE, PRETTY_INDENT, deparse_context::prettyFlags, PRETTYINDENT_STD, processIndirection(), quote_identifier(), Query::returningList, rt_fetch, Query::rtable, RTE_RELATION, RTE_SUBQUERY, RTE_VALUES, Query::targetList, deparse_context::varprefix, and deparse_context::wrapColumn.
Referenced by get_query_def().
◆ get_json_agg_constructor()
|
static |
Definition at line 11820 of file ruleutils.c.
References elog, ERROR, fb(), funcname, get_agg_expr_helper(), get_json_constructor_options(), get_windowfunc_expr_helper(), initStringInfo(), IsA, and nodeTag.
Referenced by get_json_constructor().
◆ get_json_behavior()
|
static |
Definition at line 9205 of file ruleutils.c.
9207{
9208 /*
9209 * The order of array elements must correspond to the order of
9210 * JsonBehaviorType members.
9211 */
9213 {
9214 " NULL",
9215 " ERROR",
9216 " EMPTY",
9217 " TRUE",
9218 " FALSE",
9219 " UNKNOWN",
9220 " EMPTY ARRAY",
9221 " EMPTY OBJECT",
9222 " DEFAULT "
9223 };
9224
9227
9229
9232
9234}
References appendStringInfo(), appendStringInfoString(), JsonBehavior::btype, deparse_context::buf, elog, ERROR, JsonBehavior::expr, fb(), get_rule_expr(), JSON_BEHAVIOR_DEFAULT, and lengthof.
Referenced by get_json_expr_options(), and get_json_table().
◆ get_json_constructor()
|
static |
Definition at line 11724 of file ruleutils.c.
11726{
11732
11734 {
11736 return;
11737 }
11739 {
11741 return;
11742 }
11743
11745 {
11748 break;
11751 break;
11754 break;
11757 break;
11760 break;
11761 default:
11763 }
11764
11766
11769 {
11772 {
11774
11777 }
11778
11780 }
11781
11784}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, elog, ERROR, fb(), foreach_current_index, funcname, get_json_agg_constructor(), get_json_constructor_options(), get_rule_expr(), JSCTOR_JSON_ARRAY, JSCTOR_JSON_ARRAYAGG, JSCTOR_JSON_OBJECT, JSCTOR_JSON_OBJECTAGG, JSCTOR_JSON_PARSE, JSCTOR_JSON_SCALAR, JSCTOR_JSON_SERIALIZE, and lfirst.
Referenced by get_rule_expr().
◆ get_json_constructor_options()
|
static |
Definition at line 11790 of file ruleutils.c.
11791{
11793 {
11797 }
11798 else
11799 {
11803 }
11804
11807
11808 /*
11809 * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
11810 * support one.
11811 */
11814}
References appendStringInfoString(), buf, fb(), get_json_returning(), JSCTOR_JSON_ARRAY, JSCTOR_JSON_ARRAYAGG, JSCTOR_JSON_OBJECT, JSCTOR_JSON_OBJECTAGG, JSCTOR_JSON_PARSE, and JSCTOR_JSON_SCALAR.
Referenced by get_json_agg_constructor(), and get_json_constructor().
◆ get_json_expr_options()
|
static |
Definition at line 9243 of file ruleutils.c.
9245{
9247 {
9252 /* The default */
9255
9258 /* The default */
9259 else
9261 }
9262
9265
9268}
References appendStringInfoString(), JsonBehavior::btype, deparse_context::buf, fb(), get_json_behavior(), JSON_QUERY_OP, JSW_CONDITIONAL, JSW_NONE, JSW_UNCONDITIONAL, JSW_UNSPEC, JsonExpr::omit_quotes, JsonExpr::on_empty, JsonExpr::on_error, JsonExpr::op, and JsonExpr::wrapper.
Referenced by get_json_table_columns(), and get_rule_expr().
◆ get_json_format()
|
static |
Definition at line 11679 of file ruleutils.c.
11680{
11682 return;
11683
11686 " FORMAT JSONB" : " FORMAT JSON");
11687
11689 {
11691
11692 encoding =
11695
11697 }
11698}
References appendStringInfo(), appendStringInfoString(), buf, encoding, format, JS_ENC_DEFAULT, JS_ENC_UTF16, JS_ENC_UTF32, JS_FORMAT_DEFAULT, and JS_FORMAT_JSONB.
Referenced by get_json_returning(), and get_rule_expr().
◆ get_json_path_spec()
|
static |
Definition at line 11667 of file ruleutils.c.
11668{
11671 else
11673}
References fb(), get_const_expr(), get_rule_expr(), and IsA.
Referenced by get_json_table_columns(), and get_rule_expr().
◆ get_json_returning()
|
static |
Definition at line 11704 of file ruleutils.c.
References appendStringInfo(), buf, fb(), JsonReturning::format, JsonFormat::format_type, format_type_with_typemod(), get_json_format(), JS_FORMAT_JSON, JS_FORMAT_JSONB, OidIsValid, JsonReturning::typid, and JsonReturning::typmod.
Referenced by get_json_constructor_options(), and get_rule_expr().
◆ get_json_table()
|
static |
Definition at line 12232 of file ruleutils.c.
12233{
12237
12239
12242
12244
12246
12248
12250
12252
12254 {
12256 *lc2;
12258
12261
12264
12267 {
12271
12273
12277 );
12278 }
12279
12282 }
12283
12285 showimplicit);
12286
12289
12292
12294}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, castNode, TableFunc::docexpr, fb(), forboth, get_const_expr(), get_json_behavior(), get_json_table_columns(), get_rule_expr(), deparse_context::indentLevel, JSON_BEHAVIOR_EMPTY_ARRAY, lfirst, lfirst_node, PRETTY_INDENT, PRETTYINDENT_VAR, quote_identifier(), and root.
Referenced by get_tablefunc().
◆ get_json_table_columns()
|
static |
Definition at line 12126 of file ruleutils.c.
12129{
12135 int colnum = 0;
12136
12139
12142
12144 lc_coltype, tf->coltypes,
12145 lc_coltypmod, tf->coltypmods,
12146 lc_colvalexpr, tf->colvalexprs)
12147 {
12149 JsonExpr *colexpr;
12150 Oid typid;
12151 int32 typmod;
12152 bool ordinality;
12154
12158
12159 /* Skip columns that don't belong to this scan. */
12161 {
12162 colnum++;
12163 continue;
12164 }
12166 break;
12167
12170
12171 colnum++;
12172
12173 ordinality = !colexpr;
12174
12176
12178 ordinality ? "FOR ORDINALITY" :
12179 format_type_with_typemod(typid, typmod));
12180 if (ordinality)
12181 continue;
12182
12183 /*
12184 * Set default_behavior to guide get_json_expr_options() on whether to
12185 * emit the ON ERROR / EMPTY clauses.
12186 */
12188 {
12191 }
12192 else
12193 {
12195 {
12198
12200
12204 " FORMAT JSONB" : " FORMAT JSON");
12205 }
12206
12208 }
12209
12211
12213
12215 }
12216
12219 scan->colMin >= 0);
12220
12223
12225}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, castNode, JsonTablePathScan::child, JsonTablePathScan::colMax, JsonTablePathScan::colMin, fb(), forfour, JsonExpr::format, JsonFormat::format_type, format_type_with_typemod(), get_json_expr_options(), get_json_path_spec(), get_json_table_nested_columns(), get_type_category_preferred(), deparse_context::indentLevel, JS_FORMAT_JSONB, JSON_BEHAVIOR_FALSE, JSON_BEHAVIOR_NULL, JSON_EXISTS_OP, JSON_QUERY_OP, lfirst, lfirst_int, lfirst_oid, JsonExpr::op, JsonExpr::path_spec, PRETTY_INDENT, PRETTYINDENT_VAR, quote_identifier(), and strVal.
Referenced by get_json_table(), and get_json_table_nested_columns().
◆ get_json_table_nested_columns()
|
static |
Definition at line 12094 of file ruleutils.c.
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), deparse_context::buf, castNode, fb(), get_const_expr(), get_json_table_columns(), get_json_table_nested_columns(), IsA, JsonTableSiblingJoin::lplan, JsonTablePath::name, JsonTablePathScan::path, plan, quote_identifier(), JsonTableSiblingJoin::rplan, and JsonTablePath::value.
Referenced by get_json_table_columns(), and get_json_table_nested_columns().
◆ get_lock_clause_strength()
|
static |
Definition at line 6017 of file ruleutils.c.
6018{
6019 switch (strength)
6020 {
6022 /* we intentionally throw an error for LCS_NONE */
6024 (int) strength);
6025 break;
6027 return " FOR KEY SHARE";
6029 return " FOR SHARE";
6031 return " FOR NO KEY UPDATE";
6033 return " FOR UPDATE";
6034 }
6036}
References elog, ERROR, fb(), LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, and LCS_NONE.
Referenced by get_insert_query_def(), and get_select_query_def().
◆ get_merge_query_def()
|
static |
Definition at line 7426 of file ruleutils.c.
7427{
7432
7433 /* Insert the WITH clause if given */
7434 get_with_clause(query, context);
7435
7436 /*
7437 * Start the query with MERGE INTO relname
7438 */
7442 {
7445 }
7449
7450 /* Print the relation alias, if needed */
7452
7453 /* Print the source relation and join clause */
7458
7459 /*
7460 * Test for any NOT MATCHED BY SOURCE actions. If there are none, then
7461 * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
7462 * SQL standard. Otherwise, we have a non-SQL-standard query, so output
7463 * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
7464 * more explicit.
7465 */
7468 {
7470
7472 {
7474 break;
7475 }
7476 }
7477
7478 /* Print each merge action */
7480 {
7482
7486 {
7489 break;
7492 break;
7496 else
7498 break;
7499 default:
7502 }
7503
7505 {
7509 }
7512
7514 {
7515 /* This generally matches get_insert_query_def() */
7519
7521
7525 {
7527
7529
7532
7535 tle->resno,
7536 false)));
7539 context));
7540 }
7543
7545 {
7550 }
7551
7553 {
7558 }
7559 else
7561 }
7563 {
7566 context, rte);
7567 }
7572 }
7573
7574 /* Add RETURNING if present */
7576 get_returning_clause(query, context);
7577}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, CMD_DELETE, CMD_INSERT, CMD_NOTHING, CMD_UPDATE, elog, ERROR, fb(), generate_relation_name(), get_attname(), get_from_clause(), get_returning_clause(), get_rte_alias(), get_rule_expr(), get_rule_list_toplevel(), get_update_query_targetlist_def(), get_with_clause(), deparse_context::indentLevel, lappend(), lfirst, lfirst_node, MERGE_WHEN_MATCHED, MERGE_WHEN_NOT_MATCHED_BY_SOURCE, MERGE_WHEN_NOT_MATCHED_BY_TARGET, Query::mergeActionList, Query::mergeJoinCondition, NIL, only_marker, OVERRIDING_SYSTEM_VALUE, OVERRIDING_USER_VALUE, PRETTY_INDENT, PRETTYINDENT_STD, processIndirection(), quote_identifier(), Query::returningList, rt_fetch, Query::rtable, and RTE_RELATION.
Referenced by get_query_def().
◆ get_name_for_var_field()
|
static |
Definition at line 8041 of file ruleutils.c.
8043{
8048 int varno;
8049 AttrNumber varattno;
8051 Node *expr;
8052
8053 /*
8054 * If it's a RowExpr that was expanded from a whole-row Var, use the
8055 * column names attached to it. (We could let get_expr_result_tupdesc()
8056 * handle this, but it's much cheaper to just pull out the name we need.)
8057 */
8059 {
8061
8064 }
8065
8066 /*
8067 * If it's a Param of type RECORD, try to find what the Param refers to.
8068 */
8070 {
8073
8075 if (expr)
8076 {
8077 /* Found a match, so recurse to decipher the field name */
8079 const char *result;
8080
8083 0, context);
8085 return result;
8086 }
8087 }
8088
8089 /*
8090 * If it's a Var of type RECORD, we have to find what the Var refers to;
8091 * if not, we can use get_expr_result_tupdesc().
8092 */
8094 var->vartype != RECORDOID)
8095 {
8097 /* Got the tupdesc, so we can extract the field name */
8100 }
8101
8102 /* Find appropriate nesting depth */
8106 var->varlevelsup, levelsup);
8108 netlevelsup);
8109
8110 /*
8111 * If we have a syntactic referent for the Var, and we're working from a
8112 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8113 * on the semantic referent. (See comments in get_variable().)
8114 */
8116 {
8117 varno = var->varnosyn;
8118 varattno = var->varattnosyn;
8119 }
8120 else
8121 {
8122 varno = var->varno;
8123 varattno = var->varattno;
8124 }
8125
8126 /*
8127 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8128 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8129 * down into the subplans, or INDEX_VAR, which is resolved similarly.
8130 *
8131 * Note: unlike get_variable and resolve_special_varno, we need not worry
8132 * about inheritance mapping: a child Var should have the same datatype as
8133 * its parent, and here we're really only interested in the Var's type.
8134 */
8136 {
8138 attnum = varattno;
8139 }
8141 {
8144 const char *result;
8145
8149
8152
8154 levelsup, context);
8155
8157 return result;
8158 }
8160 {
8163 const char *result;
8164
8168
8171
8173 levelsup, context);
8174
8176 return result;
8177 }
8179 {
8181 const char *result;
8182
8186
8188
8190 levelsup, context);
8191
8192 return result;
8193 }
8194 else
8195 {
8198 }
8199
8201 {
8202 /* Var is whole-row reference to RTE, so select the right field */
8204 }
8205
8206 /*
8207 * This part has essentially the same logic as the parser's
8208 * expandRecordVariable() function, but we are dealing with a different
8209 * representation of the input context, and we only need one field name
8210 * not a TupleDesc. Also, we need special cases for finding subquery and
8211 * CTE subplans when deparsing Plan trees.
8212 */
8214
8216 {
8221
8222 /*
8223 * This case should not occur: a column of a table, values list,
8224 * or ENR shouldn't have type RECORD. Fall through and fail (most
8225 * likely) at the bottom.
8226 */
8227 break;
8229 /* Subselect-in-FROM: examine sub-select's output expr */
8230 {
8232 {
8234 attnum);
8235
8241 {
8242 /*
8243 * Recurse into the sub-select to see what its Var
8244 * refers to. We have to build an additional level of
8245 * namespace to keep in step with varlevelsup in the
8246 * subselect; furthermore, the subquery RTE might be
8247 * from an outer query level, in which case the
8248 * namespace for the subselect must have that outer
8249 * level as parent namespace.
8250 */
8254 const char *result;
8255
8257 netlevelsup);
8258
8260 parent_namespaces);
8261
8263
8265 0, context);
8266
8268
8269 return result;
8270 }
8271 /* else fall through to inspect the expression */
8272 }
8273 else
8274 {
8275 /*
8276 * We're deparsing a Plan tree so we don't have complete
8277 * RTE entries (in particular, rte->subquery is NULL). But
8278 * the only place we'd normally see a Var directly
8279 * referencing a SUBQUERY RTE is in a SubqueryScan plan
8280 * node, and we can look into the child plan's tlist
8281 * instead. An exception occurs if the subquery was
8282 * proven empty and optimized away: then we'd find such a
8283 * Var in a childless Result node, and there's nothing in
8284 * the plan tree that would let us figure out what it had
8285 * originally referenced. In that case, fall back on
8286 * printing "fN", analogously to the default column names
8287 * for RowExprs.
8288 */
8291 const char *result;
8292
8294 {
8296
8300 }
8302
8306 attnum);
8309
8311 levelsup, context);
8312
8314 return result;
8315 }
8316 }
8317 break;
8319 /* Join RTE --- recursively inspect the alias variable */
8325 /* we intentionally don't strip implicit coercions here */
8328 var->varlevelsup + levelsup,
8329 context);
8330 /* else fall through to inspect the expression */
8331 break;
8334
8335 /*
8336 * We couldn't get here unless a function is declared with one of
8337 * its result columns as RECORD, which is not allowed.
8338 */
8339 break;
8341 /* CTE reference: examine subquery's output expr */
8342 {
8344 Index ctelevelsup;
8346
8347 /*
8348 * Try to find the referenced CTE using the namespace stack.
8349 */
8353 else
8354 {
8356
8360 {
8363 break;
8364 }
8365 }
8367 {
8370 attnum);
8371
8377 {
8378 /*
8379 * Recurse into the CTE to see what its Var refers to.
8380 * We have to build an additional level of namespace
8381 * to keep in step with varlevelsup in the CTE;
8382 * furthermore it could be an outer CTE (compare
8383 * SUBQUERY case above).
8384 */
8388 const char *result;
8389
8391 ctelevelsup);
8392
8394 parent_namespaces);
8395
8397
8399 0, context);
8400
8402
8403 return result;
8404 }
8405 /* else fall through to inspect the expression */
8406 }
8407 else
8408 {
8409 /*
8410 * We're deparsing a Plan tree so we don't have a CTE
8411 * list. But the only places we'd normally see a Var
8412 * directly referencing a CTE RTE are in CteScan or
8413 * WorkTableScan plan nodes. For those cases,
8414 * set_deparse_plan arranged for dpns->inner_plan to be
8415 * the plan node that emits the CTE or RecursiveUnion
8416 * result, and we can look at its tlist instead. As
8417 * above, this can fail if the CTE has been proven empty,
8418 * in which case fall back to "fN".
8419 */
8422 const char *result;
8423
8425 {
8427
8431 }
8434
8438 attnum);
8441
8443 levelsup, context);
8444
8446 return result;
8447 }
8448 }
8449 break;
8451
8452 /*
8453 * We couldn't get here: any Vars that reference the RTE_GROUP RTE
8454 * should have been replaced with the underlying grouping
8455 * expressions.
8456 */
8457 break;
8458 }
8459
8460 /*
8461 * We now have an expression we can't expand any more, so see if
8462 * get_expr_result_tupdesc() can do anything with it.
8463 */
8465 /* Got the tupdesc, so we can extract the field name */
8468}
References Assert, attname, attnum, CommonTableExpr::ctename, CommonTableExpr::ctequery, elog, ERROR, fb(), find_param_referent(), get_expr_result_tupdesc(), get_name_for_var_field(), get_rte_attribute_name(), get_tle_by_resno(), GetCTETargetList, INDEX_VAR, INNER_VAR, InvalidAttrNumber, IsA, lcons(), lfirst, list_copy_tail(), list_length(), list_nth(), deparse_context::namespaces, NameStr, NIL, OUTER_VAR, palloc(), pop_ancestor_plan(), pop_child_plan(), push_ancestor_plan(), push_child_plan(), rt_fetch, RTE_CTE, RTE_FUNCTION, RTE_GROUP, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, set_deparse_for_query(), snprintf, strVal, TupleDescAttr(), Var::varattno, Var::varlevelsup, and Var::varno.
Referenced by get_name_for_var_field(), and get_rule_expr().
◆ get_opclass_name()
|
static |
Definition at line 12911 of file ruleutils.c.
12913{
12917 char *nspname;
12918
12923
12926 {
12927 /* Okay, we need the opclass name. Do we need to qualify it? */
12931 else
12932 {
12935 quote_identifier(nspname),
12937 }
12938 }
12940}
References appendStringInfo(), buf, elog, ERROR, fb(), Form_pg_opclass, get_namespace_name_or_temp(), GetDefaultOpClass(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), OidIsValid, OpclassIsVisible(), quote_identifier(), ReleaseSysCache(), and SearchSysCache1().
Referenced by generate_opclass_name(), get_rule_expr(), pg_get_indexdef_worker(), and pg_get_partkeydef_worker().
◆ get_oper_expr()
|
static |
Definition at line 10782 of file ruleutils.c.
10783{
10787
10791 {
10792 /* binary operator */
10795
10798 generate_operator_name(opno,
10802 }
10803 else
10804 {
10805 /* prefix operator */
10807
10809 generate_operator_name(opno,
10810 InvalidOid,
10813 }
10816}
References appendStringInfo(), appendStringInfoChar(), arg, OpExpr::args, deparse_context::buf, buf, exprType(), fb(), generate_operator_name(), get_rule_expr_paren(), InvalidOid, linitial, list_length(), lsecond, OpExpr::opno, and PRETTY_PAREN.
Referenced by get_rule_expr().
◆ get_parameter()
|
static |
Definition at line 8711 of file ruleutils.c.
8712{
8713 Node *expr;
8716 SubPlan *subplan;
8718
8719 /*
8720 * If it's a PARAM_EXEC parameter, try to locate the expression from which
8721 * the parameter was computed. This stanza handles only cases in which
8722 * the Param represents an input to the subplan we are currently in.
8723 */
8725 if (expr)
8726 {
8727 /* Found a match, so print it */
8731
8732 /* Switch attention to the ancestor plan node */
8734
8735 /*
8736 * Force prefixing of Vars, since they won't belong to the relation
8737 * being scanned in the original plan node.
8738 */
8741
8742 /*
8743 * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
8744 * upper-level Param, which wouldn't need extra parentheses.
8745 * Otherwise, insert parens to ensure the expression looks atomic.
8746 */
8753
8755
8758
8760
8762
8763 return;
8764 }
8765
8766 /*
8767 * Alternatively, maybe it's a subplan output, which we print as a
8768 * reference to the subplan. (We could drill down into the subplan and
8769 * print the relevant targetlist expression, but that has been deemed too
8770 * confusing since it would violate normal SQL scope rules. Also, we're
8771 * relying on this reference to show that the testexpr containing the
8772 * Param has anything to do with that subplan at all.)
8773 */
8775 if (subplan)
8776 {
8778
8781 else
8783
8786 nameprefix,
8787 subplan->plan_name, column + 1);
8788
8789 return;
8790 }
8791
8792 /*
8793 * If it's an external parameter, see if the outermost namespace provides
8794 * function argument names.
8795 */
8797 {
8800 param->paramid > 0 &&
8802 {
8804
8805 if (argname)
8806 {
8809
8810 /*
8811 * Qualify the parameter name if there are any other deparse
8812 * namespaces with range tables. This avoids qualifying in
8813 * trivial cases like "RETURN a + b", but makes it safe in all
8814 * other cases.
8815 */
8817 {
8819
8821 {
8823 break;
8824 }
8825 }
8827 {
8830 }
8831
8833 return;
8834 }
8835 }
8836 }
8837
8838 /*
8839 * Not PARAM_EXEC, or couldn't find referent: just print $N.
8840 *
8841 * It's a bug if we get here for anything except PARAM_EXTERN Params, but
8842 * in production builds printing $N seems more useful than failing.
8843 */
8845
8847}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, fb(), find_param_generator(), find_param_referent(), get_rule_expr(), IsA, SubPlan::isInitPlan, lfirst, llast, deparse_context::namespaces, NIL, PARAM_EXTERN, Param::paramid, Param::paramkind, SubPlan::plan_name, pop_ancestor_plan(), push_ancestor_plan(), quote_identifier(), SubPlan::useHashTable, and deparse_context::varprefix.
Referenced by get_rule_expr().
◆ get_query_def()
|
static |
Definition at line 5628 of file ruleutils.c.
5631{
5632 deparse_context context;
5634 int rtable_size;
5635
5636 /* Guard against excessively long or deeply-nested queries */
5637 CHECK_FOR_INTERRUPTS();
5638 check_stack_depth();
5639
5640 rtable_size = query->hasGroupRTE ?
5643
5644 /*
5645 * Replace any Vars in the query's targetlist and havingQual that
5646 * reference GROUP outputs with the underlying grouping expressions.
5647 */
5648 if (query->hasGroupRTE)
5649 {
5652 query->havingQual =
5654 }
5655
5656 /*
5657 * Before we begin to examine the query, acquire locks on referenced
5658 * relations, and fix up deleted columns in JOIN RTEs. This ensures
5659 * consistent results. Note we assume it's OK to scribble on the passed
5660 * querytree!
5661 *
5662 * We are only deparsing the query (we are not about to execute it), so we
5663 * only need AccessShareLock on the relations it mentions.
5664 */
5666
5673 rtable_size != 1);
5674 context.prettyFlags = prettyFlags;
5675 context.wrapColumn = wrapColumn;
5677 context.colNamesVisible = colNamesVisible;
5681
5683
5685 {
5687 /* We set context.resultDesc only if it's a SELECT */
5688 context.resultDesc = resultDesc;
5689 get_select_query_def(query, &context);
5690 break;
5691
5693 get_update_query_def(query, &context);
5694 break;
5695
5697 get_insert_query_def(query, &context);
5698 break;
5699
5701 get_delete_query_def(query, &context);
5702 break;
5703
5705 get_merge_query_def(query, &context);
5706 break;
5707
5710 break;
5711
5713 get_utility_query_def(query, &context);
5714 break;
5715
5716 default:
5718 query->commandType);
5719 break;
5720 }
5721}
References AcquireRewriteLocks(), deparse_context::appendparents, appendStringInfoString(), deparse_context::buf, buf, CHECK_FOR_INTERRUPTS, check_stack_depth(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, deparse_context::colNamesVisible, Query::commandType, elog, ERROR, fb(), flatten_group_exprs(), get_delete_query_def(), get_insert_query_def(), get_merge_query_def(), get_select_query_def(), get_update_query_def(), get_utility_query_def(), Query::havingQual, deparse_context::indentLevel, deparse_context::inGroupBy, lcons(), list_copy(), list_length(), deparse_context::namespaces, NIL, deparse_context::prettyFlags, deparse_context::resultDesc, Query::rtable, set_deparse_for_query(), deparse_context::targetList, Query::targetList, deparse_context::varInOrderBy, deparse_context::varprefix, deparse_context::windowClause, and deparse_context::wrapColumn.
Referenced by get_from_clause_item(), get_insert_query_def(), get_setop_query(), get_sublink_expr(), get_with_clause(), make_ruledef(), make_viewdef(), pg_get_querydef(), and print_function_sqlbody().
◆ get_range_partbound_string()
Definition at line 13728 of file ruleutils.c.
13729{
13730 deparse_context context;
13732 ListCell *cell;
13734
13738
13742 {
13743 PartitionRangeDatum *datum =
13745
13751 else
13752 {
13754
13756 }
13758 }
13760
13762}
References appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, castNode, fb(), get_const_expr(), initStringInfo(), PartitionRangeDatum::kind, lfirst_node, PARTITION_RANGE_DATUM_MAXVALUE, PARTITION_RANGE_DATUM_MINVALUE, val, and PartitionRangeDatum::value.
Referenced by check_new_partition_bound(), check_partition_bounds_for_split_range(), and get_rule_expr().
◆ get_relation_name()
Definition at line 13183 of file ruleutils.c.
13184{
13186
13190}
References elog, ERROR, get_rel_name(), and relname.
Referenced by get_rte_alias(), pg_get_constraintdef_worker(), pg_get_indexdef_worker(), pg_get_partition_constraintdef(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), and pg_get_statisticsobjdef_expressions().
◆ get_reloptions()
|
static |
Definition at line 13640 of file ruleutils.c.
13641{
13645
13648
13650 {
13655
13656 /*
13657 * Each array element should have the form name=value. If the "=" is
13658 * missing for some reason, treat it like an empty value.
13659 */
13663 {
13666 }
13667 else
13669
13673
13674 /*
13675 * In general we need to quote the value; but to avoid unnecessary
13676 * clutter, do not quote if it is an identifier that would not need
13677 * quoting. (We could also allow numbers, but that is a bit trickier
13678 * than it looks --- for example, are leading zeroes significant? We
13679 * don't want to assume very much here about what custom reloptions
13680 * might mean.)
13681 */
13684 else
13686
13688 }
13689}
References appendStringInfo(), appendStringInfoString(), buf, DatumGetArrayTypeP, deconstruct_array_builtin(), fb(), i, name, noptions, pfree(), quote_identifier(), simple_quote_literal(), TextDatumGetCString, and value.
Referenced by flatten_reloptions(), and pg_get_indexdef_worker().
◆ get_returning_clause()
|
static |
Definition at line 6382 of file ruleutils.c.
6383{
6385
6387 {
6389
6392
6393 /* Add WITH (OLD/NEW) options, if they're not the defaults */
6395 {
6397 quote_identifier(query->returningOldAlias));
6399 }
6401 {
6404 quote_identifier(query->returningNewAlias));
6405 else
6406 {
6408 quote_identifier(query->returningNewAlias));
6410 }
6411 }
6414
6415 /* Add the returning expressions themselves */
6417 }
6418}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), deparse_context::buf, buf, fb(), get_target_list(), PRETTYINDENT_STD, quote_identifier(), and Query::returningList.
Referenced by get_delete_query_def(), get_insert_query_def(), get_merge_query_def(), and get_update_query_def().
◆ get_rtable_name()
|
static |
Definition at line 5137 of file ruleutils.c.
5138{
5140
5143}
References Assert, fb(), linitial, list_length(), list_nth(), and deparse_context::namespaces.
Referenced by get_from_clause_item(), get_rte_alias(), and get_select_query_def().
◆ get_rte_alias()
|
static |
Definition at line 12705 of file ruleutils.c.
12707{
12712
12714 {
12715 /* Always print alias if user provided one */
12717 }
12719 {
12720 /* Always print alias if we need to print column aliases */
12722 }
12724 {
12725 /*
12726 * No need to print alias if it's same as relation name (this would
12727 * normally be the case, but not if set_rtable_names had to resolve a
12728 * conflict).
12729 */
12732 }
12734 {
12735 /*
12736 * For a function RTE, always print alias. This covers possible
12737 * renaming of the function and/or instability of the FigureColname
12738 * rules for things that aren't simple functions. Note we'd need to
12739 * force it anyway for the columndef list case.
12740 */
12742 }
12745 {
12746 /*
12747 * For a subquery, always print alias. This makes the output
12748 * SQL-spec-compliant, even though we allow such aliases to be omitted
12749 * on input.
12750 */
12752 }
12754 {
12755 /*
12756 * No need to print alias if it's same as CTE name (this would
12757 * normally be the case, but not if set_rtable_names had to resolve a
12758 * conflict).
12759 */
12762 }
12763
12767 quote_identifier(refname));
12768}
References appendStringInfo(), deparse_context::buf, deparse_columns_fetch, fb(), get_relation_name(), get_rtable_name(), linitial, deparse_context::namespaces, quote_identifier(), RTE_CTE, RTE_FUNCTION, RTE_RELATION, RTE_SUBQUERY, and RTE_VALUES.
Referenced by get_delete_query_def(), get_from_clause_item(), get_insert_query_def(), get_merge_query_def(), and get_update_query_def().
◆ get_rule_expr()
|
static |
Definition at line 9284 of file ruleutils.c.
9286{
9288
9290 return;
9291
9292 /* Guard against excessively long or deeply-nested queries */
9293 CHECK_FOR_INTERRUPTS();
9294 check_stack_depth();
9295
9296 /*
9297 * Each level of get_rule_expr must emit an indivisible term
9298 * (parenthesized if necessary) to ensure result is reparsed into the same
9299 * expression tree. The only exception is that when the input is a List,
9300 * we emit the component items comma-separated with no surrounding
9301 * decoration; this is convenient for most callers.
9302 */
9304 {
9307 break;
9308
9311 break;
9312
9315 break;
9316
9319 break;
9320
9322 {
9324
9328 }
9329 break;
9330
9333 break;
9334
9337 break;
9338
9340 {
9343
9344 /*
9345 * If the argument is a CaseTestExpr, we must be inside a
9346 * FieldStore, ie, we are assigning to an element of an array
9347 * within a composite column. Since we already punted on
9348 * displaying the FieldStore's target information, just punt
9349 * here too, and display only the assignment source
9350 * expression.
9351 */
9353 {
9356 context, showimplicit);
9357 break;
9358 }
9359
9360 /*
9361 * Parenthesize the argument unless it's a simple Var or a
9362 * FieldSelect. (In particular, if it's another
9363 * SubscriptingRef, we *must* parenthesize to avoid
9364 * confusion.)
9365 */
9373
9374 /*
9375 * If there's a refassgnexpr, we want to print the node in the
9376 * format "container[subscripts] := refassgnexpr". This is
9377 * not legal SQL, so decompilation of INSERT or UPDATE
9378 * statements should always use processIndirection as part of
9379 * the statement-level syntax. We should only see this when
9380 * EXPLAIN tries to print the targetlist of a plan resulting
9381 * from such a statement.
9382 */
9384 {
9385 Node *refassgnexpr;
9386
9387 /*
9388 * Use processIndirection to print this node's subscripts
9389 * as well as any additional field selections or
9390 * subscripting in immediate descendants. It returns the
9391 * RHS expr that is actually being "assigned".
9392 */
9393 refassgnexpr = processIndirection(node, context);
9396 }
9397 else
9398 {
9399 /* Just an ordinary container fetch, so print subscripts */
9400 printSubscripts(sbsref, context);
9401 }
9402 }
9403 break;
9404
9407 break;
9408
9410 {
9412
9415 }
9416 break;
9417
9420 break;
9421
9423 {
9428
9436 }
9437 break;
9438
9440 {
9442
9446 }
9447 break;
9448
9450 {
9455
9465
9466 /*
9467 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
9468 * a bare sub-SELECT. Since we're here, the sub-SELECT must
9469 * be meant as a scalar sub-SELECT yielding an array value to
9470 * be used in ScalarArrayOpExpr; but the grammar will
9471 * preferentially interpret such a construct as an ANY/ALL
9472 * SubLink. To prevent misparsing the output that way, insert
9473 * a dummy coercion (which will be stripped by parse analysis,
9474 * so no inefficiency is added in dump and reload). This is
9475 * indeed most likely what the user wrote to get the construct
9476 * accepted in the first place.
9477 */
9486 }
9487 break;
9488
9490 {
9494
9496 {
9501 false, node);
9503 {
9506 false, node);
9507 }
9510 break;
9511
9516 false, node);
9518 {
9521 false, node);
9522 }
9525 break;
9526
9532 false, node);
9535 break;
9536
9537 default:
9540 }
9541 }
9542 break;
9543
9546 break;
9547
9549 {
9551
9552 /*
9553 * We cannot see an already-planned subplan in rule deparsing,
9554 * only while EXPLAINing a query plan. We don't try to
9555 * reconstruct the original SQL, just reference the subplan
9556 * that appears elsewhere in EXPLAIN's result. It does seem
9557 * useful to show the subLinkType and testexpr (if any), and
9558 * we also note whether the subplan will be hashed.
9559 */
9561 {
9565 break;
9569 break;
9573 break;
9575 /* Parenthesizing the testexpr seems sufficient */
9578 break;
9580 /* No need to decorate these subplan references */
9583 break;
9585 /* MULTIEXPR isn't executed in the normal way */
9588 break;
9592 break;
9594 /* This case is unreachable within expressions */
9597 break;
9598 }
9599
9601 {
9603
9604 /*
9605 * Push SubPlan into ancestors list while deparsing
9606 * testexpr, so that we can handle PARAM_EXEC references
9607 * to the SubPlan's paramIds. (This makes it look like
9608 * the SubPlan is an "ancestor" of the current plan node,
9609 * which is a little weird, but it does no harm.) In this
9610 * path, we don't need to mention the SubPlan explicitly,
9611 * because the referencing Params will show its existence.
9612 */
9615
9618
9620 }
9621 else
9622 {
9624
9625 /* No referencing Params, so show the SubPlan's name */
9628 else
9633 else
9636 }
9637 }
9638 break;
9639
9641 {
9644
9645 /*
9646 * This case cannot be reached in normal usage, since no
9647 * AlternativeSubPlan can appear either in parsetrees or
9648 * finished plan trees. We keep it just in case somebody
9649 * wants to use this code to print planner data structures.
9650 */
9653 {
9656
9659 else
9663 splan->plan_name);
9664 else
9666 splan->plan_name);
9669 }
9671 }
9672 break;
9673
9675 {
9679 const char *fieldname;
9681
9682 /*
9683 * Parenthesize the argument unless it's a SubscriptingRef or
9684 * another FieldSelect. Note in particular that it would be
9685 * WRONG to not parenthesize a Var argument; simplicity is not
9686 * the issue here, having the right number of names is.
9687 */
9695
9696 /*
9697 * Get and print the field name.
9698 */
9700 0, context);
9702 }
9703 break;
9704
9706 {
9709
9710 /*
9711 * There is no good way to represent a FieldStore as real SQL,
9712 * so decompilation of INSERT or UPDATE statements should
9713 * always use processIndirection as part of the
9714 * statement-level syntax. We should only get here when
9715 * EXPLAIN tries to print the targetlist of a plan resulting
9716 * from such a statement. The plan case is even harder than
9717 * ordinary rules would be, because the planner tries to
9718 * collapse multiple assignments to the same field or subfield
9719 * into one FieldStore; so we can see a list of target fields
9720 * not just one, and the arguments could be FieldStores
9721 * themselves. We don't bother to try to print the target
9722 * field names; we just print the source arguments, with a
9723 * ROW() around them if there's more than one. This isn't
9724 * terribly complete, but it's probably good enough for
9725 * EXPLAIN's purposes; especially since anything more would be
9726 * either hopelessly confusing or an even poorer
9727 * representation of what the plan is actually doing.
9728 */
9735 }
9736 break;
9737
9739 {
9742
9744 !showimplicit)
9745 {
9746 /* don't show the implicit cast */
9748 }
9749 else
9750 {
9752 relabel->resulttype,
9753 relabel->resulttypmod,
9754 node);
9755 }
9756 }
9757 break;
9758
9760 {
9763
9765 !showimplicit)
9766 {
9767 /* don't show the implicit cast */
9769 }
9770 else
9771 {
9773 iocoerce->resulttype,
9774 -1,
9775 node);
9776 }
9777 }
9778 break;
9779
9781 {
9784
9786 !showimplicit)
9787 {
9788 /* don't show the implicit cast */
9790 }
9791 else
9792 {
9794 acoerce->resulttype,
9795 acoerce->resulttypmod,
9796 node);
9797 }
9798 }
9799 break;
9800
9802 {
9805
9807 !showimplicit)
9808 {
9809 /* don't show the implicit cast */
9811 }
9812 else
9813 {
9815 convert->resulttype, -1,
9816 node);
9817 }
9818 }
9819 break;
9820
9822 {
9825
9830 generate_collation_name(collate->collOid));
9833 }
9834 break;
9835
9837 {
9840
9842 0, PRETTYINDENT_VAR, 0);
9844 {
9847 }
9849 {
9852
9854 {
9855 /*
9856 * The parser should have produced WHEN clauses of the
9857 * form "CaseTestExpr = RHS", possibly with an
9858 * implicit coercion inserted above the CaseTestExpr.
9859 * For accurate decompilation of rules it's essential
9860 * that we show just the RHS. However in an
9861 * expression that's been through the optimizer, the
9862 * WHEN clause could be almost anything (since the
9863 * equality operator could have been expanded into an
9864 * inline function). If we don't recognize the form
9865 * of the WHEN clause, just punt and display it as-is.
9866 */
9868 {
9870
9873 CaseTestExpr))
9875 }
9876 }
9877
9881 0, 0, 0);
9885 }
9889 0, 0, 0);
9894 -PRETTYINDENT_VAR, 0, 0);
9895 }
9896 break;
9897
9899 {
9900 /*
9901 * Normally we should never get here, since for expressions
9902 * that can contain this node type we attempt to avoid
9903 * recursing to it. But in an optimized expression we might
9904 * be unable to avoid that (see comments for CaseExpr). If we
9905 * do see one, print it as CASE_TEST_EXPR.
9906 */
9908 }
9909 break;
9910
9912 {
9914
9918
9919 /*
9920 * If the array isn't empty, we assume its elements are
9921 * coerced to the desired type. If it's empty, though, we
9922 * need an explicit coercion to the array type.
9923 */
9926 format_type_with_typemod(arrayexpr->array_typeid, -1));
9927 }
9928 break;
9929
9931 {
9937
9938 /*
9939 * If it's a named type and not RECORD, we may have to skip
9940 * dropped columns and/or claim there are NULLs for added
9941 * columns.
9942 */
9944 {
9945 tupdesc = lookup_rowtype_tupdesc(rowexpr->row_typeid, -1);
9947 }
9948
9949 /*
9950 * SQL99 allows "ROW" to be omitted when there is more than
9951 * one column, but for simplicity we always print it.
9952 */
9955 i = 0;
9957 {
9959
9962 {
9964 /* Whole-row Vars need special treatment here */
9967 }
9968 i++;
9969 }
9971 {
9973 {
9975 {
9979 }
9980 i++;
9981 }
9982
9983 ReleaseTupleDesc(tupdesc);
9984 }
9988 format_type_with_typemod(rowexpr->row_typeid, -1));
9989 }
9990 break;
9991
9993 {
9995
9996 /*
9997 * SQL99 allows "ROW" to be omitted when there is more than
9998 * one column, but for simplicity we always print it. Within
9999 * a ROW expression, whole-row Vars need special treatment, so
10000 * use get_rule_list_toplevel.
10001 */
10004
10005 /*
10006 * We assume that the name of the first-column operator will
10007 * do for all the rest too. This is definitely open to
10008 * failure, eg if some but not all operators were renamed
10009 * since the construct was parsed, but there seems no way to
10010 * be perfect.
10011 */
10018 }
10019 break;
10020
10022 {
10024
10028 }
10029 break;
10030
10032 {
10034
10036 {
10039 break;
10042 break;
10043 }
10046 }
10047 break;
10048
10050 {
10052
10053 /*
10054 * Note: this code knows that typmod for time, timestamp, and
10055 * timestamptz just prints as integer.
10056 */
10058 {
10061 break;
10064 break;
10067 break;
10070 break;
10073 svf->typmod);
10074 break;
10077 break;
10080 break;
10083 break;
10086 svf->typmod);
10087 break;
10090 break;
10093 break;
10096 break;
10099 break;
10102 break;
10105 break;
10106 }
10107 }
10108 break;
10109
10111 {
10116 Const *con;
10117
10119 {
10122 break;
10125 break;
10128 break;
10131 break;
10134 break;
10137 break;
10140 break;
10142 break;
10143 }
10145 {
10148 else
10150 }
10151 if (xexpr->name)
10152 {
10156 }
10158 {
10160 {
10165 }
10167 {
10170
10177 }
10180 }
10182 {
10186 {
10192 /* no extra decoration needed */
10194 break;
10197
10199 context, true);
10200
10202 Assert(!con->constisnull);
10205 " PRESERVE WHITESPACE");
10206 else
10208 " STRIP WHITESPACE");
10209 break;
10212
10214 context, true);
10215
10219 con->constisnull)
10221 else
10223
10225 if (con->constisnull)
10226 /* suppress STANDALONE NO VALUE */ ;
10227 else
10228 {
10230 {
10233 ", STANDALONE YES");
10234 break;
10237 ", STANDALONE NO");
10238 break;
10241 ", STANDALONE NO VALUE");
10242 break;
10243 default:
10244 break;
10245 }
10246 }
10247 break;
10250 break;
10251 }
10252 }
10254 {
10256 format_type_with_typemod(xexpr->type,
10257 xexpr->typmod));
10260 else
10262 }
10263
10266 else
10268 }
10269 break;
10270
10272 {
10274
10278
10279 /*
10280 * For scalar inputs, we prefer to print as IS [NOT] NULL,
10281 * which is shorter and traditional. If it's a rowtype input
10282 * but we're applying a scalar test, must print IS [NOT]
10283 * DISTINCT FROM NULL to be semantically correct.
10284 */
10287 {
10289 {
10292 break;
10295 break;
10296 default:
10299 }
10300 }
10301 else
10302 {
10304 {
10307 break;
10310 break;
10311 default:
10314 }
10315 }
10318 }
10319 break;
10320
10322 {
10324
10329 {
10332 break;
10335 break;
10338 break;
10341 break;
10344 break;
10347 break;
10348 default:
10351 }
10354 }
10355 break;
10356
10358 {
10361
10363 !showimplicit)
10364 {
10365 /* don't show the implicit cast */
10367 }
10368 else
10369 {
10371 ctest->resulttype,
10372 ctest->resulttypmod,
10373 node);
10374 }
10375 }
10376 break;
10377
10380 break;
10381
10384 break;
10385
10387 {
10389
10393 else
10395 cexpr->cursor_param);
10396 }
10397 break;
10398
10400 {
10402
10403 /*
10404 * This isn't exactly nextval(), but that seems close enough
10405 * for EXPLAIN's purposes.
10406 */
10410 NIL));
10412 }
10413 break;
10414
10416 {
10420
10421 /*
10422 * InferenceElem can only refer to target relation, so a
10423 * prefix is not useful, and indeed would cause parse errors.
10424 */
10427
10428 /*
10429 * Parenthesize the element unless it's a simple Var or a bare
10430 * function call. Follows pg_get_indexdef_worker().
10431 */
10435 COERCE_EXPLICIT_CALL)
10437
10441 context, false);
10444
10446
10450
10451 /* Add the operator class name, if not default */
10453 {
10456
10458 }
10459 }
10460 break;
10461
10463 {
10465
10466 /*
10467 * We cannot see a ReturningExpr in rule deparsing, only while
10468 * EXPLAINing a query plan (ReturningExpr nodes are only ever
10469 * adding during query rewriting). Just display the expression
10470 * returned (an expanded view column).
10471 */
10473 }
10474 break;
10475
10477 {
10479 ListCell *cell;
10481
10483 {
10485 break;
10486 }
10487
10489 {
10493
10497 break;
10498
10501
10505 {
10507
10511 }
10512
10514 break;
10515
10521
10525 break;
10526
10527 default:
10530 break;
10531 }
10532 }
10533 break;
10534
10536 {
10538
10541 }
10542 break;
10543
10546 break;
10547
10549 {
10551
10554
10556
10558
10559 /* TODO: handle FORMAT clause */
10560
10562 {
10565 break;
10568 break;
10571 break;
10572 default:
10573 break;
10574 }
10575
10578
10581 }
10582 break;
10583
10585 {
10587
10589 {
10592 break;
10595 break;
10598 break;
10599 default:
10602 }
10603
10605
10607
10609
10611 {
10613 *lc2;
10615
10617
10620 {
10624
10628 }
10629 }
10630
10635
10638 JSON_BEHAVIOR_NULL :
10639 JSON_BEHAVIOR_FALSE);
10640
10642 }
10643 break;
10644
10646 {
10648 ListCell *l;
10649
10652 {
10656 }
10657 }
10658 break;
10659
10662 break;
10663
10664 default:
10666 break;
10667 }
10668}
References ALL_SUBLINK, deparse_namespace::ancestors, AND_EXPR, ANY_SUBLINK, appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), arg, CoerceViaIO::arg, CollateExpr::arg, OpExpr::args, ScalarArrayOpExpr::args, BoolExpr::args, RowExpr::args, XmlExpr::args, ARRAY_SUBLINK, Assert, CompactAttribute::attisdropped, BoolExpr::boolop, deparse_context::buf, buf, CHECK_FOR_INTERRUPTS, check_stack_depth(), COERCE_EXPLICIT_CALL, COERCE_EXPLICIT_CAST, COERCE_IMPLICIT_CAST, CollateExpr::collOid, convert(), CTE_SUBLINK, CurrentOfExpr::cursor_name, CurrentOfExpr::cursor_param, DatumGetBool(), DatumGetInt32(), elog, ERROR, EXISTS_SUBLINK, JsonIsPredicate::expr, EXPR_SUBLINK, exprType(), exprTypmod(), fb(), for_each_from, forboth, format_type_with_typemod(), generate_collation_name(), generate_operator_name(), generate_relation_name(), get_agg_expr(), get_base_element_type(), get_coercion_expr(), get_const_expr(), get_func_expr(), get_json_constructor(), get_json_expr_options(), get_json_format(), get_json_path_spec(), get_json_returning(), get_name_for_var_field(), get_opclass_input_type(), get_opclass_name(), get_oper_expr(), get_parameter(), get_range_partbound_string(), get_rule_expr(), get_rule_expr_paren(), get_rule_expr_toplevel(), get_rule_list_toplevel(), get_sublink_expr(), get_tablefunc(), get_variable(), get_windowfunc_expr(), i, XmlExpr::indent, IS_DOCUMENT, IS_FALSE, IS_GREATEST, IS_LEAST, IS_NOT_FALSE, IS_NOT_NULL, IS_NOT_TRUE, IS_NOT_UNKNOWN, IS_NULL, IS_TRUE, IS_UNKNOWN, IS_XMLCONCAT, IS_XMLELEMENT, IS_XMLFOREST, IS_XMLPARSE, IS_XMLPI, IS_XMLROOT, IS_XMLSERIALIZE, IsA, SubPlan::isInitPlan, JsonIsPredicate::item_type, JS_TYPE_ARRAY, JS_TYPE_OBJECT, JS_TYPE_SCALAR, JSON_BEHAVIOR_FALSE, JSON_BEHAVIOR_NULL, JSON_EXISTS_OP, JSON_QUERY_OP, JSON_VALUE_OP, lcons(), lfirst, lfirst_node, linitial, linitial_oid, list_delete_first(), list_length(), lnext(), lookup_rowtype_tupdesc(), lsecond, lsecond_node, lthird_node, map_xml_name_to_sql_identifier(), MULTIEXPR_SUBLINK, XmlExpr::named_args, deparse_context::namespaces, TupleDescData::natts, FieldStore::newvals, NIL, nodeTag, NOT_EXPR, SQLValueFunction::op, XmlExpr::op, ScalarArrayOpExpr::opno, OR_EXPR, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, SubPlan::plan_name, PRETTY_INDENT, PRETTY_PAREN, PRETTYINDENT_VAR, printSubscripts(), processIndirection(), quote_identifier(), SubscriptingRef::refassgnexpr, SubscriptingRef::refexpr, ReleaseTupleDesc, CoerceViaIO::resulttype, ROWCOMPARE_SUBLINK, simple_quote_literal(), strip_implicit_coercions(), strVal, SubPlan::subLinkType, SVFOP_CURRENT_CATALOG, SVFOP_CURRENT_DATE, SVFOP_CURRENT_ROLE, SVFOP_CURRENT_SCHEMA, SVFOP_CURRENT_TIME, SVFOP_CURRENT_TIME_N, SVFOP_CURRENT_TIMESTAMP, SVFOP_CURRENT_TIMESTAMP_N, SVFOP_CURRENT_USER, SVFOP_LOCALTIME, SVFOP_LOCALTIME_N, SVFOP_LOCALTIMESTAMP, SVFOP_LOCALTIMESTAMP_N, SVFOP_SESSION_USER, SVFOP_USER, SubPlan::testexpr, TupleDescCompactAttr(), type_is_rowtype(), SQLValueFunction::typmod, JsonIsPredicate::unique_keys, SubPlan::useHashTable, ScalarArrayOpExpr::useOr, val, deparse_context::varprefix, XML_STANDALONE_NO, XML_STANDALONE_NO_VALUE, XML_STANDALONE_YES, and XMLOPTION_DOCUMENT.
Referenced by deparse_expression_pretty(), get_agg_expr_helper(), get_basic_select_query(), get_delete_query_def(), get_from_clause_item(), get_func_expr(), get_func_sql_syntax(), get_insert_query_def(), get_json_behavior(), get_json_constructor(), get_json_path_spec(), get_json_table(), get_merge_query_def(), get_parameter(), get_rule_expr(), get_rule_expr_funccall(), get_rule_expr_paren(), get_rule_expr_toplevel(), get_rule_sortgroupclause(), get_select_query_def(), get_special_variable(), get_sublink_expr(), get_tablesample_def(), get_target_list(), get_update_query_def(), get_update_query_targetlist_def(), get_variable(), get_window_frame_options(), get_windowfunc_expr_helper(), get_with_clause(), get_xmltable(), make_ruledef(), pg_get_triggerdef_worker(), and printSubscripts().
◆ get_rule_expr_funccall()
|
static |
Definition at line 10730 of file ruleutils.c.
10732{
10735 else
10736 {
10738
10740 /* no point in showing any top-level implicit cast */
10744 exprTypmod(node)));
10745 }
10746}
References appendStringInfo(), appendStringInfoString(), deparse_context::buf, buf, exprType(), exprTypmod(), fb(), format_type_with_typemod(), get_rule_expr(), and looks_like_function().
Referenced by get_from_clause_item().
◆ get_rule_expr_paren()
|
static |
Definition at line 9187 of file ruleutils.c.
9189{
9191
9194
9197
9199
9202}
References appendStringInfoChar(), deparse_context::buf, fb(), get_rule_expr(), isSimpleNode(), PRETTY_PAREN, and deparse_context::prettyFlags.
Referenced by get_coercion_expr(), get_func_expr(), get_func_sql_syntax(), get_oper_expr(), and get_rule_expr().
◆ get_rule_expr_toplevel()
|
static |
Definition at line 10682 of file ruleutils.c.
10684{
10687 else
10689}
References fb(), get_rule_expr(), get_variable(), and IsA.
Referenced by get_rule_expr(), get_rule_list_toplevel(), and get_values_def().
◆ get_rule_groupingset()
|
static |
Definition at line 6638 of file ruleutils.c.
6640{
6641 ListCell *l;
6645
6647 {
6650 return;
6651
6653 {
6656
6658 {
6660
6663 false, context);
6665 }
6666
6669 }
6670 return;
6671
6674 break;
6677 break;
6681 break;
6682 }
6683
6685 {
6689 }
6690
6692}
References appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, fb(), get_rule_groupingset(), get_rule_sortgroupclause(), GROUPING_SET_CUBE, GROUPING_SET_EMPTY, GROUPING_SET_ROLLUP, GROUPING_SET_SETS, GROUPING_SET_SIMPLE, lfirst, lfirst_int, and list_length().
Referenced by get_basic_select_query(), and get_rule_groupingset().
◆ get_rule_list_toplevel()
|
static |
Definition at line 10700 of file ruleutils.c.
10702{
10705
10708 {
10710
10714 }
10715}
References appendStringInfoString(), deparse_context::buf, fb(), get_rule_expr_toplevel(), and lfirst.
Referenced by get_insert_query_def(), get_merge_query_def(), and get_rule_expr().
◆ get_rule_orderby()
|
static |
Definition at line 6698 of file ruleutils.c.
6700{
6703 ListCell *l;
6704
6707 {
6711 TypeCacheEntry *typentry;
6712
6715 force_colno, context);
6717 /* See whether operator is default < or > for datatype */
6721 {
6722 /* ASC is default, so emit nothing for it */
6725 }
6727 {
6729 /* DESC defaults to NULLS FIRST */
6732 }
6733 else
6734 {
6737 sortcoltype,
6738 sortcoltype));
6739 /* be specific to eliminate ambiguity */
6742 else
6744 }
6746 }
6747}
References appendStringInfo(), appendStringInfoString(), deparse_context::buf, buf, exprType(), fb(), generate_operator_name(), get_rule_sortgroupclause(), TypeCacheEntry::gt_opr, lfirst, lookup_type_cache(), TypeCacheEntry::lt_opr, TYPECACHE_GT_OPR, and TYPECACHE_LT_OPR.
Referenced by get_agg_expr_helper(), get_rule_windowspec(), and get_select_query_def().
◆ get_rule_sortgroupclause()
|
static |
Definition at line 6569 of file ruleutils.c.
6571{
6574 Node *expr;
6575
6578
6579 /*
6580 * Use column-number form if requested by caller. Otherwise, if
6581 * expression is a constant, force it to be dumped with an explicit cast
6582 * as decoration --- this is because a simple integer constant is
6583 * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
6584 * we dump it without any decoration. Similarly, if it's just a Var,
6585 * there is risk of misinterpretation if the column name is reassigned in
6586 * the SELECT list, so we may need to force table qualification. And, if
6587 * it's anything more complex than a simple Var, then force extra parens
6588 * around it, to ensure it can't be misinterpreted as a cube() or rollup()
6589 * construct.
6590 */
6592 {
6595 }
6596 else if (!expr)
6597 /* do nothing, probably can't happen */ ;
6601 {
6602 /* Tell get_variable to check for name conflict */
6604
6608 }
6609 else
6610 {
6611 /*
6612 * We must force parens for function-like expressions even if
6613 * PRETTY_PAREN is off, since those are the ones in danger of
6614 * misparsing. For other expressions we need to force them only if
6615 * PRETTY_PAREN is on, since otherwise the expression will output them
6616 * itself. (We can't skip the parens.)
6617 */
6623
6629 }
6630
6631 return expr;
6632}
References appendStringInfo(), appendStringInfoChar(), Assert, deparse_context::buf, buf, fb(), get_const_expr(), get_rule_expr(), get_sortgroupref_tle(), get_variable(), IsA, PRETTY_PAREN, and deparse_context::varInOrderBy.
Referenced by get_basic_select_query(), get_rule_groupingset(), get_rule_orderby(), and get_rule_windowspec().
◆ get_rule_windowclause()
|
static |
Definition at line 6756 of file ruleutils.c.
6757{
6760 ListCell *l;
6761
6764 {
6766
6768 continue; /* ignore anonymous windows */
6769
6773 else
6775
6777
6779
6781 }
6782}
References appendContextKeyword(), appendStringInfo(), appendStringInfoString(), deparse_context::buf, buf, fb(), get_rule_windowspec(), lfirst, PRETTYINDENT_STD, quote_identifier(), Query::targetList, and Query::windowClause.
Referenced by get_basic_select_query().
◆ get_rule_windowspec()
|
static |
Definition at line 6788 of file ruleutils.c.
6790{
6794 ListCell *l;
6795
6797 if (wc->refname)
6798 {
6801 }
6802 /* partition clauses are always inherited, so only print if no refname */
6804 {
6810 {
6812
6815 false, context);
6817 }
6819 }
6820 /* print ordering clause only if not inherited */
6822 {
6828 }
6829 /* framing clause is never inherited, so print unless it's default */
6831 {
6836 context);
6837 }
6839}
References appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, WindowClause::endOffset, fb(), FRAMEOPTION_NONDEFAULT, WindowClause::frameOptions, get_rule_orderby(), get_rule_sortgroupclause(), get_window_frame_options(), lfirst, WindowClause::orderClause, WindowClause::partitionClause, quote_identifier(), and WindowClause::startOffset.
Referenced by get_rule_windowclause(), and get_windowfunc_expr_helper().
◆ get_select_query_def()
|
static |
Definition at line 5910 of file ruleutils.c.
5911{
5914 ListCell *l;
5915
5916 /* Insert the WITH clause if given */
5917 get_with_clause(query, context);
5918
5919 /* Subroutines may need to consult the SELECT targetlist and windowClause */
5922
5923 /*
5924 * If the Query node has a setOperations tree, then it's the top level of
5925 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
5926 * fields are interesting in the top query itself.
5927 */
5929 {
5931 /* ORDER BY clauses must be simple in this case */
5933 }
5934 else
5935 {
5936 get_basic_select_query(query, context);
5938 }
5939
5940 /* Add the ORDER BY clause if given */
5942 {
5946 force_colno, context);
5947 }
5948
5949 /*
5950 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
5951 * standard spelling of LIMIT.
5952 */
5954 {
5958 }
5960 {
5962 {
5963 /*
5964 * The limitCount arg is a c_expr, so it needs parens. Simple
5965 * literals and function expressions would not need parens, but
5966 * unfortunately it's hard to tell if the expression will be
5967 * printed as a simple literal like 123 or as a typecast
5968 * expression, like '-123'::int4. The grammar accepts the former
5969 * without quoting, but not the latter.
5970 */
5977 }
5978 else
5979 {
5985 else
5987 }
5988 }
5989
5990 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
5991 if (query->hasForUpdate)
5992 {
5994 {
5996
5997 /* don't print implicit clauses */
5999 continue;
6000
6001 appendContextKeyword(context,
6004
6007 context)));
6012 }
6013 }
6014}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, fb(), get_basic_select_query(), get_lock_clause_strength(), get_rtable_name(), get_rule_expr(), get_rule_orderby(), get_setop_query(), get_with_clause(), IsA, lfirst, LIMIT_OPTION_WITH_TIES, Query::limitCount, Query::limitOffset, Query::limitOption, LockWaitError, LockWaitSkip, NIL, PRETTYINDENT_STD, RowMarkClause::pushedDown, quote_identifier(), Query::rowMarks, RowMarkClause::rti, Query::setOperations, Query::sortClause, RowMarkClause::strength, deparse_context::targetList, Query::targetList, RowMarkClause::waitPolicy, deparse_context::windowClause, and Query::windowClause.
Referenced by get_query_def().
◆ get_setop_query()
|
static |
Definition at line 6421 of file ruleutils.c.
6422{
6425
6426 /* Guard against excessively long or deeply-nested queries */
6427 CHECK_FOR_INTERRUPTS();
6428 check_stack_depth();
6429
6431 {
6435
6437
6438 /*
6439 * We need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y.
6440 * Also add parens if the leaf query contains its own set operations.
6441 * (That shouldn't happen unless one of the other clauses is also
6442 * present, see transformSetOperationTree; but let's be safe.)
6443 */
6445 subquery->sortClause ||
6446 subquery->rowMarks ||
6447 subquery->limitOffset ||
6448 subquery->limitCount ||
6449 subquery->setOperations);
6455 context->indentLevel);
6458 }
6460 {
6464
6465 /*
6466 * We force parens when nesting two SetOperationStmts, except when the
6467 * lefthand input is another setop of the same kind. Syntactically,
6468 * we could omit parens in rather more cases, but it seems best to use
6469 * parens to flag cases where the setop operator changes. If we use
6470 * parens, we also increase the indentation level for the child query.
6471 *
6472 * There are some cases in which parens are needed around a leaf query
6473 * too, but those are more easily handled at the next level down (see
6474 * code above).
6475 */
6477 {
6479
6482 else
6484 }
6485 else
6487
6489 {
6493 }
6494 else
6495 subindent = 0;
6496
6498
6503 else
6505
6507 {
6510 break;
6513 break;
6516 break;
6517 default:
6520 }
6523
6524 /* Always parenthesize if RHS is another setop */
6526
6527 /*
6528 * The indentation code here is deliberately a bit different from that
6529 * for the lefthand input, because we want the line breaks in
6530 * different places.
6531 */
6533 {
6536 }
6537 else
6538 subindent = 0;
6540
6541 /*
6542 * The output column names of the RHS sub-select don't matter.
6543 */
6546
6548
6550
6555 }
6556 else
6557 {
6560 }
6561}
References SetOperationStmt::all, appendContextKeyword(), appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, CHECK_FOR_INTERRUPTS, check_stack_depth(), deparse_context::colNamesVisible, Query::cteList, elog, ERROR, fb(), get_query_def(), get_setop_query(), deparse_context::indentLevel, IsA, SetOperationStmt::larg, Query::limitCount, Query::limitOffset, deparse_context::namespaces, nodeTag, SetOperationStmt::op, PRETTY_INDENT, deparse_context::prettyFlags, PRETTYINDENT_STD, SetOperationStmt::rarg, deparse_context::resultDesc, Query::rowMarks, rt_fetch, Query::rtable, SETOP_EXCEPT, SETOP_INTERSECT, SETOP_UNION, Query::setOperations, Query::sortClause, and deparse_context::wrapColumn.
Referenced by get_select_query_def(), and get_setop_query().
◆ get_simple_binary_op_name()
Definition at line 8856 of file ruleutils.c.
8857{
8859
8861 {
8862 /* binary operator */
8865 const char *op;
8866
8869 return op;
8870 }
8872}
References OpExpr::args, exprType(), fb(), generate_operator_name(), linitial, list_length(), lsecond, and OpExpr::opno.
Referenced by isSimpleNode().
◆ get_simple_values_rte()
|
static |
Definition at line 6044 of file ruleutils.c.
6045{
6048
6049 /*
6050 * We want to detect a match even if the Query also contains OLD or NEW
6051 * rule RTEs. So the idea is to scan the rtable and see if there is only
6052 * one inFromCl RTE that is a VALUES RTE.
6053 */
6055 {
6057
6059 {
6060 if (result)
6062 result = rte;
6063 }
6065 continue; /* ignore rule entries */
6066 else
6068 }
6069
6070 /*
6071 * We don't need to check the targetlist in any great detail, because
6072 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6073 * appear inside auto-generated sub-queries with very restricted
6074 * structure. However, DefineView might have modified the tlist by
6075 * injecting new column aliases, or we might have some other column
6076 * aliases forced by a resultDesc. We can only simplify if the RTE's
6077 * column names match the names that get_target_list() would select.
6078 */
6079 if (result)
6080 {
6082 int colno;
6083
6086 colno = 0;
6088 {
6091 char *colname;
6092
6095
6096 /* compute name that get_target_list would use for column */
6097 colno++;
6100 else
6101 colname = tle->resname;
6102
6103 /* does it match the VALUES RTE? */
6106 }
6107 }
6108
6109 return result;
6110}
References attname, fb(), forboth, lfirst, list_length(), NameStr, Query::rtable, RTE_RELATION, RTE_VALUES, strVal, Query::targetList, and TupleDescAttr().
Referenced by get_basic_select_query().
◆ get_special_variable()
|
static |
Definition at line 7912 of file ruleutils.c.
7913{
7915
7916 /*
7917 * For a non-Var referent, force parentheses because our caller probably
7918 * assumed a Var is a simple expression.
7919 */
7925}
References appendStringInfoChar(), deparse_context::buf, buf, get_rule_expr(), and IsA.
Referenced by get_variable().
◆ get_sublink_expr()
|
static |
Definition at line 11870 of file ruleutils.c.
11871{
11876
11879 else
11881
11882 /*
11883 * Note that we print the name of only the first operator, when there are
11884 * multiple combining operators. This is an approximation that could go
11885 * wrong in various scenarios (operators in different schemas, renamed
11886 * operators, etc) but there is not a whole lot we can do about it, since
11887 * the syntax allows only one operator to be shown.
11888 */
11890 {
11892 {
11893 /* single combining operator */
11895
11900 }
11902 {
11903 /* multiple combining operators, = or <> cases */
11905 ListCell *l;
11906
11910 {
11912
11920 }
11922 }
11924 {
11925 /* multiple combining operators, < <= > >= cases */
11927
11934 }
11935 else
11938 }
11939
11941
11943 {
11946 break;
11947
11951 else
11953 break;
11954
11957 break;
11958
11961 break;
11962
11967 break;
11968
11970 default:
11973 break;
11974 }
11975
11978
11981 context->indentLevel);
11982
11985 else
11987}
References ALL_SUBLINK, ANY_SUBLINK, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), OpExpr::args, ARRAY_SUBLINK, deparse_context::buf, buf, CTE_SUBLINK, elog, ERROR, EXISTS_SUBLINK, EXPR_SUBLINK, exprType(), fb(), generate_operator_name(), get_query_def(), get_rule_expr(), deparse_context::indentLevel, IsA, lfirst_node, linitial, linitial_oid, lsecond, MULTIEXPR_SUBLINK, deparse_context::namespaces, nodeTag, OpExpr::opno, deparse_context::prettyFlags, ROWCOMPARE_SUBLINK, and deparse_context::wrapColumn.
Referenced by get_rule_expr().
◆ get_tablefunc()
|
static |
Definition at line 12301 of file ruleutils.c.
12302{
12303 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12304
12309}
References fb(), TableFunc::functype, get_json_table(), get_xmltable(), TFT_JSON_TABLE, and TFT_XMLTABLE.
Referenced by get_from_clause_item(), and get_rule_expr().
◆ get_tablesample_def()
|
static |
Definition at line 12867 of file ruleutils.c.
12868{
12870 Oid argtypes[1];
12871 int nargs;
12872 ListCell *l;
12873
12874 /*
12875 * We should qualify the handler's function name if it wouldn't be
12876 * resolved by lookup in the current search path.
12877 */
12878 argtypes[0] = INTERNALOID;
12881 NIL, argtypes,
12883
12884 nargs = 0;
12886 {
12887 if (nargs++ > 0)
12890 }
12892
12894 {
12898 }
12899}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), TableSampleClause::args, deparse_context::buf, buf, fb(), generate_function_name(), get_rule_expr(), lfirst, NIL, TableSampleClause::repeatable, and TableSampleClause::tsmhandler.
Referenced by get_from_clause_item().
◆ get_target_list()
|
static |
Definition at line 6246 of file ruleutils.c.
6247{
6252 int colno;
6253 ListCell *l;
6254
6255 /* we use targetbuf to hold each TLE's text temporarily */
6257
6259 colno = 0;
6260 foreach(l, targetList)
6261 {
6263 char *colname;
6265
6267 continue; /* ignore junk entries */
6268
6271 colno++;
6272
6273 /*
6274 * Put the new field text into targetbuf so we can decide after we've
6275 * got it whether or not it needs to go on a new line.
6276 */
6279
6280 /*
6281 * We special-case Var nodes rather than using get_rule_expr. This is
6282 * needed because get_rule_expr will display a whole-row Var as
6283 * "foo.*", which is the preferred notation in most contexts, but at
6284 * the top level of a SELECT list it's not right (the parser will
6285 * expand that notation into multiple columns, yielding behavior
6286 * different from a whole-row Var). We need to call get_variable
6287 * directly so that we can tell it to do the right thing, and so that
6288 * we can get the attribute name which is the default AS label.
6289 */
6291 {
6293 }
6294 else
6295 {
6297
6298 /*
6299 * When colNamesVisible is true, we should always show the
6300 * assigned column name explicitly. Otherwise, show it only if
6301 * it's not FigureColname's fallback.
6302 */
6304 }
6305
6306 /*
6307 * Figure out what the result column should be called. In the context
6308 * of a view, use the view's tuple descriptor (so as to pick up the
6309 * effects of any column RENAME that's been done on the view).
6310 * Otherwise, just use what we can find in the TLE.
6311 */
6314 colno - 1)->attname);
6315 else
6316 colname = tle->resname;
6317
6318 /* Show AS unless the column's name is correct as-is */
6319 if (colname) /* resname could be NULL */
6320 {
6323 }
6324
6325 /* Restore context's output buffer */
6327
6328 /* Consider line-wrapping if enabled */
6330 {
6332
6333 /* Does the new field start with a new line? */
6335 leading_nl_pos = 0;
6336 else
6337 leading_nl_pos = -1;
6338
6339 /* If so, we shouldn't add anything */
6341 {
6342 /* instead, remove any trailing spaces currently in buf */
6344 }
6345 else
6346 {
6348
6349 /* Locate the start of the current line in the output buffer */
6353 else
6354 trailing_nl++;
6355
6356 /*
6357 * Add a newline, plus some indentation, if the new field is
6358 * not the first and either the new field would cause an
6359 * overflow or the last field used more than one line.
6360 */
6361 if (colno > 1 &&
6363 last_was_multiline))
6366 }
6367
6368 /* Remember this field's multiline status for next iteration */
6369 last_was_multiline =
6371 }
6372
6373 /* Add the new field */
6375 }
6376
6377 /* clean up */
6379}
References appendBinaryStringInfo(), appendContextKeyword(), appendStringInfo(), appendStringInfoString(), attname, deparse_context::buf, buf, deparse_context::colNamesVisible, fb(), get_rule_expr(), get_variable(), initStringInfo(), IsA, lfirst, NameStr, TupleDescData::natts, pfree(), PRETTY_INDENT, PRETTYINDENT_STD, PRETTYINDENT_VAR, quote_identifier(), removeStringInfoSpaces(), resetStringInfo(), deparse_context::resultDesc, TupleDescAttr(), and deparse_context::wrapColumn.
Referenced by get_basic_select_query(), and get_returning_clause().
◆ get_update_query_def()
|
static |
Definition at line 7175 of file ruleutils.c.
7176{
7179
7180 /* Insert the WITH clause if given */
7181 get_with_clause(query, context);
7182
7183 /*
7184 * Start the query with UPDATE relname SET
7185 */
7189 {
7192 }
7196
7197 /* Print the relation alias, if needed */
7199
7201
7202 /* Deparse targetlist */
7204
7205 /* Add the FROM clause if needed */
7207
7208 /* Add a WHERE clause if given */
7210 {
7214 }
7215
7216 /* Add RETURNING if present */
7218 get_returning_clause(query, context);
7219}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, fb(), generate_relation_name(), get_from_clause(), get_returning_clause(), get_rte_alias(), get_rule_expr(), get_update_query_targetlist_def(), get_with_clause(), deparse_context::indentLevel, Query::jointree, NIL, only_marker, PRETTY_INDENT, PRETTYINDENT_STD, FromExpr::quals, Query::returningList, rt_fetch, Query::rtable, RTE_RELATION, and Query::targetList.
Referenced by get_query_def().
◆ get_update_query_targetlist_def()
|
static |
Definition at line 7227 of file ruleutils.c.
7229{
7231 ListCell *l;
7237
7238 /*
7239 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
7240 * into a list. We expect them to appear, in ID order, in resjunk tlist
7241 * entries.
7242 */
7244 if (query->hasSubLinks) /* else there can't be any */
7245 {
7246 foreach(l, targetList)
7247 {
7249
7251 {
7253
7255 {
7258 }
7259 }
7260 }
7261 }
7264 remaining_ma_columns = 0;
7265
7266 /* Add the comma separated list of 'attname = value' */
7268 foreach(l, targetList)
7269 {
7271 Node *expr;
7272
7274 continue; /* ignore junk entries */
7275
7276 /* Emit separator (OK whether we're in multiassignment or not) */
7279
7280 /*
7281 * Check to see if we're starting a multiassignment group: if so,
7282 * output a left paren.
7283 */
7285 {
7286 /*
7287 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
7288 * Param. That could be buried under FieldStores and
7289 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
7290 * and underneath those there could be an implicit type coercion.
7291 * Because we would ignore implicit type coercions anyway, we
7292 * don't need to be as careful as processIndirection() is about
7293 * descending past implicit CoerceToDomains.
7294 */
7296 while (expr)
7297 {
7299 {
7301
7303 }
7305 {
7307
7309 break;
7310
7312 }
7314 {
7316
7318 break;
7320 }
7321 else
7322 break;
7323 }
7324 expr = strip_implicit_coercions(expr);
7325
7328 {
7331 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
7333 ((cur_ma_sublink->subLinkId << 16) | 1));
7335 }
7336 }
7337
7338 /*
7339 * Put out name of target column; look in the catalogs, not at
7340 * tle->resname, since resname will fail to track RENAME.
7341 */
7344 tle->resno,
7345 false)));
7346
7347 /*
7348 * Print any indirection needed (subfields or subscripts), and strip
7349 * off the top-level nodes representing the indirection assignments.
7350 */
7352
7353 /*
7354 * If we're in a multiassignment, skip printing anything more, unless
7355 * this is the last column; in which case, what we print should be the
7356 * sublink, not the Param.
7357 */
7359 {
7361 continue; /* not the last column of multiassignment */
7365 }
7366
7368
7370 }
7371}
References appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, COERCE_IMPLICIT_CAST, count_nonjunk_tlist_entries(), fb(), get_attname(), get_rule_expr(), IsA, lappend(), lfirst, linitial, list_head(), list_length(), lnext(), MULTIEXPR_SUBLINK, FieldStore::newvals, NIL, PARAM_MULTIEXPR, processIndirection(), quote_identifier(), SubscriptingRef::refassgnexpr, and strip_implicit_coercions().
Referenced by get_insert_query_def(), get_merge_query_def(), and get_update_query_def().
◆ get_utility_query_def()
|
static |
Definition at line 7585 of file ruleutils.c.
7586{
7588
7590 {
7592
7594 0, PRETTYINDENT_STD, 1);
7598 {
7601 }
7602 }
7603 else
7604 {
7605 /* Currently only NOTIFY utility commands can appear in rules */
7607 }
7608}
References appendContextKeyword(), appendStringInfo(), appendStringInfoString(), deparse_context::buf, buf, elog, ERROR, IsA, PRETTYINDENT_STD, quote_identifier(), simple_quote_literal(), stmt, and Query::utilityStmt.
Referenced by get_query_def().
◆ get_values_def()
|
static |
Definition at line 5728 of file ruleutils.c.
5729{
5733
5735
5737 {
5741
5744 else
5746
5749 {
5751
5754 else
5756
5757 /*
5758 * Print the value. Whole-row Vars need special treatment.
5759 */
5761 }
5763 }
5764}
References appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, fb(), get_rule_expr_toplevel(), and lfirst.
Referenced by get_basic_select_query(), get_from_clause_item(), and get_insert_query_def().
◆ get_variable()
|
static |
Definition at line 7630 of file ruleutils.c.
7631{
7637 int varno;
7638 AttrNumber varattno;
7640 char *refname;
7643
7644 /* Find appropriate nesting depth */
7648 var->varlevelsup, levelsup);
7650 netlevelsup);
7651
7652 /*
7653 * If we have a syntactic referent for the Var, and we're working from a
7654 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7655 * on the semantic referent. (Forcing use of the semantic referent when
7656 * printing plan trees is a design choice that's perhaps more motivated by
7657 * backwards compatibility than anything else. But it does have the
7658 * advantage of making plans more explicit.)
7659 */
7661 {
7662 varno = var->varnosyn;
7663 varattno = var->varattnosyn;
7664 }
7665 else
7666 {
7667 varno = var->varno;
7668 varattno = var->varattno;
7669 }
7670
7671 /*
7672 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7673 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7674 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
7675 * find the aliases previously assigned for this RTE.
7676 */
7678 {
7679 /*
7680 * We might have been asked to map child Vars to some parent relation.
7681 */
7683 {
7687 bool found = false;
7688
7689 /* Only map up to inheritance parents, not UNION ALL appendrels */
7693 {
7694 found = false;
7696 {
7698 break; /* safety check */
7701 break; /* Var is local to child */
7702 }
7703
7705 found = true;
7706
7707 /* If the parent is itself a child, continue up. */
7710 }
7711
7712 /*
7713 * If we found an ancestral rel, and that rel is included in
7714 * appendparents, print that column not the original one.
7715 */
7717 {
7718 varno = pvarno;
7719 varattno = pvarattno;
7720 }
7721 }
7722
7724
7725 /* might be returning old/new column value */
7727 refname = dpns->ret_old_alias;
7729 refname = dpns->ret_new_alias;
7730 else
7732
7734 attnum = varattno;
7735 }
7736 else
7737 {
7741 }
7742
7743 /*
7744 * The planner will sometimes emit Vars referencing resjunk elements of a
7745 * subquery's target list (this is currently only possible if it chooses
7746 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
7747 * Although we prefer to print subquery-referencing Vars using the
7748 * subquery's alias, that's not possible for resjunk items since they have
7749 * no alias. So in that case, drill down to the subplan and print the
7750 * contents of the referenced tlist item. This works because in a plan
7751 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
7752 * we'll have set dpns->inner_plan to reference the child plan node.
7753 */
7756 dpns->inner_plan)
7757 {
7760
7765
7768
7769 /*
7770 * Force parentheses because our caller probably assumed a Var is a
7771 * simple expression.
7772 */
7778
7781 }
7782
7783 /*
7784 * If it's an unnamed join, look at the expansion of the alias variable.
7785 * If it's a simple reference to one of the input vars, then recursively
7786 * print the name of that var instead. When it's not a simple reference,
7787 * we have to just print the unqualified join column name. (This can only
7788 * happen with "dangerous" merged columns in a JOIN USING; we took pains
7789 * previously to make the unqualified column name unique in such cases.)
7790 *
7791 * This wouldn't work in decompiling plan trees, because we don't store
7792 * joinaliasvars lists after planning; but a plan tree should never
7793 * contain a join alias variable.
7794 */
7796 {
7800 {
7802
7804 /* we intentionally don't strip implicit coercions here */
7806 {
7808 istoplevel, context);
7809 }
7810 }
7811
7812 /*
7813 * Unnamed join has no refname. (Note: since it's unnamed, there is
7814 * no way the user could have referenced it to create a whole-row Var
7815 * for it. So we don't have to cover that case below.)
7816 */
7818 }
7819
7823 {
7824 /* Get column name to use from the colinfo struct */
7829
7830 /*
7831 * If we find a Var referencing a dropped column, it seems better to
7832 * print something (anything) than to fail. In general this should
7833 * not happen, but it used to be possible for some cases involving
7834 * functions returning named composite types, and perhaps there are
7835 * still bugs out there.
7836 */
7839 }
7840 else
7841 {
7842 /* System column - name is fixed, get it from the catalog */
7844 }
7845
7848
7849 /*
7850 * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
7851 * clause, we may need to add a table-name prefix to prevent
7852 * findTargetlistEntrySQL92 from misinterpreting the name as an
7853 * output-column name. To avoid cluttering the output with unnecessary
7854 * prefixes, do so only if there is a name match to a SELECT tlist item
7855 * that is different from the Var.
7856 */
7858 {
7859 int colno = 0;
7860
7862 {
7863 char *colname;
7864
7866 continue; /* ignore junk entries */
7867 colno++;
7868
7869 /* This must match colname-choosing logic in get_target_list() */
7872 colno - 1)->attname);
7873 else
7874 colname = tle->resname;
7875
7878 {
7880 break;
7881 }
7882 }
7883 }
7884
7886 {
7889 }
7892 else
7893 {
7897 format_type_with_typemod(var->vartype,
7898 var->vartypmod));
7899 }
7900
7902}
References deparse_context::appendparents, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attname, attnum, bms_is_member(), deparse_context::buf, buf, deparse_columns_fetch, elog, equal(), ERROR, fb(), foreach_node, format_type_with_typemod(), get_rte_attribute_name(), get_rule_expr(), get_special_variable(), get_tle_by_resno(), get_variable(), deparse_context::inGroupBy, InvalidAttrNumber, IsA, list_length(), list_nth(), deparse_context::namespaces, NameStr, TupleDescData::natts, NIL, AppendRelInfo::parent_relid, pop_child_plan(), push_child_plan(), quote_identifier(), resolve_special_varno(), deparse_context::resultDesc, rt_fetch, RTE_CTE, RTE_JOIN, RTE_RELATION, RTE_SUBQUERY, deparse_context::targetList, TupleDescAttr(), VAR_RETURNING_DEFAULT, VAR_RETURNING_NEW, VAR_RETURNING_OLD, Var::varattno, deparse_context::varInOrderBy, Var::varlevelsup, Var::varno, deparse_context::varprefix, and Var::varreturningtype.
Referenced by get_rule_expr(), get_rule_expr_toplevel(), get_rule_sortgroupclause(), get_target_list(), and get_variable().
◆ get_window_frame_options()
|
static |
Definition at line 6845 of file ruleutils.c.
6848{
6850
6852 {
6859 else
6868 {
6874 else
6876 }
6877 else
6880 {
6887 {
6893 else
6895 }
6896 else
6898 }
6905 /* we will now have a trailing space; remove it */
6907 }
6908}
References appendStringInfoString(), Assert, deparse_context::buf, buf, FRAMEOPTION_BETWEEN, FRAMEOPTION_END_CURRENT_ROW, FRAMEOPTION_END_OFFSET, FRAMEOPTION_END_OFFSET_FOLLOWING, FRAMEOPTION_END_OFFSET_PRECEDING, FRAMEOPTION_END_UNBOUNDED_FOLLOWING, FRAMEOPTION_EXCLUDE_CURRENT_ROW, FRAMEOPTION_EXCLUDE_GROUP, FRAMEOPTION_EXCLUDE_TIES, FRAMEOPTION_GROUPS, FRAMEOPTION_NONDEFAULT, FRAMEOPTION_RANGE, FRAMEOPTION_ROWS, FRAMEOPTION_START_CURRENT_ROW, FRAMEOPTION_START_OFFSET, FRAMEOPTION_START_OFFSET_FOLLOWING, FRAMEOPTION_START_OFFSET_PRECEDING, FRAMEOPTION_START_UNBOUNDED_PRECEDING, and get_rule_expr().
Referenced by get_rule_windowspec(), and get_window_frame_options_for_explain().
◆ get_window_frame_options_for_explain()
| char * get_window_frame_options_for_explain | ( | int | frameOptions, |
| Node * | startOffset, | ||
| Node * | endOffset, | ||
| List * | dpcontext, | ||
| bool | forceprefix | ||
| ) |
Definition at line 6914 of file ruleutils.c.
6917{
6919 deparse_context context;
6920
6928 context.prettyFlags = 0;
6930 context.indentLevel = 0;
6935
6936 get_window_frame_options(frameOptions, startOffset, endOffset, &context);
6937
6939}
References deparse_context::appendparents, deparse_context::buf, buf, deparse_context::colNamesVisible, fb(), get_window_frame_options(), deparse_context::indentLevel, deparse_context::inGroupBy, initStringInfo(), deparse_context::namespaces, NIL, deparse_context::prettyFlags, deparse_context::resultDesc, deparse_context::targetList, deparse_context::varInOrderBy, deparse_context::varprefix, deparse_context::windowClause, WRAP_COLUMN_DEFAULT, and deparse_context::wrapColumn.
Referenced by show_window_def().
◆ get_windowfunc_expr()
|
static |
Definition at line 11072 of file ruleutils.c.
References fb(), and get_windowfunc_expr_helper().
Referenced by get_rule_expr().
◆ get_windowfunc_expr_helper()
|
static |
Definition at line 11083 of file ruleutils.c.
11086{
11089 int nargs;
11090 List *argnames;
11091 ListCell *l;
11092
11097 nargs = 0;
11098 argnames = NIL;
11100 {
11102
11106 nargs++;
11107 }
11108
11112 context->inGroupBy);
11113
11115
11116 /* winstar can be set only in zero-argument aggregates */
11117 if (wfunc->winstar)
11119 else
11120 {
11122 {
11126 }
11127 else
11129 }
11130
11133
11135 {
11138 }
11139
11141
11144
11146
11148 {
11149 /* Query-decompilation case: search the windowClause list */
11151 {
11153
11155 {
11156 if (wc->name)
11158 else
11160 break;
11161 }
11162 }
11165 wfunc->winref);
11166 }
11167 else
11168 {
11169 /*
11170 * In EXPLAIN, search the namespace stack for a matching WindowAgg
11171 * node (probably it's always the first entry), and print winname.
11172 */
11174 {
11176
11178 {
11180
11182 {
11184 break;
11185 }
11186 }
11187 }
11190 wfunc->winref);
11191 }
11192}
References WindowFunc::aggfilter, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), arg, WindowFunc::args, deparse_context::buf, buf, elog, ereport, errcode(), errmsg(), ERROR, exprType(), fb(), FUNC_MAX_ARGS, funcname, generate_function_name(), get_rule_expr(), get_rule_windowspec(), WindowFunc::ignore_nulls, deparse_context::inGroupBy, IsA, lappend(), lfirst, linitial, list_length(), lsecond, deparse_context::namespaces, NIL, PARSER_IGNORE_NULLS, WindowAgg::plan, quote_identifier(), deparse_context::targetList, deparse_context::windowClause, WindowFunc::winfnoid, WindowClause::winref, and WindowFunc::winref.
Referenced by get_json_agg_constructor(), and get_windowfunc_expr().
◆ get_with_clause()
|
static |
Definition at line 5771 of file ruleutils.c.
5772{
5775 ListCell *l;
5776
5778 return;
5779
5781 {
5784 }
5785
5786 if (query->hasRecursive)
5788 else
5791 {
5793
5796 if (cte->aliascolnames)
5797 {
5798 bool first = true;
5800
5803 {
5804 if (first)
5805 first = false;
5806 else
5810 }
5812 }
5815 {
5817 break;
5820 break;
5823 break;
5824 }
5829 true,
5831 context->indentLevel);
5835
5836 if (cte->search_clause)
5837 {
5838 bool first = true;
5840
5842 cte->search_clause->search_breadth_first ? "BREADTH" : "DEPTH");
5843
5845 {
5846 if (first)
5847 first = false;
5848 else
5852 }
5853
5855 }
5856
5857 if (cte->cycle_clause)
5858 {
5859 bool first = true;
5861
5863
5865 {
5866 if (first)
5867 first = false;
5868 else
5872 }
5873
5875
5876 {
5879
5880 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
5882 {
5887 }
5888 }
5889
5891 }
5892
5894 }
5895
5897 {
5900 }
5901 else
5903}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, castNode, Const::consttype, Query::cteList, CTEMaterializeAlways, CommonTableExpr::ctematerialized, CTEMaterializeDefault, CTEMaterializeNever, CommonTableExpr::ctename, CommonTableExpr::ctequery, DatumGetBool(), fb(), get_query_def(), get_rule_expr(), deparse_context::indentLevel, lfirst, deparse_context::namespaces, NIL, PRETTY_INDENT, deparse_context::prettyFlags, PRETTYINDENT_STD, quote_identifier(), strVal, and deparse_context::wrapColumn.
Referenced by get_delete_query_def(), get_insert_query_def(), get_merge_query_def(), get_select_query_def(), and get_update_query_def().
◆ get_xmltable()
|
static |
Definition at line 11995 of file ruleutils.c.
11996{
11998
12000
12002 {
12004 *lc2;
12005 bool first = true;
12006
12009 {
12012
12013 if (!first)
12015 else
12016 first = false;
12017
12019 {
12023 }
12024 else
12025 {
12028 }
12029 }
12031 }
12032
12038
12040 {
12041 ListCell *l1;
12042 ListCell *l2;
12043 ListCell *l3;
12044 ListCell *l4;
12045 ListCell *l5;
12046 int colnum = 0;
12047
12049 forfive(l1, tf->colnames, l2, tf->coltypes, l3, tf->coltypmods,
12050 l4, tf->colexprs, l5, tf->coldefexprs)
12051 {
12057 bool ordinality = (tf->ordinalitycol == colnum);
12059
12060 if (colnum > 0)
12062 colnum++;
12063
12065 ordinality ? "FOR ORDINALITY" :
12066 format_type_with_typemod(typid, typmod));
12067 if (ordinality)
12068 continue;
12069
12071 {
12075 }
12077 {
12081 }
12082 if (notnull)
12084 }
12085 }
12086
12088}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), bms_is_member(), deparse_context::buf, buf, TableFunc::colexprs, TableFunc::docexpr, fb(), forboth, forfive, format_type_with_typemod(), get_rule_expr(), lfirst, lfirst_int, lfirst_node, lfirst_oid, NIL, quote_identifier(), TableFunc::rowexpr, and strVal.
Referenced by get_tablefunc().
◆ has_dangerous_join_using()
|
static |
Definition at line 4144 of file ruleutils.c.
4145{
4147 {
4148 /* nothing to do here */
4149 }
4151 {
4154
4156 {
4158 return true;
4159 }
4160 }
4162 {
4164
4165 /* Is it an unnamed JOIN with USING? */
4167 {
4168 /*
4169 * Yes, so check each join alias var to see if any of them are not
4170 * simple references to underlying columns. If so, we have a
4171 * dangerous situation and must pick unique aliases.
4172 */
4174
4175 /* We need only examine the merged columns */
4177 {
4179
4181 return true;
4182 }
4183 }
4184
4185 /* Nope, but inspect children */
4187 return true;
4189 return true;
4190 }
4191 else
4194 return false;
4195}
References elog, ERROR, fb(), FromExpr::fromlist, has_dangerous_join_using(), i, IsA, j, lfirst, list_nth(), nodeTag, and rt_fetch.
Referenced by has_dangerous_join_using(), and set_deparse_for_query().
◆ identify_join_columns()
|
static |
Definition at line 5069 of file ruleutils.c.
5071{
5076
5077 /* Extract left/right child RT indexes */
5082 else
5089 else
5092
5093 /* Assert children will be processed earlier than join in second pass */
5096
5097 /* Initialize result arrays with zeroes */
5102
5103 /*
5104 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
5105 * Recall that the column(s) merged due to USING are the first column(s)
5106 * of the join output. We need not do anything special while scanning
5107 * joinleftcols, but while scanning joinrightcols we must distinguish
5108 * merged from unmerged columns.
5109 */
5110 jcolno = 0;
5112 {
5114
5116 }
5117 rcolno = 0;
5119 {
5121
5124 else
5126 rcolno++;
5127 }
5129}
References Assert, elog, ERROR, fb(), IsA, j, lfirst_int, list_length(), nodeTag, and palloc0().
Referenced by set_using_names().
◆ is_input_argument()
Definition at line 3450 of file ruleutils.c.
3451{
3456}
References fb().
Referenced by pg_get_function_arg_default().
◆ isSimpleNode()
Definition at line 8882 of file ruleutils.c.
8883{
8884 if (!node)
8885 return false;
8886
8888 {
8895 /* single words: always simple */
8896 return true;
8897
8914 /* function-like: name(..) or name[..] */
8915 return true;
8916
8917 /* CASE keywords act as parentheses */
8919 return true;
8920
8922
8923 /*
8924 * appears simple since . has top precedence, unless parent is
8925 * T_FieldSelect itself!
8926 */
8928
8930
8931 /*
8932 * treat like FieldSelect (probably doesn't matter)
8933 */
8935
8937 /* maybe simple, check args */
8939 node, prettyFlags);
8942 node, prettyFlags);
8945 node, prettyFlags);
8948 node, prettyFlags);
8951 node, prettyFlags);
8954 node, prettyFlags);
8955
8957 {
8958 /* depends on parent node type; needs further checking */
8960 {
8961 const char *op;
8967
8969 if (!op)
8970 return false;
8971
8972 /* We know only the basic operators + - and * / % */
8976 return false;
8977
8980 return false;
8981
8985 return false;
8986
8988 return true; /* op binds tighter than parent */
8989
8991 return false;
8992
8993 /*
8994 * Operators are same priority --- can skip parens only if
8995 * we have (a - b) - c, not a - (b - c).
8996 */
8998 return true;
8999
9000 return false;
9001 }
9002 /* else do the same stuff as for T_SubLink et al. */
9003 }
9004 pg_fallthrough;
9005
9012 {
9014 {
9015 /* special handling for casts and COERCE_SQL_SYNTAX */
9017
9021 return false;
9022 return true; /* own parentheses */
9023 }
9036 return true;
9037 default:
9038 return false;
9039 }
9040
9043 {
9046 {
9049
9053 {
9057 return true;
9058 break;
9061 return true;
9062 break;
9063 }
9064 }
9065 return false;
9067 {
9068 /* special handling for casts and COERCE_SQL_SYNTAX */
9070
9074 return false;
9075 return true; /* own parentheses */
9076 }
9089 return true;
9090 default:
9091 return false;
9092 }
9093
9095 /* maybe simple, check args */
9097 node, prettyFlags);
9098
9099 default:
9100 break;
9101 }
9102 /* those we don't know: in dubio complexo */
9103 return false;
9104}
References AND_EXPR, arg, COERCE_EXPLICIT_CAST, COERCE_IMPLICIT_CAST, COERCE_SQL_SYNTAX, fb(), get_simple_binary_op_name(), IsA, isSimpleNode(), linitial, nodeTag, NOT_EXPR, OR_EXPR, pg_fallthrough, PRETTYFLAG_PAREN, and type.
Referenced by get_rule_expr_paren(), and isSimpleNode().
◆ looks_like_function()
Definition at line 10753 of file ruleutils.c.
10754{
10756 return false; /* probably shouldn't happen */
10758 {
10760 /* OK, unless it's going to deparse as a cast */
10769 /* these are all accepted by func_expr_common_subexpr */
10770 return true;
10771 default:
10772 break;
10773 }
10774 return false;
10775}
References COERCE_EXPLICIT_CALL, COERCE_SQL_SYNTAX, fb(), and nodeTag.
Referenced by get_rule_expr_funccall(), pg_get_indexdef_worker(), pg_get_partkeydef_worker(), and pg_get_statisticsobj_worker().
◆ make_colname_unique()
|
static |
Definition at line 4927 of file ruleutils.c.
4929{
4930 /*
4931 * If the selected name isn't unique, append digits to make it so. For a
4932 * very long input name, we might have to truncate to stay within
4933 * NAMEDATALEN.
4934 */
4936 {
4940
4941 do
4942 {
4943 i++;
4944 for (;;)
4945 {
4949 break;
4950 /* drop chars from colname to keep all the digits */
4952 colnamelen - 1);
4953 }
4955 colname = modname;
4956 }
4957 return colname;
4958}
References colname_is_unique(), fb(), i, NAMEDATALEN, palloc(), pg_mbcliplen(), and sprintf.
Referenced by set_join_column_names(), set_relation_column_names(), and set_using_names().
◆ make_ruledef()
|
static |
Definition at line 5351 of file ruleutils.c.
5353{
5354 char *rulename;
5355 char ev_type;
5357 bool is_instead;
5360 List *actions;
5365 bool isnull;
5366
5367 /*
5368 * Get the attribute values from the rules tuple
5369 */
5372 Assert(!isnull);
5374
5377 Assert(!isnull);
5379
5382 Assert(!isnull);
5384
5387 Assert(!isnull);
5389
5393
5400
5402
5403 /*
5404 * Build the rules definition text
5405 */
5407 quote_identifier(rulename));
5408
5411 else
5413
5414 /* The event the rule is fired for */
5415 switch (ev_type)
5416 {
5417 case '1':
5420 break;
5421
5422 case '2':
5424 break;
5425
5426 case '3':
5428 break;
5429
5430 case '4':
5432 break;
5433
5434 default:
5438 rulename, ev_type)));
5439 break;
5440 }
5441
5442 /* The relation the rule is fired on */
5444 (prettyFlags & PRETTYFLAG_SCHEMA) ?
5447
5448 /* If the rule has an event qualification, add it */
5450 {
5451 Node *qual;
5452 Query *query;
5453 deparse_context context;
5455
5459
5461
5462 /*
5463 * We need to make a context for recognizing any Vars in the qual
5464 * (which can only be references to OLD and NEW). Use the rtable of
5465 * the first query in the action list for this purpose.
5466 */
5468
5469 /*
5470 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5471 * into the SELECT, and that's what we need to look at. (Ugly kluge
5472 * ... try to fix this when we redesign querytrees.)
5473 */
5475
5476 /* Must acquire locks right away; see notes in get_query_def() */
5478
5485 context.prettyFlags = prettyFlags;
5492
5494
5496 }
5497
5499
5500 /* The INSTEAD keyword (if so) */
5501 if (is_instead)
5503
5504 /* Finally the rules actions */
5506 {
5508 Query *query;
5509
5511 foreach(action, actions)
5512 {
5515 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5516 if (prettyFlags)
5518 else
5520 }
5522 }
5523 else
5524 {
5525 Query *query;
5526
5529 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5531 }
5532
5534}
References AccessShareLock, AcquireRewriteLocks(), deparse_context::appendparents, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, deparse_context::colNamesVisible, DatumGetBool(), DatumGetChar(), DatumGetName(), DatumGetObjectId(), elog, ereport, errcode(), errmsg(), ERROR, fb(), generate_qualified_relation_name(), generate_relation_name(), get_query_def(), get_rule_expr(), getInsertSelectQuery(), deparse_context::indentLevel, deparse_context::inGroupBy, lfirst, linitial, list_length(), list_make1, deparse_context::namespaces, NameStr, NIL, PRETTYFLAG_INDENT, PRETTYFLAG_SCHEMA, deparse_context::prettyFlags, PRETTYINDENT_STD, quote_identifier(), RelationGetDescr, deparse_context::resultDesc, Query::rtable, set_deparse_for_query(), SPI_fnumber(), SPI_getbinval(), SPI_getvalue(), stringToNode(), table_close(), table_open(), deparse_context::targetList, deparse_context::varInOrderBy, deparse_context::varprefix, deparse_context::windowClause, WRAP_COLUMN_DEFAULT, and deparse_context::wrapColumn.
Referenced by pg_get_ruledef_worker().
◆ make_viewdef()
|
static |
Definition at line 5543 of file ruleutils.c.
5545{
5546 Query *query;
5547 char ev_type;
5549 bool is_instead;
5552 List *actions;
5556 bool isnull;
5557
5558 /*
5559 * Get the attribute values from the rules tuple
5560 */
5563 Assert(!isnull);
5565
5568 Assert(!isnull);
5570
5573 Assert(!isnull);
5575
5579
5584
5586 {
5587 /* keep output buffer empty and leave */
5588 return;
5589 }
5590
5592
5593 if (ev_type != '1' || !is_instead ||
5595 {
5596 /* keep output buffer empty and leave */
5597 return;
5598 }
5599
5601
5603 prettyFlags, wrapColumn, 0);
5605
5607}
References AccessShareLock, appendStringInfoChar(), Assert, buf, CMD_SELECT, Query::commandType, DatumGetBool(), DatumGetChar(), DatumGetObjectId(), fb(), get_query_def(), linitial, list_length(), NIL, RelationGetDescr, SPI_fnumber(), SPI_getbinval(), SPI_getvalue(), stringToNode(), table_close(), and table_open().
Referenced by pg_get_viewdef_worker().
◆ pg_get_constraintdef()
| Datum pg_get_constraintdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 2146 of file ruleutils.c.
2147{
2149 int prettyFlags;
2150 char *res;
2151
2152 prettyFlags = PRETTYFLAG_INDENT;
2153
2155
2157 PG_RETURN_NULL();
2158
2160}
References fb(), pg_get_constraintdef_worker(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, PRETTYFLAG_INDENT, and string_to_text().
◆ pg_get_constraintdef_command()
Definition at line 2184 of file ruleutils.c.
References fb(), and pg_get_constraintdef_worker().
Referenced by RememberConstraintForRebuilding().
◆ pg_get_constraintdef_ext()
| Datum pg_get_constraintdef_ext | ( | PG_FUNCTION_ARGS | ) |
Definition at line 2163 of file ruleutils.c.
References fb(), GET_PRETTY_FLAGS, pg_get_constraintdef_worker(), PG_GETARG_BOOL, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, and string_to_text().
◆ pg_get_constraintdef_worker()
|
static |
Definition at line 2193 of file ruleutils.c.
2195{
2199 SysScanDesc scandesc;
2203
2205 Anum_pg_constraint_oid,
2208
2209 scandesc = systable_beginscan(relation,
2210 ConstraintOidIndexId,
2211 true,
2212 snapshot,
2213 1,
2214 scankey);
2215
2216 /*
2217 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2218 * via SearchSysCache, which works fine.
2219 */
2221
2222 UnregisterSnapshot(snapshot);
2223
2225 {
2226 if (missing_ok)
2227 {
2228 systable_endscan(scandesc);
2231 }
2233 }
2234
2236
2238
2240 {
2242 {
2243 /*
2244 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2245 * constraints, and other types of constraints don't inherit
2246 * anyway so it doesn't matter whether we say ONLY or not. Someday
2247 * we might need to let callers specify whether to put ONLY in the
2248 * command.
2249 */
2253 }
2254 else
2255 {
2256 /* Must be a domain constraint */
2261 }
2262 }
2263
2265 {
2267 {
2269 bool isnull;
2271
2272 /* Start off the constraint definition */
2274
2275 /* Fetch and build referencing-column list */
2277 Anum_pg_constraint_conkey);
2278
2279 /* If it is a temporal foreign key then it uses PERIOD. */
2281
2282 /* add foreign relation name */
2285 NIL));
2286
2287 /* Fetch and build referenced-column list */
2289 Anum_pg_constraint_confkey);
2290
2292
2294
2295 /* Add match type */
2297 {
2299 string = " MATCH FULL";
2300 break;
2302 string = " MATCH PARTIAL";
2303 break;
2305 string = "";
2306 break;
2307 default:
2309 conForm->confmatchtype);
2310 string = ""; /* keep compiler quiet */
2311 break;
2312 }
2314
2315 /* Add ON UPDATE and ON DELETE clauses, if needed */
2317 {
2320 break;
2322 string = "RESTRICT";
2323 break;
2325 string = "CASCADE";
2326 break;
2328 string = "SET NULL";
2329 break;
2331 string = "SET DEFAULT";
2332 break;
2333 default:
2335 conForm->confupdtype);
2337 break;
2338 }
2339 if (string)
2341
2343 {
2346 break;
2348 string = "RESTRICT";
2349 break;
2351 string = "CASCADE";
2352 break;
2354 string = "SET NULL";
2355 break;
2357 string = "SET DEFAULT";
2358 break;
2359 default:
2361 conForm->confdeltype);
2363 break;
2364 }
2365 if (string)
2367
2368 /*
2369 * Add columns specified to SET NULL or SET DEFAULT if
2370 * provided.
2371 */
2373 Anum_pg_constraint_confdelsetcols, &isnull);
2374 if (!isnull)
2375 {
2379 }
2380
2381 break;
2382 }
2385 {
2390
2391 /* Start off the constraint definition */
2394 else
2396
2398
2405
2407
2408 /* Fetch and build target column list */
2410 Anum_pg_constraint_conkey);
2411
2415
2417
2418 /* Build including column list (from pg_index.indkeys) */
2420 Anum_pg_index_indnatts);
2422 {
2423 Datum cols;
2424 Datum *keys;
2425 int nKeys;
2427
2429
2431 Anum_pg_index_indkey);
2432
2434 &keys, NULL, &nKeys);
2435
2437 {
2439
2445 }
2446
2448 }
2450
2451 /* XXX why do we only print these bits if fullCommand? */
2453 {
2456
2458 {
2461 }
2462
2463 /*
2464 * Print the tablespace, unless it's the database default.
2465 * This is to help ALTER TABLE usage of this facility,
2466 * which needs this behavior to recreate exact catalog
2467 * state.
2468 */
2473 }
2474
2475 break;
2476 }
2478 {
2482 Node *expr;
2483 List *context;
2484
2485 /* Fetch constraint expression in parsetree form */
2487 Anum_pg_constraint_conbin);
2488
2491
2492 /* Set up deparsing context for Var nodes in constraint */
2494 {
2495 /* relation constraint */
2497 conForm->conrelid);
2498 }
2499 else
2500 {
2501 /* domain constraint --- can't have Vars */
2502 context = NIL;
2503 }
2504
2506 prettyFlags, 0);
2507
2508 /*
2509 * Now emit the constraint definition, adding NO INHERIT if
2510 * necessary.
2511 *
2512 * There are cases where the constraint expression will be
2513 * fully parenthesized and we don't need the outer parens ...
2514 * but there are other cases where we do need 'em. Be
2515 * conservative for now.
2516 *
2517 * Note that simply checking for leading '(' and trailing ')'
2518 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2519 */
2521 consrc,
2523 break;
2524 }
2526 {
2528 {
2530
2532
2538 }
2540 {
2541 /* conkey is null for domain not-null constraints */
2543 }
2544 break;
2545 }
2546
2548
2549 /*
2550 * There isn't an ALTER TABLE syntax for creating a user-defined
2551 * constraint trigger, but it seems better to print something than
2552 * throw an error; if we throw error then this function couldn't
2553 * safely be applied to all rows of pg_constraint.
2554 */
2556 break;
2558 {
2561 Datum *elems;
2562 int nElems;
2564 Oid *operators;
2565
2566 /* Extract operator OIDs from the pg_constraint tuple */
2568 Anum_pg_constraint_conexclop);
2569
2571 &elems, NULL, &nElems);
2572
2576
2577 /* pg_get_indexdef_worker does the rest */
2578 /* suppress tablespace because pg_dump wants it that way */
2580 pg_get_indexdef_worker(indexOid,
2581 0,
2582 operators,
2583 false,
2584 false,
2585 false,
2586 false,
2587 prettyFlags,
2588 false));
2589 break;
2590 }
2591 default:
2593 break;
2594 }
2595
2600
2601 /* Validated status is irrelevant when the constraint is NOT ENFORCED. */
2606
2607 /* Cleanup */
2608 systable_endscan(scandesc);
2610
2612}
References AccessShareLock, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attnum, BTEqualStrategyNumber, buf, DatumGetArrayTypeP, DatumGetInt16(), DatumGetInt32(), DatumGetObjectId(), decompile_column_index_array(), deconstruct_array_builtin(), deparse_context_for(), deparse_expression_pretty(), elog, ERROR, extractNotNullColumn(), fb(), FKCONSTR_ACTION_CASCADE, FKCONSTR_ACTION_NOACTION, FKCONSTR_ACTION_RESTRICT, FKCONSTR_ACTION_SETDEFAULT, FKCONSTR_ACTION_SETNULL, FKCONSTR_MATCH_FULL, FKCONSTR_MATCH_PARTIAL, FKCONSTR_MATCH_SIMPLE, flatten_reloptions(), Form_pg_constraint, Form_pg_index, generate_qualified_relation_name(), generate_qualified_type_name(), generate_relation_name(), get_attname(), get_rel_tablespace(), get_relation_name(), get_tablespace_name(), GETSTRUCT(), GetTransactionSnapshot(), HeapTupleIsValid, i, initStringInfo(), InvalidOid, j, NameStr, NIL, ObjectIdGetDatum(), OidIsValid, palloc(), pfree(), pg_get_indexdef_worker(), quote_identifier(), RegisterSnapshot(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), stringToNode(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, UnregisterSnapshot(), and val.
Referenced by pg_get_constraintdef(), pg_get_constraintdef_command(), and pg_get_constraintdef_ext().
◆ pg_get_expr()
| Datum pg_get_expr | ( | PG_FUNCTION_ARGS | ) |
Definition at line 2675 of file ruleutils.c.
2676{
2679 text *result;
2680 int prettyFlags;
2681
2682 prettyFlags = PRETTYFLAG_INDENT;
2683
2684 result = pg_get_expr_worker(expr, relid, prettyFlags);
2685 if (result)
2686 PG_RETURN_TEXT_P(result);
2687 else
2688 PG_RETURN_NULL();
2689}
References pg_get_expr_worker(), PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and PRETTYFLAG_INDENT.
Referenced by decompile_conbin().
◆ pg_get_expr_ext()
| Datum pg_get_expr_ext | ( | PG_FUNCTION_ARGS | ) |
Definition at line 2692 of file ruleutils.c.
2693{
2697 text *result;
2698 int prettyFlags;
2699
2701
2702 result = pg_get_expr_worker(expr, relid, prettyFlags);
2703 if (result)
2704 PG_RETURN_TEXT_P(result);
2705 else
2706 PG_RETURN_NULL();
2707}
References fb(), GET_PRETTY_FLAGS, pg_get_expr_worker(), PG_GETARG_BOOL, PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_NULL, and PG_RETURN_TEXT_P.
◆ pg_get_expr_worker()
Definition at line 2710 of file ruleutils.c.
2711{
2712 Node *node;
2714 Relids relids;
2715 List *context;
2719
2720 /* Convert input pg_node_tree (really TEXT) object to C string */
2722
2723 /* Convert expression to node tree */
2725
2727
2728 /*
2729 * Throw error if the input is a querytree rather than an expression tree.
2730 * While we could support queries here, there seems no very good reason
2731 * to. In most such catalog columns, we'll see a List of Query nodes, or
2732 * even nested Lists, so drill down to a non-List node before checking.
2733 */
2734 tst = node;
2741
2742 /*
2743 * Throw error if the expression contains Vars we won't be able to
2744 * deparse.
2745 */
2748 {
2753 }
2754 else
2755 {
2760 }
2761
2762 /*
2763 * Prepare deparse context if needed. If we are deparsing with a relid,
2764 * we need to transiently open and lock the rel, to make sure it won't go
2765 * away underneath us. (set_relation_column_names would lock it anyway,
2766 * so this isn't really introducing any new behavior.)
2767 */
2769 {
2774 }
2775 else
2776 context = NIL;
2777
2778 /* Deparse */
2780 prettyFlags, 0);
2781
2784
2786}
References AccessShareLock, bms_is_empty, bms_is_subset(), bms_make_singleton(), deparse_context_for(), deparse_expression_pretty(), ereport, errcode(), errmsg(), ERROR, fb(), IsA, linitial, NIL, OidIsValid, pfree(), pull_varnos(), relation_close(), RelationGetRelationName, str, string_to_text(), stringToNode(), text_to_cstring(), and try_relation_open().
Referenced by pg_get_expr(), and pg_get_expr_ext().
◆ pg_get_function_arg_default()
| Datum pg_get_function_arg_default | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3490 of file ruleutils.c.
3491{
3495 Form_pg_proc proc;
3496 int numargs;
3497 Oid *argtypes;
3498 char **argnames;
3502 Node *node;
3506 bool isnull;
3508
3511 PG_RETURN_NULL();
3512
3515 {
3517 PG_RETURN_NULL();
3518 }
3519
3520 nth_inputarg = 0;
3523 nth_inputarg++;
3524
3527 &isnull);
3528 if (isnull)
3529 {
3531 PG_RETURN_NULL();
3532 }
3533
3537
3539
3540 /*
3541 * Calculate index into proargdefaults: proargdefaults corresponds to the
3542 * last N input arguments, where N = pronargdefaults.
3543 */
3545
3547 {
3549 PG_RETURN_NULL();
3550 }
3553
3555
3557}
References castNode, deparse_expression(), fb(), Form_pg_proc, get_func_arg_info(), GETSTRUCT(), HeapTupleIsValid, i, is_input_argument(), list_length(), list_nth(), NIL, ObjectIdGetDatum(), pfree(), PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, ReleaseSysCache(), SearchSysCache1(), str, string_to_text(), stringToNode(), SysCacheGetAttr(), and TextDatumGetCString.
◆ pg_get_function_arguments()
| Datum pg_get_function_arguments | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3183 of file ruleutils.c.
References buf, fb(), HeapTupleIsValid, initStringInfo(), ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, print_function_arguments(), ReleaseSysCache(), SearchSysCache1(), and string_to_text().
◆ pg_get_function_identity_arguments()
| Datum pg_get_function_identity_arguments | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3209 of file ruleutils.c.
References buf, fb(), HeapTupleIsValid, initStringInfo(), ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, print_function_arguments(), ReleaseSysCache(), SearchSysCache1(), and string_to_text().
◆ pg_get_function_result()
| Datum pg_get_function_result | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3234 of file ruleutils.c.
3235{
3239
3242 PG_RETURN_NULL();
3243
3245 {
3247 PG_RETURN_NULL();
3248 }
3249
3251
3253
3255
3257}
References buf, fb(), Form_pg_proc, GETSTRUCT(), HeapTupleIsValid, initStringInfo(), ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, print_function_rettype(), ReleaseSysCache(), SearchSysCache1(), and string_to_text().
◆ pg_get_function_sqlbody()
| Datum pg_get_function_sqlbody | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3614 of file ruleutils.c.
3615{
3619 bool isnull;
3620
3622
3623 /* Look up the function */
3626 PG_RETURN_NULL();
3627
3629 if (isnull)
3630 {
3632 PG_RETURN_NULL();
3633 }
3634
3636
3638
3640}
References buf, cstring_to_text_with_len(), fb(), HeapTupleIsValid, initStringInfo(), ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, print_function_sqlbody(), ReleaseSysCache(), SearchSysCache1(), and SysCacheGetAttr().
◆ pg_get_functiondef()
| Datum pg_get_functiondef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 2927 of file ruleutils.c.
2928{
2933 Form_pg_proc proc;
2935 Datum tmp;
2936 bool isnull;
2937 const char *prosrc;
2942
2944
2945 /* Look up the function */
2948 PG_RETURN_NULL();
2949
2952
2957
2959
2960 /*
2961 * We always qualify the function name, to ensure the right function gets
2962 * replaced.
2963 */
2971 {
2975 }
2976
2978
2981
2982 /* Emit some miscellaneous options on one line */
2984
2987 switch (proc->provolatile)
2988 {
2991 break;
2994 break;
2996 break;
2997 }
2998
2999 switch (proc->proparallel)
3000 {
3003 break;
3006 break;
3008 break;
3009 }
3010
3011 if (proc->proisstrict)
3013 if (proc->prosecdef)
3015 if (proc->proleakproof)
3017
3018 /* This code for the default cost and rows should match functioncmds.c */
3020 proc->prolang == ClanguageId)
3021 procost = 1;
3022 else
3023 procost = 100;
3026
3027 if (proc->prorows > 0 && proc->prorows != 1000)
3029
3030 if (proc->prosupport)
3031 {
3032 Oid argtypes[1];
3033
3034 /*
3035 * We should qualify the support function's name if it wouldn't be
3036 * resolved by lookup in the current search path.
3037 */
3038 argtypes[0] = INTERNALOID;
3040 generate_function_name(proc->prosupport, 1,
3041 NIL, argtypes,
3043 }
3044
3047
3048 /* Emit any proconfig options, one per line */
3050 if (!isnull)
3051 {
3054
3058
3060 {
3061 Datum d;
3062
3064 -1 /* varlenarray */ ,
3065 -1 /* TEXT's typlen */ ,
3066 false /* TEXT's typbyval */ ,
3068 &isnull);
3069 if (!isnull)
3070 {
3072 char *pos;
3073
3076 continue;
3077 *pos++ = '\0';
3078
3081
3082 /*
3083 * Variables that are marked GUC_LIST_QUOTE were already fully
3084 * quoted by flatten_set_variable_args() before they were put
3085 * into the proconfig array. However, because the quoting
3086 * rules used there aren't exactly like SQL's, we have to
3087 * break the list value apart and then quote the elements as
3088 * string literals. (The elements may be double-quoted as-is,
3089 * but we can't just feed them to the SQL parser; it would do
3090 * the wrong thing with elements that are zero-length or
3091 * longer than NAMEDATALEN.) Also, we need a special case for
3092 * empty lists.
3093 *
3094 * Variables that are not so marked should just be emitted as
3095 * simple string literals. If the variable is not known to
3096 * guc.c, we'll do that; this makes it unsafe to use
3097 * GUC_LIST_QUOTE for extension variables.
3098 */
3100 {
3103
3104 /* Parse string into list of identifiers */
3106 {
3107 /* this shouldn't fail really */
3109 }
3110 /* Special case: represent an empty list as NULL */
3114 {
3116
3120 }
3121 }
3122 else
3125 }
3126 }
3127 }
3128
3129 /* And finally the function definition ... */
3132 {
3134 }
3135 else
3136 {
3138
3140 if (!isnull)
3141 {
3144 }
3145
3147 prosrc = TextDatumGetCString(tmp);
3148
3149 /*
3150 * We always use dollar quoting. Figure out a suitable delimiter.
3151 *
3152 * Since the user is likely to be editing the function body string, we
3153 * shouldn't use a short delimiter that he might easily create a
3154 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3155 * if needed.
3156 */
3163
3167 }
3168
3170
3172
3174}
References a, appendBinaryStringInfo(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), Assert, buf, DatumGetArrayTypeP, elog, ereport, errcode(), errmsg(), ERROR, fb(), Form_pg_proc, generate_function_name(), get_language_name(), get_namespace_name_or_temp(), GetConfigOptionFlags(), GETSTRUCT(), GUC_LIST_QUOTE, HeapTupleIsValid, i, initStringInfo(), lfirst, lnext(), name, NameStr, NIL, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, print_function_arguments(), print_function_rettype(), print_function_sqlbody(), print_function_trftypes(), quote_identifier(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), simple_quote_literal(), SplitGUCList(), string_to_text(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), and TextDatumGetCString.
◆ pg_get_indexdef()
| Datum pg_get_indexdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1179 of file ruleutils.c.
1180{
1182 int prettyFlags;
1183 char *res;
1184
1185 prettyFlags = PRETTYFLAG_INDENT;
1186
1188 false, false,
1189 false, false,
1190 prettyFlags, true);
1191
1193 PG_RETURN_NULL();
1194
1196}
References fb(), pg_get_indexdef_worker(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, PRETTYFLAG_INDENT, and string_to_text().
◆ pg_get_indexdef_columns()
Definition at line 1236 of file ruleutils.c.
1237{
1238 int prettyFlags;
1239
1241
1243 true, true,
1244 false, false,
1245 prettyFlags, false);
1246}
References fb(), GET_PRETTY_FLAGS, and pg_get_indexdef_worker().
Referenced by BuildIndexValueDescription().
◆ pg_get_indexdef_columns_extended()
Definition at line 1250 of file ruleutils.c.
1251{
1254 int prettyFlags;
1255
1257
1260 false, false,
1261 prettyFlags, false);
1262}
References fb(), GET_PRETTY_FLAGS, pg_get_indexdef_worker(), RULE_INDEXDEF_KEYS_ONLY, and RULE_INDEXDEF_PRETTY.
Referenced by gist_page_items().
◆ pg_get_indexdef_ext()
| Datum pg_get_indexdef_ext | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1199 of file ruleutils.c.
1200{
1204 int prettyFlags;
1205 char *res;
1206
1208
1210 colno != 0, false,
1211 false, false,
1212 prettyFlags, true);
1213
1215 PG_RETURN_NULL();
1216
1218}
References fb(), GET_PRETTY_FLAGS, pg_get_indexdef_worker(), PG_GETARG_BOOL, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, and string_to_text().
◆ pg_get_indexdef_string()
Definition at line 1226 of file ruleutils.c.
1227{
1229 false, false,
1230 true, true,
1231 0, false);
1232}
References fb(), and pg_get_indexdef_worker().
Referenced by RememberIndexForRebuilding().
◆ pg_get_indexdef_worker()
|
static |
Definition at line 1271 of file ruleutils.c.
1276{
1277 /* might want a separate isConstraint parameter later */
1288 List *context;
1290 int keyno;
1300
1301 /*
1302 * Fetch the pg_index tuple by the Oid of the index
1303 */
1306 {
1307 if (missing_ok)
1310 }
1312
1315
1316 /* Must get indcollation, indclass, and indoption the hard way */
1318 Anum_pg_index_indcollation);
1320
1322 Anum_pg_index_indclass);
1324
1326 Anum_pg_index_indoption);
1328
1329 /*
1330 * Fetch the pg_class tuple of the index relation
1331 */
1336
1337 /*
1338 * Fetch the pg_am tuple of the index' access method
1339 */
1343 idxrelrec->relam);
1345
1346 /* Fetch the index AM's API struct */
1348
1349 /*
1350 * Get the index expressions, if any. (NOTE: we do not use the relcache
1351 * versions of the expressions and predicate, because we want to display
1352 * non-const-folded expressions.)
1353 */
1355 {
1358
1360 Anum_pg_index_indexprs);
1364 }
1365 else
1367
1369
1371
1372 /*
1373 * Start the index definition. Note that the index's name should never be
1374 * schema-qualified, but the indexed rel's name may be.
1375 */
1377
1379 {
1386 (prettyFlags & PRETTYFLAG_SCHEMA) ?
1390 else /* currently, must be EXCLUDE constraint */
1393 }
1394
1395 /*
1396 * Report the indexed attributes
1397 */
1400 {
1404
1405 /*
1406 * Ignore non-key attributes if told to.
1407 */
1409 break;
1410
1411 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1413 {
1416 }
1417
1418 if (!colno)
1421
1423 {
1424 /* Simple index column */
1427
1429 if (!colno || colno == keyno + 1)
1433 &keycolcollation);
1434 }
1435 else
1436 {
1437 /* expressional index */
1439
1444 /* Deparse */
1446 prettyFlags, 0);
1447 if (!colno || colno == keyno + 1)
1448 {
1449 /* Need parens if it's not a bare function call */
1452 else
1454 }
1457 }
1458
1459 /* Print additional decoration for (selected) key columns */
1461 (!colno || colno == keyno + 1))
1462 {
1467
1468 /* Add collation, if not default for column */
1472
1473 /* Add the operator class name, if not default */
1476
1478 {
1482 }
1483
1484 /* Add options if relevant */
1486 {
1487 /* if it supports sort ordering, report DESC and NULLS opts */
1489 {
1491 /* NULLS FIRST is the default in this case */
1494 }
1495 else
1496 {
1499 }
1500 }
1501
1502 /* Add the exclusion operator if relevant */
1506 keycoltype,
1507 keycoltype));
1508 }
1509 }
1510
1512 {
1514
1517
1518 /*
1519 * If it has options, append "WITH (options)"
1520 */
1523 {
1526 }
1527
1528 /*
1529 * Print tablespace, but only if requested
1530 */
1532 {
1534
1537 {
1542 }
1543 }
1544
1545 /*
1546 * If it's a partial index, decompile and append the predicate
1547 */
1549 {
1550 Node *node;
1553
1554 /* Convert text string to node tree */
1556 Anum_pg_index_indpred);
1560
1561 /* Deparse */
1563 prettyFlags, 0);
1566 else
1568 }
1569 }
1570
1571 /* Clean up */
1575
1577}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attname, attnum, buf, DatumGetPointer(), deparse_context_for(), deparse_expression_pretty(), elog, ERROR, exprCollation(), exprType(), fb(), flatten_reloptions(), Form_pg_am, Form_pg_index, generate_collation_name(), generate_operator_name(), generate_qualified_relation_name(), generate_relation_name(), get_attname(), get_attoptions(), get_atttypetypmodcoll(), get_opclass_name(), get_rel_tablespace(), get_relation_name(), get_reloptions(), get_tablespace_name(), GetIndexAmRoutine(), GETSTRUCT(), heap_attisnull(), HeapTupleIsValid, initStringInfo(), InvalidOid, lfirst, list_head(), lnext(), looks_like_function(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, pfree(), PRETTYFLAG_SCHEMA, quote_identifier(), ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), and TextDatumGetCString.
Referenced by pg_get_constraintdef_worker(), pg_get_indexdef(), pg_get_indexdef_columns(), pg_get_indexdef_columns_extended(), pg_get_indexdef_ext(), and pg_get_indexdef_string().
◆ pg_get_partconstrdef_string()
Definition at line 2128 of file ruleutils.c.
References deparse_context_for(), deparse_expression(), fb(), and get_partition_qual_relid().
Referenced by RI_PartitionRemove_Check().
◆ pg_get_partition_constraintdef()
| Datum pg_get_partition_constraintdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 2096 of file ruleutils.c.
2097{
2100 int prettyFlags;
2101 List *context;
2103
2105
2106 /* Quick exit if no partition constraint */
2108 PG_RETURN_NULL();
2109
2110 /*
2111 * Deparse and return the constraint expression.
2112 */
2113 prettyFlags = PRETTYFLAG_INDENT;
2116 false, prettyFlags, 0);
2117
2119}
References deparse_context_for(), deparse_expression_pretty(), fb(), get_partition_qual_relid(), get_relation_name(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, PRETTYFLAG_INDENT, and string_to_text().
◆ pg_get_partkeydef()
| Datum pg_get_partkeydef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1909 of file ruleutils.c.
References fb(), pg_get_partkeydef_worker(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, PRETTYFLAG_INDENT, and string_to_text().
◆ pg_get_partkeydef_columns()
Definition at line 1924 of file ruleutils.c.
1925{
1926 int prettyFlags;
1927
1929
1931}
References fb(), GET_PRETTY_FLAGS, and pg_get_partkeydef_worker().
Referenced by ExecBuildSlotPartitionKeyDescription().
◆ pg_get_partkeydef_worker()
|
static |
Definition at line 1937 of file ruleutils.c.
1939{
1941 HeapTuple tuple;
1943 oidvector *partcollation;
1944 List *partexprs;
1946 List *context;
1947 Datum datum;
1949 int keyno;
1952
1955 {
1956 if (missing_ok)
1959 }
1960
1962
1964
1965 /* Must get partclass and partcollation the hard way */
1969
1973
1974
1975 /*
1976 * Get the expressions, if any. (NOTE: we do not use the relcache
1977 * versions of the expressions, because we want to display
1978 * non-const-folded expressions.)
1979 */
1981 {
1984
1989
1993
1995 }
1996 else
1997 partexprs = NIL;
1998
2001
2003
2005 {
2009 break;
2013 break;
2017 break;
2018 default:
2021 }
2022
2027 {
2032
2036 {
2037 /* Simple attribute reference */
2040
2045 &keycolcollation);
2046 }
2047 else
2048 {
2049 /* Expression */
2051
2056
2057 /* Deparse */
2059 prettyFlags, 0);
2060 /* Need parens if it's not a bare function call */
2063 else
2065
2068 }
2069
2070 /* Add collation, if not default for column */
2075
2076 /* Add the operator class name, if not default */
2079 }
2080
2083
2084 /* Clean up */
2085 ReleaseSysCache(tuple);
2086
2088}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attname, attnum, buf, DatumGetPointer(), deparse_context_for(), deparse_expression_pretty(), elog, ERROR, exprCollation(), exprType(), fb(), Form_pg_partitioned_table, generate_collation_name(), get_attname(), get_atttypetypmodcoll(), get_opclass_name(), get_relation_name(), GETSTRUCT(), heap_attisnull(), HeapTupleIsValid, initStringInfo(), IsA, lfirst, list_head(), lnext(), looks_like_function(), NIL, nodeTag, ObjectIdGetDatum(), OidIsValid, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, pfree(), quote_identifier(), ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), TextDatumGetCString, and oidvector::values.
Referenced by pg_get_partkeydef(), and pg_get_partkeydef_columns().
◆ pg_get_querydef()
Definition at line 1589 of file ruleutils.c.
References buf, fb(), GET_PRETTY_FLAGS, get_query_def(), initStringInfo(), NIL, and WRAP_COLUMN_DEFAULT.
◆ pg_get_ruledef()
| Datum pg_get_ruledef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 561 of file ruleutils.c.
562{
564 int prettyFlags;
565 char *res;
566
567 prettyFlags = PRETTYFLAG_INDENT;
568
570
572 PG_RETURN_NULL();
573
575}
References fb(), pg_get_ruledef_worker(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, PRETTYFLAG_INDENT, and string_to_text().
◆ pg_get_ruledef_ext()
| Datum pg_get_ruledef_ext | ( | PG_FUNCTION_ARGS | ) |
Definition at line 579 of file ruleutils.c.
References fb(), GET_PRETTY_FLAGS, pg_get_ruledef_worker(), PG_GETARG_BOOL, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, and string_to_text().
◆ pg_get_ruledef_worker()
Definition at line 598 of file ruleutils.c.
599{
601 char nulls[1];
606
607 /*
608 * Do this first so that string is alloc'd in outer context not SPI's.
609 */
611
612 /*
613 * Connect to SPI manager
614 */
615 SPI_connect();
616
617 /*
618 * On the first call prepare the plan to lookup pg_rewrite. We read
619 * pg_rewrite over the SPI manager instead of using the syscache to be
620 * checked for read access on pg_rewrite.
621 */
623 {
624 Oid argtypes[1];
626
627 argtypes[0] = OIDOID;
633 }
634
635 /*
636 * Get the pg_rewrite tuple for this rule
637 */
639 nulls[0] = ' ';
644 {
645 /*
646 * There is no tuple data available here, just keep the output buffer
647 * empty.
648 */
649 }
650 else
651 {
652 /*
653 * Get the rule's definition and put it into executor's memory
654 */
658 }
659
660 /*
661 * Disconnect from SPI manager
662 */
665
668
670}
References buf, elog, ERROR, fb(), initStringInfo(), make_ruledef(), ObjectIdGetDatum(), plan, plan_getrulebyoid, query_getrulebyoid, SPI_connect(), SPI_execute_plan(), SPI_finish(), SPI_keepplan(), SPI_OK_FINISH, SPI_OK_SELECT, SPI_prepare(), SPI_processed, SPI_tuptable, SPITupleTable::tupdesc, and SPITupleTable::vals.
Referenced by pg_get_ruledef(), and pg_get_ruledef_ext().
◆ pg_get_serial_sequence()
| Datum pg_get_serial_sequence | ( | PG_FUNCTION_ARGS | ) |
Definition at line 2833 of file ruleutils.c.
2834{
2838 Oid tableOid;
2844 SysScanDesc scan;
2846
2847 /* Look up table name. Can't lock it - we might not have privileges. */
2850
2851 /* Get the number of the column */
2853
2860
2861 /* Search the dependency table for the dependent sequence */
2863
2864 ScanKeyInit(&key[0],
2868 ScanKeyInit(&key[1],
2869 Anum_pg_depend_refobjid,
2871 ObjectIdGetDatum(tableOid));
2872 ScanKeyInit(&key[2],
2876
2878 NULL, 3, key);
2879
2881 {
2883
2884 /*
2885 * Look for an auto dependency (serial column) or internal dependency
2886 * (identity column) of a sequence on a column. (We need the relkind
2887 * test because indexes can also have auto dependencies on columns.)
2888 */
2890 deprec->objsubid == 0 &&
2894 {
2896 break;
2897 }
2898 }
2899
2900 systable_endscan(scan);
2902
2904 {
2905 char *result;
2906
2908
2910 }
2911
2912 PG_RETURN_NULL();
2913}
References AccessShareLock, attnum, BTEqualStrategyNumber, DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, ereport, errcode(), errmsg(), ERROR, fb(), Form_pg_depend, generate_qualified_relation_name(), get_attnum(), get_rel_relkind(), GETSTRUCT(), HeapTupleIsValid, Int32GetDatum(), InvalidAttrNumber, InvalidOid, makeRangeVarFromNameList(), NoLock, ObjectIdGetDatum(), OidIsValid, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, RangeVarGetRelid, ScanKeyInit(), string_to_text(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), text_to_cstring(), and textToQualifiedNameList().
◆ pg_get_statisticsobj_worker()
|
static |
Definition at line 1654 of file ruleutils.c.
1655{
1659 int colno;
1661 ArrayType *arr;
1662 char *enabled;
1663 Datum datum;
1668 List *context;
1672 int ncolumns;
1673
1675
1677 {
1678 if (missing_ok)
1681 }
1682
1683 /* has the statistics expressions? */
1685
1687
1688 /*
1689 * Get the statistics expressions, if any. (NOTE: we do not use the
1690 * relcache versions of the expressions, because we want to display
1691 * non-const-folded expressions.)
1692 */
1694 {
1697
1703 }
1704 else
1705 exprs = NIL;
1706
1707 /* count the number of columns (attributes and expressions) */
1709
1711
1713 {
1718
1719 /*
1720 * Decode the stxkind column so that we know which stats types to
1721 * print.
1722 */
1725 arr = DatumGetArrayTypeP(datum);
1727 ARR_HASNULL(arr) ||
1731
1735
1737 {
1744
1745 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
1746 }
1747
1748 /*
1749 * If any option is disabled, then we'll need to append the types
1750 * clause to show which options are enabled. We omit the types clause
1751 * on purpose when all options are enabled, so a pg_dump/pg_restore
1752 * will create all statistics types on a newer postgres version, if
1753 * the statistics had all options enabled on the original version.
1754 *
1755 * But if the statistics is defined on just a single column, it has to
1756 * be an expression statistics. In that case we don't need to specify
1757 * kinds.
1758 */
1760 (ncolumns > 1))
1761 {
1763
1765
1767 {
1770 }
1771
1773 {
1776 }
1777
1780
1782 }
1783
1785 }
1786
1787 /* decode simple column references */
1789 {
1792
1793 if (colno > 0)
1795
1797
1799 }
1800
1802 statextrec->stxrelid);
1803
1805 {
1809
1811 prettyFlags, 0);
1812
1813 if (colno > 0)
1815
1816 /* Need parens if it's not a bare function call */
1819 else
1821
1822 colno++;
1823 }
1824
1828
1830
1832}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, attname, attnum, buf, DatumGetArrayTypeP, deparse_context_for(), deparse_expression_pretty(), elog, ERROR, fb(), Form_pg_statistic_ext, generate_relation_name(), get_attname(), get_namespace_name_or_temp(), get_relation_name(), GETSTRUCT(), heap_attisnull(), HeapTupleIsValid, i, initStringInfo(), lfirst, list_length(), looks_like_function(), NameStr, NIL, ObjectIdGetDatum(), pfree(), PRETTYFLAG_PAREN, quote_identifier(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), and TextDatumGetCString.
Referenced by pg_get_statisticsobjdef(), pg_get_statisticsobjdef_columns(), and pg_get_statisticsobjdef_string().
◆ pg_get_statisticsobjdef()
| Datum pg_get_statisticsobjdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1609 of file ruleutils.c.
References fb(), pg_get_statisticsobj_worker(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, and string_to_text().
◆ pg_get_statisticsobjdef_columns()
| Datum pg_get_statisticsobjdef_columns | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1637 of file ruleutils.c.
References fb(), pg_get_statisticsobj_worker(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, and string_to_text().
◆ pg_get_statisticsobjdef_expressions()
| Datum pg_get_statisticsobjdef_expressions | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1838 of file ruleutils.c.
1839{
1843 Datum datum;
1844 List *context;
1848 char *tmp;
1850
1852
1854 PG_RETURN_NULL();
1855
1856 /* Does the stats object have expressions? */
1858
1859 /* no expressions? we're done */
1861 {
1863 PG_RETURN_NULL();
1864 }
1865
1867
1868 /*
1869 * Get the statistics expressions, and deparse them into text values.
1870 */
1873 tmp = TextDatumGetCString(datum);
1875 pfree(tmp);
1876
1878 statextrec->stxrelid);
1879
1881 {
1885
1887 prettyFlags, 0);
1888
1889 astate = accumArrayResult(astate,
1891 false,
1892 TEXTOID,
1893 CurrentMemoryContext);
1894 }
1895
1897
1899}
References accumArrayResult(), cstring_to_text(), CurrentMemoryContext, deparse_context_for(), deparse_expression_pretty(), fb(), Form_pg_statistic_ext, get_relation_name(), GETSTRUCT(), heap_attisnull(), HeapTupleIsValid, lfirst, makeArrayResult(), NIL, ObjectIdGetDatum(), pfree(), PG_GETARG_OID, PG_RETURN_DATUM, PG_RETURN_NULL, PointerGetDatum(), PRETTYFLAG_INDENT, ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), and TextDatumGetCString.
◆ pg_get_statisticsobjdef_string()
Definition at line 1627 of file ruleutils.c.
References fb(), and pg_get_statisticsobj_worker().
Referenced by RememberStatisticsForRebuilding().
◆ pg_get_triggerdef()
| Datum pg_get_triggerdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 872 of file ruleutils.c.
References fb(), pg_get_triggerdef_worker(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, and string_to_text().
◆ pg_get_triggerdef_ext()
| Datum pg_get_triggerdef_ext | ( | PG_FUNCTION_ARGS | ) |
Definition at line 886 of file ruleutils.c.
References fb(), pg_get_triggerdef_worker(), PG_GETARG_BOOL, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, and string_to_text().
◆ pg_get_triggerdef_worker()
Definition at line 901 of file ruleutils.c.
902{
910 char *tgname;
911 char *tgoldtable;
912 char *tgnewtable;
914 bool isnull;
915
916 /*
917 * Fetch the pg_trigger tuple by the Oid of the trigger
918 */
920
922 Anum_pg_trigger_oid,
925
928
930
932 {
936 }
937
939
940 /*
941 * Start the trigger definition. Note that the trigger's name should never
942 * be schema-qualified, but the trigger rel's name may be.
943 */
945
949 quote_identifier(tgname));
950
957 else
959
961 {
963 findx++;
964 }
966 {
969 else
971 findx++;
972 }
974 {
977 else
979 findx++;
980 /* tgattr is first var-width field, so OK to access directly */
982 {
984
987 {
989
995 }
996 }
997 }
999 {
1002 else
1004 findx++;
1005 }
1006
1007 /*
1008 * In non-pretty mode, always schema-qualify the target table name for
1009 * safety. In pretty mode, schema-qualify only if not visible.
1010 */
1012 pretty ?
1015
1017 {
1026 else
1028 }
1029
1031 tgrel->rd_att, &isnull);
1032 if (!isnull)
1034 else
1035 tgoldtable = NULL;
1037 tgrel->rd_att, &isnull);
1038 if (!isnull)
1040 else
1041 tgnewtable = NULL;
1043 {
1047 quote_identifier(tgoldtable));
1050 quote_identifier(tgnewtable));
1051 }
1052
1055 else
1057
1058 /* If the trigger has a WHEN qualification, add that */
1060 tgrel->rd_att, &isnull);
1061 if (!isnull)
1062 {
1063 Node *qual;
1064 char relkind;
1065 deparse_context context;
1069
1071
1073
1075
1076 /* Build minimal OLD and NEW RTEs for the rel */
1080 oldrte->relkind = relkind;
1087
1091 newrte->relkind = relkind;
1098
1099 /* Build two-element rtable */
1107
1108 /* Set up context with one-deep namespace stack */
1122
1124
1126 }
1127
1132
1134 {
1135 char *p;
1137
1139 tgrel->rd_att, &isnull);
1140 if (isnull)
1144 {
1148 /* advance p to next string embedded in tgargs */
1149 while (*p)
1150 p++;
1151 p++;
1152 }
1153 }
1154
1155 /* We deliberately do not put semi-colon at end */
1157
1158 /* Clean up */
1160
1162
1164}
References AccessShareLock, deparse_context::appendparents, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), attname, BTEqualStrategyNumber, deparse_context::buf, buf, deparse_context::colNamesVisible, DatumGetByteaPP, DatumGetName(), elog, ERROR, fastgetattr(), fb(), Form_pg_trigger, generate_function_name(), generate_qualified_relation_name(), generate_relation_name(), get_attname(), GET_PRETTY_FLAGS, get_rel_relkind(), get_rule_expr(), GETSTRUCT(), HeapTupleIsValid, i, deparse_context::indentLevel, deparse_context::inGroupBy, initStringInfo(), list_make1, list_make2, makeAlias(), makeNode, deparse_context::namespaces, NameStr, NIL, ObjectIdGetDatum(), OidIsValid, deparse_context::prettyFlags, PRETTYINDENT_STD, quote_identifier(), deparse_context::resultDesc, RTE_RELATION, ScanKeyInit(), set_rtable_names(), set_simple_column_names(), simple_quote_literal(), stringToNode(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), deparse_context::targetList, TextDatumGetCString, value, VARDATA_ANY(), deparse_context::varInOrderBy, deparse_context::varprefix, deparse_context::windowClause, WRAP_COLUMN_DEFAULT, and deparse_context::wrapColumn.
Referenced by pg_get_triggerdef(), and pg_get_triggerdef_ext().
◆ pg_get_userbyid()
| Datum pg_get_userbyid | ( | PG_FUNCTION_ARGS | ) |
Definition at line 2795 of file ruleutils.c.
2796{
2798 Name result;
2801
2802 /*
2803 * Allocate space for the result
2804 */
2807
2808 /*
2809 * Get the pg_authid entry and print the result
2810 */
2813 {
2815 *result = role_rec->rolname;
2817 }
2818 else
2820
2821 PG_RETURN_NAME(result);
2822}
References fb(), Form_pg_authid, GETSTRUCT(), HeapTupleIsValid, NAMEDATALEN, NameStr, ObjectIdGetDatum(), palloc(), PG_GETARG_OID, PG_RETURN_NAME, ReleaseSysCache(), SearchSysCache1(), and sprintf.
◆ pg_get_viewdef()
| Datum pg_get_viewdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 679 of file ruleutils.c.
680{
681 /* By OID */
683 int prettyFlags;
684 char *res;
685
686 prettyFlags = PRETTYFLAG_INDENT;
687
689
691 PG_RETURN_NULL();
692
694}
References fb(), pg_get_viewdef_worker(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, PRETTYFLAG_INDENT, string_to_text(), and WRAP_COLUMN_DEFAULT.
◆ pg_get_viewdef_ext()
| Datum pg_get_viewdef_ext | ( | PG_FUNCTION_ARGS | ) |
Definition at line 698 of file ruleutils.c.
699{
700 /* By OID */
703 int prettyFlags;
704 char *res;
705
707
709
711 PG_RETURN_NULL();
712
714}
References fb(), GET_PRETTY_FLAGS, pg_get_viewdef_worker(), PG_GETARG_BOOL, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, string_to_text(), and WRAP_COLUMN_DEFAULT.
◆ pg_get_viewdef_name()
| Datum pg_get_viewdef_name | ( | PG_FUNCTION_ARGS | ) |
Definition at line 737 of file ruleutils.c.
738{
739 /* By qualified name */
741 int prettyFlags;
743 Oid viewoid;
744 char *res;
745
746 prettyFlags = PRETTYFLAG_INDENT;
747
748 /* Look up view name. Can't lock it - we might not have privileges. */
751
753
755 PG_RETURN_NULL();
756
758}
References fb(), makeRangeVarFromNameList(), NoLock, pg_get_viewdef_worker(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, PRETTYFLAG_INDENT, RangeVarGetRelid, string_to_text(), textToQualifiedNameList(), and WRAP_COLUMN_DEFAULT.
◆ pg_get_viewdef_name_ext()
| Datum pg_get_viewdef_name_ext | ( | PG_FUNCTION_ARGS | ) |
Definition at line 762 of file ruleutils.c.
763{
764 /* By qualified name */
767 int prettyFlags;
769 Oid viewoid;
770 char *res;
771
773
774 /* Look up view name. Can't lock it - we might not have privileges. */
777
779
781 PG_RETURN_NULL();
782
784}
References fb(), GET_PRETTY_FLAGS, makeRangeVarFromNameList(), NoLock, pg_get_viewdef_worker(), PG_GETARG_BOOL, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, RangeVarGetRelid, string_to_text(), textToQualifiedNameList(), and WRAP_COLUMN_DEFAULT.
◆ pg_get_viewdef_worker()
Definition at line 790 of file ruleutils.c.
791{
793 char nulls[2];
798
799 /*
800 * Do this first so that string is alloc'd in outer context not SPI's.
801 */
803
804 /*
805 * Connect to SPI manager
806 */
807 SPI_connect();
808
809 /*
810 * On the first call prepare the plan to lookup pg_rewrite. We read
811 * pg_rewrite over the SPI manager instead of using the syscache to be
812 * checked for read access on pg_rewrite.
813 */
815 {
816 Oid argtypes[2];
818
819 argtypes[0] = OIDOID;
820 argtypes[1] = NAMEOID;
826 }
827
828 /*
829 * Get the pg_rewrite tuple for the view's SELECT rule
830 */
833 nulls[0] = ' ';
834 nulls[1] = ' ';
839 {
840 /*
841 * There is no tuple data available here, just keep the output buffer
842 * empty.
843 */
844 }
845 else
846 {
847 /*
848 * Get the rule's definition and put it into executor's memory
849 */
853 }
854
855 /*
856 * Disconnect from SPI manager
857 */
860
863
865}
References buf, CStringGetDatum(), DirectFunctionCall1, elog, ERROR, fb(), initStringInfo(), make_viewdef(), namein(), ObjectIdGetDatum(), plan, plan_getviewrule, query_getviewrule, SPI_connect(), SPI_execute_plan(), SPI_finish(), SPI_keepplan(), SPI_OK_FINISH, SPI_OK_SELECT, SPI_prepare(), SPI_processed, SPI_tuptable, SPITupleTable::tupdesc, SPITupleTable::vals, and ViewSelectRuleName.
Referenced by pg_get_viewdef(), pg_get_viewdef_ext(), pg_get_viewdef_name(), pg_get_viewdef_name_ext(), and pg_get_viewdef_wrap().
◆ pg_get_viewdef_wrap()
| Datum pg_get_viewdef_wrap | ( | PG_FUNCTION_ARGS | ) |
Definition at line 717 of file ruleutils.c.
718{
719 /* By OID */
722 int prettyFlags;
723 char *res;
724
725 /* calling this implies we want pretty printing */
727
729
731 PG_RETURN_NULL();
732
734}
References fb(), GET_PRETTY_FLAGS, pg_get_viewdef_worker(), PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, and string_to_text().
◆ pop_ancestor_plan()
|
static |
Definition at line 5335 of file ruleutils.c.
5336{
5337 /* Free the ancestor list made in push_ancestor_plan */
5339
5340 /* Restore fields changed by push_ancestor_plan */
5342}
References fb(), and list_free().
Referenced by get_name_for_var_field(), and get_parameter().
◆ pop_child_plan()
|
static |
Definition at line 5284 of file ruleutils.c.
5285{
5286 List *ancestors;
5287
5288 /* Get rid of ancestors list cell added by push_child_plan */
5290
5291 /* Restore fields changed by push_child_plan */
5293
5294 /* Make sure dpns->ancestors is right (may be unnecessary) */
5295 dpns->ancestors = ancestors;
5296}
References fb(), and list_delete_first().
Referenced by get_name_for_var_field(), get_variable(), and resolve_special_varno().
◆ print_function_arguments()
|
static |
Definition at line 3302 of file ruleutils.c.
3304{
3306 int numargs;
3307 Oid *argtypes;
3308 char **argnames;
3317
3319 &argtypes, &argnames, &argmodes);
3320
3321 nlackdefaults = numargs;
3323 {
3325 bool isnull;
3326
3329 &isnull);
3330 if (!isnull)
3331 {
3333
3338 /* nlackdefaults counts only *input* arguments lacking defaults */
3340 }
3341 }
3342
3343 /* Check for special treatment of ordered-set aggregates */
3345 {
3348
3352 proc->oid);
3357 }
3358
3359 argsprinted = 0;
3360 inputargno = 0;
3362 {
3368
3370 {
3372
3373 /*
3374 * For procedures, explicitly mark all argument modes, so as
3375 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3376 */
3379 else
3382 break;
3386 break;
3390 break;
3394 break;
3398 break;
3399 default:
3403 break;
3404 }
3407
3409 continue;
3410
3412 {
3416 }
3419
3421 if (argname && argname[0])
3425 {
3426 Node *expr;
3427
3431
3434 }
3435 argsprinted++;
3436
3437 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3439 {
3440 i--;
3441 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3443 }
3444 }
3445
3447}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, buf, castNode, deparse_expression(), elog, ERROR, fb(), Form_pg_aggregate, Form_pg_proc, format_type_be(), get_func_arg_info(), GETSTRUCT(), HeapTupleIsValid, i, lfirst, list_head(), list_length(), lnext(), NIL, ObjectIdGetDatum(), pfree(), quote_identifier(), ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttr(), and TextDatumGetCString.
Referenced by pg_get_function_arguments(), pg_get_function_identity_arguments(), pg_get_functiondef(), and print_function_rettype().
◆ print_function_rettype()
|
static |
Definition at line 3264 of file ruleutils.c.
3265{
3269
3271
3272 if (proc->proretset)
3273 {
3274 /* It might be a table function; try to print the arguments */
3279 else
3281 }
3282
3284 {
3285 /* Not a table function, so do the normal thing */
3286 if (proc->proretset)
3289 }
3290
3292}
References appendBinaryStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, fb(), Form_pg_proc, format_type_be(), GETSTRUCT(), initStringInfo(), print_function_arguments(), and resetStringInfo().
Referenced by pg_get_function_result(), and pg_get_functiondef().
◆ print_function_sqlbody()
|
static |
Definition at line 3560 of file ruleutils.c.
3561{
3562 int numargs;
3563 Oid *argtypes;
3564 char **argnames;
3567 Datum tmp;
3568 Node *n;
3569
3572 &argtypes, &argnames, &argmodes);
3573 dpns.numargs = numargs;
3574 dpns.argnames = argnames;
3575
3578
3580 {
3581 List *stmts;
3583
3585
3587
3589 {
3591
3592 /* It seems advisable to get at least AccessShareLock on rels */
3598 }
3599
3601 }
3602 else
3603 {
3605
3606 /* It seems advisable to get at least AccessShareLock on rels */
3609 0, WRAP_COLUMN_DEFAULT, 0);
3610 }
3611}
References AcquireRewriteLocks(), appendStringInfoChar(), appendStringInfoString(), buf, castNode, fb(), Form_pg_proc, get_func_arg_info(), get_query_def(), GETSTRUCT(), IsA, lfirst_node, linitial, list_make1, NameStr, PRETTYFLAG_INDENT, proname, pstrdup(), stringToNode(), SysCacheGetAttrNotNull(), TextDatumGetCString, and WRAP_COLUMN_DEFAULT.
Referenced by pg_get_function_sqlbody(), and pg_get_functiondef().
◆ print_function_trftypes()
|
static |
Definition at line 3462 of file ruleutils.c.
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, fb(), format_type_be(), get_func_trftypes(), and i.
Referenced by pg_get_functiondef().
◆ printSubscripts()
|
static |
Definition at line 13049 of file ruleutils.c.
13050{
13054
13057 {
13060 {
13061 /* If subexpression is NULL, get_rule_expr prints nothing */
13065 }
13066 /* If subexpression is NULL, get_rule_expr prints nothing */
13069 }
13070}
References appendStringInfoChar(), deparse_context::buf, buf, fb(), get_rule_expr(), lfirst, list_head(), lnext(), SubscriptingRef::reflowerindexpr, and SubscriptingRef::refupperindexpr.
Referenced by get_rule_expr(), and processIndirection().
◆ processIndirection()
|
static |
Definition at line 12971 of file ruleutils.c.
12972{
12975
12976 for (;;)
12977 {
12979 break;
12981 {
12983 Oid typrelid;
12984 char *fieldname;
12985
12986 /* lookup tuple type */
12987 typrelid = get_typ_typrelid(fstore->resulttype);
12990 format_type_be(fstore->resulttype));
12991
12992 /*
12993 * Print the field name. There should only be one target field in
12994 * stored rules. There could be more than that in executable
12995 * target lists, but this function cannot be used for that case.
12996 */
12998 fieldname = get_attname(typrelid,
13001
13002 /*
13003 * We ignore arg since it should be an uninteresting reference to
13004 * the target column or subcolumn.
13005 */
13007 }
13009 {
13011
13013 break;
13014
13015 printSubscripts(sbsref, context);
13016
13017 /*
13018 * We ignore refexpr since it should be an uninteresting reference
13019 * to the target column or subcolumn.
13020 */
13022 }
13024 {
13026 /* If it's an explicit domain coercion, we're done */
13028 break;
13029 /* Tentatively descend past the CoerceToDomain */
13031 }
13032 else
13033 break;
13034 }
13035
13036 /*
13037 * If we descended past a CoerceToDomain whose argument turned out not to
13038 * be a FieldStore or array assignment, back up to the CoerceToDomain.
13039 * (This is not enough to be fully correct if there are nested implicit
13040 * CoerceToDomains, but such cases shouldn't ever occur.)
13041 */
13044
13045 return node;
13046}
References appendStringInfo(), Assert, deparse_context::buf, buf, COERCE_IMPLICIT_CAST, elog, ERROR, fb(), format_type_be(), get_attname(), get_typ_typrelid(), IsA, linitial, linitial_int, list_length(), FieldStore::newvals, OidIsValid, printSubscripts(), quote_identifier(), and SubscriptingRef::refassgnexpr.
Referenced by get_insert_query_def(), get_merge_query_def(), get_rule_expr(), and get_update_query_targetlist_def().
◆ push_ancestor_plan()
|
static |
Definition at line 5314 of file ruleutils.c.
5316{
5318
5319 /* Save state for restoration later */
5321
5322 /* Build a new ancestor list with just this node's ancestors */
5323 dpns->ancestors =
5326
5327 /* Set attention on selected ancestor */
5329}
References fb(), lfirst, list_cell_number(), list_copy_tail(), plan, and set_deparse_plan().
Referenced by get_name_for_var_field(), and get_parameter().
◆ push_child_plan()
|
static |
Definition at line 5267 of file ruleutils.c.
5269{
5270 /* Save state for restoration later */
5272
5273 /* Link current plan node into ancestors list */
5275
5276 /* Set attention on selected child */
5278}
References fb(), lcons(), plan, and set_deparse_plan().
Referenced by get_name_for_var_field(), get_variable(), and resolve_special_varno().
◆ quote_identifier()
Definition at line 13079 of file ruleutils.c.
13080{
13081 /*
13082 * Can avoid quoting if ident starts with a lowercase letter or underscore
13083 * and contains only lowercase letters, digits, and underscores, *and* is
13084 * not any SQL keyword. Otherwise, supply quotes.
13085 */
13088 const char *ptr;
13089 char *result;
13091
13092 /*
13093 * would like to use <ctype.h> macros here, but they might yield unwanted
13094 * locale-specific results...
13095 */
13097
13099 {
13101
13105 {
13106 /* okay */
13107 }
13108 else
13109 {
13112 nquotes++;
13113 }
13114 }
13115
13118
13120 {
13121 /*
13122 * Check for keyword. We quote keywords except for unreserved ones.
13123 * (In some cases we could avoid quoting a col_name or type_func_name
13124 * keyword, but it seems much harder than it's worth to tell that.)
13125 *
13126 * Note: ScanKeywordLookup() does case-insensitive comparison, but
13127 * that's fine, since we already know we have all-lower-case.
13128 */
13130
13133 }
13134
13137
13139
13140 optr = result;
13143 {
13145
13149 }
13152
13153 return result;
13154}
References fb(), ident, palloc(), quote_all_identifiers, ScanKeywordCategories, ScanKeywordLookup(), ScanKeywords, and UNRESERVED_KEYWORD.
Referenced by add_cast_to(), appendFunctionName(), ATPrepAlterColumnType(), CheckMyDatabase(), copy_table(), createdb(), CreateSchemaCommand(), decompile_column_index_array(), deparseAnalyzeSql(), deparseColumnRef(), deparseOperatorName(), deparseRelation(), execute_extension_script(), ExplainIndexScanDetails(), ExplainNode(), ExplainTargetRel(), flatten_set_variable_args(), format_operator_extended(), generate_operator_clause(), generate_operator_name(), get_column_alias_list(), get_from_clause_coldeflist(), get_from_clause_item(), get_insert_query_def(), get_json_table(), get_json_table_columns(), get_json_table_nested_columns(), get_merge_query_def(), get_opclass_name(), get_parameter(), get_reloptions(), get_returning_clause(), get_rte_alias(), get_rule_expr(), get_rule_windowclause(), get_rule_windowspec(), get_select_query_def(), get_target_list(), get_update_query_targetlist_def(), get_utility_query_def(), get_variable(), get_windowfunc_expr_helper(), get_with_clause(), get_xmltable(), getObjectIdentityParts(), libpqrcv_alter_slot(), make_ruledef(), NameListToQuotedString(), old_9_6_invalidate_hash_indexes(), overexplain_alias(), overexplain_range_table(), pg_get_constraintdef_worker(), pg_get_functiondef(), pg_get_indexdef_worker(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), pg_get_triggerdef_worker(), pg_identify_object(), PLy_quote_ident(), postgresExplainForeignScan(), postgresImportForeignSchema(), print_function_arguments(), process_extension_updates(), processIndirection(), quote_ident(), quote_object_name(), quote_qualified_identifier(), regdatabaseout(), regnamespaceout(), regoperout(), regroleout(), ReplicationSlotDropAtPubNode(), sepgsql_attribute_post_create(), sepgsql_database_post_create(), sepgsql_relation_post_create(), sepgsql_schema_post_create(), serialize_deflist(), set_frozenxids(), show_sortorder_options(), show_window_def(), test_inline_in_from_support_func(), text_format_string_conversion(), tuple_to_stringinfo(), and worker_spi_main().
◆ quote_qualified_identifier()
Definition at line 13163 of file ruleutils.c.
13165{
13167
13173}
References appendStringInfo(), appendStringInfoString(), buf, fb(), ident, initStringInfo(), and quote_identifier().
Referenced by check_default_text_search_config(), copy_table(), create_pg_locale(), format_procedure_extended(), format_type_extended(), generate_collation_name(), generate_function_name(), generate_qualified_relation_name(), generate_qualified_type_name(), generate_relation_name(), generate_relation_name(), getObjectDescription(), getObjectIdentityParts(), getOpFamilyDescription(), getOpFamilyIdentity(), getRelationDescription(), getRelationIdentity(), pg_decode_change(), pg_decode_truncate(), pg_get_functiondef(), pg_get_statisticsobj_worker(), refresh_by_match_merge(), RefreshMatViewByOid(), regclassout(), regcollationout(), regconfigout(), regdictionaryout(), regprocout(), sepgsql_proc_post_create(), and transformColumnDefinition().
◆ removeStringInfoSpaces()
|
static |
Definition at line 9168 of file ruleutils.c.
9169{
9172}
References str.
Referenced by appendContextKeyword(), get_from_clause(), and get_target_list().
◆ resolve_special_varno()
|
static |
Definition at line 7933 of file ruleutils.c.
7935{
7936 Var *var;
7938
7939 /* This function is recursive, so let's be paranoid. */
7940 check_stack_depth();
7941
7942 /* If it's not a Var, invoke the callback. */
7944 {
7945 (*callback) (node, context, callback_arg);
7946 return;
7947 }
7948
7949 /* Find appropriate nesting depth */
7950 var = (Var *) node;
7952 var->varlevelsup);
7953
7954 /*
7955 * If varno is special, recurse. (Don't worry about varnosyn; if we're
7956 * here, we already decided not to use that.)
7957 */
7959 {
7963
7967
7968 /*
7969 * If we're descending to the first child of an Append or MergeAppend,
7970 * update appendparents. This will affect deparsing of all Vars
7971 * appearing within the eventually-resolved subexpression.
7972 */
7974
7981
7984 callback, callback_arg);
7987 return;
7988 }
7990 {
7993
7997
8000 callback, callback_arg);
8002 return;
8003 }
8005 {
8007
8011
8013 callback, callback_arg);
8014 return;
8015 }
8018
8019 /* Not special. Just invoke the callback. */
8020 (*callback) (node, context, callback_arg);
8021}
References deparse_context::appendparents, bms_union(), callback(), check_stack_depth(), elog, ERROR, fb(), get_tle_by_resno(), INDEX_VAR, INNER_VAR, IsA, list_length(), list_nth(), deparse_context::namespaces, OUTER_VAR, pop_child_plan(), push_child_plan(), resolve_special_varno(), Var::varattno, Var::varlevelsup, and Var::varno.
Referenced by get_agg_expr_helper(), get_variable(), and resolve_special_varno().
◆ select_rtable_names_for_explain()
Definition at line 3859 of file ruleutils.c.
3860{
3862
3864 dpns.rtable = rtable;
3869 /* We needn't bother computing column aliases yet */
3870
3872}
References fb(), NIL, and set_rtable_names().
Referenced by ExplainPrintPlan().
◆ set_deparse_context_plan()
Definition at line 3829 of file ruleutils.c.
3830{
3832
3833 /* Should always have one-entry namespace list for Plan deparsing */
3836
3837 /* Set our attention on the specific plan node passed in */
3838 dpns->ancestors = ancestors;
3840
3841 /* For ModifyTable, set aliases for OLD and NEW in RETURNING */
3843 {
3846 }
3847
3849}
References Assert, fb(), IsA, linitial, list_length(), plan, and set_deparse_plan().
Referenced by show_expression(), show_grouping_sets(), show_memoize_info(), show_plan_tlist(), show_sort_group_keys(), show_tablesample(), show_window_def(), and show_window_keys().
◆ set_deparse_for_query()
|
static |
Definition at line 4033 of file ruleutils.c.
4035{
4038
4039 /* Initialize *dpns and fill rtable/ctes links */
4045 dpns->ret_old_alias = query->returningOldAlias;
4046 dpns->ret_new_alias = query->returningNewAlias;
4047
4048 /* Assign a unique relation alias to each RTE */
4050
4051 /* Initialize dpns->rtable_columns to contain zeroed structs */
4056
4057 /* If it's a utility query, it won't have a jointree */
4059 {
4060 /* Detect whether global uniqueness of USING names is needed */
4061 dpns->unique_using =
4063
4064 /*
4065 * Select names for columns merged by USING, via a recursive pass over
4066 * the query jointree.
4067 */
4069 }
4070
4071 /*
4072 * Now assign remaining column aliases for each RTE. We do this in a
4073 * linear scan of the rtable, so as to process RTEs whether or not they
4074 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4075 * etc). JOIN RTEs must be processed after their children, but this is
4076 * okay because they appear later in the rtable list than their children
4077 * (cf Asserts in identify_join_columns()).
4078 */
4080 {
4083
4086 else
4088 }
4089}
References Query::cteList, fb(), forboth, has_dangerous_join_using(), Query::jointree, lappend(), lfirst, list_length(), NIL, palloc0(), Query::rtable, RTE_JOIN, set_join_column_names(), set_relation_column_names(), set_rtable_names(), and set_using_names().
Referenced by get_name_for_var_field(), get_query_def(), and make_ruledef().
◆ set_deparse_plan()
|
static |
Definition at line 5156 of file ruleutils.c.
5157{
5159
5160 /*
5161 * We special-case Append and MergeAppend to pretend that the first child
5162 * plan is the OUTER referent; we have to interpret OUTER Vars in their
5163 * tlists according to one of the children, and the first one is the most
5164 * natural choice.
5165 */
5170 else
5172
5175 else
5177
5178 /*
5179 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
5180 * use OUTER because that could someday conflict with the normal meaning.)
5181 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
5182 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
5183 * that as INNER referent.
5184 *
5185 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
5186 * INNER referent. This is the join from the target relation to the data
5187 * source, and all INNER_VAR Vars in other parts of the query refer to its
5188 * targetlist.
5189 *
5190 * For ON CONFLICT DO SELECT/UPDATE we just need the inner tlist to point
5191 * to the excluded expression's tlist. (Similar to the SubqueryScan we
5192 * don't want to reuse OUTER, it's used for RETURNING in some modify table
5193 * cases, although not INSERT .. CONFLICT).
5194 */
5204 {
5207 else
5209 }
5210 else
5212
5217 else
5219
5220 /* Set up referent for INDEX_VAR Vars, if needed */
5227 else
5229}
References CMD_INSERT, CMD_MERGE, fb(), find_recursive_union(), innerPlan, IsA, linitial, list_nth(), NIL, outerPlan, and plan.
Referenced by push_ancestor_plan(), push_child_plan(), and set_deparse_context_plan().
◆ set_join_column_names()
|
static |
Definition at line 4582 of file ruleutils.c.
4584{
4596
4597 /* Look up the previously-filled-in child deparse_columns structs */
4600
4601 /*
4602 * Ensure colinfo->colnames has a slot for each column. (It could be long
4603 * enough already, if we pushed down a name for the last column.) Note:
4604 * it's possible that one or both inputs now have more columns than there
4605 * were when the query was parsed, but we'll deal with that below. We
4606 * only need entries in colnames for pre-existing columns.
4607 */
4611
4612 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4614
4615 /*
4616 * Scan the join output columns, select an alias for each one, and store
4617 * it in colinfo->colnames. If there are USING columns, set_using_names()
4618 * already selected their names, so we can start the loop at the first
4619 * non-merged column.
4620 */
4623 {
4626
4627 /* Join column must refer to at least one input column */
4629
4630 /* Get the child column name */
4635 else
4636 {
4637 /* We're joining system columns --- use eref name */
4639 }
4640
4641 /* If child col has been dropped, no need to assign a join colname */
4643 {
4645 continue;
4646 }
4647
4648 /* In an unnamed join, just report child column names as-is */
4650 {
4653 continue;
4654 }
4655
4656 /* If alias already assigned, that's what to use */
4658 {
4659 /* If user wrote an alias, prefer that over real column name */
4662 else
4663 colname = real_colname;
4664
4665 /* Unique-ify and insert into colinfo */
4667
4670 }
4671
4672 /* Remember if any assigned aliases differ from "real" name */
4675 }
4676
4677 /*
4678 * Calculate number of columns the join would have if it were re-parsed
4679 * now, and create storage for the new_colnames and is_new_col arrays.
4680 *
4681 * Note: colname_is_unique will be consulting new_colnames[] during the
4682 * loops below, so its not-yet-filled entries must be zeroes.
4683 */
4689
4690 /*
4691 * Generating the new_colnames array is a bit tricky since any new columns
4692 * added since parse time must be inserted in the right places. This code
4693 * must match the parser, which will order a join's columns as merged
4694 * columns first (in USING-clause order), then non-merged columns from the
4695 * left input (in attnum order), then non-merged columns from the right
4696 * input (ditto). If one of the inputs is itself a join, its columns will
4697 * be ordered according to the same rule, which means newly-added columns
4698 * might not be at the end. We can figure out what's what by consulting
4699 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
4700 *
4701 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
4702 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
4703 * meanings for the current child RTE.
4704 */
4705
4706 /* Handle merged columns; they are first and can't be new */
4711 {
4712 /* column name is already determined and known unique */
4715
4716 /* build bitmapsets of child attnums of merged columns */
4721
4723 }
4724
4725 /* Handle non-merged left-child columns */
4726 ic = 0;
4728 {
4730
4732 {
4733 /* Advance ic to next non-dropped old column of left child */
4736 ic++;
4738 ic++;
4739 /* If it is a merged column, we already processed it */
4741 continue;
4742 /* Else, advance i to the corresponding existing join column */
4745 i++;
4748 /* Use the already-assigned name of this column */
4750 i++;
4751 }
4752 else
4753 {
4754 /*
4755 * Unique-ify the new child column name and assign, unless we're
4756 * in an unnamed join, in which case just copy
4757 */
4759 {
4765 }
4766 else
4769 }
4770
4772 j++;
4773 }
4774
4775 /* Handle non-merged right-child columns in exactly the same way */
4776 ic = 0;
4778 {
4780
4782 {
4783 /* Advance ic to next non-dropped old column of right child */
4786 ic++;
4788 ic++;
4789 /* If it is a merged column, we already processed it */
4791 continue;
4792 /* Else, advance i to the corresponding existing join column */
4795 i++;
4798 /* Use the already-assigned name of this column */
4800 i++;
4801 }
4802 else
4803 {
4804 /*
4805 * Unique-ify the new child column name and assign, unless we're
4806 * in an unnamed join, in which case just copy
4807 */
4809 {
4815 }
4816 else
4819 }
4820
4822 j++;
4823 }
4824
4825 /* Assert we processed the right number of columns */
4826#ifdef USE_ASSERT_CHECKING
4828 i++;
4831#endif
4832
4833 /* We're now done needing the colinfo's names_hash */
4835
4836 /*
4837 * For a named join, print column aliases if we changed any from the child
4838 * names. Unnamed joins cannot print aliases.
4839 */
4842 else
4844}
References add_to_names_hash(), Assert, bms_add_member(), bms_is_member(), build_colinfo_names_hash(), deparse_columns_fetch, destroy_colinfo_names_hash(), expand_colnames_array_to(), fb(), i, j, list_length(), list_nth(), make_colname_unique(), palloc0(), and strVal.
Referenced by set_deparse_for_query().
◆ set_relation_column_names()
|
static |
Definition at line 4379 of file ruleutils.c.
4381{
4382 int ncolumns;
4388
4389 /*
4390 * Construct an array of the current "real" column names of the RTE.
4391 * real_colnames[] will be indexed by physical column number, with NULL
4392 * entries for dropped columns.
4393 */
4395 {
4396 /* Relation --- look to the system catalogs for up-to-date info */
4397 Relation rel;
4398 TupleDesc tupdesc;
4399
4401 tupdesc = RelationGetDescr(rel);
4402
4403 ncolumns = tupdesc->natts;
4405
4407 {
4409
4410 if (attr->attisdropped)
4412 else
4414 }
4416 }
4417 else
4418 {
4419 /* Otherwise get the column names from eref or expandRTE() */
4420 List *colnames;
4422
4423 /*
4424 * Functions returning composites have the annoying property that some
4425 * of the composite type's columns might have been dropped since the
4426 * query was parsed. If possible, use expandRTE() to handle that
4427 * case, since it has the tedious logic needed to find out about
4428 * dropped columns. However, if we're explaining a plan, then we
4429 * don't have rte->functions because the planner thinks that won't be
4430 * needed later, and that breaks expandRTE(). So in that case we have
4431 * to rely on rte->eref, which may lead us to report a dropped
4432 * column's old name; that seems close enough for EXPLAIN's purposes.
4433 *
4434 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4435 * which should be sufficiently up-to-date: no other RTE types can
4436 * have columns get dropped from under them after parsing.
4437 */
4439 {
4440 /* Since we're not creating Vars, rtindex etc. don't matter */
4443 }
4444 else
4445 colnames = rte->eref->colnames;
4446
4447 ncolumns = list_length(colnames);
4449
4450 i = 0;
4452 {
4453 /*
4454 * If the column name we find here is an empty string, then it's a
4455 * dropped column, so change to NULL.
4456 */
4458
4462 i++;
4463 }
4464 }
4465
4466 /*
4467 * Ensure colinfo->colnames has a slot for each column. (It could be long
4468 * enough already, if we pushed down a name for the last column.) Note:
4469 * it's possible that there are now more columns than there were when the
4470 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4471 * We must assign unique aliases to the new columns too, else there could
4472 * be unresolved conflicts when the view/rule is reloaded.
4473 */
4476
4477 /*
4478 * Make sufficiently large new_colnames and is_new_col arrays, too.
4479 *
4480 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4481 * colname_is_unique will not consult that array, which is fine because it
4482 * would only be duplicate effort.
4483 */
4486
4487 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4489
4490 /*
4491 * Scan the columns, select a unique alias for each one, and store it in
4492 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4493 * entries for dropped columns, the latter omits them. Also mark
4494 * new_colnames entries as to whether they are new since parse time; this
4495 * is the case for entries beyond the length of rte->eref->colnames.
4496 */
4499 j = 0;
4501 {
4504
4505 /* Skip dropped columns */
4507 {
4509 continue;
4510 }
4511
4512 /* If alias already assigned, that's what to use */
4514 {
4515 /* If user wrote an alias, prefer that over real column name */
4518 else
4519 colname = real_colname;
4520
4521 /* Unique-ify and insert into colinfo */
4523
4526 }
4527
4528 /* Put names of non-dropped columns in new_colnames[] too */
4530 /* And mark them as new or not */
4532 j++;
4533
4534 /* Remember if any assigned aliases differ from "real" name */
4537 }
4538
4539 /* We're now done needing the colinfo's names_hash */
4541
4542 /*
4543 * Set correct length for new_colnames[] array. (Note: if columns have
4544 * been added, colinfo->num_cols includes them, which is not really quite
4545 * right but is harmless, since any new columns must be at the end where
4546 * they won't affect varattnos of pre-existing columns.)
4547 */
4549
4550 /*
4551 * For a relation RTE, we need only print the alias column names if any
4552 * are different from the underlying "real" names. For a function RTE,
4553 * always emit a complete column alias list; this is to protect against
4554 * possible instability of the default column names (eg, from altering
4555 * parameter names). For tablefunc RTEs, we never print aliases, because
4556 * the column names are part of the clause itself. For other RTE types,
4557 * print if we changed anything OR if there were user-written column
4558 * aliases (since the latter would be part of the underlying "reality").
4559 */
4568 else
4570}
References AccessShareLock, add_to_names_hash(), Assert, build_colinfo_names_hash(), destroy_colinfo_names_hash(), expand_colnames_array_to(), expandRTE(), fb(), i, j, lfirst, list_length(), list_nth(), make_colname_unique(), NameStr, TupleDescData::natts, NIL, palloc(), pstrdup(), relation_close(), relation_open(), RelationGetDescr, RTE_FUNCTION, RTE_RELATION, RTE_TABLEFUNC, strVal, TupleDescAttr(), and VAR_RETURNING_DEFAULT.
Referenced by set_deparse_for_query(), and set_simple_column_names().
◆ set_rtable_names()
|
static |
Definition at line 3888 of file ruleutils.c.
3890{
3892 HTAB *names_hash;
3894 bool found;
3895 int rtindex;
3897
3899 /* nothing more to do if empty rtable */
3901 return;
3902
3903 /*
3904 * We use a hash table to hold known names, so that this process is O(N)
3905 * not O(N^2) for N names.
3906 */
3912 &hash_ctl,
3914
3915 /* Preload the hash table with names appearing in parent_namespaces */
3917 {
3920
3922 {
3924
3926 continue;
3928 oldname,
3929 HASH_ENTER,
3930 &found);
3931 /* we do not complain about duplicate names in parent namespaces */
3932 hentry->counter = 0;
3933 }
3934 }
3935
3936 /* Now we can scan the rtable */
3937 rtindex = 1;
3939 {
3941 char *refname;
3942
3943 /* Just in case this takes an unreasonable amount of time ... */
3944 CHECK_FOR_INTERRUPTS();
3945
3947 {
3948 /* Ignore unreferenced RTE */
3949 refname = NULL;
3950 }
3952 {
3953 /* If RTE has a user-defined alias, prefer that */
3954 refname = rte->alias->aliasname;
3955 }
3957 {
3958 /* Use the current actual name of the relation */
3960 }
3962 {
3963 /* Unnamed join has no refname */
3964 refname = NULL;
3965 }
3966 else
3967 {
3968 /* Otherwise use whatever the parser assigned */
3969 refname = rte->eref->aliasname;
3970 }
3971
3972 /*
3973 * If the selected name isn't unique, append digits to make it so, and
3974 * make a new hash entry for it once we've got a unique name. For a
3975 * very long input name, we might have to truncate to stay within
3976 * NAMEDATALEN.
3977 */
3978 if (refname)
3979 {
3981 refname,
3982 HASH_ENTER,
3983 &found);
3984 if (found)
3985 {
3986 /* Name already in use, must choose a new one */
3990
3991 do
3992 {
3994 for (;;)
3995 {
3999 break;
4000 /* drop chars from refname to keep all the digits */
4002 refnamelen - 1);
4003 }
4005 modname,
4006 HASH_ENTER,
4007 &found);
4008 } while (found);
4010 refname = modname;
4011 }
4012 else
4013 {
4014 /* Name not previously used, need only initialize hentry */
4015 hentry->counter = 0;
4016 }
4017 }
4018
4020 rtindex++;
4021 }
4022
4023 hash_destroy(names_hash);
4024}
References bms_is_member(), CHECK_FOR_INTERRUPTS, NameHashEntry::counter, CurrentMemoryContext, fb(), get_rel_name(), HASH_CONTEXT, hash_create(), hash_destroy(), HASH_ELEM, HASH_ENTER, hash_search(), HASH_STRINGS, lappend(), lfirst, list_length(), NAMEDATALEN, NIL, palloc(), pg_mbcliplen(), RTE_JOIN, RTE_RELATION, and sprintf.
Referenced by deparse_context_for(), pg_get_triggerdef_worker(), select_rtable_names_for_explain(), and set_deparse_for_query().
◆ set_simple_column_names()
|
static |
Definition at line 4102 of file ruleutils.c.
4103{
4106
4107 /* Initialize dpns->rtable_columns to contain zeroed structs */
4112
4113 /* Assign unique column aliases within each non-join RTE */
4115 {
4118
4121 }
4122}
References fb(), forboth, lappend(), lfirst, list_length(), NIL, palloc0(), RTE_JOIN, and set_relation_column_names().
Referenced by deparse_context_for(), deparse_context_for_plan_tree(), and pg_get_triggerdef_worker().
◆ set_using_names()
|
static |
Definition at line 4214 of file ruleutils.c.
4215{
4217 {
4218 /* nothing to do now */
4219 }
4221 {
4224
4227 }
4229 {
4233 int *leftattnos;
4234 int *rightattnos;
4239
4240 /* Get info about the shape of the join */
4242 leftattnos = colinfo->leftattnos;
4243 rightattnos = colinfo->rightattnos;
4244
4245 /* Look up the not-yet-filled-in child deparse_columns structs */
4248
4249 /*
4250 * If this join is unnamed, then we cannot substitute new aliases at
4251 * this level, so any name requirements pushed down to here must be
4252 * pushed down again to the children.
4253 */
4255 {
4257 {
4259
4261 continue;
4262
4263 /* Push down to left column, unless it's a system column */
4265 {
4268 }
4269
4270 /* Same on the righthand side */
4272 {
4275 }
4276 }
4277 }
4278
4279 /*
4280 * If there's a USING clause, select the USING column names and push
4281 * those names down to the children. We have two strategies:
4282 *
4283 * If dpns->unique_using is true, we force all USING names to be
4284 * unique across the whole query level. In principle we'd only need
4285 * the names of dangerous USING columns to be globally unique, but to
4286 * safely assign all USING names in a single pass, we have to enforce
4287 * the same uniqueness rule for all of them. However, if a USING
4288 * column's name has been pushed down from the parent, we should use
4289 * it as-is rather than making a uniqueness adjustment. This is
4290 * necessary when we're at an unnamed join, and it creates no risk of
4291 * ambiguity. Also, if there's a user-written output alias for a
4292 * merged column, we prefer to use that rather than the input name;
4293 * this simplifies the logic and seems likely to lead to less aliasing
4294 * overall.
4295 *
4296 * If dpns->unique_using is false, we only need USING names to be
4297 * unique within their own join RTE. We still need to honor
4298 * pushed-down names, though.
4299 *
4300 * Though significantly different in results, these two strategies are
4301 * implemented by the same code, with only the difference of whether
4302 * to put assigned names into dpns->using_names.
4303 */
4305 {
4306 /* Copy the input parentUsing list so we don't modify it */
4307 parentUsing = list_copy(parentUsing);
4308
4309 /* USING names must correspond to the first join output columns */
4311 i = 0;
4313 {
4315
4316 /* Assert it's a merged column */
4318
4319 /* Adopt passed-down name if any, else select unique name */
4322 else
4323 {
4324 /* Prefer user-written output alias if any */
4327 /* Make it appropriately unique */
4331 colname);
4332 /* Save it as output column name, too */
4334 }
4335
4336 /* Remember selected names for use later */
4338 parentUsing = lappend(parentUsing, colname);
4339
4340 /* Push down to left column, unless it's a system column */
4342 {
4345 }
4346
4347 /* Same on the righthand side */
4349 {
4352 }
4353
4354 i++;
4355 }
4356 }
4357
4358 /* Mark child deparse_columns structs with correct parentUsing info */
4359 leftcolinfo->parentUsing = parentUsing;
4360 rightcolinfo->parentUsing = parentUsing;
4361
4362 /* Now recursively assign USING column names in children */
4365 }
4366 else
4369}
References Assert, deparse_columns_fetch, elog, ERROR, expand_colnames_array_to(), fb(), FromExpr::fromlist, i, identify_join_columns(), IsA, j, lappend(), lfirst, list_copy(), list_length(), list_nth(), make_colname_unique(), nodeTag, rt_fetch, set_using_names(), and strVal.
Referenced by set_deparse_for_query(), and set_using_names().
◆ simple_quote_literal()
|
static |
Definition at line 11845 of file ruleutils.c.
11846{
11848
11849 /*
11850 * We always form the string literal according to standard SQL rules.
11851 */
11854 {
11856
11860 }
11862}
References appendStringInfoChar(), buf, fb(), SQL_STR_DOUBLE, and val.
Referenced by get_const_expr(), get_reloptions(), get_rule_expr(), get_utility_query_def(), pg_get_functiondef(), and pg_get_triggerdef_worker().
◆ string_to_text()
Definition at line 13627 of file ruleutils.c.
References cstring_to_text(), pfree(), and str.
Referenced by pg_get_constraintdef(), pg_get_constraintdef_ext(), pg_get_expr_worker(), pg_get_function_arg_default(), pg_get_function_arguments(), pg_get_function_identity_arguments(), pg_get_function_result(), pg_get_functiondef(), pg_get_indexdef(), pg_get_indexdef_ext(), pg_get_partition_constraintdef(), pg_get_partkeydef(), pg_get_ruledef(), pg_get_ruledef_ext(), pg_get_serial_sequence(), pg_get_statisticsobjdef(), pg_get_statisticsobjdef_columns(), pg_get_triggerdef(), pg_get_triggerdef_ext(), pg_get_viewdef(), pg_get_viewdef_ext(), pg_get_viewdef_name(), pg_get_viewdef_name_ext(), and pg_get_viewdef_wrap().
Variable Documentation
◆ plan_getrulebyoid
|
static |
Definition at line 333 of file ruleutils.c.
Referenced by pg_get_ruledef_worker().
◆ plan_getviewrule
|
static |
Definition at line 335 of file ruleutils.c.
Referenced by pg_get_viewdef_worker().
◆ query_getrulebyoid
Definition at line 334 of file ruleutils.c.
Referenced by pg_get_ruledef_worker().
◆ query_getviewrule
|
static |
Definition at line 336 of file ruleutils.c.
Referenced by pg_get_viewdef_worker().
◆ quote_all_identifiers
Definition at line 339 of file ruleutils.c.
Referenced by main(), main(), quote_identifier(), and setup_connection().
