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,
432 deparse_context *context);
435 deparse_context *context);
442 deparse_context *context);
445 deparse_context *context);
447 deparse_context *context);
449 void *callback_arg);
482 void *callback_arg);
502 deparse_context *context,
510 deparse_context *context);
512 deparse_context *context);
514 deparse_context *context);
516 deparse_context *context);
519 deparse_context *context);
521 deparse_context *context);
532 bool inGroupBy);
542 deparse_context *context,
545 deparse_context *context,
548
549#define only_marker(rte) ((rte)->inh ? "" : "ONLY ")
550
551
552/* ----------
553 * pg_get_ruledef - Do it all and return a text
554 * that could be used as a statement
555 * to recreate the rule
556 * ----------
557 */
558Datum
560{
562 int prettyFlags;
563 char *res;
564
565 prettyFlags = PRETTYFLAG_INDENT;
566
568
570 PG_RETURN_NULL();
571
573}
574
575
576Datum
578{
581 int prettyFlags;
582 char *res;
583
585
587
589 PG_RETURN_NULL();
590
592}
593
594
595static char *
597{
599 char nulls[1];
604
605 /*
606 * Do this first so that string is alloc'd in outer context not SPI's.
607 */
609
610 /*
611 * Connect to SPI manager
612 */
613 SPI_connect();
614
615 /*
616 * On the first call prepare the plan to lookup pg_rewrite. We read
617 * pg_rewrite over the SPI manager instead of using the syscache to be
618 * checked for read access on pg_rewrite.
619 */
621 {
622 Oid argtypes[1];
624
625 argtypes[0] = OIDOID;
631 }
632
633 /*
634 * Get the pg_rewrite tuple for this rule
635 */
637 nulls[0] = ' ';
642 {
643 /*
644 * There is no tuple data available here, just keep the output buffer
645 * empty.
646 */
647 }
648 else
649 {
650 /*
651 * Get the rule's definition and put it into executor's memory
652 */
656 }
657
658 /*
659 * Disconnect from SPI manager
660 */
663
666
668}
669
670
671/* ----------
672 * pg_get_viewdef - Mainly the same thing, but we
673 * only return the SELECT part of a view
674 * ----------
675 */
676Datum
678{
679 /* By OID */
681 int prettyFlags;
682 char *res;
683
684 prettyFlags = PRETTYFLAG_INDENT;
685
687
689 PG_RETURN_NULL();
690
692}
693
694
695Datum
697{
698 /* By OID */
701 int prettyFlags;
702 char *res;
703
705
707
709 PG_RETURN_NULL();
710
712}
713
714Datum
716{
717 /* By OID */
720 int prettyFlags;
721 char *res;
722
723 /* calling this implies we want pretty printing */
725
727
729 PG_RETURN_NULL();
730
732}
733
734Datum
736{
737 /* By qualified name */
739 int prettyFlags;
741 Oid viewoid;
742 char *res;
743
744 prettyFlags = PRETTYFLAG_INDENT;
745
746 /* Look up view name. Can't lock it - we might not have privileges. */
749
751
753 PG_RETURN_NULL();
754
756}
757
758
759Datum
761{
762 /* By qualified name */
765 int prettyFlags;
767 Oid viewoid;
768 char *res;
769
771
772 /* Look up view name. Can't lock it - we might not have privileges. */
775
777
779 PG_RETURN_NULL();
780
782}
783
784/*
785 * Common code for by-OID and by-name variants of pg_get_viewdef
786 */
787static char *
789{
791 char nulls[2];
796
797 /*
798 * Do this first so that string is alloc'd in outer context not SPI's.
799 */
801
802 /*
803 * Connect to SPI manager
804 */
805 SPI_connect();
806
807 /*
808 * On the first call prepare the plan to lookup pg_rewrite. We read
809 * pg_rewrite over the SPI manager instead of using the syscache to be
810 * checked for read access on pg_rewrite.
811 */
813 {
814 Oid argtypes[2];
816
817 argtypes[0] = OIDOID;
818 argtypes[1] = NAMEOID;
824 }
825
826 /*
827 * Get the pg_rewrite tuple for the view's SELECT rule
828 */
831 nulls[0] = ' ';
832 nulls[1] = ' ';
837 {
838 /*
839 * There is no tuple data available here, just keep the output buffer
840 * empty.
841 */
842 }
843 else
844 {
845 /*
846 * Get the rule's definition and put it into executor's memory
847 */
851 }
852
853 /*
854 * Disconnect from SPI manager
855 */
858
861
863}
864
865/* ----------
866 * pg_get_triggerdef - Get the definition of a trigger
867 * ----------
868 */
869Datum
871{
873 char *res;
874
876
878 PG_RETURN_NULL();
879
881}
882
883Datum
885{
888 char *res;
889
891
893 PG_RETURN_NULL();
894
896}
897
898static char *
900{
908 char *tgname;
909 char *tgoldtable;
910 char *tgnewtable;
912 bool isnull;
913
914 /*
915 * Fetch the pg_trigger tuple by the Oid of the trigger
916 */
918
920 Anum_pg_trigger_oid,
923
926
928
930 {
934 }
935
937
938 /*
939 * Start the trigger definition. Note that the trigger's name should never
940 * be schema-qualified, but the trigger rel's name may be.
941 */
943
947 quote_identifier(tgname));
948
955 else
957
959 {
961 findx++;
962 }
964 {
967 else
969 findx++;
970 }
972 {
975 else
977 findx++;
978 /* tgattr is first var-width field, so OK to access directly */
980 {
982
985 {
987
993 }
994 }
995 }
997 {
1000 else
1002 findx++;
1003 }
1004
1005 /*
1006 * In non-pretty mode, always schema-qualify the target table name for
1007 * safety. In pretty mode, schema-qualify only if not visible.
1008 */
1010 pretty ?
1013
1015 {
1024 else
1026 }
1027
1029 tgrel->rd_att, &isnull);
1030 if (!isnull)
1032 else
1033 tgoldtable = NULL;
1035 tgrel->rd_att, &isnull);
1036 if (!isnull)
1038 else
1039 tgnewtable = NULL;
1041 {
1045 quote_identifier(tgoldtable));
1048 quote_identifier(tgnewtable));
1049 }
1050
1053 else
1055
1056 /* If the trigger has a WHEN qualification, add that */
1058 tgrel->rd_att, &isnull);
1059 if (!isnull)
1060 {
1061 Node *qual;
1062 char relkind;
1063 deparse_context context;
1067
1069
1071
1073
1074 /* Build minimal OLD and NEW RTEs for the rel */
1078 oldrte->relkind = relkind;
1085
1089 newrte->relkind = relkind;
1096
1097 /* Build two-element rtable */
1105
1106 /* Set up context with one-deep namespace stack */
1120
1122
1124 }
1125
1130
1132 {
1133 char *p;
1135
1137 tgrel->rd_att, &isnull);
1138 if (isnull)
1142 {
1146 /* advance p to next string embedded in tgargs */
1147 while (*p)
1148 p++;
1149 p++;
1150 }
1151 }
1152
1153 /* We deliberately do not put semi-colon at end */
1155
1156 /* Clean up */
1158
1160
1162}
1163
1164/* ----------
1165 * pg_get_indexdef - Get the definition of an index
1166 *
1167 * In the extended version, there is a colno argument as well as pretty bool.
1168 * if colno == 0, we want a complete index definition.
1169 * if colno > 0, we only want the Nth index key's variable or expression.
1170 *
1171 * Note that the SQL-function versions of this omit any info about the
1172 * index tablespace; this is intentional because pg_dump wants it that way.
1173 * However pg_get_indexdef_string() includes the index tablespace.
1174 * ----------
1175 */
1176Datum
1178{
1180 int prettyFlags;
1181 char *res;
1182
1183 prettyFlags = PRETTYFLAG_INDENT;
1184
1186 false, false,
1187 false, false,
1188 prettyFlags, true);
1189
1191 PG_RETURN_NULL();
1192
1194}
1195
1196Datum
1198{
1202 int prettyFlags;
1203 char *res;
1204
1206
1208 colno != 0, false,
1209 false, false,
1210 prettyFlags, true);
1211
1213 PG_RETURN_NULL();
1214
1216}
1217
1218/*
1219 * Internal version for use by ALTER TABLE.
1220 * Includes a tablespace clause in the result.
1221 * Returns a palloc'd C string; no pretty-printing.
1222 */
1223char *
1225{
1227 false, false,
1228 true, true,
1229 0, false);
1230}
1231
1232/* Internal version that just reports the key-column definitions */
1233char *
1235{
1236 int prettyFlags;
1237
1239
1241 true, true,
1242 false, false,
1243 prettyFlags, false);
1244}
1245
1246/* Internal version, extensible with flags to control its behavior */
1247char *
1249{
1252 int prettyFlags;
1253
1255
1258 false, false,
1259 prettyFlags, false);
1260}
1261
1262/*
1263 * Internal workhorse to decompile an index definition.
1264 *
1265 * This is now used for exclusion constraints as well: if excludeOps is not
1266 * NULL then it points to an array of exclusion operator OIDs.
1267 */
1268static char *
1273 int prettyFlags, bool missing_ok)
1274{
1275 /* might want a separate isConstraint parameter later */
1286 List *context;
1288 int keyno;
1298
1299 /*
1300 * Fetch the pg_index tuple by the Oid of the index
1301 */
1304 {
1305 if (missing_ok)
1308 }
1310
1313
1314 /* Must get indcollation, indclass, and indoption the hard way */
1316 Anum_pg_index_indcollation);
1318
1320 Anum_pg_index_indclass);
1322
1324 Anum_pg_index_indoption);
1326
1327 /*
1328 * Fetch the pg_class tuple of the index relation
1329 */
1334
1335 /*
1336 * Fetch the pg_am tuple of the index' access method
1337 */
1341 idxrelrec->relam);
1343
1344 /* Fetch the index AM's API struct */
1346
1347 /*
1348 * Get the index expressions, if any. (NOTE: we do not use the relcache
1349 * versions of the expressions and predicate, because we want to display
1350 * non-const-folded expressions.)
1351 */
1353 {
1356
1358 Anum_pg_index_indexprs);
1362 }
1363 else
1365
1367
1369
1370 /*
1371 * Start the index definition. Note that the index's name should never be
1372 * schema-qualified, but the indexed rel's name may be.
1373 */
1375
1377 {
1384 (prettyFlags & PRETTYFLAG_SCHEMA) ?
1388 else /* currently, must be EXCLUDE constraint */
1391 }
1392
1393 /*
1394 * Report the indexed attributes
1395 */
1398 {
1402
1403 /*
1404 * Ignore non-key attributes if told to.
1405 */
1407 break;
1408
1409 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1411 {
1414 }
1415
1416 if (!colno)
1419
1421 {
1422 /* Simple index column */
1425
1427 if (!colno || colno == keyno + 1)
1431 &keycolcollation);
1432 }
1433 else
1434 {
1435 /* expressional index */
1437
1442 /* Deparse */
1444 prettyFlags, 0);
1445 if (!colno || colno == keyno + 1)
1446 {
1447 /* Need parens if it's not a bare function call */
1450 else
1452 }
1455 }
1456
1457 /* Print additional decoration for (selected) key columns */
1459 (!colno || colno == keyno + 1))
1460 {
1465
1466 /* Add collation, if not default for column */
1470
1471 /* Add the operator class name, if not default */
1474
1476 {
1480 }
1481
1482 /* Add options if relevant */
1484 {
1485 /* if it supports sort ordering, report DESC and NULLS opts */
1487 {
1489 /* NULLS FIRST is the default in this case */
1492 }
1493 else
1494 {
1497 }
1498 }
1499
1500 /* Add the exclusion operator if relevant */
1504 keycoltype,
1505 keycoltype));
1506 }
1507 }
1508
1510 {
1512
1515
1516 /*
1517 * If it has options, append "WITH (options)"
1518 */
1521 {
1524 }
1525
1526 /*
1527 * Print tablespace, but only if requested
1528 */
1530 {
1532
1535 {
1540 }
1541 }
1542
1543 /*
1544 * If it's a partial index, decompile and append the predicate
1545 */
1547 {
1548 Node *node;
1551
1552 /* Convert text string to node tree */
1554 Anum_pg_index_indpred);
1558
1559 /* Deparse */
1561 prettyFlags, 0);
1564 else
1566 }
1567 }
1568
1569 /* Clean up */
1573
1575}
1576
1577/* ----------
1578 * pg_get_querydef
1579 *
1580 * Public entry point to deparse one query parsetree.
1581 * The pretty flags are determined by GET_PRETTY_FLAGS(pretty).
1582 *
1583 * The result is a palloc'd C string.
1584 * ----------
1585 */
1586char *
1588{
1590 int prettyFlags;
1591
1593
1595
1597 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
1598
1600}
1601
1602/*
1603 * pg_get_statisticsobjdef
1604 * Get the definition of an extended statistics object
1605 */
1606Datum
1608{
1610 char *res;
1611
1613
1615 PG_RETURN_NULL();
1616
1618}
1619
1620/*
1621 * Internal version for use by ALTER TABLE.
1622 * Returns a palloc'd C string; no pretty-printing.
1623 */
1624char *
1626{
1628}
1629
1630/*
1631 * pg_get_statisticsobjdef_columns
1632 * Get columns and expressions for an extended statistics object
1633 */
1634Datum
1636{
1638 char *res;
1639
1641
1643 PG_RETURN_NULL();
1644
1646}
1647
1648/*
1649 * Internal workhorse to decompile an extended statistics object.
1650 */
1651static char *
1653{
1657 int colno;
1659 ArrayType *arr;
1660 char *enabled;
1661 Datum datum;
1666 List *context;
1670 int ncolumns;
1671
1673
1675 {
1676 if (missing_ok)
1679 }
1680
1681 /* has the statistics expressions? */
1683
1685
1686 /*
1687 * Get the statistics expressions, if any. (NOTE: we do not use the
1688 * relcache versions of the expressions, because we want to display
1689 * non-const-folded expressions.)
1690 */
1692 {
1695
1701 }
1702 else
1703 exprs = NIL;
1704
1705 /* count the number of columns (attributes and expressions) */
1707
1709
1711 {
1716
1717 /*
1718 * Decode the stxkind column so that we know which stats types to
1719 * print.
1720 */
1723 arr = DatumGetArrayTypeP(datum);
1725 ARR_HASNULL(arr) ||
1729
1733
1735 {
1742
1743 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
1744 }
1745
1746 /*
1747 * If any option is disabled, then we'll need to append the types
1748 * clause to show which options are enabled. We omit the types clause
1749 * on purpose when all options are enabled, so a pg_dump/pg_restore
1750 * will create all statistics types on a newer postgres version, if
1751 * the statistics had all options enabled on the original version.
1752 *
1753 * But if the statistics is defined on just a single column, it has to
1754 * be an expression statistics. In that case we don't need to specify
1755 * kinds.
1756 */
1758 (ncolumns > 1))
1759 {
1761
1763
1765 {
1768 }
1769
1771 {
1774 }
1775
1778
1780 }
1781
1783 }
1784
1785 /* decode simple column references */
1787 {
1790
1791 if (colno > 0)
1793
1795
1797 }
1798
1800 statextrec->stxrelid);
1801
1803 {
1807
1809 prettyFlags, 0);
1810
1811 if (colno > 0)
1813
1814 /* Need parens if it's not a bare function call */
1817 else
1819
1820 colno++;
1821 }
1822
1826
1828
1830}
1831
1832/*
1833 * Generate text array of expressions for statistics object.
1834 */
1835Datum
1837{
1841 Datum datum;
1842 List *context;
1846 char *tmp;
1848
1850
1852 PG_RETURN_NULL();
1853
1854 /* Does the stats object have expressions? */
1856
1857 /* no expressions? we're done */
1859 {
1861 PG_RETURN_NULL();
1862 }
1863
1865
1866 /*
1867 * Get the statistics expressions, and deparse them into text values.
1868 */
1871 tmp = TextDatumGetCString(datum);
1873 pfree(tmp);
1874
1876 statextrec->stxrelid);
1877
1879 {
1883
1885 prettyFlags, 0);
1886
1887 astate = accumArrayResult(astate,
1889 false,
1890 TEXTOID,
1891 CurrentMemoryContext);
1892 }
1893
1895
1897}
1898
1899/*
1900 * pg_get_partkeydef
1901 *
1902 * Returns the partition key specification, ie, the following:
1903 *
1904 * { RANGE | LIST | HASH } (column opt_collation opt_opclass [, ...])
1905 */
1906Datum
1908{
1910 char *res;
1911
1913
1915 PG_RETURN_NULL();
1916
1918}
1919
1920/* Internal version that just reports the column definitions */
1921char *
1923{
1924 int prettyFlags;
1925
1927
1929}
1930
1931/*
1932 * Internal workhorse to decompile a partition key definition.
1933 */
1934static char *
1937{
1939 HeapTuple tuple;
1941 oidvector *partcollation;
1942 List *partexprs;
1944 List *context;
1945 Datum datum;
1947 int keyno;
1950
1953 {
1954 if (missing_ok)
1957 }
1958
1960
1962
1963 /* Must get partclass and partcollation the hard way */
1967
1971
1972
1973 /*
1974 * Get the expressions, if any. (NOTE: we do not use the relcache
1975 * versions of the expressions, because we want to display
1976 * non-const-folded expressions.)
1977 */
1979 {
1982
1987
1991
1993 }
1994 else
1995 partexprs = NIL;
1996
1999
2001
2003 {
2007 break;
2011 break;
2015 break;
2016 default:
2019 }
2020
2025 {
2030
2034 {
2035 /* Simple attribute reference */
2038
2043 &keycolcollation);
2044 }
2045 else
2046 {
2047 /* Expression */
2049
2054
2055 /* Deparse */
2057 prettyFlags, 0);
2058 /* Need parens if it's not a bare function call */
2061 else
2063
2066 }
2067
2068 /* Add collation, if not default for column */
2073
2074 /* Add the operator class name, if not default */
2077 }
2078
2081
2082 /* Clean up */
2083 ReleaseSysCache(tuple);
2084
2086}
2087
2088/*
2089 * pg_get_partition_constraintdef
2090 *
2091 * Returns partition constraint expression as a string for the input relation
2092 */
2093Datum
2095{
2098 int prettyFlags;
2099 List *context;
2101
2103
2104 /* Quick exit if no partition constraint */
2106 PG_RETURN_NULL();
2107
2108 /*
2109 * Deparse and return the constraint expression.
2110 */
2111 prettyFlags = PRETTYFLAG_INDENT;
2114 false, prettyFlags, 0);
2115
2117}
2118
2119/*
2120 * pg_get_partconstrdef_string
2121 *
2122 * Returns the partition constraint as a C-string for the input relation, with
2123 * the given alias. No pretty-printing.
2124 */
2125char *
2127{
2129 List *context;
2130
2133
2135}
2136
2137/*
2138 * pg_get_constraintdef
2139 *
2140 * Returns the definition for the constraint, ie, everything that needs to
2141 * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
2142 */
2143Datum
2145{
2147 int prettyFlags;
2148 char *res;
2149
2150 prettyFlags = PRETTYFLAG_INDENT;
2151
2153
2155 PG_RETURN_NULL();
2156
2158}
2159
2160Datum
2162{
2165 int prettyFlags;
2166 char *res;
2167
2169
2171
2173 PG_RETURN_NULL();
2174
2176}
2177
2178/*
2179 * Internal version that returns a full ALTER TABLE ... ADD CONSTRAINT command
2180 */
2181char *
2183{
2185}
2186
2187/*
2188 * As of 9.4, we now use an MVCC snapshot for this.
2189 */
2190static char *
2192 int prettyFlags, bool missing_ok)
2193{
2197 SysScanDesc scandesc;
2201
2203 Anum_pg_constraint_oid,
2206
2207 scandesc = systable_beginscan(relation,
2208 ConstraintOidIndexId,
2209 true,
2210 snapshot,
2211 1,
2212 scankey);
2213
2214 /*
2215 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2216 * via SearchSysCache, which works fine.
2217 */
2219
2220 UnregisterSnapshot(snapshot);
2221
2223 {
2224 if (missing_ok)
2225 {
2226 systable_endscan(scandesc);
2229 }
2231 }
2232
2234
2236
2238 {
2240 {
2241 /*
2242 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2243 * constraints, and other types of constraints don't inherit
2244 * anyway so it doesn't matter whether we say ONLY or not. Someday
2245 * we might need to let callers specify whether to put ONLY in the
2246 * command.
2247 */
2251 }
2252 else
2253 {
2254 /* Must be a domain constraint */
2259 }
2260 }
2261
2263 {
2265 {
2267 bool isnull;
2269
2270 /* Start off the constraint definition */
2272
2273 /* Fetch and build referencing-column list */
2275 Anum_pg_constraint_conkey);
2276
2277 /* If it is a temporal foreign key then it uses PERIOD. */
2279
2280 /* add foreign relation name */
2283 NIL));
2284
2285 /* Fetch and build referenced-column list */
2287 Anum_pg_constraint_confkey);
2288
2290
2292
2293 /* Add match type */
2295 {
2297 string = " MATCH FULL";
2298 break;
2300 string = " MATCH PARTIAL";
2301 break;
2303 string = "";
2304 break;
2305 default:
2307 conForm->confmatchtype);
2308 string = ""; /* keep compiler quiet */
2309 break;
2310 }
2312
2313 /* Add ON UPDATE and ON DELETE clauses, if needed */
2315 {
2318 break;
2320 string = "RESTRICT";
2321 break;
2323 string = "CASCADE";
2324 break;
2326 string = "SET NULL";
2327 break;
2329 string = "SET DEFAULT";
2330 break;
2331 default:
2333 conForm->confupdtype);
2335 break;
2336 }
2337 if (string)
2339
2341 {
2344 break;
2346 string = "RESTRICT";
2347 break;
2349 string = "CASCADE";
2350 break;
2352 string = "SET NULL";
2353 break;
2355 string = "SET DEFAULT";
2356 break;
2357 default:
2359 conForm->confdeltype);
2361 break;
2362 }
2363 if (string)
2365
2366 /*
2367 * Add columns specified to SET NULL or SET DEFAULT if
2368 * provided.
2369 */
2371 Anum_pg_constraint_confdelsetcols, &isnull);
2372 if (!isnull)
2373 {
2377 }
2378
2379 break;
2380 }
2383 {
2388
2389 /* Start off the constraint definition */
2392 else
2394
2396
2403
2405
2406 /* Fetch and build target column list */
2408 Anum_pg_constraint_conkey);
2409
2413
2415
2416 /* Build including column list (from pg_index.indkeys) */
2418 Anum_pg_index_indnatts);
2420 {
2421 Datum cols;
2422 Datum *keys;
2423 int nKeys;
2425
2427
2429 Anum_pg_index_indkey);
2430
2432 &keys, NULL, &nKeys);
2433
2435 {
2437
2443 }
2444
2446 }
2448
2449 /* XXX why do we only print these bits if fullCommand? */
2451 {
2454
2456 {
2459 }
2460
2461 /*
2462 * Print the tablespace, unless it's the database default.
2463 * This is to help ALTER TABLE usage of this facility,
2464 * which needs this behavior to recreate exact catalog
2465 * state.
2466 */
2471 }
2472
2473 break;
2474 }
2476 {
2480 Node *expr;
2481 List *context;
2482
2483 /* Fetch constraint expression in parsetree form */
2485 Anum_pg_constraint_conbin);
2486
2489
2490 /* Set up deparsing context for Var nodes in constraint */
2492 {
2493 /* relation constraint */
2495 conForm->conrelid);
2496 }
2497 else
2498 {
2499 /* domain constraint --- can't have Vars */
2500 context = NIL;
2501 }
2502
2504 prettyFlags, 0);
2505
2506 /*
2507 * Now emit the constraint definition, adding NO INHERIT if
2508 * necessary.
2509 *
2510 * There are cases where the constraint expression will be
2511 * fully parenthesized and we don't need the outer parens ...
2512 * but there are other cases where we do need 'em. Be
2513 * conservative for now.
2514 *
2515 * Note that simply checking for leading '(' and trailing ')'
2516 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2517 */
2519 consrc,
2521 break;
2522 }
2524 {
2526 {
2528
2530
2536 }
2538 {
2539 /* conkey is null for domain not-null constraints */
2541 }
2542 break;
2543 }
2544
2546
2547 /*
2548 * There isn't an ALTER TABLE syntax for creating a user-defined
2549 * constraint trigger, but it seems better to print something than
2550 * throw an error; if we throw error then this function couldn't
2551 * safely be applied to all rows of pg_constraint.
2552 */
2554 break;
2556 {
2559 Datum *elems;
2560 int nElems;
2562 Oid *operators;
2563
2564 /* Extract operator OIDs from the pg_constraint tuple */
2566 Anum_pg_constraint_conexclop);
2567
2569 &elems, NULL, &nElems);
2570
2574
2575 /* pg_get_indexdef_worker does the rest */
2576 /* suppress tablespace because pg_dump wants it that way */
2578 pg_get_indexdef_worker(indexOid,
2579 0,
2580 operators,
2581 false,
2582 false,
2583 false,
2584 false,
2585 prettyFlags,
2586 false));
2587 break;
2588 }
2589 default:
2591 break;
2592 }
2593
2598
2599 /* Validated status is irrelevant when the constraint is NOT ENFORCED. */
2604
2605 /* Cleanup */
2606 systable_endscan(scandesc);
2608
2610}
2611
2612
2613/*
2614 * Convert an int16[] Datum into a comma-separated list of column names
2615 * for the indicated relation; append the list to buf. Returns the number
2616 * of keys.
2617 */
2618static int
2621{
2622 Datum *keys;
2623 int nKeys;
2625
2626 /* Extract data from array of int16 */
2628 &keys, NULL, &nKeys);
2629
2631 {
2633
2635
2638 else
2642 }
2643
2644 return nKeys;
2645}
2646
2647
2648/* ----------
2649 * pg_get_expr - Decompile an expression tree
2650 *
2651 * Input: an expression tree in nodeToString form, and a relation OID
2652 *
2653 * Output: reverse-listed expression
2654 *
2655 * Currently, the expression can only refer to a single relation, namely
2656 * the one specified by the second parameter. This is sufficient for
2657 * partial indexes, column default expressions, etc. We also support
2658 * Var-free expressions, for which the OID can be InvalidOid.
2659 *
2660 * If the OID is nonzero but not actually valid, don't throw an error,
2661 * just return NULL. This is a bit questionable, but it's what we've
2662 * done historically, and it can help avoid unwanted failures when
2663 * examining catalog entries for just-deleted relations.
2664 *
2665 * We expect this function to work, or throw a reasonably clean error,
2666 * for any node tree that can appear in a catalog pg_node_tree column.
2667 * Query trees, such as those appearing in pg_rewrite.ev_action, are
2668 * not supported. Nor are expressions in more than one relation, which
2669 * can appear in places like pg_rewrite.ev_qual.
2670 * ----------
2671 */
2672Datum
2674{
2677 text *result;
2678 int prettyFlags;
2679
2680 prettyFlags = PRETTYFLAG_INDENT;
2681
2682 result = pg_get_expr_worker(expr, relid, prettyFlags);
2683 if (result)
2684 PG_RETURN_TEXT_P(result);
2685 else
2686 PG_RETURN_NULL();
2687}
2688
2689Datum
2691{
2695 text *result;
2696 int prettyFlags;
2697
2699
2700 result = pg_get_expr_worker(expr, relid, prettyFlags);
2701 if (result)
2702 PG_RETURN_TEXT_P(result);
2703 else
2704 PG_RETURN_NULL();
2705}
2706
2709{
2710 Node *node;
2712 Relids relids;
2713 List *context;
2717
2718 /* Convert input pg_node_tree (really TEXT) object to C string */
2720
2721 /* Convert expression to node tree */
2723
2725
2726 /*
2727 * Throw error if the input is a querytree rather than an expression tree.
2728 * While we could support queries here, there seems no very good reason
2729 * to. In most such catalog columns, we'll see a List of Query nodes, or
2730 * even nested Lists, so drill down to a non-List node before checking.
2731 */
2732 tst = node;
2739
2740 /*
2741 * Throw error if the expression contains Vars we won't be able to
2742 * deparse.
2743 */
2746 {
2751 }
2752 else
2753 {
2758 }
2759
2760 /*
2761 * Prepare deparse context if needed. If we are deparsing with a relid,
2762 * we need to transiently open and lock the rel, to make sure it won't go
2763 * away underneath us. (set_relation_column_names would lock it anyway,
2764 * so this isn't really introducing any new behavior.)
2765 */
2767 {
2772 }
2773 else
2774 context = NIL;
2775
2776 /* Deparse */
2778 prettyFlags, 0);
2779
2782
2784}
2785
2786
2787/* ----------
2788 * pg_get_userbyid - Get a user name by roleid and
2789 * fallback to 'unknown (OID=n)'
2790 * ----------
2791 */
2792Datum
2794{
2796 Name result;
2799
2800 /*
2801 * Allocate space for the result
2802 */
2805
2806 /*
2807 * Get the pg_authid entry and print the result
2808 */
2811 {
2813 *result = role_rec->rolname;
2815 }
2816 else
2818
2819 PG_RETURN_NAME(result);
2820}
2821
2822
2823/*
2824 * pg_get_serial_sequence
2825 * Get the name of the sequence used by an identity or serial column,
2826 * formatted suitably for passing to setval, nextval or currval.
2827 * First parameter is not treated as double-quoted, second parameter
2828 * is --- see documentation for reason.
2829 */
2830Datum
2832{
2836 Oid tableOid;
2842 SysScanDesc scan;
2844
2845 /* Look up table name. Can't lock it - we might not have privileges. */
2848
2849 /* Get the number of the column */
2851
2858
2859 /* Search the dependency table for the dependent sequence */
2861
2862 ScanKeyInit(&key[0],
2866 ScanKeyInit(&key[1],
2867 Anum_pg_depend_refobjid,
2869 ObjectIdGetDatum(tableOid));
2870 ScanKeyInit(&key[2],
2874
2876 NULL, 3, key);
2877
2879 {
2881
2882 /*
2883 * Look for an auto dependency (serial column) or internal dependency
2884 * (identity column) of a sequence on a column. (We need the relkind
2885 * test because indexes can also have auto dependencies on columns.)
2886 */
2888 deprec->objsubid == 0 &&
2892 {
2894 break;
2895 }
2896 }
2897
2898 systable_endscan(scan);
2900
2902 {
2903 char *result;
2904
2906
2908 }
2909
2910 PG_RETURN_NULL();
2911}
2912
2913
2914/*
2915 * pg_get_functiondef
2916 * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
2917 * the specified function.
2918 *
2919 * Note: if you change the output format of this function, be careful not
2920 * to break psql's rules (in \ef and \sf) for identifying the start of the
2921 * function body. To wit: the function body starts on a line that begins with
2922 * "AS ", "BEGIN ", or "RETURN ", and no preceding line will look like that.
2923 */
2924Datum
2926{
2931 Form_pg_proc proc;
2933 Datum tmp;
2934 bool isnull;
2935 const char *prosrc;
2940
2942
2943 /* Look up the function */
2946 PG_RETURN_NULL();
2947
2950
2955
2957
2958 /*
2959 * We always qualify the function name, to ensure the right function gets
2960 * replaced.
2961 */
2969 {
2973 }
2974
2976
2979
2980 /* Emit some miscellaneous options on one line */
2982
2985 switch (proc->provolatile)
2986 {
2989 break;
2992 break;
2994 break;
2995 }
2996
2997 switch (proc->proparallel)
2998 {
3001 break;
3004 break;
3006 break;
3007 }
3008
3009 if (proc->proisstrict)
3011 if (proc->prosecdef)
3013 if (proc->proleakproof)
3015
3016 /* This code for the default cost and rows should match functioncmds.c */
3018 proc->prolang == ClanguageId)
3019 procost = 1;
3020 else
3021 procost = 100;
3024
3025 if (proc->prorows > 0 && proc->prorows != 1000)
3027
3028 if (proc->prosupport)
3029 {
3030 Oid argtypes[1];
3031
3032 /*
3033 * We should qualify the support function's name if it wouldn't be
3034 * resolved by lookup in the current search path.
3035 */
3036 argtypes[0] = INTERNALOID;
3038 generate_function_name(proc->prosupport, 1,
3039 NIL, argtypes,
3041 }
3042
3045
3046 /* Emit any proconfig options, one per line */
3048 if (!isnull)
3049 {
3052
3056
3058 {
3059 Datum d;
3060
3062 -1 /* varlenarray */ ,
3063 -1 /* TEXT's typlen */ ,
3064 false /* TEXT's typbyval */ ,
3066 &isnull);
3067 if (!isnull)
3068 {
3070 char *pos;
3071
3074 continue;
3075 *pos++ = '\0';
3076
3079
3080 /*
3081 * Variables that are marked GUC_LIST_QUOTE were already fully
3082 * quoted by flatten_set_variable_args() before they were put
3083 * into the proconfig array. However, because the quoting
3084 * rules used there aren't exactly like SQL's, we have to
3085 * break the list value apart and then quote the elements as
3086 * string literals. (The elements may be double-quoted as-is,
3087 * but we can't just feed them to the SQL parser; it would do
3088 * the wrong thing with elements that are zero-length or
3089 * longer than NAMEDATALEN.) Also, we need a special case for
3090 * empty lists.
3091 *
3092 * Variables that are not so marked should just be emitted as
3093 * simple string literals. If the variable is not known to
3094 * guc.c, we'll do that; this makes it unsafe to use
3095 * GUC_LIST_QUOTE for extension variables.
3096 */
3098 {
3101
3102 /* Parse string into list of identifiers */
3104 {
3105 /* this shouldn't fail really */
3107 }
3108 /* Special case: represent an empty list as NULL */
3112 {
3114
3118 }
3119 }
3120 else
3123 }
3124 }
3125 }
3126
3127 /* And finally the function definition ... */
3130 {
3132 }
3133 else
3134 {
3136
3138 if (!isnull)
3139 {
3142 }
3143
3145 prosrc = TextDatumGetCString(tmp);
3146
3147 /*
3148 * We always use dollar quoting. Figure out a suitable delimiter.
3149 *
3150 * Since the user is likely to be editing the function body string, we
3151 * shouldn't use a short delimiter that he might easily create a
3152 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3153 * if needed.
3154 */
3161
3165 }
3166
3168
3170
3172}
3173
3174/*
3175 * pg_get_function_arguments
3176 * Get a nicely-formatted list of arguments for a function.
3177 * This is everything that would go between the parentheses in
3178 * CREATE FUNCTION.
3179 */
3180Datum
3182{
3186
3189 PG_RETURN_NULL();
3190
3192
3194
3196
3198}
3199
3200/*
3201 * pg_get_function_identity_arguments
3202 * Get a formatted list of arguments for a function.
3203 * This is everything that would go between the parentheses in
3204 * ALTER FUNCTION, etc. In particular, don't print defaults.
3205 */
3206Datum
3208{
3212
3215 PG_RETURN_NULL();
3216
3218
3220
3222
3224}
3225
3226/*
3227 * pg_get_function_result
3228 * Get a nicely-formatted version of the result type of a function.
3229 * This is what would appear after RETURNS in CREATE FUNCTION.
3230 */
3231Datum
3233{
3237
3240 PG_RETURN_NULL();
3241
3243 {
3245 PG_RETURN_NULL();
3246 }
3247
3249
3251
3253
3255}
3256
3257/*
3258 * Guts of pg_get_function_result: append the function's return type
3259 * to the specified buffer.
3260 */
3261static void
3263{
3267
3269
3270 if (proc->proretset)
3271 {
3272 /* It might be a table function; try to print the arguments */
3277 else
3279 }
3280
3282 {
3283 /* Not a table function, so do the normal thing */
3284 if (proc->proretset)
3287 }
3288
3290}
3291
3292/*
3293 * Common code for pg_get_function_arguments and pg_get_function_result:
3294 * append the desired subset of arguments to buf. We print only TABLE
3295 * arguments when print_table_args is true, and all the others when it's false.
3296 * We print argument defaults only if print_defaults is true.
3297 * Function return value is the number of arguments printed.
3298 */
3299static int
3302{
3304 int numargs;
3305 Oid *argtypes;
3306 char **argnames;
3315
3317 &argtypes, &argnames, &argmodes);
3318
3319 nlackdefaults = numargs;
3321 {
3323 bool isnull;
3324
3327 &isnull);
3328 if (!isnull)
3329 {
3331
3336 /* nlackdefaults counts only *input* arguments lacking defaults */
3338 }
3339 }
3340
3341 /* Check for special treatment of ordered-set aggregates */
3343 {
3346
3350 proc->oid);
3355 }
3356
3357 argsprinted = 0;
3358 inputargno = 0;
3360 {
3366
3368 {
3370
3371 /*
3372 * For procedures, explicitly mark all argument modes, so as
3373 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3374 */
3377 else
3380 break;
3384 break;
3388 break;
3392 break;
3396 break;
3397 default:
3401 break;
3402 }
3405
3407 continue;
3408
3410 {
3414 }
3417
3419 if (argname && argname[0])
3423 {
3424 Node *expr;
3425
3429
3432 }
3433 argsprinted++;
3434
3435 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3437 {
3438 i--;
3439 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3441 }
3442 }
3443
3445}
3446
3447static bool
3449{
3454}
3455
3456/*
3457 * Append used transformed types to specified buffer
3458 */
3459static void
3461{
3462 Oid *trftypes;
3464
3467 {
3469
3472 {
3476 }
3478 }
3479}
3480
3481/*
3482 * Get textual representation of a function argument's default value. The
3483 * second argument of this function is the argument number among all arguments
3484 * (i.e. proallargtypes, *not* proargtypes), starting with 1, because that's
3485 * how information_schema.sql uses it.
3486 */
3487Datum
3489{
3493 Form_pg_proc proc;
3494 int numargs;
3495 Oid *argtypes;
3496 char **argnames;
3500 Node *node;
3504 bool isnull;
3506
3509 PG_RETURN_NULL();
3510
3513 {
3515 PG_RETURN_NULL();
3516 }
3517
3518 nth_inputarg = 0;
3521 nth_inputarg++;
3522
3525 &isnull);
3526 if (isnull)
3527 {
3529 PG_RETURN_NULL();
3530 }
3531
3535
3537
3538 /*
3539 * Calculate index into proargdefaults: proargdefaults corresponds to the
3540 * last N input arguments, where N = pronargdefaults.
3541 */
3543
3545 {
3547 PG_RETURN_NULL();
3548 }
3551
3553
3555}
3556
3557static void
3559{
3560 int numargs;
3561 Oid *argtypes;
3562 char **argnames;
3565 Datum tmp;
3566 Node *n;
3567
3570 &argtypes, &argnames, &argmodes);
3571 dpns.numargs = numargs;
3572 dpns.argnames = argnames;
3573
3576
3578 {
3579 List *stmts;
3581
3583
3585
3587 {
3589
3590 /* It seems advisable to get at least AccessShareLock on rels */
3596 }
3597
3599 }
3600 else
3601 {
3603
3604 /* It seems advisable to get at least AccessShareLock on rels */
3607 0, WRAP_COLUMN_DEFAULT, 0);
3608 }
3609}
3610
3611Datum
3613{
3617 bool isnull;
3618
3620
3621 /* Look up the function */
3624 PG_RETURN_NULL();
3625
3627 if (isnull)
3628 {
3630 PG_RETURN_NULL();
3631 }
3632
3634
3636
3638}
3639
3640
3641/*
3642 * deparse_expression - General utility for deparsing expressions
3643 *
3644 * calls deparse_expression_pretty with all prettyPrinting disabled
3645 */
3646char *
3649{
3651 showimplicit, 0, 0);
3652}
3653
3654/* ----------
3655 * deparse_expression_pretty - General utility for deparsing expressions
3656 *
3657 * expr is the node tree to be deparsed. It must be a transformed expression
3658 * tree (ie, not the raw output of gram.y).
3659 *
3660 * dpcontext is a list of deparse_namespace nodes representing the context
3661 * for interpreting Vars in the node tree. It can be NIL if no Vars are
3662 * expected.
3663 *
3664 * forceprefix is true to force all Vars to be prefixed with their table names.
3665 *
3666 * showimplicit is true to force all implicit casts to be shown explicitly.
3667 *
3668 * Tries to pretty up the output according to prettyFlags and startIndent.
3669 *
3670 * The result is a palloc'd string.
3671 * ----------
3672 */
3673static char *
3677{
3679 deparse_context context;
3680
3688 context.prettyFlags = prettyFlags;
3695
3697
3699}
3700
3701/* ----------
3702 * deparse_context_for - Build deparse context for a single relation
3703 *
3704 * Given the reference name (alias) and OID of a relation, build deparsing
3705 * context for an expression referencing only that relation (as varno 1,
3706 * varlevelsup 0). This is sufficient for many uses of deparse_expression.
3707 * ----------
3708 */
3709List *
3711{
3714
3716
3717 /* Build a minimal RTE for the rel */
3720 rte->relid = relid;
3728
3729 /* Build one-element rtable */
3736
3737 /* Return a one-deep namespace stack */
3739}
3740
3741/*
3742 * deparse_context_for_plan_tree - Build deparse context for a Plan tree
3743 *
3744 * When deparsing an expression in a Plan tree, we use the plan's rangetable
3745 * to resolve names of simple Vars. The initialization of column names for
3746 * this is rather expensive if the rangetable is large, and it'll be the same
3747 * for every expression in the Plan tree; so we do it just once and re-use
3748 * the result of this function for each expression. (Note that the result
3749 * is not usable until set_deparse_context_plan() is applied to it.)
3750 *
3751 * In addition to the PlannedStmt, pass the per-RTE alias names
3752 * assigned by a previous call to select_rtable_names_for_explain.
3753 */
3754List *
3756{
3758
3760
3761 /* Initialize fields that stay the same across the whole plan tree */
3763 dpns->rtable_names = rtable_names;
3767 {
3768 /* Set up the array, indexed by child relid */
3771
3775 {
3778
3782 }
3783 }
3784 else
3786
3787 /*
3788 * Set up column name aliases, ignoring any join RTEs; they don't matter
3789 * because plan trees don't contain any join alias Vars.
3790 */
3792
3793 /* Return a one-deep namespace stack */
3795}
3796
3797/*
3798 * set_deparse_context_plan - Specify Plan node containing expression
3799 *
3800 * When deparsing an expression in a Plan tree, we might have to resolve
3801 * OUTER_VAR, INNER_VAR, or INDEX_VAR references. To do this, the caller must
3802 * provide the parent Plan node. Then OUTER_VAR and INNER_VAR references
3803 * can be resolved by drilling down into the left and right child plans.
3804 * Similarly, INDEX_VAR references can be resolved by reference to the
3805 * indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
3806 * ForeignScan and CustomScan nodes. (Note that we don't currently support
3807 * deparsing of indexquals in regular IndexScan or BitmapIndexScan nodes;
3808 * for those, we can only deparse the indexqualorig fields, which won't
3809 * contain INDEX_VAR Vars.)
3810 *
3811 * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
3812 * the most-closely-nested first. This is needed to resolve PARAM_EXEC
3813 * Params. Note we assume that all the Plan nodes share the same rtable.
3814 *
3815 * For a ModifyTable plan, we might also need to resolve references to OLD/NEW
3816 * variables in the RETURNING list, so we copy the alias names of the OLD and
3817 * NEW rows from the ModifyTable plan node.
3818 *
3819 * Once this function has been called, deparse_expression() can be called on
3820 * subsidiary expression(s) of the specified Plan node. To deparse
3821 * expressions of a different Plan node in the same Plan tree, re-call this
3822 * function to identify the new parent Plan node.
3823 *
3824 * The result is the same List passed in; this is a notational convenience.
3825 */
3826List *
3828{
3830
3831 /* Should always have one-entry namespace list for Plan deparsing */
3834
3835 /* Set our attention on the specific plan node passed in */
3836 dpns->ancestors = ancestors;
3838
3839 /* For ModifyTable, set aliases for OLD and NEW in RETURNING */
3841 {
3844 }
3845
3847}
3848
3849/*
3850 * select_rtable_names_for_explain - Select RTE aliases for EXPLAIN
3851 *
3852 * Determine the relation aliases we'll use during an EXPLAIN operation.
3853 * This is just a frontend to set_rtable_names. We have to expose the aliases
3854 * to EXPLAIN because EXPLAIN needs to know the right alias names to print.
3855 */
3856List *
3858{
3860
3862 dpns.rtable = rtable;
3867 /* We needn't bother computing column aliases yet */
3868
3870}
3871
3872/*
3873 * set_rtable_names: select RTE aliases to be used in printing a query
3874 *
3875 * We fill in dpns->rtable_names with a list of names that is one-for-one with
3876 * the already-filled dpns->rtable list. Each RTE name is unique among those
3877 * in the new namespace plus any ancestor namespaces listed in
3878 * parent_namespaces.
3879 *
3880 * If rels_used isn't NULL, only RTE indexes listed in it are given aliases.
3881 *
3882 * Note that this function is only concerned with relation names, not column
3883 * names.
3884 */
3885static void
3888{
3890 HTAB *names_hash;
3892 bool found;
3893 int rtindex;
3895
3897 /* nothing more to do if empty rtable */
3899 return;
3900
3901 /*
3902 * We use a hash table to hold known names, so that this process is O(N)
3903 * not O(N^2) for N names.
3904 */
3910 &hash_ctl,
3912
3913 /* Preload the hash table with names appearing in parent_namespaces */
3915 {
3918
3920 {
3922
3924 continue;
3926 oldname,
3927 HASH_ENTER,
3928 &found);
3929 /* we do not complain about duplicate names in parent namespaces */
3930 hentry->counter = 0;
3931 }
3932 }
3933
3934 /* Now we can scan the rtable */
3935 rtindex = 1;
3937 {
3939 char *refname;
3940
3941 /* Just in case this takes an unreasonable amount of time ... */
3942 CHECK_FOR_INTERRUPTS();
3943
3945 {
3946 /* Ignore unreferenced RTE */
3947 refname = NULL;
3948 }
3950 {
3951 /* If RTE has a user-defined alias, prefer that */
3952 refname = rte->alias->aliasname;
3953 }
3955 {
3956 /* Use the current actual name of the relation */
3958 }
3960 {
3961 /* Unnamed join has no refname */
3962 refname = NULL;
3963 }
3964 else
3965 {
3966 /* Otherwise use whatever the parser assigned */
3967 refname = rte->eref->aliasname;
3968 }
3969
3970 /*
3971 * If the selected name isn't unique, append digits to make it so, and
3972 * make a new hash entry for it once we've got a unique name. For a
3973 * very long input name, we might have to truncate to stay within
3974 * NAMEDATALEN.
3975 */
3976 if (refname)
3977 {
3979 refname,
3980 HASH_ENTER,
3981 &found);
3982 if (found)
3983 {
3984 /* Name already in use, must choose a new one */
3988
3989 do
3990 {
3992 for (;;)
3993 {
3997 break;
3998 /* drop chars from refname to keep all the digits */
4000 refnamelen - 1);
4001 }
4003 modname,
4004 HASH_ENTER,
4005 &found);
4006 } while (found);
4008 refname = modname;
4009 }
4010 else
4011 {
4012 /* Name not previously used, need only initialize hentry */
4013 hentry->counter = 0;
4014 }
4015 }
4016
4018 rtindex++;
4019 }
4020
4021 hash_destroy(names_hash);
4022}
4023
4024/*
4025 * set_deparse_for_query: set up deparse_namespace for deparsing a Query tree
4026 *
4027 * For convenience, this is defined to initialize the deparse_namespace struct
4028 * from scratch.
4029 */
4030static void
4033{
4036
4037 /* Initialize *dpns and fill rtable/ctes links */
4043 dpns->ret_old_alias = query->returningOldAlias;
4044 dpns->ret_new_alias = query->returningNewAlias;
4045
4046 /* Assign a unique relation alias to each RTE */
4048
4049 /* Initialize dpns->rtable_columns to contain zeroed structs */
4054
4055 /* If it's a utility query, it won't have a jointree */
4057 {
4058 /* Detect whether global uniqueness of USING names is needed */
4059 dpns->unique_using =
4061
4062 /*
4063 * Select names for columns merged by USING, via a recursive pass over
4064 * the query jointree.
4065 */
4067 }
4068
4069 /*
4070 * Now assign remaining column aliases for each RTE. We do this in a
4071 * linear scan of the rtable, so as to process RTEs whether or not they
4072 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4073 * etc). JOIN RTEs must be processed after their children, but this is
4074 * okay because they appear later in the rtable list than their children
4075 * (cf Asserts in identify_join_columns()).
4076 */
4078 {
4081
4084 else
4086 }
4087}
4088
4089/*
4090 * set_simple_column_names: fill in column aliases for non-query situations
4091 *
4092 * This handles EXPLAIN and cases where we only have relation RTEs. Without
4093 * a join tree, we can't do anything smart about join RTEs, but we don't
4094 * need to, because EXPLAIN should never see join alias Vars anyway.
4095 * If we find a join RTE we'll just skip it, leaving its deparse_columns
4096 * struct all-zero. If somehow we try to deparse a join alias Var, we'll
4097 * error out cleanly because the struct's num_cols will be zero.
4098 */
4099static void
4101{
4104
4105 /* Initialize dpns->rtable_columns to contain zeroed structs */
4110
4111 /* Assign unique column aliases within each non-join RTE */
4113 {
4116
4119 }
4120}
4121
4122/*
4123 * has_dangerous_join_using: search jointree for unnamed JOIN USING
4124 *
4125 * Merged columns of a JOIN USING may act differently from either of the input
4126 * columns, either because they are merged with COALESCE (in a FULL JOIN) or
4127 * because an implicit coercion of the underlying input column is required.
4128 * In such a case the column must be referenced as a column of the JOIN not as
4129 * a column of either input. And this is problematic if the join is unnamed
4130 * (alias-less): we cannot qualify the column's name with an RTE name, since
4131 * there is none. (Forcibly assigning an alias to the join is not a solution,
4132 * since that will prevent legal references to tables below the join.)
4133 * To ensure that every column in the query is unambiguously referenceable,
4134 * we must assign such merged columns names that are globally unique across
4135 * the whole query, aliasing other columns out of the way as necessary.
4136 *
4137 * Because the ensuing re-aliasing is fairly damaging to the readability of
4138 * the query, we don't do this unless we have to. So, we must pre-scan
4139 * the join tree to see if we have to, before starting set_using_names().
4140 */
4141static bool
4143{
4145 {
4146 /* nothing to do here */
4147 }
4149 {
4152
4154 {
4156 return true;
4157 }
4158 }
4160 {
4162
4163 /* Is it an unnamed JOIN with USING? */
4165 {
4166 /*
4167 * Yes, so check each join alias var to see if any of them are not
4168 * simple references to underlying columns. If so, we have a
4169 * dangerous situation and must pick unique aliases.
4170 */
4172
4173 /* We need only examine the merged columns */
4175 {
4177
4179 return true;
4180 }
4181 }
4182
4183 /* Nope, but inspect children */
4185 return true;
4187 return true;
4188 }
4189 else
4192 return false;
4193}
4194
4195/*
4196 * set_using_names: select column aliases to be used for merged USING columns
4197 *
4198 * We do this during a recursive descent of the query jointree.
4199 * dpns->unique_using must already be set to determine the global strategy.
4200 *
4201 * Column alias info is saved in the dpns->rtable_columns list, which is
4202 * assumed to be filled with pre-zeroed deparse_columns structs.
4203 *
4204 * parentUsing is a list of all USING aliases assigned in parent joins of
4205 * the current jointree node. (The passed-in list must not be modified.)
4206 *
4207 * Note that we do not use per-deparse_columns hash tables in this function.
4208 * The number of names that need to be assigned should be small enough that
4209 * we don't need to trouble with that.
4210 */
4211static void
4213{
4215 {
4216 /* nothing to do now */
4217 }
4219 {
4222
4225 }
4227 {
4231 int *leftattnos;
4232 int *rightattnos;
4237
4238 /* Get info about the shape of the join */
4240 leftattnos = colinfo->leftattnos;
4241 rightattnos = colinfo->rightattnos;
4242
4243 /* Look up the not-yet-filled-in child deparse_columns structs */
4246
4247 /*
4248 * If this join is unnamed, then we cannot substitute new aliases at
4249 * this level, so any name requirements pushed down to here must be
4250 * pushed down again to the children.
4251 */
4253 {
4255 {
4257
4259 continue;
4260
4261 /* Push down to left column, unless it's a system column */
4263 {
4266 }
4267
4268 /* Same on the righthand side */
4270 {
4273 }
4274 }
4275 }
4276
4277 /*
4278 * If there's a USING clause, select the USING column names and push
4279 * those names down to the children. We have two strategies:
4280 *
4281 * If dpns->unique_using is true, we force all USING names to be
4282 * unique across the whole query level. In principle we'd only need
4283 * the names of dangerous USING columns to be globally unique, but to
4284 * safely assign all USING names in a single pass, we have to enforce
4285 * the same uniqueness rule for all of them. However, if a USING
4286 * column's name has been pushed down from the parent, we should use
4287 * it as-is rather than making a uniqueness adjustment. This is
4288 * necessary when we're at an unnamed join, and it creates no risk of
4289 * ambiguity. Also, if there's a user-written output alias for a
4290 * merged column, we prefer to use that rather than the input name;
4291 * this simplifies the logic and seems likely to lead to less aliasing
4292 * overall.
4293 *
4294 * If dpns->unique_using is false, we only need USING names to be
4295 * unique within their own join RTE. We still need to honor
4296 * pushed-down names, though.
4297 *
4298 * Though significantly different in results, these two strategies are
4299 * implemented by the same code, with only the difference of whether
4300 * to put assigned names into dpns->using_names.
4301 */
4303 {
4304 /* Copy the input parentUsing list so we don't modify it */
4305 parentUsing = list_copy(parentUsing);
4306
4307 /* USING names must correspond to the first join output columns */
4309 i = 0;
4311 {
4313
4314 /* Assert it's a merged column */
4316
4317 /* Adopt passed-down name if any, else select unique name */
4320 else
4321 {
4322 /* Prefer user-written output alias if any */
4325 /* Make it appropriately unique */
4329 colname);
4330 /* Save it as output column name, too */
4332 }
4333
4334 /* Remember selected names for use later */
4336 parentUsing = lappend(parentUsing, colname);
4337
4338 /* Push down to left column, unless it's a system column */
4340 {
4343 }
4344
4345 /* Same on the righthand side */
4347 {
4350 }
4351
4352 i++;
4353 }
4354 }
4355
4356 /* Mark child deparse_columns structs with correct parentUsing info */
4357 leftcolinfo->parentUsing = parentUsing;
4358 rightcolinfo->parentUsing = parentUsing;
4359
4360 /* Now recursively assign USING column names in children */
4363 }
4364 else
4367}
4368
4369/*
4370 * set_relation_column_names: select column aliases for a non-join RTE
4371 *
4372 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4373 * If any colnames entries are already filled in, those override local
4374 * choices.
4375 */
4376static void
4379{
4380 int ncolumns;
4386
4387 /*
4388 * Construct an array of the current "real" column names of the RTE.
4389 * real_colnames[] will be indexed by physical column number, with NULL
4390 * entries for dropped columns.
4391 */
4393 {
4394 /* Relation --- look to the system catalogs for up-to-date info */
4395 Relation rel;
4396 TupleDesc tupdesc;
4397
4399 tupdesc = RelationGetDescr(rel);
4400
4401 ncolumns = tupdesc->natts;
4403
4405 {
4407
4408 if (attr->attisdropped)
4410 else
4412 }
4414 }
4415 else
4416 {
4417 /* Otherwise get the column names from eref or expandRTE() */
4418 List *colnames;
4420
4421 /*
4422 * Functions returning composites have the annoying property that some
4423 * of the composite type's columns might have been dropped since the
4424 * query was parsed. If possible, use expandRTE() to handle that
4425 * case, since it has the tedious logic needed to find out about
4426 * dropped columns. However, if we're explaining a plan, then we
4427 * don't have rte->functions because the planner thinks that won't be
4428 * needed later, and that breaks expandRTE(). So in that case we have
4429 * to rely on rte->eref, which may lead us to report a dropped
4430 * column's old name; that seems close enough for EXPLAIN's purposes.
4431 *
4432 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4433 * which should be sufficiently up-to-date: no other RTE types can
4434 * have columns get dropped from under them after parsing.
4435 */
4437 {
4438 /* Since we're not creating Vars, rtindex etc. don't matter */
4441 }
4442 else
4443 colnames = rte->eref->colnames;
4444
4445 ncolumns = list_length(colnames);
4447
4448 i = 0;
4450 {
4451 /*
4452 * If the column name we find here is an empty string, then it's a
4453 * dropped column, so change to NULL.
4454 */
4456
4460 i++;
4461 }
4462 }
4463
4464 /*
4465 * Ensure colinfo->colnames has a slot for each column. (It could be long
4466 * enough already, if we pushed down a name for the last column.) Note:
4467 * it's possible that there are now more columns than there were when the
4468 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4469 * We must assign unique aliases to the new columns too, else there could
4470 * be unresolved conflicts when the view/rule is reloaded.
4471 */
4474
4475 /*
4476 * Make sufficiently large new_colnames and is_new_col arrays, too.
4477 *
4478 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4479 * colname_is_unique will not consult that array, which is fine because it
4480 * would only be duplicate effort.
4481 */
4484
4485 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4487
4488 /*
4489 * Scan the columns, select a unique alias for each one, and store it in
4490 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4491 * entries for dropped columns, the latter omits them. Also mark
4492 * new_colnames entries as to whether they are new since parse time; this
4493 * is the case for entries beyond the length of rte->eref->colnames.
4494 */
4497 j = 0;
4499 {
4502
4503 /* Skip dropped columns */
4505 {
4507 continue;
4508 }
4509
4510 /* If alias already assigned, that's what to use */
4512 {
4513 /* If user wrote an alias, prefer that over real column name */
4516 else
4517 colname = real_colname;
4518
4519 /* Unique-ify and insert into colinfo */
4521
4524 }
4525
4526 /* Put names of non-dropped columns in new_colnames[] too */
4528 /* And mark them as new or not */
4530 j++;
4531
4532 /* Remember if any assigned aliases differ from "real" name */
4535 }
4536
4537 /* We're now done needing the colinfo's names_hash */
4539
4540 /*
4541 * Set correct length for new_colnames[] array. (Note: if columns have
4542 * been added, colinfo->num_cols includes them, which is not really quite
4543 * right but is harmless, since any new columns must be at the end where
4544 * they won't affect varattnos of pre-existing columns.)
4545 */
4547
4548 /*
4549 * For a relation RTE, we need only print the alias column names if any
4550 * are different from the underlying "real" names. For a function RTE,
4551 * always emit a complete column alias list; this is to protect against
4552 * possible instability of the default column names (eg, from altering
4553 * parameter names). For tablefunc RTEs, we never print aliases, because
4554 * the column names are part of the clause itself. For other RTE types,
4555 * print if we changed anything OR if there were user-written column
4556 * aliases (since the latter would be part of the underlying "reality").
4557 */
4566 else
4568}
4569
4570/*
4571 * set_join_column_names: select column aliases for a join RTE
4572 *
4573 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4574 * If any colnames entries are already filled in, those override local
4575 * choices. Also, names for USING columns were already chosen by
4576 * set_using_names(). We further expect that column alias selection has been
4577 * completed for both input RTEs.
4578 */
4579static void
4582{
4594
4595 /* Look up the previously-filled-in child deparse_columns structs */
4598
4599 /*
4600 * Ensure colinfo->colnames has a slot for each column. (It could be long
4601 * enough already, if we pushed down a name for the last column.) Note:
4602 * it's possible that one or both inputs now have more columns than there
4603 * were when the query was parsed, but we'll deal with that below. We
4604 * only need entries in colnames for pre-existing columns.
4605 */
4609
4610 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4612
4613 /*
4614 * Scan the join output columns, select an alias for each one, and store
4615 * it in colinfo->colnames. If there are USING columns, set_using_names()
4616 * already selected their names, so we can start the loop at the first
4617 * non-merged column.
4618 */
4621 {
4624
4625 /* Join column must refer to at least one input column */
4627
4628 /* Get the child column name */
4633 else
4634 {
4635 /* We're joining system columns --- use eref name */
4637 }
4638
4639 /* If child col has been dropped, no need to assign a join colname */
4641 {
4643 continue;
4644 }
4645
4646 /* In an unnamed join, just report child column names as-is */
4648 {
4651 continue;
4652 }
4653
4654 /* If alias already assigned, that's what to use */
4656 {
4657 /* If user wrote an alias, prefer that over real column name */
4660 else
4661 colname = real_colname;
4662
4663 /* Unique-ify and insert into colinfo */
4665
4668 }
4669
4670 /* Remember if any assigned aliases differ from "real" name */
4673 }
4674
4675 /*
4676 * Calculate number of columns the join would have if it were re-parsed
4677 * now, and create storage for the new_colnames and is_new_col arrays.
4678 *
4679 * Note: colname_is_unique will be consulting new_colnames[] during the
4680 * loops below, so its not-yet-filled entries must be zeroes.
4681 */
4687
4688 /*
4689 * Generating the new_colnames array is a bit tricky since any new columns
4690 * added since parse time must be inserted in the right places. This code
4691 * must match the parser, which will order a join's columns as merged
4692 * columns first (in USING-clause order), then non-merged columns from the
4693 * left input (in attnum order), then non-merged columns from the right
4694 * input (ditto). If one of the inputs is itself a join, its columns will
4695 * be ordered according to the same rule, which means newly-added columns
4696 * might not be at the end. We can figure out what's what by consulting
4697 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
4698 *
4699 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
4700 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
4701 * meanings for the current child RTE.
4702 */
4703
4704 /* Handle merged columns; they are first and can't be new */
4709 {
4710 /* column name is already determined and known unique */
4713
4714 /* build bitmapsets of child attnums of merged columns */
4719
4721 }
4722
4723 /* Handle non-merged left-child columns */
4724 ic = 0;
4726 {
4728
4730 {
4731 /* Advance ic to next non-dropped old column of left child */
4734 ic++;
4736 ic++;
4737 /* If it is a merged column, we already processed it */
4739 continue;
4740 /* Else, advance i to the corresponding existing join column */
4743 i++;
4746 /* Use the already-assigned name of this column */
4748 i++;
4749 }
4750 else
4751 {
4752 /*
4753 * Unique-ify the new child column name and assign, unless we're
4754 * in an unnamed join, in which case just copy
4755 */
4757 {
4763 }
4764 else
4767 }
4768
4770 j++;
4771 }
4772
4773 /* Handle non-merged right-child columns in exactly the same way */
4774 ic = 0;
4776 {
4778
4780 {
4781 /* Advance ic to next non-dropped old column of right child */
4784 ic++;
4786 ic++;
4787 /* If it is a merged column, we already processed it */
4789 continue;
4790 /* Else, advance i to the corresponding existing join column */
4793 i++;
4796 /* Use the already-assigned name of this column */
4798 i++;
4799 }
4800 else
4801 {
4802 /*
4803 * Unique-ify the new child column name and assign, unless we're
4804 * in an unnamed join, in which case just copy
4805 */
4807 {
4813 }
4814 else
4817 }
4818
4820 j++;
4821 }
4822
4823 /* Assert we processed the right number of columns */
4824#ifdef USE_ASSERT_CHECKING
4826 i++;
4829#endif
4830
4831 /* We're now done needing the colinfo's names_hash */
4833
4834 /*
4835 * For a named join, print column aliases if we changed any from the child
4836 * names. Unnamed joins cannot print aliases.
4837 */
4840 else
4842}
4843
4844/*
4845 * colname_is_unique: is colname distinct from already-chosen column names?
4846 *
4847 * dpns is query-wide info, colinfo is for the column's RTE
4848 */
4849static bool
4852{
4855
4856 /*
4857 * If we have a hash table, consult that instead of linearly scanning the
4858 * colinfo's strings.
4859 */
4861 {
4863 colname,
4864 HASH_FIND,
4866 return false;
4867 }
4868 else
4869 {
4870 /* Check against already-assigned column aliases within RTE */
4872 {
4874
4876 return false;
4877 }
4878
4879 /*
4880 * If we're building a new_colnames array, check that too (this will
4881 * be partially but not completely redundant with the previous checks)
4882 */
4884 {
4886
4888 return false;
4889 }
4890
4891 /*
4892 * Also check against names already assigned for parent-join USING
4893 * cols
4894 */
4896 {
4898
4900 return false;
4901 }
4902 }
4903
4904 /*
4905 * Also check against USING-column names that must be globally unique.
4906 * These are not hashed, but there should be few of them.
4907 */
4909 {
4911
4913 return false;
4914 }
4915
4916 return true;
4917}
4918
4919/*
4920 * make_colname_unique: modify colname if necessary to make it unique
4921 *
4922 * dpns is query-wide info, colinfo is for the column's RTE
4923 */
4924static char *
4927{
4928 /*
4929 * If the selected name isn't unique, append digits to make it so. For a
4930 * very long input name, we might have to truncate to stay within
4931 * NAMEDATALEN.
4932 */
4934 {
4938
4939 do
4940 {
4941 i++;
4942 for (;;)
4943 {
4947 break;
4948 /* drop chars from colname to keep all the digits */
4950 colnamelen - 1);
4951 }
4953 colname = modname;
4954 }
4955 return colname;
4956}
4957
4958/*
4959 * expand_colnames_array_to: make colinfo->colnames at least n items long
4960 *
4961 * Any added array entries are initialized to zero.
4962 */
4963static void
4965{
4967 {
4970 else
4972 colinfo->num_cols = n;
4973 }
4974}
4975
4976/*
4977 * build_colinfo_names_hash: optionally construct a hash table for colinfo
4978 */
4979static void
4981{
4985
4986 /*
4987 * Use a hash table only for RTEs with at least 32 columns. (The cutoff
4988 * is somewhat arbitrary, but let's choose it so that this code does get
4989 * exercised in the regression tests.)
4990 */
4992 return;
4993
4994 /*
4995 * Set up the hash table. The entries are just strings with no other
4996 * payload.
4997 */
5003 &hash_ctl,
5005
5006 /*
5007 * Preload the hash table with any names already present (these would have
5008 * come from set_using_names).
5009 */
5011 {
5013
5016 }
5017
5019 {
5021
5024 }
5025
5027 {
5029
5031 }
5032}
5033
5034/*
5035 * add_to_names_hash: add a string to the names_hash, if we're using one
5036 */
5037static void
5039{
5042 name,
5043 HASH_ENTER,
5044 NULL);
5045}
5046
5047/*
5048 * destroy_colinfo_names_hash: destroy hash table when done with it
5049 */
5050static void
5052{
5054 {
5057 }
5058}
5059
5060/*
5061 * identify_join_columns: figure out where columns of a join come from
5062 *
5063 * Fills the join-specific fields of the colinfo struct, except for
5064 * usingNames which is filled later.
5065 */
5066static void
5069{
5074
5075 /* Extract left/right child RT indexes */
5080 else
5087 else
5090
5091 /* Assert children will be processed earlier than join in second pass */
5094
5095 /* Initialize result arrays with zeroes */
5100
5101 /*
5102 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
5103 * Recall that the column(s) merged due to USING are the first column(s)
5104 * of the join output. We need not do anything special while scanning
5105 * joinleftcols, but while scanning joinrightcols we must distinguish
5106 * merged from unmerged columns.
5107 */
5108 jcolno = 0;
5110 {
5112
5114 }
5115 rcolno = 0;
5117 {
5119
5122 else
5124 rcolno++;
5125 }
5127}
5128
5129/*
5130 * get_rtable_name: convenience function to get a previously assigned RTE alias
5131 *
5132 * The RTE must belong to the topmost namespace level in "context".
5133 */
5134static char *
5136{
5138
5141}
5142
5143/*
5144 * set_deparse_plan: set up deparse_namespace to parse subexpressions
5145 * of a given Plan node
5146 *
5147 * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
5148 * and index_tlist fields. Caller must already have adjusted the ancestors
5149 * list if necessary. Note that the rtable, subplans, and ctes fields do
5150 * not need to change when shifting attention to different plan nodes in a
5151 * single plan tree.
5152 */
5153static void
5155{
5157
5158 /*
5159 * We special-case Append and MergeAppend to pretend that the first child
5160 * plan is the OUTER referent; we have to interpret OUTER Vars in their
5161 * tlists according to one of the children, and the first one is the most
5162 * natural choice.
5163 */
5168 else
5170
5173 else
5175
5176 /*
5177 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
5178 * use OUTER because that could someday conflict with the normal meaning.)
5179 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
5180 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
5181 * that as INNER referent.
5182 *
5183 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
5184 * INNER referent. This is the join from the target relation to the data
5185 * source, and all INNER_VAR Vars in other parts of the query refer to its
5186 * targetlist.
5187 *
5188 * For ON CONFLICT .. UPDATE we just need the inner tlist to point to the
5189 * excluded expression's tlist. (Similar to the SubqueryScan we don't want
5190 * to reuse OUTER, it's used for RETURNING in some modify table cases,
5191 * although not INSERT .. CONFLICT).
5192 */
5202 {
5205 else
5207 }
5208 else
5210
5215 else
5217
5218 /* Set up referent for INDEX_VAR Vars, if needed */
5225 else
5227}
5228
5229/*
5230 * Locate the ancestor plan node that is the RecursiveUnion generating
5231 * the WorkTableScan's work table. We can match on wtParam, since that
5232 * should be unique within the plan tree.
5233 */
5236{
5238
5240 {
5242
5246 }
5248 wtscan->wtParam);
5250}
5251
5252/*
5253 * push_child_plan: temporarily transfer deparsing attention to a child plan
5254 *
5255 * When expanding an OUTER_VAR or INNER_VAR reference, we must adjust the
5256 * deparse context in case the referenced expression itself uses
5257 * OUTER_VAR/INNER_VAR. We modify the top stack entry in-place to avoid
5258 * affecting levelsup issues (although in a Plan tree there really shouldn't
5259 * be any).
5260 *
5261 * Caller must provide a local deparse_namespace variable to save the
5262 * previous state for pop_child_plan.
5263 */
5264static void
5267{
5268 /* Save state for restoration later */
5270
5271 /* Link current plan node into ancestors list */
5273
5274 /* Set attention on selected child */
5276}
5277
5278/*
5279 * pop_child_plan: undo the effects of push_child_plan
5280 */
5281static void
5283{
5284 List *ancestors;
5285
5286 /* Get rid of ancestors list cell added by push_child_plan */
5288
5289 /* Restore fields changed by push_child_plan */
5291
5292 /* Make sure dpns->ancestors is right (may be unnecessary) */
5293 dpns->ancestors = ancestors;
5294}
5295
5296/*
5297 * push_ancestor_plan: temporarily transfer deparsing attention to an
5298 * ancestor plan
5299 *
5300 * When expanding a Param reference, we must adjust the deparse context
5301 * to match the plan node that contains the expression being printed;
5302 * otherwise we'd fail if that expression itself contains a Param or
5303 * OUTER_VAR/INNER_VAR/INDEX_VAR variable.
5304 *
5305 * The target ancestor is conveniently identified by the ListCell holding it
5306 * in dpns->ancestors.
5307 *
5308 * Caller must provide a local deparse_namespace variable to save the
5309 * previous state for pop_ancestor_plan.
5310 */
5311static void
5314{
5316
5317 /* Save state for restoration later */
5319
5320 /* Build a new ancestor list with just this node's ancestors */
5321 dpns->ancestors =
5324
5325 /* Set attention on selected ancestor */
5327}
5328
5329/*
5330 * pop_ancestor_plan: undo the effects of push_ancestor_plan
5331 */
5332static void
5334{
5335 /* Free the ancestor list made in push_ancestor_plan */
5337
5338 /* Restore fields changed by push_ancestor_plan */
5340}
5341
5342
5343/* ----------
5344 * make_ruledef - reconstruct the CREATE RULE command
5345 * for a given pg_rewrite tuple
5346 * ----------
5347 */
5348static void
5350 int prettyFlags)
5351{
5352 char *rulename;
5353 char ev_type;
5355 bool is_instead;
5358 List *actions;
5363 bool isnull;
5364
5365 /*
5366 * Get the attribute values from the rules tuple
5367 */
5370 Assert(!isnull);
5372
5375 Assert(!isnull);
5377
5380 Assert(!isnull);
5382
5385 Assert(!isnull);
5387
5391
5398
5400
5401 /*
5402 * Build the rules definition text
5403 */
5405 quote_identifier(rulename));
5406
5409 else
5411
5412 /* The event the rule is fired for */
5413 switch (ev_type)
5414 {
5415 case '1':
5418 break;
5419
5420 case '2':
5422 break;
5423
5424 case '3':
5426 break;
5427
5428 case '4':
5430 break;
5431
5432 default:
5436 rulename, ev_type)));
5437 break;
5438 }
5439
5440 /* The relation the rule is fired on */
5442 (prettyFlags & PRETTYFLAG_SCHEMA) ?
5445
5446 /* If the rule has an event qualification, add it */
5448 {
5449 Node *qual;
5450 Query *query;
5451 deparse_context context;
5453
5457
5459
5460 /*
5461 * We need to make a context for recognizing any Vars in the qual
5462 * (which can only be references to OLD and NEW). Use the rtable of
5463 * the first query in the action list for this purpose.
5464 */
5466
5467 /*
5468 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5469 * into the SELECT, and that's what we need to look at. (Ugly kluge
5470 * ... try to fix this when we redesign querytrees.)
5471 */
5473
5474 /* Must acquire locks right away; see notes in get_query_def() */
5476
5483 context.prettyFlags = prettyFlags;
5490
5492
5494 }
5495
5497
5498 /* The INSTEAD keyword (if so) */
5499 if (is_instead)
5501
5502 /* Finally the rules actions */
5504 {
5506 Query *query;
5507
5509 foreach(action, actions)
5510 {
5513 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5514 if (prettyFlags)
5516 else
5518 }
5520 }
5521 else
5522 {
5523 Query *query;
5524
5527 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5529 }
5530
5532}
5533
5534
5535/* ----------
5536 * make_viewdef - reconstruct the SELECT part of a
5537 * view rewrite rule
5538 * ----------
5539 */
5540static void
5542 int prettyFlags, int wrapColumn)
5543{
5544 Query *query;
5545 char ev_type;
5547 bool is_instead;
5550 List *actions;
5554 bool isnull;
5555
5556 /*
5557 * Get the attribute values from the rules tuple
5558 */
5561 Assert(!isnull);
5563
5566 Assert(!isnull);
5568
5571 Assert(!isnull);
5573
5577
5582
5584 {
5585 /* keep output buffer empty and leave */
5586 return;
5587 }
5588
5590
5591 if (ev_type != '1' || !is_instead ||
5593 {
5594 /* keep output buffer empty and leave */
5595 return;
5596 }
5597
5599
5601 prettyFlags, wrapColumn, 0);
5603
5605}
5606
5607
5608/* ----------
5609 * get_query_def - Parse back one query parsetree
5610 *
5611 * query: parsetree to be displayed
5612 * buf: output text is appended to buf
5613 * parentnamespace: list (initially empty) of outer-level deparse_namespace's
5614 * resultDesc: if not NULL, the output tuple descriptor for the view
5615 * represented by a SELECT query. We use the column names from it
5616 * to label SELECT output columns, in preference to names in the query
5617 * colNamesVisible: true if the surrounding context cares about the output
5618 * column names at all (as, for example, an EXISTS() context does not);
5619 * when false, we can suppress dummy column labels such as "?column?"
5620 * prettyFlags: bitmask of PRETTYFLAG_XXX options
5621 * wrapColumn: maximum line length, or -1 to disable wrapping
5622 * startIndent: initial indentation amount
5623 * ----------
5624 */
5625static void
5629{
5630 deparse_context context;
5632 int rtable_size;
5633
5634 /* Guard against excessively long or deeply-nested queries */
5635 CHECK_FOR_INTERRUPTS();
5636 check_stack_depth();
5637
5638 rtable_size = query->hasGroupRTE ?
5641
5642 /*
5643 * Replace any Vars in the query's targetlist and havingQual that
5644 * reference GROUP outputs with the underlying grouping expressions.
5645 */
5646 if (query->hasGroupRTE)
5647 {
5650 query->havingQual =
5652 }
5653
5654 /*
5655 * Before we begin to examine the query, acquire locks on referenced
5656 * relations, and fix up deleted columns in JOIN RTEs. This ensures
5657 * consistent results. Note we assume it's OK to scribble on the passed
5658 * querytree!
5659 *
5660 * We are only deparsing the query (we are not about to execute it), so we
5661 * only need AccessShareLock on the relations it mentions.
5662 */
5664
5671 rtable_size != 1);
5672 context.prettyFlags = prettyFlags;
5673 context.wrapColumn = wrapColumn;
5675 context.colNamesVisible = colNamesVisible;
5679
5681
5683 {
5685 /* We set context.resultDesc only if it's a SELECT */
5686 context.resultDesc = resultDesc;
5687 get_select_query_def(query, &context);
5688 break;
5689
5691 get_update_query_def(query, &context);
5692 break;
5693
5695 get_insert_query_def(query, &context);
5696 break;
5697
5699 get_delete_query_def(query, &context);
5700 break;
5701
5703 get_merge_query_def(query, &context);
5704 break;
5705
5708 break;
5709
5711 get_utility_query_def(query, &context);
5712 break;
5713
5714 default:
5716 query->commandType);
5717 break;
5718 }
5719}
5720
5721/* ----------
5722 * get_values_def - Parse back a VALUES list
5723 * ----------
5724 */
5725static void
5727{
5731
5733
5735 {
5739
5742 else
5744
5747 {
5749
5752 else
5754
5755 /*
5756 * Print the value. Whole-row Vars need special treatment.
5757 */
5759 }
5761 }
5762}
5763
5764/* ----------
5765 * get_with_clause - Parse back a WITH clause
5766 * ----------
5767 */
5768static void
5770{
5773 ListCell *l;
5774
5776 return;
5777
5779 {
5782 }
5783
5784 if (query->hasRecursive)
5786 else
5789 {
5791
5794 if (cte->aliascolnames)
5795 {
5796 bool first = true;
5798
5801 {
5802 if (first)
5803 first = false;
5804 else
5808 }
5810 }
5813 {
5815 break;
5818 break;
5821 break;
5822 }
5827 true,
5829 context->indentLevel);
5833
5834 if (cte->search_clause)
5835 {
5836 bool first = true;
5838
5840 cte->search_clause->search_breadth_first ? "BREADTH" : "DEPTH");
5841
5843 {
5844 if (first)
5845 first = false;
5846 else
5850 }
5851
5853 }
5854
5855 if (cte->cycle_clause)
5856 {
5857 bool first = true;
5859
5861
5863 {
5864 if (first)
5865 first = false;
5866 else
5870 }
5871
5873
5874 {
5877
5878 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
5880 {
5885 }
5886 }
5887
5889 }
5890
5892 }
5893
5895 {
5898 }
5899 else
5901}
5902
5903/* ----------
5904 * get_select_query_def - Parse back a SELECT parsetree
5905 * ----------
5906 */
5907static void
5909{
5912 ListCell *l;
5913
5914 /* Insert the WITH clause if given */
5915 get_with_clause(query, context);
5916
5917 /* Subroutines may need to consult the SELECT targetlist and windowClause */
5920
5921 /*
5922 * If the Query node has a setOperations tree, then it's the top level of
5923 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
5924 * fields are interesting in the top query itself.
5925 */
5927 {
5929 /* ORDER BY clauses must be simple in this case */
5931 }
5932 else
5933 {
5934 get_basic_select_query(query, context);
5936 }
5937
5938 /* Add the ORDER BY clause if given */
5940 {
5944 force_colno, context);
5945 }
5946
5947 /*
5948 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
5949 * standard spelling of LIMIT.
5950 */
5952 {
5956 }
5958 {
5960 {
5961 /*
5962 * The limitCount arg is a c_expr, so it needs parens. Simple
5963 * literals and function expressions would not need parens, but
5964 * unfortunately it's hard to tell if the expression will be
5965 * printed as a simple literal like 123 or as a typecast
5966 * expression, like '-123'::int4. The grammar accepts the former
5967 * without quoting, but not the latter.
5968 */
5975 }
5976 else
5977 {
5983 else
5985 }
5986 }
5987
5988 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
5989 if (query->hasForUpdate)
5990 {
5992 {
5994
5995 /* don't print implicit clauses */
5997 continue;
5998
6000 {
6002 /* we intentionally throw an error for LCS_NONE */
6005 break;
6009 break;
6013 break;
6017 break;
6021 break;
6022 }
6023
6026 context)));
6031 }
6032 }
6033}
6034
6035/*
6036 * Detect whether query looks like SELECT ... FROM VALUES(),
6037 * with no need to rename the output columns of the VALUES RTE.
6038 * If so, return the VALUES RTE. Otherwise return NULL.
6039 */
6042{
6045
6046 /*
6047 * We want to detect a match even if the Query also contains OLD or NEW
6048 * rule RTEs. So the idea is to scan the rtable and see if there is only
6049 * one inFromCl RTE that is a VALUES RTE.
6050 */
6052 {
6054
6056 {
6057 if (result)
6059 result = rte;
6060 }
6062 continue; /* ignore rule entries */
6063 else
6065 }
6066
6067 /*
6068 * We don't need to check the targetlist in any great detail, because
6069 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6070 * appear inside auto-generated sub-queries with very restricted
6071 * structure. However, DefineView might have modified the tlist by
6072 * injecting new column aliases, or we might have some other column
6073 * aliases forced by a resultDesc. We can only simplify if the RTE's
6074 * column names match the names that get_target_list() would select.
6075 */
6076 if (result)
6077 {
6079 int colno;
6080
6083 colno = 0;
6085 {
6088 char *colname;
6089
6092
6093 /* compute name that get_target_list would use for column */
6094 colno++;
6097 else
6098 colname = tle->resname;
6099
6100 /* does it match the VALUES RTE? */
6103 }
6104 }
6105
6106 return result;
6107}
6108
6109static void
6111{
6115 ListCell *l;
6116
6118 {
6121 }
6122
6123 /*
6124 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6125 * VALUES part. This reverses what transformValuesClause() did at parse
6126 * time.
6127 */
6130 {
6132 return;
6133 }
6134
6135 /*
6136 * Build up the query string - first we say SELECT
6137 */
6138 if (query->isReturn)
6140 else
6142
6143 /* Add the DISTINCT clause if given */
6145 {
6146 if (query->hasDistinctOn)
6147 {
6151 {
6153
6156 false, context);
6158 }
6160 }
6161 else
6163 }
6164
6165 /* Then we tell what to select (the targetlist) */
6167
6168 /* Add the FROM clause if needed */
6170
6171 /* Add the WHERE clause if given */
6173 {
6177 }
6178
6179 /* Add the GROUP BY clause if given */
6181 {
6183
6188
6191
6195 {
6198 {
6200
6203 false, context);
6205 }
6206 }
6207 else
6208 {
6211 {
6213
6217 }
6218 }
6219
6221 }
6222
6223 /* Add the HAVING clause if given */
6225 {
6229 }
6230
6231 /* Add the WINDOW clause if needed */
6233 get_rule_windowclause(query, context);
6234}
6235
6236/* ----------
6237 * get_target_list - Parse back a SELECT target list
6238 *
6239 * This is also used for RETURNING lists in INSERT/UPDATE/DELETE/MERGE.
6240 * ----------
6241 */
6242static void
6244{
6249 int colno;
6250 ListCell *l;
6251
6252 /* we use targetbuf to hold each TLE's text temporarily */
6254
6256 colno = 0;
6257 foreach(l, targetList)
6258 {
6260 char *colname;
6262
6264 continue; /* ignore junk entries */
6265
6268 colno++;
6269
6270 /*
6271 * Put the new field text into targetbuf so we can decide after we've
6272 * got it whether or not it needs to go on a new line.
6273 */
6276
6277 /*
6278 * We special-case Var nodes rather than using get_rule_expr. This is
6279 * needed because get_rule_expr will display a whole-row Var as
6280 * "foo.*", which is the preferred notation in most contexts, but at
6281 * the top level of a SELECT list it's not right (the parser will
6282 * expand that notation into multiple columns, yielding behavior
6283 * different from a whole-row Var). We need to call get_variable
6284 * directly so that we can tell it to do the right thing, and so that
6285 * we can get the attribute name which is the default AS label.
6286 */
6288 {
6290 }
6291 else
6292 {
6294
6295 /*
6296 * When colNamesVisible is true, we should always show the
6297 * assigned column name explicitly. Otherwise, show it only if
6298 * it's not FigureColname's fallback.
6299 */
6301 }
6302
6303 /*
6304 * Figure out what the result column should be called. In the context
6305 * of a view, use the view's tuple descriptor (so as to pick up the
6306 * effects of any column RENAME that's been done on the view).
6307 * Otherwise, just use what we can find in the TLE.
6308 */
6311 colno - 1)->attname);
6312 else
6313 colname = tle->resname;
6314
6315 /* Show AS unless the column's name is correct as-is */
6316 if (colname) /* resname could be NULL */
6317 {
6320 }
6321
6322 /* Restore context's output buffer */
6324
6325 /* Consider line-wrapping if enabled */
6327 {
6329
6330 /* Does the new field start with a new line? */
6332 leading_nl_pos = 0;
6333 else
6334 leading_nl_pos = -1;
6335
6336 /* If so, we shouldn't add anything */
6338 {
6339 /* instead, remove any trailing spaces currently in buf */
6341 }
6342 else
6343 {
6345
6346 /* Locate the start of the current line in the output buffer */
6350 else
6351 trailing_nl++;
6352
6353 /*
6354 * Add a newline, plus some indentation, if the new field is
6355 * not the first and either the new field would cause an
6356 * overflow or the last field used more than one line.
6357 */
6358 if (colno > 1 &&
6360 last_was_multiline))
6363 }
6364
6365 /* Remember this field's multiline status for next iteration */
6366 last_was_multiline =
6368 }
6369
6370 /* Add the new field */
6372 }
6373
6374 /* clean up */
6376}
6377
6378static void
6380{
6382
6384 {
6386
6389
6390 /* Add WITH (OLD/NEW) options, if they're not the defaults */
6392 {
6394 quote_identifier(query->returningOldAlias));
6396 }
6398 {
6401 quote_identifier(query->returningNewAlias));
6402 else
6403 {
6405 quote_identifier(query->returningNewAlias));
6407 }
6408 }
6411
6412 /* Add the returning expressions themselves */
6414 }
6415}
6416
6417static void
6419{
6422
6423 /* Guard against excessively long or deeply-nested queries */
6424 CHECK_FOR_INTERRUPTS();
6425 check_stack_depth();
6426
6428 {
6432
6434
6435 /*
6436 * We need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y.
6437 * Also add parens if the leaf query contains its own set operations.
6438 * (That shouldn't happen unless one of the other clauses is also
6439 * present, see transformSetOperationTree; but let's be safe.)
6440 */
6442 subquery->sortClause ||
6443 subquery->rowMarks ||
6444 subquery->limitOffset ||
6445 subquery->limitCount ||
6446 subquery->setOperations);
6452 context->indentLevel);
6455 }
6457 {
6461
6462 /*
6463 * We force parens when nesting two SetOperationStmts, except when the
6464 * lefthand input is another setop of the same kind. Syntactically,
6465 * we could omit parens in rather more cases, but it seems best to use
6466 * parens to flag cases where the setop operator changes. If we use
6467 * parens, we also increase the indentation level for the child query.
6468 *
6469 * There are some cases in which parens are needed around a leaf query
6470 * too, but those are more easily handled at the next level down (see
6471 * code above).
6472 */
6474 {
6476
6479 else
6481 }
6482 else
6484
6486 {
6490 }
6491 else
6492 subindent = 0;
6493
6495
6500 else
6502
6504 {
6507 break;
6510 break;
6513 break;
6514 default:
6517 }
6520
6521 /* Always parenthesize if RHS is another setop */
6523
6524 /*
6525 * The indentation code here is deliberately a bit different from that
6526 * for the lefthand input, because we want the line breaks in
6527 * different places.
6528 */
6530 {
6533 }
6534 else
6535 subindent = 0;
6537
6538 /*
6539 * The output column names of the RHS sub-select don't matter.
6540 */
6543
6545
6547
6552 }
6553 else
6554 {
6557 }
6558}
6559
6560/*
6561 * Display a sort/group clause.
6562 *
6563 * Also returns the expression tree, so caller need not find it again.
6564 */
6567 deparse_context *context)
6568{
6571 Node *expr;
6572
6575
6576 /*
6577 * Use column-number form if requested by caller. Otherwise, if
6578 * expression is a constant, force it to be dumped with an explicit cast
6579 * as decoration --- this is because a simple integer constant is
6580 * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
6581 * we dump it without any decoration. Similarly, if it's just a Var,
6582 * there is risk of misinterpretation if the column name is reassigned in
6583 * the SELECT list, so we may need to force table qualification. And, if
6584 * it's anything more complex than a simple Var, then force extra parens
6585 * around it, to ensure it can't be misinterpreted as a cube() or rollup()
6586 * construct.
6587 */
6589 {
6592 }
6593 else if (!expr)
6594 /* do nothing, probably can't happen */ ;
6598 {
6599 /* Tell get_variable to check for name conflict */
6601
6605 }
6606 else
6607 {
6608 /*
6609 * We must force parens for function-like expressions even if
6610 * PRETTY_PAREN is off, since those are the ones in danger of
6611 * misparsing. For other expressions we need to force them only if
6612 * PRETTY_PAREN is on, since otherwise the expression will output them
6613 * itself. (We can't skip the parens.)
6614 */
6620
6626 }
6627
6628 return expr;
6629}
6630
6631/*
6632 * Display a GroupingSet
6633 */
6634static void
6637{
6638 ListCell *l;
6642
6644 {
6647 return;
6648
6650 {
6653
6655 {
6657
6660 false, context);
6662 }
6663
6666 }
6667 return;
6668
6671 break;
6674 break;
6678 break;
6679 }
6680
6682 {
6686 }
6687
6689}
6690
6691/*
6692 * Display an ORDER BY list.
6693 */
6694static void
6697{
6700 ListCell *l;
6701
6704 {
6708 TypeCacheEntry *typentry;
6709
6712 force_colno, context);
6714 /* See whether operator is default < or > for datatype */
6718 {
6719 /* ASC is default, so emit nothing for it */
6722 }
6724 {
6726 /* DESC defaults to NULLS FIRST */
6729 }
6730 else
6731 {
6734 sortcoltype,
6735 sortcoltype));
6736 /* be specific to eliminate ambiguity */
6739 else
6741 }
6743 }
6744}
6745
6746/*
6747 * Display a WINDOW clause.
6748 *
6749 * Note that the windowClause list might contain only anonymous window
6750 * specifications, in which case we should print nothing here.
6751 */
6752static void
6754{
6757 ListCell *l;
6758
6761 {
6763
6765 continue; /* ignore anonymous windows */
6766
6770 else
6772
6774
6776
6778 }
6779}
6780
6781/*
6782 * Display a window definition
6783 */
6784static void
6786 deparse_context *context)
6787{
6791 ListCell *l;
6792
6794 if (wc->refname)
6795 {
6798 }
6799 /* partition clauses are always inherited, so only print if no refname */
6801 {
6807 {
6809
6812 false, context);
6814 }
6816 }
6817 /* print ordering clause only if not inherited */
6819 {
6825 }
6826 /* framing clause is never inherited, so print unless it's default */
6828 {
6833 context);
6834 }
6836}
6837
6838/*
6839 * Append the description of a window's framing options to context->buf
6840 */
6841static void
6844 deparse_context *context)
6845{
6847
6849 {
6856 else
6865 {
6871 else
6873 }
6874 else
6877 {
6884 {
6890 else
6892 }
6893 else
6895 }
6902 /* we will now have a trailing space; remove it */
6904 }
6905}
6906
6907/*
6908 * Return the description of a window's framing options as a palloc'd string
6909 */
6910char *
6914{
6916 deparse_context context;
6917
6925 context.prettyFlags = 0;
6927 context.indentLevel = 0;
6932
6933 get_window_frame_options(frameOptions, startOffset, endOffset, &context);
6934
6936}
6937
6938/* ----------
6939 * get_insert_query_def - Parse back an INSERT parsetree
6940 * ----------
6941 */
6942static void
6944{
6950 ListCell *l;
6952
6953 /* Insert the WITH clause if given */
6954 get_with_clause(query, context);
6955
6956 /*
6957 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
6958 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
6959 */
6961 {
6963
6965 {
6969 }
6970
6972 {
6976 }
6977 }
6980
6981 /*
6982 * Start the query with INSERT INTO relname
6983 */
6986
6988 {
6991 }
6994
6995 /* Print the relation alias, if needed; INSERT requires explicit AS */
6997
6998 /* always want a space here */
7000
7001 /*
7002 * Add the insert-column-names list. Any indirection decoration needed on
7003 * the column names can be inferred from the top targetlist.
7004 */
7010 {
7012
7014 continue; /* ignore junk entries */
7015
7018
7019 /*
7020 * Put out name of target column; look in the catalogs, not at
7021 * tle->resname, since resname will fail to track RENAME.
7022 */
7025 tle->resno,
7026 false)));
7027
7028 /*
7029 * Print any indirection needed (subfields or subscripts), and strip
7030 * off the top-level nodes representing the indirection assignments.
7031 * Add the stripped expressions to strippedexprs. (If it's a
7032 * single-VALUES statement, the stripped expressions are the VALUES to
7033 * print below. Otherwise they're just Vars and not really
7034 * interesting.)
7035 */
7038 context));
7039 }
7042
7043 if (query->override)
7044 {
7049 }
7050
7052 {
7053 /* Add the SELECT */
7055 false,
7057 context->indentLevel);
7058 }
7060 {
7061 /* Add the multi-VALUES expression lists */
7063 }
7065 {
7066 /* Add the single-VALUES expression list */
7071 }
7072 else
7073 {
7074 /* No expressions, so it must be DEFAULT VALUES */
7076 }
7077
7078 /* Add ON CONFLICT if present */
7080 {
7082
7084
7086 {
7087 /* Add the single-VALUES expression list */
7091
7092 /* Add a WHERE clause (for partial indexes) if given */
7094 {
7096
7097 /*
7098 * Force non-prefixing of Vars, since parser assumes that they
7099 * belong to target relation. WHERE clause does not use
7100 * InferenceElem, so this is separately required.
7101 */
7104
7108
7110 }
7111 }
7113 {
7115
7116 if (!constraint)
7118 confl->constraint);
7120 quote_identifier(constraint));
7121 }
7122
7124 {
7126 }
7127 else
7128 {
7130 /* Deparse targetlist */
7132 context, rte);
7133
7134 /* Add a WHERE clause if given */
7136 {
7140 }
7141 }
7142 }
7143
7144 /* Add RETURNING if present */
7146 get_returning_clause(query, context);
7147}
7148
7149
7150/* ----------
7151 * get_update_query_def - Parse back an UPDATE parsetree
7152 * ----------
7153 */
7154static void
7156{
7159
7160 /* Insert the WITH clause if given */
7161 get_with_clause(query, context);
7162
7163 /*
7164 * Start the query with UPDATE relname SET
7165 */
7169 {
7172 }
7176
7177 /* Print the relation alias, if needed */
7179
7181
7182 /* Deparse targetlist */
7184
7185 /* Add the FROM clause if needed */
7187
7188 /* Add a WHERE clause if given */
7190 {
7194 }
7195
7196 /* Add RETURNING if present */
7198 get_returning_clause(query, context);
7199}
7200
7201
7202/* ----------
7203 * get_update_query_targetlist_def - Parse back an UPDATE targetlist
7204 * ----------
7205 */
7206static void
7209{
7211 ListCell *l;
7217
7218 /*
7219 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
7220 * into a list. We expect them to appear, in ID order, in resjunk tlist
7221 * entries.
7222 */
7224 if (query->hasSubLinks) /* else there can't be any */
7225 {
7226 foreach(l, targetList)
7227 {
7229
7231 {
7233
7235 {
7238 }
7239 }
7240 }
7241 }
7244 remaining_ma_columns = 0;
7245
7246 /* Add the comma separated list of 'attname = value' */
7248 foreach(l, targetList)
7249 {
7251 Node *expr;
7252
7254 continue; /* ignore junk entries */
7255
7256 /* Emit separator (OK whether we're in multiassignment or not) */
7259
7260 /*
7261 * Check to see if we're starting a multiassignment group: if so,
7262 * output a left paren.
7263 */
7265 {
7266 /*
7267 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
7268 * Param. That could be buried under FieldStores and
7269 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
7270 * and underneath those there could be an implicit type coercion.
7271 * Because we would ignore implicit type coercions anyway, we
7272 * don't need to be as careful as processIndirection() is about
7273 * descending past implicit CoerceToDomains.
7274 */
7276 while (expr)
7277 {
7279 {
7281
7283 }
7285 {
7287
7289 break;
7290
7292 }
7294 {
7296
7298 break;
7300 }
7301 else
7302 break;
7303 }
7304 expr = strip_implicit_coercions(expr);
7305
7308 {
7311 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
7313 ((cur_ma_sublink->subLinkId << 16) | 1));
7315 }
7316 }
7317
7318 /*
7319 * Put out name of target column; look in the catalogs, not at
7320 * tle->resname, since resname will fail to track RENAME.
7321 */
7324 tle->resno,
7325 false)));
7326
7327 /*
7328 * Print any indirection needed (subfields or subscripts), and strip
7329 * off the top-level nodes representing the indirection assignments.
7330 */
7332
7333 /*
7334 * If we're in a multiassignment, skip printing anything more, unless
7335 * this is the last column; in which case, what we print should be the
7336 * sublink, not the Param.
7337 */
7339 {
7341 continue; /* not the last column of multiassignment */
7345 }
7346
7348
7350 }
7351}
7352
7353
7354/* ----------
7355 * get_delete_query_def - Parse back a DELETE parsetree
7356 * ----------
7357 */
7358static void
7360{
7363
7364 /* Insert the WITH clause if given */
7365 get_with_clause(query, context);
7366
7367 /*
7368 * Start the query with DELETE FROM relname
7369 */
7373 {
7376 }
7380
7381 /* Print the relation alias, if needed */
7383
7384 /* Add the USING clause if given */
7386
7387 /* Add a WHERE clause if given */
7389 {
7393 }
7394
7395 /* Add RETURNING if present */
7397 get_returning_clause(query, context);
7398}
7399
7400
7401/* ----------
7402 * get_merge_query_def - Parse back a MERGE parsetree
7403 * ----------
7404 */
7405static void
7407{
7412
7413 /* Insert the WITH clause if given */
7414 get_with_clause(query, context);
7415
7416 /*
7417 * Start the query with MERGE INTO relname
7418 */
7422 {
7425 }
7429
7430 /* Print the relation alias, if needed */
7432
7433 /* Print the source relation and join clause */
7438
7439 /*
7440 * Test for any NOT MATCHED BY SOURCE actions. If there are none, then
7441 * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
7442 * SQL standard. Otherwise, we have a non-SQL-standard query, so output
7443 * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
7444 * more explicit.
7445 */
7448 {
7450
7452 {
7454 break;
7455 }
7456 }
7457
7458 /* Print each merge action */
7460 {
7462
7466 {
7469 break;
7472 break;
7476 else
7478 break;
7479 default:
7482 }
7483
7485 {
7489 }
7492
7494 {
7495 /* This generally matches get_insert_query_def() */
7499
7501
7505 {
7507
7509
7512
7515 tle->resno,
7516 false)));
7519 context));
7520 }
7523
7525 {
7530 }
7531
7533 {
7538 }
7539 else
7541 }
7543 {
7546 context, rte);
7547 }
7552 }
7553
7554 /* Add RETURNING if present */
7556 get_returning_clause(query, context);
7557}
7558
7559
7560/* ----------
7561 * get_utility_query_def - Parse back a UTILITY parsetree
7562 * ----------
7563 */
7564static void
7566{
7568
7570 {
7572
7574 0, PRETTYINDENT_STD, 1);
7578 {
7581 }
7582 }
7583 else
7584 {
7585 /* Currently only NOTIFY utility commands can appear in rules */
7587 }
7588}
7589
7590/*
7591 * Display a Var appropriately.
7592 *
7593 * In some cases (currently only when recursing into an unnamed join)
7594 * the Var's varlevelsup has to be interpreted with respect to a context
7595 * above the current one; levelsup indicates the offset.
7596 *
7597 * If istoplevel is true, the Var is at the top level of a SELECT's
7598 * targetlist, which means we need special treatment of whole-row Vars.
7599 * Instead of the normal "tab.*", we'll print "tab.*::typename", which is a
7600 * dirty hack to prevent "tab.*" from being expanded into multiple columns.
7601 * (The parser will strip the useless coercion, so no inefficiency is added in
7602 * dump and reload.) We used to print just "tab" in such cases, but that is
7603 * ambiguous and will yield the wrong result if "tab" is also a plain column
7604 * name in the query.
7605 *
7606 * Returns the attname of the Var, or NULL if the Var has no attname (because
7607 * it is a whole-row Var or a subplan output reference).
7608 */
7609static char *
7611{
7617 int varno;
7618 AttrNumber varattno;
7620 char *refname;
7623
7624 /* Find appropriate nesting depth */
7628 var->varlevelsup, levelsup);
7630 netlevelsup);
7631
7632 /*
7633 * If we have a syntactic referent for the Var, and we're working from a
7634 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7635 * on the semantic referent. (Forcing use of the semantic referent when
7636 * printing plan trees is a design choice that's perhaps more motivated by
7637 * backwards compatibility than anything else. But it does have the
7638 * advantage of making plans more explicit.)
7639 */
7641 {
7642 varno = var->varnosyn;
7643 varattno = var->varattnosyn;
7644 }
7645 else
7646 {
7647 varno = var->varno;
7648 varattno = var->varattno;
7649 }
7650
7651 /*
7652 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7653 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7654 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
7655 * find the aliases previously assigned for this RTE.
7656 */
7658 {
7659 /*
7660 * We might have been asked to map child Vars to some parent relation.
7661 */
7663 {
7667 bool found = false;
7668
7669 /* Only map up to inheritance parents, not UNION ALL appendrels */
7673 {
7674 found = false;
7676 {
7678 break; /* safety check */
7681 break; /* Var is local to child */
7682 }
7683
7685 found = true;
7686
7687 /* If the parent is itself a child, continue up. */
7690 }
7691
7692 /*
7693 * If we found an ancestral rel, and that rel is included in
7694 * appendparents, print that column not the original one.
7695 */
7697 {
7698 varno = pvarno;
7699 varattno = pvarattno;
7700 }
7701 }
7702
7704
7705 /* might be returning old/new column value */
7707 refname = dpns->ret_old_alias;
7709 refname = dpns->ret_new_alias;
7710 else
7712
7714 attnum = varattno;
7715 }
7716 else
7717 {
7721 }
7722
7723 /*
7724 * The planner will sometimes emit Vars referencing resjunk elements of a
7725 * subquery's target list (this is currently only possible if it chooses
7726 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
7727 * Although we prefer to print subquery-referencing Vars using the
7728 * subquery's alias, that's not possible for resjunk items since they have
7729 * no alias. So in that case, drill down to the subplan and print the
7730 * contents of the referenced tlist item. This works because in a plan
7731 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
7732 * we'll have set dpns->inner_plan to reference the child plan node.
7733 */
7736 dpns->inner_plan)
7737 {
7740
7745
7748
7749 /*
7750 * Force parentheses because our caller probably assumed a Var is a
7751 * simple expression.
7752 */
7758
7761 }
7762
7763 /*
7764 * If it's an unnamed join, look at the expansion of the alias variable.
7765 * If it's a simple reference to one of the input vars, then recursively
7766 * print the name of that var instead. When it's not a simple reference,
7767 * we have to just print the unqualified join column name. (This can only
7768 * happen with "dangerous" merged columns in a JOIN USING; we took pains
7769 * previously to make the unqualified column name unique in such cases.)
7770 *
7771 * This wouldn't work in decompiling plan trees, because we don't store
7772 * joinaliasvars lists after planning; but a plan tree should never
7773 * contain a join alias variable.
7774 */
7776 {
7780 {
7782
7784 /* we intentionally don't strip implicit coercions here */
7786 {
7788 istoplevel, context);
7789 }
7790 }
7791
7792 /*
7793 * Unnamed join has no refname. (Note: since it's unnamed, there is
7794 * no way the user could have referenced it to create a whole-row Var
7795 * for it. So we don't have to cover that case below.)
7796 */
7798 }
7799
7803 {
7804 /* Get column name to use from the colinfo struct */
7809
7810 /*
7811 * If we find a Var referencing a dropped column, it seems better to
7812 * print something (anything) than to fail. In general this should
7813 * not happen, but it used to be possible for some cases involving
7814 * functions returning named composite types, and perhaps there are
7815 * still bugs out there.
7816 */
7819 }
7820 else
7821 {
7822 /* System column - name is fixed, get it from the catalog */
7824 }
7825
7828
7829 /*
7830 * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
7831 * clause, we may need to add a table-name prefix to prevent
7832 * findTargetlistEntrySQL92 from misinterpreting the name as an
7833 * output-column name. To avoid cluttering the output with unnecessary
7834 * prefixes, do so only if there is a name match to a SELECT tlist item
7835 * that is different from the Var.
7836 */
7838 {
7839 int colno = 0;
7840
7842 {
7843 char *colname;
7844
7846 continue; /* ignore junk entries */
7847 colno++;
7848
7849 /* This must match colname-choosing logic in get_target_list() */
7852 colno - 1)->attname);
7853 else
7854 colname = tle->resname;
7855
7858 {
7860 break;
7861 }
7862 }
7863 }
7864
7866 {
7869 }
7872 else
7873 {
7877 format_type_with_typemod(var->vartype,
7878 var->vartypmod));
7879 }
7880
7882}
7883
7884/*
7885 * Deparse a Var which references OUTER_VAR, INNER_VAR, or INDEX_VAR. This
7886 * routine is actually a callback for resolve_special_varno, which handles
7887 * finding the correct TargetEntry. We get the expression contained in that
7888 * TargetEntry and just need to deparse it, a job we can throw back on
7889 * get_rule_expr.
7890 */
7891static void
7893{
7895
7896 /*
7897 * For a non-Var referent, force parentheses because our caller probably
7898 * assumed a Var is a simple expression.
7899 */
7905}
7906
7907/*
7908 * Chase through plan references to special varnos (OUTER_VAR, INNER_VAR,
7909 * INDEX_VAR) until we find a real Var or some kind of non-Var node; then,
7910 * invoke the callback provided.
7911 */
7912static void
7915{
7916 Var *var;
7918
7919 /* This function is recursive, so let's be paranoid. */
7920 check_stack_depth();
7921
7922 /* If it's not a Var, invoke the callback. */
7924 {
7925 (*callback) (node, context, callback_arg);
7926 return;
7927 }
7928
7929 /* Find appropriate nesting depth */
7930 var = (Var *) node;
7932 var->varlevelsup);
7933
7934 /*
7935 * If varno is special, recurse. (Don't worry about varnosyn; if we're
7936 * here, we already decided not to use that.)
7937 */
7939 {
7943
7947
7948 /*
7949 * If we're descending to the first child of an Append or MergeAppend,
7950 * update appendparents. This will affect deparsing of all Vars
7951 * appearing within the eventually-resolved subexpression.
7952 */
7954
7961
7964 callback, callback_arg);
7967 return;
7968 }
7970 {
7973
7977
7980 callback, callback_arg);
7982 return;
7983 }
7985 {
7987
7991
7993 callback, callback_arg);
7994 return;
7995 }
7998
7999 /* Not special. Just invoke the callback. */
8000 (*callback) (node, context, callback_arg);
8001}
8002
8003/*
8004 * Get the name of a field of an expression of composite type. The
8005 * expression is usually a Var, but we handle other cases too.
8006 *
8007 * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
8008 *
8009 * This is fairly straightforward when the expression has a named composite
8010 * type; we need only look up the type in the catalogs. However, the type
8011 * could also be RECORD. Since no actual table or view column is allowed to
8012 * have type RECORD, a Var of type RECORD must refer to a JOIN or FUNCTION RTE
8013 * or to a subquery output. We drill down to find the ultimate defining
8014 * expression and attempt to infer the field name from it. We ereport if we
8015 * can't determine the name.
8016 *
8017 * Similarly, a PARAM of type RECORD has to refer to some expression of
8018 * a determinable composite type.
8019 */
8020static const char *
8023{
8028 int varno;
8029 AttrNumber varattno;
8031 Node *expr;
8032
8033 /*
8034 * If it's a RowExpr that was expanded from a whole-row Var, use the
8035 * column names attached to it. (We could let get_expr_result_tupdesc()
8036 * handle this, but it's much cheaper to just pull out the name we need.)
8037 */
8039 {
8041
8044 }
8045
8046 /*
8047 * If it's a Param of type RECORD, try to find what the Param refers to.
8048 */
8050 {
8053
8055 if (expr)
8056 {
8057 /* Found a match, so recurse to decipher the field name */
8059 const char *result;
8060
8063 0, context);
8065 return result;
8066 }
8067 }
8068
8069 /*
8070 * If it's a Var of type RECORD, we have to find what the Var refers to;
8071 * if not, we can use get_expr_result_tupdesc().
8072 */
8074 var->vartype != RECORDOID)
8075 {
8077 /* Got the tupdesc, so we can extract the field name */
8080 }
8081
8082 /* Find appropriate nesting depth */
8086 var->varlevelsup, levelsup);
8088 netlevelsup);
8089
8090 /*
8091 * If we have a syntactic referent for the Var, and we're working from a
8092 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8093 * on the semantic referent. (See comments in get_variable().)
8094 */
8096 {
8097 varno = var->varnosyn;
8098 varattno = var->varattnosyn;
8099 }
8100 else
8101 {
8102 varno = var->varno;
8103 varattno = var->varattno;
8104 }
8105
8106 /*
8107 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8108 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8109 * down into the subplans, or INDEX_VAR, which is resolved similarly.
8110 *
8111 * Note: unlike get_variable and resolve_special_varno, we need not worry
8112 * about inheritance mapping: a child Var should have the same datatype as
8113 * its parent, and here we're really only interested in the Var's type.
8114 */
8116 {
8118 attnum = varattno;
8119 }
8121 {
8124 const char *result;
8125
8129
8132
8134 levelsup, context);
8135
8137 return result;
8138 }
8140 {
8143 const char *result;
8144
8148
8151
8153 levelsup, context);
8154
8156 return result;
8157 }
8159 {
8161 const char *result;
8162
8166
8168
8170 levelsup, context);
8171
8172 return result;
8173 }
8174 else
8175 {
8178 }
8179
8181 {
8182 /* Var is whole-row reference to RTE, so select the right field */
8184 }
8185
8186 /*
8187 * This part has essentially the same logic as the parser's
8188 * expandRecordVariable() function, but we are dealing with a different
8189 * representation of the input context, and we only need one field name
8190 * not a TupleDesc. Also, we need special cases for finding subquery and
8191 * CTE subplans when deparsing Plan trees.
8192 */
8194
8196 {
8201
8202 /*
8203 * This case should not occur: a column of a table, values list,
8204 * or ENR shouldn't have type RECORD. Fall through and fail (most
8205 * likely) at the bottom.
8206 */
8207 break;
8209 /* Subselect-in-FROM: examine sub-select's output expr */
8210 {
8212 {
8214 attnum);
8215
8221 {
8222 /*
8223 * Recurse into the sub-select to see what its Var
8224 * refers to. We have to build an additional level of
8225 * namespace to keep in step with varlevelsup in the
8226 * subselect; furthermore, the subquery RTE might be
8227 * from an outer query level, in which case the
8228 * namespace for the subselect must have that outer
8229 * level as parent namespace.
8230 */
8234 const char *result;
8235
8237 netlevelsup);
8238
8240 parent_namespaces);
8241
8243
8245 0, context);
8246
8248
8249 return result;
8250 }
8251 /* else fall through to inspect the expression */
8252 }
8253 else
8254 {
8255 /*
8256 * We're deparsing a Plan tree so we don't have complete
8257 * RTE entries (in particular, rte->subquery is NULL). But
8258 * the only place we'd normally see a Var directly
8259 * referencing a SUBQUERY RTE is in a SubqueryScan plan
8260 * node, and we can look into the child plan's tlist
8261 * instead. An exception occurs if the subquery was
8262 * proven empty and optimized away: then we'd find such a
8263 * Var in a childless Result node, and there's nothing in
8264 * the plan tree that would let us figure out what it had
8265 * originally referenced. In that case, fall back on
8266 * printing "fN", analogously to the default column names
8267 * for RowExprs.
8268 */
8271 const char *result;
8272
8274 {
8276
8280 }
8282
8286 attnum);
8289
8291 levelsup, context);
8292
8294 return result;
8295 }
8296 }
8297 break;
8299 /* Join RTE --- recursively inspect the alias variable */
8305 /* we intentionally don't strip implicit coercions here */
8308 var->varlevelsup + levelsup,
8309 context);
8310 /* else fall through to inspect the expression */
8311 break;
8314
8315 /*
8316 * We couldn't get here unless a function is declared with one of
8317 * its result columns as RECORD, which is not allowed.
8318 */
8319 break;
8321 /* CTE reference: examine subquery's output expr */
8322 {
8324 Index ctelevelsup;
8326
8327 /*
8328 * Try to find the referenced CTE using the namespace stack.
8329 */
8333 else
8334 {
8336
8340 {
8343 break;
8344 }
8345 }
8347 {
8350 attnum);
8351
8357 {
8358 /*
8359 * Recurse into the CTE to see what its Var refers to.
8360 * We have to build an additional level of namespace
8361 * to keep in step with varlevelsup in the CTE;
8362 * furthermore it could be an outer CTE (compare
8363 * SUBQUERY case above).
8364 */
8368 const char *result;
8369
8371 ctelevelsup);
8372
8374 parent_namespaces);
8375
8377
8379 0, context);
8380
8382
8383 return result;
8384 }
8385 /* else fall through to inspect the expression */
8386 }
8387 else
8388 {
8389 /*
8390 * We're deparsing a Plan tree so we don't have a CTE
8391 * list. But the only places we'd normally see a Var
8392 * directly referencing a CTE RTE are in CteScan or
8393 * WorkTableScan plan nodes. For those cases,
8394 * set_deparse_plan arranged for dpns->inner_plan to be
8395 * the plan node that emits the CTE or RecursiveUnion
8396 * result, and we can look at its tlist instead. As
8397 * above, this can fail if the CTE has been proven empty,
8398 * in which case fall back to "fN".
8399 */
8402 const char *result;
8403
8405 {
8407
8411 }
8414
8418 attnum);
8421
8423 levelsup, context);
8424
8426 return result;
8427 }
8428 }
8429 break;
8431
8432 /*
8433 * We couldn't get here: any Vars that reference the RTE_GROUP RTE
8434 * should have been replaced with the underlying grouping
8435 * expressions.
8436 */
8437 break;
8438 }
8439
8440 /*
8441 * We now have an expression we can't expand any more, so see if
8442 * get_expr_result_tupdesc() can do anything with it.
8443 */
8445 /* Got the tupdesc, so we can extract the field name */
8448}
8449
8450/*
8451 * Try to find the referenced expression for a PARAM_EXEC Param that might
8452 * reference a parameter supplied by an upper NestLoop or SubPlan plan node.
8453 *
8454 * If successful, return the expression and set *dpns_p and *ancestor_cell_p
8455 * appropriately for calling push_ancestor_plan(). If no referent can be
8456 * found, return NULL.
8457 */
8461{
8462 /* Initialize output parameters to prevent compiler warnings */
8465
8466 /*
8467 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
8468 * SubPlan argument. This will necessarily be in some ancestor of the
8469 * current expression's Plan node.
8470 */
8472 {
8476
8479
8481 {
8484
8485 /*
8486 * NestLoops transmit params to their inner child only.
8487 */
8490 {
8492
8494 {
8496
8498 {
8499 /* Found a match, so return it */
8503 }
8504 }
8505 }
8506
8507 /*
8508 * If ancestor is a SubPlan, check the arguments it provides.
8509 */
8511 {
8515
8517 {
8520
8522 {
8523 /*
8524 * Found a match, so return it. But, since Vars in
8525 * the arg are to be evaluated in the surrounding
8526 * context, we have to point to the next ancestor item
8527 * that is *not* a SubPlan.
8528 */
8530
8533 {
8535
8537 {
8541 }
8542 }
8544 }
8545 }
8546
8547 /* SubPlan isn't a kind of Plan, so skip the rest */
8548 continue;
8549 }
8550
8551 /*
8552 * We need not consider the ancestor's initPlan list, since
8553 * initplans never have any parParams.
8554 */
8555
8556 /* No luck, crawl up to next ancestor */
8558 }
8559 }
8560
8561 /* No referent found */
8563}
8564
8565/*
8566 * Try to find a subplan/initplan that emits the value for a PARAM_EXEC Param.
8567 *
8568 * If successful, return the generating subplan/initplan and set *column_p
8569 * to the subplan's 0-based output column number.
8570 * Otherwise, return NULL.
8571 */
8574{
8575 /* Initialize output parameter to prevent compiler warnings */
8576 *column_p = 0;
8577
8578 /*
8579 * If it's a PARAM_EXEC parameter, search the current plan node as well as
8580 * ancestor nodes looking for a subplan or initplan that emits the value
8581 * for the Param. It could appear in the setParams of an initplan or
8582 * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
8583 */
8585 {
8586 SubPlan *result;
8589
8591
8592 /* First check the innermost plan node's initplans */
8594 if (result)
8595 return result;
8596
8597 /*
8598 * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
8599 * which can be referenced by Params elsewhere in the targetlist.
8600 * (Such Params should always be in the same targetlist, so there's no
8601 * need to do this work at upper plan nodes.)
8602 */
8604 {
8606 {
8608
8610 {
8612 {
8614 {
8615 /* Found a match, so return it. */
8617 return subplan;
8618 }
8619 }
8620 }
8621 }
8622 }
8623
8624 /* No luck, so check the ancestor nodes */
8626 {
8628
8629 /*
8630 * If ancestor is a SubPlan, check the paramIds it provides.
8631 */
8633 {
8635
8637 {
8639 {
8640 /* Found a match, so return it. */
8642 return subplan;
8643 }
8644 }
8645
8646 /* SubPlan isn't a kind of Plan, so skip the rest */
8647 continue;
8648 }
8649
8650 /*
8651 * Otherwise, it's some kind of Plan node, so check its initplans.
8652 */
8654 column_p);
8655 if (result)
8656 return result;
8657
8658 /* No luck, crawl up to next ancestor */
8659 }
8660 }
8661
8662 /* No generator found */
8664}
8665
8666/*
8667 * Subroutine for find_param_generator: search one Plan node's initplans
8668 */
8671{
8673 {
8675 {
8677 {
8678 /* Found a match, so return it. */
8680 return subplan;
8681 }
8682 }
8683 }
8685}
8686
8687/*
8688 * Display a Param appropriately.
8689 */
8690static void
8692{
8693 Node *expr;
8696 SubPlan *subplan;
8698
8699 /*
8700 * If it's a PARAM_EXEC parameter, try to locate the expression from which
8701 * the parameter was computed. This stanza handles only cases in which
8702 * the Param represents an input to the subplan we are currently in.
8703 */
8705 if (expr)
8706 {
8707 /* Found a match, so print it */
8711
8712 /* Switch attention to the ancestor plan node */
8714
8715 /*
8716 * Force prefixing of Vars, since they won't belong to the relation
8717 * being scanned in the original plan node.
8718 */
8721
8722 /*
8723 * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
8724 * upper-level Param, which wouldn't need extra parentheses.
8725 * Otherwise, insert parens to ensure the expression looks atomic.
8726 */
8733
8735
8738
8740
8742
8743 return;
8744 }
8745
8746 /*
8747 * Alternatively, maybe it's a subplan output, which we print as a
8748 * reference to the subplan. (We could drill down into the subplan and
8749 * print the relevant targetlist expression, but that has been deemed too
8750 * confusing since it would violate normal SQL scope rules. Also, we're
8751 * relying on this reference to show that the testexpr containing the
8752 * Param has anything to do with that subplan at all.)
8753 */
8755 if (subplan)
8756 {
8758
8761 else
8763
8766 nameprefix,
8767 subplan->plan_name, column + 1);
8768
8769 return;
8770 }
8771
8772 /*
8773 * If it's an external parameter, see if the outermost namespace provides
8774 * function argument names.
8775 */
8777 {
8780 param->paramid > 0 &&
8782 {
8784
8785 if (argname)
8786 {
8789
8790 /*
8791 * Qualify the parameter name if there are any other deparse
8792 * namespaces with range tables. This avoids qualifying in
8793 * trivial cases like "RETURN a + b", but makes it safe in all
8794 * other cases.
8795 */
8797 {
8799
8801 {
8803 break;
8804 }
8805 }
8807 {
8810 }
8811
8813 return;
8814 }
8815 }
8816 }
8817
8818 /*
8819 * Not PARAM_EXEC, or couldn't find referent: just print $N.
8820 *
8821 * It's a bug if we get here for anything except PARAM_EXTERN Params, but
8822 * in production builds printing $N seems more useful than failing.
8823 */
8825
8827}
8828
8829/*
8830 * get_simple_binary_op_name
8831 *
8832 * helper function for isSimpleNode
8833 * will return single char binary operator name, or NULL if it's not
8834 */
8835static const char *
8837{
8839
8841 {
8842 /* binary operator */
8845 const char *op;
8846
8849 return op;
8850 }
8852}
8853
8854
8855/*
8856 * isSimpleNode - check if given node is simple (doesn't need parenthesizing)
8857 *
8858 * true : simple in the context of parent node's type
8859 * false : not simple
8860 */
8861static bool
8863{
8864 if (!node)
8865 return false;
8866
8868 {
8875 /* single words: always simple */
8876 return true;
8877
8894 /* function-like: name(..) or name[..] */
8895 return true;
8896
8897 /* CASE keywords act as parentheses */
8899 return true;
8900
8902
8903 /*
8904 * appears simple since . has top precedence, unless parent is
8905 * T_FieldSelect itself!
8906 */
8908
8910
8911 /*
8912 * treat like FieldSelect (probably doesn't matter)
8913 */
8915
8917 /* maybe simple, check args */
8919 node, prettyFlags);
8922 node, prettyFlags);
8925 node, prettyFlags);
8928 node, prettyFlags);
8931 node, prettyFlags);
8934 node, prettyFlags);
8935
8937 {
8938 /* depends on parent node type; needs further checking */
8940 {
8941 const char *op;
8947
8949 if (!op)
8950 return false;
8951
8952 /* We know only the basic operators + - and * / % */
8956 return false;
8957
8960 return false;
8961
8965 return false;
8966
8968 return true; /* op binds tighter than parent */
8969
8971 return false;
8972
8973 /*
8974 * Operators are same priority --- can skip parens only if
8975 * we have (a - b) - c, not a - (b - c).
8976 */
8978 return true;
8979
8980 return false;
8981 }
8982 /* else do the same stuff as for T_SubLink et al. */
8983 }
8984 /* FALLTHROUGH */
8985
8992 {
8994 {
8995 /* special handling for casts and COERCE_SQL_SYNTAX */
8997
9001 return false;
9002 return true; /* own parentheses */
9003 }
9016 return true;
9017 default:
9018 return false;
9019 }
9020
9023 {
9026 {
9029
9033 {
9037 return true;
9038 break;
9041 return true;
9042 break;
9043 }
9044 }
9045 return false;
9047 {
9048 /* special handling for casts and COERCE_SQL_SYNTAX */
9050
9054 return false;
9055 return true; /* own parentheses */
9056 }
9069 return true;
9070 default:
9071 return false;
9072 }
9073
9075 /* maybe simple, check args */
9077 node, prettyFlags);
9078
9079 default:
9080 break;
9081 }
9082 /* those we don't know: in dubio complexo */
9083 return false;
9084}
9085
9086
9087/*
9088 * appendContextKeyword - append a keyword to buffer
9089 *
9090 * If prettyPrint is enabled, perform a line break, and adjust indentation.
9091 * Otherwise, just append the keyword.
9092 */
9093static void
9096{
9098
9100 {
9102
9104
9105 /* remove any trailing spaces currently in the buffer ... */
9107 /* ... then add a newline and some spaces */
9109
9112 else
9113 {
9114 /*
9115 * If we're indented more than PRETTYINDENT_LIMIT characters, try
9116 * to conserve horizontal space by reducing the per-level
9117 * indentation. For best results the scale factor here should
9118 * divide all the indent amounts that get added to indentLevel
9119 * (PRETTYINDENT_STD, etc). It's important that the indentation
9120 * not grow unboundedly, else deeply-nested trees use O(N^2)
9121 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
9122 */
9125 (PRETTYINDENT_STD / 2);
9127 /* scale/wrap logic affects indentLevel, but not indentPlus */
9129 }
9131
9133
9136 context->indentLevel = 0;
9137 }
9138 else
9140}
9141
9142/*
9143 * removeStringInfoSpaces - delete trailing spaces from a buffer.
9144 *
9145 * Possibly this should move to stringinfo.c at some point.
9146 */
9147static void
9149{
9152}
9153
9154
9155/*
9156 * get_rule_expr_paren - deparse expr using get_rule_expr,
9157 * embracing the string with parentheses if necessary for prettyPrint.
9158 *
9159 * Never embrace if prettyFlags=0, because it's done in the calling node.
9160 *
9161 * Any node that does *not* embrace its argument node by sql syntax (with
9162 * parentheses, non-operator keywords like CASE/WHEN/ON, or comma etc) should
9163 * use get_rule_expr_paren instead of get_rule_expr so parentheses can be
9164 * added.
9165 */
9166static void
9169{
9171
9174
9177
9179
9182}
9183
9184static void
9187{
9188 /*
9189 * The order of array elements must correspond to the order of
9190 * JsonBehaviorType members.
9191 */
9193 {
9194 " NULL",
9195 " ERROR",
9196 " EMPTY",
9197 " TRUE",
9198 " FALSE",
9199 " UNKNOWN",
9200 " EMPTY ARRAY",
9201 " EMPTY OBJECT",
9202 " DEFAULT "
9203 };
9204
9207
9209
9212
9214}
9215
9216/*
9217 * get_json_expr_options
9218 *
9219 * Parse back common options for JSON_QUERY, JSON_VALUE, JSON_EXISTS and
9220 * JSON_TABLE columns.
9221 */
9222static void
9225{
9227 {
9232 /* The default */
9235
9238 /* The default */
9239 else
9241 }
9242
9245
9248}
9249
9250/* ----------
9251 * get_rule_expr - Parse back an expression
9252 *
9253 * Note: showimplicit determines whether we display any implicit cast that
9254 * is present at the top of the expression tree. It is a passed argument,
9255 * not a field of the context struct, because we change the value as we
9256 * recurse down into the expression. In general we suppress implicit casts
9257 * when the result type is known with certainty (eg, the arguments of an
9258 * OR must be boolean). We display implicit casts for arguments of functions
9259 * and operators, since this is needed to be certain that the same function
9260 * or operator will be chosen when the expression is re-parsed.
9261 * ----------
9262 */
9263static void
9266{
9268
9270 return;
9271
9272 /* Guard against excessively long or deeply-nested queries */
9273 CHECK_FOR_INTERRUPTS();
9274 check_stack_depth();
9275
9276 /*
9277 * Each level of get_rule_expr must emit an indivisible term
9278 * (parenthesized if necessary) to ensure result is reparsed into the same
9279 * expression tree. The only exception is that when the input is a List,
9280 * we emit the component items comma-separated with no surrounding
9281 * decoration; this is convenient for most callers.
9282 */
9284 {
9287 break;
9288
9291 break;
9292
9295 break;
9296
9299 break;
9300
9302 {
9304
9308 }
9309 break;
9310
9313 break;
9314
9317 break;
9318
9320 {
9323
9324 /*
9325 * If the argument is a CaseTestExpr, we must be inside a
9326 * FieldStore, ie, we are assigning to an element of an array
9327 * within a composite column. Since we already punted on
9328 * displaying the FieldStore's target information, just punt
9329 * here too, and display only the assignment source
9330 * expression.
9331 */
9333 {
9336 context, showimplicit);
9337 break;
9338 }
9339
9340 /*
9341 * Parenthesize the argument unless it's a simple Var or a
9342 * FieldSelect. (In particular, if it's another
9343 * SubscriptingRef, we *must* parenthesize to avoid
9344 * confusion.)
9345 */
9353
9354 /*
9355 * If there's a refassgnexpr, we want to print the node in the
9356 * format "container[subscripts] := refassgnexpr". This is
9357 * not legal SQL, so decompilation of INSERT or UPDATE
9358 * statements should always use processIndirection as part of
9359 * the statement-level syntax. We should only see this when
9360 * EXPLAIN tries to print the targetlist of a plan resulting
9361 * from such a statement.
9362 */
9364 {
9365 Node *refassgnexpr;
9366
9367 /*
9368 * Use processIndirection to print this node's subscripts
9369 * as well as any additional field selections or
9370 * subscripting in immediate descendants. It returns the
9371 * RHS expr that is actually being "assigned".
9372 */
9373 refassgnexpr = processIndirection(node, context);
9376 }
9377 else
9378 {
9379 /* Just an ordinary container fetch, so print subscripts */
9380 printSubscripts(sbsref, context);
9381 }
9382 }
9383 break;
9384
9387 break;
9388
9390 {
9392
9395 }
9396 break;
9397
9400 break;
9401
9403 {
9408
9416 }
9417 break;
9418
9420 {
9422
9426 }
9427 break;
9428
9430 {
9435
9445
9446 /*
9447 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
9448 * a bare sub-SELECT. Since we're here, the sub-SELECT must
9449 * be meant as a scalar sub-SELECT yielding an array value to
9450 * be used in ScalarArrayOpExpr; but the grammar will
9451 * preferentially interpret such a construct as an ANY/ALL
9452 * SubLink. To prevent misparsing the output that way, insert
9453 * a dummy coercion (which will be stripped by parse analysis,
9454 * so no inefficiency is added in dump and reload). This is
9455 * indeed most likely what the user wrote to get the construct
9456 * accepted in the first place.
9457 */
9466 }
9467 break;
9468
9470 {
9474
9476 {
9481 false, node);
9483 {
9486 false, node);
9487 }
9490 break;
9491
9496 false, node);
9498 {
9501 false, node);
9502 }
9505 break;
9506
9512 false, node);
9515 break;
9516
9517 default:
9520 }
9521 }
9522 break;
9523
9526 break;
9527
9529 {
9531
9532 /*
9533 * We cannot see an already-planned subplan in rule deparsing,
9534 * only while EXPLAINing a query plan. We don't try to
9535 * reconstruct the original SQL, just reference the subplan
9536 * that appears elsewhere in EXPLAIN's result. It does seem
9537 * useful to show the subLinkType and testexpr (if any), and
9538 * we also note whether the subplan will be hashed.
9539 */
9541 {
9545 break;
9549 break;
9553 break;
9555 /* Parenthesizing the testexpr seems sufficient */
9558 break;
9560 /* No need to decorate these subplan references */
9563 break;
9565 /* MULTIEXPR isn't executed in the normal way */
9568 break;
9572 break;
9574 /* This case is unreachable within expressions */
9577 break;
9578 }
9579
9581 {
9583
9584 /*
9585 * Push SubPlan into ancestors list while deparsing
9586 * testexpr, so that we can handle PARAM_EXEC references
9587 * to the SubPlan's paramIds. (This makes it look like
9588 * the SubPlan is an "ancestor" of the current plan node,
9589 * which is a little weird, but it does no harm.) In this
9590 * path, we don't need to mention the SubPlan explicitly,
9591 * because the referencing Params will show its existence.
9592 */
9595
9598
9600 }
9601 else
9602 {
9604
9605 /* No referencing Params, so show the SubPlan's name */
9608 else
9613 else
9616 }
9617 }
9618 break;
9619
9621 {
9624
9625 /*
9626 * This case cannot be reached in normal usage, since no
9627 * AlternativeSubPlan can appear either in parsetrees or
9628 * finished plan trees. We keep it just in case somebody
9629 * wants to use this code to print planner data structures.
9630 */
9633 {
9636
9639 else
9643 splan->plan_name);
9644 else
9646 splan->plan_name);
9649 }
9651 }
9652 break;
9653
9655 {
9659 const char *fieldname;
9661
9662 /*
9663 * Parenthesize the argument unless it's a SubscriptingRef or
9664 * another FieldSelect. Note in particular that it would be
9665 * WRONG to not parenthesize a Var argument; simplicity is not
9666 * the issue here, having the right number of names is.
9667 */
9675
9676 /*
9677 * Get and print the field name.
9678 */
9680 0, context);
9682 }
9683 break;
9684
9686 {
9689
9690 /*
9691 * There is no good way to represent a FieldStore as real SQL,
9692 * so decompilation of INSERT or UPDATE statements should
9693 * always use processIndirection as part of the
9694 * statement-level syntax. We should only get here when
9695 * EXPLAIN tries to print the targetlist of a plan resulting
9696 * from such a statement. The plan case is even harder than
9697 * ordinary rules would be, because the planner tries to
9698 * collapse multiple assignments to the same field or subfield
9699 * into one FieldStore; so we can see a list of target fields
9700 * not just one, and the arguments could be FieldStores
9701 * themselves. We don't bother to try to print the target
9702 * field names; we just print the source arguments, with a
9703 * ROW() around them if there's more than one. This isn't
9704 * terribly complete, but it's probably good enough for
9705 * EXPLAIN's purposes; especially since anything more would be
9706 * either hopelessly confusing or an even poorer
9707 * representation of what the plan is actually doing.
9708 */
9715 }
9716 break;
9717
9719 {
9722
9724 !showimplicit)
9725 {
9726 /* don't show the implicit cast */
9728 }
9729 else
9730 {
9732 relabel->resulttype,
9733 relabel->resulttypmod,
9734 node);
9735 }
9736 }
9737 break;
9738
9740 {
9743
9745 !showimplicit)
9746 {
9747 /* don't show the implicit cast */
9749 }
9750 else
9751 {
9753 iocoerce->resulttype,
9754 -1,
9755 node);
9756 }
9757 }
9758 break;
9759
9761 {
9764
9766 !showimplicit)
9767 {
9768 /* don't show the implicit cast */
9770 }
9771 else
9772 {
9774 acoerce->resulttype,
9775 acoerce->resulttypmod,
9776 node);
9777 }
9778 }
9779 break;
9780
9782 {
9785
9787 !showimplicit)
9788 {
9789 /* don't show the implicit cast */
9791 }
9792 else
9793 {
9795 convert->resulttype, -1,
9796 node);
9797 }
9798 }
9799 break;
9800
9802 {
9805
9810 generate_collation_name(collate->collOid));
9813 }
9814 break;
9815
9817 {
9820
9822 0, PRETTYINDENT_VAR, 0);
9824 {
9827 }
9829 {
9832
9834 {
9835 /*
9836 * The parser should have produced WHEN clauses of the
9837 * form "CaseTestExpr = RHS", possibly with an
9838 * implicit coercion inserted above the CaseTestExpr.
9839 * For accurate decompilation of rules it's essential
9840 * that we show just the RHS. However in an
9841 * expression that's been through the optimizer, the
9842 * WHEN clause could be almost anything (since the
9843 * equality operator could have been expanded into an
9844 * inline function). If we don't recognize the form
9845 * of the WHEN clause, just punt and display it as-is.
9846 */
9848 {
9850
9853 CaseTestExpr))
9855 }
9856 }
9857
9861 0, 0, 0);
9865 }
9869 0, 0, 0);
9874 -PRETTYINDENT_VAR, 0, 0);
9875 }
9876 break;
9877
9879 {
9880 /*
9881 * Normally we should never get here, since for expressions
9882 * that can contain this node type we attempt to avoid
9883 * recursing to it. But in an optimized expression we might
9884 * be unable to avoid that (see comments for CaseExpr). If we
9885 * do see one, print it as CASE_TEST_EXPR.
9886 */
9888 }
9889 break;
9890
9892 {
9894
9898
9899 /*
9900 * If the array isn't empty, we assume its elements are
9901 * coerced to the desired type. If it's empty, though, we
9902 * need an explicit coercion to the array type.
9903 */
9906 format_type_with_typemod(arrayexpr->array_typeid, -1));
9907 }
9908 break;
9909
9911 {
9917
9918 /*
9919 * If it's a named type and not RECORD, we may have to skip
9920 * dropped columns and/or claim there are NULLs for added
9921 * columns.
9922 */
9924 {
9925 tupdesc = lookup_rowtype_tupdesc(rowexpr->row_typeid, -1);
9927 }
9928
9929 /*
9930 * SQL99 allows "ROW" to be omitted when there is more than
9931 * one column, but for simplicity we always print it.
9932 */
9935 i = 0;
9937 {
9939
9942 {
9944 /* Whole-row Vars need special treatment here */
9947 }
9948 i++;
9949 }
9951 {
9953 {
9955 {
9959 }
9960 i++;
9961 }
9962
9963 ReleaseTupleDesc(tupdesc);
9964 }
9968 format_type_with_typemod(rowexpr->row_typeid, -1));
9969 }
9970 break;
9971
9973 {
9975
9976 /*
9977 * SQL99 allows "ROW" to be omitted when there is more than
9978 * one column, but for simplicity we always print it. Within
9979 * a ROW expression, whole-row Vars need special treatment, so
9980 * use get_rule_list_toplevel.
9981 */
9984
9985 /*
9986 * We assume that the name of the first-column operator will
9987 * do for all the rest too. This is definitely open to
9988 * failure, eg if some but not all operators were renamed
9989 * since the construct was parsed, but there seems no way to
9990 * be perfect.
9991 */
9998 }
9999 break;
10000
10002 {
10004
10008 }
10009 break;
10010
10012 {
10014
10016 {
10019 break;
10022 break;
10023 }
10026 }
10027 break;
10028
10030 {
10032
10033 /*
10034 * Note: this code knows that typmod for time, timestamp, and
10035 * timestamptz just prints as integer.
10036 */
10038 {
10041 break;
10044 break;
10047 break;
10050 break;
10053 svf->typmod);
10054 break;
10057 break;
10060 break;
10063 break;
10066 svf->typmod);
10067 break;
10070 break;
10073 break;
10076 break;
10079 break;
10082 break;
10085 break;
10086 }
10087 }
10088 break;
10089
10091 {
10096 Const *con;
10097
10099 {
10102 break;
10105 break;
10108 break;
10111 break;
10114 break;
10117 break;
10120 break;
10122 break;
10123 }
10125 {
10128 else
10130 }
10131 if (xexpr->name)
10132 {
10136 }
10138 {
10140 {
10145 }
10147 {
10150
10157 }
10160 }
10162 {
10166 {
10172 /* no extra decoration needed */
10174 break;
10177
10179 context, true);
10180
10182 Assert(!con->constisnull);
10185 " PRESERVE WHITESPACE");
10186 else
10188 " STRIP WHITESPACE");
10189 break;
10192
10194 context, true);
10195
10199 con->constisnull)
10201 else
10203
10205 if (con->constisnull)
10206 /* suppress STANDALONE NO VALUE */ ;
10207 else
10208 {
10210 {
10213 ", STANDALONE YES");
10214 break;
10217 ", STANDALONE NO");
10218 break;
10221 ", STANDALONE NO VALUE");
10222 break;
10223 default:
10224 break;
10225 }
10226 }
10227 break;
10230 break;
10231 }
10232 }
10234 {
10236 format_type_with_typemod(xexpr->type,
10237 xexpr->typmod));
10240 else
10242 }
10243
10246 else
10248 }
10249 break;
10250
10252 {
10254
10258
10259 /*
10260 * For scalar inputs, we prefer to print as IS [NOT] NULL,
10261 * which is shorter and traditional. If it's a rowtype input
10262 * but we're applying a scalar test, must print IS [NOT]
10263 * DISTINCT FROM NULL to be semantically correct.
10264 */
10267 {
10269 {
10272 break;
10275 break;
10276 default:
10279 }
10280 }
10281 else
10282 {
10284 {
10287 break;
10290 break;
10291 default:
10294 }
10295 }
10298 }
10299 break;
10300
10302 {
10304
10309 {
10312 break;
10315 break;
10318 break;
10321 break;
10324 break;
10327 break;
10328 default:
10331 }
10334 }
10335 break;
10336
10338 {
10341
10343 !showimplicit)
10344 {
10345 /* don't show the implicit cast */
10347 }
10348 else
10349 {
10351 ctest->resulttype,
10352 ctest->resulttypmod,
10353 node);
10354 }
10355 }
10356 break;
10357
10360 break;
10361
10364 break;
10365
10367 {
10369
10373 else
10375 cexpr->cursor_param);
10376 }
10377 break;
10378
10380 {
10382
10383 /*
10384 * This isn't exactly nextval(), but that seems close enough
10385 * for EXPLAIN's purposes.
10386 */
10390 NIL));
10392 }
10393 break;
10394
10396 {
10400
10401 /*
10402 * InferenceElem can only refer to target relation, so a
10403 * prefix is not useful, and indeed would cause parse errors.
10404 */
10407
10408 /*
10409 * Parenthesize the element unless it's a simple Var or a bare
10410 * function call. Follows pg_get_indexdef_worker().
10411 */
10415 COERCE_EXPLICIT_CALL)
10417
10421 context, false);
10424
10426
10430
10431 /* Add the operator class name, if not default */
10433 {
10436
10438 }
10439 }
10440 break;
10441
10443 {
10445
10446 /*
10447 * We cannot see a ReturningExpr in rule deparsing, only while
10448 * EXPLAINing a query plan (ReturningExpr nodes are only ever
10449 * adding during query rewriting). Just display the expression
10450 * returned (an expanded view column).
10451 */
10453 }
10454 break;
10455
10457 {
10459 ListCell *cell;
10461
10463 {
10465 break;
10466 }
10467
10469 {
10473
10477 break;
10478
10481
10485 {
10487
10491 }
10492
10494 break;
10495
10501
10505 break;
10506
10507 default:
10510 break;
10511 }
10512 }
10513 break;
10514
10516 {
10518
10521 }
10522 break;
10523
10526 break;
10527
10529 {
10531
10534
10536
10538
10539 /* TODO: handle FORMAT clause */
10540
10542 {
10545 break;
10548 break;
10551 break;
10552 default:
10553 break;
10554 }
10555
10558
10561 }
10562 break;
10563
10565 {
10567
10569 {
10572 break;
10575 break;
10578 break;
10579 default:
10582 }
10583
10585
10587
10589
10591 {
10593 *lc2;
10595
10597
10600 {
10604
10608 }
10609 }
10610
10615
10618 JSON_BEHAVIOR_NULL :
10619 JSON_BEHAVIOR_FALSE);
10620
10622 }
10623 break;
10624
10626 {
10628 ListCell *l;
10629
10632 {
10636 }
10637 }
10638 break;
10639
10642 break;
10643
10644 default:
10646 break;
10647 }
10648}
10649
10650/*
10651 * get_rule_expr_toplevel - Parse back a toplevel expression
10652 *
10653 * Same as get_rule_expr(), except that if the expr is just a Var, we pass
10654 * istoplevel = true not false to get_variable(). This causes whole-row Vars
10655 * to get printed with decoration that will prevent expansion of "*".
10656 * We need to use this in contexts such as ROW() and VALUES(), where the
10657 * parser would expand "foo.*" appearing at top level. (In principle we'd
10658 * use this in get_target_list() too, but that has additional worries about
10659 * whether to print AS, so it needs to invoke get_variable() directly anyway.)
10660 */
10661static void
10664{
10667 else
10669}
10670
10671/*
10672 * get_rule_list_toplevel - Parse back a list of toplevel expressions
10673 *
10674 * Apply get_rule_expr_toplevel() to each element of a List.
10675 *
10676 * This adds commas between the expressions, but caller is responsible
10677 * for printing surrounding decoration.
10678 */
10679static void
10682{
10685
10688 {
10690
10694 }
10695}
10696
10697/*
10698 * get_rule_expr_funccall - Parse back a function-call expression
10699 *
10700 * Same as get_rule_expr(), except that we guarantee that the output will
10701 * look like a function call, or like one of the things the grammar treats as
10702 * equivalent to a function call (see the func_expr_windowless production).
10703 * This is needed in places where the grammar uses func_expr_windowless and
10704 * you can't substitute a parenthesized a_expr. If what we have isn't going
10705 * to look like a function call, wrap it in a dummy CAST() expression, which
10706 * will satisfy the grammar --- and, indeed, is likely what the user wrote to
10707 * produce such a thing.
10708 */
10709static void
10712{
10715 else
10716 {
10718
10720 /* no point in showing any top-level implicit cast */
10724 exprTypmod(node)));
10725 }
10726}
10727
10728/*
10729 * Helper function to identify node types that satisfy func_expr_windowless.
10730 * If in doubt, "false" is always a safe answer.
10731 */
10732static bool
10734{
10736 return false; /* probably shouldn't happen */
10738 {
10740 /* OK, unless it's going to deparse as a cast */
10749 /* these are all accepted by func_expr_common_subexpr */
10750 return true;
10751 default:
10752 break;
10753 }
10754 return false;
10755}
10756
10757
10758/*
10759 * get_oper_expr - Parse back an OpExpr node
10760 */
10761static void
10763{
10767
10771 {
10772 /* binary operator */
10775
10778 generate_operator_name(opno,
10782 }
10783 else
10784 {
10785 /* prefix operator */
10787
10789 generate_operator_name(opno,
10790 InvalidOid,
10793 }
10796}
10797
10798/*
10799 * get_func_expr - Parse back a FuncExpr node
10800 */
10801static void
10804{
10808 int nargs;
10809 List *argnames;
10811 ListCell *l;
10812
10813 /*
10814 * If the function call came from an implicit coercion, then just show the
10815 * first argument --- unless caller wants to see implicit coercions.
10816 */
10818 {
10821 return;
10822 }
10823
10824 /*
10825 * If the function call came from a cast, then show the first argument
10826 * plus an explicit cast operation.
10827 */
10829 expr->funcformat == COERCE_IMPLICIT_CAST)
10830 {
10832 Oid rettype = expr->funcresulttype;
10834
10835 /* Get the typmod if this is a length-coercion function */
10837
10839 rettype, coercedTypmod,
10840 (Node *) expr);
10841
10842 return;
10843 }
10844
10845 /*
10846 * If the function was called using one of the SQL spec's random special
10847 * syntaxes, try to reproduce that. If we don't recognize the function,
10848 * fall through.
10849 */
10851 {
10853 return;
10854 }
10855
10856 /*
10857 * Normal function: display as proname(args). First we need to extract
10858 * the argument datatypes.
10859 */
10864 nargs = 0;
10865 argnames = NIL;
10867 {
10869
10873 nargs++;
10874 }
10875
10878 argnames, argtypes,
10879 expr->funcvariadic,
10880 &use_variadic,
10881 context->inGroupBy));
10882 nargs = 0;
10884 {
10885 if (nargs++ > 0)
10890 }
10892}
10893
10894/*
10895 * get_agg_expr - Parse back an Aggref node
10896 */
10897static void
10900{
10902 false);
10903}
10904
10905/*
10906 * get_agg_expr_helper - subroutine for get_agg_expr and
10907 * get_json_agg_constructor
10908 */
10909static void
10913{
10916 int nargs;
10918
10919 /*
10920 * For a combining aggregate, we look up and deparse the corresponding
10921 * partial aggregate instead. This is necessary because our input
10922 * argument list has been replaced; the new argument list always has just
10923 * one element, which will point to a partial Aggref that supplies us with
10924 * transition states to combine.
10925 */
10927 {
10929
10934 return;
10935 }
10936
10937 /*
10938 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
10939 * to avoid printing this when recursing from the code just above.
10940 */
10943
10944 /* Extract the argument types as seen by the parser */
10945 nargs = get_aggregate_argtypes(aggref, argtypes);
10946
10949 argtypes, aggref->aggvariadic,
10950 &use_variadic,
10951 context->inGroupBy);
10952
10953 /* Print the aggregate name, schema-qualified if needed */
10956
10958 {
10959 /*
10960 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
10961 * worry about inserting VARIADIC. So we can just dump the direct
10962 * args as-is.
10963 */
10964 Assert(!aggref->aggvariadic);
10969 }
10970 else
10971 {
10972 /* aggstar can be set only in zero-argument aggregates */
10973 if (aggref->aggstar)
10975 else
10976 {
10977 ListCell *l;
10979
10980 i = 0;
10982 {
10985
10988 continue;
10990 {
10992 {
10993 /*
10994 * the ABSENT ON NULL and WITH UNIQUE args are printed
10995 * separately, so ignore them here
10996 */
10998 break;
10999
11001 }
11002 else
11004 }
11008 }
11009 }
11010
11012 {
11015 }
11016 }
11017
11020
11022 {
11025 }
11026
11028}
11029
11030/*
11031 * This is a helper function for get_agg_expr(). It's used when we deparse
11032 * a combining Aggref; resolve_special_varno locates the corresponding partial
11033 * Aggref and then calls this.
11034 */
11035static void
11037{
11038 Aggref *aggref;
11040
11043
11044 aggref = (Aggref *) node;
11046}
11047
11048/*
11049 * get_windowfunc_expr - Parse back a WindowFunc node
11050 */
11051static void
11053{
11055}
11056
11057
11058/*
11059 * get_windowfunc_expr_helper - subroutine for get_windowfunc_expr and
11060 * get_json_agg_constructor
11061 */
11062static void
11066{
11069 int nargs;
11070 List *argnames;
11071 ListCell *l;
11072
11077 nargs = 0;
11078 argnames = NIL;
11080 {
11082
11086 nargs++;
11087 }
11088
11092 context->inGroupBy);
11093
11095
11096 /* winstar can be set only in zero-argument aggregates */
11097 if (wfunc->winstar)
11099 else
11100 {
11102 {
11106 }
11107 else
11109 }
11110
11113
11115 {
11118 }
11119
11121
11124
11126
11128 {
11129 /* Query-decompilation case: search the windowClause list */
11131 {
11133
11135 {
11136 if (wc->name)
11138 else
11140 break;
11141 }
11142 }
11145 wfunc->winref);
11146 }
11147 else
11148 {
11149 /*
11150 * In EXPLAIN, search the namespace stack for a matching WindowAgg
11151 * node (probably it's always the first entry), and print winname.
11152 */
11154 {
11156
11158 {
11160
11162 {
11164 break;
11165 }
11166 }
11167 }
11170 wfunc->winref);
11171 }
11172}
11173
11174/*
11175 * get_func_sql_syntax - Parse back a SQL-syntax function call
11176 *
11177 * Returns true if we successfully deparsed, false if we did not
11178 * recognize the function.
11179 */
11180static bool
11182{
11185
11187 {
11194 /* AT TIME ZONE ... note reversed argument order */
11197 (Node *) expr);
11200 (Node *) expr);
11202 return true;
11203
11207 /* AT LOCAL */
11210 (Node *) expr);
11212 return true;
11213
11227 /* (x1, x2) OVERLAPS (y1, y2) */
11237 return true;
11238
11245 /* EXTRACT (x FROM y) */
11247 {
11249
11252 !con->constisnull);
11254 }
11258 return true;
11259
11261 /* IS xxx NORMALIZED */
11264 (Node *) expr);
11267 {
11269
11272 !con->constisnull);
11274 TextDatumGetCString(con->constvalue));
11275 }
11277 return true;
11278
11280 /* COLLATION FOR */
11284 return true;
11285
11287 /* NORMALIZE() */
11291 {
11293
11296 !con->constisnull);
11298 TextDatumGetCString(con->constvalue));
11299 }
11301 return true;
11302
11309 /* OVERLAY() */
11317 {
11320 }
11322 return true;
11323
11327 /* POSITION() ... extra parens since args are b_expr not a_expr */
11333 return true;
11334
11341 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
11347 {
11350 }
11352 return true;
11353
11355 /* SUBSTRING SIMILAR/ESCAPE */
11363 return true;
11364
11368 /* TRIM() */
11371 {
11374 }
11378 return true;
11379
11383 /* TRIM() */
11386 {
11389 }
11393 return true;
11394
11398 /* TRIM() */
11401 {
11404 }
11408 return true;
11409
11412 return true;
11413
11415 /* XMLEXISTS ... extra parens because args are c_expr */
11421 return true;
11422 }
11423 return false;
11424}
11425
11426/* ----------
11427 * get_coercion_expr
11428 *
11429 * Make a string representation of a value coerced to a specific type
11430 * ----------
11431 */
11432static void
11436{
11438
11439 /*
11440 * Since parse_coerce.c doesn't immediately collapse application of
11441 * length-coercion functions to constants, what we'll typically see in
11442 * such cases is a Const with typmod -1 and a length-coercion function
11443 * right above it. Avoid generating redundant output. However, beware of
11444 * suppressing casts when the user actually wrote something like
11445 * 'foo'::text::char(3).
11446 *
11447 * Note: it might seem that we are missing the possibility of needing to
11448 * print a COLLATE clause for such a Const. However, a Const could only
11449 * have nondefault collation in a post-constant-folding tree, in which the
11450 * length coercion would have been folded too. See also the special
11451 * handling of CollateExpr in coerce_to_target_type(): any collation
11452 * marking will be above the coercion node, not below it.
11453 */
11457 {
11458 /* Show the constant without normal ::typename decoration */
11460 }
11461 else
11462 {
11468 }
11469
11470 /*
11471 * Never emit resulttype(arg) functional notation. A pg_proc entry could
11472 * take precedence, and a resulttype in pg_temp would require schema
11473 * qualification that format_type_with_typemod() would usually omit. We've
11474 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
11475 * would work fine.
11476 */
11479}
11480
11481/* ----------
11482 * get_const_expr
11483 *
11484 * Make a string representation of a Const
11485 *
11486 * showtype can be -1 to never show "::typename" decoration, or +1 to always
11487 * show it, or 0 to show it only if the constant wouldn't be assumed to be
11488 * the right type by default.
11489 *
11490 * If the Const's collation isn't default for its type, show that too.
11491 * We mustn't do this when showtype is -1 (since that means the caller will
11492 * print "::typename", and we can't put a COLLATE clause in between). It's
11493 * caller's responsibility that collation isn't missed in such cases.
11494 * ----------
11495 */
11496static void
11498{
11500 Oid typoutput;
11504
11505 if (constval->constisnull)
11506 {
11507 /*
11508 * Always label the type of a NULL constant to prevent misdecisions
11509 * about type when reparsing.
11510 */
11513 {
11516 constval->consttypmod));
11517 get_const_collation(constval, context);
11518 }
11519 return;
11520 }
11521
11523 &typoutput, &typIsVarlena);
11524
11526
11528 {
11530
11531 /*
11532 * INT4 can be printed without any decoration, unless it is
11533 * negative; in that case print it as '-nnn'::integer to ensure
11534 * that the output will re-parse as a constant, not as a constant
11535 * plus operator. In most cases we could get away with printing
11536 * (-nnn) instead, because of the way that gram.y handles negative
11537 * literals; but that doesn't work for INT_MIN, and it doesn't
11538 * seem that much prettier anyway.
11539 */
11542 else
11543 {
11546 }
11547 break;
11548
11550
11551 /*
11552 * NUMERIC can be printed without quotes if it looks like a float
11553 * constant (not an integer, and not Infinity or NaN) and doesn't
11554 * have a leading sign (for the same reason as for INT4).
11555 */
11558 {
11560 }
11561 else
11562 {
11565 }
11566 break;
11567
11571 else
11573 break;
11574
11575 default:
11577 break;
11578 }
11579
11581
11583 return;
11584
11585 /*
11586 * For showtype == 0, append ::typename unless the constant will be
11587 * implicitly typed as the right type when it is read in.
11588 *
11589 * XXX this code has to be kept in sync with the behavior of the parser,
11590 * especially make_const.
11591 */
11593 {
11596 /* These types can be left unlabeled */
11598 break;
11600 /* We determined above whether a label is needed */
11601 break;
11603
11604 /*
11605 * Float-looking constants will be typed as numeric, which we
11606 * checked above; but if there's a nondefault typmod we need to
11607 * show it.
11608 */
11609 needlabel |= (constval->consttypmod >= 0);
11610 break;
11611 default:
11613 break;
11614 }
11618 constval->consttypmod));
11619
11620 get_const_collation(constval, context);
11621}
11622
11623/*
11624 * helper for get_const_expr: append COLLATE if needed
11625 */
11626static void
11628{
11630
11632 {
11634
11635 if (constval->constcollid != typcollation)
11636 {
11638 generate_collation_name(constval->constcollid));
11639 }
11640 }
11641}
11642
11643/*
11644 * get_json_path_spec - Parse back a JSON path specification
11645 */
11646static void
11648{
11651 else
11653}
11654
11655/*
11656 * get_json_format - Parse back a JsonFormat node
11657 */
11658static void
11660{
11662 return;
11663
11666 " FORMAT JSONB" : " FORMAT JSON");
11667
11669 {
11671
11672 encoding =
11675
11677 }
11678}
11679
11680/*
11681 * get_json_returning - Parse back a JsonReturning structure
11682 */
11683static void
11686{
11688 return;
11689
11692 returning->typmod));
11693
11698}
11699
11700/*
11701 * get_json_constructor - Parse back a JsonConstructorExpr node
11702 */
11703static void
11706{
11712
11714 {
11716 return;
11717 }
11719 {
11721 return;
11722 }
11723
11725 {
11728 break;
11731 break;
11734 break;
11737 break;
11740 break;
11741 default:
11743 }
11744
11746
11749 {
11752 {
11754
11757 }
11758
11760 }
11761
11764}
11765
11766/*
11767 * Append options, if any, to the JSON constructor being deparsed
11768 */
11769static void
11771{
11773 {
11777 }
11778 else
11779 {
11783 }
11784
11787
11788 /*
11789 * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
11790 * support one.
11791 */
11794}
11795
11796/*
11797 * get_json_agg_constructor - Parse back an aggregate JsonConstructorExpr node
11798 */
11799static void
11802{
11804
11807
11815 is_json_objectagg);
11816 else
11819}
11820
11821/*
11822 * simple_quote_literal - Format a string as a SQL literal, append to buf
11823 */
11824static void
11826{
11828
11829 /*
11830 * We always form the string literal according to standard SQL rules.
11831 */
11834 {
11836
11840 }
11842}
11843
11844
11845/* ----------
11846 * get_sublink_expr - Parse back a sublink
11847 * ----------
11848 */
11849static void
11851{
11856
11859 else
11861
11862 /*
11863 * Note that we print the name of only the first operator, when there are
11864 * multiple combining operators. This is an approximation that could go
11865 * wrong in various scenarios (operators in different schemas, renamed
11866 * operators, etc) but there is not a whole lot we can do about it, since
11867 * the syntax allows only one operator to be shown.
11868 */
11870 {
11872 {
11873 /* single combining operator */
11875
11880 }
11882 {
11883 /* multiple combining operators, = or <> cases */
11885 ListCell *l;
11886
11890 {
11892
11900 }
11902 }
11904 {
11905 /* multiple combining operators, < <= > >= cases */
11907
11914 }
11915 else
11918 }
11919
11921
11923 {
11926 break;
11927
11931 else
11933 break;
11934
11937 break;
11938
11941 break;
11942
11947 break;
11948
11950 default:
11953 break;
11954 }
11955
11958
11961 context->indentLevel);
11962
11965 else
11967}
11968
11969
11970/* ----------
11971 * get_xmltable - Parse back a XMLTABLE function
11972 * ----------
11973 */
11974static void
11976{
11978
11980
11982 {
11984 *lc2;
11985 bool first = true;
11986
11989 {
11992
11993 if (!first)
11995 else
11996 first = false;
11997
11999 {
12003 }
12004 else
12005 {
12008 }
12009 }
12011 }
12012
12018
12020 {
12021 ListCell *l1;
12022 ListCell *l2;
12023 ListCell *l3;
12024 ListCell *l4;
12025 ListCell *l5;
12026 int colnum = 0;
12027
12029 forfive(l1, tf->colnames, l2, tf->coltypes, l3, tf->coltypmods,
12030 l4, tf->colexprs, l5, tf->coldefexprs)
12031 {
12037 bool ordinality = (tf->ordinalitycol == colnum);
12039
12040 if (colnum > 0)
12042 colnum++;
12043
12045 ordinality ? "FOR ORDINALITY" :
12046 format_type_with_typemod(typid, typmod));
12047 if (ordinality)
12048 continue;
12049
12051 {
12055 }
12057 {
12061 }
12062 if (notnull)
12064 }
12065 }
12066
12068}
12069
12070/*
12071 * get_json_table_nested_columns - Parse back nested JSON_TABLE columns
12072 */
12073static void
12077{
12079 {
12081
12084
12090 }
12092 {
12094
12096 needcomma);
12098 true);
12099 }
12100}
12101
12102/*
12103 * get_json_table_columns - Parse back JSON_TABLE columns
12104 */
12105static void
12107 deparse_context *context,
12109{
12115 int colnum = 0;
12116
12119
12122
12124 lc_coltype, tf->coltypes,
12125 lc_coltypmod, tf->coltypmods,
12126 lc_colvalexpr, tf->colvalexprs)
12127 {
12129 JsonExpr *colexpr;
12130 Oid typid;
12131 int32 typmod;
12132 bool ordinality;
12134
12138
12139 /* Skip columns that don't belong to this scan. */
12141 {
12142 colnum++;
12143 continue;
12144 }
12146 break;
12147
12150
12151 colnum++;
12152
12153 ordinality = !colexpr;
12154
12156
12158 ordinality ? "FOR ORDINALITY" :
12159 format_type_with_typemod(typid, typmod));
12160 if (ordinality)
12161 continue;
12162
12163 /*
12164 * Set default_behavior to guide get_json_expr_options() on whether to
12165 * emit the ON ERROR / EMPTY clauses.
12166 */
12168 {
12171 }
12172 else
12173 {
12175 {
12178
12180
12184 " FORMAT JSONB" : " FORMAT JSON");
12185 }
12186
12188 }
12189
12191
12193
12195 }
12196
12199 scan->colMin >= 0);
12200
12203
12205}
12206
12207/* ----------
12208 * get_json_table - Parse back a JSON_TABLE function
12209 * ----------
12210 */
12211static void
12213{
12217
12219
12222
12224
12226
12228
12230
12232
12234 {
12236 *lc2;
12238
12241
12244
12247 {
12251
12253
12257 );
12258 }
12259
12262 }
12263
12265 showimplicit);
12266
12269
12272
12274}
12275
12276/* ----------
12277 * get_tablefunc - Parse back a table function
12278 * ----------
12279 */
12280static void
12282{
12283 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12284
12289}
12290
12291/* ----------
12292 * get_from_clause - Parse back a FROM clause
12293 *
12294 * "prefix" is the keyword that denotes the start of the list of FROM
12295 * elements. It is FROM when used to parse back SELECT and UPDATE, but
12296 * is USING when parsing back DELETE.
12297 * ----------
12298 */
12299static void
12301{
12303 bool first = true;
12304 ListCell *l;
12305
12306 /*
12307 * We use the query's jointree as a guide to what to print. However, we
12308 * must ignore auto-added RTEs that are marked not inFromCl. (These can
12309 * only appear at the top level of the jointree, so it's sufficient to
12310 * check here.) This check also ensures we ignore the rule pseudo-RTEs
12311 * for NEW and OLD.
12312 */
12314 {
12316
12318 {
12321
12323 continue;
12324 }
12325
12326 if (first)
12327 {
12328 appendContextKeyword(context, prefix,
12330 first = false;
12331
12332 get_from_clause_item(jtnode, query, context);
12333 }
12334 else
12335 {
12337
12339
12340 /*
12341 * Put the new FROM item's text into itembuf so we can decide
12342 * after we've got it whether or not it needs to go on a new line.
12343 */
12346
12347 get_from_clause_item(jtnode, query, context);
12348
12349 /* Restore context's output buffer */
12351
12352 /* Consider line-wrapping if enabled */
12354 {
12355 /* Does the new item start with a new line? */
12357 {
12358 /* If so, we shouldn't add anything */
12359 /* instead, remove any trailing spaces currently in buf */
12361 }
12362 else
12363 {
12365
12366 /* Locate the start of the current line in the buffer */
12370 else
12371 trailing_nl++;
12372
12373 /*
12374 * Add a newline, plus some indentation, if the new item
12375 * would cause an overflow.
12376 */
12379 PRETTYINDENT_STD,
12380 PRETTYINDENT_VAR);
12381 }
12382 }
12383
12384 /* Add the new item */
12386
12387 /* clean up */
12389 }
12390 }
12391}
12392
12393static void
12395{
12398
12400 {
12405
12408
12409 /* Print the FROM item proper */
12411 {
12413 /* Normal relation RTE */
12417 context->namespaces));
12418 break;
12420 /* Subquery RTE */
12423 true,
12425 context->indentLevel);
12427 break;
12429 /* Function RTE */
12431
12432 /*
12433 * Omit ROWS FROM() syntax for just one function, unless it
12434 * has both a coldeflist and WITH ORDINALITY. If it has both,
12435 * we must use ROWS FROM() syntax to avoid ambiguity about
12436 * whether the coldeflist includes the ordinality column.
12437 */
12440 {
12442 /* we'll print the coldeflist below, if it has one */
12443 }
12444 else
12445 {
12448
12449 /*
12450 * If all the function calls in the list are to unnest,
12451 * and none need a coldeflist, then collapse the list back
12452 * down to UNNEST(args). (If we had more than one
12453 * built-in unnest function, this would get more
12454 * difficult.)
12455 *
12456 * XXX This is pretty ugly, since it makes not-terribly-
12457 * future-proof assumptions about what the parser would do
12458 * with the output; but the alternative is to emit our
12459 * nonstandard ROWS FROM() notation for what might have
12460 * been a perfectly spec-compliant multi-argument
12461 * UNNEST().
12462 */
12465 {
12467
12470 rtfunc->funccolnames != NIL)
12471 {
12473 break;
12474 }
12475 }
12476
12478 {
12480
12482 {
12485
12487 }
12488
12492 }
12493 else
12494 {
12496
12499 {
12501
12506 {
12507 /* Reconstruct the column definition list */
12509 get_from_clause_coldeflist(rtfunc,
12510 NULL,
12511 context);
12512 }
12513 funcno++;
12514 }
12516 }
12517 /* prevent printing duplicate coldeflist below */
12519 }
12522 break;
12525 break;
12527 /* Values list RTE */
12531 break;
12534 break;
12535 default:
12537 break;
12538 }
12539
12540 /* Print the relation alias, if needed */
12542
12543 /* Print the column definitions or aliases, if needed */
12545 {
12546 /* Reconstruct the columndef list, which is also the aliases */
12548 }
12549 else
12550 {
12551 /* Else print column aliases as needed */
12553 }
12554
12555 /* Tablesample clause must go after any alias */
12558 }
12560 {
12564
12568
12571
12573
12575 {
12579 -PRETTYINDENT_STD,
12580 PRETTYINDENT_STD,
12581 PRETTYINDENT_JOIN);
12582 else
12584 -PRETTYINDENT_STD,
12585 PRETTYINDENT_STD,
12586 PRETTYINDENT_JOIN);
12587 break;
12590 -PRETTYINDENT_STD,
12591 PRETTYINDENT_STD,
12592 PRETTYINDENT_JOIN);
12593 break;
12596 -PRETTYINDENT_STD,
12597 PRETTYINDENT_STD,
12598 PRETTYINDENT_JOIN);
12599 break;
12602 -PRETTYINDENT_STD,
12603 PRETTYINDENT_STD,
12604 PRETTYINDENT_JOIN);
12605 break;
12606 default:
12609 }
12610
12616
12618 {
12620 bool first = true;
12621
12623 /* Use the assigned names, not what's in usingClause */
12625 {
12627
12628 if (first)
12629 first = false;
12630 else
12633 }
12635
12639 }
12641 {
12648 }
12650 {
12651 /* If we didn't say CROSS JOIN above, we must provide an ON */
12653 }
12654
12657
12658 /* Yes, it's correct to put alias after the right paren ... */
12660 {
12661 /*
12662 * Note that it's correct to emit an alias clause if and only if
12663 * there was one originally. Otherwise we'd be converting a named
12664 * join to unnamed or vice versa, which creates semantic
12665 * subtleties we don't want. However, we might print a different
12666 * alias name than was there originally.
12667 */
12670 context)));
12672 }
12673 }
12674 else
12677}
12678
12679/*
12680 * get_rte_alias - print the relation's alias, if needed
12681 *
12682 * If printed, the alias is preceded by a space, or by " AS " if use_as is true.
12683 */
12684static void
12686 deparse_context *context)
12687{
12692
12694 {
12695 /* Always print alias if user provided one */
12697 }
12699 {
12700 /* Always print alias if we need to print column aliases */
12702 }
12704 {
12705 /*
12706 * No need to print alias if it's same as relation name (this would
12707 * normally be the case, but not if set_rtable_names had to resolve a
12708 * conflict).
12709 */
12712 }
12714 {
12715 /*
12716 * For a function RTE, always print alias. This covers possible
12717 * renaming of the function and/or instability of the FigureColname
12718 * rules for things that aren't simple functions. Note we'd need to
12719 * force it anyway for the columndef list case.
12720 */
12722 }
12725 {
12726 /*
12727 * For a subquery, always print alias. This makes the output
12728 * SQL-spec-compliant, even though we allow such aliases to be omitted
12729 * on input.
12730 */
12732 }
12734 {
12735 /*
12736 * No need to print alias if it's same as CTE name (this would
12737 * normally be the case, but not if set_rtable_names had to resolve a
12738 * conflict).
12739 */
12742 }
12743
12747 quote_identifier(refname));
12748}
12749
12750/*
12751 * get_column_alias_list - print column alias list for an RTE
12752 *
12753 * Caller must already have printed the relation's alias name.
12754 */
12755static void
12757{
12760 bool first = true;
12761
12762 /* Don't print aliases if not needed */
12764 return;
12765
12767 {
12769
12770 if (first)
12771 {
12773 first = false;
12774 }
12775 else
12778 }
12779 if (!first)
12781}
12782
12783/*
12784 * get_from_clause_coldeflist - reproduce FROM clause coldeflist
12785 *
12786 * When printing a top-level coldeflist (which is syntactically also the
12787 * relation's column alias list), use column names from colinfo. But when
12788 * printing a coldeflist embedded inside ROWS FROM(), we prefer to use the
12789 * original coldeflist's names, which are available in rtfunc->funccolnames.
12790 * Pass NULL for colinfo to select the latter behavior.
12791 *
12792 * The coldeflist is appended immediately (no space) to buf. Caller is
12793 * responsible for ensuring that an alias or AS is present before it.
12794 */
12795static void
12798 deparse_context *context)
12799{
12801 ListCell *l1;
12802 ListCell *l2;
12803 ListCell *l3;
12804 ListCell *l4;
12806
12808
12809 i = 0;
12810 forfour(l1, rtfunc->funccoltypes,
12811 l2, rtfunc->funccoltypmods,
12812 l3, rtfunc->funccolcollations,
12813 l4, rtfunc->funccolnames)
12814 {
12819
12822 else
12824
12826
12835 generate_collation_name(attcollation));
12836
12837 i++;
12838 }
12839
12841}
12842
12843/*
12844 * get_tablesample_def - print a TableSampleClause
12845 */
12846static void
12848{
12850 Oid argtypes[1];
12851 int nargs;
12852 ListCell *l;
12853
12854 /*
12855 * We should qualify the handler's function name if it wouldn't be
12856 * resolved by lookup in the current search path.
12857 */
12858 argtypes[0] = INTERNALOID;
12861 NIL, argtypes,
12863
12864 nargs = 0;
12866 {
12867 if (nargs++ > 0)
12870 }
12872
12874 {
12878 }
12879}
12880
12881/*
12882 * get_opclass_name - fetch name of an index operator class
12883 *
12884 * The opclass name is appended (after a space) to buf.
12885 *
12886 * Output is suppressed if the opclass is the default for the given
12887 * actual_datatype. (If you don't want this behavior, just pass
12888 * InvalidOid for actual_datatype.)
12889 */
12890static void
12893{
12897 char *nspname;
12898
12903
12906 {
12907 /* Okay, we need the opclass name. Do we need to qualify it? */
12911 else
12912 {
12915 quote_identifier(nspname),
12917 }
12918 }
12920}
12921
12922/*
12923 * generate_opclass_name
12924 * Compute the name to display for an opclass specified by OID
12925 *
12926 * The result includes all necessary quoting and schema-prefixing.
12927 */
12928char *
12930{
12932
12935
12937}
12938
12939/*
12940 * processIndirection - take care of array and subfield assignment
12941 *
12942 * We strip any top-level FieldStore or assignment SubscriptingRef nodes that
12943 * appear in the input, printing them as decoration for the base column
12944 * name (which we assume the caller just printed). We might also need to
12945 * strip CoerceToDomain nodes, but only ones that appear above assignment
12946 * nodes.
12947 *
12948 * Returns the subexpression that's to be assigned.
12949 */
12952{
12955
12956 for (;;)
12957 {
12959 break;
12961 {
12963 Oid typrelid;
12964 char *fieldname;
12965
12966 /* lookup tuple type */
12967 typrelid = get_typ_typrelid(fstore->resulttype);
12970 format_type_be(fstore->resulttype));
12971
12972 /*
12973 * Print the field name. There should only be one target field in
12974 * stored rules. There could be more than that in executable
12975 * target lists, but this function cannot be used for that case.
12976 */
12978 fieldname = get_attname(typrelid,
12981
12982 /*
12983 * We ignore arg since it should be an uninteresting reference to
12984 * the target column or subcolumn.
12985 */
12987 }
12989 {
12991
12993 break;
12994
12995 printSubscripts(sbsref, context);
12996
12997 /*
12998 * We ignore refexpr since it should be an uninteresting reference
12999 * to the target column or subcolumn.
13000 */
13002 }
13004 {
13006 /* If it's an explicit domain coercion, we're done */
13008 break;
13009 /* Tentatively descend past the CoerceToDomain */
13011 }
13012 else
13013 break;
13014 }
13015
13016 /*
13017 * If we descended past a CoerceToDomain whose argument turned out not to
13018 * be a FieldStore or array assignment, back up to the CoerceToDomain.
13019 * (This is not enough to be fully correct if there are nested implicit
13020 * CoerceToDomains, but such cases shouldn't ever occur.)
13021 */
13024
13025 return node;
13026}
13027
13028static void
13030{
13034
13037 {
13040 {
13041 /* If subexpression is NULL, get_rule_expr prints nothing */
13045 }
13046 /* If subexpression is NULL, get_rule_expr prints nothing */
13049 }
13050}
13051
13052/*
13053 * quote_identifier - Quote an identifier only if needed
13054 *
13055 * When quotes are needed, we palloc the required space; slightly
13056 * space-wasteful but well worth it for notational simplicity.
13057 */
13058const char *
13060{
13061 /*
13062 * Can avoid quoting if ident starts with a lowercase letter or underscore
13063 * and contains only lowercase letters, digits, and underscores, *and* is
13064 * not any SQL keyword. Otherwise, supply quotes.
13065 */
13068 const char *ptr;
13069 char *result;
13071
13072 /*
13073 * would like to use <ctype.h> macros here, but they might yield unwanted
13074 * locale-specific results...
13075 */
13077
13079 {
13081
13085 {
13086 /* okay */
13087 }
13088 else
13089 {
13092 nquotes++;
13093 }
13094 }
13095
13098
13100 {
13101 /*
13102 * Check for keyword. We quote keywords except for unreserved ones.
13103 * (In some cases we could avoid quoting a col_name or type_func_name
13104 * keyword, but it seems much harder than it's worth to tell that.)
13105 *
13106 * Note: ScanKeywordLookup() does case-insensitive comparison, but
13107 * that's fine, since we already know we have all-lower-case.
13108 */
13110
13113 }
13114
13117
13119
13120 optr = result;
13123 {
13125
13129 }
13132
13133 return result;
13134}
13135
13136/*
13137 * quote_qualified_identifier - Quote a possibly-qualified identifier
13138 *
13139 * Return a name of the form qualifier.ident, or just ident if qualifier
13140 * is NULL, quoting each component if necessary. The result is palloc'd.
13141 */
13142char *
13145{
13147
13153}
13154
13155/*
13156 * get_relation_name
13157 * Get the unqualified name of a relation specified by OID
13158 *
13159 * This differs from the underlying get_rel_name() function in that it will
13160 * throw error instead of silently returning NULL if the OID is bad.
13161 */
13162static char *
13164{
13166
13170}
13171
13172/*
13173 * generate_relation_name
13174 * Compute the name to display for a relation specified by OID
13175 *
13176 * The result includes all necessary quoting and schema-prefixing.
13177 *
13178 * If namespaces isn't NIL, it must be a list of deparse_namespace nodes.
13179 * We will forcibly qualify the relation name if it equals any CTE name
13180 * visible in the namespace list.
13181 */
13182static char *
13184{
13185 HeapTuple tp;
13190 char *nspname;
13191 char *result;
13192
13198
13199 /* Check for conflicting CTE name */
13202 {
13205
13207 {
13209
13211 {
13213 break;
13214 }
13215 }
13217 break;
13218 }
13219
13220 /* Otherwise, qualify the name if not visible in search path */
13223
13226 else
13227 nspname = NULL;
13228
13230
13231 ReleaseSysCache(tp);
13232
13233 return result;
13234}
13235
13236/*
13237 * generate_qualified_relation_name
13238 * Compute the name to display for a relation specified by OID
13239 *
13240 * As above, but unconditionally schema-qualify the name.
13241 */
13242static char *
13244{
13245 HeapTuple tp;
13248 char *nspname;
13249 char *result;
13250
13256
13258 if (!nspname)
13260 reltup->relnamespace);
13261
13263
13264 ReleaseSysCache(tp);
13265
13266 return result;
13267}
13268
13269/*
13270 * generate_function_name
13271 * Compute the name to display for a function specified by OID,
13272 * given that it is being called with the specified actual arg names and
13273 * types. (Those matter because of ambiguous-function resolution rules.)
13274 *
13275 * If we're dealing with a potentially variadic function (in practice, this
13276 * means a FuncExpr or Aggref, not some other way of calling a function), then
13277 * has_variadic must specify whether variadic arguments have been merged,
13278 * and *use_variadic_p will be set to indicate whether to print VARIADIC in
13279 * the output. For non-FuncExpr cases, has_variadic should be false and
13280 * use_variadic_p can be NULL.
13281 *
13282 * inGroupBy must be true if we're deparsing a GROUP BY clause.
13283 *
13284 * The result includes all necessary quoting and schema-prefixing.
13285 */
13286static char *
13289 bool inGroupBy)
13290{
13291 char *result;
13296 char *nspname;
13306
13312
13313 /*
13314 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
13315 * qualification of some function names within GROUP BY.
13316 */
13317 if (inGroupBy)
13318 {
13321 }
13322
13323 /*
13324 * Determine whether VARIADIC should be printed. We must do this first
13325 * since it affects the lookup rules in func_get_detail().
13326 *
13327 * We always print VARIADIC if the function has a merged variadic-array
13328 * argument. Note that this is always the case for functions taking a
13329 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
13330 * and printed the array elements as separate arguments, the call could
13331 * match a newer non-VARIADIC function.
13332 */
13334 {
13335 /* Parser should not have set funcvariadic unless fn is variadic */
13339 }
13340 else
13341 {
13344 }
13345
13346 /*
13347 * The idea here is to schema-qualify only if the parser would fail to
13348 * resolve the correct function given the unqualified func name with the
13349 * specified argtypes and VARIADIC flag. But if we already decided to
13350 * force qualification, then we can skip the lookup and pretend we didn't
13351 * find it.
13352 */
13355 NIL, argnames, nargs, argtypes,
13357 &fgc_flags,
13361 else
13362 {
13365 }
13366
13370 p_funcid == funcid)
13371 nspname = NULL;
13372 else
13374
13376
13378
13379 return result;
13380}
13381
13382/*
13383 * generate_operator_name
13384 * Compute the name to display for an operator specified by OID,
13385 * given that it is being called with the specified actual arg types.
13386 * (Arg types matter because of ambiguous-operator resolution rules.
13387 * Pass InvalidOid for unused arg of a unary operator.)
13388 *
13389 * The result includes all necessary quoting and schema-prefixing,
13390 * plus the OPERATOR() decoration needed to use a qualified operator name
13391 * in an expression.
13392 */
13393static char *
13395{
13399 char *oprname;
13400 char *nspname;
13402
13404
13410
13411 /*
13412 * The idea here is to schema-qualify only if the parser would fail to
13413 * resolve the correct operator given the unqualified op name with the
13414 * specified argtypes.
13415 */
13417 {
13418 case 'b':
13420 true, -1);
13421 break;
13422 case 'l':
13424 true, -1);
13425 break;
13426 default:
13429 break;
13430 }
13431
13433 nspname = NULL;
13434 else
13435 {
13438 }
13439
13441
13442 if (nspname)
13444
13447
13449
13451}
13452
13453/*
13454 * generate_operator_clause --- generate a binary-operator WHERE clause
13455 *
13456 * This is used for internally-generated-and-executed SQL queries, where
13457 * precision is essential and readability is secondary. The basic
13458 * requirement is to append "leftop op rightop" to buf, where leftop and
13459 * rightop are given as strings and are assumed to yield types leftoptype
13460 * and rightoptype; the operator is identified by OID. The complexity
13461 * comes from needing to be sure that the parser will select the desired
13462 * operator when the query is parsed. We always name the operator using
13463 * OPERATOR(schema.op) syntax, so as to avoid search-path uncertainties.
13464 * We have to emit casts too, if either input isn't already the input type
13465 * of the operator; else we are at the mercy of the parser's heuristics for
13466 * ambiguous-operator resolution. The caller must ensure that leftop and
13467 * rightop are suitable arguments for a cast operation; it's best to insert
13468 * parentheses if they aren't just variables or parameters.
13469 */
13470void
13475{
13478 char *oprname;
13479 char *nspname;
13480
13487
13489
13498
13500}
13501
13502/*
13503 * Add a cast specification to buf. We spell out the type name the hard way,
13504 * intentionally not using format_type_be(). This is to avoid corner cases
13505 * for CHARACTER, BIT, and perhaps other types, where specifying the type
13506 * using SQL-standard syntax results in undesirable data truncation. By
13507 * doing it this way we can be certain that the cast will have default (-1)
13508 * target typmod.
13509 */
13510static void
13512{
13516 char *nspname;
13517
13522
13525
13528
13530}
13531
13532/*
13533 * generate_qualified_type_name
13534 * Compute the name to display for a type specified by OID
13535 *
13536 * This is different from format_type_be() in that we unconditionally
13537 * schema-qualify the name. That also means no special syntax for
13538 * SQL-standard type names ... although in current usage, this should
13539 * only get used for domains, so such cases wouldn't occur anyway.
13540 */
13541static char *
13543{
13544 HeapTuple tp;
13547 char *nspname;
13548 char *result;
13549
13555
13557 if (!nspname)
13559 typtup->typnamespace);
13560
13562
13563 ReleaseSysCache(tp);
13564
13565 return result;
13566}
13567
13568/*
13569 * generate_collation_name
13570 * Compute the name to display for a collation specified by OID
13571 *
13572 * The result includes all necessary quoting and schema-prefixing.
13573 */
13574char *
13576{
13577 HeapTuple tp;
13579 char *collname;
13580 char *nspname;
13581 char *result;
13582
13588
13591 else
13592 nspname = NULL;
13593
13594 result = quote_qualified_identifier(nspname, collname);
13595
13596 ReleaseSysCache(tp);
13597
13598 return result;
13599}
13600
13601/*
13602 * Given a C string, produce a TEXT datum.
13603 *
13604 * We assume that the input was palloc'd and may be freed.
13605 */
13608{
13609 text *result;
13610
13613 return result;
13614}
13615
13616/*
13617 * Generate a C string representing a relation options from text[] datum.
13618 */
13619static void
13621{
13625
13628
13630 {
13635
13636 /*
13637 * Each array element should have the form name=value. If the "=" is
13638 * missing for some reason, treat it like an empty value.
13639 */
13643 {
13646 }
13647 else
13649
13653
13654 /*
13655 * In general we need to quote the value; but to avoid unnecessary
13656 * clutter, do not quote if it is an identifier that would not need
13657 * quoting. (We could also allow numbers, but that is a bit trickier
13658 * than it looks --- for example, are leading zeroes significant? We
13659 * don't want to assume very much here about what custom reloptions
13660 * might mean.)
13661 */
13664 else
13666
13668 }
13669}
13670
13671/*
13672 * Generate a C string representing a relation's reloptions, or NULL if none.
13673 */
13674static char *
13676{
13678 HeapTuple tuple;
13679 Datum reloptions;
13680 bool isnull;
13681
13685
13687 Anum_pg_class_reloptions, &isnull);
13688 if (!isnull)
13689 {
13691
13694
13695 result = buf.data;
13696 }
13697
13698 ReleaseSysCache(tuple);
13699
13700 return result;
13701}
13702
13703/*
13704 * get_range_partbound_string
13705 * A C string representation of one range partition bound
13706 */
13707char *
13709{
13710 deparse_context context;
13712 ListCell *cell;
13714
13718
13722 {
13723 PartitionRangeDatum *datum =
13725
13731 else
13732 {
13734
13736 }
13738 }
13740
13742}
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition arrayfuncs.c:5351
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition arrayfuncs.c:3147
void deconstruct_array_builtin(const ArrayType *array, Oid elmtype, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition arrayfuncs.c:3698
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition arrayfuncs.c:5421
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:861
static struct @172 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:3057
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:2860
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:3624
bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
Definition nodeFuncs.c:557
int get_aggregate_argtypes(Aggref *aggref, Oid *inputTypes)
Definition parse_agg.c:2050
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:521
Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
Definition parse_oper.c:371
char * get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum)
Definition parse_relation.c:3354
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
Definition parse_relation.c:3541
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:2747
#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
AttrNumber extractNotNullColumn(HeapTuple constrTup)
Definition pg_constraint.c:702
#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
FormData_pg_partitioned_table * Form_pg_partitioned_table
Definition pg_partitioned_table.h:65
FormData_pg_statistic_ext * Form_pg_statistic_ext
Definition pg_statistic_ext.h:69
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:5542
Datum pg_get_partition_constraintdef(PG_FUNCTION_ARGS)
Definition ruleutils.c:2095
static char * get_rtable_name(int rtindex, deparse_context *context)
Definition ruleutils.c:5136
static int decompile_column_index_array(Datum column_index_array, Oid relId, bool withPeriod, StringInfo buf)
Definition ruleutils.c:2620
static void set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition ruleutils.c:4378
static void appendContextKeyword(deparse_context *context, const char *str, int indentBefore, int indentAfter, int indentPlus)
Definition ruleutils.c:9095
List * deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names)
Definition ruleutils.c:3756
char * pg_get_statisticsobjdef_string(Oid statextid)
Definition ruleutils.c:1626
static void set_using_names(deparse_namespace *dpns, Node *jtnode, List *parentUsing)
Definition ruleutils.c:4213
static Plan * find_recursive_union(deparse_namespace *dpns, WorkTableScan *wtscan)
Definition ruleutils.c:5236
static void get_values_def(List *values_lists, deparse_context *context)
Definition ruleutils.c:5727
static char * make_colname_unique(char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition ruleutils.c:4926
static void get_json_behavior(JsonBehavior *behavior, deparse_context *context, const char *on)
Definition ruleutils.c:9186
static const char * get_simple_binary_op_name(OpExpr *expr)
Definition ruleutils.c:8837
static void get_json_agg_constructor(JsonConstructorExpr *ctor, deparse_context *context, const char *funcname, bool is_json_objectagg)
Definition ruleutils.c:11801
static void set_deparse_for_query(deparse_namespace *dpns, Query *query, List *parent_namespaces)
Definition ruleutils.c:4032
static void print_function_trftypes(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3461
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:13144
static void get_setop_query(Node *setOp, Query *query, deparse_context *context)
Definition ruleutils.c:6419
static bool is_input_argument(int nth, const char *argmodes)
Definition ruleutils.c:3449
static void get_query_def(Query *query, StringInfo buf, List *parentnamespace, TupleDesc resultDesc, bool colNamesVisible, int prettyFlags, int wrapColumn, int startIndent)
Definition ruleutils.c:5627
static void get_tablesample_def(TableSampleClause *tablesample, deparse_context *context)
Definition ruleutils.c:12848
static void get_sublink_expr(SubLink *sublink, deparse_context *context)
Definition ruleutils.c:11851
static const char * get_name_for_var_field(Var *var, int fieldno, int levelsup, deparse_context *context)
Definition ruleutils.c:8022
static void get_rte_alias(RangeTblEntry *rte, int varno, bool use_as, deparse_context *context)
Definition ruleutils.c:12686
Datum pg_get_function_arg_default(PG_FUNCTION_ARGS)
Definition ruleutils.c:3489
static void get_parameter(Param *param, deparse_context *context)
Definition ruleutils.c:8692
static void build_colinfo_names_hash(deparse_columns *colinfo)
Definition ruleutils.c:4981
Datum pg_get_statisticsobjdef_expressions(PG_FUNCTION_ARGS)
Definition ruleutils.c:1837
static void get_delete_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7360
static void get_json_table_columns(TableFunc *tf, JsonTablePathScan *scan, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12107
static void get_column_alias_list(deparse_columns *colinfo, deparse_context *context)
Definition ruleutils.c:12757
Datum pg_get_statisticsobjdef_columns(PG_FUNCTION_ARGS)
Definition ruleutils.c:1636
static void add_to_names_hash(deparse_columns *colinfo, const char *name)
Definition ruleutils.c:5039
static void simple_quote_literal(StringInfo buf, const char *val)
Definition ruleutils.c:11826
static bool colname_is_unique(const char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition ruleutils.c:4851
static void get_from_clause_coldeflist(RangeTblFunction *rtfunc, deparse_columns *colinfo, deparse_context *context)
Definition ruleutils.c:12797
char * pg_get_partkeydef_columns(Oid relid, bool pretty)
Definition ruleutils.c:1923
static void get_from_clause(Query *query, const char *prefix, deparse_context *context)
Definition ruleutils.c:12301
List * deparse_context_for(const char *aliasname, Oid relid)
Definition ruleutils.c:3711
static bool get_func_sql_syntax(FuncExpr *expr, deparse_context *context)
Definition ruleutils.c:11182
static char * generate_qualified_relation_name(Oid relid)
Definition ruleutils.c:13244
static void set_simple_column_names(deparse_namespace *dpns)
Definition ruleutils.c:4101
static void get_json_expr_options(JsonExpr *jsexpr, deparse_context *context, JsonBehaviorType default_behavior)
Definition ruleutils.c:9224
char * pg_get_indexdef_columns(Oid indexrelid, bool pretty)
Definition ruleutils.c:1235
static void get_rule_groupingset(GroupingSet *gset, List *targetlist, bool omit_parens, deparse_context *context)
Definition ruleutils.c:6636
char * pg_get_indexdef_columns_extended(Oid indexrelid, bits16 flags)
Definition ruleutils.c:1249
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:1270
static char * pg_get_constraintdef_worker(Oid constraintId, bool fullCommand, int prettyFlags, bool missing_ok)
Definition ruleutils.c:2192
static void get_rule_expr_funccall(Node *node, deparse_context *context, bool showimplicit)
Definition ruleutils.c:10711
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:13288
static void expand_colnames_array_to(deparse_columns *colinfo, int n)
Definition ruleutils.c:4965
static void get_returning_clause(Query *query, deparse_context *context)
Definition ruleutils.c:6380
List * set_deparse_context_plan(List *dpcontext, Plan *plan, List *ancestors)
Definition ruleutils.c:3828
static SubPlan * find_param_generator(Param *param, deparse_context *context, int *column_p)
Definition ruleutils.c:8574
static void get_special_variable(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:7893
static void get_windowfunc_expr_helper(WindowFunc *wfunc, deparse_context *context, const char *funcname, const char *options, bool is_json_objectagg)
Definition ruleutils.c:11064
static void get_rule_list_toplevel(List *lst, deparse_context *context, bool showimplicit)
Definition ruleutils.c:10681
static char * pg_get_statisticsobj_worker(Oid statextid, bool columns_only, bool missing_ok)
Definition ruleutils.c:1653
#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:11705
static void get_json_path_spec(Node *path_spec, deparse_context *context, bool showimplicit)
Definition ruleutils.c:11648
static void printSubscripts(SubscriptingRef *sbsref, deparse_context *context)
Definition ruleutils.c:13030
static SubPlan * find_param_generator_initplan(Param *param, Plan *plan, int *column_p)
Definition ruleutils.c:8671
static void pop_ancestor_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
Definition ruleutils.c:5334
static void get_window_frame_options(int frameOptions, Node *startOffset, Node *endOffset, deparse_context *context)
Definition ruleutils.c:6843
static void get_rule_expr_paren(Node *node, deparse_context *context, bool showimplicit, Node *parentNode)
Definition ruleutils.c:9168
static void get_agg_expr(Aggref *aggref, deparse_context *context, Aggref *original_aggref)
Definition ruleutils.c:10899
static void get_const_collation(Const *constval, deparse_context *context)
Definition ruleutils.c:11628
static void get_target_list(List *targetList, deparse_context *context)
Definition ruleutils.c:6244
static void get_json_table_nested_columns(TableFunc *tf, JsonTablePlan *plan, deparse_context *context, bool showimplicit, bool needcomma)
Definition ruleutils.c:12075
static char * deparse_expression_pretty(Node *expr, List *dpcontext, bool forceprefix, bool showimplicit, int prettyFlags, int startIndent)
Definition ruleutils.c:3675
static void get_insert_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:6944
static void print_function_sqlbody(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3559
static bool has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode)
Definition ruleutils.c:4143
static Node * get_rule_sortgroupclause(Index ref, List *tlist, bool force_colno, deparse_context *context)
Definition ruleutils.c:6567
static char * pg_get_viewdef_worker(Oid viewoid, int prettyFlags, int wrapColumn)
Definition ruleutils.c:789
static void push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell, deparse_namespace *save_dpns)
Definition ruleutils.c:5313
static text * pg_get_expr_worker(text *expr, Oid relid, int prettyFlags)
Definition ruleutils.c:2709
static Node * processIndirection(Node *node, deparse_context *context)
Definition ruleutils.c:12952
static void get_agg_combine_expr(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:11037
List * select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used)
Definition ruleutils.c:3858
static char * generate_qualified_type_name(Oid typid)
Definition ruleutils.c:13543
static void get_xmltable(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:11976
static void get_utility_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7566
static void get_rule_windowclause(Query *query, deparse_context *context)
Definition ruleutils.c:6754
static void get_rule_windowspec(WindowClause *wc, List *targetList, deparse_context *context)
Definition ruleutils.c:6786
static void get_json_returning(JsonReturning *returning, StringInfo buf, bool json_format_by_default)
Definition ruleutils.c:11685
static Node * find_param_referent(Param *param, deparse_context *context, deparse_namespace **dpns_p, ListCell **ancestor_cell_p)
Definition ruleutils.c:8460
static void get_rule_orderby(List *orderList, List *targetList, bool force_colno, deparse_context *context)
Definition ruleutils.c:6696
static void pop_child_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
Definition ruleutils.c:5283
char * pg_get_constraintdef_command(Oid constraintId)
Definition ruleutils.c:2183
char * pg_get_partconstrdef_string(Oid partitionId, char *aliasname)
Definition ruleutils.c:2127
static void set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition ruleutils.c:4581
static void set_rtable_names(deparse_namespace *dpns, List *parent_namespaces, Bitmapset *rels_used)
Definition ruleutils.c:3887
char * get_window_frame_options_for_explain(int frameOptions, Node *startOffset, Node *endOffset, List *dpcontext, bool forceprefix)
Definition ruleutils.c:6912
static void get_update_query_targetlist_def(Query *query, List *targetList, deparse_context *context, RangeTblEntry *rte)
Definition ruleutils.c:7208
static void get_rule_expr(Node *node, deparse_context *context, bool showimplicit)
Definition ruleutils.c:9265
static char * pg_get_partkeydef_worker(Oid relid, int prettyFlags, bool attrsOnly, bool missing_ok)
Definition ruleutils.c:1936
static void get_oper_expr(OpExpr *expr, deparse_context *context)
Definition ruleutils.c:10763
Datum pg_get_function_identity_arguments(PG_FUNCTION_ARGS)
Definition ruleutils.c:3208
static char * pg_get_triggerdef_worker(Oid trigid, bool pretty)
Definition ruleutils.c:900
static void get_reloptions(StringInfo buf, Datum reloptions)
Definition ruleutils.c:13621
static void get_func_expr(FuncExpr *expr, deparse_context *context, bool showimplicit)
Definition ruleutils.c:10803
static void get_const_expr(Const *constval, deparse_context *context, int showtype)
Definition ruleutils.c:11498
char * deparse_expression(Node *expr, List *dpcontext, bool forceprefix, bool showimplicit)
Definition ruleutils.c:3648
void generate_operator_clause(StringInfo buf, const char *leftop, Oid leftoptype, Oid opoid, const char *rightop, Oid rightoptype)
Definition ruleutils.c:13472
static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags)
Definition ruleutils.c:5350
static char * pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)
Definition ruleutils.c:597
static int print_function_arguments(StringInfo buf, HeapTuple proctup, bool print_table_args, bool print_defaults)
Definition ruleutils.c:3301
static void identify_join_columns(JoinExpr *j, RangeTblEntry *jrte, deparse_columns *colinfo)
Definition ruleutils.c:5068
static void print_function_rettype(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3263
static void set_deparse_plan(deparse_namespace *dpns, Plan *plan)
Definition ruleutils.c:5155
static void get_merge_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7407
static void resolve_special_varno(Node *node, deparse_context *context, rsv_callback callback, void *callback_arg)
Definition ruleutils.c:7914
static void get_json_format(JsonFormat *format, StringInfo buf)
Definition ruleutils.c:11660
char * get_range_partbound_string(List *bound_datums)
Definition ruleutils.c:13709
static void get_tablefunc(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12282
static void get_rule_expr_toplevel(Node *node, deparse_context *context, bool showimplicit)
Definition ruleutils.c:10663
static RangeTblEntry * get_simple_values_rte(Query *query, TupleDesc resultDesc)
Definition ruleutils.c:6042
static void get_coercion_expr(Node *arg, deparse_context *context, Oid resulttype, int32 resulttypmod, Node *parentNode)
Definition ruleutils.c:11434
static void push_child_plan(deparse_namespace *dpns, Plan *plan, deparse_namespace *save_dpns)
Definition ruleutils.c:5266
static void get_update_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7156
static void get_json_constructor_options(JsonConstructorExpr *ctor, StringInfo buf)
Definition ruleutils.c:11771
static void get_basic_select_query(Query *query, deparse_context *context)
Definition ruleutils.c:6111
static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags)
Definition ruleutils.c:8863
static void get_with_clause(Query *query, deparse_context *context)
Definition ruleutils.c:5770
static void destroy_colinfo_names_hash(deparse_columns *colinfo)
Definition ruleutils.c:5052
static char * generate_relation_name(Oid relid, List *namespaces)
Definition ruleutils.c:13184
static void get_windowfunc_expr(WindowFunc *wfunc, deparse_context *context)
Definition ruleutils.c:11053
static char * get_variable(Var *var, int levelsup, bool istoplevel, deparse_context *context)
Definition ruleutils.c:7611
static char * generate_operator_name(Oid operid, Oid arg1, Oid arg2)
Definition ruleutils.c:13395
static void get_from_clause_item(Node *jtnode, Query *query, deparse_context *context)
Definition ruleutils.c:12395
Datum pg_get_function_arguments(PG_FUNCTION_ARGS)
Definition ruleutils.c:3182
static void get_json_table(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12213
static void get_select_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:5909
static void get_opclass_name(Oid opclass, Oid actual_datatype, StringInfo buf)
Definition ruleutils.c:12892
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:10911
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:459
Definition primnodes.h:1142
Definition pathnodes.h:3259
Definition plannodes.h:389
Definition array.h:188
Definition primnodes.h:1264
Definition primnodes.h:1404
Definition array.h:93
Definition bitmapset.h:50
Definition primnodes.h:967
Definition primnodes.h:2005
Definition primnodes.h:1340
Definition primnodes.h:1386
Definition primnodes.h:1356
Definition primnodes.h:1510
Definition primnodes.h:2051
Definition primnodes.h:1238
Definition primnodes.h:1310
Definition parsenodes.h:1727
Definition primnodes.h:324
Definition primnodes.h:1292
Definition plannodes.h:799
Definition primnodes.h:2120
Definition plannodes.h:912
Definition primnodes.h:189
Definition primnodes.h:1159
Definition primnodes.h:1190
Definition plannodes.h:870
Definition primnodes.h:2355
Definition primnodes.h:779
Definition primnodes.h:557
Definition parsenodes.h:1565
Definition hsearch.h:66
Definition dynahash.c:222
Definition htup.h:63
Definition amapi.h:233
Definition plannodes.h:634
Definition primnodes.h:2149
Definition primnodes.h:2327
Definition primnodes.h:1812
Definition primnodes.h:1729
Definition primnodes.h:1839
Definition primnodes.h:1674
Definition primnodes.h:1758
Definition primnodes.h:1686
Definition primnodes.h:1919
Definition primnodes.h:1908
Definition primnodes.h:1949
Definition primnodes.h:1706
Definition pg_list.h:54
Definition primnodes.h:2029
Definition plannodes.h:417
Definition primnodes.h:1532
Definition plannodes.h:331
Definition ruleutils.c:319
Definition primnodes.h:820
Definition plannodes.h:993
Definition plannodes.h:986
Definition primnodes.h:2135
Definition nodes.h:135
Definition parsenodes.h:3788
Definition primnodes.h:1981
Definition primnodes.h:2371
Definition primnodes.h:846
Definition primnodes.h:391
Definition parsenodes.h:926
Definition parsenodes.h:959
Definition plannodes.h:186
Definition plannodes.h:62
Definition parsenodes.h:118
Definition parsenodes.h:1085
Definition parsenodes.h:1375
Definition primnodes.h:2293
Definition primnodes.h:73
Definition plannodes.h:459
Definition primnodes.h:1215
Definition rel.h:56
Definition plannodes.h:296
Definition primnodes.h:2173
Definition primnodes.h:1489
Definition primnodes.h:1446
Definition parsenodes.h:1635
Definition primnodes.h:1579
Definition primnodes.h:926
Definition skey.h:65
Definition parsenodes.h:2280
Definition snapshot.h:139
Definition parsenodes.h:1494
Definition stringinfo.h:47
Definition value.h:64
Definition primnodes.h:1041
Definition primnodes.h:1092
Definition plannodes.h:753
Definition primnodes.h:712
Definition relscan.h:209
Definition primnodes.h:111
Definition parsenodes.h:1402
Definition primnodes.h:2236
Definition tupdesc.h:136
Definition typcache.h:32
Definition primnodes.h:262
Definition plannodes.h:1231
Definition parsenodes.h:1595
Definition primnodes.h:594
Definition plannodes.h:823
Definition primnodes.h:1622
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:734
Definition getopt_long.h:18
Definition oid2name.c:30
Definition print.h:106
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition syscache.c:595
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition syscache.c:625
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:1921
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition typcache.c:386
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:193
bool SplitGUCList(char *rawstring, char separator, List **namelist)
Definition varlena.c:2978
char * map_xml_name_to_sql_identifier(const char *name)
Definition xml.c:2474
◆ GET_PRETTY_FLAGS
◆ only_marker
Definition at line 550 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 13512 of file ruleutils.c.
13513{
13517 char *nspname;
13518
13523
13526
13529
13531}
References appendStringInfo(), buf, elog, ERROR, fb(), 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 5039 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 9095 of file ruleutils.c.
9097{
9099
9101 {
9103
9105
9106 /* remove any trailing spaces currently in the buffer ... */
9108 /* ... then add a newline and some spaces */
9110
9113 else
9114 {
9115 /*
9116 * If we're indented more than PRETTYINDENT_LIMIT characters, try
9117 * to conserve horizontal space by reducing the per-level
9118 * indentation. For best results the scale factor here should
9119 * divide all the indent amounts that get added to indentLevel
9120 * (PRETTYINDENT_STD, etc). It's important that the indentation
9121 * not grow unboundedly, else deeply-nested trees use O(N^2)
9122 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
9123 */
9126 (PRETTYINDENT_STD / 2);
9128 /* scale/wrap logic affects indentLevel, but not indentPlus */
9130 }
9132
9134
9137 context->indentLevel = 0;
9138 }
9139 else
9141}
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 4981 of file ruleutils.c.
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}
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 4851 of file ruleutils.c.
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}
References fb(), HASH_FIND, hash_search(), i, and lfirst.
Referenced by make_colname_unique().
◆ decompile_column_index_array()
|
static |
Definition at line 2620 of file ruleutils.c.
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}
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 3711 of file ruleutils.c.
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}
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 3756 of file ruleutils.c.
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}
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 3648 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 3675 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 5052 of file ruleutils.c.
5053{
5055 {
5058 }
5059}
References fb(), and hash_destroy().
Referenced by set_join_column_names(), and set_relation_column_names().
◆ expand_colnames_array_to()
|
static |
Definition at line 4965 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 8574 of file ruleutils.c.
8575{
8576 /* Initialize output parameter to prevent compiler warnings */
8577 *column_p = 0;
8578
8579 /*
8580 * If it's a PARAM_EXEC parameter, search the current plan node as well as
8581 * ancestor nodes looking for a subplan or initplan that emits the value
8582 * for the Param. It could appear in the setParams of an initplan or
8583 * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
8584 */
8586 {
8587 SubPlan *result;
8590
8592
8593 /* First check the innermost plan node's initplans */
8595 if (result)
8596 return result;
8597
8598 /*
8599 * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
8600 * which can be referenced by Params elsewhere in the targetlist.
8601 * (Such Params should always be in the same targetlist, so there's no
8602 * need to do this work at upper plan nodes.)
8603 */
8605 {
8607 {
8609
8611 {
8612 foreach_int(paramid, subplan->setParam)
8613 {
8615 {
8616 /* Found a match, so return it. */
8618 return subplan;
8619 }
8620 }
8621 }
8622 }
8623 }
8624
8625 /* No luck, so check the ancestor nodes */
8627 {
8629
8630 /*
8631 * If ancestor is a SubPlan, check the paramIds it provides.
8632 */
8634 {
8636
8638 {
8640 {
8641 /* Found a match, so return it. */
8643 return subplan;
8644 }
8645 }
8646
8647 /* SubPlan isn't a kind of Plan, so skip the rest */
8648 continue;
8649 }
8650
8651 /*
8652 * Otherwise, it's some kind of Plan node, so check its initplans.
8653 */
8655 column_p);
8656 if (result)
8657 return result;
8658
8659 /* No luck, crawl up to next ancestor */
8660 }
8661 }
8662
8663 /* No generator found */
8665}
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 8671 of file ruleutils.c.
8672{
8674 {
8675 foreach_int(paramid, subplan->setParam)
8676 {
8678 {
8679 /* Found a match, so return it. */
8681 return subplan;
8682 }
8683 }
8684 }
8686}
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 8460 of file ruleutils.c.
8462{
8463 /* Initialize output parameters to prevent compiler warnings */
8466
8467 /*
8468 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
8469 * SubPlan argument. This will necessarily be in some ancestor of the
8470 * current expression's Plan node.
8471 */
8473 {
8477
8480
8482 {
8485
8486 /*
8487 * NestLoops transmit params to their inner child only.
8488 */
8491 {
8493
8495 {
8497
8499 {
8500 /* Found a match, so return it */
8504 }
8505 }
8506 }
8507
8508 /*
8509 * If ancestor is a SubPlan, check the arguments it provides.
8510 */
8512 {
8516
8518 {
8521
8523 {
8524 /*
8525 * Found a match, so return it. But, since Vars in
8526 * the arg are to be evaluated in the surrounding
8527 * context, we have to point to the next ancestor item
8528 * that is *not* a SubPlan.
8529 */
8531
8534 {
8536
8538 {
8542 }
8543 }
8545 }
8546 }
8547
8548 /* SubPlan isn't a kind of Plan, so skip the rest */
8549 continue;
8550 }
8551
8552 /*
8553 * We need not consider the ancestor's initPlan list, since
8554 * initplans never have any parParams.
8555 */
8556
8557 /* No luck, crawl up to next ancestor */
8559 }
8560 }
8561
8562 /* No referent found */
8564}
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 5236 of file ruleutils.c.
References elog, ERROR, fb(), IsA, and lfirst.
Referenced by set_deparse_plan().
◆ flatten_reloptions()
Definition at line 13676 of file ruleutils.c.
13677{
13679 HeapTuple tuple;
13680 Datum reloptions;
13681 bool isnull;
13682
13686
13688 Anum_pg_class_reloptions, &isnull);
13689 if (!isnull)
13690 {
13692
13695
13696 result = buf.data;
13697 }
13698
13699 ReleaseSysCache(tuple);
13700
13701 return result;
13702}
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 13576 of file ruleutils.c.
13577{
13578 HeapTuple tp;
13580 char *collname;
13581 char *nspname;
13582 char *result;
13583
13589
13592 else
13593 nspname = NULL;
13594
13595 result = quote_qualified_identifier(nspname, collname);
13596
13597 ReleaseSysCache(tp);
13598
13599 return result;
13600}
References CollationIsVisible(), collid, elog, ERROR, fb(), 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 13288 of file ruleutils.c.
13291{
13292 char *result;
13297 char *nspname;
13307
13313
13314 /*
13315 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
13316 * qualification of some function names within GROUP BY.
13317 */
13318 if (inGroupBy)
13319 {
13322 }
13323
13324 /*
13325 * Determine whether VARIADIC should be printed. We must do this first
13326 * since it affects the lookup rules in func_get_detail().
13327 *
13328 * We always print VARIADIC if the function has a merged variadic-array
13329 * argument. Note that this is always the case for functions taking a
13330 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
13331 * and printed the array elements as separate arguments, the call could
13332 * match a newer non-VARIADIC function.
13333 */
13335 {
13336 /* Parser should not have set funcvariadic unless fn is variadic */
13340 }
13341 else
13342 {
13345 }
13346
13347 /*
13348 * The idea here is to schema-qualify only if the parser would fail to
13349 * resolve the correct function given the unqualified func name with the
13350 * specified argtypes and VARIADIC flag. But if we already decided to
13351 * force qualification, then we can skip the lookup and pretend we didn't
13352 * find it.
13353 */
13356 NIL, argnames, nargs, argtypes,
13358 &fgc_flags,
13362 else
13363 {
13366 }
13367
13371 p_funcid == funcid)
13372 nspname = NULL;
13373 else
13375
13377
13379
13380 return result;
13381}
References Assert, elog, ERROR, fb(), 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 12930 of file ruleutils.c.
12931{
12933
12936
12938}
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 13472 of file ruleutils.c.
13476{
13479 char *oprname;
13480 char *nspname;
13481
13488
13490
13499
13501}
References add_cast_to(), appendStringInfo(), appendStringInfoString(), Assert, buf, elog, ERROR, fb(), 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 13395 of file ruleutils.c.
13396{
13400 char *oprname;
13401 char *nspname;
13403
13405
13411
13412 /*
13413 * The idea here is to schema-qualify only if the parser would fail to
13414 * resolve the correct operator given the unqualified op name with the
13415 * specified argtypes.
13416 */
13418 {
13419 case 'b':
13421 true, -1);
13422 break;
13423 case 'l':
13425 true, -1);
13426 break;
13427 default:
13430 break;
13431 }
13432
13434 nspname = NULL;
13435 else
13436 {
13439 }
13440
13442
13443 if (nspname)
13445
13448
13450
13452}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, elog, ERROR, fb(), 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 13244 of file ruleutils.c.
13245{
13246 HeapTuple tp;
13249 char *nspname;
13250 char *result;
13251
13257
13259 if (!nspname)
13261 reltup->relnamespace);
13262
13264
13265 ReleaseSysCache(tp);
13266
13267 return result;
13268}
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 13543 of file ruleutils.c.
13544{
13545 HeapTuple tp;
13548 char *nspname;
13549 char *result;
13550
13556
13558 if (!nspname)
13560 typtup->typnamespace);
13561
13563
13564 ReleaseSysCache(tp);
13565
13566 return result;
13567}
References elog, ERROR, fb(), 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 13184 of file ruleutils.c.
13185{
13186 HeapTuple tp;
13191 char *nspname;
13192 char *result;
13193
13199
13200 /* Check for conflicting CTE name */
13203 {
13206
13208 {
13210
13212 {
13214 break;
13215 }
13216 }
13218 break;
13219 }
13220
13221 /* Otherwise, qualify the name if not visible in search path */
13224
13227 else
13228 nspname = NULL;
13229
13231
13232 ReleaseSysCache(tp);
13233
13234 return result;
13235}
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 11037 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 10899 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 10911 of file ruleutils.c.
10914{
10917 int nargs;
10919
10920 /*
10921 * For a combining aggregate, we look up and deparse the corresponding
10922 * partial aggregate instead. This is necessary because our input
10923 * argument list has been replaced; the new argument list always has just
10924 * one element, which will point to a partial Aggref that supplies us with
10925 * transition states to combine.
10926 */
10928 {
10930
10935 return;
10936 }
10937
10938 /*
10939 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
10940 * to avoid printing this when recursing from the code just above.
10941 */
10944
10945 /* Extract the argument types as seen by the parser */
10946 nargs = get_aggregate_argtypes(aggref, argtypes);
10947
10950 argtypes, aggref->aggvariadic,
10951 &use_variadic,
10952 context->inGroupBy);
10953
10954 /* Print the aggregate name, schema-qualified if needed */
10957
10959 {
10960 /*
10961 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
10962 * worry about inserting VARIADIC. So we can just dump the direct
10963 * args as-is.
10964 */
10965 Assert(!aggref->aggvariadic);
10970 }
10971 else
10972 {
10973 /* aggstar can be set only in zero-argument aggregates */
10974 if (aggref->aggstar)
10976 else
10977 {
10978 ListCell *l;
10980
10981 i = 0;
10983 {
10986
10989 continue;
10991 {
10993 {
10994 /*
10995 * the ABSENT ON NULL and WITH UNIQUE args are printed
10996 * separately, so ignore them here
10997 */
10999 break;
11000
11002 }
11003 else
11005 }
11009 }
11010 }
11011
11013 {
11016 }
11017 }
11018
11021
11023 {
11026 }
11027
11029}
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 6111 of file ruleutils.c.
6112{
6116 ListCell *l;
6117
6119 {
6122 }
6123
6124 /*
6125 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6126 * VALUES part. This reverses what transformValuesClause() did at parse
6127 * time.
6128 */
6131 {
6133 return;
6134 }
6135
6136 /*
6137 * Build up the query string - first we say SELECT
6138 */
6139 if (query->isReturn)
6141 else
6143
6144 /* Add the DISTINCT clause if given */
6146 {
6147 if (query->hasDistinctOn)
6148 {
6152 {
6154
6157 false, context);
6159 }
6161 }
6162 else
6164 }
6165
6166 /* Then we tell what to select (the targetlist) */
6168
6169 /* Add the FROM clause if needed */
6171
6172 /* Add the WHERE clause if given */
6174 {
6178 }
6179
6180 /* Add the GROUP BY clause if given */
6182 {
6184
6189
6192
6196 {
6199 {
6201
6204 false, context);
6206 }
6207 }
6208 else
6209 {
6212 {
6214
6218 }
6219 }
6220
6222 }
6223
6224 /* Add the HAVING clause if given */
6226 {
6230 }
6231
6232 /* Add the WINDOW clause if needed */
6234 get_rule_windowclause(query, context);
6235}
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 11434 of file ruleutils.c.
11437{
11439
11440 /*
11441 * Since parse_coerce.c doesn't immediately collapse application of
11442 * length-coercion functions to constants, what we'll typically see in
11443 * such cases is a Const with typmod -1 and a length-coercion function
11444 * right above it. Avoid generating redundant output. However, beware of
11445 * suppressing casts when the user actually wrote something like
11446 * 'foo'::text::char(3).
11447 *
11448 * Note: it might seem that we are missing the possibility of needing to
11449 * print a COLLATE clause for such a Const. However, a Const could only
11450 * have nondefault collation in a post-constant-folding tree, in which the
11451 * length coercion would have been folded too. See also the special
11452 * handling of CollateExpr in coerce_to_target_type(): any collation
11453 * marking will be above the coercion node, not below it.
11454 */
11458 {
11459 /* Show the constant without normal ::typename decoration */
11461 }
11462 else
11463 {
11469 }
11470
11471 /*
11472 * Never emit resulttype(arg) functional notation. A pg_proc entry could
11473 * take precedence, and a resulttype in pg_temp would require schema
11474 * qualification that format_type_with_typemod() would usually omit. We've
11475 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
11476 * would work fine.
11477 */
11480}
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 12757 of file ruleutils.c.
12758{
12761 bool first = true;
12762
12763 /* Don't print aliases if not needed */
12765 return;
12766
12768 {
12770
12771 if (first)
12772 {
12774 first = false;
12775 }
12776 else
12779 }
12780 if (!first)
12782}
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 11628 of file ruleutils.c.
11629{
11631
11633 {
11635
11636 if (constval->constcollid != typcollation)
11637 {
11639 generate_collation_name(constval->constcollid));
11640 }
11641 }
11642}
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 11498 of file ruleutils.c.
11499{
11501 Oid typoutput;
11505
11506 if (constval->constisnull)
11507 {
11508 /*
11509 * Always label the type of a NULL constant to prevent misdecisions
11510 * about type when reparsing.
11511 */
11514 {
11517 constval->consttypmod));
11518 get_const_collation(constval, context);
11519 }
11520 return;
11521 }
11522
11524 &typoutput, &typIsVarlena);
11525
11527
11529 {
11531
11532 /*
11533 * INT4 can be printed without any decoration, unless it is
11534 * negative; in that case print it as '-nnn'::integer to ensure
11535 * that the output will re-parse as a constant, not as a constant
11536 * plus operator. In most cases we could get away with printing
11537 * (-nnn) instead, because of the way that gram.y handles negative
11538 * literals; but that doesn't work for INT_MIN, and it doesn't
11539 * seem that much prettier anyway.
11540 */
11543 else
11544 {
11547 }
11548 break;
11549
11551
11552 /*
11553 * NUMERIC can be printed without quotes if it looks like a float
11554 * constant (not an integer, and not Infinity or NaN) and doesn't
11555 * have a leading sign (for the same reason as for INT4).
11556 */
11559 {
11561 }
11562 else
11563 {
11566 }
11567 break;
11568
11572 else
11574 break;
11575
11576 default:
11578 break;
11579 }
11580
11582
11584 return;
11585
11586 /*
11587 * For showtype == 0, append ::typename unless the constant will be
11588 * implicitly typed as the right type when it is read in.
11589 *
11590 * XXX this code has to be kept in sync with the behavior of the parser,
11591 * especially make_const.
11592 */
11594 {
11597 /* These types can be left unlabeled */
11599 break;
11601 /* We determined above whether a label is needed */
11602 break;
11604
11605 /*
11606 * Float-looking constants will be typed as numeric, which we
11607 * checked above; but if there's a nondefault typmod we need to
11608 * show it.
11609 */
11610 needlabel |= (constval->consttypmod >= 0);
11611 break;
11612 default:
11614 break;
11615 }
11619 constval->consttypmod));
11620
11621 get_const_collation(constval, context);
11622}
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 7360 of file ruleutils.c.
7361{
7364
7365 /* Insert the WITH clause if given */
7366 get_with_clause(query, context);
7367
7368 /*
7369 * Start the query with DELETE FROM relname
7370 */
7374 {
7377 }
7381
7382 /* Print the relation alias, if needed */
7384
7385 /* Add the USING clause if given */
7387
7388 /* Add a WHERE clause if given */
7390 {
7394 }
7395
7396 /* Add RETURNING if present */
7398 get_returning_clause(query, context);
7399}
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 12301 of file ruleutils.c.
12302{
12304 bool first = true;
12305 ListCell *l;
12306
12307 /*
12308 * We use the query's jointree as a guide to what to print. However, we
12309 * must ignore auto-added RTEs that are marked not inFromCl. (These can
12310 * only appear at the top level of the jointree, so it's sufficient to
12311 * check here.) This check also ensures we ignore the rule pseudo-RTEs
12312 * for NEW and OLD.
12313 */
12315 {
12317
12319 {
12322
12324 continue;
12325 }
12326
12327 if (first)
12328 {
12329 appendContextKeyword(context, prefix,
12331 first = false;
12332
12333 get_from_clause_item(jtnode, query, context);
12334 }
12335 else
12336 {
12338
12340
12341 /*
12342 * Put the new FROM item's text into itembuf so we can decide
12343 * after we've got it whether or not it needs to go on a new line.
12344 */
12347
12348 get_from_clause_item(jtnode, query, context);
12349
12350 /* Restore context's output buffer */
12352
12353 /* Consider line-wrapping if enabled */
12355 {
12356 /* Does the new item start with a new line? */
12358 {
12359 /* If so, we shouldn't add anything */
12360 /* instead, remove any trailing spaces currently in buf */
12362 }
12363 else
12364 {
12366
12367 /* Locate the start of the current line in the buffer */
12371 else
12372 trailing_nl++;
12373
12374 /*
12375 * Add a newline, plus some indentation, if the new item
12376 * would cause an overflow.
12377 */
12380 PRETTYINDENT_STD,
12381 PRETTYINDENT_VAR);
12382 }
12383 }
12384
12385 /* Add the new item */
12387
12388 /* clean up */
12390 }
12391 }
12392}
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 12797 of file ruleutils.c.
12800{
12802 ListCell *l1;
12803 ListCell *l2;
12804 ListCell *l3;
12805 ListCell *l4;
12807
12809
12810 i = 0;
12811 forfour(l1, rtfunc->funccoltypes,
12812 l2, rtfunc->funccoltypmods,
12813 l3, rtfunc->funccolcollations,
12814 l4, rtfunc->funccolnames)
12815 {
12820
12823 else
12825
12827
12836 generate_collation_name(attcollation));
12837
12838 i++;
12839 }
12840
12842}
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 12395 of file ruleutils.c.
12396{
12399
12401 {
12406
12409
12410 /* Print the FROM item proper */
12412 {
12414 /* Normal relation RTE */
12418 context->namespaces));
12419 break;
12421 /* Subquery RTE */
12424 true,
12426 context->indentLevel);
12428 break;
12430 /* Function RTE */
12432
12433 /*
12434 * Omit ROWS FROM() syntax for just one function, unless it
12435 * has both a coldeflist and WITH ORDINALITY. If it has both,
12436 * we must use ROWS FROM() syntax to avoid ambiguity about
12437 * whether the coldeflist includes the ordinality column.
12438 */
12441 {
12443 /* we'll print the coldeflist below, if it has one */
12444 }
12445 else
12446 {
12449
12450 /*
12451 * If all the function calls in the list are to unnest,
12452 * and none need a coldeflist, then collapse the list back
12453 * down to UNNEST(args). (If we had more than one
12454 * built-in unnest function, this would get more
12455 * difficult.)
12456 *
12457 * XXX This is pretty ugly, since it makes not-terribly-
12458 * future-proof assumptions about what the parser would do
12459 * with the output; but the alternative is to emit our
12460 * nonstandard ROWS FROM() notation for what might have
12461 * been a perfectly spec-compliant multi-argument
12462 * UNNEST().
12463 */
12466 {
12468
12471 rtfunc->funccolnames != NIL)
12472 {
12474 break;
12475 }
12476 }
12477
12479 {
12481
12483 {
12486
12488 }
12489
12493 }
12494 else
12495 {
12497
12500 {
12502
12507 {
12508 /* Reconstruct the column definition list */
12510 get_from_clause_coldeflist(rtfunc,
12511 NULL,
12512 context);
12513 }
12514 funcno++;
12515 }
12517 }
12518 /* prevent printing duplicate coldeflist below */
12520 }
12523 break;
12526 break;
12528 /* Values list RTE */
12532 break;
12535 break;
12536 default:
12538 break;
12539 }
12540
12541 /* Print the relation alias, if needed */
12543
12544 /* Print the column definitions or aliases, if needed */
12546 {
12547 /* Reconstruct the columndef list, which is also the aliases */
12549 }
12550 else
12551 {
12552 /* Else print column aliases as needed */
12554 }
12555
12556 /* Tablesample clause must go after any alias */
12559 }
12561 {
12565
12569
12572
12574
12576 {
12580 -PRETTYINDENT_STD,
12581 PRETTYINDENT_STD,
12582 PRETTYINDENT_JOIN);
12583 else
12585 -PRETTYINDENT_STD,
12586 PRETTYINDENT_STD,
12587 PRETTYINDENT_JOIN);
12588 break;
12591 -PRETTYINDENT_STD,
12592 PRETTYINDENT_STD,
12593 PRETTYINDENT_JOIN);
12594 break;
12597 -PRETTYINDENT_STD,
12598 PRETTYINDENT_STD,
12599 PRETTYINDENT_JOIN);
12600 break;
12603 -PRETTYINDENT_STD,
12604 PRETTYINDENT_STD,
12605 PRETTYINDENT_JOIN);
12606 break;
12607 default:
12610 }
12611
12617
12619 {
12621 bool first = true;
12622
12624 /* Use the assigned names, not what's in usingClause */
12626 {
12628
12629 if (first)
12630 first = false;
12631 else
12634 }
12636
12640 }
12642 {
12649 }
12651 {
12652 /* If we didn't say CROSS JOIN above, we must provide an ON */
12654 }
12655
12658
12659 /* Yes, it's correct to put alias after the right paren ... */
12661 {
12662 /*
12663 * Note that it's correct to emit an alias clause if and only if
12664 * there was one originally. Otherwise we'd be converting a named
12665 * join to unnamed or vice versa, which creates semantic
12666 * subtleties we don't want. However, we might print a different
12667 * alias name than was there originally.
12668 */
12671 context)));
12673 }
12674 }
12675 else
12678}
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 10803 of file ruleutils.c.
10805{
10809 int nargs;
10810 List *argnames;
10812 ListCell *l;
10813
10814 /*
10815 * If the function call came from an implicit coercion, then just show the
10816 * first argument --- unless caller wants to see implicit coercions.
10817 */
10819 {
10822 return;
10823 }
10824
10825 /*
10826 * If the function call came from a cast, then show the first argument
10827 * plus an explicit cast operation.
10828 */
10830 expr->funcformat == COERCE_IMPLICIT_CAST)
10831 {
10833 Oid rettype = expr->funcresulttype;
10835
10836 /* Get the typmod if this is a length-coercion function */
10838
10840 rettype, coercedTypmod,
10841 (Node *) expr);
10842
10843 return;
10844 }
10845
10846 /*
10847 * If the function was called using one of the SQL spec's random special
10848 * syntaxes, try to reproduce that. If we don't recognize the function,
10849 * fall through.
10850 */
10852 {
10854 return;
10855 }
10856
10857 /*
10858 * Normal function: display as proname(args). First we need to extract
10859 * the argument datatypes.
10860 */
10865 nargs = 0;
10866 argnames = NIL;
10868 {
10870
10874 nargs++;
10875 }
10876
10879 argnames, argtypes,
10880 expr->funcvariadic,
10881 &use_variadic,
10882 context->inGroupBy));
10883 nargs = 0;
10885 {
10886 if (nargs++ > 0)
10891 }
10893}
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 11182 of file ruleutils.c.
11183{
11186
11188 {
11195 /* AT TIME ZONE ... note reversed argument order */
11198 (Node *) expr);
11201 (Node *) expr);
11203 return true;
11204
11208 /* AT LOCAL */
11211 (Node *) expr);
11213 return true;
11214
11228 /* (x1, x2) OVERLAPS (y1, y2) */
11238 return true;
11239
11246 /* EXTRACT (x FROM y) */
11248 {
11250
11253 !con->constisnull);
11255 }
11259 return true;
11260
11262 /* IS xxx NORMALIZED */
11265 (Node *) expr);
11268 {
11270
11273 !con->constisnull);
11275 TextDatumGetCString(con->constvalue));
11276 }
11278 return true;
11279
11281 /* COLLATION FOR */
11285 return true;
11286
11288 /* NORMALIZE() */
11292 {
11294
11297 !con->constisnull);
11299 TextDatumGetCString(con->constvalue));
11300 }
11302 return true;
11303
11310 /* OVERLAY() */
11318 {
11321 }
11323 return true;
11324
11328 /* POSITION() ... extra parens since args are b_expr not a_expr */
11334 return true;
11335
11342 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
11348 {
11351 }
11353 return true;
11354
11356 /* SUBSTRING SIMILAR/ESCAPE */
11364 return true;
11365
11369 /* TRIM() */
11372 {
11375 }
11379 return true;
11380
11384 /* TRIM() */
11387 {
11390 }
11394 return true;
11395
11399 /* TRIM() */
11402 {
11405 }
11409 return true;
11410
11413 return true;
11414
11416 /* XMLEXISTS ... extra parens because args are c_expr */
11422 return true;
11423 }
11424 return false;
11425}
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 6944 of file ruleutils.c.
6945{
6951 ListCell *l;
6953
6954 /* Insert the WITH clause if given */
6955 get_with_clause(query, context);
6956
6957 /*
6958 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
6959 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
6960 */
6962 {
6964
6966 {
6970 }
6971
6973 {
6977 }
6978 }
6981
6982 /*
6983 * Start the query with INSERT INTO relname
6984 */
6987
6989 {
6992 }
6995
6996 /* Print the relation alias, if needed; INSERT requires explicit AS */
6998
6999 /* always want a space here */
7001
7002 /*
7003 * Add the insert-column-names list. Any indirection decoration needed on
7004 * the column names can be inferred from the top targetlist.
7005 */
7011 {
7013
7015 continue; /* ignore junk entries */
7016
7019
7020 /*
7021 * Put out name of target column; look in the catalogs, not at
7022 * tle->resname, since resname will fail to track RENAME.
7023 */
7026 tle->resno,
7027 false)));
7028
7029 /*
7030 * Print any indirection needed (subfields or subscripts), and strip
7031 * off the top-level nodes representing the indirection assignments.
7032 * Add the stripped expressions to strippedexprs. (If it's a
7033 * single-VALUES statement, the stripped expressions are the VALUES to
7034 * print below. Otherwise they're just Vars and not really
7035 * interesting.)
7036 */
7039 context));
7040 }
7043
7044 if (query->override)
7045 {
7050 }
7051
7053 {
7054 /* Add the SELECT */
7056 false,
7058 context->indentLevel);
7059 }
7061 {
7062 /* Add the multi-VALUES expression lists */
7064 }
7066 {
7067 /* Add the single-VALUES expression list */
7072 }
7073 else
7074 {
7075 /* No expressions, so it must be DEFAULT VALUES */
7077 }
7078
7079 /* Add ON CONFLICT if present */
7081 {
7083
7085
7087 {
7088 /* Add the single-VALUES expression list */
7092
7093 /* Add a WHERE clause (for partial indexes) if given */
7095 {
7097
7098 /*
7099 * Force non-prefixing of Vars, since parser assumes that they
7100 * belong to target relation. WHERE clause does not use
7101 * InferenceElem, so this is separately required.
7102 */
7105
7109
7111 }
7112 }
7114 {
7116
7117 if (!constraint)
7119 confl->constraint);
7121 quote_identifier(constraint));
7122 }
7123
7125 {
7127 }
7128 else
7129 {
7131 /* Deparse targetlist */
7133 context, rte);
7134
7135 /* Add a WHERE clause if given */
7137 {
7141 }
7142 }
7143 }
7144
7145 /* Add RETURNING if present */
7147 get_returning_clause(query, context);
7148}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, elog, ERROR, fb(), generate_relation_name(), get_attname(), get_constraint_name(), 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(), lfirst, deparse_context::namespaces, NIL, OidIsValid, Query::onConflict, ONCONFLICT_NOTHING, 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 11801 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 9186 of file ruleutils.c.
9188{
9189 /*
9190 * The order of array elements must correspond to the order of
9191 * JsonBehaviorType members.
9192 */
9194 {
9195 " NULL",
9196 " ERROR",
9197 " EMPTY",
9198 " TRUE",
9199 " FALSE",
9200 " UNKNOWN",
9201 " EMPTY ARRAY",
9202 " EMPTY OBJECT",
9203 " DEFAULT "
9204 };
9205
9208
9210
9213
9215}
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 11705 of file ruleutils.c.
11707{
11713
11715 {
11717 return;
11718 }
11720 {
11722 return;
11723 }
11724
11726 {
11729 break;
11732 break;
11735 break;
11738 break;
11741 break;
11742 default:
11744 }
11745
11747
11750 {
11753 {
11755
11758 }
11759
11761 }
11762
11765}
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 11771 of file ruleutils.c.
11772{
11774 {
11778 }
11779 else
11780 {
11784 }
11785
11788
11789 /*
11790 * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
11791 * support one.
11792 */
11795}
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 9224 of file ruleutils.c.
9226{
9228 {
9233 /* The default */
9236
9239 /* The default */
9240 else
9242 }
9243
9246
9249}
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 11660 of file ruleutils.c.
11661{
11663 return;
11664
11667 " FORMAT JSONB" : " FORMAT JSON");
11668
11670 {
11672
11673 encoding =
11676
11678 }
11679}
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 11648 of file ruleutils.c.
11649{
11652 else
11654}
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 11685 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 12213 of file ruleutils.c.
12214{
12218
12220
12223
12225
12227
12229
12231
12233
12235 {
12237 *lc2;
12239
12242
12245
12248 {
12252
12254
12258 );
12259 }
12260
12263 }
12264
12266 showimplicit);
12267
12270
12273
12275}
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 12107 of file ruleutils.c.
12110{
12116 int colnum = 0;
12117
12120
12123
12125 lc_coltype, tf->coltypes,
12126 lc_coltypmod, tf->coltypmods,
12127 lc_colvalexpr, tf->colvalexprs)
12128 {
12130 JsonExpr *colexpr;
12131 Oid typid;
12132 int32 typmod;
12133 bool ordinality;
12135
12139
12140 /* Skip columns that don't belong to this scan. */
12142 {
12143 colnum++;
12144 continue;
12145 }
12147 break;
12148
12151
12152 colnum++;
12153
12154 ordinality = !colexpr;
12155
12157
12159 ordinality ? "FOR ORDINALITY" :
12160 format_type_with_typemod(typid, typmod));
12161 if (ordinality)
12162 continue;
12163
12164 /*
12165 * Set default_behavior to guide get_json_expr_options() on whether to
12166 * emit the ON ERROR / EMPTY clauses.
12167 */
12169 {
12172 }
12173 else
12174 {
12176 {
12179
12181
12185 " FORMAT JSONB" : " FORMAT JSON");
12186 }
12187
12189 }
12190
12192
12194
12196 }
12197
12200 scan->colMin >= 0);
12201
12204
12206}
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 12075 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_merge_query_def()
|
static |
Definition at line 7407 of file ruleutils.c.
7408{
7413
7414 /* Insert the WITH clause if given */
7415 get_with_clause(query, context);
7416
7417 /*
7418 * Start the query with MERGE INTO relname
7419 */
7423 {
7426 }
7430
7431 /* Print the relation alias, if needed */
7433
7434 /* Print the source relation and join clause */
7439
7440 /*
7441 * Test for any NOT MATCHED BY SOURCE actions. If there are none, then
7442 * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
7443 * SQL standard. Otherwise, we have a non-SQL-standard query, so output
7444 * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
7445 * more explicit.
7446 */
7449 {
7451
7453 {
7455 break;
7456 }
7457 }
7458
7459 /* Print each merge action */
7461 {
7463
7467 {
7470 break;
7473 break;
7477 else
7479 break;
7480 default:
7483 }
7484
7486 {
7490 }
7493
7495 {
7496 /* This generally matches get_insert_query_def() */
7500
7502
7506 {
7508
7510
7513
7516 tle->resno,
7517 false)));
7520 context));
7521 }
7524
7526 {
7531 }
7532
7534 {
7539 }
7540 else
7542 }
7544 {
7547 context, rte);
7548 }
7553 }
7554
7555 /* Add RETURNING if present */
7557 get_returning_clause(query, context);
7558}
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 8022 of file ruleutils.c.
8024{
8029 int varno;
8030 AttrNumber varattno;
8032 Node *expr;
8033
8034 /*
8035 * If it's a RowExpr that was expanded from a whole-row Var, use the
8036 * column names attached to it. (We could let get_expr_result_tupdesc()
8037 * handle this, but it's much cheaper to just pull out the name we need.)
8038 */
8040 {
8042
8045 }
8046
8047 /*
8048 * If it's a Param of type RECORD, try to find what the Param refers to.
8049 */
8051 {
8054
8056 if (expr)
8057 {
8058 /* Found a match, so recurse to decipher the field name */
8060 const char *result;
8061
8064 0, context);
8066 return result;
8067 }
8068 }
8069
8070 /*
8071 * If it's a Var of type RECORD, we have to find what the Var refers to;
8072 * if not, we can use get_expr_result_tupdesc().
8073 */
8075 var->vartype != RECORDOID)
8076 {
8078 /* Got the tupdesc, so we can extract the field name */
8081 }
8082
8083 /* Find appropriate nesting depth */
8087 var->varlevelsup, levelsup);
8089 netlevelsup);
8090
8091 /*
8092 * If we have a syntactic referent for the Var, and we're working from a
8093 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8094 * on the semantic referent. (See comments in get_variable().)
8095 */
8097 {
8098 varno = var->varnosyn;
8099 varattno = var->varattnosyn;
8100 }
8101 else
8102 {
8103 varno = var->varno;
8104 varattno = var->varattno;
8105 }
8106
8107 /*
8108 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8109 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8110 * down into the subplans, or INDEX_VAR, which is resolved similarly.
8111 *
8112 * Note: unlike get_variable and resolve_special_varno, we need not worry
8113 * about inheritance mapping: a child Var should have the same datatype as
8114 * its parent, and here we're really only interested in the Var's type.
8115 */
8117 {
8119 attnum = varattno;
8120 }
8122 {
8125 const char *result;
8126
8130
8133
8135 levelsup, context);
8136
8138 return result;
8139 }
8141 {
8144 const char *result;
8145
8149
8152
8154 levelsup, context);
8155
8157 return result;
8158 }
8160 {
8162 const char *result;
8163
8167
8169
8171 levelsup, context);
8172
8173 return result;
8174 }
8175 else
8176 {
8179 }
8180
8182 {
8183 /* Var is whole-row reference to RTE, so select the right field */
8185 }
8186
8187 /*
8188 * This part has essentially the same logic as the parser's
8189 * expandRecordVariable() function, but we are dealing with a different
8190 * representation of the input context, and we only need one field name
8191 * not a TupleDesc. Also, we need special cases for finding subquery and
8192 * CTE subplans when deparsing Plan trees.
8193 */
8195
8197 {
8202
8203 /*
8204 * This case should not occur: a column of a table, values list,
8205 * or ENR shouldn't have type RECORD. Fall through and fail (most
8206 * likely) at the bottom.
8207 */
8208 break;
8210 /* Subselect-in-FROM: examine sub-select's output expr */
8211 {
8213 {
8215 attnum);
8216
8222 {
8223 /*
8224 * Recurse into the sub-select to see what its Var
8225 * refers to. We have to build an additional level of
8226 * namespace to keep in step with varlevelsup in the
8227 * subselect; furthermore, the subquery RTE might be
8228 * from an outer query level, in which case the
8229 * namespace for the subselect must have that outer
8230 * level as parent namespace.
8231 */
8235 const char *result;
8236
8238 netlevelsup);
8239
8241 parent_namespaces);
8242
8244
8246 0, context);
8247
8249
8250 return result;
8251 }
8252 /* else fall through to inspect the expression */
8253 }
8254 else
8255 {
8256 /*
8257 * We're deparsing a Plan tree so we don't have complete
8258 * RTE entries (in particular, rte->subquery is NULL). But
8259 * the only place we'd normally see a Var directly
8260 * referencing a SUBQUERY RTE is in a SubqueryScan plan
8261 * node, and we can look into the child plan's tlist
8262 * instead. An exception occurs if the subquery was
8263 * proven empty and optimized away: then we'd find such a
8264 * Var in a childless Result node, and there's nothing in
8265 * the plan tree that would let us figure out what it had
8266 * originally referenced. In that case, fall back on
8267 * printing "fN", analogously to the default column names
8268 * for RowExprs.
8269 */
8272 const char *result;
8273
8275 {
8277
8281 }
8283
8287 attnum);
8290
8292 levelsup, context);
8293
8295 return result;
8296 }
8297 }
8298 break;
8300 /* Join RTE --- recursively inspect the alias variable */
8306 /* we intentionally don't strip implicit coercions here */
8309 var->varlevelsup + levelsup,
8310 context);
8311 /* else fall through to inspect the expression */
8312 break;
8315
8316 /*
8317 * We couldn't get here unless a function is declared with one of
8318 * its result columns as RECORD, which is not allowed.
8319 */
8320 break;
8322 /* CTE reference: examine subquery's output expr */
8323 {
8325 Index ctelevelsup;
8327
8328 /*
8329 * Try to find the referenced CTE using the namespace stack.
8330 */
8334 else
8335 {
8337
8341 {
8344 break;
8345 }
8346 }
8348 {
8351 attnum);
8352
8358 {
8359 /*
8360 * Recurse into the CTE to see what its Var refers to.
8361 * We have to build an additional level of namespace
8362 * to keep in step with varlevelsup in the CTE;
8363 * furthermore it could be an outer CTE (compare
8364 * SUBQUERY case above).
8365 */
8369 const char *result;
8370
8372 ctelevelsup);
8373
8375 parent_namespaces);
8376
8378
8380 0, context);
8381
8383
8384 return result;
8385 }
8386 /* else fall through to inspect the expression */
8387 }
8388 else
8389 {
8390 /*
8391 * We're deparsing a Plan tree so we don't have a CTE
8392 * list. But the only places we'd normally see a Var
8393 * directly referencing a CTE RTE are in CteScan or
8394 * WorkTableScan plan nodes. For those cases,
8395 * set_deparse_plan arranged for dpns->inner_plan to be
8396 * the plan node that emits the CTE or RecursiveUnion
8397 * result, and we can look at its tlist instead. As
8398 * above, this can fail if the CTE has been proven empty,
8399 * in which case fall back to "fN".
8400 */
8403 const char *result;
8404
8406 {
8408
8412 }
8415
8419 attnum);
8422
8424 levelsup, context);
8425
8427 return result;
8428 }
8429 }
8430 break;
8432
8433 /*
8434 * We couldn't get here: any Vars that reference the RTE_GROUP RTE
8435 * should have been replaced with the underlying grouping
8436 * expressions.
8437 */
8438 break;
8439 }
8440
8441 /*
8442 * We now have an expression we can't expand any more, so see if
8443 * get_expr_result_tupdesc() can do anything with it.
8444 */
8446 /* Got the tupdesc, so we can extract the field name */
8449}
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 12892 of file ruleutils.c.
12894{
12898 char *nspname;
12899
12904
12907 {
12908 /* Okay, we need the opclass name. Do we need to qualify it? */
12912 else
12913 {
12916 quote_identifier(nspname),
12918 }
12919 }
12921}
References appendStringInfo(), buf, elog, ERROR, fb(), 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 10763 of file ruleutils.c.
10764{
10768
10772 {
10773 /* binary operator */
10776
10779 generate_operator_name(opno,
10783 }
10784 else
10785 {
10786 /* prefix operator */
10788
10790 generate_operator_name(opno,
10791 InvalidOid,
10794 }
10797}
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 8692 of file ruleutils.c.
8693{
8694 Node *expr;
8697 SubPlan *subplan;
8699
8700 /*
8701 * If it's a PARAM_EXEC parameter, try to locate the expression from which
8702 * the parameter was computed. This stanza handles only cases in which
8703 * the Param represents an input to the subplan we are currently in.
8704 */
8706 if (expr)
8707 {
8708 /* Found a match, so print it */
8712
8713 /* Switch attention to the ancestor plan node */
8715
8716 /*
8717 * Force prefixing of Vars, since they won't belong to the relation
8718 * being scanned in the original plan node.
8719 */
8722
8723 /*
8724 * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
8725 * upper-level Param, which wouldn't need extra parentheses.
8726 * Otherwise, insert parens to ensure the expression looks atomic.
8727 */
8734
8736
8739
8741
8743
8744 return;
8745 }
8746
8747 /*
8748 * Alternatively, maybe it's a subplan output, which we print as a
8749 * reference to the subplan. (We could drill down into the subplan and
8750 * print the relevant targetlist expression, but that has been deemed too
8751 * confusing since it would violate normal SQL scope rules. Also, we're
8752 * relying on this reference to show that the testexpr containing the
8753 * Param has anything to do with that subplan at all.)
8754 */
8756 if (subplan)
8757 {
8759
8762 else
8764
8767 nameprefix,
8768 subplan->plan_name, column + 1);
8769
8770 return;
8771 }
8772
8773 /*
8774 * If it's an external parameter, see if the outermost namespace provides
8775 * function argument names.
8776 */
8778 {
8781 param->paramid > 0 &&
8783 {
8785
8786 if (argname)
8787 {
8790
8791 /*
8792 * Qualify the parameter name if there are any other deparse
8793 * namespaces with range tables. This avoids qualifying in
8794 * trivial cases like "RETURN a + b", but makes it safe in all
8795 * other cases.
8796 */
8798 {
8800
8802 {
8804 break;
8805 }
8806 }
8808 {
8811 }
8812
8814 return;
8815 }
8816 }
8817 }
8818
8819 /*
8820 * Not PARAM_EXEC, or couldn't find referent: just print $N.
8821 *
8822 * It's a bug if we get here for anything except PARAM_EXTERN Params, but
8823 * in production builds printing $N seems more useful than failing.
8824 */
8826
8828}
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 5627 of file ruleutils.c.
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}
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 13709 of file ruleutils.c.
13710{
13711 deparse_context context;
13713 ListCell *cell;
13715
13719
13723 {
13724 PartitionRangeDatum *datum =
13726
13732 else
13733 {
13735
13737 }
13739 }
13741
13743}
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 13164 of file ruleutils.c.
13165{
13167
13171}
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 13621 of file ruleutils.c.
13622{
13626
13629
13631 {
13636
13637 /*
13638 * Each array element should have the form name=value. If the "=" is
13639 * missing for some reason, treat it like an empty value.
13640 */
13644 {
13647 }
13648 else
13650
13654
13655 /*
13656 * In general we need to quote the value; but to avoid unnecessary
13657 * clutter, do not quote if it is an identifier that would not need
13658 * quoting. (We could also allow numbers, but that is a bit trickier
13659 * than it looks --- for example, are leading zeroes significant? We
13660 * don't want to assume very much here about what custom reloptions
13661 * might mean.)
13662 */
13665 else
13667
13669 }
13670}
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 6380 of file ruleutils.c.
6381{
6383
6385 {
6387
6390
6391 /* Add WITH (OLD/NEW) options, if they're not the defaults */
6393 {
6395 quote_identifier(query->returningOldAlias));
6397 }
6399 {
6402 quote_identifier(query->returningNewAlias));
6403 else
6404 {
6406 quote_identifier(query->returningNewAlias));
6408 }
6409 }
6412
6413 /* Add the returning expressions themselves */
6415 }
6416}
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 5136 of file ruleutils.c.
5137{
5139
5142}
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 12686 of file ruleutils.c.
12688{
12693
12695 {
12696 /* Always print alias if user provided one */
12698 }
12700 {
12701 /* Always print alias if we need to print column aliases */
12703 }
12705 {
12706 /*
12707 * No need to print alias if it's same as relation name (this would
12708 * normally be the case, but not if set_rtable_names had to resolve a
12709 * conflict).
12710 */
12713 }
12715 {
12716 /*
12717 * For a function RTE, always print alias. This covers possible
12718 * renaming of the function and/or instability of the FigureColname
12719 * rules for things that aren't simple functions. Note we'd need to
12720 * force it anyway for the columndef list case.
12721 */
12723 }
12726 {
12727 /*
12728 * For a subquery, always print alias. This makes the output
12729 * SQL-spec-compliant, even though we allow such aliases to be omitted
12730 * on input.
12731 */
12733 }
12735 {
12736 /*
12737 * No need to print alias if it's same as CTE name (this would
12738 * normally be the case, but not if set_rtable_names had to resolve a
12739 * conflict).
12740 */
12743 }
12744
12748 quote_identifier(refname));
12749}
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 9265 of file ruleutils.c.
9267{
9269
9271 return;
9272
9273 /* Guard against excessively long or deeply-nested queries */
9274 CHECK_FOR_INTERRUPTS();
9275 check_stack_depth();
9276
9277 /*
9278 * Each level of get_rule_expr must emit an indivisible term
9279 * (parenthesized if necessary) to ensure result is reparsed into the same
9280 * expression tree. The only exception is that when the input is a List,
9281 * we emit the component items comma-separated with no surrounding
9282 * decoration; this is convenient for most callers.
9283 */
9285 {
9288 break;
9289
9292 break;
9293
9296 break;
9297
9300 break;
9301
9303 {
9305
9309 }
9310 break;
9311
9314 break;
9315
9318 break;
9319
9321 {
9324
9325 /*
9326 * If the argument is a CaseTestExpr, we must be inside a
9327 * FieldStore, ie, we are assigning to an element of an array
9328 * within a composite column. Since we already punted on
9329 * displaying the FieldStore's target information, just punt
9330 * here too, and display only the assignment source
9331 * expression.
9332 */
9334 {
9337 context, showimplicit);
9338 break;
9339 }
9340
9341 /*
9342 * Parenthesize the argument unless it's a simple Var or a
9343 * FieldSelect. (In particular, if it's another
9344 * SubscriptingRef, we *must* parenthesize to avoid
9345 * confusion.)
9346 */
9354
9355 /*
9356 * If there's a refassgnexpr, we want to print the node in the
9357 * format "container[subscripts] := refassgnexpr". This is
9358 * not legal SQL, so decompilation of INSERT or UPDATE
9359 * statements should always use processIndirection as part of
9360 * the statement-level syntax. We should only see this when
9361 * EXPLAIN tries to print the targetlist of a plan resulting
9362 * from such a statement.
9363 */
9365 {
9366 Node *refassgnexpr;
9367
9368 /*
9369 * Use processIndirection to print this node's subscripts
9370 * as well as any additional field selections or
9371 * subscripting in immediate descendants. It returns the
9372 * RHS expr that is actually being "assigned".
9373 */
9374 refassgnexpr = processIndirection(node, context);
9377 }
9378 else
9379 {
9380 /* Just an ordinary container fetch, so print subscripts */
9381 printSubscripts(sbsref, context);
9382 }
9383 }
9384 break;
9385
9388 break;
9389
9391 {
9393
9396 }
9397 break;
9398
9401 break;
9402
9404 {
9409
9417 }
9418 break;
9419
9421 {
9423
9427 }
9428 break;
9429
9431 {
9436
9446
9447 /*
9448 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
9449 * a bare sub-SELECT. Since we're here, the sub-SELECT must
9450 * be meant as a scalar sub-SELECT yielding an array value to
9451 * be used in ScalarArrayOpExpr; but the grammar will
9452 * preferentially interpret such a construct as an ANY/ALL
9453 * SubLink. To prevent misparsing the output that way, insert
9454 * a dummy coercion (which will be stripped by parse analysis,
9455 * so no inefficiency is added in dump and reload). This is
9456 * indeed most likely what the user wrote to get the construct
9457 * accepted in the first place.
9458 */
9467 }
9468 break;
9469
9471 {
9475
9477 {
9482 false, node);
9484 {
9487 false, node);
9488 }
9491 break;
9492
9497 false, node);
9499 {
9502 false, node);
9503 }
9506 break;
9507
9513 false, node);
9516 break;
9517
9518 default:
9521 }
9522 }
9523 break;
9524
9527 break;
9528
9530 {
9532
9533 /*
9534 * We cannot see an already-planned subplan in rule deparsing,
9535 * only while EXPLAINing a query plan. We don't try to
9536 * reconstruct the original SQL, just reference the subplan
9537 * that appears elsewhere in EXPLAIN's result. It does seem
9538 * useful to show the subLinkType and testexpr (if any), and
9539 * we also note whether the subplan will be hashed.
9540 */
9542 {
9546 break;
9550 break;
9554 break;
9556 /* Parenthesizing the testexpr seems sufficient */
9559 break;
9561 /* No need to decorate these subplan references */
9564 break;
9566 /* MULTIEXPR isn't executed in the normal way */
9569 break;
9573 break;
9575 /* This case is unreachable within expressions */
9578 break;
9579 }
9580
9582 {
9584
9585 /*
9586 * Push SubPlan into ancestors list while deparsing
9587 * testexpr, so that we can handle PARAM_EXEC references
9588 * to the SubPlan's paramIds. (This makes it look like
9589 * the SubPlan is an "ancestor" of the current plan node,
9590 * which is a little weird, but it does no harm.) In this
9591 * path, we don't need to mention the SubPlan explicitly,
9592 * because the referencing Params will show its existence.
9593 */
9596
9599
9601 }
9602 else
9603 {
9605
9606 /* No referencing Params, so show the SubPlan's name */
9609 else
9614 else
9617 }
9618 }
9619 break;
9620
9622 {
9625
9626 /*
9627 * This case cannot be reached in normal usage, since no
9628 * AlternativeSubPlan can appear either in parsetrees or
9629 * finished plan trees. We keep it just in case somebody
9630 * wants to use this code to print planner data structures.
9631 */
9634 {
9637
9640 else
9644 splan->plan_name);
9645 else
9647 splan->plan_name);
9650 }
9652 }
9653 break;
9654
9656 {
9660 const char *fieldname;
9662
9663 /*
9664 * Parenthesize the argument unless it's a SubscriptingRef or
9665 * another FieldSelect. Note in particular that it would be
9666 * WRONG to not parenthesize a Var argument; simplicity is not
9667 * the issue here, having the right number of names is.
9668 */
9676
9677 /*
9678 * Get and print the field name.
9679 */
9681 0, context);
9683 }
9684 break;
9685
9687 {
9690
9691 /*
9692 * There is no good way to represent a FieldStore as real SQL,
9693 * so decompilation of INSERT or UPDATE statements should
9694 * always use processIndirection as part of the
9695 * statement-level syntax. We should only get here when
9696 * EXPLAIN tries to print the targetlist of a plan resulting
9697 * from such a statement. The plan case is even harder than
9698 * ordinary rules would be, because the planner tries to
9699 * collapse multiple assignments to the same field or subfield
9700 * into one FieldStore; so we can see a list of target fields
9701 * not just one, and the arguments could be FieldStores
9702 * themselves. We don't bother to try to print the target
9703 * field names; we just print the source arguments, with a
9704 * ROW() around them if there's more than one. This isn't
9705 * terribly complete, but it's probably good enough for
9706 * EXPLAIN's purposes; especially since anything more would be
9707 * either hopelessly confusing or an even poorer
9708 * representation of what the plan is actually doing.
9709 */
9716 }
9717 break;
9718
9720 {
9723
9725 !showimplicit)
9726 {
9727 /* don't show the implicit cast */
9729 }
9730 else
9731 {
9733 relabel->resulttype,
9734 relabel->resulttypmod,
9735 node);
9736 }
9737 }
9738 break;
9739
9741 {
9744
9746 !showimplicit)
9747 {
9748 /* don't show the implicit cast */
9750 }
9751 else
9752 {
9754 iocoerce->resulttype,
9755 -1,
9756 node);
9757 }
9758 }
9759 break;
9760
9762 {
9765
9767 !showimplicit)
9768 {
9769 /* don't show the implicit cast */
9771 }
9772 else
9773 {
9775 acoerce->resulttype,
9776 acoerce->resulttypmod,
9777 node);
9778 }
9779 }
9780 break;
9781
9783 {
9786
9788 !showimplicit)
9789 {
9790 /* don't show the implicit cast */
9792 }
9793 else
9794 {
9796 convert->resulttype, -1,
9797 node);
9798 }
9799 }
9800 break;
9801
9803 {
9806
9811 generate_collation_name(collate->collOid));
9814 }
9815 break;
9816
9818 {
9821
9823 0, PRETTYINDENT_VAR, 0);
9825 {
9828 }
9830 {
9833
9835 {
9836 /*
9837 * The parser should have produced WHEN clauses of the
9838 * form "CaseTestExpr = RHS", possibly with an
9839 * implicit coercion inserted above the CaseTestExpr.
9840 * For accurate decompilation of rules it's essential
9841 * that we show just the RHS. However in an
9842 * expression that's been through the optimizer, the
9843 * WHEN clause could be almost anything (since the
9844 * equality operator could have been expanded into an
9845 * inline function). If we don't recognize the form
9846 * of the WHEN clause, just punt and display it as-is.
9847 */
9849 {
9851
9854 CaseTestExpr))
9856 }
9857 }
9858
9862 0, 0, 0);
9866 }
9870 0, 0, 0);
9875 -PRETTYINDENT_VAR, 0, 0);
9876 }
9877 break;
9878
9880 {
9881 /*
9882 * Normally we should never get here, since for expressions
9883 * that can contain this node type we attempt to avoid
9884 * recursing to it. But in an optimized expression we might
9885 * be unable to avoid that (see comments for CaseExpr). If we
9886 * do see one, print it as CASE_TEST_EXPR.
9887 */
9889 }
9890 break;
9891
9893 {
9895
9899
9900 /*
9901 * If the array isn't empty, we assume its elements are
9902 * coerced to the desired type. If it's empty, though, we
9903 * need an explicit coercion to the array type.
9904 */
9907 format_type_with_typemod(arrayexpr->array_typeid, -1));
9908 }
9909 break;
9910
9912 {
9918
9919 /*
9920 * If it's a named type and not RECORD, we may have to skip
9921 * dropped columns and/or claim there are NULLs for added
9922 * columns.
9923 */
9925 {
9926 tupdesc = lookup_rowtype_tupdesc(rowexpr->row_typeid, -1);
9928 }
9929
9930 /*
9931 * SQL99 allows "ROW" to be omitted when there is more than
9932 * one column, but for simplicity we always print it.
9933 */
9936 i = 0;
9938 {
9940
9943 {
9945 /* Whole-row Vars need special treatment here */
9948 }
9949 i++;
9950 }
9952 {
9954 {
9956 {
9960 }
9961 i++;
9962 }
9963
9964 ReleaseTupleDesc(tupdesc);
9965 }
9969 format_type_with_typemod(rowexpr->row_typeid, -1));
9970 }
9971 break;
9972
9974 {
9976
9977 /*
9978 * SQL99 allows "ROW" to be omitted when there is more than
9979 * one column, but for simplicity we always print it. Within
9980 * a ROW expression, whole-row Vars need special treatment, so
9981 * use get_rule_list_toplevel.
9982 */
9985
9986 /*
9987 * We assume that the name of the first-column operator will
9988 * do for all the rest too. This is definitely open to
9989 * failure, eg if some but not all operators were renamed
9990 * since the construct was parsed, but there seems no way to
9991 * be perfect.
9992 */
9999 }
10000 break;
10001
10003 {
10005
10009 }
10010 break;
10011
10013 {
10015
10017 {
10020 break;
10023 break;
10024 }
10027 }
10028 break;
10029
10031 {
10033
10034 /*
10035 * Note: this code knows that typmod for time, timestamp, and
10036 * timestamptz just prints as integer.
10037 */
10039 {
10042 break;
10045 break;
10048 break;
10051 break;
10054 svf->typmod);
10055 break;
10058 break;
10061 break;
10064 break;
10067 svf->typmod);
10068 break;
10071 break;
10074 break;
10077 break;
10080 break;
10083 break;
10086 break;
10087 }
10088 }
10089 break;
10090
10092 {
10097 Const *con;
10098
10100 {
10103 break;
10106 break;
10109 break;
10112 break;
10115 break;
10118 break;
10121 break;
10123 break;
10124 }
10126 {
10129 else
10131 }
10132 if (xexpr->name)
10133 {
10137 }
10139 {
10141 {
10146 }
10148 {
10151
10158 }
10161 }
10163 {
10167 {
10173 /* no extra decoration needed */
10175 break;
10178
10180 context, true);
10181
10183 Assert(!con->constisnull);
10186 " PRESERVE WHITESPACE");
10187 else
10189 " STRIP WHITESPACE");
10190 break;
10193
10195 context, true);
10196
10200 con->constisnull)
10202 else
10204
10206 if (con->constisnull)
10207 /* suppress STANDALONE NO VALUE */ ;
10208 else
10209 {
10211 {
10214 ", STANDALONE YES");
10215 break;
10218 ", STANDALONE NO");
10219 break;
10222 ", STANDALONE NO VALUE");
10223 break;
10224 default:
10225 break;
10226 }
10227 }
10228 break;
10231 break;
10232 }
10233 }
10235 {
10237 format_type_with_typemod(xexpr->type,
10238 xexpr->typmod));
10241 else
10243 }
10244
10247 else
10249 }
10250 break;
10251
10253 {
10255
10259
10260 /*
10261 * For scalar inputs, we prefer to print as IS [NOT] NULL,
10262 * which is shorter and traditional. If it's a rowtype input
10263 * but we're applying a scalar test, must print IS [NOT]
10264 * DISTINCT FROM NULL to be semantically correct.
10265 */
10268 {
10270 {
10273 break;
10276 break;
10277 default:
10280 }
10281 }
10282 else
10283 {
10285 {
10288 break;
10291 break;
10292 default:
10295 }
10296 }
10299 }
10300 break;
10301
10303 {
10305
10310 {
10313 break;
10316 break;
10319 break;
10322 break;
10325 break;
10328 break;
10329 default:
10332 }
10335 }
10336 break;
10337
10339 {
10342
10344 !showimplicit)
10345 {
10346 /* don't show the implicit cast */
10348 }
10349 else
10350 {
10352 ctest->resulttype,
10353 ctest->resulttypmod,
10354 node);
10355 }
10356 }
10357 break;
10358
10361 break;
10362
10365 break;
10366
10368 {
10370
10374 else
10376 cexpr->cursor_param);
10377 }
10378 break;
10379
10381 {
10383
10384 /*
10385 * This isn't exactly nextval(), but that seems close enough
10386 * for EXPLAIN's purposes.
10387 */
10391 NIL));
10393 }
10394 break;
10395
10397 {
10401
10402 /*
10403 * InferenceElem can only refer to target relation, so a
10404 * prefix is not useful, and indeed would cause parse errors.
10405 */
10408
10409 /*
10410 * Parenthesize the element unless it's a simple Var or a bare
10411 * function call. Follows pg_get_indexdef_worker().
10412 */
10416 COERCE_EXPLICIT_CALL)
10418
10422 context, false);
10425
10427
10431
10432 /* Add the operator class name, if not default */
10434 {
10437
10439 }
10440 }
10441 break;
10442
10444 {
10446
10447 /*
10448 * We cannot see a ReturningExpr in rule deparsing, only while
10449 * EXPLAINing a query plan (ReturningExpr nodes are only ever
10450 * adding during query rewriting). Just display the expression
10451 * returned (an expanded view column).
10452 */
10454 }
10455 break;
10456
10458 {
10460 ListCell *cell;
10462
10464 {
10466 break;
10467 }
10468
10470 {
10474
10478 break;
10479
10482
10486 {
10488
10492 }
10493
10495 break;
10496
10502
10506 break;
10507
10508 default:
10511 break;
10512 }
10513 }
10514 break;
10515
10517 {
10519
10522 }
10523 break;
10524
10527 break;
10528
10530 {
10532
10535
10537
10539
10540 /* TODO: handle FORMAT clause */
10541
10543 {
10546 break;
10549 break;
10552 break;
10553 default:
10554 break;
10555 }
10556
10559
10562 }
10563 break;
10564
10566 {
10568
10570 {
10573 break;
10576 break;
10579 break;
10580 default:
10583 }
10584
10586
10588
10590
10592 {
10594 *lc2;
10596
10598
10601 {
10605
10609 }
10610 }
10611
10616
10619 JSON_BEHAVIOR_NULL :
10620 JSON_BEHAVIOR_FALSE);
10621
10623 }
10624 break;
10625
10627 {
10629 ListCell *l;
10630
10633 {
10637 }
10638 }
10639 break;
10640
10643 break;
10644
10645 default:
10647 break;
10648 }
10649}
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 10711 of file ruleutils.c.
10713{
10716 else
10717 {
10719
10721 /* no point in showing any top-level implicit cast */
10725 exprTypmod(node)));
10726 }
10727}
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 9168 of file ruleutils.c.
9170{
9172
9175
9178
9180
9183}
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 10663 of file ruleutils.c.
10665{
10668 else
10670}
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 6636 of file ruleutils.c.
6638{
6639 ListCell *l;
6643
6645 {
6648 return;
6649
6651 {
6654
6656 {
6658
6661 false, context);
6663 }
6664
6667 }
6668 return;
6669
6672 break;
6675 break;
6679 break;
6680 }
6681
6683 {
6687 }
6688
6690}
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 10681 of file ruleutils.c.
10683{
10686
10689 {
10691
10695 }
10696}
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 6696 of file ruleutils.c.
6698{
6701 ListCell *l;
6702
6705 {
6709 TypeCacheEntry *typentry;
6710
6713 force_colno, context);
6715 /* See whether operator is default < or > for datatype */
6719 {
6720 /* ASC is default, so emit nothing for it */
6723 }
6725 {
6727 /* DESC defaults to NULLS FIRST */
6730 }
6731 else
6732 {
6735 sortcoltype,
6736 sortcoltype));
6737 /* be specific to eliminate ambiguity */
6740 else
6742 }
6744 }
6745}
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 6567 of file ruleutils.c.
6569{
6572 Node *expr;
6573
6576
6577 /*
6578 * Use column-number form if requested by caller. Otherwise, if
6579 * expression is a constant, force it to be dumped with an explicit cast
6580 * as decoration --- this is because a simple integer constant is
6581 * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
6582 * we dump it without any decoration. Similarly, if it's just a Var,
6583 * there is risk of misinterpretation if the column name is reassigned in
6584 * the SELECT list, so we may need to force table qualification. And, if
6585 * it's anything more complex than a simple Var, then force extra parens
6586 * around it, to ensure it can't be misinterpreted as a cube() or rollup()
6587 * construct.
6588 */
6590 {
6593 }
6594 else if (!expr)
6595 /* do nothing, probably can't happen */ ;
6599 {
6600 /* Tell get_variable to check for name conflict */
6602
6606 }
6607 else
6608 {
6609 /*
6610 * We must force parens for function-like expressions even if
6611 * PRETTY_PAREN is off, since those are the ones in danger of
6612 * misparsing. For other expressions we need to force them only if
6613 * PRETTY_PAREN is on, since otherwise the expression will output them
6614 * itself. (We can't skip the parens.)
6615 */
6621
6627 }
6628
6629 return expr;
6630}
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 6754 of file ruleutils.c.
6755{
6758 ListCell *l;
6759
6762 {
6764
6766 continue; /* ignore anonymous windows */
6767
6771 else
6773
6775
6777
6779 }
6780}
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 6786 of file ruleutils.c.
6788{
6792 ListCell *l;
6793
6795 if (wc->refname)
6796 {
6799 }
6800 /* partition clauses are always inherited, so only print if no refname */
6802 {
6808 {
6810
6813 false, context);
6815 }
6817 }
6818 /* print ordering clause only if not inherited */
6820 {
6826 }
6827 /* framing clause is never inherited, so print unless it's default */
6829 {
6834 context);
6835 }
6837}
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 5909 of file ruleutils.c.
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
6001 {
6003 /* we intentionally throw an error for LCS_NONE */
6006 break;
6010 break;
6014 break;
6018 break;
6022 break;
6023 }
6024
6027 context)));
6032 }
6033 }
6034}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, elog, ERROR, fb(), get_basic_select_query(), get_rtable_name(), get_rule_expr(), get_rule_orderby(), get_setop_query(), get_with_clause(), IsA, LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, LCS_NONE, 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 6419 of file ruleutils.c.
6420{
6423
6424 /* Guard against excessively long or deeply-nested queries */
6425 CHECK_FOR_INTERRUPTS();
6426 check_stack_depth();
6427
6429 {
6433
6435
6436 /*
6437 * We need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y.
6438 * Also add parens if the leaf query contains its own set operations.
6439 * (That shouldn't happen unless one of the other clauses is also
6440 * present, see transformSetOperationTree; but let's be safe.)
6441 */
6443 subquery->sortClause ||
6444 subquery->rowMarks ||
6445 subquery->limitOffset ||
6446 subquery->limitCount ||
6447 subquery->setOperations);
6453 context->indentLevel);
6456 }
6458 {
6462
6463 /*
6464 * We force parens when nesting two SetOperationStmts, except when the
6465 * lefthand input is another setop of the same kind. Syntactically,
6466 * we could omit parens in rather more cases, but it seems best to use
6467 * parens to flag cases where the setop operator changes. If we use
6468 * parens, we also increase the indentation level for the child query.
6469 *
6470 * There are some cases in which parens are needed around a leaf query
6471 * too, but those are more easily handled at the next level down (see
6472 * code above).
6473 */
6475 {
6477
6480 else
6482 }
6483 else
6485
6487 {
6491 }
6492 else
6493 subindent = 0;
6494
6496
6501 else
6503
6505 {
6508 break;
6511 break;
6514 break;
6515 default:
6518 }
6521
6522 /* Always parenthesize if RHS is another setop */
6524
6525 /*
6526 * The indentation code here is deliberately a bit different from that
6527 * for the lefthand input, because we want the line breaks in
6528 * different places.
6529 */
6531 {
6534 }
6535 else
6536 subindent = 0;
6538
6539 /*
6540 * The output column names of the RHS sub-select don't matter.
6541 */
6544
6546
6548
6553 }
6554 else
6555 {
6558 }
6559}
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 8837 of file ruleutils.c.
8838{
8840
8842 {
8843 /* binary operator */
8846 const char *op;
8847
8850 return op;
8851 }
8853}
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 6042 of file ruleutils.c.
6043{
6046
6047 /*
6048 * We want to detect a match even if the Query also contains OLD or NEW
6049 * rule RTEs. So the idea is to scan the rtable and see if there is only
6050 * one inFromCl RTE that is a VALUES RTE.
6051 */
6053 {
6055
6057 {
6058 if (result)
6060 result = rte;
6061 }
6063 continue; /* ignore rule entries */
6064 else
6066 }
6067
6068 /*
6069 * We don't need to check the targetlist in any great detail, because
6070 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6071 * appear inside auto-generated sub-queries with very restricted
6072 * structure. However, DefineView might have modified the tlist by
6073 * injecting new column aliases, or we might have some other column
6074 * aliases forced by a resultDesc. We can only simplify if the RTE's
6075 * column names match the names that get_target_list() would select.
6076 */
6077 if (result)
6078 {
6080 int colno;
6081
6084 colno = 0;
6086 {
6089 char *colname;
6090
6093
6094 /* compute name that get_target_list would use for column */
6095 colno++;
6098 else
6099 colname = tle->resname;
6100
6101 /* does it match the VALUES RTE? */
6104 }
6105 }
6106
6107 return result;
6108}
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 7893 of file ruleutils.c.
7894{
7896
7897 /*
7898 * For a non-Var referent, force parentheses because our caller probably
7899 * assumed a Var is a simple expression.
7900 */
7906}
References appendStringInfoChar(), deparse_context::buf, buf, get_rule_expr(), and IsA.
Referenced by get_variable().
◆ get_sublink_expr()
|
static |
Definition at line 11851 of file ruleutils.c.
11852{
11857
11860 else
11862
11863 /*
11864 * Note that we print the name of only the first operator, when there are
11865 * multiple combining operators. This is an approximation that could go
11866 * wrong in various scenarios (operators in different schemas, renamed
11867 * operators, etc) but there is not a whole lot we can do about it, since
11868 * the syntax allows only one operator to be shown.
11869 */
11871 {
11873 {
11874 /* single combining operator */
11876
11881 }
11883 {
11884 /* multiple combining operators, = or <> cases */
11886 ListCell *l;
11887
11891 {
11893
11901 }
11903 }
11905 {
11906 /* multiple combining operators, < <= > >= cases */
11908
11915 }
11916 else
11919 }
11920
11922
11924 {
11927 break;
11928
11932 else
11934 break;
11935
11938 break;
11939
11942 break;
11943
11948 break;
11949
11951 default:
11954 break;
11955 }
11956
11959
11962 context->indentLevel);
11963
11966 else
11968}
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 12282 of file ruleutils.c.
12283{
12284 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12285
12290}
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 12848 of file ruleutils.c.
12849{
12851 Oid argtypes[1];
12852 int nargs;
12853 ListCell *l;
12854
12855 /*
12856 * We should qualify the handler's function name if it wouldn't be
12857 * resolved by lookup in the current search path.
12858 */
12859 argtypes[0] = INTERNALOID;
12862 NIL, argtypes,
12864
12865 nargs = 0;
12867 {
12868 if (nargs++ > 0)
12871 }
12873
12875 {
12879 }
12880}
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 6244 of file ruleutils.c.
6245{
6250 int colno;
6251 ListCell *l;
6252
6253 /* we use targetbuf to hold each TLE's text temporarily */
6255
6257 colno = 0;
6258 foreach(l, targetList)
6259 {
6261 char *colname;
6263
6265 continue; /* ignore junk entries */
6266
6269 colno++;
6270
6271 /*
6272 * Put the new field text into targetbuf so we can decide after we've
6273 * got it whether or not it needs to go on a new line.
6274 */
6277
6278 /*
6279 * We special-case Var nodes rather than using get_rule_expr. This is
6280 * needed because get_rule_expr will display a whole-row Var as
6281 * "foo.*", which is the preferred notation in most contexts, but at
6282 * the top level of a SELECT list it's not right (the parser will
6283 * expand that notation into multiple columns, yielding behavior
6284 * different from a whole-row Var). We need to call get_variable
6285 * directly so that we can tell it to do the right thing, and so that
6286 * we can get the attribute name which is the default AS label.
6287 */
6289 {
6291 }
6292 else
6293 {
6295
6296 /*
6297 * When colNamesVisible is true, we should always show the
6298 * assigned column name explicitly. Otherwise, show it only if
6299 * it's not FigureColname's fallback.
6300 */
6302 }
6303
6304 /*
6305 * Figure out what the result column should be called. In the context
6306 * of a view, use the view's tuple descriptor (so as to pick up the
6307 * effects of any column RENAME that's been done on the view).
6308 * Otherwise, just use what we can find in the TLE.
6309 */
6312 colno - 1)->attname);
6313 else
6314 colname = tle->resname;
6315
6316 /* Show AS unless the column's name is correct as-is */
6317 if (colname) /* resname could be NULL */
6318 {
6321 }
6322
6323 /* Restore context's output buffer */
6325
6326 /* Consider line-wrapping if enabled */
6328 {
6330
6331 /* Does the new field start with a new line? */
6333 leading_nl_pos = 0;
6334 else
6335 leading_nl_pos = -1;
6336
6337 /* If so, we shouldn't add anything */
6339 {
6340 /* instead, remove any trailing spaces currently in buf */
6342 }
6343 else
6344 {
6346
6347 /* Locate the start of the current line in the output buffer */
6351 else
6352 trailing_nl++;
6353
6354 /*
6355 * Add a newline, plus some indentation, if the new field is
6356 * not the first and either the new field would cause an
6357 * overflow or the last field used more than one line.
6358 */
6359 if (colno > 1 &&
6361 last_was_multiline))
6364 }
6365
6366 /* Remember this field's multiline status for next iteration */
6367 last_was_multiline =
6369 }
6370
6371 /* Add the new field */
6373 }
6374
6375 /* clean up */
6377}
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 7156 of file ruleutils.c.
7157{
7160
7161 /* Insert the WITH clause if given */
7162 get_with_clause(query, context);
7163
7164 /*
7165 * Start the query with UPDATE relname SET
7166 */
7170 {
7173 }
7177
7178 /* Print the relation alias, if needed */
7180
7182
7183 /* Deparse targetlist */
7185
7186 /* Add the FROM clause if needed */
7188
7189 /* Add a WHERE clause if given */
7191 {
7195 }
7196
7197 /* Add RETURNING if present */
7199 get_returning_clause(query, context);
7200}
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 7208 of file ruleutils.c.
7210{
7212 ListCell *l;
7218
7219 /*
7220 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
7221 * into a list. We expect them to appear, in ID order, in resjunk tlist
7222 * entries.
7223 */
7225 if (query->hasSubLinks) /* else there can't be any */
7226 {
7227 foreach(l, targetList)
7228 {
7230
7232 {
7234
7236 {
7239 }
7240 }
7241 }
7242 }
7245 remaining_ma_columns = 0;
7246
7247 /* Add the comma separated list of 'attname = value' */
7249 foreach(l, targetList)
7250 {
7252 Node *expr;
7253
7255 continue; /* ignore junk entries */
7256
7257 /* Emit separator (OK whether we're in multiassignment or not) */
7260
7261 /*
7262 * Check to see if we're starting a multiassignment group: if so,
7263 * output a left paren.
7264 */
7266 {
7267 /*
7268 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
7269 * Param. That could be buried under FieldStores and
7270 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
7271 * and underneath those there could be an implicit type coercion.
7272 * Because we would ignore implicit type coercions anyway, we
7273 * don't need to be as careful as processIndirection() is about
7274 * descending past implicit CoerceToDomains.
7275 */
7277 while (expr)
7278 {
7280 {
7282
7284 }
7286 {
7288
7290 break;
7291
7293 }
7295 {
7297
7299 break;
7301 }
7302 else
7303 break;
7304 }
7305 expr = strip_implicit_coercions(expr);
7306
7309 {
7312 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
7314 ((cur_ma_sublink->subLinkId << 16) | 1));
7316 }
7317 }
7318
7319 /*
7320 * Put out name of target column; look in the catalogs, not at
7321 * tle->resname, since resname will fail to track RENAME.
7322 */
7325 tle->resno,
7326 false)));
7327
7328 /*
7329 * Print any indirection needed (subfields or subscripts), and strip
7330 * off the top-level nodes representing the indirection assignments.
7331 */
7333
7334 /*
7335 * If we're in a multiassignment, skip printing anything more, unless
7336 * this is the last column; in which case, what we print should be the
7337 * sublink, not the Param.
7338 */
7340 {
7342 continue; /* not the last column of multiassignment */
7346 }
7347
7349
7351 }
7352}
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 7566 of file ruleutils.c.
7567{
7569
7571 {
7573
7575 0, PRETTYINDENT_STD, 1);
7579 {
7582 }
7583 }
7584 else
7585 {
7586 /* Currently only NOTIFY utility commands can appear in rules */
7588 }
7589}
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 5727 of file ruleutils.c.
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}
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 7611 of file ruleutils.c.
7612{
7618 int varno;
7619 AttrNumber varattno;
7621 char *refname;
7624
7625 /* Find appropriate nesting depth */
7629 var->varlevelsup, levelsup);
7631 netlevelsup);
7632
7633 /*
7634 * If we have a syntactic referent for the Var, and we're working from a
7635 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
7636 * on the semantic referent. (Forcing use of the semantic referent when
7637 * printing plan trees is a design choice that's perhaps more motivated by
7638 * backwards compatibility than anything else. But it does have the
7639 * advantage of making plans more explicit.)
7640 */
7642 {
7643 varno = var->varnosyn;
7644 varattno = var->varattnosyn;
7645 }
7646 else
7647 {
7648 varno = var->varno;
7649 varattno = var->varattno;
7650 }
7651
7652 /*
7653 * Try to find the relevant RTE in this rtable. In a plan tree, it's
7654 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
7655 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
7656 * find the aliases previously assigned for this RTE.
7657 */
7659 {
7660 /*
7661 * We might have been asked to map child Vars to some parent relation.
7662 */
7664 {
7668 bool found = false;
7669
7670 /* Only map up to inheritance parents, not UNION ALL appendrels */
7674 {
7675 found = false;
7677 {
7679 break; /* safety check */
7682 break; /* Var is local to child */
7683 }
7684
7686 found = true;
7687
7688 /* If the parent is itself a child, continue up. */
7691 }
7692
7693 /*
7694 * If we found an ancestral rel, and that rel is included in
7695 * appendparents, print that column not the original one.
7696 */
7698 {
7699 varno = pvarno;
7700 varattno = pvarattno;
7701 }
7702 }
7703
7705
7706 /* might be returning old/new column value */
7708 refname = dpns->ret_old_alias;
7710 refname = dpns->ret_new_alias;
7711 else
7713
7715 attnum = varattno;
7716 }
7717 else
7718 {
7722 }
7723
7724 /*
7725 * The planner will sometimes emit Vars referencing resjunk elements of a
7726 * subquery's target list (this is currently only possible if it chooses
7727 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
7728 * Although we prefer to print subquery-referencing Vars using the
7729 * subquery's alias, that's not possible for resjunk items since they have
7730 * no alias. So in that case, drill down to the subplan and print the
7731 * contents of the referenced tlist item. This works because in a plan
7732 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
7733 * we'll have set dpns->inner_plan to reference the child plan node.
7734 */
7737 dpns->inner_plan)
7738 {
7741
7746
7749
7750 /*
7751 * Force parentheses because our caller probably assumed a Var is a
7752 * simple expression.
7753 */
7759
7762 }
7763
7764 /*
7765 * If it's an unnamed join, look at the expansion of the alias variable.
7766 * If it's a simple reference to one of the input vars, then recursively
7767 * print the name of that var instead. When it's not a simple reference,
7768 * we have to just print the unqualified join column name. (This can only
7769 * happen with "dangerous" merged columns in a JOIN USING; we took pains
7770 * previously to make the unqualified column name unique in such cases.)
7771 *
7772 * This wouldn't work in decompiling plan trees, because we don't store
7773 * joinaliasvars lists after planning; but a plan tree should never
7774 * contain a join alias variable.
7775 */
7777 {
7781 {
7783
7785 /* we intentionally don't strip implicit coercions here */
7787 {
7789 istoplevel, context);
7790 }
7791 }
7792
7793 /*
7794 * Unnamed join has no refname. (Note: since it's unnamed, there is
7795 * no way the user could have referenced it to create a whole-row Var
7796 * for it. So we don't have to cover that case below.)
7797 */
7799 }
7800
7804 {
7805 /* Get column name to use from the colinfo struct */
7810
7811 /*
7812 * If we find a Var referencing a dropped column, it seems better to
7813 * print something (anything) than to fail. In general this should
7814 * not happen, but it used to be possible for some cases involving
7815 * functions returning named composite types, and perhaps there are
7816 * still bugs out there.
7817 */
7820 }
7821 else
7822 {
7823 /* System column - name is fixed, get it from the catalog */
7825 }
7826
7829
7830 /*
7831 * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
7832 * clause, we may need to add a table-name prefix to prevent
7833 * findTargetlistEntrySQL92 from misinterpreting the name as an
7834 * output-column name. To avoid cluttering the output with unnecessary
7835 * prefixes, do so only if there is a name match to a SELECT tlist item
7836 * that is different from the Var.
7837 */
7839 {
7840 int colno = 0;
7841
7843 {
7844 char *colname;
7845
7847 continue; /* ignore junk entries */
7848 colno++;
7849
7850 /* This must match colname-choosing logic in get_target_list() */
7853 colno - 1)->attname);
7854 else
7855 colname = tle->resname;
7856
7859 {
7861 break;
7862 }
7863 }
7864 }
7865
7867 {
7870 }
7873 else
7874 {
7878 format_type_with_typemod(var->vartype,
7879 var->vartypmod));
7880 }
7881
7883}
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 6843 of file ruleutils.c.
6846{
6848
6850 {
6857 else
6866 {
6872 else
6874 }
6875 else
6878 {
6885 {
6891 else
6893 }
6894 else
6896 }
6903 /* we will now have a trailing space; remove it */
6905 }
6906}
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 6912 of file ruleutils.c.
6915{
6917 deparse_context context;
6918
6926 context.prettyFlags = 0;
6928 context.indentLevel = 0;
6933
6934 get_window_frame_options(frameOptions, startOffset, endOffset, &context);
6935
6937}
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 11053 of file ruleutils.c.
References fb(), and get_windowfunc_expr_helper().
Referenced by get_rule_expr().
◆ get_windowfunc_expr_helper()
|
static |
Definition at line 11064 of file ruleutils.c.
11067{
11070 int nargs;
11071 List *argnames;
11072 ListCell *l;
11073
11078 nargs = 0;
11079 argnames = NIL;
11081 {
11083
11087 nargs++;
11088 }
11089
11093 context->inGroupBy);
11094
11096
11097 /* winstar can be set only in zero-argument aggregates */
11098 if (wfunc->winstar)
11100 else
11101 {
11103 {
11107 }
11108 else
11110 }
11111
11114
11116 {
11119 }
11120
11122
11125
11127
11129 {
11130 /* Query-decompilation case: search the windowClause list */
11132 {
11134
11136 {
11137 if (wc->name)
11139 else
11141 break;
11142 }
11143 }
11146 wfunc->winref);
11147 }
11148 else
11149 {
11150 /*
11151 * In EXPLAIN, search the namespace stack for a matching WindowAgg
11152 * node (probably it's always the first entry), and print winname.
11153 */
11155 {
11157
11159 {
11161
11163 {
11165 break;
11166 }
11167 }
11168 }
11171 wfunc->winref);
11172 }
11173}
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 5770 of file ruleutils.c.
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}
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 11976 of file ruleutils.c.
11977{
11979
11981
11983 {
11985 *lc2;
11986 bool first = true;
11987
11990 {
11993
11994 if (!first)
11996 else
11997 first = false;
11998
12000 {
12004 }
12005 else
12006 {
12009 }
12010 }
12012 }
12013
12019
12021 {
12022 ListCell *l1;
12023 ListCell *l2;
12024 ListCell *l3;
12025 ListCell *l4;
12026 ListCell *l5;
12027 int colnum = 0;
12028
12030 forfive(l1, tf->colnames, l2, tf->coltypes, l3, tf->coltypmods,
12031 l4, tf->colexprs, l5, tf->coldefexprs)
12032 {
12038 bool ordinality = (tf->ordinalitycol == colnum);
12040
12041 if (colnum > 0)
12043 colnum++;
12044
12046 ordinality ? "FOR ORDINALITY" :
12047 format_type_with_typemod(typid, typmod));
12048 if (ordinality)
12049 continue;
12050
12052 {
12056 }
12058 {
12062 }
12063 if (notnull)
12065 }
12066 }
12067
12069}
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 4143 of file ruleutils.c.
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}
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 5068 of file ruleutils.c.
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}
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 3449 of file ruleutils.c.
3450{
3455}
References fb().
Referenced by pg_get_function_arg_default().
◆ isSimpleNode()
Definition at line 8863 of file ruleutils.c.
8864{
8865 if (!node)
8866 return false;
8867
8869 {
8876 /* single words: always simple */
8877 return true;
8878
8895 /* function-like: name(..) or name[..] */
8896 return true;
8897
8898 /* CASE keywords act as parentheses */
8900 return true;
8901
8903
8904 /*
8905 * appears simple since . has top precedence, unless parent is
8906 * T_FieldSelect itself!
8907 */
8909
8911
8912 /*
8913 * treat like FieldSelect (probably doesn't matter)
8914 */
8916
8918 /* maybe simple, check args */
8920 node, prettyFlags);
8923 node, prettyFlags);
8926 node, prettyFlags);
8929 node, prettyFlags);
8932 node, prettyFlags);
8935 node, prettyFlags);
8936
8938 {
8939 /* depends on parent node type; needs further checking */
8941 {
8942 const char *op;
8948
8950 if (!op)
8951 return false;
8952
8953 /* We know only the basic operators + - and * / % */
8957 return false;
8958
8961 return false;
8962
8966 return false;
8967
8969 return true; /* op binds tighter than parent */
8970
8972 return false;
8973
8974 /*
8975 * Operators are same priority --- can skip parens only if
8976 * we have (a - b) - c, not a - (b - c).
8977 */
8979 return true;
8980
8981 return false;
8982 }
8983 /* else do the same stuff as for T_SubLink et al. */
8984 }
8985 /* FALLTHROUGH */
8986
8993 {
8995 {
8996 /* special handling for casts and COERCE_SQL_SYNTAX */
8998
9002 return false;
9003 return true; /* own parentheses */
9004 }
9017 return true;
9018 default:
9019 return false;
9020 }
9021
9024 {
9027 {
9030
9034 {
9038 return true;
9039 break;
9042 return true;
9043 break;
9044 }
9045 }
9046 return false;
9048 {
9049 /* special handling for casts and COERCE_SQL_SYNTAX */
9051
9055 return false;
9056 return true; /* own parentheses */
9057 }
9070 return true;
9071 default:
9072 return false;
9073 }
9074
9076 /* maybe simple, check args */
9078 node, prettyFlags);
9079
9080 default:
9081 break;
9082 }
9083 /* those we don't know: in dubio complexo */
9084 return false;
9085}
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, PRETTYFLAG_PAREN, and type.
Referenced by get_rule_expr_paren(), and isSimpleNode().
◆ looks_like_function()
Definition at line 10734 of file ruleutils.c.
10735{
10737 return false; /* probably shouldn't happen */
10739 {
10741 /* OK, unless it's going to deparse as a cast */
10750 /* these are all accepted by func_expr_common_subexpr */
10751 return true;
10752 default:
10753 break;
10754 }
10755 return false;
10756}
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 4926 of file ruleutils.c.
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}
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 5350 of file ruleutils.c.
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}
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 5542 of file ruleutils.c.
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}
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 2145 of file ruleutils.c.
2146{
2148 int prettyFlags;
2149 char *res;
2150
2151 prettyFlags = PRETTYFLAG_INDENT;
2152
2154
2156 PG_RETURN_NULL();
2157
2159}
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 2183 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 2162 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 2192 of file ruleutils.c.
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}
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(), 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 2674 of file ruleutils.c.
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}
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 2691 of file ruleutils.c.
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}
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 2709 of file ruleutils.c.
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}
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 3489 of file ruleutils.c.
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}
References castNode, deparse_expression(), fb(), 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 3182 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 3208 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 3233 of file ruleutils.c.
3234{
3238
3241 PG_RETURN_NULL();
3242
3244 {
3246 PG_RETURN_NULL();
3247 }
3248
3250
3252
3254
3256}
References buf, fb(), 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 3613 of file ruleutils.c.
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}
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 2926 of file ruleutils.c.
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}
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(), 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 1178 of file ruleutils.c.
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}
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 1235 of file ruleutils.c.
1236{
1237 int prettyFlags;
1238
1240
1242 true, true,
1243 false, false,
1244 prettyFlags, false);
1245}
References fb(), GET_PRETTY_FLAGS, and pg_get_indexdef_worker().
Referenced by BuildIndexValueDescription().
◆ pg_get_indexdef_columns_extended()
Definition at line 1249 of file ruleutils.c.
1250{
1253 int prettyFlags;
1254
1256
1259 false, false,
1260 prettyFlags, false);
1261}
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 1198 of file ruleutils.c.
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}
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 1225 of file ruleutils.c.
1226{
1228 false, false,
1229 true, true,
1230 0, false);
1231}
References fb(), and pg_get_indexdef_worker().
Referenced by RememberIndexForRebuilding().
◆ pg_get_indexdef_worker()
|
static |
Definition at line 1270 of file ruleutils.c.
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}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attname, attnum, buf, DatumGetPointer(), deparse_context_for(), deparse_expression_pretty(), elog, ERROR, exprCollation(), exprType(), fb(), flatten_reloptions(), 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 2127 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 2095 of file ruleutils.c.
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}
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 1908 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 1923 of file ruleutils.c.
1924{
1925 int prettyFlags;
1926
1928
1930}
References fb(), GET_PRETTY_FLAGS, and pg_get_partkeydef_worker().
Referenced by ExecBuildSlotPartitionKeyDescription().
◆ pg_get_partkeydef_worker()
|
static |
Definition at line 1936 of file ruleutils.c.
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}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attname, attnum, buf, DatumGetPointer(), deparse_context_for(), deparse_expression_pretty(), elog, ERROR, exprCollation(), exprType(), fb(), 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 1588 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 560 of file ruleutils.c.
561{
563 int prettyFlags;
564 char *res;
565
566 prettyFlags = PRETTYFLAG_INDENT;
567
569
571 PG_RETURN_NULL();
572
574}
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 578 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 597 of file ruleutils.c.
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}
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 2832 of file ruleutils.c.
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}
References AccessShareLock, attnum, BTEqualStrategyNumber, DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, ereport, errcode(), errmsg(), ERROR, fb(), 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 1653 of file ruleutils.c.
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}
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(), 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 1608 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 1636 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 1837 of file ruleutils.c.
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}
References accumArrayResult(), cstring_to_text(), CurrentMemoryContext, deparse_context_for(), deparse_expression_pretty(), fb(), 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 1626 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 871 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 885 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 900 of file ruleutils.c.
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}
References AccessShareLock, deparse_context::appendparents, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), attname, BTEqualStrategyNumber, deparse_context::buf, buf, deparse_context::colNamesVisible, DatumGetByteaPP, DatumGetName(), elog, ERROR, fastgetattr(), fb(), 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 2794 of file ruleutils.c.
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}
References fb(), 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 678 of file ruleutils.c.
679{
680 /* By OID */
682 int prettyFlags;
683 char *res;
684
685 prettyFlags = PRETTYFLAG_INDENT;
686
688
690 PG_RETURN_NULL();
691
693}
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 697 of file ruleutils.c.
698{
699 /* By OID */
702 int prettyFlags;
703 char *res;
704
706
708
710 PG_RETURN_NULL();
711
713}
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 736 of file ruleutils.c.
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}
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 761 of file ruleutils.c.
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}
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 789 of file ruleutils.c.
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}
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 716 of file ruleutils.c.
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}
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 5334 of file ruleutils.c.
5335{
5336 /* Free the ancestor list made in push_ancestor_plan */
5338
5339 /* Restore fields changed by push_ancestor_plan */
5341}
References fb(), and list_free().
Referenced by get_name_for_var_field(), and get_parameter().
◆ pop_child_plan()
|
static |
Definition at line 5283 of file ruleutils.c.
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}
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 3301 of file ruleutils.c.
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}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, buf, castNode, deparse_expression(), elog, ERROR, fb(), 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 3263 of file ruleutils.c.
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}
References appendBinaryStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, fb(), 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 3559 of file ruleutils.c.
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}
References AcquireRewriteLocks(), appendStringInfoChar(), appendStringInfoString(), buf, castNode, fb(), 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 3461 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 13030 of file ruleutils.c.
13031{
13035
13038 {
13041 {
13042 /* If subexpression is NULL, get_rule_expr prints nothing */
13046 }
13047 /* If subexpression is NULL, get_rule_expr prints nothing */
13050 }
13051}
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 12952 of file ruleutils.c.
12953{
12956
12957 for (;;)
12958 {
12960 break;
12962 {
12964 Oid typrelid;
12965 char *fieldname;
12966
12967 /* lookup tuple type */
12968 typrelid = get_typ_typrelid(fstore->resulttype);
12971 format_type_be(fstore->resulttype));
12972
12973 /*
12974 * Print the field name. There should only be one target field in
12975 * stored rules. There could be more than that in executable
12976 * target lists, but this function cannot be used for that case.
12977 */
12979 fieldname = get_attname(typrelid,
12982
12983 /*
12984 * We ignore arg since it should be an uninteresting reference to
12985 * the target column or subcolumn.
12986 */
12988 }
12990 {
12992
12994 break;
12995
12996 printSubscripts(sbsref, context);
12997
12998 /*
12999 * We ignore refexpr since it should be an uninteresting reference
13000 * to the target column or subcolumn.
13001 */
13003 }
13005 {
13007 /* If it's an explicit domain coercion, we're done */
13009 break;
13010 /* Tentatively descend past the CoerceToDomain */
13012 }
13013 else
13014 break;
13015 }
13016
13017 /*
13018 * If we descended past a CoerceToDomain whose argument turned out not to
13019 * be a FieldStore or array assignment, back up to the CoerceToDomain.
13020 * (This is not enough to be fully correct if there are nested implicit
13021 * CoerceToDomains, but such cases shouldn't ever occur.)
13022 */
13025
13026 return node;
13027}
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 5313 of file ruleutils.c.
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}
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 5266 of file ruleutils.c.
5268{
5269 /* Save state for restoration later */
5271
5272 /* Link current plan node into ancestors list */
5274
5275 /* Set attention on selected child */
5277}
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 13060 of file ruleutils.c.
13061{
13062 /*
13063 * Can avoid quoting if ident starts with a lowercase letter or underscore
13064 * and contains only lowercase letters, digits, and underscores, *and* is
13065 * not any SQL keyword. Otherwise, supply quotes.
13066 */
13069 const char *ptr;
13070 char *result;
13072
13073 /*
13074 * would like to use <ctype.h> macros here, but they might yield unwanted
13075 * locale-specific results...
13076 */
13078
13080 {
13082
13086 {
13087 /* okay */
13088 }
13089 else
13090 {
13093 nquotes++;
13094 }
13095 }
13096
13099
13101 {
13102 /*
13103 * Check for keyword. We quote keywords except for unreserved ones.
13104 * (In some cases we could avoid quoting a col_name or type_func_name
13105 * keyword, but it seems much harder than it's worth to tell that.)
13106 *
13107 * Note: ScanKeywordLookup() does case-insensitive comparison, but
13108 * that's fine, since we already know we have all-lower-case.
13109 */
13111
13114 }
13115
13118
13120
13121 optr = result;
13124 {
13126
13130 }
13133
13134 return result;
13135}
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(), extended_statistics_update(), 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 13144 of file ruleutils.c.
13146{
13148
13154}
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 9149 of file ruleutils.c.
9150{
9153}
References str.
Referenced by appendContextKeyword(), get_from_clause(), and get_target_list().
◆ resolve_special_varno()
|
static |
Definition at line 7914 of file ruleutils.c.
7916{
7917 Var *var;
7919
7920 /* This function is recursive, so let's be paranoid. */
7921 check_stack_depth();
7922
7923 /* If it's not a Var, invoke the callback. */
7925 {
7926 (*callback) (node, context, callback_arg);
7927 return;
7928 }
7929
7930 /* Find appropriate nesting depth */
7931 var = (Var *) node;
7933 var->varlevelsup);
7934
7935 /*
7936 * If varno is special, recurse. (Don't worry about varnosyn; if we're
7937 * here, we already decided not to use that.)
7938 */
7940 {
7944
7948
7949 /*
7950 * If we're descending to the first child of an Append or MergeAppend,
7951 * update appendparents. This will affect deparsing of all Vars
7952 * appearing within the eventually-resolved subexpression.
7953 */
7955
7962
7965 callback, callback_arg);
7968 return;
7969 }
7971 {
7974
7978
7981 callback, callback_arg);
7983 return;
7984 }
7986 {
7988
7992
7994 callback, callback_arg);
7995 return;
7996 }
7999
8000 /* Not special. Just invoke the callback. */
8001 (*callback) (node, context, callback_arg);
8002}
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 3858 of file ruleutils.c.
3859{
3861
3863 dpns.rtable = rtable;
3868 /* We needn't bother computing column aliases yet */
3869
3871}
References fb(), NIL, and set_rtable_names().
Referenced by ExplainPrintPlan().
◆ set_deparse_context_plan()
Definition at line 3828 of file ruleutils.c.
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}
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 4032 of file ruleutils.c.
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}
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 5155 of file ruleutils.c.
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 .. UPDATE we just need the inner tlist to point to the
5190 * excluded expression's tlist. (Similar to the SubqueryScan we don't want
5191 * to reuse OUTER, it's used for RETURNING in some modify table cases,
5192 * 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}
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 4581 of file ruleutils.c.
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}
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 4378 of file ruleutils.c.
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}
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 3887 of file ruleutils.c.
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}
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 4101 of file ruleutils.c.
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}
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 4213 of file ruleutils.c.
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}
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 11826 of file ruleutils.c.
11827{
11829
11830 /*
11831 * We always form the string literal according to standard SQL rules.
11832 */
11835 {
11837
11841 }
11843}
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 13608 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().
