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_propgraph_element.h"#include "catalog/pg_propgraph_element_label.h"#include "catalog/pg_propgraph_label.h"#include "catalog/pg_propgraph_label_property.h"#include "catalog/pg_propgraph_property.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 |
| struct | oid_str_pair |
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 317 of file ruleutils.c.
323{
325 int counter; /* Largest addition used so far for name */
326} NameHashEntry;
327
328/* Callback signature for resolve_special_varno() */
330 void *callback_arg);
331
332
333/* ----------
334 * Global data
335 * ----------
336 */
338static const char *const query_getrulebyoid = "SELECT * FROM pg_catalog.pg_rewrite WHERE oid = $1";
340static const char *const query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";
341
342/* GUC parameters */
344
345
346/* ----------
347 * Local functions
348 *
349 * Most of these functions used to use fixed-size buffers to build their
350 * results. Now, they take an (already initialized) StringInfo object
351 * as a parameter, and append their text output to its contents.
352 * ----------
353 */
358 int prettyFlags, int wrapColumn);
367 int prettyFlags, bool missing_ok);
369static void make_propgraphdef_labels(StringInfo buf, Oid elid, const char *elalias, Oid elrelid);
372 bool missing_ok);
376 int prettyFlags, bool missing_ok);
390 List *parentUsing);
419 int prettyFlags);
421 int prettyFlags, int wrapColumn);
431 deparse_context *context,
441 deparse_context *context);
444 deparse_context *context);
451 deparse_context *context);
454 deparse_context *context);
456 deparse_context *context);
458 void *callback_arg);
491 void *callback_arg);
511 deparse_context *context,
515 void *callback_arg);
521 deparse_context *context);
523 deparse_context *context);
525 deparse_context *context);
527 deparse_context *context);
529 deparse_context *context);
532 deparse_context *context);
534 deparse_context *context);
545 bool inGroupBy);
555 deparse_context *context,
558 deparse_context *context,
561
562#define only_marker(rte) ((rte)->inh ? "" : "ONLY ")
563
564
565/* ----------
566 * pg_get_ruledef - Do it all and return a text
567 * that could be used as a statement
568 * to recreate the rule
569 * ----------
570 */
571Datum
573{
575 int prettyFlags;
576 char *res;
577
578 prettyFlags = PRETTYFLAG_INDENT;
579
581
583 PG_RETURN_NULL();
584
586}
587
588
589Datum
591{
594 int prettyFlags;
595 char *res;
596
598
600
602 PG_RETURN_NULL();
603
605}
606
607
608static char *
610{
612 char nulls[1];
617
618 /*
619 * Do this first so that string is alloc'd in outer context not SPI's.
620 */
622
623 /*
624 * Connect to SPI manager
625 */
626 SPI_connect();
627
628 /*
629 * On the first call prepare the plan to lookup pg_rewrite. We read
630 * pg_rewrite over the SPI manager instead of using the syscache to be
631 * checked for read access on pg_rewrite.
632 */
634 {
635 Oid argtypes[1];
637
638 argtypes[0] = OIDOID;
644 }
645
646 /*
647 * Get the pg_rewrite tuple for this rule
648 */
650 nulls[0] = ' ';
655 {
656 /*
657 * There is no tuple data available here, just keep the output buffer
658 * empty.
659 */
660 }
661 else
662 {
663 /*
664 * Get the rule's definition and put it into executor's memory
665 */
669 }
670
671 /*
672 * Disconnect from SPI manager
673 */
676
679
681}
682
683
684/* ----------
685 * pg_get_viewdef - Mainly the same thing, but we
686 * only return the SELECT part of a view
687 * ----------
688 */
689Datum
691{
692 /* By OID */
694 int prettyFlags;
695 char *res;
696
697 prettyFlags = PRETTYFLAG_INDENT;
698
700
702 PG_RETURN_NULL();
703
705}
706
707
708Datum
710{
711 /* By OID */
714 int prettyFlags;
715 char *res;
716
718
720
722 PG_RETURN_NULL();
723
725}
726
727Datum
729{
730 /* By OID */
733 int prettyFlags;
734 char *res;
735
736 /* calling this implies we want pretty printing */
738
740
742 PG_RETURN_NULL();
743
745}
746
747Datum
749{
750 /* By qualified name */
752 int prettyFlags;
754 Oid viewoid;
755 char *res;
756
757 prettyFlags = PRETTYFLAG_INDENT;
758
759 /* Look up view name. Can't lock it - we might not have privileges. */
762
764
766 PG_RETURN_NULL();
767
769}
770
771
772Datum
774{
775 /* By qualified name */
778 int prettyFlags;
780 Oid viewoid;
781 char *res;
782
784
785 /* Look up view name. Can't lock it - we might not have privileges. */
788
790
792 PG_RETURN_NULL();
793
795}
796
797/*
798 * Common code for by-OID and by-name variants of pg_get_viewdef
799 */
800static char *
802{
804 char nulls[2];
809
810 /*
811 * Do this first so that string is alloc'd in outer context not SPI's.
812 */
814
815 /*
816 * Connect to SPI manager
817 */
818 SPI_connect();
819
820 /*
821 * On the first call prepare the plan to lookup pg_rewrite. We read
822 * pg_rewrite over the SPI manager instead of using the syscache to be
823 * checked for read access on pg_rewrite.
824 */
826 {
827 Oid argtypes[2];
829
830 argtypes[0] = OIDOID;
831 argtypes[1] = NAMEOID;
837 }
838
839 /*
840 * Get the pg_rewrite tuple for the view's SELECT rule
841 */
844 nulls[0] = ' ';
845 nulls[1] = ' ';
850 {
851 /*
852 * There is no tuple data available here, just keep the output buffer
853 * empty.
854 */
855 }
856 else
857 {
858 /*
859 * Get the rule's definition and put it into executor's memory
860 */
864 }
865
866 /*
867 * Disconnect from SPI manager
868 */
871
874
876}
877
878/* ----------
879 * pg_get_triggerdef - Get the definition of a trigger
880 * ----------
881 */
882Datum
884{
886 char *res;
887
889
891 PG_RETURN_NULL();
892
894}
895
896Datum
898{
901 char *res;
902
904
906 PG_RETURN_NULL();
907
909}
910
911static char *
913{
921 char *tgname;
922 char *tgoldtable;
923 char *tgnewtable;
925 bool isnull;
926
927 /*
928 * Fetch the pg_trigger tuple by the Oid of the trigger
929 */
931
933 Anum_pg_trigger_oid,
936
939
941
943 {
947 }
948
950
951 /*
952 * Start the trigger definition. Note that the trigger's name should never
953 * be schema-qualified, but the trigger rel's name may be.
954 */
956
960 quote_identifier(tgname));
961
968 else
970
972 {
974 findx++;
975 }
977 {
980 else
982 findx++;
983 }
985 {
988 else
990 findx++;
991 /* tgattr is first var-width field, so OK to access directly */
993 {
995
998 {
1000
1006 }
1007 }
1008 }
1010 {
1013 else
1015 findx++;
1016 }
1017
1018 /*
1019 * In non-pretty mode, always schema-qualify the target table name for
1020 * safety. In pretty mode, schema-qualify only if not visible.
1021 */
1023 pretty ?
1026
1028 {
1037 else
1039 }
1040
1042 tgrel->rd_att, &isnull);
1043 if (!isnull)
1045 else
1046 tgoldtable = NULL;
1048 tgrel->rd_att, &isnull);
1049 if (!isnull)
1051 else
1052 tgnewtable = NULL;
1054 {
1058 quote_identifier(tgoldtable));
1061 quote_identifier(tgnewtable));
1062 }
1063
1066 else
1068
1069 /* If the trigger has a WHEN qualification, add that */
1071 tgrel->rd_att, &isnull);
1072 if (!isnull)
1073 {
1074 Node *qual;
1075 char relkind;
1076 deparse_context context;
1080
1082
1084
1086
1087 /* Build minimal OLD and NEW RTEs for the rel */
1091 oldrte->relkind = relkind;
1098
1102 newrte->relkind = relkind;
1109
1110 /* Build two-element rtable */
1118
1119 /* Set up context with one-deep namespace stack */
1133
1135
1137 }
1138
1143
1145 {
1146 char *p;
1148
1150 tgrel->rd_att, &isnull);
1151 if (isnull)
1155 {
1159 /* advance p to next string embedded in tgargs */
1160 while (*p)
1161 p++;
1162 p++;
1163 }
1164 }
1165
1166 /* We deliberately do not put semi-colon at end */
1168
1169 /* Clean up */
1171
1173
1175}
1176
1177/* ----------
1178 * pg_get_indexdef - Get the definition of an index
1179 *
1180 * In the extended version, there is a colno argument as well as pretty bool.
1181 * if colno == 0, we want a complete index definition.
1182 * if colno > 0, we only want the Nth index key's variable or expression.
1183 *
1184 * Note that the SQL-function versions of this omit any info about the
1185 * index tablespace; this is intentional because pg_dump wants it that way.
1186 * However pg_get_indexdef_string() includes the index tablespace.
1187 * ----------
1188 */
1189Datum
1191{
1193 int prettyFlags;
1194 char *res;
1195
1196 prettyFlags = PRETTYFLAG_INDENT;
1197
1199 false, false,
1200 false, false,
1201 prettyFlags, true);
1202
1204 PG_RETURN_NULL();
1205
1207}
1208
1209Datum
1211{
1215 int prettyFlags;
1216 char *res;
1217
1219
1221 colno != 0, false,
1222 false, false,
1223 prettyFlags, true);
1224
1226 PG_RETURN_NULL();
1227
1229}
1230
1231/*
1232 * Internal version for use by ALTER TABLE.
1233 * Includes a tablespace clause in the result.
1234 * Returns a palloc'd C string; no pretty-printing.
1235 */
1236char *
1238{
1240 false, false,
1241 true, true,
1242 0, false);
1243}
1244
1245/* Internal version that just reports the key-column definitions */
1246char *
1248{
1249 int prettyFlags;
1250
1252
1254 true, true,
1255 false, false,
1256 prettyFlags, false);
1257}
1258
1259/* Internal version, extensible with flags to control its behavior */
1260char *
1262{
1265 int prettyFlags;
1266
1268
1271 false, false,
1272 prettyFlags, false);
1273}
1274
1275/*
1276 * Internal workhorse to decompile an index definition.
1277 *
1278 * This is now used for exclusion constraints as well: if excludeOps is not
1279 * NULL then it points to an array of exclusion operator OIDs.
1280 */
1281static char *
1286 int prettyFlags, bool missing_ok)
1287{
1288 /* might want a separate isConstraint parameter later */
1299 List *context;
1301 int keyno;
1311
1312 /*
1313 * Fetch the pg_index tuple by the Oid of the index
1314 */
1317 {
1318 if (missing_ok)
1321 }
1323
1326
1327 /* Must get indcollation, indclass, and indoption the hard way */
1329 Anum_pg_index_indcollation);
1331
1333 Anum_pg_index_indclass);
1335
1337 Anum_pg_index_indoption);
1339
1340 /*
1341 * Fetch the pg_class tuple of the index relation
1342 */
1347
1348 /*
1349 * Fetch the pg_am tuple of the index' access method
1350 */
1354 idxrelrec->relam);
1356
1357 /* Fetch the index AM's API struct */
1359
1360 /*
1361 * Get the index expressions, if any. (NOTE: we do not use the relcache
1362 * versions of the expressions and predicate, because we want to display
1363 * non-const-folded expressions.)
1364 */
1366 {
1369
1371 Anum_pg_index_indexprs);
1375 }
1376 else
1378
1380
1382
1383 /*
1384 * Start the index definition. Note that the index's name should never be
1385 * schema-qualified, but the indexed rel's name may be.
1386 */
1388
1390 {
1397 (prettyFlags & PRETTYFLAG_SCHEMA) ?
1401 else /* currently, must be EXCLUDE constraint */
1404 }
1405
1406 /*
1407 * Report the indexed attributes
1408 */
1411 {
1415
1416 /*
1417 * Ignore non-key attributes if told to.
1418 */
1420 break;
1421
1422 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1424 {
1427 }
1428
1429 if (!colno)
1432
1434 {
1435 /* Simple index column */
1438
1440 if (!colno || colno == keyno + 1)
1444 &keycolcollation);
1445 }
1446 else
1447 {
1448 /* expressional index */
1450
1455 /* Deparse */
1457 prettyFlags, 0);
1458 if (!colno || colno == keyno + 1)
1459 {
1460 /* Need parens if it's not a bare function call */
1463 else
1465 }
1468 }
1469
1470 /* Print additional decoration for (selected) key columns */
1472 (!colno || colno == keyno + 1))
1473 {
1478
1479 /* Add collation, if not default for column */
1483
1484 /* Add the operator class name, if not default */
1487
1489 {
1493 }
1494
1495 /* Add options if relevant */
1497 {
1498 /* if it supports sort ordering, report DESC and NULLS opts */
1500 {
1502 /* NULLS FIRST is the default in this case */
1505 }
1506 else
1507 {
1510 }
1511 }
1512
1513 /* Add the exclusion operator if relevant */
1517 keycoltype,
1518 keycoltype));
1519 }
1520 }
1521
1523 {
1525
1528
1529 /*
1530 * If it has options, append "WITH (options)"
1531 */
1534 {
1537 }
1538
1539 /*
1540 * Print tablespace, but only if requested
1541 */
1543 {
1545
1548 {
1553 }
1554 }
1555
1556 /*
1557 * If it's a partial index, decompile and append the predicate
1558 */
1560 {
1561 Node *node;
1564
1565 /* Convert text string to node tree */
1567 Anum_pg_index_indpred);
1571
1572 /* Deparse */
1574 prettyFlags, 0);
1577 else
1579 }
1580 }
1581
1582 /* Clean up */
1586
1588}
1589
1590/* ----------
1591 * pg_get_querydef
1592 *
1593 * Public entry point to deparse one query parsetree.
1594 * The pretty flags are determined by GET_PRETTY_FLAGS(pretty).
1595 *
1596 * The result is a palloc'd C string.
1597 * ----------
1598 */
1599char *
1601{
1603 int prettyFlags;
1604
1606
1608
1610 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
1611
1613}
1614
1615/*
1616 * pg_get_propgraphdef - get the definition of a property graph
1617 */
1618Datum
1620{
1627
1629
1632 PG_RETURN_NULL();
1633
1636
1641
1643
1646
1648
1651
1653}
1654
1655/*
1656 * Generates a VERTEX TABLES (...) or EDGE TABLES (...) clause. Pass in the
1657 * property graph relation OID and the element kind (vertex or edge). Result
1658 * is appended to buf.
1659 */
1660static void
1662{
1665 SysScanDesc scan;
1666 bool first;
1668
1670
1675
1677
1678 first = true;
1680 {
1683 Datum datum;
1684 bool isnull;
1685
1687 continue;
1688
1689 if (first)
1690 {
1692 first = false;
1693 }
1694 else
1696
1701 else
1705
1706 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgekey, RelationGetDescr(pgerel), &isnull);
1707 if (!isnull)
1708 {
1712 }
1713 else
1715
1717 {
1718 Datum srckey;
1719 Datum srcref;
1720 Datum destkey;
1721 Datum destref;
1724
1725 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgesrckey, RelationGetDescr(pgerel), &isnull);
1726 srckey = isnull ? 0 : datum;
1727 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgesrcref, RelationGetDescr(pgerel), &isnull);
1728 srcref = isnull ? 0 : datum;
1729 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgedestkey, RelationGetDescr(pgerel), &isnull);
1730 destkey = isnull ? 0 : datum;
1731 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgedestref, RelationGetDescr(pgerel), &isnull);
1732 destref = isnull ? 0 : datum;
1733
1739 if (srckey)
1740 {
1746 }
1747 else
1750
1756 if (destkey)
1757 {
1763 }
1764 else
1767 }
1768
1770 }
1771 if (!first)
1773
1774 systable_endscan(scan);
1776}
1777
1779{
1782};
1783
1784static int
1786{
1789
1791}
1792
1793/*
1794 * Generates label and properties list. Pass in the element OID, the element
1795 * alias, and the graph relation OID. Result is appended to buf.
1796 */
1797static void
1799{
1802 SysScanDesc scan;
1803 int count;
1806
1808
1813
1814 /*
1815 * We want to output the labels in a deterministic order. So we first
1816 * read all the data, then sort, then print it.
1817 */
1818 scan = systable_beginscan(pglrel, PropgraphElementLabelElementLabelIndexId, true, NULL, 1, scankey);
1819
1821 {
1824
1828
1830 }
1831
1832 systable_endscan(scan);
1834
1836
1837 /* Each element has at least one label. */
1838 Assert(count > 0);
1839
1840 /*
1841 * It is enough for the comparison function to compare just labels, since
1842 * all the labels of an element table should have distinct names.
1843 */
1845
1847 {
1849 {
1850 /* If the default label is the only label, don't print anything. */
1851 if (count != 1)
1853 }
1854 else
1856
1858 }
1859}
1860
1861/*
1862 * Helper function for make_propgraphdef_properties(): Sort (propname, expr)
1863 * pairs by name.
1864 */
1865static int
1867{
1872
1874}
1875
1876/*
1877 * Generates element table properties clause (PROPERTIES (...) or NO
1878 * PROPERTIES). Pass in label OID and element table OID. Result is appended
1879 * to buf.
1880 */
1881static void
1883{
1886 SysScanDesc scan;
1889
1891
1896
1897 /*
1898 * We want to output the properties in a deterministic order. So we first
1899 * read all the data, then sort, then print it.
1900 */
1901 scan = systable_beginscan(plprel, PropgraphLabelPropertyLabelPropIndexId, true, NULL, 1, scankey);
1902
1904 {
1907 bool isnull;
1908 char *tmp;
1909 Node *expr;
1911
1912 exprDatum = heap_getattr(tup, Anum_pg_propgraph_label_property_plpexpr, RelationGetDescr(plprel), &isnull);
1913 Assert(!isnull);
1915 expr = stringToNode(tmp);
1916 pfree(tmp);
1917
1919
1921 }
1922
1923 systable_endscan(scan);
1925
1927
1928 if (outlist)
1929 {
1930 List *context;
1932 bool first = true;
1933
1935
1937
1939 {
1943
1944 if (first)
1945 first = false;
1946 else
1948
1949 if (IsA(expr, Var) && strcmp(propname, get_attname(elrelid, castNode(Var, expr)->varattno, false)) == 0)
1951 else
1955 }
1956
1958 }
1959 else
1961}
1962
1963/*
1964 * pg_get_statisticsobjdef
1965 * Get the definition of an extended statistics object
1966 */
1967Datum
1969{
1971 char *res;
1972
1974
1976 PG_RETURN_NULL();
1977
1979}
1980
1981/*
1982 * Internal version for use by ALTER TABLE.
1983 * Returns a palloc'd C string; no pretty-printing.
1984 */
1985char *
1987{
1989}
1990
1991/*
1992 * pg_get_statisticsobjdef_columns
1993 * Get columns and expressions for an extended statistics object
1994 */
1995Datum
1997{
1999 char *res;
2000
2002
2004 PG_RETURN_NULL();
2005
2007}
2008
2009/*
2010 * Internal workhorse to decompile an extended statistics object.
2011 */
2012static char *
2014{
2018 int colno;
2020 ArrayType *arr;
2021 char *enabled;
2022 Datum datum;
2027 List *context;
2031 int ncolumns;
2032
2034
2036 {
2037 if (missing_ok)
2040 }
2041
2042 /* has the statistics expressions? */
2044
2046
2047 /*
2048 * Get the statistics expressions, if any. (NOTE: we do not use the
2049 * relcache versions of the expressions, because we want to display
2050 * non-const-folded expressions.)
2051 */
2053 {
2056
2062 }
2063 else
2064 exprs = NIL;
2065
2066 /* count the number of columns (attributes and expressions) */
2068
2070
2072 {
2077
2078 /*
2079 * Decode the stxkind column so that we know which stats types to
2080 * print.
2081 */
2084 arr = DatumGetArrayTypeP(datum);
2086 ARR_HASNULL(arr) ||
2090
2094
2096 {
2103
2104 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
2105 }
2106
2107 /*
2108 * If any option is disabled, then we'll need to append the types
2109 * clause to show which options are enabled. We omit the types clause
2110 * on purpose when all options are enabled, so a pg_dump/pg_restore
2111 * will create all statistics types on a newer postgres version, if
2112 * the statistics had all options enabled on the original version.
2113 *
2114 * But if the statistics is defined on just a single column, it has to
2115 * be an expression statistics. In that case we don't need to specify
2116 * kinds.
2117 */
2119 (ncolumns > 1))
2120 {
2122
2124
2126 {
2129 }
2130
2132 {
2135 }
2136
2139
2141 }
2142
2144 }
2145
2146 /* decode simple column references */
2148 {
2151
2152 if (colno > 0)
2154
2156
2158 }
2159
2161 statextrec->stxrelid);
2162
2164 {
2168
2170 prettyFlags, 0);
2171
2172 if (colno > 0)
2174
2175 /* Need parens if it's not a bare function call */
2178 else
2180
2181 colno++;
2182 }
2183
2187
2189
2191}
2192
2193/*
2194 * Generate text array of expressions for statistics object.
2195 */
2196Datum
2198{
2202 Datum datum;
2203 List *context;
2207 char *tmp;
2209
2211
2213 PG_RETURN_NULL();
2214
2215 /* Does the stats object have expressions? */
2217
2218 /* no expressions? we're done */
2220 {
2222 PG_RETURN_NULL();
2223 }
2224
2226
2227 /*
2228 * Get the statistics expressions, and deparse them into text values.
2229 */
2232 tmp = TextDatumGetCString(datum);
2234 pfree(tmp);
2235
2237 statextrec->stxrelid);
2238
2240 {
2244
2246 prettyFlags, 0);
2247
2248 astate = accumArrayResult(astate,
2250 false,
2251 TEXTOID,
2252 CurrentMemoryContext);
2253 }
2254
2256
2258}
2259
2260/*
2261 * pg_get_partkeydef
2262 *
2263 * Returns the partition key specification, ie, the following:
2264 *
2265 * { RANGE | LIST | HASH } (column opt_collation opt_opclass [, ...])
2266 */
2267Datum
2269{
2271 char *res;
2272
2274
2276 PG_RETURN_NULL();
2277
2279}
2280
2281/* Internal version that just reports the column definitions */
2282char *
2284{
2285 int prettyFlags;
2286
2288
2290}
2291
2292/*
2293 * Internal workhorse to decompile a partition key definition.
2294 */
2295static char *
2298{
2300 HeapTuple tuple;
2302 oidvector *partcollation;
2303 List *partexprs;
2305 List *context;
2306 Datum datum;
2308 int keyno;
2311
2314 {
2315 if (missing_ok)
2318 }
2319
2321
2323
2324 /* Must get partclass and partcollation the hard way */
2328
2332
2333
2334 /*
2335 * Get the expressions, if any. (NOTE: we do not use the relcache
2336 * versions of the expressions, because we want to display
2337 * non-const-folded expressions.)
2338 */
2340 {
2343
2348
2352
2354 }
2355 else
2356 partexprs = NIL;
2357
2360
2362
2364 {
2368 break;
2372 break;
2376 break;
2377 default:
2380 }
2381
2386 {
2391
2395 {
2396 /* Simple attribute reference */
2399
2404 &keycolcollation);
2405 }
2406 else
2407 {
2408 /* Expression */
2410
2415
2416 /* Deparse */
2418 prettyFlags, 0);
2419 /* Need parens if it's not a bare function call */
2422 else
2424
2427 }
2428
2429 /* Add collation, if not default for column */
2434
2435 /* Add the operator class name, if not default */
2438 }
2439
2442
2443 /* Clean up */
2444 ReleaseSysCache(tuple);
2445
2447}
2448
2449/*
2450 * pg_get_partition_constraintdef
2451 *
2452 * Returns partition constraint expression as a string for the input relation
2453 */
2454Datum
2456{
2459 int prettyFlags;
2460 List *context;
2462
2464
2465 /* Quick exit if no partition constraint */
2467 PG_RETURN_NULL();
2468
2469 /*
2470 * Deparse and return the constraint expression.
2471 */
2472 prettyFlags = PRETTYFLAG_INDENT;
2475 false, prettyFlags, 0);
2476
2478}
2479
2480/*
2481 * pg_get_partconstrdef_string
2482 *
2483 * Returns the partition constraint as a C-string for the input relation, with
2484 * the given alias. No pretty-printing.
2485 */
2486char *
2488{
2490 List *context;
2491
2494
2496}
2497
2498/*
2499 * pg_get_constraintdef
2500 *
2501 * Returns the definition for the constraint, ie, everything that needs to
2502 * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
2503 */
2504Datum
2506{
2508 int prettyFlags;
2509 char *res;
2510
2511 prettyFlags = PRETTYFLAG_INDENT;
2512
2514
2516 PG_RETURN_NULL();
2517
2519}
2520
2521Datum
2523{
2526 int prettyFlags;
2527 char *res;
2528
2530
2532
2534 PG_RETURN_NULL();
2535
2537}
2538
2539/*
2540 * Internal version that returns a full ALTER TABLE ... ADD CONSTRAINT command
2541 */
2542char *
2544{
2546}
2547
2548/*
2549 * As of 9.4, we now use an MVCC snapshot for this.
2550 */
2551static char *
2553 int prettyFlags, bool missing_ok)
2554{
2558 SysScanDesc scandesc;
2562
2564 Anum_pg_constraint_oid,
2567
2568 scandesc = systable_beginscan(relation,
2569 ConstraintOidIndexId,
2570 true,
2571 snapshot,
2572 1,
2573 scankey);
2574
2575 /*
2576 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2577 * via SearchSysCache, which works fine.
2578 */
2580
2581 UnregisterSnapshot(snapshot);
2582
2584 {
2585 if (missing_ok)
2586 {
2587 systable_endscan(scandesc);
2590 }
2592 }
2593
2595
2597
2599 {
2601 {
2602 /*
2603 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2604 * constraints, and other types of constraints don't inherit
2605 * anyway so it doesn't matter whether we say ONLY or not. Someday
2606 * we might need to let callers specify whether to put ONLY in the
2607 * command.
2608 */
2612 }
2613 else
2614 {
2615 /* Must be a domain constraint */
2620 }
2621 }
2622
2624 {
2626 {
2628 bool isnull;
2630
2631 /* Start off the constraint definition */
2633
2634 /* Fetch and build referencing-column list */
2636 Anum_pg_constraint_conkey);
2637
2638 /* If it is a temporal foreign key then it uses PERIOD. */
2640
2641 /* add foreign relation name */
2644 NIL));
2645
2646 /* Fetch and build referenced-column list */
2648 Anum_pg_constraint_confkey);
2649
2651
2653
2654 /* Add match type */
2656 {
2658 string = " MATCH FULL";
2659 break;
2661 string = " MATCH PARTIAL";
2662 break;
2664 string = "";
2665 break;
2666 default:
2668 conForm->confmatchtype);
2669 string = ""; /* keep compiler quiet */
2670 break;
2671 }
2673
2674 /* Add ON UPDATE and ON DELETE clauses, if needed */
2676 {
2679 break;
2681 string = "RESTRICT";
2682 break;
2684 string = "CASCADE";
2685 break;
2687 string = "SET NULL";
2688 break;
2690 string = "SET DEFAULT";
2691 break;
2692 default:
2694 conForm->confupdtype);
2696 break;
2697 }
2698 if (string)
2700
2702 {
2705 break;
2707 string = "RESTRICT";
2708 break;
2710 string = "CASCADE";
2711 break;
2713 string = "SET NULL";
2714 break;
2716 string = "SET DEFAULT";
2717 break;
2718 default:
2720 conForm->confdeltype);
2722 break;
2723 }
2724 if (string)
2726
2727 /*
2728 * Add columns specified to SET NULL or SET DEFAULT if
2729 * provided.
2730 */
2732 Anum_pg_constraint_confdelsetcols, &isnull);
2733 if (!isnull)
2734 {
2738 }
2739
2740 break;
2741 }
2744 {
2749
2750 /* Start off the constraint definition */
2753 else
2755
2757
2764
2766
2767 /* Fetch and build target column list */
2769 Anum_pg_constraint_conkey);
2770
2774
2776
2777 /* Build including column list (from pg_index.indkeys) */
2779 Anum_pg_index_indnatts);
2781 {
2782 Datum cols;
2783 Datum *keys;
2784 int nKeys;
2786
2788
2790 Anum_pg_index_indkey);
2791
2793 &keys, NULL, &nKeys);
2794
2796 {
2798
2804 }
2805
2807 }
2809
2810 /* XXX why do we only print these bits if fullCommand? */
2812 {
2815
2817 {
2820 }
2821
2822 /*
2823 * Print the tablespace, unless it's the database default.
2824 * This is to help ALTER TABLE usage of this facility,
2825 * which needs this behavior to recreate exact catalog
2826 * state.
2827 */
2832 }
2833
2834 break;
2835 }
2837 {
2841 Node *expr;
2842 List *context;
2843
2844 /* Fetch constraint expression in parsetree form */
2846 Anum_pg_constraint_conbin);
2847
2850
2851 /* Set up deparsing context for Var nodes in constraint */
2853 {
2854 /* relation constraint */
2856 conForm->conrelid);
2857 }
2858 else
2859 {
2860 /* domain constraint --- can't have Vars */
2861 context = NIL;
2862 }
2863
2865 prettyFlags, 0);
2866
2867 /*
2868 * Now emit the constraint definition, adding NO INHERIT if
2869 * necessary.
2870 *
2871 * There are cases where the constraint expression will be
2872 * fully parenthesized and we don't need the outer parens ...
2873 * but there are other cases where we do need 'em. Be
2874 * conservative for now.
2875 *
2876 * Note that simply checking for leading '(' and trailing ')'
2877 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2878 */
2880 consrc,
2882 break;
2883 }
2885 {
2887 {
2889
2891
2897 }
2899 {
2900 /* conkey is null for domain not-null constraints */
2902 }
2903 break;
2904 }
2905
2907
2908 /*
2909 * There isn't an ALTER TABLE syntax for creating a user-defined
2910 * constraint trigger, but it seems better to print something than
2911 * throw an error; if we throw error then this function couldn't
2912 * safely be applied to all rows of pg_constraint.
2913 */
2915 break;
2917 {
2920 Datum *elems;
2921 int nElems;
2923 Oid *operators;
2924
2925 /* Extract operator OIDs from the pg_constraint tuple */
2927 Anum_pg_constraint_conexclop);
2928
2930 &elems, NULL, &nElems);
2931
2935
2936 /* pg_get_indexdef_worker does the rest */
2937 /* suppress tablespace because pg_dump wants it that way */
2939 pg_get_indexdef_worker(indexOid,
2940 0,
2941 operators,
2942 false,
2943 false,
2944 false,
2945 false,
2946 prettyFlags,
2947 false));
2948 break;
2949 }
2950 default:
2952 break;
2953 }
2954
2959
2960 /* Validated status is irrelevant when the constraint is NOT ENFORCED. */
2965
2966 /* Cleanup */
2967 systable_endscan(scandesc);
2969
2971}
2972
2973
2974/*
2975 * Convert an int16[] Datum into a comma-separated list of column names
2976 * for the indicated relation; append the list to buf. Returns the number
2977 * of keys.
2978 */
2979static int
2982{
2983 Datum *keys;
2984 int nKeys;
2986
2987 /* Extract data from array of int16 */
2989 &keys, NULL, &nKeys);
2990
2992 {
2994
2996
2999 else
3003 }
3004
3005 return nKeys;
3006}
3007
3008
3009/* ----------
3010 * pg_get_expr - Decompile an expression tree
3011 *
3012 * Input: an expression tree in nodeToString form, and a relation OID
3013 *
3014 * Output: reverse-listed expression
3015 *
3016 * Currently, the expression can only refer to a single relation, namely
3017 * the one specified by the second parameter. This is sufficient for
3018 * partial indexes, column default expressions, etc. We also support
3019 * Var-free expressions, for which the OID can be InvalidOid.
3020 *
3021 * If the OID is nonzero but not actually valid, don't throw an error,
3022 * just return NULL. This is a bit questionable, but it's what we've
3023 * done historically, and it can help avoid unwanted failures when
3024 * examining catalog entries for just-deleted relations.
3025 *
3026 * We expect this function to work, or throw a reasonably clean error,
3027 * for any node tree that can appear in a catalog pg_node_tree column.
3028 * Query trees, such as those appearing in pg_rewrite.ev_action, are
3029 * not supported. Nor are expressions in more than one relation, which
3030 * can appear in places like pg_rewrite.ev_qual.
3031 * ----------
3032 */
3033Datum
3035{
3039 int prettyFlags;
3040
3041 prettyFlags = PRETTYFLAG_INDENT;
3042
3046 else
3047 PG_RETURN_NULL();
3048}
3049
3050Datum
3052{
3057 int prettyFlags;
3058
3060
3064 else
3065 PG_RETURN_NULL();
3066}
3067
3070{
3071 Node *node;
3073 Relids relids;
3074 List *context;
3078
3079 /* Convert input pg_node_tree (really TEXT) object to C string */
3081
3082 /* Convert expression to node tree */
3084
3086
3087 /*
3088 * Throw error if the input is a querytree rather than an expression tree.
3089 * While we could support queries here, there seems no very good reason
3090 * to. In most such catalog columns, we'll see a List of Query nodes, or
3091 * even nested Lists, so drill down to a non-List node before checking.
3092 */
3093 tst = node;
3100
3101 /*
3102 * Throw error if the expression contains Vars we won't be able to
3103 * deparse.
3104 */
3107 {
3112 }
3113 else
3114 {
3119 }
3120
3121 /*
3122 * Prepare deparse context if needed. If we are deparsing with a relid,
3123 * we need to transiently open and lock the rel, to make sure it won't go
3124 * away underneath us. (set_relation_column_names would lock it anyway,
3125 * so this isn't really introducing any new behavior.)
3126 */
3128 {
3133 }
3134 else
3135 context = NIL;
3136
3137 /* Deparse */
3139 prettyFlags, 0);
3140
3143
3145}
3146
3147
3148/* ----------
3149 * pg_get_userbyid - Get a user name by roleid and
3150 * fallback to 'unknown (OID=n)'
3151 * ----------
3152 */
3153Datum
3155{
3160
3161 /*
3162 * Allocate space for the result
3163 */
3166
3167 /*
3168 * Get the pg_authid entry and print the result
3169 */
3172 {
3176 }
3177 else
3179
3181}
3182
3183
3184/*
3185 * pg_get_serial_sequence
3186 * Get the name of the sequence used by an identity or serial column,
3187 * formatted suitably for passing to setval, nextval or currval.
3188 * First parameter is not treated as double-quoted, second parameter
3189 * is --- see documentation for reason.
3190 */
3191Datum
3193{
3197 Oid tableOid;
3203 SysScanDesc scan;
3205
3206 /* Look up table name. Can't lock it - we might not have privileges. */
3209
3210 /* Get the number of the column */
3212
3219
3220 /* Search the dependency table for the dependent sequence */
3222
3223 ScanKeyInit(&key[0],
3227 ScanKeyInit(&key[1],
3228 Anum_pg_depend_refobjid,
3230 ObjectIdGetDatum(tableOid));
3231 ScanKeyInit(&key[2],
3235
3237 NULL, 3, key);
3238
3240 {
3242
3243 /*
3244 * Look for an auto dependency (serial column) or internal dependency
3245 * (identity column) of a sequence on a column. (We need the relkind
3246 * test because indexes can also have auto dependencies on columns.)
3247 */
3249 deprec->objsubid == 0 &&
3253 {
3255 break;
3256 }
3257 }
3258
3259 systable_endscan(scan);
3261
3263 {
3265
3267
3269 }
3270
3271 PG_RETURN_NULL();
3272}
3273
3274
3275/*
3276 * pg_get_functiondef
3277 * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
3278 * the specified function.
3279 *
3280 * Note: if you change the output format of this function, be careful not
3281 * to break psql's rules (in \ef and \sf) for identifying the start of the
3282 * function body. To wit: the function body starts on a line that begins with
3283 * "AS ", "BEGIN ", or "RETURN ", and no preceding line will look like that.
3284 */
3285Datum
3287{
3292 Form_pg_proc proc;
3294 Datum tmp;
3295 bool isnull;
3296 const char *prosrc;
3301
3303
3304 /* Look up the function */
3307 PG_RETURN_NULL();
3308
3311
3316
3318
3319 /*
3320 * We always qualify the function name, to ensure the right function gets
3321 * replaced.
3322 */
3330 {
3334 }
3335
3337
3340
3341 /* Emit some miscellaneous options on one line */
3343
3346 switch (proc->provolatile)
3347 {
3350 break;
3353 break;
3355 break;
3356 }
3357
3358 switch (proc->proparallel)
3359 {
3362 break;
3365 break;
3367 break;
3368 }
3369
3370 if (proc->proisstrict)
3372 if (proc->prosecdef)
3374 if (proc->proleakproof)
3376
3377 /* This code for the default cost and rows should match functioncmds.c */
3379 proc->prolang == ClanguageId)
3380 procost = 1;
3381 else
3382 procost = 100;
3385
3386 if (proc->prorows > 0 && proc->prorows != 1000)
3388
3389 if (proc->prosupport)
3390 {
3391 Oid argtypes[1];
3392
3393 /*
3394 * We should qualify the support function's name if it wouldn't be
3395 * resolved by lookup in the current search path.
3396 */
3397 argtypes[0] = INTERNALOID;
3399 generate_function_name(proc->prosupport, 1,
3400 NIL, argtypes,
3402 }
3403
3406
3407 /* Emit any proconfig options, one per line */
3409 if (!isnull)
3410 {
3413
3417
3419 {
3420 Datum d;
3421
3423 -1 /* varlenarray */ ,
3424 -1 /* TEXT's typlen */ ,
3425 false /* TEXT's typbyval */ ,
3427 &isnull);
3428 if (!isnull)
3429 {
3431 char *pos;
3432
3435 continue;
3436 *pos++ = '\0';
3437
3440
3441 /*
3442 * Variables that are marked GUC_LIST_QUOTE were already fully
3443 * quoted by flatten_set_variable_args() before they were put
3444 * into the proconfig array. However, because the quoting
3445 * rules used there aren't exactly like SQL's, we have to
3446 * break the list value apart and then quote the elements as
3447 * string literals. (The elements may be double-quoted as-is,
3448 * but we can't just feed them to the SQL parser; it would do
3449 * the wrong thing with elements that are zero-length or
3450 * longer than NAMEDATALEN.) Also, we need a special case for
3451 * empty lists.
3452 *
3453 * Variables that are not so marked should just be emitted as
3454 * simple string literals. If the variable is not known to
3455 * guc.c, we'll do that; this makes it unsafe to use
3456 * GUC_LIST_QUOTE for extension variables.
3457 */
3459 {
3462
3463 /* Parse string into list of identifiers */
3465 {
3466 /* this shouldn't fail really */
3468 }
3469 /* Special case: represent an empty list as NULL */
3473 {
3475
3479 }
3480 }
3481 else
3484 }
3485 }
3486 }
3487
3488 /* And finally the function definition ... */
3491 {
3493 }
3494 else
3495 {
3497
3499 if (!isnull)
3500 {
3503 }
3504
3506 prosrc = TextDatumGetCString(tmp);
3507
3508 /*
3509 * We always use dollar quoting. Figure out a suitable delimiter.
3510 *
3511 * Since the user is likely to be editing the function body string, we
3512 * shouldn't use a short delimiter that he might easily create a
3513 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3514 * if needed.
3515 */
3522
3526 }
3527
3529
3531
3533}
3534
3535/*
3536 * pg_get_function_arguments
3537 * Get a nicely-formatted list of arguments for a function.
3538 * This is everything that would go between the parentheses in
3539 * CREATE FUNCTION.
3540 */
3541Datum
3543{
3547
3550 PG_RETURN_NULL();
3551
3553
3555
3557
3559}
3560
3561/*
3562 * pg_get_function_identity_arguments
3563 * Get a formatted list of arguments for a function.
3564 * This is everything that would go between the parentheses in
3565 * ALTER FUNCTION, etc. In particular, don't print defaults.
3566 */
3567Datum
3569{
3573
3576 PG_RETURN_NULL();
3577
3579
3581
3583
3585}
3586
3587/*
3588 * pg_get_function_result
3589 * Get a nicely-formatted version of the result type of a function.
3590 * This is what would appear after RETURNS in CREATE FUNCTION.
3591 */
3592Datum
3594{
3598
3601 PG_RETURN_NULL();
3602
3604 {
3606 PG_RETURN_NULL();
3607 }
3608
3610
3612
3614
3616}
3617
3618/*
3619 * Guts of pg_get_function_result: append the function's return type
3620 * to the specified buffer.
3621 */
3622static void
3624{
3628
3630
3631 if (proc->proretset)
3632 {
3633 /* It might be a table function; try to print the arguments */
3638 else
3640 }
3641
3643 {
3644 /* Not a table function, so do the normal thing */
3645 if (proc->proretset)
3648 }
3649
3651}
3652
3653/*
3654 * Common code for pg_get_function_arguments and pg_get_function_result:
3655 * append the desired subset of arguments to buf. We print only TABLE
3656 * arguments when print_table_args is true, and all the others when it's false.
3657 * We print argument defaults only if print_defaults is true.
3658 * Function return value is the number of arguments printed.
3659 */
3660static int
3663{
3665 int numargs;
3666 Oid *argtypes;
3667 char **argnames;
3676
3678 &argtypes, &argnames, &argmodes);
3679
3680 nlackdefaults = numargs;
3682 {
3684 bool isnull;
3685
3688 &isnull);
3689 if (!isnull)
3690 {
3692
3697 /* nlackdefaults counts only *input* arguments lacking defaults */
3699 }
3700 }
3701
3702 /* Check for special treatment of ordered-set aggregates */
3704 {
3707
3711 proc->oid);
3716 }
3717
3718 argsprinted = 0;
3719 inputargno = 0;
3721 {
3727
3729 {
3731
3732 /*
3733 * For procedures, explicitly mark all argument modes, so as
3734 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3735 */
3738 else
3741 break;
3745 break;
3749 break;
3753 break;
3757 break;
3758 default:
3762 break;
3763 }
3766
3768 continue;
3769
3771 {
3775 }
3778
3780 if (argname && argname[0])
3784 {
3785 Node *expr;
3786
3790
3793 }
3794 argsprinted++;
3795
3796 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3798 {
3799 i--;
3800 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3802 }
3803 }
3804
3806}
3807
3808static bool
3810{
3815}
3816
3817/*
3818 * Append used transformed types to specified buffer
3819 */
3820static void
3822{
3823 Oid *trftypes;
3825
3828 {
3830
3833 {
3837 }
3839 }
3840}
3841
3842/*
3843 * Get textual representation of a function argument's default value. The
3844 * second argument of this function is the argument number among all arguments
3845 * (i.e. proallargtypes, *not* proargtypes), starting with 1, because that's
3846 * how information_schema.sql uses it.
3847 */
3848Datum
3850{
3854 Form_pg_proc proc;
3855 int numargs;
3856 Oid *argtypes;
3857 char **argnames;
3861 Node *node;
3865 bool isnull;
3867
3870 PG_RETURN_NULL();
3871
3874 {
3876 PG_RETURN_NULL();
3877 }
3878
3879 nth_inputarg = 0;
3882 nth_inputarg++;
3883
3886 &isnull);
3887 if (isnull)
3888 {
3890 PG_RETURN_NULL();
3891 }
3892
3896
3898
3899 /*
3900 * Calculate index into proargdefaults: proargdefaults corresponds to the
3901 * last N input arguments, where N = pronargdefaults.
3902 */
3904
3906 {
3908 PG_RETURN_NULL();
3909 }
3912
3914
3916}
3917
3918static void
3920{
3921 int numargs;
3922 Oid *argtypes;
3923 char **argnames;
3926 Datum tmp;
3927 Node *n;
3928
3931 &argtypes, &argnames, &argmodes);
3932 dpns.numargs = numargs;
3933 dpns.argnames = argnames;
3934
3937
3939 {
3940 List *stmts;
3942
3944
3946
3948 {
3950
3951 /* It seems advisable to get at least AccessShareLock on rels */
3957 }
3958
3960 }
3961 else
3962 {
3964
3965 /* It seems advisable to get at least AccessShareLock on rels */
3968 0, WRAP_COLUMN_DEFAULT, 0);
3969 }
3970}
3971
3972Datum
3974{
3978 bool isnull;
3979
3981
3982 /* Look up the function */
3985 PG_RETURN_NULL();
3986
3988 if (isnull)
3989 {
3991 PG_RETURN_NULL();
3992 }
3993
3995
3997
3999}
4000
4001
4002/*
4003 * deparse_expression - General utility for deparsing expressions
4004 *
4005 * calls deparse_expression_pretty with all prettyPrinting disabled
4006 */
4007char *
4010{
4012 showimplicit, 0, 0);
4013}
4014
4015/* ----------
4016 * deparse_expression_pretty - General utility for deparsing expressions
4017 *
4018 * expr is the node tree to be deparsed. It must be a transformed expression
4019 * tree (ie, not the raw output of gram.y).
4020 *
4021 * dpcontext is a list of deparse_namespace nodes representing the context
4022 * for interpreting Vars in the node tree. It can be NIL if no Vars are
4023 * expected.
4024 *
4025 * forceprefix is true to force all Vars to be prefixed with their table names.
4026 *
4027 * showimplicit is true to force all implicit casts to be shown explicitly.
4028 *
4029 * Tries to pretty up the output according to prettyFlags and startIndent.
4030 *
4031 * The result is a palloc'd string.
4032 * ----------
4033 */
4034static char *
4038{
4040 deparse_context context;
4041
4049 context.prettyFlags = prettyFlags;
4056
4058
4060}
4061
4062/* ----------
4063 * deparse_context_for - Build deparse context for a single relation
4064 *
4065 * Given the reference name (alias) and OID of a relation, build deparsing
4066 * context for an expression referencing only that relation (as varno 1,
4067 * varlevelsup 0). This is sufficient for many uses of deparse_expression.
4068 * ----------
4069 */
4070List *
4072{
4075
4077
4078 /* Build a minimal RTE for the rel */
4081 rte->relid = relid;
4089
4090 /* Build one-element rtable */
4097
4098 /* Return a one-deep namespace stack */
4100}
4101
4102/*
4103 * deparse_context_for_plan_tree - Build deparse context for a Plan tree
4104 *
4105 * When deparsing an expression in a Plan tree, we use the plan's rangetable
4106 * to resolve names of simple Vars. The initialization of column names for
4107 * this is rather expensive if the rangetable is large, and it'll be the same
4108 * for every expression in the Plan tree; so we do it just once and re-use
4109 * the result of this function for each expression. (Note that the result
4110 * is not usable until set_deparse_context_plan() is applied to it.)
4111 *
4112 * In addition to the PlannedStmt, pass the per-RTE alias names
4113 * assigned by a previous call to select_rtable_names_for_explain.
4114 */
4115List *
4117{
4119
4121
4122 /* Initialize fields that stay the same across the whole plan tree */
4124 dpns->rtable_names = rtable_names;
4128 {
4129 /* Set up the array, indexed by child relid */
4132
4136 {
4139
4143 }
4144 }
4145 else
4147
4148 /*
4149 * Set up column name aliases, ignoring any join RTEs; they don't matter
4150 * because plan trees don't contain any join alias Vars.
4151 */
4153
4154 /* Return a one-deep namespace stack */
4156}
4157
4158/*
4159 * set_deparse_context_plan - Specify Plan node containing expression
4160 *
4161 * When deparsing an expression in a Plan tree, we might have to resolve
4162 * OUTER_VAR, INNER_VAR, or INDEX_VAR references. To do this, the caller must
4163 * provide the parent Plan node. Then OUTER_VAR and INNER_VAR references
4164 * can be resolved by drilling down into the left and right child plans.
4165 * Similarly, INDEX_VAR references can be resolved by reference to the
4166 * indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
4167 * ForeignScan and CustomScan nodes. (Note that we don't currently support
4168 * deparsing of indexquals in regular IndexScan or BitmapIndexScan nodes;
4169 * for those, we can only deparse the indexqualorig fields, which won't
4170 * contain INDEX_VAR Vars.)
4171 *
4172 * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
4173 * the most-closely-nested first. This is needed to resolve PARAM_EXEC
4174 * Params. Note we assume that all the Plan nodes share the same rtable.
4175 *
4176 * For a ModifyTable plan, we might also need to resolve references to OLD/NEW
4177 * variables in the RETURNING list, so we copy the alias names of the OLD and
4178 * NEW rows from the ModifyTable plan node.
4179 *
4180 * Once this function has been called, deparse_expression() can be called on
4181 * subsidiary expression(s) of the specified Plan node. To deparse
4182 * expressions of a different Plan node in the same Plan tree, re-call this
4183 * function to identify the new parent Plan node.
4184 *
4185 * The result is the same List passed in; this is a notational convenience.
4186 */
4187List *
4189{
4191
4192 /* Should always have one-entry namespace list for Plan deparsing */
4195
4196 /* Set our attention on the specific plan node passed in */
4197 dpns->ancestors = ancestors;
4199
4200 /* For ModifyTable, set aliases for OLD and NEW in RETURNING */
4202 {
4205 }
4206
4208}
4209
4210/*
4211 * select_rtable_names_for_explain - Select RTE aliases for EXPLAIN
4212 *
4213 * Determine the relation aliases we'll use during an EXPLAIN operation.
4214 * This is just a frontend to set_rtable_names. We have to expose the aliases
4215 * to EXPLAIN because EXPLAIN needs to know the right alias names to print.
4216 */
4217List *
4219{
4221
4223 dpns.rtable = rtable;
4228 /* We needn't bother computing column aliases yet */
4229
4231}
4232
4233/*
4234 * set_rtable_names: select RTE aliases to be used in printing a query
4235 *
4236 * We fill in dpns->rtable_names with a list of names that is one-for-one with
4237 * the already-filled dpns->rtable list. Each RTE name is unique among those
4238 * in the new namespace plus any ancestor namespaces listed in
4239 * parent_namespaces.
4240 *
4241 * If rels_used isn't NULL, only RTE indexes listed in it are given aliases.
4242 *
4243 * Note that this function is only concerned with relation names, not column
4244 * names.
4245 */
4246static void
4249{
4251 HTAB *names_hash;
4253 bool found;
4254 int rtindex;
4256
4258 /* nothing more to do if empty rtable */
4260 return;
4261
4262 /*
4263 * We use a hash table to hold known names, so that this process is O(N)
4264 * not O(N^2) for N names.
4265 */
4271 &hash_ctl,
4273
4274 /* Preload the hash table with names appearing in parent_namespaces */
4276 {
4279
4281 {
4283
4285 continue;
4287 oldname,
4288 HASH_ENTER,
4289 &found);
4290 /* we do not complain about duplicate names in parent namespaces */
4291 hentry->counter = 0;
4292 }
4293 }
4294
4295 /* Now we can scan the rtable */
4296 rtindex = 1;
4298 {
4300 char *refname;
4301
4302 /* Just in case this takes an unreasonable amount of time ... */
4303 CHECK_FOR_INTERRUPTS();
4304
4306 {
4307 /* Ignore unreferenced RTE */
4308 refname = NULL;
4309 }
4311 {
4312 /* If RTE has a user-defined alias, prefer that */
4313 refname = rte->alias->aliasname;
4314 }
4316 {
4317 /* Use the current actual name of the relation */
4319 }
4321 {
4322 /* Unnamed join has no refname */
4323 refname = NULL;
4324 }
4325 else
4326 {
4327 /* Otherwise use whatever the parser assigned */
4328 refname = rte->eref->aliasname;
4329 }
4330
4331 /*
4332 * If the selected name isn't unique, append digits to make it so, and
4333 * make a new hash entry for it once we've got a unique name. For a
4334 * very long input name, we might have to truncate to stay within
4335 * NAMEDATALEN.
4336 */
4337 if (refname)
4338 {
4340 refname,
4341 HASH_ENTER,
4342 &found);
4343 if (found)
4344 {
4345 /* Name already in use, must choose a new one */
4349
4350 do
4351 {
4353 for (;;)
4354 {
4358 break;
4359 /* drop chars from refname to keep all the digits */
4361 refnamelen - 1);
4362 }
4364 modname,
4365 HASH_ENTER,
4366 &found);
4367 } while (found);
4369 refname = modname;
4370 }
4371 else
4372 {
4373 /* Name not previously used, need only initialize hentry */
4374 hentry->counter = 0;
4375 }
4376 }
4377
4379 rtindex++;
4380 }
4381
4382 hash_destroy(names_hash);
4383}
4384
4385/*
4386 * set_deparse_for_query: set up deparse_namespace for deparsing a Query tree
4387 *
4388 * For convenience, this is defined to initialize the deparse_namespace struct
4389 * from scratch.
4390 */
4391static void
4394{
4397
4398 /* Initialize *dpns and fill rtable/ctes links */
4404 dpns->ret_old_alias = query->returningOldAlias;
4405 dpns->ret_new_alias = query->returningNewAlias;
4406
4407 /* Assign a unique relation alias to each RTE */
4409
4410 /* Initialize dpns->rtable_columns to contain zeroed structs */
4415
4416 /* If it's a utility query, it won't have a jointree */
4418 {
4419 /* Detect whether global uniqueness of USING names is needed */
4420 dpns->unique_using =
4422
4423 /*
4424 * Select names for columns merged by USING, via a recursive pass over
4425 * the query jointree.
4426 */
4428 }
4429
4430 /*
4431 * Now assign remaining column aliases for each RTE. We do this in a
4432 * linear scan of the rtable, so as to process RTEs whether or not they
4433 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4434 * etc). JOIN RTEs must be processed after their children, but this is
4435 * okay because they appear later in the rtable list than their children
4436 * (cf Asserts in identify_join_columns()).
4437 */
4439 {
4442
4445 else
4447 }
4448}
4449
4450/*
4451 * set_simple_column_names: fill in column aliases for non-query situations
4452 *
4453 * This handles EXPLAIN and cases where we only have relation RTEs. Without
4454 * a join tree, we can't do anything smart about join RTEs, but we don't
4455 * need to, because EXPLAIN should never see join alias Vars anyway.
4456 * If we find a join RTE we'll just skip it, leaving its deparse_columns
4457 * struct all-zero. If somehow we try to deparse a join alias Var, we'll
4458 * error out cleanly because the struct's num_cols will be zero.
4459 */
4460static void
4462{
4465
4466 /* Initialize dpns->rtable_columns to contain zeroed structs */
4471
4472 /* Assign unique column aliases within each non-join RTE */
4474 {
4477
4480 }
4481}
4482
4483/*
4484 * has_dangerous_join_using: search jointree for unnamed JOIN USING
4485 *
4486 * Merged columns of a JOIN USING may act differently from either of the input
4487 * columns, either because they are merged with COALESCE (in a FULL JOIN) or
4488 * because an implicit coercion of the underlying input column is required.
4489 * In such a case the column must be referenced as a column of the JOIN not as
4490 * a column of either input. And this is problematic if the join is unnamed
4491 * (alias-less): we cannot qualify the column's name with an RTE name, since
4492 * there is none. (Forcibly assigning an alias to the join is not a solution,
4493 * since that will prevent legal references to tables below the join.)
4494 * To ensure that every column in the query is unambiguously referenceable,
4495 * we must assign such merged columns names that are globally unique across
4496 * the whole query, aliasing other columns out of the way as necessary.
4497 *
4498 * Because the ensuing re-aliasing is fairly damaging to the readability of
4499 * the query, we don't do this unless we have to. So, we must pre-scan
4500 * the join tree to see if we have to, before starting set_using_names().
4501 */
4502static bool
4504{
4506 {
4507 /* nothing to do here */
4508 }
4510 {
4513
4515 {
4517 return true;
4518 }
4519 }
4521 {
4523
4524 /* Is it an unnamed JOIN with USING? */
4526 {
4527 /*
4528 * Yes, so check each join alias var to see if any of them are not
4529 * simple references to underlying columns. If so, we have a
4530 * dangerous situation and must pick unique aliases.
4531 */
4533
4534 /* We need only examine the merged columns */
4536 {
4538
4540 return true;
4541 }
4542 }
4543
4544 /* Nope, but inspect children */
4546 return true;
4548 return true;
4549 }
4550 else
4553 return false;
4554}
4555
4556/*
4557 * set_using_names: select column aliases to be used for merged USING columns
4558 *
4559 * We do this during a recursive descent of the query jointree.
4560 * dpns->unique_using must already be set to determine the global strategy.
4561 *
4562 * Column alias info is saved in the dpns->rtable_columns list, which is
4563 * assumed to be filled with pre-zeroed deparse_columns structs.
4564 *
4565 * parentUsing is a list of all USING aliases assigned in parent joins of
4566 * the current jointree node. (The passed-in list must not be modified.)
4567 *
4568 * Note that we do not use per-deparse_columns hash tables in this function.
4569 * The number of names that need to be assigned should be small enough that
4570 * we don't need to trouble with that.
4571 */
4572static void
4574{
4576 {
4577 /* nothing to do now */
4578 }
4580 {
4583
4586 }
4588 {
4592 int *leftattnos;
4593 int *rightattnos;
4598
4599 /* Get info about the shape of the join */
4601 leftattnos = colinfo->leftattnos;
4602 rightattnos = colinfo->rightattnos;
4603
4604 /* Look up the not-yet-filled-in child deparse_columns structs */
4607
4608 /*
4609 * If this join is unnamed, then we cannot substitute new aliases at
4610 * this level, so any name requirements pushed down to here must be
4611 * pushed down again to the children.
4612 */
4614 {
4616 {
4618
4620 continue;
4621
4622 /* Push down to left column, unless it's a system column */
4624 {
4627 }
4628
4629 /* Same on the righthand side */
4631 {
4634 }
4635 }
4636 }
4637
4638 /*
4639 * If there's a USING clause, select the USING column names and push
4640 * those names down to the children. We have two strategies:
4641 *
4642 * If dpns->unique_using is true, we force all USING names to be
4643 * unique across the whole query level. In principle we'd only need
4644 * the names of dangerous USING columns to be globally unique, but to
4645 * safely assign all USING names in a single pass, we have to enforce
4646 * the same uniqueness rule for all of them. However, if a USING
4647 * column's name has been pushed down from the parent, we should use
4648 * it as-is rather than making a uniqueness adjustment. This is
4649 * necessary when we're at an unnamed join, and it creates no risk of
4650 * ambiguity. Also, if there's a user-written output alias for a
4651 * merged column, we prefer to use that rather than the input name;
4652 * this simplifies the logic and seems likely to lead to less aliasing
4653 * overall.
4654 *
4655 * If dpns->unique_using is false, we only need USING names to be
4656 * unique within their own join RTE. We still need to honor
4657 * pushed-down names, though.
4658 *
4659 * Though significantly different in results, these two strategies are
4660 * implemented by the same code, with only the difference of whether
4661 * to put assigned names into dpns->using_names.
4662 */
4664 {
4665 /* Copy the input parentUsing list so we don't modify it */
4666 parentUsing = list_copy(parentUsing);
4667
4668 /* USING names must correspond to the first join output columns */
4670 i = 0;
4672 {
4674
4675 /* Assert it's a merged column */
4677
4678 /* Adopt passed-down name if any, else select unique name */
4681 else
4682 {
4683 /* Prefer user-written output alias if any */
4686 /* Make it appropriately unique */
4690 colname);
4691 /* Save it as output column name, too */
4693 }
4694
4695 /* Remember selected names for use later */
4697 parentUsing = lappend(parentUsing, colname);
4698
4699 /* Push down to left column, unless it's a system column */
4701 {
4704 }
4705
4706 /* Same on the righthand side */
4708 {
4711 }
4712
4713 i++;
4714 }
4715 }
4716
4717 /* Mark child deparse_columns structs with correct parentUsing info */
4718 leftcolinfo->parentUsing = parentUsing;
4719 rightcolinfo->parentUsing = parentUsing;
4720
4721 /* Now recursively assign USING column names in children */
4724 }
4725 else
4728}
4729
4730/*
4731 * set_relation_column_names: select column aliases for a non-join RTE
4732 *
4733 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4734 * If any colnames entries are already filled in, those override local
4735 * choices.
4736 */
4737static void
4740{
4741 int ncolumns;
4747
4748 /*
4749 * Construct an array of the current "real" column names of the RTE.
4750 * real_colnames[] will be indexed by physical column number, with NULL
4751 * entries for dropped columns.
4752 */
4754 {
4755 /* Relation --- look to the system catalogs for up-to-date info */
4756 Relation rel;
4757 TupleDesc tupdesc;
4758
4760 tupdesc = RelationGetDescr(rel);
4761
4762 ncolumns = tupdesc->natts;
4764
4766 {
4768
4769 if (attr->attisdropped)
4771 else
4773 }
4775 }
4776 else
4777 {
4778 /* Otherwise get the column names from eref or expandRTE() */
4779 List *colnames;
4781
4782 /*
4783 * Functions returning composites have the annoying property that some
4784 * of the composite type's columns might have been dropped since the
4785 * query was parsed. If possible, use expandRTE() to handle that
4786 * case, since it has the tedious logic needed to find out about
4787 * dropped columns. However, if we're explaining a plan, then we
4788 * don't have rte->functions because the planner thinks that won't be
4789 * needed later, and that breaks expandRTE(). So in that case we have
4790 * to rely on rte->eref, which may lead us to report a dropped
4791 * column's old name; that seems close enough for EXPLAIN's purposes.
4792 *
4793 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4794 * which should be sufficiently up-to-date: no other RTE types can
4795 * have columns get dropped from under them after parsing.
4796 */
4798 {
4799 /* Since we're not creating Vars, rtindex etc. don't matter */
4802 }
4803 else
4804 colnames = rte->eref->colnames;
4805
4806 ncolumns = list_length(colnames);
4808
4809 i = 0;
4811 {
4812 /*
4813 * If the column name we find here is an empty string, then it's a
4814 * dropped column, so change to NULL.
4815 */
4817
4821 i++;
4822 }
4823 }
4824
4825 /*
4826 * Ensure colinfo->colnames has a slot for each column. (It could be long
4827 * enough already, if we pushed down a name for the last column.) Note:
4828 * it's possible that there are now more columns than there were when the
4829 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4830 * We must assign unique aliases to the new columns too, else there could
4831 * be unresolved conflicts when the view/rule is reloaded.
4832 */
4835
4836 /*
4837 * Make sufficiently large new_colnames and is_new_col arrays, too.
4838 *
4839 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4840 * colname_is_unique will not consult that array, which is fine because it
4841 * would only be duplicate effort.
4842 */
4845
4846 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4848
4849 /*
4850 * Scan the columns, select a unique alias for each one, and store it in
4851 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4852 * entries for dropped columns, the latter omits them. Also mark
4853 * new_colnames entries as to whether they are new since parse time; this
4854 * is the case for entries beyond the length of rte->eref->colnames.
4855 */
4858 j = 0;
4860 {
4863
4864 /* Skip dropped columns */
4866 {
4868 continue;
4869 }
4870
4871 /* If alias already assigned, that's what to use */
4873 {
4874 /* If user wrote an alias, prefer that over real column name */
4877 else
4878 colname = real_colname;
4879
4880 /* Unique-ify and insert into colinfo */
4882
4885 }
4886
4887 /* Put names of non-dropped columns in new_colnames[] too */
4889 /* And mark them as new or not */
4891 j++;
4892
4893 /* Remember if any assigned aliases differ from "real" name */
4896 }
4897
4898 /* We're now done needing the colinfo's names_hash */
4900
4901 /*
4902 * Set correct length for new_colnames[] array. (Note: if columns have
4903 * been added, colinfo->num_cols includes them, which is not really quite
4904 * right but is harmless, since any new columns must be at the end where
4905 * they won't affect varattnos of pre-existing columns.)
4906 */
4908
4909 /*
4910 * For a relation RTE, we need only print the alias column names if any
4911 * are different from the underlying "real" names. For a function RTE,
4912 * always emit a complete column alias list; this is to protect against
4913 * possible instability of the default column names (eg, from altering
4914 * parameter names). For tablefunc RTEs, we never print aliases, because
4915 * the column names are part of the clause itself. For other RTE types,
4916 * print if we changed anything OR if there were user-written column
4917 * aliases (since the latter would be part of the underlying "reality").
4918 */
4927 else
4929}
4930
4931/*
4932 * set_join_column_names: select column aliases for a join RTE
4933 *
4934 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4935 * If any colnames entries are already filled in, those override local
4936 * choices. Also, names for USING columns were already chosen by
4937 * set_using_names(). We further expect that column alias selection has been
4938 * completed for both input RTEs.
4939 */
4940static void
4943{
4955
4956 /* Look up the previously-filled-in child deparse_columns structs */
4959
4960 /*
4961 * Ensure colinfo->colnames has a slot for each column. (It could be long
4962 * enough already, if we pushed down a name for the last column.) Note:
4963 * it's possible that one or both inputs now have more columns than there
4964 * were when the query was parsed, but we'll deal with that below. We
4965 * only need entries in colnames for pre-existing columns.
4966 */
4970
4971 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4973
4974 /*
4975 * Scan the join output columns, select an alias for each one, and store
4976 * it in colinfo->colnames. If there are USING columns, set_using_names()
4977 * already selected their names, so we can start the loop at the first
4978 * non-merged column.
4979 */
4982 {
4985
4986 /* Join column must refer to at least one input column */
4988
4989 /* Get the child column name */
4994 else
4995 {
4996 /* We're joining system columns --- use eref name */
4998 }
4999
5000 /* If child col has been dropped, no need to assign a join colname */
5002 {
5004 continue;
5005 }
5006
5007 /* In an unnamed join, just report child column names as-is */
5009 {
5012 continue;
5013 }
5014
5015 /* If alias already assigned, that's what to use */
5017 {
5018 /* If user wrote an alias, prefer that over real column name */
5021 else
5022 colname = real_colname;
5023
5024 /* Unique-ify and insert into colinfo */
5026
5029 }
5030
5031 /* Remember if any assigned aliases differ from "real" name */
5034 }
5035
5036 /*
5037 * Calculate number of columns the join would have if it were re-parsed
5038 * now, and create storage for the new_colnames and is_new_col arrays.
5039 *
5040 * Note: colname_is_unique will be consulting new_colnames[] during the
5041 * loops below, so its not-yet-filled entries must be zeroes.
5042 */
5048
5049 /*
5050 * Generating the new_colnames array is a bit tricky since any new columns
5051 * added since parse time must be inserted in the right places. This code
5052 * must match the parser, which will order a join's columns as merged
5053 * columns first (in USING-clause order), then non-merged columns from the
5054 * left input (in attnum order), then non-merged columns from the right
5055 * input (ditto). If one of the inputs is itself a join, its columns will
5056 * be ordered according to the same rule, which means newly-added columns
5057 * might not be at the end. We can figure out what's what by consulting
5058 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
5059 *
5060 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
5061 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
5062 * meanings for the current child RTE.
5063 */
5064
5065 /* Handle merged columns; they are first and can't be new */
5070 {
5071 /* column name is already determined and known unique */
5074
5075 /* build bitmapsets of child attnums of merged columns */
5080
5082 }
5083
5084 /* Handle non-merged left-child columns */
5085 ic = 0;
5087 {
5089
5091 {
5092 /* Advance ic to next non-dropped old column of left child */
5095 ic++;
5097 ic++;
5098 /* If it is a merged column, we already processed it */
5100 continue;
5101 /* Else, advance i to the corresponding existing join column */
5104 i++;
5107 /* Use the already-assigned name of this column */
5109 i++;
5110 }
5111 else
5112 {
5113 /*
5114 * Unique-ify the new child column name and assign, unless we're
5115 * in an unnamed join, in which case just copy
5116 */
5118 {
5124 }
5125 else
5128 }
5129
5131 j++;
5132 }
5133
5134 /* Handle non-merged right-child columns in exactly the same way */
5135 ic = 0;
5137 {
5139
5141 {
5142 /* Advance ic to next non-dropped old column of right child */
5145 ic++;
5147 ic++;
5148 /* If it is a merged column, we already processed it */
5150 continue;
5151 /* Else, advance i to the corresponding existing join column */
5154 i++;
5157 /* Use the already-assigned name of this column */
5159 i++;
5160 }
5161 else
5162 {
5163 /*
5164 * Unique-ify the new child column name and assign, unless we're
5165 * in an unnamed join, in which case just copy
5166 */
5168 {
5174 }
5175 else
5178 }
5179
5181 j++;
5182 }
5183
5184 /* Assert we processed the right number of columns */
5185#ifdef USE_ASSERT_CHECKING
5187 i++;
5190#endif
5191
5192 /* We're now done needing the colinfo's names_hash */
5194
5195 /*
5196 * For a named join, print column aliases if we changed any from the child
5197 * names. Unnamed joins cannot print aliases.
5198 */
5201 else
5203}
5204
5205/*
5206 * colname_is_unique: is colname distinct from already-chosen column names?
5207 *
5208 * dpns is query-wide info, colinfo is for the column's RTE
5209 */
5210static bool
5213{
5216
5217 /*
5218 * If we have a hash table, consult that instead of linearly scanning the
5219 * colinfo's strings.
5220 */
5222 {
5224 colname,
5225 HASH_FIND,
5227 return false;
5228 }
5229 else
5230 {
5231 /* Check against already-assigned column aliases within RTE */
5233 {
5235
5237 return false;
5238 }
5239
5240 /*
5241 * If we're building a new_colnames array, check that too (this will
5242 * be partially but not completely redundant with the previous checks)
5243 */
5245 {
5247
5249 return false;
5250 }
5251
5252 /*
5253 * Also check against names already assigned for parent-join USING
5254 * cols
5255 */
5257 {
5259
5261 return false;
5262 }
5263 }
5264
5265 /*
5266 * Also check against USING-column names that must be globally unique.
5267 * These are not hashed, but there should be few of them.
5268 */
5270 {
5272
5274 return false;
5275 }
5276
5277 return true;
5278}
5279
5280/*
5281 * make_colname_unique: modify colname if necessary to make it unique
5282 *
5283 * dpns is query-wide info, colinfo is for the column's RTE
5284 */
5285static char *
5288{
5289 /*
5290 * If the selected name isn't unique, append digits to make it so. For a
5291 * very long input name, we might have to truncate to stay within
5292 * NAMEDATALEN.
5293 */
5295 {
5299
5300 do
5301 {
5302 i++;
5303 for (;;)
5304 {
5308 break;
5309 /* drop chars from colname to keep all the digits */
5311 colnamelen - 1);
5312 }
5314 colname = modname;
5315 }
5316 return colname;
5317}
5318
5319/*
5320 * expand_colnames_array_to: make colinfo->colnames at least n items long
5321 *
5322 * Any added array entries are initialized to zero.
5323 */
5324static void
5326{
5328 {
5331 else
5333 colinfo->num_cols = n;
5334 }
5335}
5336
5337/*
5338 * build_colinfo_names_hash: optionally construct a hash table for colinfo
5339 */
5340static void
5342{
5346
5347 /*
5348 * Use a hash table only for RTEs with at least 32 columns. (The cutoff
5349 * is somewhat arbitrary, but let's choose it so that this code does get
5350 * exercised in the regression tests.)
5351 */
5353 return;
5354
5355 /*
5356 * Set up the hash table. The entries are just strings with no other
5357 * payload.
5358 */
5364 &hash_ctl,
5366
5367 /*
5368 * Preload the hash table with any names already present (these would have
5369 * come from set_using_names).
5370 */
5372 {
5374
5377 }
5378
5380 {
5382
5385 }
5386
5388 {
5390
5392 }
5393}
5394
5395/*
5396 * add_to_names_hash: add a string to the names_hash, if we're using one
5397 */
5398static void
5400{
5403 name,
5404 HASH_ENTER,
5405 NULL);
5406}
5407
5408/*
5409 * destroy_colinfo_names_hash: destroy hash table when done with it
5410 */
5411static void
5413{
5415 {
5418 }
5419}
5420
5421/*
5422 * identify_join_columns: figure out where columns of a join come from
5423 *
5424 * Fills the join-specific fields of the colinfo struct, except for
5425 * usingNames which is filled later.
5426 */
5427static void
5430{
5435
5436 /* Extract left/right child RT indexes */
5441 else
5448 else
5451
5452 /* Assert children will be processed earlier than join in second pass */
5455
5456 /* Initialize result arrays with zeroes */
5461
5462 /*
5463 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
5464 * Recall that the column(s) merged due to USING are the first column(s)
5465 * of the join output. We need not do anything special while scanning
5466 * joinleftcols, but while scanning joinrightcols we must distinguish
5467 * merged from unmerged columns.
5468 */
5469 jcolno = 0;
5471 {
5473
5475 }
5476 rcolno = 0;
5478 {
5480
5483 else
5485 rcolno++;
5486 }
5488}
5489
5490/*
5491 * get_rtable_name: convenience function to get a previously assigned RTE alias
5492 *
5493 * The RTE must belong to the topmost namespace level in "context".
5494 */
5495static char *
5497{
5499
5502}
5503
5504/*
5505 * set_deparse_plan: set up deparse_namespace to parse subexpressions
5506 * of a given Plan node
5507 *
5508 * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
5509 * and index_tlist fields. Caller must already have adjusted the ancestors
5510 * list if necessary. Note that the rtable, subplans, and ctes fields do
5511 * not need to change when shifting attention to different plan nodes in a
5512 * single plan tree.
5513 */
5514static void
5516{
5518
5519 /*
5520 * We special-case Append and MergeAppend to pretend that the first child
5521 * plan is the OUTER referent; we have to interpret OUTER Vars in their
5522 * tlists according to one of the children, and the first one is the most
5523 * natural choice.
5524 */
5529 else
5531
5534 else
5536
5537 /*
5538 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
5539 * use OUTER because that could someday conflict with the normal meaning.)
5540 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
5541 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
5542 * that as INNER referent.
5543 *
5544 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
5545 * INNER referent. This is the join from the target relation to the data
5546 * source, and all INNER_VAR Vars in other parts of the query refer to its
5547 * targetlist.
5548 *
5549 * For ON CONFLICT DO SELECT/UPDATE we just need the inner tlist to point
5550 * to the excluded expression's tlist. (Similar to the SubqueryScan we
5551 * don't want to reuse OUTER, it's used for RETURNING in some modify table
5552 * cases, although not INSERT .. CONFLICT).
5553 */
5563 {
5566 else
5568 }
5569 else
5571
5576 else
5578
5579 /* Set up referent for INDEX_VAR Vars, if needed */
5586 else
5588}
5589
5590/*
5591 * Locate the ancestor plan node that is the RecursiveUnion generating
5592 * the WorkTableScan's work table. We can match on wtParam, since that
5593 * should be unique within the plan tree.
5594 */
5597{
5599
5601 {
5603
5607 }
5609 wtscan->wtParam);
5611}
5612
5613/*
5614 * push_child_plan: temporarily transfer deparsing attention to a child plan
5615 *
5616 * When expanding an OUTER_VAR or INNER_VAR reference, we must adjust the
5617 * deparse context in case the referenced expression itself uses
5618 * OUTER_VAR/INNER_VAR. We modify the top stack entry in-place to avoid
5619 * affecting levelsup issues (although in a Plan tree there really shouldn't
5620 * be any).
5621 *
5622 * Caller must provide a local deparse_namespace variable to save the
5623 * previous state for pop_child_plan.
5624 */
5625static void
5628{
5629 /* Save state for restoration later */
5631
5632 /* Link current plan node into ancestors list */
5634
5635 /* Set attention on selected child */
5637}
5638
5639/*
5640 * pop_child_plan: undo the effects of push_child_plan
5641 */
5642static void
5644{
5645 List *ancestors;
5646
5647 /* Get rid of ancestors list cell added by push_child_plan */
5649
5650 /* Restore fields changed by push_child_plan */
5652
5653 /* Make sure dpns->ancestors is right (may be unnecessary) */
5654 dpns->ancestors = ancestors;
5655}
5656
5657/*
5658 * push_ancestor_plan: temporarily transfer deparsing attention to an
5659 * ancestor plan
5660 *
5661 * When expanding a Param reference, we must adjust the deparse context
5662 * to match the plan node that contains the expression being printed;
5663 * otherwise we'd fail if that expression itself contains a Param or
5664 * OUTER_VAR/INNER_VAR/INDEX_VAR variable.
5665 *
5666 * The target ancestor is conveniently identified by the ListCell holding it
5667 * in dpns->ancestors.
5668 *
5669 * Caller must provide a local deparse_namespace variable to save the
5670 * previous state for pop_ancestor_plan.
5671 */
5672static void
5675{
5677
5678 /* Save state for restoration later */
5680
5681 /* Build a new ancestor list with just this node's ancestors */
5682 dpns->ancestors =
5685
5686 /* Set attention on selected ancestor */
5688}
5689
5690/*
5691 * pop_ancestor_plan: undo the effects of push_ancestor_plan
5692 */
5693static void
5695{
5696 /* Free the ancestor list made in push_ancestor_plan */
5698
5699 /* Restore fields changed by push_ancestor_plan */
5701}
5702
5703
5704/* ----------
5705 * make_ruledef - reconstruct the CREATE RULE command
5706 * for a given pg_rewrite tuple
5707 * ----------
5708 */
5709static void
5711 int prettyFlags)
5712{
5713 char *rulename;
5714 char ev_type;
5716 bool is_instead;
5719 List *actions;
5724 bool isnull;
5725
5726 /*
5727 * Get the attribute values from the rules tuple
5728 */
5731 Assert(!isnull);
5733
5736 Assert(!isnull);
5738
5741 Assert(!isnull);
5743
5746 Assert(!isnull);
5748
5752
5759
5761
5762 /*
5763 * Build the rules definition text
5764 */
5766 quote_identifier(rulename));
5767
5770 else
5772
5773 /* The event the rule is fired for */
5774 switch (ev_type)
5775 {
5776 case '1':
5779 break;
5780
5781 case '2':
5783 break;
5784
5785 case '3':
5787 break;
5788
5789 case '4':
5791 break;
5792
5793 default:
5797 rulename, ev_type)));
5798 break;
5799 }
5800
5801 /* The relation the rule is fired on */
5803 (prettyFlags & PRETTYFLAG_SCHEMA) ?
5806
5807 /* If the rule has an event qualification, add it */
5809 {
5810 Node *qual;
5811 Query *query;
5812 deparse_context context;
5814
5818
5820
5821 /*
5822 * We need to make a context for recognizing any Vars in the qual
5823 * (which can only be references to OLD and NEW). Use the rtable of
5824 * the first query in the action list for this purpose.
5825 */
5827
5828 /*
5829 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5830 * into the SELECT, and that's what we need to look at. (Ugly kluge
5831 * ... try to fix this when we redesign querytrees.)
5832 */
5834
5835 /* Must acquire locks right away; see notes in get_query_def() */
5837
5844 context.prettyFlags = prettyFlags;
5851
5853
5855 }
5856
5858
5859 /* The INSTEAD keyword (if so) */
5860 if (is_instead)
5862
5863 /* Finally the rules actions */
5865 {
5867 Query *query;
5868
5870 foreach(action, actions)
5871 {
5874 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5875 if (prettyFlags)
5877 else
5879 }
5881 }
5882 else
5883 {
5884 Query *query;
5885
5888 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5890 }
5891
5893}
5894
5895
5896/* ----------
5897 * make_viewdef - reconstruct the SELECT part of a
5898 * view rewrite rule
5899 * ----------
5900 */
5901static void
5903 int prettyFlags, int wrapColumn)
5904{
5905 Query *query;
5906 char ev_type;
5908 bool is_instead;
5911 List *actions;
5915 bool isnull;
5916
5917 /*
5918 * Get the attribute values from the rules tuple
5919 */
5922 Assert(!isnull);
5924
5927 Assert(!isnull);
5929
5932 Assert(!isnull);
5934
5938
5943
5945 {
5946 /* keep output buffer empty and leave */
5947 return;
5948 }
5949
5951
5952 if (ev_type != '1' || !is_instead ||
5954 {
5955 /* keep output buffer empty and leave */
5956 return;
5957 }
5958
5960
5962 prettyFlags, wrapColumn, 0);
5964
5966}
5967
5968
5969/* ----------
5970 * get_query_def - Parse back one query parsetree
5971 *
5972 * query: parsetree to be displayed
5973 * buf: output text is appended to buf
5974 * parentnamespace: list (initially empty) of outer-level deparse_namespace's
5975 * resultDesc: if not NULL, the output tuple descriptor for the view
5976 * represented by a SELECT query. We use the column names from it
5977 * to label SELECT output columns, in preference to names in the query
5978 * colNamesVisible: true if the surrounding context cares about the output
5979 * column names at all (as, for example, an EXISTS() context does not);
5980 * when false, we can suppress dummy column labels such as "?column?"
5981 * prettyFlags: bitmask of PRETTYFLAG_XXX options
5982 * wrapColumn: maximum line length, or -1 to disable wrapping
5983 * startIndent: initial indentation amount
5984 * ----------
5985 */
5986static void
5990{
5991 deparse_context context;
5993 int rtable_size;
5994
5995 /* Guard against excessively long or deeply-nested queries */
5996 CHECK_FOR_INTERRUPTS();
5997 check_stack_depth();
5998
5999 rtable_size = query->hasGroupRTE ?
6002
6003 /*
6004 * Replace any Vars in the query's targetlist and havingQual that
6005 * reference GROUP outputs with the underlying grouping expressions.
6006 *
6007 * We can safely pass NULL for the root here. Preserving varnullingrels
6008 * makes no difference to the deparsed source text.
6009 */
6010 if (query->hasGroupRTE)
6011 {
6014 query->havingQual =
6016 }
6017
6018 /*
6019 * Before we begin to examine the query, acquire locks on referenced
6020 * relations, and fix up deleted columns in JOIN RTEs. This ensures
6021 * consistent results. Note we assume it's OK to scribble on the passed
6022 * querytree!
6023 *
6024 * We are only deparsing the query (we are not about to execute it), so we
6025 * only need AccessShareLock on the relations it mentions.
6026 */
6028
6035 rtable_size != 1);
6036 context.prettyFlags = prettyFlags;
6037 context.wrapColumn = wrapColumn;
6039 context.colNamesVisible = colNamesVisible;
6043
6045
6047 {
6049 /* We set context.resultDesc only if it's a SELECT */
6050 context.resultDesc = resultDesc;
6051 get_select_query_def(query, &context);
6052 break;
6053
6055 get_update_query_def(query, &context);
6056 break;
6057
6059 get_insert_query_def(query, &context);
6060 break;
6061
6063 get_delete_query_def(query, &context);
6064 break;
6065
6067 get_merge_query_def(query, &context);
6068 break;
6069
6072 break;
6073
6075 get_utility_query_def(query, &context);
6076 break;
6077
6078 default:
6080 query->commandType);
6081 break;
6082 }
6083}
6084
6085/* ----------
6086 * get_values_def - Parse back a VALUES list
6087 * ----------
6088 */
6089static void
6091{
6095
6097
6099 {
6103
6106 else
6108
6111 {
6113
6116 else
6118
6119 /*
6120 * Print the value. Whole-row Vars need special treatment.
6121 */
6123 }
6125 }
6126}
6127
6128/* ----------
6129 * get_with_clause - Parse back a WITH clause
6130 * ----------
6131 */
6132static void
6134{
6137 ListCell *l;
6138
6140 return;
6141
6143 {
6146 }
6147
6148 if (query->hasRecursive)
6150 else
6153 {
6155
6158 if (cte->aliascolnames)
6159 {
6160 bool first = true;
6162
6165 {
6166 if (first)
6167 first = false;
6168 else
6172 }
6174 }
6177 {
6179 break;
6182 break;
6185 break;
6186 }
6191 true,
6193 context->indentLevel);
6197
6198 if (cte->search_clause)
6199 {
6200 bool first = true;
6202
6204 cte->search_clause->search_breadth_first ? "BREADTH" : "DEPTH");
6205
6207 {
6208 if (first)
6209 first = false;
6210 else
6214 }
6215
6217 }
6218
6219 if (cte->cycle_clause)
6220 {
6221 bool first = true;
6223
6225
6227 {
6228 if (first)
6229 first = false;
6230 else
6234 }
6235
6237
6238 {
6241
6242 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
6244 {
6249 }
6250 }
6251
6253 }
6254
6256 }
6257
6259 {
6262 }
6263 else
6265}
6266
6267/* ----------
6268 * get_select_query_def - Parse back a SELECT parsetree
6269 * ----------
6270 */
6271static void
6273{
6276 ListCell *l;
6277
6278 /* Insert the WITH clause if given */
6279 get_with_clause(query, context);
6280
6281 /* Subroutines may need to consult the SELECT targetlist and windowClause */
6284
6285 /*
6286 * If the Query node has a setOperations tree, then it's the top level of
6287 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
6288 * fields are interesting in the top query itself.
6289 */
6291 {
6293 /* ORDER BY clauses must be simple in this case */
6295 }
6296 else
6297 {
6298 get_basic_select_query(query, context);
6300 }
6301
6302 /* Add the ORDER BY clause if given */
6304 {
6308 force_colno, context);
6309 }
6310
6311 /*
6312 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
6313 * standard spelling of LIMIT.
6314 */
6316 {
6320 }
6322 {
6324 {
6325 /*
6326 * The limitCount arg is a c_expr, so it needs parens. Simple
6327 * literals and function expressions would not need parens, but
6328 * unfortunately it's hard to tell if the expression will be
6329 * printed as a simple literal like 123 or as a typecast
6330 * expression, like '-123'::int4. The grammar accepts the former
6331 * without quoting, but not the latter.
6332 */
6339 }
6340 else
6341 {
6347 else
6349 }
6350 }
6351
6352 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
6353 if (query->hasForUpdate)
6354 {
6356 {
6358
6359 /* don't print implicit clauses */
6361 continue;
6362
6363 appendContextKeyword(context,
6366
6369 context)));
6374 }
6375 }
6376}
6377
6378static char *
6380{
6381 switch (strength)
6382 {
6384 /* we intentionally throw an error for LCS_NONE */
6386 (int) strength);
6387 break;
6389 return " FOR KEY SHARE";
6391 return " FOR SHARE";
6393 return " FOR NO KEY UPDATE";
6395 return " FOR UPDATE";
6396 }
6398}
6399
6400/*
6401 * Detect whether query looks like SELECT ... FROM VALUES(),
6402 * with no need to rename the output columns of the VALUES RTE.
6403 * If so, return the VALUES RTE. Otherwise return NULL.
6404 */
6407{
6410
6411 /*
6412 * We want to detect a match even if the Query also contains OLD or NEW
6413 * rule RTEs. So the idea is to scan the rtable and see if there is only
6414 * one inFromCl RTE that is a VALUES RTE.
6415 */
6417 {
6419
6421 {
6425 }
6427 continue; /* ignore rule entries */
6428 else
6430 }
6431
6432 /*
6433 * We don't need to check the targetlist in any great detail, because
6434 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6435 * appear inside auto-generated sub-queries with very restricted
6436 * structure. However, DefineView might have modified the tlist by
6437 * injecting new column aliases, or we might have some other column
6438 * aliases forced by a resultDesc. We can only simplify if the RTE's
6439 * column names match the names that get_target_list() would select.
6440 */
6442 {
6444 int colno;
6445
6448 colno = 0;
6450 {
6453 char *colname;
6454
6457
6458 /* compute name that get_target_list would use for column */
6459 colno++;
6462 else
6463 colname = tle->resname;
6464
6465 /* does it match the VALUES RTE? */
6468 }
6469 }
6470
6472}
6473
6474static void
6476{
6480 ListCell *l;
6481
6483 {
6486 }
6487
6488 /*
6489 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6490 * VALUES part. This reverses what transformValuesClause() did at parse
6491 * time.
6492 */
6495 {
6497 return;
6498 }
6499
6500 /*
6501 * Build up the query string - first we say SELECT
6502 */
6503 if (query->isReturn)
6505 else
6507
6508 /* Add the DISTINCT clause if given */
6510 {
6511 if (query->hasDistinctOn)
6512 {
6516 {
6518
6521 false, context);
6523 }
6525 }
6526 else
6528 }
6529
6530 /* Then we tell what to select (the targetlist) */
6532
6533 /* Add the FROM clause if needed */
6535
6536 /* Add the WHERE clause if given */
6538 {
6542 }
6543
6544 /* Add the GROUP BY clause if given */
6546 {
6548
6553
6556
6558 {
6561 {
6563
6566 false, context);
6568 }
6569 }
6570 else
6571 {
6574 {
6576
6580 }
6581 }
6582
6584 }
6585
6586 /* Add the HAVING clause if given */
6588 {
6592 }
6593
6594 /* Add the WINDOW clause if needed */
6596 get_rule_windowclause(query, context);
6597}
6598
6599/* ----------
6600 * get_target_list - Parse back a SELECT target list
6601 *
6602 * This is also used for RETURNING lists in INSERT/UPDATE/DELETE/MERGE.
6603 * ----------
6604 */
6605static void
6607{
6612 int colno;
6613 ListCell *l;
6614
6615 /* we use targetbuf to hold each TLE's text temporarily */
6617
6619 colno = 0;
6620 foreach(l, targetList)
6621 {
6623 char *colname;
6625
6627 continue; /* ignore junk entries */
6628
6631 colno++;
6632
6633 /*
6634 * Put the new field text into targetbuf so we can decide after we've
6635 * got it whether or not it needs to go on a new line.
6636 */
6639
6640 /*
6641 * We special-case Var nodes rather than using get_rule_expr. This is
6642 * needed because get_rule_expr will display a whole-row Var as
6643 * "foo.*", which is the preferred notation in most contexts, but at
6644 * the top level of a SELECT list it's not right (the parser will
6645 * expand that notation into multiple columns, yielding behavior
6646 * different from a whole-row Var). We need to call get_variable
6647 * directly so that we can tell it to do the right thing, and so that
6648 * we can get the attribute name which is the default AS label.
6649 */
6651 {
6653 }
6654 else
6655 {
6657
6658 /*
6659 * When colNamesVisible is true, we should always show the
6660 * assigned column name explicitly. Otherwise, show it only if
6661 * it's not FigureColname's fallback.
6662 */
6664 }
6665
6666 /*
6667 * Figure out what the result column should be called. In the context
6668 * of a view, use the view's tuple descriptor (so as to pick up the
6669 * effects of any column RENAME that's been done on the view).
6670 * Otherwise, just use what we can find in the TLE.
6671 */
6674 colno - 1)->attname);
6675 else
6676 colname = tle->resname;
6677
6678 /* Show AS unless the column's name is correct as-is */
6679 if (colname) /* resname could be NULL */
6680 {
6683 }
6684
6685 /* Restore context's output buffer */
6687
6688 /* Consider line-wrapping if enabled */
6690 {
6692
6693 /* Does the new field start with a new line? */
6695 leading_nl_pos = 0;
6696 else
6697 leading_nl_pos = -1;
6698
6699 /* If so, we shouldn't add anything */
6701 {
6702 /* instead, remove any trailing spaces currently in buf */
6704 }
6705 else
6706 {
6708
6709 /* Locate the start of the current line in the output buffer */
6713 else
6714 trailing_nl++;
6715
6716 /*
6717 * Add a newline, plus some indentation, if the new field is
6718 * not the first and either the new field would cause an
6719 * overflow or the last field used more than one line.
6720 */
6721 if (colno > 1 &&
6723 last_was_multiline))
6726 }
6727
6728 /* Remember this field's multiline status for next iteration */
6729 last_was_multiline =
6731 }
6732
6733 /* Add the new field */
6735 }
6736
6737 /* clean up */
6739}
6740
6741static void
6743{
6745
6747 {
6749
6752
6753 /* Add WITH (OLD/NEW) options, if they're not the defaults */
6755 {
6757 quote_identifier(query->returningOldAlias));
6759 }
6761 {
6764 quote_identifier(query->returningNewAlias));
6765 else
6766 {
6768 quote_identifier(query->returningNewAlias));
6770 }
6771 }
6774
6775 /* Add the returning expressions themselves */
6777 }
6778}
6779
6780static void
6782{
6785
6786 /* Guard against excessively long or deeply-nested queries */
6787 CHECK_FOR_INTERRUPTS();
6788 check_stack_depth();
6789
6791 {
6795
6797
6798 /*
6799 * We need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y.
6800 * Also add parens if the leaf query contains its own set operations.
6801 * (That shouldn't happen unless one of the other clauses is also
6802 * present, see transformSetOperationTree; but let's be safe.)
6803 */
6805 subquery->sortClause ||
6806 subquery->rowMarks ||
6807 subquery->limitOffset ||
6808 subquery->limitCount ||
6809 subquery->setOperations);
6815 context->indentLevel);
6818 }
6820 {
6824
6825 /*
6826 * We force parens when nesting two SetOperationStmts, except when the
6827 * lefthand input is another setop of the same kind. Syntactically,
6828 * we could omit parens in rather more cases, but it seems best to use
6829 * parens to flag cases where the setop operator changes. If we use
6830 * parens, we also increase the indentation level for the child query.
6831 *
6832 * There are some cases in which parens are needed around a leaf query
6833 * too, but those are more easily handled at the next level down (see
6834 * code above).
6835 */
6837 {
6839
6842 else
6844 }
6845 else
6847
6849 {
6853 }
6854 else
6855 subindent = 0;
6856
6858
6863 else
6865
6867 {
6870 break;
6873 break;
6876 break;
6877 default:
6880 }
6883
6884 /* Always parenthesize if RHS is another setop */
6886
6887 /*
6888 * The indentation code here is deliberately a bit different from that
6889 * for the lefthand input, because we want the line breaks in
6890 * different places.
6891 */
6893 {
6896 }
6897 else
6898 subindent = 0;
6900
6901 /*
6902 * The output column names of the RHS sub-select don't matter.
6903 */
6906
6908
6910
6915 }
6916 else
6917 {
6920 }
6921}
6922
6923/*
6924 * Display a sort/group clause.
6925 *
6926 * Also returns the expression tree, so caller need not find it again.
6927 */
6930 deparse_context *context)
6931{
6934 Node *expr;
6935
6938
6939 /*
6940 * Use column-number form if requested by caller. Otherwise, if
6941 * expression is a constant, force it to be dumped with an explicit cast
6942 * as decoration --- this is because a simple integer constant is
6943 * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
6944 * we dump it without any decoration. Similarly, if it's just a Var,
6945 * there is risk of misinterpretation if the column name is reassigned in
6946 * the SELECT list, so we may need to force table qualification. And, if
6947 * it's anything more complex than a simple Var, then force extra parens
6948 * around it, to ensure it can't be misinterpreted as a cube() or rollup()
6949 * construct.
6950 */
6952 {
6955 }
6956 else if (!expr)
6957 /* do nothing, probably can't happen */ ;
6961 {
6962 /* Tell get_variable to check for name conflict */
6964
6968 }
6969 else
6970 {
6971 /*
6972 * We must force parens for function-like expressions even if
6973 * PRETTY_PAREN is off, since those are the ones in danger of
6974 * misparsing. For other expressions we need to force them only if
6975 * PRETTY_PAREN is on, since otherwise the expression will output them
6976 * itself. (We can't skip the parens.)
6977 */
6983
6989 }
6990
6991 return expr;
6992}
6993
6994/*
6995 * Display a GroupingSet
6996 */
6997static void
7000{
7001 ListCell *l;
7005
7007 {
7010 return;
7011
7013 {
7016
7018 {
7020
7023 false, context);
7025 }
7026
7029 }
7030 return;
7031
7034 break;
7037 break;
7041 break;
7042 }
7043
7045 {
7049 }
7050
7052}
7053
7054/*
7055 * Display an ORDER BY list.
7056 */
7057static void
7060{
7063 ListCell *l;
7064
7067 {
7071 TypeCacheEntry *typentry;
7072
7075 force_colno, context);
7077 /* See whether operator is default < or > for datatype */
7081 {
7082 /* ASC is default, so emit nothing for it */
7085 }
7087 {
7089 /* DESC defaults to NULLS FIRST */
7092 }
7093 else
7094 {
7097 sortcoltype,
7098 sortcoltype));
7099 /* be specific to eliminate ambiguity */
7102 else
7104 }
7106 }
7107}
7108
7109/*
7110 * Display a WINDOW clause.
7111 *
7112 * Note that the windowClause list might contain only anonymous window
7113 * specifications, in which case we should print nothing here.
7114 */
7115static void
7117{
7120 ListCell *l;
7121
7124 {
7126
7128 continue; /* ignore anonymous windows */
7129
7133 else
7135
7137
7139
7141 }
7142}
7143
7144/*
7145 * Display a window definition
7146 */
7147static void
7149 deparse_context *context)
7150{
7154 ListCell *l;
7155
7157 if (wc->refname)
7158 {
7161 }
7162 /* partition clauses are always inherited, so only print if no refname */
7164 {
7170 {
7172
7175 false, context);
7177 }
7179 }
7180 /* print ordering clause only if not inherited */
7182 {
7188 }
7189 /* framing clause is never inherited, so print unless it's default */
7191 {
7196 context);
7197 }
7199}
7200
7201/*
7202 * Append the description of a window's framing options to context->buf
7203 */
7204static void
7207 deparse_context *context)
7208{
7210
7212 {
7219 else
7228 {
7234 else
7236 }
7237 else
7240 {
7247 {
7253 else
7255 }
7256 else
7258 }
7265 /* we will now have a trailing space; remove it */
7267 }
7268}
7269
7270/*
7271 * Return the description of a window's framing options as a palloc'd string
7272 */
7273char *
7277{
7279 deparse_context context;
7280
7288 context.prettyFlags = 0;
7290 context.indentLevel = 0;
7295
7296 get_window_frame_options(frameOptions, startOffset, endOffset, &context);
7297
7299}
7300
7301/* ----------
7302 * get_insert_query_def - Parse back an INSERT parsetree
7303 * ----------
7304 */
7305static void
7307{
7313 ListCell *l;
7315
7316 /* Insert the WITH clause if given */
7317 get_with_clause(query, context);
7318
7319 /*
7320 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
7321 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
7322 */
7324 {
7326
7328 {
7332 }
7333
7335 {
7339 }
7340 }
7343
7344 /*
7345 * Start the query with INSERT INTO relname
7346 */
7349
7351 {
7354 }
7357
7358 /* Print the relation alias, if needed; INSERT requires explicit AS */
7360
7361 /* always want a space here */
7363
7364 /*
7365 * Add the insert-column-names list. Any indirection decoration needed on
7366 * the column names can be inferred from the top targetlist.
7367 */
7373 {
7375
7377 continue; /* ignore junk entries */
7378
7381
7382 /*
7383 * Put out name of target column; look in the catalogs, not at
7384 * tle->resname, since resname will fail to track RENAME.
7385 */
7388 tle->resno,
7389 false)));
7390
7391 /*
7392 * Print any indirection needed (subfields or subscripts), and strip
7393 * off the top-level nodes representing the indirection assignments.
7394 * Add the stripped expressions to strippedexprs. (If it's a
7395 * single-VALUES statement, the stripped expressions are the VALUES to
7396 * print below. Otherwise they're just Vars and not really
7397 * interesting.)
7398 */
7401 context));
7402 }
7405
7406 if (query->override)
7407 {
7412 }
7413
7415 {
7416 /* Add the SELECT */
7418 false,
7420 context->indentLevel);
7421 }
7423 {
7424 /* Add the multi-VALUES expression lists */
7426 }
7428 {
7429 /* Add the single-VALUES expression list */
7434 }
7435 else
7436 {
7437 /* No expressions, so it must be DEFAULT VALUES */
7439 }
7440
7441 /* Add ON CONFLICT if present */
7443 {
7445
7447
7449 {
7450 /* Add the single-VALUES expression list */
7454
7455 /* Add a WHERE clause (for partial indexes) if given */
7457 {
7459
7460 /*
7461 * Force non-prefixing of Vars, since parser assumes that they
7462 * belong to target relation. WHERE clause does not use
7463 * InferenceElem, so this is separately required.
7464 */
7467
7471
7473 }
7474 }
7476 {
7478
7479 if (!constraint)
7481 confl->constraint);
7483 quote_identifier(constraint));
7484 }
7485
7487 {
7489 }
7491 {
7493 /* Deparse targetlist */
7495 context, rte);
7496
7497 /* Add a WHERE clause if given */
7499 {
7503 }
7504 }
7505 else
7506 {
7509
7510 /* Add FOR [KEY] UPDATE/SHARE clause if present */
7513
7514 /* Add a WHERE clause if given */
7516 {
7520 }
7521 }
7522 }
7523
7524 /* Add RETURNING if present */
7526 get_returning_clause(query, context);
7527}
7528
7529
7530/* ----------
7531 * get_update_query_def - Parse back an UPDATE parsetree
7532 * ----------
7533 */
7534static void
7536{
7539
7540 /* Insert the WITH clause if given */
7541 get_with_clause(query, context);
7542
7543 /*
7544 * Start the query with UPDATE relname SET
7545 */
7549 {
7552 }
7556
7557 /* Print the FOR PORTION OF, if needed */
7559
7560 /* Print the relation alias, if needed */
7562
7564
7565 /* Deparse targetlist */
7567
7568 /* Add the FROM clause if needed */
7570
7571 /* Add a WHERE clause if given */
7573 {
7577 }
7578
7579 /* Add RETURNING if present */
7581 get_returning_clause(query, context);
7582}
7583
7584
7585/* ----------
7586 * get_update_query_targetlist_def - Parse back an UPDATE targetlist
7587 * ----------
7588 */
7589static void
7592{
7594 ListCell *l;
7600
7601 /*
7602 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
7603 * into a list. We expect them to appear, in ID order, in resjunk tlist
7604 * entries.
7605 */
7607 if (query->hasSubLinks) /* else there can't be any */
7608 {
7609 foreach(l, targetList)
7610 {
7612
7614 {
7616
7618 {
7621 }
7622 }
7623 }
7624 }
7627 remaining_ma_columns = 0;
7628
7629 /* Add the comma separated list of 'attname = value' */
7631 foreach(l, targetList)
7632 {
7634 Node *expr;
7635
7637 continue; /* ignore junk entries */
7638
7639 /* Emit separator (OK whether we're in multiassignment or not) */
7642
7643 /*
7644 * Check to see if we're starting a multiassignment group: if so,
7645 * output a left paren.
7646 */
7648 {
7649 /*
7650 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
7651 * Param. That could be buried under FieldStores and
7652 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
7653 * and underneath those there could be an implicit type coercion.
7654 * Because we would ignore implicit type coercions anyway, we
7655 * don't need to be as careful as processIndirection() is about
7656 * descending past implicit CoerceToDomains.
7657 */
7659 while (expr)
7660 {
7662 {
7664
7666 }
7668 {
7670
7672 break;
7673
7675 }
7677 {
7679
7681 break;
7683 }
7684 else
7685 break;
7686 }
7687 expr = strip_implicit_coercions(expr);
7688
7691 {
7694 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
7696 ((cur_ma_sublink->subLinkId << 16) | 1));
7698 }
7699 }
7700
7701 /*
7702 * Put out name of target column; look in the catalogs, not at
7703 * tle->resname, since resname will fail to track RENAME.
7704 */
7707 tle->resno,
7708 false)));
7709
7710 /*
7711 * Print any indirection needed (subfields or subscripts), and strip
7712 * off the top-level nodes representing the indirection assignments.
7713 */
7715
7716 /*
7717 * If we're in a multiassignment, skip printing anything more, unless
7718 * this is the last column; in which case, what we print should be the
7719 * sublink, not the Param.
7720 */
7722 {
7724 continue; /* not the last column of multiassignment */
7728 }
7729
7731
7733 }
7734}
7735
7736
7737/* ----------
7738 * get_delete_query_def - Parse back a DELETE parsetree
7739 * ----------
7740 */
7741static void
7743{
7746
7747 /* Insert the WITH clause if given */
7748 get_with_clause(query, context);
7749
7750 /*
7751 * Start the query with DELETE FROM relname
7752 */
7756 {
7759 }
7763
7764 /* Print the FOR PORTION OF, if needed */
7766
7767 /* Print the relation alias, if needed */
7769
7770 /* Add the USING clause if given */
7772
7773 /* Add a WHERE clause if given */
7775 {
7779 }
7780
7781 /* Add RETURNING if present */
7783 get_returning_clause(query, context);
7784}
7785
7786
7787/* ----------
7788 * get_merge_query_def - Parse back a MERGE parsetree
7789 * ----------
7790 */
7791static void
7793{
7798
7799 /* Insert the WITH clause if given */
7800 get_with_clause(query, context);
7801
7802 /*
7803 * Start the query with MERGE INTO relname
7804 */
7808 {
7811 }
7815
7816 /* Print the relation alias, if needed */
7818
7819 /* Print the source relation and join clause */
7824
7825 /*
7826 * Test for any NOT MATCHED BY SOURCE actions. If there are none, then
7827 * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
7828 * SQL standard. Otherwise, we have a non-SQL-standard query, so output
7829 * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
7830 * more explicit.
7831 */
7834 {
7836
7838 {
7840 break;
7841 }
7842 }
7843
7844 /* Print each merge action */
7846 {
7848
7852 {
7855 break;
7858 break;
7862 else
7864 break;
7865 default:
7868 }
7869
7871 {
7875 }
7878
7880 {
7881 /* This generally matches get_insert_query_def() */
7885
7887
7891 {
7893
7895
7898
7901 tle->resno,
7902 false)));
7905 context));
7906 }
7909
7911 {
7916 }
7917
7919 {
7924 }
7925 else
7927 }
7929 {
7932 context, rte);
7933 }
7938 }
7939
7940 /* Add RETURNING if present */
7942 get_returning_clause(query, context);
7943}
7944
7945
7946/* ----------
7947 * get_utility_query_def - Parse back a UTILITY parsetree
7948 * ----------
7949 */
7950static void
7952{
7954
7956 {
7958
7960 0, PRETTYINDENT_STD, 1);
7964 {
7967 }
7968 }
7969 else
7970 {
7971 /* Currently only NOTIFY utility commands can appear in rules */
7973 }
7974}
7975
7976
7977/*
7978 * Parse back a graph label expression
7979 */
7980static void
7982{
7984
7985 check_stack_depth();
7986
7988 {
7990 {
7992
7994 break;
7995 }
7996
7998 {
8001 bool first = true;
8002
8004
8006 {
8007 if (!first)
8008 {
8011 }
8012 else
8013 first = false;
8015 }
8016
8017 break;
8018 }
8019
8020 default:
8022 break;
8023 }
8024}
8025
8026/*
8027 * Parse back a path pattern expression
8028 */
8029static void
8031{
8034
8036 {
8039
8041 {
8044 break;
8047 break;
8051 break;
8054 break;
8055 }
8056
8058 {
8061 }
8062
8064 {
8069 }
8070
8072 {
8076 }
8077
8079 {
8083 }
8084
8086 {
8089 break;
8093 break;
8096 break;
8099 break;
8100 }
8101
8103 {
8106
8108 }
8109 }
8110}
8111
8112/*
8113 * Parse back a graph pattern
8114 */
8115static void
8117{
8120 bool first = true;
8121
8123 {
8125
8126 if (!first)
8128 else
8129 first = false;
8130
8132 }
8133
8135 {
8138 }
8139}
8140
8141/*
8142 * Display a Var appropriately.
8143 *
8144 * In some cases (currently only when recursing into an unnamed join)
8145 * the Var's varlevelsup has to be interpreted with respect to a context
8146 * above the current one; levelsup indicates the offset.
8147 *
8148 * If istoplevel is true, the Var is at the top level of a SELECT's
8149 * targetlist, which means we need special treatment of whole-row Vars.
8150 * Instead of the normal "tab.*", we'll print "tab.*::typename", which is a
8151 * dirty hack to prevent "tab.*" from being expanded into multiple columns.
8152 * (The parser will strip the useless coercion, so no inefficiency is added in
8153 * dump and reload.) We used to print just "tab" in such cases, but that is
8154 * ambiguous and will yield the wrong result if "tab" is also a plain column
8155 * name in the query.
8156 *
8157 * Returns the attname of the Var, or NULL if the Var has no attname (because
8158 * it is a whole-row Var or a subplan output reference).
8159 */
8160static char *
8162{
8168 int varno;
8169 AttrNumber varattno;
8171 char *refname;
8174
8175 /* Find appropriate nesting depth */
8179 var->varlevelsup, levelsup);
8181 netlevelsup);
8182
8183 /*
8184 * If we have a syntactic referent for the Var, and we're working from a
8185 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8186 * on the semantic referent. (Forcing use of the semantic referent when
8187 * printing plan trees is a design choice that's perhaps more motivated by
8188 * backwards compatibility than anything else. But it does have the
8189 * advantage of making plans more explicit.)
8190 */
8192 {
8193 varno = var->varnosyn;
8194 varattno = var->varattnosyn;
8195 }
8196 else
8197 {
8198 varno = var->varno;
8199 varattno = var->varattno;
8200 }
8201
8202 /*
8203 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8204 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8205 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
8206 * find the aliases previously assigned for this RTE.
8207 */
8209 {
8210 /*
8211 * We might have been asked to map child Vars to some parent relation.
8212 */
8214 {
8218 bool found = false;
8219
8220 /* Only map up to inheritance parents, not UNION ALL appendrels */
8224 {
8225 found = false;
8227 {
8229 break; /* safety check */
8232 break; /* Var is local to child */
8233 }
8234
8236 found = true;
8237
8238 /* If the parent is itself a child, continue up. */
8241 }
8242
8243 /*
8244 * If we found an ancestral rel, and that rel is included in
8245 * appendparents, print that column not the original one.
8246 */
8248 {
8249 varno = pvarno;
8250 varattno = pvarattno;
8251 }
8252 }
8253
8255
8256 /* might be returning old/new column value */
8258 refname = dpns->ret_old_alias;
8260 refname = dpns->ret_new_alias;
8261 else
8263
8265 attnum = varattno;
8266 }
8267 else
8268 {
8272 }
8273
8274 /*
8275 * The planner will sometimes emit Vars referencing resjunk elements of a
8276 * subquery's target list (this is currently only possible if it chooses
8277 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
8278 * Although we prefer to print subquery-referencing Vars using the
8279 * subquery's alias, that's not possible for resjunk items since they have
8280 * no alias. So in that case, drill down to the subplan and print the
8281 * contents of the referenced tlist item. This works because in a plan
8282 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
8283 * we'll have set dpns->inner_plan to reference the child plan node.
8284 */
8287 dpns->inner_plan)
8288 {
8291
8296
8299
8300 /*
8301 * Force parentheses because our caller probably assumed a Var is a
8302 * simple expression.
8303 */
8309
8312 }
8313
8314 /*
8315 * If it's an unnamed join, look at the expansion of the alias variable.
8316 * If it's a simple reference to one of the input vars, then recursively
8317 * print the name of that var instead. When it's not a simple reference,
8318 * we have to just print the unqualified join column name. (This can only
8319 * happen with "dangerous" merged columns in a JOIN USING; we took pains
8320 * previously to make the unqualified column name unique in such cases.)
8321 *
8322 * This wouldn't work in decompiling plan trees, because we don't store
8323 * joinaliasvars lists after planning; but a plan tree should never
8324 * contain a join alias variable.
8325 */
8327 {
8331 {
8333
8335 /* we intentionally don't strip implicit coercions here */
8337 {
8339 istoplevel, context);
8340 }
8341 }
8342
8343 /*
8344 * Unnamed join has no refname. (Note: since it's unnamed, there is
8345 * no way the user could have referenced it to create a whole-row Var
8346 * for it. So we don't have to cover that case below.)
8347 */
8349 }
8350
8354 {
8355 /* Get column name to use from the colinfo struct */
8360
8361 /*
8362 * If we find a Var referencing a dropped column, it seems better to
8363 * print something (anything) than to fail. In general this should
8364 * not happen, but it used to be possible for some cases involving
8365 * functions returning named composite types, and perhaps there are
8366 * still bugs out there.
8367 */
8370 }
8371 else
8372 {
8373 /* System column - name is fixed, get it from the catalog */
8375 }
8376
8379
8380 /*
8381 * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
8382 * clause, we may need to add a table-name prefix to prevent
8383 * findTargetlistEntrySQL92 from misinterpreting the name as an
8384 * output-column name. To avoid cluttering the output with unnecessary
8385 * prefixes, do so only if there is a name match to a SELECT tlist item
8386 * that is different from the Var.
8387 */
8389 {
8390 int colno = 0;
8391
8393 {
8394 char *colname;
8395
8397 continue; /* ignore junk entries */
8398 colno++;
8399
8400 /* This must match colname-choosing logic in get_target_list() */
8403 colno - 1)->attname);
8404 else
8405 colname = tle->resname;
8406
8409 {
8411 break;
8412 }
8413 }
8414 }
8415
8417 {
8420 }
8423 else
8424 {
8428 format_type_with_typemod(var->vartype,
8429 var->vartypmod));
8430 }
8431
8433}
8434
8435/*
8436 * Deparse a Var which references OUTER_VAR, INNER_VAR, or INDEX_VAR. This
8437 * routine is actually a callback for resolve_special_varno, which handles
8438 * finding the correct TargetEntry. We get the expression contained in that
8439 * TargetEntry and just need to deparse it, a job we can throw back on
8440 * get_rule_expr.
8441 */
8442static void
8444{
8446
8447 /*
8448 * For a non-Var referent, force parentheses because our caller probably
8449 * assumed a Var is a simple expression.
8450 */
8456}
8457
8458/*
8459 * Chase through plan references to special varnos (OUTER_VAR, INNER_VAR,
8460 * INDEX_VAR) until we find a real Var or some kind of non-Var node; then,
8461 * invoke the callback provided.
8462 */
8463static void
8466{
8467 Var *var;
8469
8470 /* This function is recursive, so let's be paranoid. */
8471 check_stack_depth();
8472
8473 /* If it's not a Var, invoke the callback. */
8475 {
8476 (*callback) (node, context, callback_arg);
8477 return;
8478 }
8479
8480 /* Find appropriate nesting depth */
8481 var = (Var *) node;
8483 var->varlevelsup);
8484
8485 /*
8486 * If varno is special, recurse. (Don't worry about varnosyn; if we're
8487 * here, we already decided not to use that.)
8488 */
8490 {
8494
8498
8499 /*
8500 * If we're descending to the first child of an Append or MergeAppend,
8501 * update appendparents. This will affect deparsing of all Vars
8502 * appearing within the eventually-resolved subexpression.
8503 */
8505
8512
8515 callback, callback_arg);
8518 return;
8519 }
8521 {
8524
8528
8531 callback, callback_arg);
8533 return;
8534 }
8536 {
8538
8542
8544 callback, callback_arg);
8545 return;
8546 }
8549
8550 /* Not special. Just invoke the callback. */
8551 (*callback) (node, context, callback_arg);
8552}
8553
8554/*
8555 * Get the name of a field of an expression of composite type. The
8556 * expression is usually a Var, but we handle other cases too.
8557 *
8558 * levelsup is an extra offset to interpret the Var's varlevelsup correctly.
8559 *
8560 * This is fairly straightforward when the expression has a named composite
8561 * type; we need only look up the type in the catalogs. However, the type
8562 * could also be RECORD. Since no actual table or view column is allowed to
8563 * have type RECORD, a Var of type RECORD must refer to a JOIN or FUNCTION RTE
8564 * or to a subquery output. We drill down to find the ultimate defining
8565 * expression and attempt to infer the field name from it. We ereport if we
8566 * can't determine the name.
8567 *
8568 * Similarly, a PARAM of type RECORD has to refer to some expression of
8569 * a determinable composite type.
8570 */
8571static const char *
8574{
8579 int varno;
8580 AttrNumber varattno;
8582 Node *expr;
8583
8584 /*
8585 * If it's a RowExpr that was expanded from a whole-row Var, use the
8586 * column names attached to it. (We could let get_expr_result_tupdesc()
8587 * handle this, but it's much cheaper to just pull out the name we need.)
8588 */
8590 {
8592
8595 }
8596
8597 /*
8598 * If it's a Param of type RECORD, try to find what the Param refers to.
8599 */
8601 {
8604
8606 if (expr)
8607 {
8608 /* Found a match, so recurse to decipher the field name */
8611
8614 0, context);
8617 }
8618 }
8619
8620 /*
8621 * If it's a Var of type RECORD, we have to find what the Var refers to;
8622 * if not, we can use get_expr_result_tupdesc().
8623 */
8625 var->vartype != RECORDOID)
8626 {
8628 /* Got the tupdesc, so we can extract the field name */
8631 }
8632
8633 /* Find appropriate nesting depth */
8637 var->varlevelsup, levelsup);
8639 netlevelsup);
8640
8641 /*
8642 * If we have a syntactic referent for the Var, and we're working from a
8643 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8644 * on the semantic referent. (See comments in get_variable().)
8645 */
8647 {
8648 varno = var->varnosyn;
8649 varattno = var->varattnosyn;
8650 }
8651 else
8652 {
8653 varno = var->varno;
8654 varattno = var->varattno;
8655 }
8656
8657 /*
8658 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8659 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8660 * down into the subplans, or INDEX_VAR, which is resolved similarly.
8661 *
8662 * Note: unlike get_variable and resolve_special_varno, we need not worry
8663 * about inheritance mapping: a child Var should have the same datatype as
8664 * its parent, and here we're really only interested in the Var's type.
8665 */
8667 {
8669 attnum = varattno;
8670 }
8672 {
8676
8680
8683
8685 levelsup, context);
8686
8689 }
8691 {
8695
8699
8702
8704 levelsup, context);
8705
8708 }
8710 {
8713
8717
8719
8721 levelsup, context);
8722
8724 }
8725 else
8726 {
8729 }
8730
8732 {
8733 /* Var is whole-row reference to RTE, so select the right field */
8735 }
8736
8737 /*
8738 * This part has essentially the same logic as the parser's
8739 * expandRecordVariable() function, but we are dealing with a different
8740 * representation of the input context, and we only need one field name
8741 * not a TupleDesc. Also, we need special cases for finding subquery and
8742 * CTE subplans when deparsing Plan trees.
8743 */
8745
8747 {
8753
8754 /*
8755 * This case should not occur: a column of a table, values list,
8756 * or ENR shouldn't have type RECORD. Fall through and fail (most
8757 * likely) at the bottom.
8758 */
8759 break;
8761 /* Subselect-in-FROM: examine sub-select's output expr */
8762 {
8764 {
8766 attnum);
8767
8773 {
8774 /*
8775 * Recurse into the sub-select to see what its Var
8776 * refers to. We have to build an additional level of
8777 * namespace to keep in step with varlevelsup in the
8778 * subselect; furthermore, the subquery RTE might be
8779 * from an outer query level, in which case the
8780 * namespace for the subselect must have that outer
8781 * level as parent namespace.
8782 */
8787
8789 netlevelsup);
8790
8792 parent_namespaces);
8793
8795
8797 0, context);
8798
8800
8802 }
8803 /* else fall through to inspect the expression */
8804 }
8805 else
8806 {
8807 /*
8808 * We're deparsing a Plan tree so we don't have complete
8809 * RTE entries (in particular, rte->subquery is NULL). But
8810 * the only place we'd normally see a Var directly
8811 * referencing a SUBQUERY RTE is in a SubqueryScan plan
8812 * node, and we can look into the child plan's tlist
8813 * instead. An exception occurs if the subquery was
8814 * proven empty and optimized away: then we'd find such a
8815 * Var in a childless Result node, and there's nothing in
8816 * the plan tree that would let us figure out what it had
8817 * originally referenced. In that case, fall back on
8818 * printing "fN", analogously to the default column names
8819 * for RowExprs.
8820 */
8824
8826 {
8828
8832 }
8834
8838 attnum);
8841
8843 levelsup, context);
8844
8847 }
8848 }
8849 break;
8851 /* Join RTE --- recursively inspect the alias variable */
8857 /* we intentionally don't strip implicit coercions here */
8860 var->varlevelsup + levelsup,
8861 context);
8862 /* else fall through to inspect the expression */
8863 break;
8866
8867 /*
8868 * We couldn't get here unless a function is declared with one of
8869 * its result columns as RECORD, which is not allowed.
8870 */
8871 break;
8873 /* CTE reference: examine subquery's output expr */
8874 {
8876 Index ctelevelsup;
8878
8879 /*
8880 * Try to find the referenced CTE using the namespace stack.
8881 */
8885 else
8886 {
8888
8892 {
8895 break;
8896 }
8897 }
8899 {
8902 attnum);
8903
8909 {
8910 /*
8911 * Recurse into the CTE to see what its Var refers to.
8912 * We have to build an additional level of namespace
8913 * to keep in step with varlevelsup in the CTE;
8914 * furthermore it could be an outer CTE (compare
8915 * SUBQUERY case above).
8916 */
8921
8923 ctelevelsup);
8924
8926 parent_namespaces);
8927
8929
8931 0, context);
8932
8934
8936 }
8937 /* else fall through to inspect the expression */
8938 }
8939 else
8940 {
8941 /*
8942 * We're deparsing a Plan tree so we don't have a CTE
8943 * list. But the only places we'd normally see a Var
8944 * directly referencing a CTE RTE are in CteScan or
8945 * WorkTableScan plan nodes. For those cases,
8946 * set_deparse_plan arranged for dpns->inner_plan to be
8947 * the plan node that emits the CTE or RecursiveUnion
8948 * result, and we can look at its tlist instead. As
8949 * above, this can fail if the CTE has been proven empty,
8950 * in which case fall back to "fN".
8951 */
8955
8957 {
8959
8963 }
8966
8970 attnum);
8973
8975 levelsup, context);
8976
8979 }
8980 }
8981 break;
8983
8984 /*
8985 * We couldn't get here: any Vars that reference the RTE_GROUP RTE
8986 * should have been replaced with the underlying grouping
8987 * expressions.
8988 */
8989 break;
8990 }
8991
8992 /*
8993 * We now have an expression we can't expand any more, so see if
8994 * get_expr_result_tupdesc() can do anything with it.
8995 */
8997 /* Got the tupdesc, so we can extract the field name */
9000}
9001
9002/*
9003 * Try to find the referenced expression for a PARAM_EXEC Param that might
9004 * reference a parameter supplied by an upper NestLoop or SubPlan plan node.
9005 *
9006 * If successful, return the expression and set *dpns_p and *ancestor_cell_p
9007 * appropriately for calling push_ancestor_plan(). If no referent can be
9008 * found, return NULL.
9009 */
9013{
9014 /* Initialize output parameters to prevent compiler warnings */
9017
9018 /*
9019 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
9020 * SubPlan argument. This will necessarily be in some ancestor of the
9021 * current expression's Plan node.
9022 */
9024 {
9028
9031
9033 {
9036
9037 /*
9038 * NestLoops transmit params to their inner child only.
9039 */
9042 {
9044
9046 {
9048
9050 {
9051 /* Found a match, so return it */
9055 }
9056 }
9057 }
9058
9059 /*
9060 * If ancestor is a SubPlan, check the arguments it provides.
9061 */
9063 {
9067
9069 {
9072
9074 {
9075 /*
9076 * Found a match, so return it. But, since Vars in
9077 * the arg are to be evaluated in the surrounding
9078 * context, we have to point to the next ancestor item
9079 * that is *not* a SubPlan.
9080 */
9082
9085 {
9087
9089 {
9093 }
9094 }
9096 }
9097 }
9098
9099 /* SubPlan isn't a kind of Plan, so skip the rest */
9100 continue;
9101 }
9102
9103 /*
9104 * We need not consider the ancestor's initPlan list, since
9105 * initplans never have any parParams.
9106 */
9107
9108 /* No luck, crawl up to next ancestor */
9110 }
9111 }
9112
9113 /* No referent found */
9115}
9116
9117/*
9118 * Try to find a subplan/initplan that emits the value for a PARAM_EXEC Param.
9119 *
9120 * If successful, return the generating subplan/initplan and set *column_p
9121 * to the subplan's 0-based output column number.
9122 * Otherwise, return NULL.
9123 */
9126{
9127 /* Initialize output parameter to prevent compiler warnings */
9128 *column_p = 0;
9129
9130 /*
9131 * If it's a PARAM_EXEC parameter, search the current plan node as well as
9132 * ancestor nodes looking for a subplan or initplan that emits the value
9133 * for the Param. It could appear in the setParams of an initplan or
9134 * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
9135 */
9137 {
9141
9143
9144 /* First check the innermost plan node's initplans */
9148
9149 /*
9150 * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
9151 * which can be referenced by Params elsewhere in the targetlist.
9152 * (Such Params should always be in the same targetlist, so there's no
9153 * need to do this work at upper plan nodes.)
9154 */
9156 {
9158 {
9160
9162 {
9164 {
9166 {
9167 /* Found a match, so return it. */
9169 return subplan;
9170 }
9171 }
9172 }
9173 }
9174 }
9175
9176 /* No luck, so check the ancestor nodes */
9178 {
9180
9181 /*
9182 * If ancestor is a SubPlan, check the paramIds it provides.
9183 */
9185 {
9187
9189 {
9191 {
9192 /* Found a match, so return it. */
9194 return subplan;
9195 }
9196 }
9197
9198 /* SubPlan isn't a kind of Plan, so skip the rest */
9199 continue;
9200 }
9201
9202 /*
9203 * Otherwise, it's some kind of Plan node, so check its initplans.
9204 */
9206 column_p);
9209
9210 /* No luck, crawl up to next ancestor */
9211 }
9212 }
9213
9214 /* No generator found */
9216}
9217
9218/*
9219 * Subroutine for find_param_generator: search one Plan node's initplans
9220 */
9223{
9225 {
9227 {
9229 {
9230 /* Found a match, so return it. */
9232 return subplan;
9233 }
9234 }
9235 }
9237}
9238
9239/*
9240 * Display a Param appropriately.
9241 */
9242static void
9244{
9245 Node *expr;
9248 SubPlan *subplan;
9250
9251 /*
9252 * If it's a PARAM_EXEC parameter, try to locate the expression from which
9253 * the parameter was computed. This stanza handles only cases in which
9254 * the Param represents an input to the subplan we are currently in.
9255 */
9257 if (expr)
9258 {
9259 /* Found a match, so print it */
9263
9264 /* Switch attention to the ancestor plan node */
9266
9267 /*
9268 * Force prefixing of Vars, since they won't belong to the relation
9269 * being scanned in the original plan node.
9270 */
9273
9274 /*
9275 * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
9276 * upper-level Param, which wouldn't need extra parentheses.
9277 * Otherwise, insert parens to ensure the expression looks atomic.
9278 */
9285
9287
9290
9292
9294
9295 return;
9296 }
9297
9298 /*
9299 * Alternatively, maybe it's a subplan output, which we print as a
9300 * reference to the subplan. (We could drill down into the subplan and
9301 * print the relevant targetlist expression, but that has been deemed too
9302 * confusing since it would violate normal SQL scope rules. Also, we're
9303 * relying on this reference to show that the testexpr containing the
9304 * Param has anything to do with that subplan at all.)
9305 */
9307 if (subplan)
9308 {
9310
9313 else
9315
9318 nameprefix,
9319 subplan->plan_name, column + 1);
9320
9321 return;
9322 }
9323
9324 /*
9325 * If it's an external parameter, see if the outermost namespace provides
9326 * function argument names.
9327 */
9329 {
9332 param->paramid > 0 &&
9334 {
9336
9337 if (argname)
9338 {
9341
9342 /*
9343 * Qualify the parameter name if there are any other deparse
9344 * namespaces with range tables. This avoids qualifying in
9345 * trivial cases like "RETURN a + b", but makes it safe in all
9346 * other cases.
9347 */
9349 {
9351
9353 {
9355 break;
9356 }
9357 }
9359 {
9362 }
9363
9365 return;
9366 }
9367 }
9368 }
9369
9370 /*
9371 * Not PARAM_EXEC, or couldn't find referent: just print $N.
9372 *
9373 * It's a bug if we get here for anything except PARAM_EXTERN Params, but
9374 * in production builds printing $N seems more useful than failing.
9375 */
9377
9379}
9380
9381/*
9382 * get_simple_binary_op_name
9383 *
9384 * helper function for isSimpleNode
9385 * will return single char binary operator name, or NULL if it's not
9386 */
9387static const char *
9389{
9391
9393 {
9394 /* binary operator */
9397 const char *op;
9398
9401 return op;
9402 }
9404}
9405
9406
9407/*
9408 * isSimpleNode - check if given node is simple (doesn't need parenthesizing)
9409 *
9410 * true : simple in the context of parent node's type
9411 * false : not simple
9412 */
9413static bool
9415{
9416 if (!node)
9417 return false;
9418
9420 {
9427 /* single words: always simple */
9428 return true;
9429
9446 /* function-like: name(..) or name[..] */
9447 return true;
9448
9449 /* CASE keywords act as parentheses */
9451 return true;
9452
9454
9455 /*
9456 * appears simple since . has top precedence, unless parent is
9457 * T_FieldSelect itself!
9458 */
9460
9462
9463 /*
9464 * treat like FieldSelect (probably doesn't matter)
9465 */
9467
9469 /* maybe simple, check args */
9471 node, prettyFlags);
9474 node, prettyFlags);
9477 node, prettyFlags);
9480 node, prettyFlags);
9483 node, prettyFlags);
9486 node, prettyFlags);
9487
9489 {
9490 /* depends on parent node type; needs further checking */
9492 {
9493 const char *op;
9499
9501 if (!op)
9502 return false;
9503
9504 /* We know only the basic operators + - and * / % */
9508 return false;
9509
9512 return false;
9513
9517 return false;
9518
9520 return true; /* op binds tighter than parent */
9521
9523 return false;
9524
9525 /*
9526 * Operators are same priority --- can skip parens only if
9527 * we have (a - b) - c, not a - (b - c).
9528 */
9530 return true;
9531
9532 return false;
9533 }
9534 /* else do the same stuff as for T_SubLink et al. */
9535 }
9536 pg_fallthrough;
9537
9544 {
9546 {
9547 /* special handling for casts and COERCE_SQL_SYNTAX */
9549
9553 return false;
9554 return true; /* own parentheses */
9555 }
9568 return true;
9569 default:
9570 return false;
9571 }
9572
9575 {
9578 {
9581
9585 {
9589 return true;
9590 break;
9593 return true;
9594 break;
9595 }
9596 }
9597 return false;
9599 {
9600 /* special handling for casts and COERCE_SQL_SYNTAX */
9602
9606 return false;
9607 return true; /* own parentheses */
9608 }
9621 return true;
9622 default:
9623 return false;
9624 }
9625
9627 /* maybe simple, check args */
9629 node, prettyFlags);
9630
9631 default:
9632 break;
9633 }
9634 /* those we don't know: in dubio complexo */
9635 return false;
9636}
9637
9638
9639/*
9640 * appendContextKeyword - append a keyword to buffer
9641 *
9642 * If prettyPrint is enabled, perform a line break, and adjust indentation.
9643 * Otherwise, just append the keyword.
9644 */
9645static void
9648{
9650
9652 {
9654
9656
9657 /* remove any trailing spaces currently in the buffer ... */
9659 /* ... then add a newline and some spaces */
9661
9664 else
9665 {
9666 /*
9667 * If we're indented more than PRETTYINDENT_LIMIT characters, try
9668 * to conserve horizontal space by reducing the per-level
9669 * indentation. For best results the scale factor here should
9670 * divide all the indent amounts that get added to indentLevel
9671 * (PRETTYINDENT_STD, etc). It's important that the indentation
9672 * not grow unboundedly, else deeply-nested trees use O(N^2)
9673 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
9674 */
9677 (PRETTYINDENT_STD / 2);
9679 /* scale/wrap logic affects indentLevel, but not indentPlus */
9681 }
9683
9685
9688 context->indentLevel = 0;
9689 }
9690 else
9692}
9693
9694/*
9695 * removeStringInfoSpaces - delete trailing spaces from a buffer.
9696 *
9697 * Possibly this should move to stringinfo.c at some point.
9698 */
9699static void
9701{
9704}
9705
9706
9707/*
9708 * get_rule_expr_paren - deparse expr using get_rule_expr,
9709 * embracing the string with parentheses if necessary for prettyPrint.
9710 *
9711 * Never embrace if prettyFlags=0, because it's done in the calling node.
9712 *
9713 * Any node that does *not* embrace its argument node by sql syntax (with
9714 * parentheses, non-operator keywords like CASE/WHEN/ON, or comma etc) should
9715 * use get_rule_expr_paren instead of get_rule_expr so parentheses can be
9716 * added.
9717 */
9718static void
9721{
9723
9726
9729
9731
9734}
9735
9736static void
9739{
9740 /*
9741 * The order of array elements must correspond to the order of
9742 * JsonBehaviorType members.
9743 */
9745 {
9746 " NULL",
9747 " ERROR",
9748 " EMPTY",
9749 " TRUE",
9750 " FALSE",
9751 " UNKNOWN",
9752 " EMPTY ARRAY",
9753 " EMPTY OBJECT",
9754 " DEFAULT "
9755 };
9756
9759
9761
9764
9766}
9767
9768/*
9769 * get_json_expr_options
9770 *
9771 * Parse back common options for JSON_QUERY, JSON_VALUE, JSON_EXISTS and
9772 * JSON_TABLE columns.
9773 */
9774static void
9777{
9779 {
9784 /* The default */
9787
9790 /* The default */
9791 else
9793 }
9794
9797
9800}
9801
9802/* ----------
9803 * get_rule_expr - Parse back an expression
9804 *
9805 * Note: showimplicit determines whether we display any implicit cast that
9806 * is present at the top of the expression tree. It is a passed argument,
9807 * not a field of the context struct, because we change the value as we
9808 * recurse down into the expression. In general we suppress implicit casts
9809 * when the result type is known with certainty (eg, the arguments of an
9810 * OR must be boolean). We display implicit casts for arguments of functions
9811 * and operators, since this is needed to be certain that the same function
9812 * or operator will be chosen when the expression is re-parsed.
9813 * ----------
9814 */
9815static void
9818{
9820
9822 return;
9823
9824 /* Guard against excessively long or deeply-nested queries */
9825 CHECK_FOR_INTERRUPTS();
9826 check_stack_depth();
9827
9828 /*
9829 * Each level of get_rule_expr must emit an indivisible term
9830 * (parenthesized if necessary) to ensure result is reparsed into the same
9831 * expression tree. The only exception is that when the input is a List,
9832 * we emit the component items comma-separated with no surrounding
9833 * decoration; this is convenient for most callers.
9834 */
9836 {
9839 break;
9840
9843 break;
9844
9847 break;
9848
9851 break;
9852
9854 {
9856
9860 }
9861 break;
9862
9865 break;
9866
9869 break;
9870
9872 {
9875
9876 /*
9877 * If the argument is a CaseTestExpr, we must be inside a
9878 * FieldStore, ie, we are assigning to an element of an array
9879 * within a composite column. Since we already punted on
9880 * displaying the FieldStore's target information, just punt
9881 * here too, and display only the assignment source
9882 * expression.
9883 */
9885 {
9888 context, showimplicit);
9889 break;
9890 }
9891
9892 /*
9893 * Parenthesize the argument unless it's a simple Var or a
9894 * FieldSelect. (In particular, if it's another
9895 * SubscriptingRef, we *must* parenthesize to avoid
9896 * confusion.)
9897 */
9905
9906 /*
9907 * If there's a refassgnexpr, we want to print the node in the
9908 * format "container[subscripts] := refassgnexpr". This is
9909 * not legal SQL, so decompilation of INSERT or UPDATE
9910 * statements should always use processIndirection as part of
9911 * the statement-level syntax. We should only see this when
9912 * EXPLAIN tries to print the targetlist of a plan resulting
9913 * from such a statement.
9914 */
9916 {
9917 Node *refassgnexpr;
9918
9919 /*
9920 * Use processIndirection to print this node's subscripts
9921 * as well as any additional field selections or
9922 * subscripting in immediate descendants. It returns the
9923 * RHS expr that is actually being "assigned".
9924 */
9925 refassgnexpr = processIndirection(node, context);
9928 }
9929 else
9930 {
9931 /* Just an ordinary container fetch, so print subscripts */
9932 printSubscripts(sbsref, context);
9933 }
9934 }
9935 break;
9936
9939 break;
9940
9942 {
9944
9947 }
9948 break;
9949
9952 break;
9953
9955 {
9960
9968 }
9969 break;
9970
9972 {
9974
9978 }
9979 break;
9980
9982 {
9987
9997
9998 /*
9999 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
10000 * a bare sub-SELECT. Since we're here, the sub-SELECT must
10001 * be meant as a scalar sub-SELECT yielding an array value to
10002 * be used in ScalarArrayOpExpr; but the grammar will
10003 * preferentially interpret such a construct as an ANY/ALL
10004 * SubLink. To prevent misparsing the output that way, insert
10005 * a dummy coercion (which will be stripped by parse analysis,
10006 * so no inefficiency is added in dump and reload). This is
10007 * indeed most likely what the user wrote to get the construct
10008 * accepted in the first place.
10009 */
10018 }
10019 break;
10020
10022 {
10026
10028 {
10033 false, node);
10035 {
10038 false, node);
10039 }
10042 break;
10043
10048 false, node);
10050 {
10053 false, node);
10054 }
10057 break;
10058
10064 false, node);
10067 break;
10068
10069 default:
10072 }
10073 }
10074 break;
10075
10078 break;
10079
10081 {
10083
10084 /*
10085 * We cannot see an already-planned subplan in rule deparsing,
10086 * only while EXPLAINing a query plan. We don't try to
10087 * reconstruct the original SQL, just reference the subplan
10088 * that appears elsewhere in EXPLAIN's result. It does seem
10089 * useful to show the subLinkType and testexpr (if any), and
10090 * we also note whether the subplan will be hashed.
10091 */
10093 {
10097 break;
10101 break;
10105 break;
10107 /* Parenthesizing the testexpr seems sufficient */
10110 break;
10112 /* No need to decorate these subplan references */
10115 break;
10117 /* MULTIEXPR isn't executed in the normal way */
10120 break;
10124 break;
10126 /* This case is unreachable within expressions */
10129 break;
10130 }
10131
10133 {
10135
10136 /*
10137 * Push SubPlan into ancestors list while deparsing
10138 * testexpr, so that we can handle PARAM_EXEC references
10139 * to the SubPlan's paramIds. (This makes it look like
10140 * the SubPlan is an "ancestor" of the current plan node,
10141 * which is a little weird, but it does no harm.) In this
10142 * path, we don't need to mention the SubPlan explicitly,
10143 * because the referencing Params will show its existence.
10144 */
10147
10150
10152 }
10153 else
10154 {
10156
10157 /* No referencing Params, so show the SubPlan's name */
10160 else
10165 else
10168 }
10169 }
10170 break;
10171
10173 {
10176
10177 /*
10178 * This case cannot be reached in normal usage, since no
10179 * AlternativeSubPlan can appear either in parsetrees or
10180 * finished plan trees. We keep it just in case somebody
10181 * wants to use this code to print planner data structures.
10182 */
10185 {
10188
10191 else
10195 splan->plan_name);
10196 else
10198 splan->plan_name);
10201 }
10203 }
10204 break;
10205
10207 {
10211 const char *fieldname;
10213
10214 /*
10215 * Parenthesize the argument unless it's a SubscriptingRef or
10216 * another FieldSelect. Note in particular that it would be
10217 * WRONG to not parenthesize a Var argument; simplicity is not
10218 * the issue here, having the right number of names is.
10219 */
10227
10228 /*
10229 * Get and print the field name.
10230 */
10232 0, context);
10234 }
10235 break;
10236
10238 {
10241
10242 /*
10243 * There is no good way to represent a FieldStore as real SQL,
10244 * so decompilation of INSERT or UPDATE statements should
10245 * always use processIndirection as part of the
10246 * statement-level syntax. We should only get here when
10247 * EXPLAIN tries to print the targetlist of a plan resulting
10248 * from such a statement. The plan case is even harder than
10249 * ordinary rules would be, because the planner tries to
10250 * collapse multiple assignments to the same field or subfield
10251 * into one FieldStore; so we can see a list of target fields
10252 * not just one, and the arguments could be FieldStores
10253 * themselves. We don't bother to try to print the target
10254 * field names; we just print the source arguments, with a
10255 * ROW() around them if there's more than one. This isn't
10256 * terribly complete, but it's probably good enough for
10257 * EXPLAIN's purposes; especially since anything more would be
10258 * either hopelessly confusing or an even poorer
10259 * representation of what the plan is actually doing.
10260 */
10267 }
10268 break;
10269
10271 {
10274
10276 !showimplicit)
10277 {
10278 /* don't show the implicit cast */
10280 }
10281 else
10282 {
10284 relabel->resulttype,
10285 relabel->resulttypmod,
10286 node);
10287 }
10288 }
10289 break;
10290
10292 {
10295
10297 !showimplicit)
10298 {
10299 /* don't show the implicit cast */
10301 }
10302 else
10303 {
10305 iocoerce->resulttype,
10306 -1,
10307 node);
10308 }
10309 }
10310 break;
10311
10313 {
10316
10318 !showimplicit)
10319 {
10320 /* don't show the implicit cast */
10322 }
10323 else
10324 {
10326 acoerce->resulttype,
10327 acoerce->resulttypmod,
10328 node);
10329 }
10330 }
10331 break;
10332
10334 {
10337
10339 !showimplicit)
10340 {
10341 /* don't show the implicit cast */
10343 }
10344 else
10345 {
10347 convert->resulttype, -1,
10348 node);
10349 }
10350 }
10351 break;
10352
10354 {
10357
10362 generate_collation_name(collate->collOid));
10365 }
10366 break;
10367
10369 {
10372
10374 0, PRETTYINDENT_VAR, 0);
10376 {
10379 }
10381 {
10384
10386 {
10387 /*
10388 * The parser should have produced WHEN clauses of the
10389 * form "CaseTestExpr = RHS", possibly with an
10390 * implicit coercion inserted above the CaseTestExpr.
10391 * For accurate decompilation of rules it's essential
10392 * that we show just the RHS. However in an
10393 * expression that's been through the optimizer, the
10394 * WHEN clause could be almost anything (since the
10395 * equality operator could have been expanded into an
10396 * inline function). If we don't recognize the form
10397 * of the WHEN clause, just punt and display it as-is.
10398 */
10400 {
10402
10405 CaseTestExpr))
10407 }
10408 }
10409
10413 0, 0, 0);
10417 }
10421 0, 0, 0);
10426 -PRETTYINDENT_VAR, 0, 0);
10427 }
10428 break;
10429
10431 {
10432 /*
10433 * Normally we should never get here, since for expressions
10434 * that can contain this node type we attempt to avoid
10435 * recursing to it. But in an optimized expression we might
10436 * be unable to avoid that (see comments for CaseExpr). If we
10437 * do see one, print it as CASE_TEST_EXPR.
10438 */
10440 }
10441 break;
10442
10444 {
10446
10450
10451 /*
10452 * If the array isn't empty, we assume its elements are
10453 * coerced to the desired type. If it's empty, though, we
10454 * need an explicit coercion to the array type.
10455 */
10458 format_type_with_typemod(arrayexpr->array_typeid, -1));
10459 }
10460 break;
10461
10463 {
10469
10470 /*
10471 * If it's a named type and not RECORD, we may have to skip
10472 * dropped columns and/or claim there are NULLs for added
10473 * columns.
10474 */
10476 {
10477 tupdesc = lookup_rowtype_tupdesc(rowexpr->row_typeid, -1);
10479 }
10480
10481 /*
10482 * SQL99 allows "ROW" to be omitted when there is more than
10483 * one column, but for simplicity we always print it.
10484 */
10487 i = 0;
10489 {
10491
10494 {
10496 /* Whole-row Vars need special treatment here */
10499 }
10500 i++;
10501 }
10503 {
10505 {
10507 {
10511 }
10512 i++;
10513 }
10514
10515 ReleaseTupleDesc(tupdesc);
10516 }
10520 format_type_with_typemod(rowexpr->row_typeid, -1));
10521 }
10522 break;
10523
10525 {
10527
10528 /*
10529 * SQL99 allows "ROW" to be omitted when there is more than
10530 * one column, but for simplicity we always print it. Within
10531 * a ROW expression, whole-row Vars need special treatment, so
10532 * use get_rule_list_toplevel.
10533 */
10536
10537 /*
10538 * We assume that the name of the first-column operator will
10539 * do for all the rest too. This is definitely open to
10540 * failure, eg if some but not all operators were renamed
10541 * since the construct was parsed, but there seems no way to
10542 * be perfect.
10543 */
10550 }
10551 break;
10552
10554 {
10556
10560 }
10561 break;
10562
10564 {
10566
10568 {
10571 break;
10574 break;
10575 }
10578 }
10579 break;
10580
10582 {
10584
10585 /*
10586 * Note: this code knows that typmod for time, timestamp, and
10587 * timestamptz just prints as integer.
10588 */
10590 {
10593 break;
10596 break;
10599 break;
10602 break;
10605 svf->typmod);
10606 break;
10609 break;
10612 break;
10615 break;
10618 svf->typmod);
10619 break;
10622 break;
10625 break;
10628 break;
10631 break;
10634 break;
10637 break;
10638 }
10639 }
10640 break;
10641
10643 {
10648 Const *con;
10649
10651 {
10654 break;
10657 break;
10660 break;
10663 break;
10666 break;
10669 break;
10672 break;
10674 break;
10675 }
10677 {
10680 else
10682 }
10683 if (xexpr->name)
10684 {
10688 }
10690 {
10692 {
10697 }
10699 {
10702
10709 }
10712 }
10714 {
10718 {
10724 /* no extra decoration needed */
10726 break;
10729
10731 context, true);
10732
10734 Assert(!con->constisnull);
10737 " PRESERVE WHITESPACE");
10738 else
10740 " STRIP WHITESPACE");
10741 break;
10744
10746 context, true);
10747
10751 con->constisnull)
10753 else
10755
10757 if (con->constisnull)
10758 /* suppress STANDALONE NO VALUE */ ;
10759 else
10760 {
10762 {
10765 ", STANDALONE YES");
10766 break;
10769 ", STANDALONE NO");
10770 break;
10773 ", STANDALONE NO VALUE");
10774 break;
10775 default:
10776 break;
10777 }
10778 }
10779 break;
10782 break;
10783 }
10784 }
10786 {
10788 format_type_with_typemod(xexpr->type,
10789 xexpr->typmod));
10792 else
10794 }
10795
10798 else
10800 }
10801 break;
10802
10804 {
10806
10810
10811 /*
10812 * For scalar inputs, we prefer to print as IS [NOT] NULL,
10813 * which is shorter and traditional. If it's a rowtype input
10814 * but we're applying a scalar test, must print IS [NOT]
10815 * DISTINCT FROM NULL to be semantically correct.
10816 */
10819 {
10821 {
10824 break;
10827 break;
10828 default:
10831 }
10832 }
10833 else
10834 {
10836 {
10839 break;
10842 break;
10843 default:
10846 }
10847 }
10850 }
10851 break;
10852
10854 {
10856
10861 {
10864 break;
10867 break;
10870 break;
10873 break;
10876 break;
10879 break;
10880 default:
10883 }
10886 }
10887 break;
10888
10890 {
10893
10895 !showimplicit)
10896 {
10897 /* don't show the implicit cast */
10899 }
10900 else
10901 {
10903 ctest->resulttype,
10904 ctest->resulttypmod,
10905 node);
10906 }
10907 }
10908 break;
10909
10912 break;
10913
10916 break;
10917
10919 {
10921
10925 else
10927 cexpr->cursor_param);
10928 }
10929 break;
10930
10932 {
10934
10935 /*
10936 * This isn't exactly nextval(), but that seems close enough
10937 * for EXPLAIN's purposes.
10938 */
10942 NIL));
10944 }
10945 break;
10946
10948 {
10952
10953 /*
10954 * InferenceElem can only refer to target relation, so a
10955 * prefix is not useful, and indeed would cause parse errors.
10956 */
10959
10960 /*
10961 * Parenthesize the element unless it's a simple Var or a bare
10962 * function call. Follows pg_get_indexdef_worker().
10963 */
10967 COERCE_EXPLICIT_CALL)
10969
10973 context, false);
10976
10978
10982
10983 /* Add the operator class name, if not default */
10985 {
10988
10990 }
10991 }
10992 break;
10993
10995 {
10997
10998 /*
10999 * We cannot see a ReturningExpr in rule deparsing, only while
11000 * EXPLAINing a query plan (ReturningExpr nodes are only ever
11001 * adding during query rewriting). Just display the expression
11002 * returned (an expanded view column).
11003 */
11005 }
11006 break;
11007
11009 {
11011 ListCell *cell;
11013
11015 {
11017 break;
11018 }
11019
11021 {
11025
11029 break;
11030
11033
11037 {
11039
11043 }
11044
11046 break;
11047
11053
11057 break;
11058
11059 default:
11062 break;
11063 }
11064 }
11065 break;
11066
11068 {
11070
11073 }
11074 break;
11075
11078 break;
11079
11081 {
11083
11086
11088
11090
11091 /* TODO: handle FORMAT clause */
11092
11094 {
11097 break;
11100 break;
11103 break;
11104 default:
11105 break;
11106 }
11107
11110
11113 }
11114 break;
11115
11117 {
11119
11121 {
11124 break;
11127 break;
11130 break;
11131 default:
11134 }
11135
11137
11139
11141
11143 {
11145 *lc2;
11147
11149
11152 {
11156
11160 }
11161 }
11162
11167
11170 JSON_BEHAVIOR_NULL :
11171 JSON_BEHAVIOR_FALSE);
11172
11174 }
11175 break;
11176
11178 {
11180 ListCell *l;
11181
11184 {
11188 }
11189 }
11190 break;
11191
11194 break;
11195
11197 {
11199
11200 appendStringInfo(buf, "%s.%s", quote_identifier(gpr->elvarname), quote_identifier(get_propgraph_property_name(gpr->propid)));
11201 break;
11202 }
11203
11204 default:
11206 break;
11207 }
11208}
11209
11210/*
11211 * get_rule_expr_toplevel - Parse back a toplevel expression
11212 *
11213 * Same as get_rule_expr(), except that if the expr is just a Var, we pass
11214 * istoplevel = true not false to get_variable(). This causes whole-row Vars
11215 * to get printed with decoration that will prevent expansion of "*".
11216 * We need to use this in contexts such as ROW() and VALUES(), where the
11217 * parser would expand "foo.*" appearing at top level. (In principle we'd
11218 * use this in get_target_list() too, but that has additional worries about
11219 * whether to print AS, so it needs to invoke get_variable() directly anyway.)
11220 */
11221static void
11224{
11227 else
11229}
11230
11231/*
11232 * get_rule_list_toplevel - Parse back a list of toplevel expressions
11233 *
11234 * Apply get_rule_expr_toplevel() to each element of a List.
11235 *
11236 * This adds commas between the expressions, but caller is responsible
11237 * for printing surrounding decoration.
11238 */
11239static void
11242{
11245
11248 {
11250
11254 }
11255}
11256
11257/*
11258 * get_rule_expr_funccall - Parse back a function-call expression
11259 *
11260 * Same as get_rule_expr(), except that we guarantee that the output will
11261 * look like a function call, or like one of the things the grammar treats as
11262 * equivalent to a function call (see the func_expr_windowless production).
11263 * This is needed in places where the grammar uses func_expr_windowless and
11264 * you can't substitute a parenthesized a_expr. If what we have isn't going
11265 * to look like a function call, wrap it in a dummy CAST() expression, which
11266 * will satisfy the grammar --- and, indeed, is likely what the user wrote to
11267 * produce such a thing.
11268 */
11269static void
11272{
11275 else
11276 {
11278
11280 /* no point in showing any top-level implicit cast */
11284 exprTypmod(node)));
11285 }
11286}
11287
11288/*
11289 * Helper function to identify node types that satisfy func_expr_windowless.
11290 * If in doubt, "false" is always a safe answer.
11291 */
11292static bool
11294{
11296 return false; /* probably shouldn't happen */
11298 {
11300 /* OK, unless it's going to deparse as a cast */
11309 /* these are all accepted by func_expr_common_subexpr */
11310 return true;
11311 default:
11312 break;
11313 }
11314 return false;
11315}
11316
11317
11318/*
11319 * get_oper_expr - Parse back an OpExpr node
11320 */
11321static void
11323{
11327
11331 {
11332 /* binary operator */
11335
11338 generate_operator_name(opno,
11342 }
11343 else
11344 {
11345 /* prefix operator */
11347
11349 generate_operator_name(opno,
11350 InvalidOid,
11353 }
11356}
11357
11358/*
11359 * get_func_expr - Parse back a FuncExpr node
11360 */
11361static void
11364{
11368 int nargs;
11369 List *argnames;
11371 ListCell *l;
11372
11373 /*
11374 * If the function call came from an implicit coercion, then just show the
11375 * first argument --- unless caller wants to see implicit coercions.
11376 */
11378 {
11381 return;
11382 }
11383
11384 /*
11385 * If the function call came from a cast, then show the first argument
11386 * plus an explicit cast operation.
11387 */
11389 expr->funcformat == COERCE_IMPLICIT_CAST)
11390 {
11392 Oid rettype = expr->funcresulttype;
11394
11395 /* Get the typmod if this is a length-coercion function */
11397
11399 rettype, coercedTypmod,
11400 (Node *) expr);
11401
11402 return;
11403 }
11404
11405 /*
11406 * If the function was called using one of the SQL spec's random special
11407 * syntaxes, try to reproduce that. If we don't recognize the function,
11408 * fall through.
11409 */
11411 {
11413 return;
11414 }
11415
11416 /*
11417 * Normal function: display as proname(args). First we need to extract
11418 * the argument datatypes.
11419 */
11424 nargs = 0;
11425 argnames = NIL;
11427 {
11429
11433 nargs++;
11434 }
11435
11438 argnames, argtypes,
11439 expr->funcvariadic,
11440 &use_variadic,
11441 context->inGroupBy));
11442 nargs = 0;
11444 {
11445 if (nargs++ > 0)
11450 }
11452}
11453
11454/*
11455 * get_agg_expr - Parse back an Aggref node
11456 */
11457static void
11460{
11462 false);
11463}
11464
11465/*
11466 * get_agg_expr_helper - subroutine for get_agg_expr and
11467 * get_json_agg_constructor
11468 */
11469static void
11473{
11476 int nargs;
11478
11479 /*
11480 * For a combining aggregate, we look up and deparse the corresponding
11481 * partial aggregate instead. This is necessary because our input
11482 * argument list has been replaced; the new argument list always has just
11483 * one element, which will point to a partial Aggref that supplies us with
11484 * transition states to combine.
11485 */
11487 {
11489
11494 return;
11495 }
11496
11497 /*
11498 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
11499 * to avoid printing this when recursing from the code just above.
11500 */
11503
11504 /* Extract the argument types as seen by the parser */
11505 nargs = get_aggregate_argtypes(aggref, argtypes);
11506
11509 argtypes, aggref->aggvariadic,
11510 &use_variadic,
11511 context->inGroupBy);
11512
11513 /* Print the aggregate name, schema-qualified if needed */
11516
11518 {
11519 /*
11520 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
11521 * worry about inserting VARIADIC. So we can just dump the direct
11522 * args as-is.
11523 */
11524 Assert(!aggref->aggvariadic);
11529 }
11530 else
11531 {
11532 /* aggstar can be set only in zero-argument aggregates */
11533 if (aggref->aggstar)
11535 else
11536 {
11537 ListCell *l;
11539
11540 i = 0;
11542 {
11545
11548 continue;
11550 {
11552 {
11553 /*
11554 * the ABSENT ON NULL and WITH UNIQUE args are printed
11555 * separately, so ignore them here
11556 */
11558 break;
11559
11561 }
11562 else
11564 }
11568 }
11569 }
11570
11572 {
11575 }
11576 }
11577
11580
11582 {
11585 }
11586
11588}
11589
11590/*
11591 * This is a helper function for get_agg_expr(). It's used when we deparse
11592 * a combining Aggref; resolve_special_varno locates the corresponding partial
11593 * Aggref and then calls this.
11594 */
11595static void
11597{
11598 Aggref *aggref;
11600
11603
11604 aggref = (Aggref *) node;
11606}
11607
11608/*
11609 * get_windowfunc_expr - Parse back a WindowFunc node
11610 */
11611static void
11613{
11615}
11616
11617
11618/*
11619 * get_windowfunc_expr_helper - subroutine for get_windowfunc_expr and
11620 * get_json_agg_constructor
11621 */
11622static void
11626{
11629 int nargs;
11630 List *argnames;
11631 ListCell *l;
11632
11637 nargs = 0;
11638 argnames = NIL;
11640 {
11642
11646 nargs++;
11647 }
11648
11652 context->inGroupBy);
11653
11655
11656 /* winstar can be set only in zero-argument aggregates */
11657 if (wfunc->winstar)
11659 else
11660 {
11662 {
11666 }
11667 else
11669 }
11670
11673
11675 {
11678 }
11679
11681
11684
11686
11688 {
11689 /* Query-decompilation case: search the windowClause list */
11691 {
11693
11695 {
11696 if (wc->name)
11698 else
11700 break;
11701 }
11702 }
11705 wfunc->winref);
11706 }
11707 else
11708 {
11709 /*
11710 * In EXPLAIN, search the namespace stack for a matching WindowAgg
11711 * node (probably it's always the first entry), and print winname.
11712 */
11714 {
11716
11718 {
11720
11722 {
11724 break;
11725 }
11726 }
11727 }
11730 wfunc->winref);
11731 }
11732}
11733
11734/*
11735 * get_func_sql_syntax - Parse back a SQL-syntax function call
11736 *
11737 * Returns true if we successfully deparsed, false if we did not
11738 * recognize the function.
11739 */
11740static bool
11742{
11745
11747 {
11754 /* AT TIME ZONE ... note reversed argument order */
11757 (Node *) expr);
11760 (Node *) expr);
11762 return true;
11763
11767 /* AT LOCAL */
11770 (Node *) expr);
11772 return true;
11773
11787 /* (x1, x2) OVERLAPS (y1, y2) */
11797 return true;
11798
11805 /* EXTRACT (x FROM y) */
11807 {
11809
11812 !con->constisnull);
11814 }
11818 return true;
11819
11821 /* IS xxx NORMALIZED */
11824 (Node *) expr);
11827 {
11829
11832 !con->constisnull);
11834 TextDatumGetCString(con->constvalue));
11835 }
11837 return true;
11838
11840 /* COLLATION FOR */
11844 return true;
11845
11847 /* NORMALIZE() */
11851 {
11853
11856 !con->constisnull);
11858 TextDatumGetCString(con->constvalue));
11859 }
11861 return true;
11862
11869 /* OVERLAY() */
11877 {
11880 }
11882 return true;
11883
11887 /* POSITION() ... extra parens since args are b_expr not a_expr */
11893 return true;
11894
11901 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
11907 {
11910 }
11912 return true;
11913
11915 /* SUBSTRING SIMILAR/ESCAPE */
11923 return true;
11924
11928 /* TRIM() */
11931 {
11934 }
11938 return true;
11939
11943 /* TRIM() */
11946 {
11949 }
11953 return true;
11954
11958 /* TRIM() */
11961 {
11964 }
11968 return true;
11969
11972 return true;
11973
11975 /* XMLEXISTS ... extra parens because args are c_expr */
11981 return true;
11982 }
11983 return false;
11984}
11985
11986/* ----------
11987 * get_coercion_expr
11988 *
11989 * Make a string representation of a value coerced to a specific type
11990 * ----------
11991 */
11992static void
11996{
11998
11999 /*
12000 * Since parse_coerce.c doesn't immediately collapse application of
12001 * length-coercion functions to constants, what we'll typically see in
12002 * such cases is a Const with typmod -1 and a length-coercion function
12003 * right above it. Avoid generating redundant output. However, beware of
12004 * suppressing casts when the user actually wrote something like
12005 * 'foo'::text::char(3).
12006 *
12007 * Note: it might seem that we are missing the possibility of needing to
12008 * print a COLLATE clause for such a Const. However, a Const could only
12009 * have nondefault collation in a post-constant-folding tree, in which the
12010 * length coercion would have been folded too. See also the special
12011 * handling of CollateExpr in coerce_to_target_type(): any collation
12012 * marking will be above the coercion node, not below it.
12013 */
12017 {
12018 /* Show the constant without normal ::typename decoration */
12020 }
12021 else
12022 {
12028 }
12029
12030 /*
12031 * Never emit resulttype(arg) functional notation. A pg_proc entry could
12032 * take precedence, and a resulttype in pg_temp would require schema
12033 * qualification that format_type_with_typemod() would usually omit. We've
12034 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
12035 * would work fine.
12036 */
12039}
12040
12041/* ----------
12042 * get_const_expr
12043 *
12044 * Make a string representation of a Const
12045 *
12046 * showtype can be -1 to never show "::typename" decoration, or +1 to always
12047 * show it, or 0 to show it only if the constant wouldn't be assumed to be
12048 * the right type by default.
12049 *
12050 * If the Const's collation isn't default for its type, show that too.
12051 * We mustn't do this when showtype is -1 (since that means the caller will
12052 * print "::typename", and we can't put a COLLATE clause in between). It's
12053 * caller's responsibility that collation isn't missed in such cases.
12054 * ----------
12055 */
12056static void
12058{
12060 Oid typoutput;
12064
12065 if (constval->constisnull)
12066 {
12067 /*
12068 * Always label the type of a NULL constant to prevent misdecisions
12069 * about type when reparsing.
12070 */
12073 {
12076 constval->consttypmod));
12077 get_const_collation(constval, context);
12078 }
12079 return;
12080 }
12081
12083 &typoutput, &typIsVarlena);
12084
12086
12088 {
12090
12091 /*
12092 * INT4 can be printed without any decoration, unless it is
12093 * negative; in that case print it as '-nnn'::integer to ensure
12094 * that the output will re-parse as a constant, not as a constant
12095 * plus operator. In most cases we could get away with printing
12096 * (-nnn) instead, because of the way that gram.y handles negative
12097 * literals; but that doesn't work for INT_MIN, and it doesn't
12098 * seem that much prettier anyway.
12099 */
12102 else
12103 {
12106 }
12107 break;
12108
12110
12111 /*
12112 * NUMERIC can be printed without quotes if it looks like a float
12113 * constant (not an integer, and not Infinity or NaN) and doesn't
12114 * have a leading sign (for the same reason as for INT4).
12115 */
12118 {
12120 }
12121 else
12122 {
12125 }
12126 break;
12127
12131 else
12133 break;
12134
12135 default:
12137 break;
12138 }
12139
12141
12143 return;
12144
12145 /*
12146 * For showtype == 0, append ::typename unless the constant will be
12147 * implicitly typed as the right type when it is read in.
12148 *
12149 * XXX this code has to be kept in sync with the behavior of the parser,
12150 * especially make_const.
12151 */
12153 {
12156 /* These types can be left unlabeled */
12158 break;
12160 /* We determined above whether a label is needed */
12161 break;
12163
12164 /*
12165 * Float-looking constants will be typed as numeric, which we
12166 * checked above; but if there's a nondefault typmod we need to
12167 * show it.
12168 */
12169 needlabel |= (constval->consttypmod >= 0);
12170 break;
12171 default:
12173 break;
12174 }
12178 constval->consttypmod));
12179
12180 get_const_collation(constval, context);
12181}
12182
12183/*
12184 * helper for get_const_expr: append COLLATE if needed
12185 */
12186static void
12188{
12190
12192 {
12194
12195 if (constval->constcollid != typcollation)
12196 {
12198 generate_collation_name(constval->constcollid));
12199 }
12200 }
12201}
12202
12203/*
12204 * get_json_path_spec - Parse back a JSON path specification
12205 */
12206static void
12208{
12211 else
12213}
12214
12215/*
12216 * get_json_format - Parse back a JsonFormat node
12217 */
12218static void
12220{
12222 return;
12223
12226 " FORMAT JSONB" : " FORMAT JSON");
12227
12229 {
12231
12232 encoding =
12235
12237 }
12238}
12239
12240/*
12241 * get_json_returning - Parse back a JsonReturning structure
12242 */
12243static void
12246{
12248 return;
12249
12252 returning->typmod));
12253
12258}
12259
12260/*
12261 * get_json_constructor - Parse back a JsonConstructorExpr node
12262 */
12263static void
12266{
12272
12274 {
12276 return;
12277 }
12279 {
12281 return;
12282 }
12284 {
12286
12288
12291 context->indentLevel);
12292
12295
12296 return;
12297 }
12298
12300 {
12303 break;
12306 break;
12309 break;
12312 break;
12315 break;
12316 default:
12318 }
12319
12321
12324 {
12327 {
12329
12332 }
12333
12335 }
12336
12339}
12340
12341/*
12342 * Append options, if any, to the JSON constructor being deparsed
12343 */
12344static void
12346{
12348 {
12352 }
12353 else
12354 {
12358 }
12359
12362
12363 /*
12364 * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
12365 * support one.
12366 */
12369}
12370
12371/*
12372 * get_json_agg_constructor - Parse back an aggregate JsonConstructorExpr node
12373 */
12374static void
12377{
12379
12382
12390 is_json_objectagg);
12392 {
12393 /*
12394 * If the aggregate is computed by a lower plan node, setrefs.c will
12395 * have replaced the Aggref or WindowFunc with a Var referencing that
12396 * node's output. Chase the Var back to it so we can still print the
12397 * original JSON aggregate syntax. This only happens in EXPLAIN.
12398 */
12401 }
12402 else
12405}
12406
12407/*
12408 * Deparse a JsonConstructorExpr whose aggregate is computed by a lower plan
12409 * node; resolve_special_varno has located the underlying Aggref/WindowFunc.
12410 */
12411static void
12413 void *callback_arg)
12414{
12416
12419
12420 /* Flat copy suffices; we only replace func. */
12424}
12425
12426/*
12427 * simple_quote_literal - Format a string as a SQL literal, append to buf
12428 */
12429static void
12431{
12433
12434 /*
12435 * We always form the string literal according to standard SQL rules.
12436 */
12439 {
12441
12445 }
12447}
12448
12449
12450/* ----------
12451 * get_sublink_expr - Parse back a sublink
12452 * ----------
12453 */
12454static void
12456{
12461
12464 else
12466
12467 /*
12468 * Note that we print the name of only the first operator, when there are
12469 * multiple combining operators. This is an approximation that could go
12470 * wrong in various scenarios (operators in different schemas, renamed
12471 * operators, etc) but there is not a whole lot we can do about it, since
12472 * the syntax allows only one operator to be shown.
12473 */
12475 {
12477 {
12478 /* single combining operator */
12480
12485 }
12487 {
12488 /* multiple combining operators, = or <> cases */
12490 ListCell *l;
12491
12495 {
12497
12505 }
12507 }
12509 {
12510 /* multiple combining operators, < <= > >= cases */
12512
12519 }
12520 else
12523 }
12524
12526
12528 {
12531 break;
12532
12536 else
12538 break;
12539
12542 break;
12543
12546 break;
12547
12552 break;
12553
12555 default:
12558 break;
12559 }
12560
12563
12566 context->indentLevel);
12567
12570 else
12572}
12573
12574
12575/* ----------
12576 * get_xmltable - Parse back a XMLTABLE function
12577 * ----------
12578 */
12579static void
12581{
12583
12585
12587 {
12589 *lc2;
12590 bool first = true;
12591
12594 {
12597
12598 if (!first)
12600 else
12601 first = false;
12602
12604 {
12608 }
12609 else
12610 {
12613 }
12614 }
12616 }
12617
12623
12625 {
12626 ListCell *l1;
12627 ListCell *l2;
12628 ListCell *l3;
12629 ListCell *l4;
12630 ListCell *l5;
12631 int colnum = 0;
12632
12634 forfive(l1, tf->colnames, l2, tf->coltypes, l3, tf->coltypmods,
12635 l4, tf->colexprs, l5, tf->coldefexprs)
12636 {
12642 bool ordinality = (tf->ordinalitycol == colnum);
12644
12645 if (colnum > 0)
12647 colnum++;
12648
12650 ordinality ? "FOR ORDINALITY" :
12651 format_type_with_typemod(typid, typmod));
12652 if (ordinality)
12653 continue;
12654
12656 {
12660 }
12662 {
12666 }
12667 if (notnull)
12669 }
12670 }
12671
12673}
12674
12675/*
12676 * get_json_table_nested_columns - Parse back nested JSON_TABLE columns
12677 */
12678static void
12682{
12684 {
12686
12689
12695 }
12697 {
12699
12701 needcomma);
12703 true);
12704 }
12705}
12706
12707/*
12708 * json_table_plan_is_default - does this plan match the implicit default?
12709 *
12710 * When no PLAN clause is given, JSON_TABLE builds a default plan that joins
12711 * every nested path to its parent with OUTER and every set of sibling paths
12712 * with UNION (see transformJsonTableColumns()). Such a plan is fully implied
12713 * by the NESTED COLUMNS structure, so we need not (and, to match the input,
12714 * should not) print a PLAN clause for it; we only deparse a PLAN clause when
12715 * the plan deviates from the default, i.e. uses an INNER or CROSS join
12716 * somewhere. This follows the usual ruleutils convention of omitting a clause
12717 * that merely restates the default (cf. get_json_expr_options() for ON
12718 * EMPTY/ON ERROR, or the NULLS FIRST/LAST handling in get_rule_orderby()).
12719 */
12720static bool
12722{
12724 {
12726
12728 {
12730 return false; /* INNER is not the default */
12732 }
12733
12734 return true;
12735 }
12736 else
12737 {
12739
12741 return false; /* CROSS is not the default */
12744 }
12745}
12746
12747/*
12748 * get_json_table_plan - Parse back a JSON_TABLE plan
12749 */
12750static void
12753{
12756
12758 {
12760
12762
12764 {
12770 }
12771 }
12773 {
12775
12779
12781
12785 }
12786
12789}
12790
12791/*
12792 * get_json_table_columns - Parse back JSON_TABLE columns
12793 */
12794static void
12796 deparse_context *context,
12798{
12804 int colnum = 0;
12805
12808
12811
12813 lc_coltype, tf->coltypes,
12814 lc_coltypmod, tf->coltypmods,
12815 lc_colvalexpr, tf->colvalexprs)
12816 {
12818 JsonExpr *colexpr;
12819 Oid typid;
12820 int32 typmod;
12821 bool ordinality;
12823
12827
12828 /* Skip columns that don't belong to this scan. */
12830 {
12831 colnum++;
12832 continue;
12833 }
12835 break;
12836
12839
12840 colnum++;
12841
12842 ordinality = !colexpr;
12843
12845
12847 ordinality ? "FOR ORDINALITY" :
12848 format_type_with_typemod(typid, typmod));
12849 if (ordinality)
12850 continue;
12851
12852 /*
12853 * Set default_behavior to guide get_json_expr_options() on whether to
12854 * emit the ON ERROR / EMPTY clauses.
12855 */
12857 {
12860 }
12861 else
12862 {
12864 {
12867
12869
12873 " FORMAT JSONB" : " FORMAT JSON");
12874 }
12875
12877 }
12878
12880
12882
12884 }
12885
12888 scan->colMin >= 0);
12889
12892
12894}
12895
12896/* ----------
12897 * get_json_table - Parse back a JSON_TABLE function
12898 * ----------
12899 */
12900static void
12902{
12906
12908
12911
12913
12915
12917
12919
12921
12923 {
12925 *lc2;
12927
12930
12933
12936 {
12940
12942
12946 );
12947 }
12948
12951 }
12952
12954 showimplicit);
12955
12956 /*
12957 * Deparse a PLAN clause only for a non-default plan; the default plan is
12958 * implied by the NESTED COLUMNS structure (see
12959 * json_table_plan_is_default).
12960 */
12962 {
12966 }
12967
12970
12973
12975}
12976
12977/* ----------
12978 * get_tablefunc - Parse back a table function
12979 * ----------
12980 */
12981static void
12983{
12984 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12985
12990}
12991
12992/* ----------
12993 * get_from_clause - Parse back a FROM clause
12994 *
12995 * "prefix" is the keyword that denotes the start of the list of FROM
12996 * elements. It is FROM when used to parse back SELECT and UPDATE, but
12997 * is USING when parsing back DELETE.
12998 * ----------
12999 */
13000static void
13002{
13004 bool first = true;
13005 ListCell *l;
13006
13007 /*
13008 * We use the query's jointree as a guide to what to print. However, we
13009 * must ignore auto-added RTEs that are marked not inFromCl. (These can
13010 * only appear at the top level of the jointree, so it's sufficient to
13011 * check here.) This check also ensures we ignore the rule pseudo-RTEs
13012 * for NEW and OLD.
13013 */
13015 {
13017
13019 {
13022
13024 continue;
13025 }
13026
13027 if (first)
13028 {
13029 appendContextKeyword(context, prefix,
13031 first = false;
13032
13033 get_from_clause_item(jtnode, query, context);
13034 }
13035 else
13036 {
13038
13040
13041 /*
13042 * Put the new FROM item's text into itembuf so we can decide
13043 * after we've got it whether or not it needs to go on a new line.
13044 */
13047
13048 get_from_clause_item(jtnode, query, context);
13049
13050 /* Restore context's output buffer */
13052
13053 /* Consider line-wrapping if enabled */
13055 {
13056 /* Does the new item start with a new line? */
13058 {
13059 /* If so, we shouldn't add anything */
13060 /* instead, remove any trailing spaces currently in buf */
13062 }
13063 else
13064 {
13066
13067 /* Locate the start of the current line in the buffer */
13071 else
13072 trailing_nl++;
13073
13074 /*
13075 * Add a newline, plus some indentation, if the new item
13076 * would cause an overflow.
13077 */
13080 PRETTYINDENT_STD,
13081 PRETTYINDENT_VAR);
13082 }
13083 }
13084
13085 /* Add the new item */
13087
13088 /* clean up */
13090 }
13091 }
13092}
13093
13094static void
13096{
13099
13101 {
13106
13109
13110 /* Print the FROM item proper */
13112 {
13114 /* Normal relation RTE */
13118 context->namespaces));
13119 break;
13121 /* Subquery RTE */
13124 true,
13126 context->indentLevel);
13128 break;
13130 /* Function RTE */
13132
13133 /*
13134 * Omit ROWS FROM() syntax for just one function, unless it
13135 * has both a coldeflist and WITH ORDINALITY. If it has both,
13136 * we must use ROWS FROM() syntax to avoid ambiguity about
13137 * whether the coldeflist includes the ordinality column.
13138 */
13141 {
13143 /* we'll print the coldeflist below, if it has one */
13144 }
13145 else
13146 {
13149
13150 /*
13151 * If all the function calls in the list are to unnest,
13152 * and none need a coldeflist, then collapse the list back
13153 * down to UNNEST(args). (If we had more than one
13154 * built-in unnest function, this would get more
13155 * difficult.)
13156 *
13157 * XXX This is pretty ugly, since it makes not-terribly-
13158 * future-proof assumptions about what the parser would do
13159 * with the output; but the alternative is to emit our
13160 * nonstandard ROWS FROM() notation for what might have
13161 * been a perfectly spec-compliant multi-argument
13162 * UNNEST().
13163 */
13166 {
13168
13171 rtfunc->funccolnames != NIL)
13172 {
13174 break;
13175 }
13176 }
13177
13179 {
13181
13183 {
13186
13188 }
13189
13193 }
13194 else
13195 {
13197
13200 {
13202
13207 {
13208 /* Reconstruct the column definition list */
13210 get_from_clause_coldeflist(rtfunc,
13211 NULL,
13212 context);
13213 }
13214 funcno++;
13215 }
13217 }
13218 /* prevent printing duplicate coldeflist below */
13220 }
13223 break;
13226 break;
13233 {
13234 bool first = true;
13235
13237 {
13238 if (!first)
13240 else
13241 first = false;
13242
13246 }
13247 }
13249 break;
13251 /* Values list RTE */
13255 break;
13258 break;
13259 default:
13261 break;
13262 }
13263
13264 /* Print the relation alias, if needed */
13266
13267 /* Print the column definitions or aliases, if needed */
13269 {
13270 /* Reconstruct the columndef list, which is also the aliases */
13272 }
13273 else
13274 {
13275 /* Else print column aliases as needed */
13277 }
13278
13279 /* Tablesample clause must go after any alias */
13282 }
13284 {
13288
13292
13295
13297
13299 {
13303 -PRETTYINDENT_STD,
13304 PRETTYINDENT_STD,
13305 PRETTYINDENT_JOIN);
13306 else
13308 -PRETTYINDENT_STD,
13309 PRETTYINDENT_STD,
13310 PRETTYINDENT_JOIN);
13311 break;
13314 -PRETTYINDENT_STD,
13315 PRETTYINDENT_STD,
13316 PRETTYINDENT_JOIN);
13317 break;
13320 -PRETTYINDENT_STD,
13321 PRETTYINDENT_STD,
13322 PRETTYINDENT_JOIN);
13323 break;
13326 -PRETTYINDENT_STD,
13327 PRETTYINDENT_STD,
13328 PRETTYINDENT_JOIN);
13329 break;
13330 default:
13333 }
13334
13340
13342 {
13344 bool first = true;
13345
13347 /* Use the assigned names, not what's in usingClause */
13349 {
13351
13352 if (first)
13353 first = false;
13354 else
13357 }
13359
13363 }
13365 {
13372 }
13374 {
13375 /* If we didn't say CROSS JOIN above, we must provide an ON */
13377 }
13378
13381
13382 /* Yes, it's correct to put alias after the right paren ... */
13384 {
13385 /*
13386 * Note that it's correct to emit an alias clause if and only if
13387 * there was one originally. Otherwise we'd be converting a named
13388 * join to unnamed or vice versa, which creates semantic
13389 * subtleties we don't want. However, we might print a different
13390 * alias name than was there originally.
13391 */
13394 context)));
13396 }
13397 }
13398 else
13401}
13402
13403/*
13404 * get_rte_alias - print the relation's alias, if needed
13405 *
13406 * If printed, the alias is preceded by a space, or by " AS " if use_as is true.
13407 */
13408static void
13410 deparse_context *context)
13411{
13416
13418 {
13419 /* Always print alias if user provided one */
13421 }
13423 {
13424 /* Always print alias if we need to print column aliases */
13426 }
13428 {
13429 /*
13430 * No need to print alias if it's same as relation name (this would
13431 * normally be the case, but not if set_rtable_names had to resolve a
13432 * conflict).
13433 */
13436 }
13438 {
13439 /*
13440 * For a function RTE, always print alias. This covers possible
13441 * renaming of the function and/or instability of the FigureColname
13442 * rules for things that aren't simple functions. Note we'd need to
13443 * force it anyway for the columndef list case.
13444 */
13446 }
13449 {
13450 /*
13451 * For a subquery, always print alias. This makes the output
13452 * SQL-spec-compliant, even though we allow such aliases to be omitted
13453 * on input.
13454 */
13456 }
13458 {
13459 /*
13460 * No need to print alias if it's same as CTE name (this would
13461 * normally be the case, but not if set_rtable_names had to resolve a
13462 * conflict).
13463 */
13466 }
13467
13471 quote_identifier(refname));
13472}
13473
13474/*
13475 * get_for_portion_of - print FOR PORTION OF if needed
13476 * XXX: Newlines would help here, at least when pretty-printing. But then the
13477 * alias and SET will be on their own line with a leading space.
13478 */
13479static void
13481{
13482 if (forPortionOf)
13483 {
13486
13487 /*
13488 * Try to write it as FROM ... TO ... if we received it that way,
13489 * otherwise (targetRange).
13490 */
13492 {
13497 }
13498 else
13499 {
13503 }
13504 }
13505}
13506
13507/*
13508 * get_column_alias_list - print column alias list for an RTE
13509 *
13510 * Caller must already have printed the relation's alias name.
13511 */
13512static void
13514{
13517 bool first = true;
13518
13519 /* Don't print aliases if not needed */
13521 return;
13522
13524 {
13526
13527 if (first)
13528 {
13530 first = false;
13531 }
13532 else
13535 }
13536 if (!first)
13538}
13539
13540/*
13541 * get_from_clause_coldeflist - reproduce FROM clause coldeflist
13542 *
13543 * When printing a top-level coldeflist (which is syntactically also the
13544 * relation's column alias list), use column names from colinfo. But when
13545 * printing a coldeflist embedded inside ROWS FROM(), we prefer to use the
13546 * original coldeflist's names, which are available in rtfunc->funccolnames.
13547 * Pass NULL for colinfo to select the latter behavior.
13548 *
13549 * The coldeflist is appended immediately (no space) to buf. Caller is
13550 * responsible for ensuring that an alias or AS is present before it.
13551 */
13552static void
13555 deparse_context *context)
13556{
13558 ListCell *l1;
13559 ListCell *l2;
13560 ListCell *l3;
13561 ListCell *l4;
13563
13565
13566 i = 0;
13567 forfour(l1, rtfunc->funccoltypes,
13568 l2, rtfunc->funccoltypmods,
13569 l3, rtfunc->funccolcollations,
13570 l4, rtfunc->funccolnames)
13571 {
13576
13579 else
13581
13583
13588 format_type_with_typemod(atttypid, atttypmod));
13590 attcollation != get_typcollation(atttypid))
13592 generate_collation_name(attcollation));
13593
13594 i++;
13595 }
13596
13598}
13599
13600/*
13601 * get_tablesample_def - print a TableSampleClause
13602 */
13603static void
13605{
13607 Oid argtypes[1];
13608 int nargs;
13609 ListCell *l;
13610
13611 /*
13612 * We should qualify the handler's function name if it wouldn't be
13613 * resolved by lookup in the current search path.
13614 */
13615 argtypes[0] = INTERNALOID;
13618 NIL, argtypes,
13620
13621 nargs = 0;
13623 {
13624 if (nargs++ > 0)
13627 }
13629
13631 {
13635 }
13636}
13637
13638/*
13639 * get_opclass_name - fetch name of an index operator class
13640 *
13641 * The opclass name is appended (after a space) to buf.
13642 *
13643 * Output is suppressed if the opclass is the default for the given
13644 * actual_datatype. (If you don't want this behavior, just pass
13645 * InvalidOid for actual_datatype.)
13646 */
13647static void
13650{
13654 char *nspname;
13655
13660
13663 {
13664 /* Okay, we need the opclass name. Do we need to qualify it? */
13668 else
13669 {
13672 quote_identifier(nspname),
13674 }
13675 }
13677}
13678
13679/*
13680 * generate_opclass_name
13681 * Compute the name to display for an opclass specified by OID
13682 *
13683 * The result includes all necessary quoting and schema-prefixing.
13684 */
13685char *
13687{
13689
13692
13694}
13695
13696/*
13697 * processIndirection - take care of array and subfield assignment
13698 *
13699 * We strip any top-level FieldStore or assignment SubscriptingRef nodes that
13700 * appear in the input, printing them as decoration for the base column
13701 * name (which we assume the caller just printed). We might also need to
13702 * strip CoerceToDomain nodes, but only ones that appear above assignment
13703 * nodes.
13704 *
13705 * Returns the subexpression that's to be assigned.
13706 */
13709{
13712
13713 for (;;)
13714 {
13716 break;
13718 {
13720 Oid typrelid;
13721 char *fieldname;
13722
13723 /* lookup tuple type */
13724 typrelid = get_typ_typrelid(fstore->resulttype);
13727 format_type_be(fstore->resulttype));
13728
13729 /*
13730 * Print the field name. There should only be one target field in
13731 * stored rules. There could be more than that in executable
13732 * target lists, but this function cannot be used for that case.
13733 */
13735 fieldname = get_attname(typrelid,
13738
13739 /*
13740 * We ignore arg since it should be an uninteresting reference to
13741 * the target column or subcolumn.
13742 */
13744 }
13746 {
13748
13750 break;
13751
13752 printSubscripts(sbsref, context);
13753
13754 /*
13755 * We ignore refexpr since it should be an uninteresting reference
13756 * to the target column or subcolumn.
13757 */
13759 }
13761 {
13763 /* If it's an explicit domain coercion, we're done */
13765 break;
13766 /* Tentatively descend past the CoerceToDomain */
13768 }
13769 else
13770 break;
13771 }
13772
13773 /*
13774 * If we descended past a CoerceToDomain whose argument turned out not to
13775 * be a FieldStore or array assignment, back up to the CoerceToDomain.
13776 * (This is not enough to be fully correct if there are nested implicit
13777 * CoerceToDomains, but such cases shouldn't ever occur.)
13778 */
13781
13782 return node;
13783}
13784
13785static void
13787{
13791
13794 {
13797 {
13798 /* If subexpression is NULL, get_rule_expr prints nothing */
13802 }
13803 /* If subexpression is NULL, get_rule_expr prints nothing */
13806 }
13807}
13808
13809/*
13810 * quote_identifier - Quote an identifier only if needed
13811 *
13812 * When quotes are needed, we palloc the required space; slightly
13813 * space-wasteful but well worth it for notational simplicity.
13814 */
13815const char *
13817{
13818 /*
13819 * Can avoid quoting if ident starts with a lowercase letter or underscore
13820 * and contains only lowercase letters, digits, and underscores, *and* is
13821 * not any SQL keyword. Otherwise, supply quotes.
13822 */
13825 const char *ptr;
13828
13829 /*
13830 * would like to use <ctype.h> macros here, but they might yield unwanted
13831 * locale-specific results...
13832 */
13834
13836 {
13838
13842 {
13843 /* okay */
13844 }
13845 else
13846 {
13849 nquotes++;
13850 }
13851 }
13852
13855
13857 {
13858 /*
13859 * Check for keyword. We quote keywords except for unreserved ones.
13860 * (In some cases we could avoid quoting a col_name or type_func_name
13861 * keyword, but it seems much harder than it's worth to tell that.)
13862 *
13863 * Note: ScanKeywordLookup() does case-insensitive comparison, but
13864 * that's fine, since we already know we have all-lower-case.
13865 */
13867
13870 }
13871
13874
13876
13880 {
13882
13886 }
13889
13891}
13892
13893/*
13894 * quote_qualified_identifier - Quote a possibly-qualified identifier
13895 *
13896 * Return a name of the form qualifier.ident, or just ident if qualifier
13897 * is NULL, quoting each component if necessary. The result is palloc'd.
13898 */
13899char *
13902{
13904
13910}
13911
13912/*
13913 * get_relation_name
13914 * Get the unqualified name of a relation specified by OID
13915 *
13916 * This differs from the underlying get_rel_name() function in that it will
13917 * throw error instead of silently returning NULL if the OID is bad.
13918 */
13919static char *
13921{
13923
13927}
13928
13929/*
13930 * generate_relation_name
13931 * Compute the name to display for a relation specified by OID
13932 *
13933 * The result includes all necessary quoting and schema-prefixing.
13934 *
13935 * If namespaces isn't NIL, it must be a list of deparse_namespace nodes.
13936 * We will forcibly qualify the relation name if it equals any CTE name
13937 * visible in the namespace list.
13938 */
13939static char *
13941{
13942 HeapTuple tp;
13947 char *nspname;
13949
13955
13956 /* Check for conflicting CTE name */
13959 {
13962
13964 {
13966
13968 {
13970 break;
13971 }
13972 }
13974 break;
13975 }
13976
13977 /* Otherwise, qualify the name if not visible in search path */
13980
13983 else
13984 nspname = NULL;
13985
13987
13988 ReleaseSysCache(tp);
13989
13991}
13992
13993/*
13994 * generate_qualified_relation_name
13995 * Compute the name to display for a relation specified by OID
13996 *
13997 * As above, but unconditionally schema-qualify the name.
13998 */
13999static char *
14001{
14002 HeapTuple tp;
14005
14010
14013 ReleaseSysCache(tp);
14014
14016}
14017
14018/*
14019 * generate_function_name
14020 * Compute the name to display for a function specified by OID,
14021 * given that it is being called with the specified actual arg names and
14022 * types. (Those matter because of ambiguous-function resolution rules.)
14023 *
14024 * If we're dealing with a potentially variadic function (in practice, this
14025 * means a FuncExpr or Aggref, not some other way of calling a function), then
14026 * has_variadic must specify whether variadic arguments have been merged,
14027 * and *use_variadic_p will be set to indicate whether to print VARIADIC in
14028 * the output. For non-FuncExpr cases, has_variadic should be false and
14029 * use_variadic_p can be NULL.
14030 *
14031 * inGroupBy must be true if we're deparsing a GROUP BY clause.
14032 *
14033 * The result includes all necessary quoting and schema-prefixing.
14034 */
14035static char *
14038 bool inGroupBy)
14039{
14045 char *nspname;
14055
14061
14062 /*
14063 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
14064 * qualification of some function names within GROUP BY.
14065 */
14066 if (inGroupBy)
14067 {
14070 }
14071
14072 /*
14073 * Determine whether VARIADIC should be printed. We must do this first
14074 * since it affects the lookup rules in func_get_detail().
14075 *
14076 * We always print VARIADIC if the function has a merged variadic-array
14077 * argument. Note that this is always the case for functions taking a
14078 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
14079 * and printed the array elements as separate arguments, the call could
14080 * match a newer non-VARIADIC function.
14081 */
14083 {
14084 /* Parser should not have set funcvariadic unless fn is variadic */
14088 }
14089 else
14090 {
14093 }
14094
14095 /*
14096 * The idea here is to schema-qualify only if the parser would fail to
14097 * resolve the correct function given the unqualified func name with the
14098 * specified argtypes and VARIADIC flag. But if we already decided to
14099 * force qualification, then we can skip the lookup and pretend we didn't
14100 * find it.
14101 */
14104 NIL, argnames, nargs, argtypes,
14106 &fgc_flags,
14110 else
14111 {
14114 }
14115
14119 p_funcid == funcid)
14120 nspname = NULL;
14121 else
14123
14125
14127
14129}
14130
14131/*
14132 * generate_operator_name
14133 * Compute the name to display for an operator specified by OID,
14134 * given that it is being called with the specified actual arg types.
14135 * (Arg types matter because of ambiguous-operator resolution rules.
14136 * Pass InvalidOid for unused arg of a unary operator.)
14137 *
14138 * The result includes all necessary quoting and schema-prefixing,
14139 * plus the OPERATOR() decoration needed to use a qualified operator name
14140 * in an expression.
14141 */
14142static char *
14144{
14148 char *oprname;
14149 char *nspname;
14151
14153
14159
14160 /*
14161 * The idea here is to schema-qualify only if the parser would fail to
14162 * resolve the correct operator given the unqualified op name with the
14163 * specified argtypes.
14164 */
14166 {
14167 case 'b':
14169 true, -1);
14170 break;
14171 case 'l':
14173 true, -1);
14174 break;
14175 default:
14178 break;
14179 }
14180
14182 nspname = NULL;
14183 else
14184 {
14187 }
14188
14190
14191 if (nspname)
14193
14196
14198
14200}
14201
14202/*
14203 * generate_operator_clause --- generate a binary-operator WHERE clause
14204 *
14205 * This is used for internally-generated-and-executed SQL queries, where
14206 * precision is essential and readability is secondary. The basic
14207 * requirement is to append "leftop op rightop" to buf, where leftop and
14208 * rightop are given as strings and are assumed to yield types leftoptype
14209 * and rightoptype; the operator is identified by OID. The complexity
14210 * comes from needing to be sure that the parser will select the desired
14211 * operator when the query is parsed. We always name the operator using
14212 * OPERATOR(schema.op) syntax, so as to avoid search-path uncertainties.
14213 * We have to emit casts too, if either input isn't already the input type
14214 * of the operator; else we are at the mercy of the parser's heuristics for
14215 * ambiguous-operator resolution. The caller must ensure that leftop and
14216 * rightop are suitable arguments for a cast operation; it's best to insert
14217 * parentheses if they aren't just variables or parameters.
14218 */
14219void
14224{
14227 char *oprname;
14228 char *nspname;
14229
14236
14238
14247
14249}
14250
14251/*
14252 * Add a cast specification to buf. We spell out the type name the hard way,
14253 * intentionally not using format_type_be(). This is to avoid corner cases
14254 * for CHARACTER, BIT, and perhaps other types, where specifying the type
14255 * using SQL-standard syntax results in undesirable data truncation. By
14256 * doing it this way we can be certain that the cast will have default (-1)
14257 * target typmod.
14258 */
14259static void
14261{
14265 char *nspname;
14266
14271
14274
14277
14279}
14280
14281/*
14282 * generate_qualified_type_name
14283 * Compute the name to display for a type specified by OID
14284 *
14285 * This is different from format_type_be() in that we unconditionally
14286 * schema-qualify the name. That also means no special syntax for
14287 * SQL-standard type names ... although in current usage, this should
14288 * only get used for domains, so such cases wouldn't occur anyway.
14289 */
14290static char *
14292{
14293 HeapTuple tp;
14296 char *nspname;
14298
14304
14306 if (!nspname)
14308 typtup->typnamespace);
14309
14311
14312 ReleaseSysCache(tp);
14313
14315}
14316
14317/*
14318 * generate_collation_name
14319 * Compute the name to display for a collation specified by OID
14320 *
14321 * The result includes all necessary quoting and schema-prefixing.
14322 */
14323char *
14325{
14326 HeapTuple tp;
14328 char *collname;
14329 char *nspname;
14331
14337
14340 else
14341 nspname = NULL;
14342
14344
14345 ReleaseSysCache(tp);
14346
14348}
14349
14350/*
14351 * Given a C string, produce a TEXT datum.
14352 *
14353 * We assume that the input was palloc'd and may be freed.
14354 */
14357{
14359
14363}
14364
14365/*
14366 * Generate a C string representing a relation options from text[] datum.
14367 */
14368void
14370{
14374
14377
14379 {
14384
14385 /*
14386 * Each array element should have the form name=value. If the "=" is
14387 * missing for some reason, treat it like an empty value.
14388 */
14392 {
14395 }
14396 else
14398
14402
14403 /*
14404 * In general we need to quote the value; but to avoid unnecessary
14405 * clutter, do not quote if it is an identifier that would not need
14406 * quoting. (We could also allow numbers, but that is a bit trickier
14407 * than it looks --- for example, are leading zeroes significant? We
14408 * don't want to assume very much here about what custom reloptions
14409 * might mean.)
14410 */
14413 else
14415
14417 }
14418}
14419
14420/*
14421 * Generate a C string representing a relation's reloptions, or NULL if none.
14422 */
14423static char *
14425{
14427 HeapTuple tuple;
14428 Datum reloptions;
14429 bool isnull;
14430
14434
14436 Anum_pg_class_reloptions, &isnull);
14437 if (!isnull)
14438 {
14440
14443
14445 }
14446
14447 ReleaseSysCache(tuple);
14448
14450}
14451
14452/*
14453 * get_range_partbound_string
14454 * A C string representation of one range partition bound
14455 */
14456char *
14458{
14459 deparse_context context;
14461 ListCell *cell;
14463
14467
14471 {
14472 PartitionRangeDatum *datum =
14474
14480 else
14481 {
14483
14485 }
14487 }
14489
14491}
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition arrayfuncs.c:5365
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition arrayfuncs.c:3151
void deconstruct_array_builtin(const ArrayType *array, Oid elmtype, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition arrayfuncs.c:3705
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition arrayfuncs.c:5435
memcpy(sums, checksumBaseOffsets, sizeof(checksumBaseOffsets))
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:889
HTAB * hash_create(const char *tabname, int64 nelem, const HASHCTL *info, int flags)
Definition dynahash.c:360
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:1478
int get_func_arg_info(HeapTuple procTup, Oid **p_argtypes, char ***p_argnames, char **p_argmodes)
Definition funcapi.c:1382
TupleDesc get_expr_result_tupdesc(Node *expr, bool noError)
Definition funcapi.c:553
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:4354
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
Definition heaptuple.c:456
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition htup_details.h:890
static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition htup_details.h:847
static struct @175 value
PGDLLIMPORT const ScanKeywordList ScanKeywords
int ScanKeywordLookup(const char *str, const ScanKeywordList *keywords)
Definition kwlookup.c:38
char * get_propgraph_property_name(Oid propoid)
Definition lsyscache.c:4098
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition lsyscache.c:3223
char * get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
Definition lsyscache.c:1053
char * get_qualified_objname(Oid nspid, char *objname)
Definition lsyscache.c:3720
void get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
Definition lsyscache.c:3026
void get_atttypetypmodcoll(Oid relid, AttrNumber attnum, Oid *typid, int32 *typmod, Oid *collid)
Definition lsyscache.c:1169
RangeVar * makeRangeVarFromNameList(const List *names)
Definition namespace.c:3626
bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod)
Definition nodeFuncs.c:562
int get_aggregate_argtypes(Aggref *aggref, Oid *inputTypes)
Definition parse_agg.c:2122
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:1522
Operator left_oper(ParseState *pstate, List *op, Oid arg, bool noError, int location)
Definition parse_oper.c:529
Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
Definition parse_oper.c:376
char * get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum)
Definition parse_relation.c:3474
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
Definition parse_relation.c:3662
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:2866
#define FRAMEOPTION_START_UNBOUNDED_PRECEDING
Definition parsenodes.h:618
#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING
Definition parsenodes.h:621
#define FRAMEOPTION_START_OFFSET_PRECEDING
Definition parsenodes.h:624
#define FRAMEOPTION_START_OFFSET_FOLLOWING
Definition parsenodes.h:626
END_CATALOG_STRUCT typedef FormData_pg_aggregate * Form_pg_aggregate
Definition pg_aggregate.h:113
END_CATALOG_STRUCT typedef FormData_pg_authid * Form_pg_authid
Definition pg_authid.h:60
END_CATALOG_STRUCT typedef FormData_pg_collation * Form_pg_collation
Definition pg_collation.h:62
AttrNumber extractNotNullColumn(HeapTuple constrTup)
Definition pg_constraint.c:702
END_CATALOG_STRUCT typedef FormData_pg_constraint * Form_pg_constraint
Definition pg_constraint.h:179
END_CATALOG_STRUCT typedef FormData_pg_depend * Form_pg_depend
Definition pg_depend.h:76
#define forfour(cell1, list1, cell2, list2, cell3, list3, cell4, list4)
Definition pg_list.h:607
#define forfive(cell1, list1, cell2, list2, cell3, list3, cell4, list4, cell5, list5)
Definition pg_list.h:620
static int list_cell_number(const List *l, const ListCell *c)
Definition pg_list.h:365
END_CATALOG_STRUCT typedef FormData_pg_opclass * Form_pg_opclass
Definition pg_opclass.h:87
END_CATALOG_STRUCT typedef FormData_pg_operator * Form_pg_operator
Definition pg_operator.h:87
END_CATALOG_STRUCT typedef FormData_pg_partitioned_table * Form_pg_partitioned_table
Definition pg_partitioned_table.h:69
END_CATALOG_STRUCT typedef FormData_pg_propgraph_element * Form_pg_propgraph_element
Definition pg_propgraph_element.h:98
END_CATALOG_STRUCT typedef FormData_pg_propgraph_element_label * Form_pg_propgraph_element_label
Definition pg_propgraph_element_label.h:47
END_CATALOG_STRUCT typedef FormData_pg_propgraph_label_property * Form_pg_propgraph_label_property
Definition pg_propgraph_label_property.h:54
END_CATALOG_STRUCT typedef FormData_pg_statistic_ext * Form_pg_statistic_ext
Definition pg_statistic_ext.h:73
END_CATALOG_STRUCT typedef FormData_pg_trigger * Form_pg_trigger
Definition pg_trigger.h:84
void AcquireRewriteLocks(Query *parsetree, bool forExecute, bool forUpdatePushedDown)
Definition rewriteHandler.c:148
Query * getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
Definition rewriteManip.c:1089
static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags, int wrapColumn)
Definition ruleutils.c:5903
Datum pg_get_partition_constraintdef(PG_FUNCTION_ARGS)
Definition ruleutils.c:2456
static char * get_rtable_name(int rtindex, deparse_context *context)
Definition ruleutils.c:5497
static int decompile_column_index_array(Datum column_index_array, Oid relId, bool withPeriod, StringInfo buf)
Definition ruleutils.c:2981
static void make_propgraphdef_labels(StringInfo buf, Oid elid, const char *elalias, Oid elrelid)
Definition ruleutils.c:1799
static void set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition ruleutils.c:4739
static void appendContextKeyword(deparse_context *context, const char *str, int indentBefore, int indentAfter, int indentPlus)
Definition ruleutils.c:9647
List * deparse_context_for_plan_tree(PlannedStmt *pstmt, List *rtable_names)
Definition ruleutils.c:4117
char * pg_get_statisticsobjdef_string(Oid statextid)
Definition ruleutils.c:1987
static void set_using_names(deparse_namespace *dpns, Node *jtnode, List *parentUsing)
Definition ruleutils.c:4574
static Plan * find_recursive_union(deparse_namespace *dpns, WorkTableScan *wtscan)
Definition ruleutils.c:5597
static void get_values_def(List *values_lists, deparse_context *context)
Definition ruleutils.c:6091
static char * make_colname_unique(char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition ruleutils.c:5287
static void get_json_behavior(JsonBehavior *behavior, deparse_context *context, const char *on)
Definition ruleutils.c:9738
static const char * get_simple_binary_op_name(OpExpr *expr)
Definition ruleutils.c:9389
static void get_json_agg_constructor(JsonConstructorExpr *ctor, deparse_context *context, const char *funcname, bool is_json_objectagg)
Definition ruleutils.c:12376
static void set_deparse_for_query(deparse_namespace *dpns, Query *query, List *parent_namespaces)
Definition ruleutils.c:4393
static void print_function_trftypes(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3822
void(* rsv_callback)(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:330
static void get_graph_label_expr(Node *label_expr, deparse_context *context)
Definition ruleutils.c:7982
char * quote_qualified_identifier(const char *qualifier, const char *ident)
Definition ruleutils.c:13901
static void get_setop_query(Node *setOp, Query *query, deparse_context *context)
Definition ruleutils.c:6782
static bool is_input_argument(int nth, const char *argmodes)
Definition ruleutils.c:3810
static void get_query_def(Query *query, StringInfo buf, List *parentnamespace, TupleDesc resultDesc, bool colNamesVisible, int prettyFlags, int wrapColumn, int startIndent)
Definition ruleutils.c:5988
static void get_tablesample_def(TableSampleClause *tablesample, deparse_context *context)
Definition ruleutils.c:13605
static void get_sublink_expr(SubLink *sublink, deparse_context *context)
Definition ruleutils.c:12456
static const char * get_name_for_var_field(Var *var, int fieldno, int levelsup, deparse_context *context)
Definition ruleutils.c:8573
static char * get_lock_clause_strength(LockClauseStrength strength)
Definition ruleutils.c:6380
static void get_rte_alias(RangeTblEntry *rte, int varno, bool use_as, deparse_context *context)
Definition ruleutils.c:13410
Datum pg_get_function_arg_default(PG_FUNCTION_ARGS)
Definition ruleutils.c:3850
static void get_parameter(Param *param, deparse_context *context)
Definition ruleutils.c:9244
static void build_colinfo_names_hash(deparse_columns *colinfo)
Definition ruleutils.c:5342
Datum pg_get_statisticsobjdef_expressions(PG_FUNCTION_ARGS)
Definition ruleutils.c:2198
static void get_delete_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7743
static void get_json_table_columns(TableFunc *tf, JsonTablePathScan *scan, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12796
static void get_column_alias_list(deparse_columns *colinfo, deparse_context *context)
Definition ruleutils.c:13514
Datum pg_get_statisticsobjdef_columns(PG_FUNCTION_ARGS)
Definition ruleutils.c:1997
static void add_to_names_hash(deparse_columns *colinfo, const char *name)
Definition ruleutils.c:5400
static void simple_quote_literal(StringInfo buf, const char *val)
Definition ruleutils.c:12431
static bool colname_is_unique(const char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition ruleutils.c:5212
static void get_from_clause_coldeflist(RangeTblFunction *rtfunc, deparse_columns *colinfo, deparse_context *context)
Definition ruleutils.c:13554
char * pg_get_indexdef_columns_extended(Oid indexrelid, uint16 flags)
Definition ruleutils.c:1262
char * pg_get_partkeydef_columns(Oid relid, bool pretty)
Definition ruleutils.c:2284
static void get_from_clause(Query *query, const char *prefix, deparse_context *context)
Definition ruleutils.c:13002
List * deparse_context_for(const char *aliasname, Oid relid)
Definition ruleutils.c:4072
static bool get_func_sql_syntax(FuncExpr *expr, deparse_context *context)
Definition ruleutils.c:11742
static char * generate_qualified_relation_name(Oid relid)
Definition ruleutils.c:14001
static void set_simple_column_names(deparse_namespace *dpns)
Definition ruleutils.c:4462
static void get_json_expr_options(JsonExpr *jsexpr, deparse_context *context, JsonBehaviorType default_behavior)
Definition ruleutils.c:9776
char * pg_get_indexdef_columns(Oid indexrelid, bool pretty)
Definition ruleutils.c:1248
static void get_rule_groupingset(GroupingSet *gset, List *targetlist, bool omit_parens, deparse_context *context)
Definition ruleutils.c:6999
static int propdata_by_name_cmp(const ListCell *a, const ListCell *b)
Definition ruleutils.c:1867
static void get_for_portion_of(ForPortionOfExpr *forPortionOf, deparse_context *context)
Definition ruleutils.c:13481
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:1283
static char * pg_get_constraintdef_worker(Oid constraintId, bool fullCommand, int prettyFlags, bool missing_ok)
Definition ruleutils.c:2553
static void get_rule_expr_funccall(Node *node, deparse_context *context, bool showimplicit)
Definition ruleutils.c:11271
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:14037
static void expand_colnames_array_to(deparse_columns *colinfo, int n)
Definition ruleutils.c:5326
static void get_returning_clause(Query *query, deparse_context *context)
Definition ruleutils.c:6743
List * set_deparse_context_plan(List *dpcontext, Plan *plan, List *ancestors)
Definition ruleutils.c:4189
static SubPlan * find_param_generator(Param *param, deparse_context *context, int *column_p)
Definition ruleutils.c:9126
static void get_special_variable(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:8444
static void get_windowfunc_expr_helper(WindowFunc *wfunc, deparse_context *context, const char *funcname, const char *options, bool is_json_objectagg)
Definition ruleutils.c:11624
static void get_rule_list_toplevel(List *lst, deparse_context *context, bool showimplicit)
Definition ruleutils.c:11241
static char * pg_get_statisticsobj_worker(Oid statextid, bool columns_only, bool missing_ok)
Definition ruleutils.c:2014
#define deparse_columns_fetch(rangetable_index, dpns)
Definition ruleutils.c:317
static void get_json_constructor(JsonConstructorExpr *ctor, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12265
static void get_json_path_spec(Node *path_spec, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12208
static void printSubscripts(SubscriptingRef *sbsref, deparse_context *context)
Definition ruleutils.c:13787
static SubPlan * find_param_generator_initplan(Param *param, Plan *plan, int *column_p)
Definition ruleutils.c:9223
static void pop_ancestor_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
Definition ruleutils.c:5695
static void get_window_frame_options(int frameOptions, Node *startOffset, Node *endOffset, deparse_context *context)
Definition ruleutils.c:7206
static void get_rule_expr_paren(Node *node, deparse_context *context, bool showimplicit, Node *parentNode)
Definition ruleutils.c:9720
static void get_agg_expr(Aggref *aggref, deparse_context *context, Aggref *original_aggref)
Definition ruleutils.c:11459
static void get_const_collation(Const *constval, deparse_context *context)
Definition ruleutils.c:12188
static void get_target_list(List *targetList, deparse_context *context)
Definition ruleutils.c:6607
static void get_json_table_nested_columns(TableFunc *tf, JsonTablePlan *plan, deparse_context *context, bool showimplicit, bool needcomma)
Definition ruleutils.c:12680
static char * deparse_expression_pretty(Node *expr, List *dpcontext, bool forceprefix, bool showimplicit, int prettyFlags, int startIndent)
Definition ruleutils.c:4036
static void get_insert_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7307
static void print_function_sqlbody(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3920
static bool has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode)
Definition ruleutils.c:4504
static Node * get_rule_sortgroupclause(Index ref, List *tlist, bool force_colno, deparse_context *context)
Definition ruleutils.c:6930
static char * pg_get_viewdef_worker(Oid viewoid, int prettyFlags, int wrapColumn)
Definition ruleutils.c:802
static void push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell, deparse_namespace *save_dpns)
Definition ruleutils.c:5674
static text * pg_get_expr_worker(text *expr, Oid relid, int prettyFlags)
Definition ruleutils.c:3070
static Node * processIndirection(Node *node, deparse_context *context)
Definition ruleutils.c:13709
static void get_agg_combine_expr(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:11597
static bool json_table_plan_is_default(JsonTablePlan *plan)
Definition ruleutils.c:12722
List * select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used)
Definition ruleutils.c:4219
static void get_path_pattern_expr_def(List *path_pattern_expr, deparse_context *context)
Definition ruleutils.c:8031
static void get_json_agg_constructor_expr(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:12413
static char * generate_qualified_type_name(Oid typid)
Definition ruleutils.c:14292
static void get_xmltable(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12581
static void get_json_table_plan(TableFunc *tf, JsonTablePlan *plan, deparse_context *context, bool parenthesize)
Definition ruleutils.c:12752
static void get_utility_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7952
static int list_oid_str_pair_cmp_by_str(const ListCell *p1, const ListCell *p2)
Definition ruleutils.c:1786
static void get_rule_windowclause(Query *query, deparse_context *context)
Definition ruleutils.c:7117
static void get_rule_windowspec(WindowClause *wc, List *targetList, deparse_context *context)
Definition ruleutils.c:7149
static void get_json_returning(JsonReturning *returning, StringInfo buf, bool json_format_by_default)
Definition ruleutils.c:12245
static Node * find_param_referent(Param *param, deparse_context *context, deparse_namespace **dpns_p, ListCell **ancestor_cell_p)
Definition ruleutils.c:9012
static void get_rule_orderby(List *orderList, List *targetList, bool force_colno, deparse_context *context)
Definition ruleutils.c:7059
static void pop_child_plan(deparse_namespace *dpns, deparse_namespace *save_dpns)
Definition ruleutils.c:5644
static void get_graph_pattern_def(GraphPattern *graph_pattern, deparse_context *context)
Definition ruleutils.c:8117
char * pg_get_constraintdef_command(Oid constraintId)
Definition ruleutils.c:2544
char * pg_get_partconstrdef_string(Oid partitionId, char *aliasname)
Definition ruleutils.c:2488
static void set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition ruleutils.c:4942
static void make_propgraphdef_properties(StringInfo buf, Oid ellabelid, Oid elrelid)
Definition ruleutils.c:1883
static void set_rtable_names(deparse_namespace *dpns, List *parent_namespaces, Bitmapset *rels_used)
Definition ruleutils.c:4248
char * get_window_frame_options_for_explain(int frameOptions, Node *startOffset, Node *endOffset, List *dpcontext, bool forceprefix)
Definition ruleutils.c:7275
static void get_update_query_targetlist_def(Query *query, List *targetList, deparse_context *context, RangeTblEntry *rte)
Definition ruleutils.c:7591
static void get_rule_expr(Node *node, deparse_context *context, bool showimplicit)
Definition ruleutils.c:9817
static char * pg_get_partkeydef_worker(Oid relid, int prettyFlags, bool attrsOnly, bool missing_ok)
Definition ruleutils.c:2297
static void get_oper_expr(OpExpr *expr, deparse_context *context)
Definition ruleutils.c:11323
Datum pg_get_function_identity_arguments(PG_FUNCTION_ARGS)
Definition ruleutils.c:3569
static char * pg_get_triggerdef_worker(Oid trigid, bool pretty)
Definition ruleutils.c:913
static void get_func_expr(FuncExpr *expr, deparse_context *context, bool showimplicit)
Definition ruleutils.c:11363
static void get_const_expr(Const *constval, deparse_context *context, int showtype)
Definition ruleutils.c:12058
char * deparse_expression(Node *expr, List *dpcontext, bool forceprefix, bool showimplicit)
Definition ruleutils.c:4009
void generate_operator_clause(StringInfo buf, const char *leftop, Oid leftoptype, Oid opoid, const char *rightop, Oid rightoptype)
Definition ruleutils.c:14221
static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags)
Definition ruleutils.c:5711
static char * pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)
Definition ruleutils.c:610
static int print_function_arguments(StringInfo buf, HeapTuple proctup, bool print_table_args, bool print_defaults)
Definition ruleutils.c:3662
static void identify_join_columns(JoinExpr *j, RangeTblEntry *jrte, deparse_columns *colinfo)
Definition ruleutils.c:5429
static void print_function_rettype(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3624
static void set_deparse_plan(deparse_namespace *dpns, Plan *plan)
Definition ruleutils.c:5516
static void make_propgraphdef_elements(StringInfo buf, Oid pgrelid, char pgekind)
Definition ruleutils.c:1662
static void get_merge_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7793
static void resolve_special_varno(Node *node, deparse_context *context, rsv_callback callback, void *callback_arg)
Definition ruleutils.c:8465
static void get_json_format(JsonFormat *format, StringInfo buf)
Definition ruleutils.c:12220
char * get_range_partbound_string(List *bound_datums)
Definition ruleutils.c:14458
static void get_tablefunc(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12983
static void get_rule_expr_toplevel(Node *node, deparse_context *context, bool showimplicit)
Definition ruleutils.c:11223
static RangeTblEntry * get_simple_values_rte(Query *query, TupleDesc resultDesc)
Definition ruleutils.c:6407
static void get_coercion_expr(Node *arg, deparse_context *context, Oid resulttype, int32 resulttypmod, Node *parentNode)
Definition ruleutils.c:11994
static void push_child_plan(deparse_namespace *dpns, Plan *plan, deparse_namespace *save_dpns)
Definition ruleutils.c:5627
static void get_update_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:7536
static void get_json_constructor_options(JsonConstructorExpr *ctor, StringInfo buf)
Definition ruleutils.c:12346
static void get_basic_select_query(Query *query, deparse_context *context)
Definition ruleutils.c:6476
static bool isSimpleNode(Node *node, Node *parentNode, int prettyFlags)
Definition ruleutils.c:9415
static void get_with_clause(Query *query, deparse_context *context)
Definition ruleutils.c:6134
static void destroy_colinfo_names_hash(deparse_columns *colinfo)
Definition ruleutils.c:5413
static char * generate_relation_name(Oid relid, List *namespaces)
Definition ruleutils.c:13941
static void get_windowfunc_expr(WindowFunc *wfunc, deparse_context *context)
Definition ruleutils.c:11613
static char * get_variable(Var *var, int levelsup, bool istoplevel, deparse_context *context)
Definition ruleutils.c:8162
static char * generate_operator_name(Oid operid, Oid arg1, Oid arg2)
Definition ruleutils.c:14144
static void get_from_clause_item(Node *jtnode, Query *query, deparse_context *context)
Definition ruleutils.c:13096
Datum pg_get_function_arguments(PG_FUNCTION_ARGS)
Definition ruleutils.c:3543
static void get_json_table(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12902
static void get_select_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:6273
static void get_opclass_name(Oid opclass, Oid actual_datatype, StringInfo buf)
Definition ruleutils.c:13649
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:11471
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:673
char * SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber)
Definition spi.c:1221
SPIPlanPtr SPI_prepare(const char *src, int nargs, const Oid *argtypes)
Definition spi.c:861
Datum SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull)
Definition spi.c:1253
Relation try_relation_open(Oid relationId, LOCKMODE lockmode)
Definition relation.c:89
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:457
Definition primnodes.h:1125
Definition pathnodes.h:3290
Definition plannodes.h:399
Definition array.h:188
Definition primnodes.h:1247
Definition primnodes.h:1387
Definition array.h:93
Definition bitmapset.h:50
Definition primnodes.h:949
Definition primnodes.h:2003
Definition primnodes.h:1323
Definition primnodes.h:1369
Definition primnodes.h:1339
Definition primnodes.h:1493
Definition primnodes.h:2049
Definition primnodes.h:1221
Definition primnodes.h:1293
Definition parsenodes.h:1801
Definition primnodes.h:328
Definition primnodes.h:1275
Definition plannodes.h:820
Definition primnodes.h:2118
Definition plannodes.h:933
Definition primnodes.h:190
Definition primnodes.h:1142
Definition primnodes.h:1173
Definition primnodes.h:2433
Definition plannodes.h:891
Definition primnodes.h:2377
Definition primnodes.h:767
Definition parsenodes.h:1049
Definition primnodes.h:2182
Definition parsenodes.h:1029
Definition primnodes.h:2192
Definition primnodes.h:552
Definition parsenodes.h:1625
Definition hsearch.h:65
Definition dynahash.c:225
Definition htup.h:63
Definition amapi.h:234
Definition plannodes.h:655
Definition primnodes.h:2147
Definition primnodes.h:2349
Definition primnodes.h:1808
Definition primnodes.h:1723
Definition primnodes.h:1835
Definition primnodes.h:1657
Definition primnodes.h:1753
Definition primnodes.h:1669
Definition primnodes.h:1915
Definition primnodes.h:1904
Definition primnodes.h:1946
Definition primnodes.h:1689
Definition pg_list.h:54
Definition primnodes.h:2027
Definition plannodes.h:434
Definition primnodes.h:1515
Definition plannodes.h:337
Definition ruleutils.c:324
Definition primnodes.h:808
Definition plannodes.h:1016
Definition plannodes.h:1009
Definition primnodes.h:2133
Definition nodes.h:133
Definition parsenodes.h:3905
Definition primnodes.h:1979
Definition primnodes.h:2393
Definition primnodes.h:831
Definition primnodes.h:392
Definition parsenodes.h:944
Definition parsenodes.h:977
Definition plannodes.h:192
Definition plannodes.h:60
Definition parsenodes.h:121
Definition parsenodes.h:1140
Definition parsenodes.h:1434
Definition primnodes.h:2315
Definition primnodes.h:74
Definition plannodes.h:480
Definition primnodes.h:1198
Definition rel.h:56
Definition plannodes.h:302
Definition primnodes.h:2171
Definition primnodes.h:1472
Definition primnodes.h:1429
Definition parsenodes.h:1692
Definition primnodes.h:1562
Definition primnodes.h:908
Definition skey.h:65
Definition parsenodes.h:2398
Definition snapshot.h:139
Definition parsenodes.h:1554
Definition stringinfo.h:47
Definition value.h:64
Definition primnodes.h:1023
Definition primnodes.h:1074
Definition plannodes.h:774
Definition primnodes.h:703
Definition relscan.h:220
Definition primnodes.h:112
Definition parsenodes.h:1461
Definition primnodes.h:2258
Definition tupdesc.h:149
Definition typcache.h:32
Definition primnodes.h:263
Definition plannodes.h:1254
Definition parsenodes.h:1652
Definition primnodes.h:587
Definition plannodes.h:844
Definition primnodes.h:1605
Definition spi_priv.h:91
Definition regc_locale.c:56
Definition ruleutils.c:240
Definition ruleutils.c:118
Definition ruleutils.c:168
Definition c.h:863
Definition ruleutils.c:1780
Definition getopt_long.h:18
Definition oid2name.c:30
Definition print.h:106
Datum SysCacheGetAttrNotNull(SysCacheIdentifier cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition syscache.c:626
HeapTuple SearchSysCache1(SysCacheIdentifier cacheId, Datum key1)
Definition syscache.c:221
Datum SysCacheGetAttr(SysCacheIdentifier cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition syscache.c:596
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:178
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:195
TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
Definition typcache.c:1949
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition typcache.c:389
Definition pg_list.h:46
Node * flatten_group_exprs(PlannerInfo *root, Query *query, Node *node)
Definition var.c:999
text * cstring_to_text_with_len(const char *s, int len)
Definition varlena.c:196
bool SplitGUCList(char *rawstring, char separator, List **namelist)
Definition varlena.c:3063
char * map_xml_name_to_sql_identifier(const char *name)
Definition xml.c:2478
◆ GET_PRETTY_FLAGS
◆ only_marker
Definition at line 563 of file ruleutils.c.
◆ PRETTY_INDENT
| #define PRETTY_INDENT | ( | context | ) | ((context)->prettyFlags & PRETTYFLAG_INDENT) |
Definition at line 107 of file ruleutils.c.
◆ PRETTY_PAREN
| #define PRETTY_PAREN | ( | context | ) | ((context)->prettyFlags & PRETTYFLAG_PAREN) |
Definition at line 106 of file ruleutils.c.
◆ PRETTY_SCHEMA
| #define PRETTY_SCHEMA | ( | context | ) | ((context)->prettyFlags & PRETTYFLAG_SCHEMA) |
Definition at line 108 of file ruleutils.c.
◆ PRETTYFLAG_INDENT
| #define PRETTYFLAG_INDENT 0x0002 |
Definition at line 94 of file ruleutils.c.
◆ PRETTYFLAG_PAREN
| #define PRETTYFLAG_PAREN 0x0001 |
Definition at line 93 of file ruleutils.c.
◆ PRETTYFLAG_SCHEMA
| #define PRETTYFLAG_SCHEMA 0x0004 |
Definition at line 95 of file ruleutils.c.
◆ PRETTYINDENT_JOIN
| #define PRETTYINDENT_JOIN 4 |
Definition at line 87 of file ruleutils.c.
◆ PRETTYINDENT_LIMIT
Definition at line 90 of file ruleutils.c.
◆ PRETTYINDENT_STD
| #define PRETTYINDENT_STD 8 |
Definition at line 86 of file ruleutils.c.
◆ PRETTYINDENT_VAR
| #define PRETTYINDENT_VAR 4 |
Definition at line 88 of file ruleutils.c.
◆ WRAP_COLUMN_DEFAULT
| #define WRAP_COLUMN_DEFAULT 0 |
Definition at line 103 of file ruleutils.c.
Typedef Documentation
◆ rsv_callback
| typedef void(* rsv_callback) (Node *node, deparse_context *context, void *callback_arg) |
Definition at line 330 of file ruleutils.c.
Function Documentation
◆ add_cast_to()
|
static |
Definition at line 14261 of file ruleutils.c.
14262{
14266 char *nspname;
14267
14272
14275
14278
14280}
References appendStringInfo(), buf, elog, ERROR, fb(), Form_pg_type, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_identifier(), ReleaseSysCache(), SearchSysCache1(), and typname.
Referenced by generate_operator_clause().
◆ add_to_names_hash()
|
static |
Definition at line 5400 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 9647 of file ruleutils.c.
9649{
9651
9653 {
9655
9657
9658 /* remove any trailing spaces currently in the buffer ... */
9660 /* ... then add a newline and some spaces */
9662
9665 else
9666 {
9667 /*
9668 * If we're indented more than PRETTYINDENT_LIMIT characters, try
9669 * to conserve horizontal space by reducing the per-level
9670 * indentation. For best results the scale factor here should
9671 * divide all the indent amounts that get added to indentLevel
9672 * (PRETTYINDENT_STD, etc). It's important that the indentation
9673 * not grow unboundedly, else deeply-nested trees use O(N^2)
9674 * whitespace; so we also wrap modulo PRETTYINDENT_LIMIT.
9675 */
9678 (PRETTYINDENT_STD / 2);
9680 /* scale/wrap logic affects indentLevel, but not indentPlus */
9682 }
9684
9686
9689 context->indentLevel = 0;
9690 }
9691 else
9693}
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 5342 of file ruleutils.c.
5343{
5347
5348 /*
5349 * Use a hash table only for RTEs with at least 32 columns. (The cutoff
5350 * is somewhat arbitrary, but let's choose it so that this code does get
5351 * exercised in the regression tests.)
5352 */
5354 return;
5355
5356 /*
5357 * Set up the hash table. The entries are just strings with no other
5358 * payload.
5359 */
5365 &hash_ctl,
5367
5368 /*
5369 * Preload the hash table with any names already present (these would have
5370 * come from set_using_names).
5371 */
5373 {
5375
5378 }
5379
5381 {
5383
5386 }
5387
5389 {
5391
5393 }
5394}
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 5212 of file ruleutils.c.
5214{
5217
5218 /*
5219 * If we have a hash table, consult that instead of linearly scanning the
5220 * colinfo's strings.
5221 */
5223 {
5225 colname,
5226 HASH_FIND,
5228 return false;
5229 }
5230 else
5231 {
5232 /* Check against already-assigned column aliases within RTE */
5234 {
5236
5238 return false;
5239 }
5240
5241 /*
5242 * If we're building a new_colnames array, check that too (this will
5243 * be partially but not completely redundant with the previous checks)
5244 */
5246 {
5248
5250 return false;
5251 }
5252
5253 /*
5254 * Also check against names already assigned for parent-join USING
5255 * cols
5256 */
5258 {
5260
5262 return false;
5263 }
5264 }
5265
5266 /*
5267 * Also check against USING-column names that must be globally unique.
5268 * These are not hashed, but there should be few of them.
5269 */
5271 {
5273
5275 return false;
5276 }
5277
5278 return true;
5279}
References fb(), HASH_FIND, hash_search(), i, and lfirst.
Referenced by make_colname_unique().
◆ decompile_column_index_array()
|
static |
Definition at line 2981 of file ruleutils.c.
2983{
2984 Datum *keys;
2985 int nKeys;
2987
2988 /* Extract data from array of int16 */
2990 &keys, NULL, &nKeys);
2991
2993 {
2995
2997
3000 else
3004 }
3005
3006 return nKeys;
3007}
References appendStringInfo(), appendStringInfoString(), buf, DatumGetArrayTypeP, DatumGetInt16(), deconstruct_array_builtin(), fb(), get_attname(), j, and quote_identifier().
Referenced by make_propgraphdef_elements(), and pg_get_constraintdef_worker().
◆ deparse_context_for()
Definition at line 4072 of file ruleutils.c.
4073{
4076
4078
4079 /* Build a minimal RTE for the rel */
4082 rte->relid = relid;
4090
4091 /* Build one-element rtable */
4098
4099 /* Return a one-deep namespace stack */
4101}
References AccessShareLock, fb(), list_make1, makeAlias(), makeNode, NIL, palloc0_object, RTE_RELATION, set_rtable_names(), and set_simple_column_names().
Referenced by check_element_properties(), make_propgraphdef_properties(), 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 4117 of file ruleutils.c.
4118{
4120
4122
4123 /* Initialize fields that stay the same across the whole plan tree */
4125 dpns->rtable_names = rtable_names;
4129 {
4130 /* Set up the array, indexed by child relid */
4133
4137 {
4140
4144 }
4145 }
4146 else
4148
4149 /*
4150 * Set up column name aliases, ignoring any join RTEs; they don't matter
4151 * because plan trees don't contain any join alias Vars.
4152 */
4154
4155 /* Return a one-deep namespace stack */
4157}
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 4009 of file ruleutils.c.
References deparse_expression_pretty(), and fb().
Referenced by AlterDomainDefault(), check_element_properties(), 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 4036 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(), make_propgraphdef_properties(), 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 5413 of file ruleutils.c.
5414{
5416 {
5419 }
5420}
References fb(), and hash_destroy().
Referenced by set_join_column_names(), and set_relation_column_names().
◆ expand_colnames_array_to()
|
static |
Definition at line 5326 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 9126 of file ruleutils.c.
9127{
9128 /* Initialize output parameter to prevent compiler warnings */
9129 *column_p = 0;
9130
9131 /*
9132 * If it's a PARAM_EXEC parameter, search the current plan node as well as
9133 * ancestor nodes looking for a subplan or initplan that emits the value
9134 * for the Param. It could appear in the setParams of an initplan or
9135 * MULTIEXPR_SUBLINK subplan, or in the paramIds of an ancestral SubPlan.
9136 */
9138 {
9142
9144
9145 /* First check the innermost plan node's initplans */
9149
9150 /*
9151 * The plan's targetlist might contain MULTIEXPR_SUBLINK SubPlans,
9152 * which can be referenced by Params elsewhere in the targetlist.
9153 * (Such Params should always be in the same targetlist, so there's no
9154 * need to do this work at upper plan nodes.)
9155 */
9157 {
9159 {
9161
9163 {
9164 foreach_int(paramid, subplan->setParam)
9165 {
9167 {
9168 /* Found a match, so return it. */
9170 return subplan;
9171 }
9172 }
9173 }
9174 }
9175 }
9176
9177 /* No luck, so check the ancestor nodes */
9179 {
9181
9182 /*
9183 * If ancestor is a SubPlan, check the paramIds it provides.
9184 */
9186 {
9188
9190 {
9192 {
9193 /* Found a match, so return it. */
9195 return subplan;
9196 }
9197 }
9198
9199 /* SubPlan isn't a kind of Plan, so skip the rest */
9200 continue;
9201 }
9202
9203 /*
9204 * Otherwise, it's some kind of Plan node, so check its initplans.
9205 */
9207 column_p);
9210
9211 /* No luck, crawl up to next ancestor */
9212 }
9213 }
9214
9215 /* No generator found */
9217}
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, result, SubPlan::setParam, and SubPlan::subLinkType.
Referenced by get_parameter().
◆ find_param_generator_initplan()
|
static |
Definition at line 9223 of file ruleutils.c.
9224{
9226 {
9227 foreach_int(paramid, subplan->setParam)
9228 {
9230 {
9231 /* Found a match, so return it. */
9233 return subplan;
9234 }
9235 }
9236 }
9238}
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 9012 of file ruleutils.c.
9014{
9015 /* Initialize output parameters to prevent compiler warnings */
9018
9019 /*
9020 * If it's a PARAM_EXEC parameter, look for a matching NestLoopParam or
9021 * SubPlan argument. This will necessarily be in some ancestor of the
9022 * current expression's Plan node.
9023 */
9025 {
9029
9032
9034 {
9037
9038 /*
9039 * NestLoops transmit params to their inner child only.
9040 */
9043 {
9045
9047 {
9049
9051 {
9052 /* Found a match, so return it */
9056 }
9057 }
9058 }
9059
9060 /*
9061 * If ancestor is a SubPlan, check the arguments it provides.
9062 */
9064 {
9068
9070 {
9073
9075 {
9076 /*
9077 * Found a match, so return it. But, since Vars in
9078 * the arg are to be evaluated in the surrounding
9079 * context, we have to point to the next ancestor item
9080 * that is *not* a SubPlan.
9081 */
9083
9086 {
9088
9090 {
9094 }
9095 }
9097 }
9098 }
9099
9100 /* SubPlan isn't a kind of Plan, so skip the rest */
9101 continue;
9102 }
9103
9104 /*
9105 * We need not consider the ancestor's initPlan list, since
9106 * initplans never have any parParams.
9107 */
9108
9109 /* No luck, crawl up to next ancestor */
9111 }
9112 }
9113
9114 /* No referent found */
9116}
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 5597 of file ruleutils.c.
References elog, ERROR, fb(), IsA, and lfirst.
Referenced by set_deparse_plan().
◆ flatten_reloptions()
Definition at line 14425 of file ruleutils.c.
14426{
14428 HeapTuple tuple;
14429 Datum reloptions;
14430 bool isnull;
14431
14435
14437 Anum_pg_class_reloptions, &isnull);
14438 if (!isnull)
14439 {
14441
14444
14446 }
14447
14448 ReleaseSysCache(tuple);
14449
14451}
References buf, elog, ERROR, fb(), get_reloptions(), HeapTupleIsValid, initStringInfo(), ObjectIdGetDatum(), ReleaseSysCache(), result, SearchSysCache1(), and SysCacheGetAttr().
Referenced by pg_get_constraintdef_worker(), and pg_get_indexdef_worker().
◆ generate_collation_name()
Definition at line 14325 of file ruleutils.c.
14326{
14327 HeapTuple tp;
14329 char *collname;
14330 char *nspname;
14332
14338
14341 else
14342 nspname = NULL;
14343
14345
14346 ReleaseSysCache(tp);
14347
14349}
References CollationIsVisible(), collid, elog, ERROR, fb(), Form_pg_collation, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), ReleaseSysCache(), result, 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 14037 of file ruleutils.c.
14040{
14046 char *nspname;
14056
14062
14063 /*
14064 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
14065 * qualification of some function names within GROUP BY.
14066 */
14067 if (inGroupBy)
14068 {
14071 }
14072
14073 /*
14074 * Determine whether VARIADIC should be printed. We must do this first
14075 * since it affects the lookup rules in func_get_detail().
14076 *
14077 * We always print VARIADIC if the function has a merged variadic-array
14078 * argument. Note that this is always the case for functions taking a
14079 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
14080 * and printed the array elements as separate arguments, the call could
14081 * match a newer non-VARIADIC function.
14082 */
14084 {
14085 /* Parser should not have set funcvariadic unless fn is variadic */
14089 }
14090 else
14091 {
14094 }
14095
14096 /*
14097 * The idea here is to schema-qualify only if the parser would fail to
14098 * resolve the correct function given the unqualified func name with the
14099 * specified argtypes and VARIADIC flag. But if we already decided to
14100 * force qualification, then we can skip the lookup and pretend we didn't
14101 * find it.
14102 */
14105 NIL, argnames, nargs, argtypes,
14107 &fgc_flags,
14111 else
14112 {
14115 }
14116
14120 p_funcid == funcid)
14121 nspname = NULL;
14122 else
14124
14126
14128
14130}
References Assert, elog, ERROR, fb(), Form_pg_proc, func_get_detail(), FUNCDETAIL_AGGREGATE, FUNCDETAIL_NORMAL, FUNCDETAIL_NOTFOUND, FUNCDETAIL_WINDOWFUNC, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, list_make1, makeString(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, proname, quote_qualified_identifier(), ReleaseSysCache(), result, 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 13687 of file ruleutils.c.
13688{
13690
13693
13695}
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 14221 of file ruleutils.c.
14225{
14228 char *oprname;
14229 char *nspname;
14230
14237
14239
14248
14250}
References add_cast_to(), appendStringInfo(), appendStringInfoString(), Assert, buf, elog, ERROR, fb(), Form_pg_operator, get_namespace_name(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_identifier(), ReleaseSysCache(), and SearchSysCache1().
Referenced by refresh_by_match_merge(), and ri_GenerateQual().
◆ generate_operator_name()
Definition at line 14144 of file ruleutils.c.
14145{
14149 char *oprname;
14150 char *nspname;
14152
14154
14160
14161 /*
14162 * The idea here is to schema-qualify only if the parser would fail to
14163 * resolve the correct operator given the unqualified op name with the
14164 * specified argtypes.
14165 */
14167 {
14168 case 'b':
14170 true, -1);
14171 break;
14172 case 'l':
14174 true, -1);
14175 break;
14176 default:
14179 break;
14180 }
14181
14183 nspname = NULL;
14184 else
14185 {
14188 }
14189
14191
14192 if (nspname)
14194
14197
14199
14201}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, elog, ERROR, fb(), Form_pg_operator, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, initStringInfo(), left_oper(), list_make1, makeString(), NameStr, ObjectIdGetDatum(), oper(), oprid(), quote_identifier(), ReleaseSysCache(), and SearchSysCache1().
Referenced by get_oper_expr(), get_rule_expr(), get_rule_orderby(), get_simple_binary_op_name(), get_sublink_expr(), and pg_get_indexdef_worker().
◆ generate_qualified_relation_name()
Definition at line 14001 of file ruleutils.c.
References elog, ERROR, fb(), get_qualified_objname(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), ReleaseSysCache(), result, 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 14292 of file ruleutils.c.
14293{
14294 HeapTuple tp;
14297 char *nspname;
14299
14305
14307 if (!nspname)
14309 typtup->typnamespace);
14310
14312
14313 ReleaseSysCache(tp);
14314
14316}
References elog, ERROR, fb(), Form_pg_type, get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), ReleaseSysCache(), result, SearchSysCache1(), and typname.
Referenced by pg_get_constraintdef_worker().
◆ generate_relation_name()
Definition at line 13941 of file ruleutils.c.
13942{
13943 HeapTuple tp;
13948 char *nspname;
13950
13956
13957 /* Check for conflicting CTE name */
13960 {
13963
13965 {
13967
13969 {
13971 break;
13972 }
13973 }
13975 break;
13976 }
13977
13978 /* Otherwise, qualify the name if not visible in search path */
13981
13984 else
13985 nspname = NULL;
13986
13988
13989 ReleaseSysCache(tp);
13990
13992}
References CommonTableExpr::ctename, elog, ERROR, fb(), get_namespace_name_or_temp(), GETSTRUCT(), HeapTupleIsValid, lfirst, NameStr, ObjectIdGetDatum(), quote_qualified_identifier(), RelationIsVisible(), ReleaseSysCache(), relname, result, 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_propgraphdef_elements(), 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 11597 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 11459 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 11471 of file ruleutils.c.
11474{
11477 int nargs;
11479
11480 /*
11481 * For a combining aggregate, we look up and deparse the corresponding
11482 * partial aggregate instead. This is necessary because our input
11483 * argument list has been replaced; the new argument list always has just
11484 * one element, which will point to a partial Aggref that supplies us with
11485 * transition states to combine.
11486 */
11488 {
11490
11495 return;
11496 }
11497
11498 /*
11499 * Mark as PARTIAL, if appropriate. We look to the original aggref so as
11500 * to avoid printing this when recursing from the code just above.
11501 */
11504
11505 /* Extract the argument types as seen by the parser */
11506 nargs = get_aggregate_argtypes(aggref, argtypes);
11507
11510 argtypes, aggref->aggvariadic,
11511 &use_variadic,
11512 context->inGroupBy);
11513
11514 /* Print the aggregate name, schema-qualified if needed */
11517
11519 {
11520 /*
11521 * Ordered-set aggregates do not use "*" syntax. Also, we needn't
11522 * worry about inserting VARIADIC. So we can just dump the direct
11523 * args as-is.
11524 */
11525 Assert(!aggref->aggvariadic);
11530 }
11531 else
11532 {
11533 /* aggstar can be set only in zero-argument aggregates */
11534 if (aggref->aggstar)
11536 else
11537 {
11538 ListCell *l;
11540
11541 i = 0;
11543 {
11546
11549 continue;
11551 {
11553 {
11554 /*
11555 * the ABSENT ON NULL and WITH UNIQUE args are printed
11556 * separately, so ignore them here
11557 */
11559 break;
11560
11562 }
11563 else
11565 }
11569 }
11570 }
11571
11573 {
11576 }
11577 }
11578
11581
11583 {
11586 }
11587
11589}
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 6476 of file ruleutils.c.
6477{
6481 ListCell *l;
6482
6484 {
6487 }
6488
6489 /*
6490 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6491 * VALUES part. This reverses what transformValuesClause() did at parse
6492 * time.
6493 */
6496 {
6498 return;
6499 }
6500
6501 /*
6502 * Build up the query string - first we say SELECT
6503 */
6504 if (query->isReturn)
6506 else
6508
6509 /* Add the DISTINCT clause if given */
6511 {
6512 if (query->hasDistinctOn)
6513 {
6517 {
6519
6522 false, context);
6524 }
6526 }
6527 else
6529 }
6530
6531 /* Then we tell what to select (the targetlist) */
6533
6534 /* Add the FROM clause if needed */
6536
6537 /* Add the WHERE clause if given */
6539 {
6543 }
6544
6545 /* Add the GROUP BY clause if given */
6547 {
6549
6554
6557
6559 {
6562 {
6564
6567 false, context);
6569 }
6570 }
6571 else
6572 {
6575 {
6577
6581 }
6582 }
6583
6585 }
6586
6587 /* Add the HAVING clause if given */
6589 {
6593 }
6594
6595 /* Add the WINDOW clause if needed */
6597 get_rule_windowclause(query, context);
6598}
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::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 11994 of file ruleutils.c.
11997{
11999
12000 /*
12001 * Since parse_coerce.c doesn't immediately collapse application of
12002 * length-coercion functions to constants, what we'll typically see in
12003 * such cases is a Const with typmod -1 and a length-coercion function
12004 * right above it. Avoid generating redundant output. However, beware of
12005 * suppressing casts when the user actually wrote something like
12006 * 'foo'::text::char(3).
12007 *
12008 * Note: it might seem that we are missing the possibility of needing to
12009 * print a COLLATE clause for such a Const. However, a Const could only
12010 * have nondefault collation in a post-constant-folding tree, in which the
12011 * length coercion would have been folded too. See also the special
12012 * handling of CollateExpr in coerce_to_target_type(): any collation
12013 * marking will be above the coercion node, not below it.
12014 */
12018 {
12019 /* Show the constant without normal ::typename decoration */
12021 }
12022 else
12023 {
12029 }
12030
12031 /*
12032 * Never emit resulttype(arg) functional notation. A pg_proc entry could
12033 * take precedence, and a resulttype in pg_temp would require schema
12034 * qualification that format_type_with_typemod() would usually omit. We've
12035 * standardized on arg::resulttype, but CAST(arg AS resulttype) notation
12036 * would work fine.
12037 */
12040}
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 13514 of file ruleutils.c.
13515{
13518 bool first = true;
13519
13520 /* Don't print aliases if not needed */
13522 return;
13523
13525 {
13527
13528 if (first)
13529 {
13531 first = false;
13532 }
13533 else
13536 }
13537 if (!first)
13539}
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 12188 of file ruleutils.c.
12189{
12191
12193 {
12195
12196 if (constval->constcollid != typcollation)
12197 {
12199 generate_collation_name(constval->constcollid));
12200 }
12201 }
12202}
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 12058 of file ruleutils.c.
12059{
12061 Oid typoutput;
12065
12066 if (constval->constisnull)
12067 {
12068 /*
12069 * Always label the type of a NULL constant to prevent misdecisions
12070 * about type when reparsing.
12071 */
12074 {
12077 constval->consttypmod));
12078 get_const_collation(constval, context);
12079 }
12080 return;
12081 }
12082
12084 &typoutput, &typIsVarlena);
12085
12087
12089 {
12091
12092 /*
12093 * INT4 can be printed without any decoration, unless it is
12094 * negative; in that case print it as '-nnn'::integer to ensure
12095 * that the output will re-parse as a constant, not as a constant
12096 * plus operator. In most cases we could get away with printing
12097 * (-nnn) instead, because of the way that gram.y handles negative
12098 * literals; but that doesn't work for INT_MIN, and it doesn't
12099 * seem that much prettier anyway.
12100 */
12103 else
12104 {
12107 }
12108 break;
12109
12111
12112 /*
12113 * NUMERIC can be printed without quotes if it looks like a float
12114 * constant (not an integer, and not Infinity or NaN) and doesn't
12115 * have a leading sign (for the same reason as for INT4).
12116 */
12119 {
12121 }
12122 else
12123 {
12126 }
12127 break;
12128
12132 else
12134 break;
12135
12136 default:
12138 break;
12139 }
12140
12142
12144 return;
12145
12146 /*
12147 * For showtype == 0, append ::typename unless the constant will be
12148 * implicitly typed as the right type when it is read in.
12149 *
12150 * XXX this code has to be kept in sync with the behavior of the parser,
12151 * especially make_const.
12152 */
12154 {
12157 /* These types can be left unlabeled */
12159 break;
12161 /* We determined above whether a label is needed */
12162 break;
12164
12165 /*
12166 * Float-looking constants will be typed as numeric, which we
12167 * checked above; but if there's a nondefault typmod we need to
12168 * show it.
12169 */
12170 needlabel |= (constval->consttypmod >= 0);
12171 break;
12172 default:
12174 break;
12175 }
12179 constval->consttypmod));
12180
12181 get_const_collation(constval, context);
12182}
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 7743 of file ruleutils.c.
7744{
7747
7748 /* Insert the WITH clause if given */
7749 get_with_clause(query, context);
7750
7751 /*
7752 * Start the query with DELETE FROM relname
7753 */
7757 {
7760 }
7764
7765 /* Print the FOR PORTION OF, if needed */
7767
7768 /* Print the relation alias, if needed */
7770
7771 /* Add the USING clause if given */
7773
7774 /* Add a WHERE clause if given */
7776 {
7780 }
7781
7782 /* Add RETURNING if present */
7784 get_returning_clause(query, context);
7785}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), Assert, deparse_context::buf, buf, fb(), Query::forPortionOf, generate_relation_name(), get_for_portion_of(), 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_for_portion_of()
|
static |
Definition at line 13481 of file ruleutils.c.
13482{
13483 if (forPortionOf)
13484 {
13487
13488 /*
13489 * Try to write it as FROM ... TO ... if we received it that way,
13490 * otherwise (targetRange).
13491 */
13493 {
13498 }
13499 else
13500 {
13504 }
13505 }
13506}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, get_rule_expr(), quote_identifier(), ForPortionOfExpr::range_name, ForPortionOfExpr::targetFrom, ForPortionOfExpr::targetRange, and ForPortionOfExpr::targetTo.
Referenced by get_delete_query_def(), and get_update_query_def().
◆ get_from_clause()
|
static |
Definition at line 13002 of file ruleutils.c.
13003{
13005 bool first = true;
13006 ListCell *l;
13007
13008 /*
13009 * We use the query's jointree as a guide to what to print. However, we
13010 * must ignore auto-added RTEs that are marked not inFromCl. (These can
13011 * only appear at the top level of the jointree, so it's sufficient to
13012 * check here.) This check also ensures we ignore the rule pseudo-RTEs
13013 * for NEW and OLD.
13014 */
13016 {
13018
13020 {
13023
13025 continue;
13026 }
13027
13028 if (first)
13029 {
13030 appendContextKeyword(context, prefix,
13032 first = false;
13033
13034 get_from_clause_item(jtnode, query, context);
13035 }
13036 else
13037 {
13039
13041
13042 /*
13043 * Put the new FROM item's text into itembuf so we can decide
13044 * after we've got it whether or not it needs to go on a new line.
13045 */
13048
13049 get_from_clause_item(jtnode, query, context);
13050
13051 /* Restore context's output buffer */
13053
13054 /* Consider line-wrapping if enabled */
13056 {
13057 /* Does the new item start with a new line? */
13059 {
13060 /* If so, we shouldn't add anything */
13061 /* instead, remove any trailing spaces currently in buf */
13063 }
13064 else
13065 {
13067
13068 /* Locate the start of the current line in the buffer */
13072 else
13073 trailing_nl++;
13074
13075 /*
13076 * Add a newline, plus some indentation, if the new item
13077 * would cause an overflow.
13078 */
13081 PRETTYINDENT_STD,
13082 PRETTYINDENT_VAR);
13083 }
13084 }
13085
13086 /* Add the new item */
13088
13089 /* clean up */
13091 }
13092 }
13093}
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 13554 of file ruleutils.c.
13557{
13559 ListCell *l1;
13560 ListCell *l2;
13561 ListCell *l3;
13562 ListCell *l4;
13564
13566
13567 i = 0;
13568 forfour(l1, rtfunc->funccoltypes,
13569 l2, rtfunc->funccoltypmods,
13570 l3, rtfunc->funccolcollations,
13571 l4, rtfunc->funccolnames)
13572 {
13577
13580 else
13582
13584
13589 format_type_with_typemod(atttypid, atttypmod));
13591 attcollation != get_typcollation(atttypid))
13593 generate_collation_name(attcollation));
13594
13595 i++;
13596 }
13597
13599}
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 13096 of file ruleutils.c.
13097{
13100
13102 {
13107
13110
13111 /* Print the FROM item proper */
13113 {
13115 /* Normal relation RTE */
13119 context->namespaces));
13120 break;
13122 /* Subquery RTE */
13125 true,
13127 context->indentLevel);
13129 break;
13131 /* Function RTE */
13133
13134 /*
13135 * Omit ROWS FROM() syntax for just one function, unless it
13136 * has both a coldeflist and WITH ORDINALITY. If it has both,
13137 * we must use ROWS FROM() syntax to avoid ambiguity about
13138 * whether the coldeflist includes the ordinality column.
13139 */
13142 {
13144 /* we'll print the coldeflist below, if it has one */
13145 }
13146 else
13147 {
13150
13151 /*
13152 * If all the function calls in the list are to unnest,
13153 * and none need a coldeflist, then collapse the list back
13154 * down to UNNEST(args). (If we had more than one
13155 * built-in unnest function, this would get more
13156 * difficult.)
13157 *
13158 * XXX This is pretty ugly, since it makes not-terribly-
13159 * future-proof assumptions about what the parser would do
13160 * with the output; but the alternative is to emit our
13161 * nonstandard ROWS FROM() notation for what might have
13162 * been a perfectly spec-compliant multi-argument
13163 * UNNEST().
13164 */
13167 {
13169
13172 rtfunc->funccolnames != NIL)
13173 {
13175 break;
13176 }
13177 }
13178
13180 {
13182
13184 {
13187
13189 }
13190
13194 }
13195 else
13196 {
13198
13201 {
13203
13208 {
13209 /* Reconstruct the column definition list */
13211 get_from_clause_coldeflist(rtfunc,
13212 NULL,
13213 context);
13214 }
13215 funcno++;
13216 }
13218 }
13219 /* prevent printing duplicate coldeflist below */
13221 }
13224 break;
13227 break;
13234 {
13235 bool first = true;
13236
13238 {
13239 if (!first)
13241 else
13242 first = false;
13243
13247 }
13248 }
13250 break;
13252 /* Values list RTE */
13256 break;
13259 break;
13260 default:
13262 break;
13263 }
13264
13265 /* Print the relation alias, if needed */
13267
13268 /* Print the column definitions or aliases, if needed */
13270 {
13271 /* Reconstruct the columndef list, which is also the aliases */
13273 }
13274 else
13275 {
13276 /* Else print column aliases as needed */
13278 }
13279
13280 /* Tablesample clause must go after any alias */
13283 }
13285 {
13289
13293
13296
13298
13300 {
13304 -PRETTYINDENT_STD,
13305 PRETTYINDENT_STD,
13306 PRETTYINDENT_JOIN);
13307 else
13309 -PRETTYINDENT_STD,
13310 PRETTYINDENT_STD,
13311 PRETTYINDENT_JOIN);
13312 break;
13315 -PRETTYINDENT_STD,
13316 PRETTYINDENT_STD,
13317 PRETTYINDENT_JOIN);
13318 break;
13321 -PRETTYINDENT_STD,
13322 PRETTYINDENT_STD,
13323 PRETTYINDENT_JOIN);
13324 break;
13327 -PRETTYINDENT_STD,
13328 PRETTYINDENT_STD,
13329 PRETTYINDENT_JOIN);
13330 break;
13331 default:
13334 }
13335
13341
13343 {
13345 bool first = true;
13346
13348 /* Use the assigned names, not what's in usingClause */
13350 {
13352
13353 if (first)
13354 first = false;
13355 else
13358 }
13360
13364 }
13366 {
13373 }
13375 {
13376 /* If we didn't say CROSS JOIN above, we must provide an ON */
13378 }
13379
13382
13383 /* Yes, it's correct to put alias after the right paren ... */
13385 {
13386 /*
13387 * Note that it's correct to emit an alias clause if and only if
13388 * there was one originally. Otherwise we'd be converting a named
13389 * join to unnamed or vice versa, which creates semantic
13390 * subtleties we don't want. However, we might print a different
13391 * alias name than was there originally.
13392 */
13395 context)));
13397 }
13398 }
13399 else
13402}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, deparse_columns_fetch, elog, ERROR, fb(), foreach_node, RangeTblFunction::funcexpr, generate_relation_name(), get_column_alias_list(), get_from_clause_coldeflist(), get_from_clause_item(), get_graph_pattern_def(), 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_GRAPH_TABLE, 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 11363 of file ruleutils.c.
11365{
11369 int nargs;
11370 List *argnames;
11372 ListCell *l;
11373
11374 /*
11375 * If the function call came from an implicit coercion, then just show the
11376 * first argument --- unless caller wants to see implicit coercions.
11377 */
11379 {
11382 return;
11383 }
11384
11385 /*
11386 * If the function call came from a cast, then show the first argument
11387 * plus an explicit cast operation.
11388 */
11390 expr->funcformat == COERCE_IMPLICIT_CAST)
11391 {
11393 Oid rettype = expr->funcresulttype;
11395
11396 /* Get the typmod if this is a length-coercion function */
11398
11400 rettype, coercedTypmod,
11401 (Node *) expr);
11402
11403 return;
11404 }
11405
11406 /*
11407 * If the function was called using one of the SQL spec's random special
11408 * syntaxes, try to reproduce that. If we don't recognize the function,
11409 * fall through.
11410 */
11412 {
11414 return;
11415 }
11416
11417 /*
11418 * Normal function: display as proname(args). First we need to extract
11419 * the argument datatypes.
11420 */
11425 nargs = 0;
11426 argnames = NIL;
11428 {
11430
11434 nargs++;
11435 }
11436
11439 argnames, argtypes,
11440 expr->funcvariadic,
11441 &use_variadic,
11442 context->inGroupBy));
11443 nargs = 0;
11445 {
11446 if (nargs++ > 0)
11451 }
11453}
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 11742 of file ruleutils.c.
11743{
11746
11748 {
11755 /* AT TIME ZONE ... note reversed argument order */
11758 (Node *) expr);
11761 (Node *) expr);
11763 return true;
11764
11768 /* AT LOCAL */
11771 (Node *) expr);
11773 return true;
11774
11788 /* (x1, x2) OVERLAPS (y1, y2) */
11798 return true;
11799
11806 /* EXTRACT (x FROM y) */
11808 {
11810
11813 !con->constisnull);
11815 }
11819 return true;
11820
11822 /* IS xxx NORMALIZED */
11825 (Node *) expr);
11828 {
11830
11833 !con->constisnull);
11835 TextDatumGetCString(con->constvalue));
11836 }
11838 return true;
11839
11841 /* COLLATION FOR */
11845 return true;
11846
11848 /* NORMALIZE() */
11852 {
11854
11857 !con->constisnull);
11859 TextDatumGetCString(con->constvalue));
11860 }
11862 return true;
11863
11870 /* OVERLAY() */
11878 {
11881 }
11883 return true;
11884
11888 /* POSITION() ... extra parens since args are b_expr not a_expr */
11894 return true;
11895
11902 /* SUBSTRING FROM/FOR (i.e., integer-position variants) */
11908 {
11911 }
11913 return true;
11914
11916 /* SUBSTRING SIMILAR/ESCAPE */
11924 return true;
11925
11929 /* TRIM() */
11932 {
11935 }
11939 return true;
11940
11944 /* TRIM() */
11947 {
11950 }
11954 return true;
11955
11959 /* TRIM() */
11962 {
11965 }
11969 return true;
11970
11973 return true;
11974
11976 /* XMLEXISTS ... extra parens because args are c_expr */
11982 return true;
11983 }
11984 return false;
11985}
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_graph_label_expr()
|
static |
Definition at line 7982 of file ruleutils.c.
7983{
7985
7986 check_stack_depth();
7987
7989 {
7991 {
7993
7995 break;
7996 }
7997
7999 {
8002 bool first = true;
8003
8005
8007 {
8008 if (!first)
8009 {
8012 }
8013 else
8014 first = false;
8016 }
8017
8018 break;
8019 }
8020
8021 default:
8023 break;
8024 }
8025}
References appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, check_stack_depth(), elog, ERROR, fb(), get_graph_label_expr(), get_propgraph_label_name(), lfirst, nodeTag, OR_EXPR, and quote_identifier().
Referenced by get_graph_label_expr(), and get_path_pattern_expr_def().
◆ get_graph_pattern_def()
|
static |
Definition at line 8117 of file ruleutils.c.
8118{
8121 bool first = true;
8122
8124 {
8126
8127 if (!first)
8129 else
8130 first = false;
8131
8133 }
8134
8136 {
8139 }
8140}
References appendStringInfoString(), deparse_context::buf, buf, fb(), get_path_pattern_expr_def(), get_rule_expr(), lfirst_node, GraphPattern::path_pattern_list, and GraphPattern::whereClause.
Referenced by get_from_clause_item().
◆ get_insert_query_def()
|
static |
Definition at line 7307 of file ruleutils.c.
7308{
7314 ListCell *l;
7316
7317 /* Insert the WITH clause if given */
7318 get_with_clause(query, context);
7319
7320 /*
7321 * If it's an INSERT ... SELECT or multi-row VALUES, there will be a
7322 * single RTE for the SELECT or VALUES. Plain VALUES has neither.
7323 */
7325 {
7327
7329 {
7333 }
7334
7336 {
7340 }
7341 }
7344
7345 /*
7346 * Start the query with INSERT INTO relname
7347 */
7350
7352 {
7355 }
7358
7359 /* Print the relation alias, if needed; INSERT requires explicit AS */
7361
7362 /* always want a space here */
7364
7365 /*
7366 * Add the insert-column-names list. Any indirection decoration needed on
7367 * the column names can be inferred from the top targetlist.
7368 */
7374 {
7376
7378 continue; /* ignore junk entries */
7379
7382
7383 /*
7384 * Put out name of target column; look in the catalogs, not at
7385 * tle->resname, since resname will fail to track RENAME.
7386 */
7389 tle->resno,
7390 false)));
7391
7392 /*
7393 * Print any indirection needed (subfields or subscripts), and strip
7394 * off the top-level nodes representing the indirection assignments.
7395 * Add the stripped expressions to strippedexprs. (If it's a
7396 * single-VALUES statement, the stripped expressions are the VALUES to
7397 * print below. Otherwise they're just Vars and not really
7398 * interesting.)
7399 */
7402 context));
7403 }
7406
7407 if (query->override)
7408 {
7413 }
7414
7416 {
7417 /* Add the SELECT */
7419 false,
7421 context->indentLevel);
7422 }
7424 {
7425 /* Add the multi-VALUES expression lists */
7427 }
7429 {
7430 /* Add the single-VALUES expression list */
7435 }
7436 else
7437 {
7438 /* No expressions, so it must be DEFAULT VALUES */
7440 }
7441
7442 /* Add ON CONFLICT if present */
7444 {
7446
7448
7450 {
7451 /* Add the single-VALUES expression list */
7455
7456 /* Add a WHERE clause (for partial indexes) if given */
7458 {
7460
7461 /*
7462 * Force non-prefixing of Vars, since parser assumes that they
7463 * belong to target relation. WHERE clause does not use
7464 * InferenceElem, so this is separately required.
7465 */
7468
7472
7474 }
7475 }
7477 {
7479
7480 if (!constraint)
7482 confl->constraint);
7484 quote_identifier(constraint));
7485 }
7486
7488 {
7490 }
7492 {
7494 /* Deparse targetlist */
7496 context, rte);
7497
7498 /* Add a WHERE clause if given */
7500 {
7504 }
7505 }
7506 else
7507 {
7510
7511 /* Add FOR [KEY] UPDATE/SHARE clause if present */
7514
7515 /* Add a WHERE clause if given */
7517 {
7521 }
7522 }
7523 }
7524
7525 /* Add RETURNING if present */
7527 get_returning_clause(query, context);
7528}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, elog, ERROR, fb(), generate_relation_name(), get_attname(), get_constraint_name(), get_lock_clause_strength(), get_query_def(), get_returning_clause(), get_rte_alias(), get_rule_expr(), get_rule_list_toplevel(), get_update_query_targetlist_def(), get_values_def(), get_with_clause(), deparse_context::indentLevel, lappend(), LCS_NONE, lfirst, deparse_context::namespaces, NIL, OidIsValid, Query::onConflict, ONCONFLICT_NOTHING, ONCONFLICT_SELECT, ONCONFLICT_UPDATE, OVERRIDING_SYSTEM_VALUE, OVERRIDING_USER_VALUE, PRETTY_INDENT, deparse_context::prettyFlags, PRETTYINDENT_STD, processIndirection(), quote_identifier(), Query::returningList, rt_fetch, Query::rtable, RTE_RELATION, RTE_SUBQUERY, RTE_VALUES, Query::targetList, deparse_context::varprefix, and deparse_context::wrapColumn.
Referenced by get_query_def().
◆ get_json_agg_constructor()
|
static |
Definition at line 12376 of file ruleutils.c.
12378{
12380
12383
12391 is_json_objectagg);
12393 {
12394 /*
12395 * If the aggregate is computed by a lower plan node, setrefs.c will
12396 * have replaced the Aggref or WindowFunc with a Var referencing that
12397 * node's output. Chase the Var back to it so we can still print the
12398 * original JSON aggregate syntax. This only happens in EXPLAIN.
12399 */
12402 }
12403 else
12406}
References elog, ERROR, fb(), funcname, get_agg_expr_helper(), get_json_agg_constructor_expr(), get_json_constructor_options(), get_windowfunc_expr_helper(), initStringInfo(), IsA, nodeTag, and resolve_special_varno().
Referenced by get_json_constructor().
◆ get_json_agg_constructor_expr()
|
static |
Definition at line 12413 of file ruleutils.c.
12415{
12417
12420
12421 /* Flat copy suffices; we only replace func. */
12425}
References elog, ERROR, fb(), get_json_constructor(), and IsA.
Referenced by get_json_agg_constructor().
◆ get_json_behavior()
|
static |
Definition at line 9738 of file ruleutils.c.
9740{
9741 /*
9742 * The order of array elements must correspond to the order of
9743 * JsonBehaviorType members.
9744 */
9746 {
9747 " NULL",
9748 " ERROR",
9749 " EMPTY",
9750 " TRUE",
9751 " FALSE",
9752 " UNKNOWN",
9753 " EMPTY ARRAY",
9754 " EMPTY OBJECT",
9755 " DEFAULT "
9756 };
9757
9760
9762
9765
9767}
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 12265 of file ruleutils.c.
12267{
12273
12275 {
12277 return;
12278 }
12280 {
12282 return;
12283 }
12285 {
12287
12289
12292 context->indentLevel);
12293
12296
12297 return;
12298 }
12299
12301 {
12304 break;
12307 break;
12310 break;
12313 break;
12316 break;
12317 default:
12319 }
12320
12322
12325 {
12328 {
12330
12333 }
12334
12336 }
12337
12340}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, castNode, elog, ERROR, fb(), foreach_current_index, funcname, get_json_agg_constructor(), get_json_constructor_options(), get_query_def(), get_rule_expr(), deparse_context::indentLevel, JSCTOR_JSON_ARRAY, JSCTOR_JSON_ARRAY_QUERY, JSCTOR_JSON_ARRAYAGG, JSCTOR_JSON_OBJECT, JSCTOR_JSON_OBJECTAGG, JSCTOR_JSON_PARSE, JSCTOR_JSON_SCALAR, JSCTOR_JSON_SERIALIZE, lfirst, deparse_context::namespaces, deparse_context::prettyFlags, and deparse_context::wrapColumn.
Referenced by get_json_agg_constructor_expr(), and get_rule_expr().
◆ get_json_constructor_options()
|
static |
Definition at line 12346 of file ruleutils.c.
12347{
12349 {
12353 }
12354 else
12355 {
12359 }
12360
12363
12364 /*
12365 * Append RETURNING clause if needed; JSON() and JSON_SCALAR() don't
12366 * support one.
12367 */
12370}
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 9776 of file ruleutils.c.
9778{
9780 {
9785 /* The default */
9788
9791 /* The default */
9792 else
9794 }
9795
9798
9801}
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 12220 of file ruleutils.c.
12221{
12223 return;
12224
12227 " FORMAT JSONB" : " FORMAT JSON");
12228
12230 {
12232
12233 encoding =
12236
12238 }
12239}
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 12208 of file ruleutils.c.
12209{
12212 else
12214}
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 12245 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 12902 of file ruleutils.c.
12903{
12907
12909
12912
12914
12916
12918
12920
12922
12924 {
12926 *lc2;
12928
12931
12934
12937 {
12941
12943
12947 );
12948 }
12949
12952 }
12953
12955 showimplicit);
12956
12957 /*
12958 * Deparse a PLAN clause only for a non-default plan; the default plan is
12959 * implied by the NESTED COLUMNS structure (see
12960 * json_table_plan_is_default).
12961 */
12963 {
12967 }
12968
12971
12974
12976}
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_json_table_plan(), get_rule_expr(), deparse_context::indentLevel, JSON_BEHAVIOR_EMPTY_ARRAY, json_table_plan_is_default(), lfirst, lfirst_node, PRETTY_INDENT, PRETTYINDENT_VAR, quote_identifier(), and root.
Referenced by get_tablefunc().
◆ get_json_table_columns()
|
static |
Definition at line 12796 of file ruleutils.c.
12799{
12805 int colnum = 0;
12806
12809
12812
12814 lc_coltype, tf->coltypes,
12815 lc_coltypmod, tf->coltypmods,
12816 lc_colvalexpr, tf->colvalexprs)
12817 {
12819 JsonExpr *colexpr;
12820 Oid typid;
12821 int32 typmod;
12822 bool ordinality;
12824
12828
12829 /* Skip columns that don't belong to this scan. */
12831 {
12832 colnum++;
12833 continue;
12834 }
12836 break;
12837
12840
12841 colnum++;
12842
12843 ordinality = !colexpr;
12844
12846
12848 ordinality ? "FOR ORDINALITY" :
12849 format_type_with_typemod(typid, typmod));
12850 if (ordinality)
12851 continue;
12852
12853 /*
12854 * Set default_behavior to guide get_json_expr_options() on whether to
12855 * emit the ON ERROR / EMPTY clauses.
12856 */
12858 {
12861 }
12862 else
12863 {
12865 {
12868
12870
12874 " FORMAT JSONB" : " FORMAT JSON");
12875 }
12876
12878 }
12879
12881
12883
12885 }
12886
12889 scan->colMin >= 0);
12890
12893
12895}
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 12680 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_json_table_plan()
|
static |
Definition at line 12752 of file ruleutils.c.
12754{
12757
12759 {
12761
12763
12765 {
12771 }
12772 }
12774 {
12776
12780
12782
12786 }
12787
12790}
References appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, castNode, JsonTablePathScan::child, fb(), get_json_table_plan(), IsA, j, JsonTablePath::name, JsonTablePathScan::outerJoin, JsonTablePathScan::path, plan, and quote_identifier().
Referenced by get_json_table(), and get_json_table_plan().
◆ get_lock_clause_strength()
|
static |
Definition at line 6380 of file ruleutils.c.
6381{
6382 switch (strength)
6383 {
6385 /* we intentionally throw an error for LCS_NONE */
6387 (int) strength);
6388 break;
6390 return " FOR KEY SHARE";
6392 return " FOR SHARE";
6394 return " FOR NO KEY UPDATE";
6396 return " FOR UPDATE";
6397 }
6399}
References elog, ERROR, fb(), LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, and LCS_NONE.
Referenced by get_insert_query_def(), and get_select_query_def().
◆ get_merge_query_def()
|
static |
Definition at line 7793 of file ruleutils.c.
7794{
7799
7800 /* Insert the WITH clause if given */
7801 get_with_clause(query, context);
7802
7803 /*
7804 * Start the query with MERGE INTO relname
7805 */
7809 {
7812 }
7816
7817 /* Print the relation alias, if needed */
7819
7820 /* Print the source relation and join clause */
7825
7826 /*
7827 * Test for any NOT MATCHED BY SOURCE actions. If there are none, then
7828 * any NOT MATCHED BY TARGET actions are output as "WHEN NOT MATCHED", per
7829 * SQL standard. Otherwise, we have a non-SQL-standard query, so output
7830 * "BY SOURCE" / "BY TARGET" qualifiers for all NOT MATCHED actions, to be
7831 * more explicit.
7832 */
7835 {
7837
7839 {
7841 break;
7842 }
7843 }
7844
7845 /* Print each merge action */
7847 {
7849
7853 {
7856 break;
7859 break;
7863 else
7865 break;
7866 default:
7869 }
7870
7872 {
7876 }
7879
7881 {
7882 /* This generally matches get_insert_query_def() */
7886
7888
7892 {
7894
7896
7899
7902 tle->resno,
7903 false)));
7906 context));
7907 }
7910
7912 {
7917 }
7918
7920 {
7925 }
7926 else
7928 }
7930 {
7933 context, rte);
7934 }
7939 }
7940
7941 /* Add RETURNING if present */
7943 get_returning_clause(query, context);
7944}
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 8573 of file ruleutils.c.
8575{
8580 int varno;
8581 AttrNumber varattno;
8583 Node *expr;
8584
8585 /*
8586 * If it's a RowExpr that was expanded from a whole-row Var, use the
8587 * column names attached to it. (We could let get_expr_result_tupdesc()
8588 * handle this, but it's much cheaper to just pull out the name we need.)
8589 */
8591 {
8593
8596 }
8597
8598 /*
8599 * If it's a Param of type RECORD, try to find what the Param refers to.
8600 */
8602 {
8605
8607 if (expr)
8608 {
8609 /* Found a match, so recurse to decipher the field name */
8612
8615 0, context);
8618 }
8619 }
8620
8621 /*
8622 * If it's a Var of type RECORD, we have to find what the Var refers to;
8623 * if not, we can use get_expr_result_tupdesc().
8624 */
8626 var->vartype != RECORDOID)
8627 {
8629 /* Got the tupdesc, so we can extract the field name */
8632 }
8633
8634 /* Find appropriate nesting depth */
8638 var->varlevelsup, levelsup);
8640 netlevelsup);
8641
8642 /*
8643 * If we have a syntactic referent for the Var, and we're working from a
8644 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8645 * on the semantic referent. (See comments in get_variable().)
8646 */
8648 {
8649 varno = var->varnosyn;
8650 varattno = var->varattnosyn;
8651 }
8652 else
8653 {
8654 varno = var->varno;
8655 varattno = var->varattno;
8656 }
8657
8658 /*
8659 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8660 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8661 * down into the subplans, or INDEX_VAR, which is resolved similarly.
8662 *
8663 * Note: unlike get_variable and resolve_special_varno, we need not worry
8664 * about inheritance mapping: a child Var should have the same datatype as
8665 * its parent, and here we're really only interested in the Var's type.
8666 */
8668 {
8670 attnum = varattno;
8671 }
8673 {
8677
8681
8684
8686 levelsup, context);
8687
8690 }
8692 {
8696
8700
8703
8705 levelsup, context);
8706
8709 }
8711 {
8714
8718
8720
8722 levelsup, context);
8723
8725 }
8726 else
8727 {
8730 }
8731
8733 {
8734 /* Var is whole-row reference to RTE, so select the right field */
8736 }
8737
8738 /*
8739 * This part has essentially the same logic as the parser's
8740 * expandRecordVariable() function, but we are dealing with a different
8741 * representation of the input context, and we only need one field name
8742 * not a TupleDesc. Also, we need special cases for finding subquery and
8743 * CTE subplans when deparsing Plan trees.
8744 */
8746
8748 {
8754
8755 /*
8756 * This case should not occur: a column of a table, values list,
8757 * or ENR shouldn't have type RECORD. Fall through and fail (most
8758 * likely) at the bottom.
8759 */
8760 break;
8762 /* Subselect-in-FROM: examine sub-select's output expr */
8763 {
8765 {
8767 attnum);
8768
8774 {
8775 /*
8776 * Recurse into the sub-select to see what its Var
8777 * refers to. We have to build an additional level of
8778 * namespace to keep in step with varlevelsup in the
8779 * subselect; furthermore, the subquery RTE might be
8780 * from an outer query level, in which case the
8781 * namespace for the subselect must have that outer
8782 * level as parent namespace.
8783 */
8788
8790 netlevelsup);
8791
8793 parent_namespaces);
8794
8796
8798 0, context);
8799
8801
8803 }
8804 /* else fall through to inspect the expression */
8805 }
8806 else
8807 {
8808 /*
8809 * We're deparsing a Plan tree so we don't have complete
8810 * RTE entries (in particular, rte->subquery is NULL). But
8811 * the only place we'd normally see a Var directly
8812 * referencing a SUBQUERY RTE is in a SubqueryScan plan
8813 * node, and we can look into the child plan's tlist
8814 * instead. An exception occurs if the subquery was
8815 * proven empty and optimized away: then we'd find such a
8816 * Var in a childless Result node, and there's nothing in
8817 * the plan tree that would let us figure out what it had
8818 * originally referenced. In that case, fall back on
8819 * printing "fN", analogously to the default column names
8820 * for RowExprs.
8821 */
8825
8827 {
8829
8833 }
8835
8839 attnum);
8842
8844 levelsup, context);
8845
8848 }
8849 }
8850 break;
8852 /* Join RTE --- recursively inspect the alias variable */
8858 /* we intentionally don't strip implicit coercions here */
8861 var->varlevelsup + levelsup,
8862 context);
8863 /* else fall through to inspect the expression */
8864 break;
8867
8868 /*
8869 * We couldn't get here unless a function is declared with one of
8870 * its result columns as RECORD, which is not allowed.
8871 */
8872 break;
8874 /* CTE reference: examine subquery's output expr */
8875 {
8877 Index ctelevelsup;
8879
8880 /*
8881 * Try to find the referenced CTE using the namespace stack.
8882 */
8886 else
8887 {
8889
8893 {
8896 break;
8897 }
8898 }
8900 {
8903 attnum);
8904
8910 {
8911 /*
8912 * Recurse into the CTE to see what its Var refers to.
8913 * We have to build an additional level of namespace
8914 * to keep in step with varlevelsup in the CTE;
8915 * furthermore it could be an outer CTE (compare
8916 * SUBQUERY case above).
8917 */
8922
8924 ctelevelsup);
8925
8927 parent_namespaces);
8928
8930
8932 0, context);
8933
8935
8937 }
8938 /* else fall through to inspect the expression */
8939 }
8940 else
8941 {
8942 /*
8943 * We're deparsing a Plan tree so we don't have a CTE
8944 * list. But the only places we'd normally see a Var
8945 * directly referencing a CTE RTE are in CteScan or
8946 * WorkTableScan plan nodes. For those cases,
8947 * set_deparse_plan arranged for dpns->inner_plan to be
8948 * the plan node that emits the CTE or RecursiveUnion
8949 * result, and we can look at its tlist instead. As
8950 * above, this can fail if the CTE has been proven empty,
8951 * in which case fall back to "fN".
8952 */
8956
8958 {
8960
8964 }
8967
8971 attnum);
8974
8976 levelsup, context);
8977
8980 }
8981 }
8982 break;
8984
8985 /*
8986 * We couldn't get here: any Vars that reference the RTE_GROUP RTE
8987 * should have been replaced with the underlying grouping
8988 * expressions.
8989 */
8990 break;
8991 }
8992
8993 /*
8994 * We now have an expression we can't expand any more, so see if
8995 * get_expr_result_tupdesc() can do anything with it.
8996 */
8998 /* Got the tupdesc, so we can extract the field name */
9001}
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(), result, rt_fetch, RTE_CTE, RTE_FUNCTION, RTE_GRAPH_TABLE, 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 13649 of file ruleutils.c.
13651{
13655 char *nspname;
13656
13661
13664 {
13665 /* Okay, we need the opclass name. Do we need to qualify it? */
13669 else
13670 {
13673 quote_identifier(nspname),
13675 }
13676 }
13678}
References appendStringInfo(), buf, elog, ERROR, fb(), Form_pg_opclass, get_namespace_name_or_temp(), GetDefaultOpClass(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), OidIsValid, OpclassIsVisible(), quote_identifier(), ReleaseSysCache(), and SearchSysCache1().
Referenced by generate_opclass_name(), get_rule_expr(), pg_get_indexdef_worker(), and pg_get_partkeydef_worker().
◆ get_oper_expr()
|
static |
Definition at line 11323 of file ruleutils.c.
11324{
11328
11332 {
11333 /* binary operator */
11336
11339 generate_operator_name(opno,
11343 }
11344 else
11345 {
11346 /* prefix operator */
11348
11350 generate_operator_name(opno,
11351 InvalidOid,
11354 }
11357}
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 9244 of file ruleutils.c.
9245{
9246 Node *expr;
9249 SubPlan *subplan;
9251
9252 /*
9253 * If it's a PARAM_EXEC parameter, try to locate the expression from which
9254 * the parameter was computed. This stanza handles only cases in which
9255 * the Param represents an input to the subplan we are currently in.
9256 */
9258 if (expr)
9259 {
9260 /* Found a match, so print it */
9264
9265 /* Switch attention to the ancestor plan node */
9267
9268 /*
9269 * Force prefixing of Vars, since they won't belong to the relation
9270 * being scanned in the original plan node.
9271 */
9274
9275 /*
9276 * A Param's expansion is typically a Var, Aggref, GroupingFunc, or
9277 * upper-level Param, which wouldn't need extra parentheses.
9278 * Otherwise, insert parens to ensure the expression looks atomic.
9279 */
9286
9288
9291
9293
9295
9296 return;
9297 }
9298
9299 /*
9300 * Alternatively, maybe it's a subplan output, which we print as a
9301 * reference to the subplan. (We could drill down into the subplan and
9302 * print the relevant targetlist expression, but that has been deemed too
9303 * confusing since it would violate normal SQL scope rules. Also, we're
9304 * relying on this reference to show that the testexpr containing the
9305 * Param has anything to do with that subplan at all.)
9306 */
9308 if (subplan)
9309 {
9311
9314 else
9316
9319 nameprefix,
9320 subplan->plan_name, column + 1);
9321
9322 return;
9323 }
9324
9325 /*
9326 * If it's an external parameter, see if the outermost namespace provides
9327 * function argument names.
9328 */
9330 {
9333 param->paramid > 0 &&
9335 {
9337
9338 if (argname)
9339 {
9342
9343 /*
9344 * Qualify the parameter name if there are any other deparse
9345 * namespaces with range tables. This avoids qualifying in
9346 * trivial cases like "RETURN a + b", but makes it safe in all
9347 * other cases.
9348 */
9350 {
9352
9354 {
9356 break;
9357 }
9358 }
9360 {
9363 }
9364
9366 return;
9367 }
9368 }
9369 }
9370
9371 /*
9372 * Not PARAM_EXEC, or couldn't find referent: just print $N.
9373 *
9374 * It's a bug if we get here for anything except PARAM_EXTERN Params, but
9375 * in production builds printing $N seems more useful than failing.
9376 */
9378
9380}
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_path_pattern_expr_def()
|
static |
Definition at line 8031 of file ruleutils.c.
8032{
8035
8037 {
8040
8042 {
8045 break;
8048 break;
8052 break;
8055 break;
8056 }
8057
8059 {
8062 }
8063
8065 {
8070 }
8071
8073 {
8077 }
8078
8080 {
8084 }
8085
8087 {
8090 break;
8094 break;
8097 break;
8100 break;
8101 }
8102
8104 {
8107
8109 }
8110 }
8111}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, EDGE_PATTERN_ANY, EDGE_PATTERN_LEFT, EDGE_PATTERN_RIGHT, fb(), get_graph_label_expr(), get_path_pattern_expr_def(), get_rule_expr(), lfirst_node, linitial_int, lower(), lsecond_int, PAREN_EXPR, quote_identifier(), upper(), and VERTEX_PATTERN.
Referenced by get_graph_pattern_def(), and get_path_pattern_expr_def().
◆ get_query_def()
|
static |
Definition at line 5988 of file ruleutils.c.
5991{
5992 deparse_context context;
5994 int rtable_size;
5995
5996 /* Guard against excessively long or deeply-nested queries */
5997 CHECK_FOR_INTERRUPTS();
5998 check_stack_depth();
5999
6000 rtable_size = query->hasGroupRTE ?
6003
6004 /*
6005 * Replace any Vars in the query's targetlist and havingQual that
6006 * reference GROUP outputs with the underlying grouping expressions.
6007 *
6008 * We can safely pass NULL for the root here. Preserving varnullingrels
6009 * makes no difference to the deparsed source text.
6010 */
6011 if (query->hasGroupRTE)
6012 {
6015 query->havingQual =
6017 }
6018
6019 /*
6020 * Before we begin to examine the query, acquire locks on referenced
6021 * relations, and fix up deleted columns in JOIN RTEs. This ensures
6022 * consistent results. Note we assume it's OK to scribble on the passed
6023 * querytree!
6024 *
6025 * We are only deparsing the query (we are not about to execute it), so we
6026 * only need AccessShareLock on the relations it mentions.
6027 */
6029
6036 rtable_size != 1);
6037 context.prettyFlags = prettyFlags;
6038 context.wrapColumn = wrapColumn;
6040 context.colNamesVisible = colNamesVisible;
6044
6046
6048 {
6050 /* We set context.resultDesc only if it's a SELECT */
6051 context.resultDesc = resultDesc;
6052 get_select_query_def(query, &context);
6053 break;
6054
6056 get_update_query_def(query, &context);
6057 break;
6058
6060 get_insert_query_def(query, &context);
6061 break;
6062
6064 get_delete_query_def(query, &context);
6065 break;
6066
6068 get_merge_query_def(query, &context);
6069 break;
6070
6073 break;
6074
6076 get_utility_query_def(query, &context);
6077 break;
6078
6079 default:
6081 query->commandType);
6082 break;
6083 }
6084}
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_json_constructor(), 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 14458 of file ruleutils.c.
14459{
14460 deparse_context context;
14462 ListCell *cell;
14464
14468
14472 {
14473 PartitionRangeDatum *datum =
14475
14481 else
14482 {
14484
14486 }
14488 }
14490
14492}
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 13921 of file ruleutils.c.
13922{
13924
13928}
References elog, ERROR, get_rel_name(), and relname.
Referenced by get_rte_alias(), make_propgraphdef_properties(), 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()
| void get_reloptions | ( | StringInfo | buf, |
| Datum | reloptions | ||
| ) |
Definition at line 14370 of file ruleutils.c.
14371{
14375
14378
14380 {
14385
14386 /*
14387 * Each array element should have the form name=value. If the "=" is
14388 * missing for some reason, treat it like an empty value.
14389 */
14393 {
14396 }
14397 else
14399
14403
14404 /*
14405 * In general we need to quote the value; but to avoid unnecessary
14406 * clutter, do not quote if it is an identifier that would not need
14407 * quoting. (We could also allow numbers, but that is a bit trickier
14408 * than it looks --- for example, are leading zeroes significant? We
14409 * don't want to assume very much here about what custom reloptions
14410 * might mean.)
14411 */
14414 else
14416
14418 }
14419}
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(), pg_get_indexdef_worker(), and pg_get_tablespace_ddl_internal().
◆ get_returning_clause()
|
static |
Definition at line 6743 of file ruleutils.c.
6744{
6746
6748 {
6750
6753
6754 /* Add WITH (OLD/NEW) options, if they're not the defaults */
6756 {
6758 quote_identifier(query->returningOldAlias));
6760 }
6762 {
6765 quote_identifier(query->returningNewAlias));
6766 else
6767 {
6769 quote_identifier(query->returningNewAlias));
6771 }
6772 }
6775
6776 /* Add the returning expressions themselves */
6778 }
6779}
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 5497 of file ruleutils.c.
5498{
5500
5503}
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 13410 of file ruleutils.c.
13412{
13417
13419 {
13420 /* Always print alias if user provided one */
13422 }
13424 {
13425 /* Always print alias if we need to print column aliases */
13427 }
13429 {
13430 /*
13431 * No need to print alias if it's same as relation name (this would
13432 * normally be the case, but not if set_rtable_names had to resolve a
13433 * conflict).
13434 */
13437 }
13439 {
13440 /*
13441 * For a function RTE, always print alias. This covers possible
13442 * renaming of the function and/or instability of the FigureColname
13443 * rules for things that aren't simple functions. Note we'd need to
13444 * force it anyway for the columndef list case.
13445 */
13447 }
13450 {
13451 /*
13452 * For a subquery, always print alias. This makes the output
13453 * SQL-spec-compliant, even though we allow such aliases to be omitted
13454 * on input.
13455 */
13457 }
13459 {
13460 /*
13461 * No need to print alias if it's same as CTE name (this would
13462 * normally be the case, but not if set_rtable_names had to resolve a
13463 * conflict).
13464 */
13467 }
13468
13472 quote_identifier(refname));
13473}
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 9817 of file ruleutils.c.
9819{
9821
9823 return;
9824
9825 /* Guard against excessively long or deeply-nested queries */
9826 CHECK_FOR_INTERRUPTS();
9827 check_stack_depth();
9828
9829 /*
9830 * Each level of get_rule_expr must emit an indivisible term
9831 * (parenthesized if necessary) to ensure result is reparsed into the same
9832 * expression tree. The only exception is that when the input is a List,
9833 * we emit the component items comma-separated with no surrounding
9834 * decoration; this is convenient for most callers.
9835 */
9837 {
9840 break;
9841
9844 break;
9845
9848 break;
9849
9852 break;
9853
9855 {
9857
9861 }
9862 break;
9863
9866 break;
9867
9870 break;
9871
9873 {
9876
9877 /*
9878 * If the argument is a CaseTestExpr, we must be inside a
9879 * FieldStore, ie, we are assigning to an element of an array
9880 * within a composite column. Since we already punted on
9881 * displaying the FieldStore's target information, just punt
9882 * here too, and display only the assignment source
9883 * expression.
9884 */
9886 {
9889 context, showimplicit);
9890 break;
9891 }
9892
9893 /*
9894 * Parenthesize the argument unless it's a simple Var or a
9895 * FieldSelect. (In particular, if it's another
9896 * SubscriptingRef, we *must* parenthesize to avoid
9897 * confusion.)
9898 */
9906
9907 /*
9908 * If there's a refassgnexpr, we want to print the node in the
9909 * format "container[subscripts] := refassgnexpr". This is
9910 * not legal SQL, so decompilation of INSERT or UPDATE
9911 * statements should always use processIndirection as part of
9912 * the statement-level syntax. We should only see this when
9913 * EXPLAIN tries to print the targetlist of a plan resulting
9914 * from such a statement.
9915 */
9917 {
9918 Node *refassgnexpr;
9919
9920 /*
9921 * Use processIndirection to print this node's subscripts
9922 * as well as any additional field selections or
9923 * subscripting in immediate descendants. It returns the
9924 * RHS expr that is actually being "assigned".
9925 */
9926 refassgnexpr = processIndirection(node, context);
9929 }
9930 else
9931 {
9932 /* Just an ordinary container fetch, so print subscripts */
9933 printSubscripts(sbsref, context);
9934 }
9935 }
9936 break;
9937
9940 break;
9941
9943 {
9945
9948 }
9949 break;
9950
9953 break;
9954
9956 {
9961
9969 }
9970 break;
9971
9973 {
9975
9979 }
9980 break;
9981
9983 {
9988
9998
9999 /*
10000 * There's inherent ambiguity in "x op ANY/ALL (y)" when y is
10001 * a bare sub-SELECT. Since we're here, the sub-SELECT must
10002 * be meant as a scalar sub-SELECT yielding an array value to
10003 * be used in ScalarArrayOpExpr; but the grammar will
10004 * preferentially interpret such a construct as an ANY/ALL
10005 * SubLink. To prevent misparsing the output that way, insert
10006 * a dummy coercion (which will be stripped by parse analysis,
10007 * so no inefficiency is added in dump and reload). This is
10008 * indeed most likely what the user wrote to get the construct
10009 * accepted in the first place.
10010 */
10019 }
10020 break;
10021
10023 {
10027
10029 {
10034 false, node);
10036 {
10039 false, node);
10040 }
10043 break;
10044
10049 false, node);
10051 {
10054 false, node);
10055 }
10058 break;
10059
10065 false, node);
10068 break;
10069
10070 default:
10073 }
10074 }
10075 break;
10076
10079 break;
10080
10082 {
10084
10085 /*
10086 * We cannot see an already-planned subplan in rule deparsing,
10087 * only while EXPLAINing a query plan. We don't try to
10088 * reconstruct the original SQL, just reference the subplan
10089 * that appears elsewhere in EXPLAIN's result. It does seem
10090 * useful to show the subLinkType and testexpr (if any), and
10091 * we also note whether the subplan will be hashed.
10092 */
10094 {
10098 break;
10102 break;
10106 break;
10108 /* Parenthesizing the testexpr seems sufficient */
10111 break;
10113 /* No need to decorate these subplan references */
10116 break;
10118 /* MULTIEXPR isn't executed in the normal way */
10121 break;
10125 break;
10127 /* This case is unreachable within expressions */
10130 break;
10131 }
10132
10134 {
10136
10137 /*
10138 * Push SubPlan into ancestors list while deparsing
10139 * testexpr, so that we can handle PARAM_EXEC references
10140 * to the SubPlan's paramIds. (This makes it look like
10141 * the SubPlan is an "ancestor" of the current plan node,
10142 * which is a little weird, but it does no harm.) In this
10143 * path, we don't need to mention the SubPlan explicitly,
10144 * because the referencing Params will show its existence.
10145 */
10148
10151
10153 }
10154 else
10155 {
10157
10158 /* No referencing Params, so show the SubPlan's name */
10161 else
10166 else
10169 }
10170 }
10171 break;
10172
10174 {
10177
10178 /*
10179 * This case cannot be reached in normal usage, since no
10180 * AlternativeSubPlan can appear either in parsetrees or
10181 * finished plan trees. We keep it just in case somebody
10182 * wants to use this code to print planner data structures.
10183 */
10186 {
10189
10192 else
10196 splan->plan_name);
10197 else
10199 splan->plan_name);
10202 }
10204 }
10205 break;
10206
10208 {
10212 const char *fieldname;
10214
10215 /*
10216 * Parenthesize the argument unless it's a SubscriptingRef or
10217 * another FieldSelect. Note in particular that it would be
10218 * WRONG to not parenthesize a Var argument; simplicity is not
10219 * the issue here, having the right number of names is.
10220 */
10228
10229 /*
10230 * Get and print the field name.
10231 */
10233 0, context);
10235 }
10236 break;
10237
10239 {
10242
10243 /*
10244 * There is no good way to represent a FieldStore as real SQL,
10245 * so decompilation of INSERT or UPDATE statements should
10246 * always use processIndirection as part of the
10247 * statement-level syntax. We should only get here when
10248 * EXPLAIN tries to print the targetlist of a plan resulting
10249 * from such a statement. The plan case is even harder than
10250 * ordinary rules would be, because the planner tries to
10251 * collapse multiple assignments to the same field or subfield
10252 * into one FieldStore; so we can see a list of target fields
10253 * not just one, and the arguments could be FieldStores
10254 * themselves. We don't bother to try to print the target
10255 * field names; we just print the source arguments, with a
10256 * ROW() around them if there's more than one. This isn't
10257 * terribly complete, but it's probably good enough for
10258 * EXPLAIN's purposes; especially since anything more would be
10259 * either hopelessly confusing or an even poorer
10260 * representation of what the plan is actually doing.
10261 */
10268 }
10269 break;
10270
10272 {
10275
10277 !showimplicit)
10278 {
10279 /* don't show the implicit cast */
10281 }
10282 else
10283 {
10285 relabel->resulttype,
10286 relabel->resulttypmod,
10287 node);
10288 }
10289 }
10290 break;
10291
10293 {
10296
10298 !showimplicit)
10299 {
10300 /* don't show the implicit cast */
10302 }
10303 else
10304 {
10306 iocoerce->resulttype,
10307 -1,
10308 node);
10309 }
10310 }
10311 break;
10312
10314 {
10317
10319 !showimplicit)
10320 {
10321 /* don't show the implicit cast */
10323 }
10324 else
10325 {
10327 acoerce->resulttype,
10328 acoerce->resulttypmod,
10329 node);
10330 }
10331 }
10332 break;
10333
10335 {
10338
10340 !showimplicit)
10341 {
10342 /* don't show the implicit cast */
10344 }
10345 else
10346 {
10348 convert->resulttype, -1,
10349 node);
10350 }
10351 }
10352 break;
10353
10355 {
10358
10363 generate_collation_name(collate->collOid));
10366 }
10367 break;
10368
10370 {
10373
10375 0, PRETTYINDENT_VAR, 0);
10377 {
10380 }
10382 {
10385
10387 {
10388 /*
10389 * The parser should have produced WHEN clauses of the
10390 * form "CaseTestExpr = RHS", possibly with an
10391 * implicit coercion inserted above the CaseTestExpr.
10392 * For accurate decompilation of rules it's essential
10393 * that we show just the RHS. However in an
10394 * expression that's been through the optimizer, the
10395 * WHEN clause could be almost anything (since the
10396 * equality operator could have been expanded into an
10397 * inline function). If we don't recognize the form
10398 * of the WHEN clause, just punt and display it as-is.
10399 */
10401 {
10403
10406 CaseTestExpr))
10408 }
10409 }
10410
10414 0, 0, 0);
10418 }
10422 0, 0, 0);
10427 -PRETTYINDENT_VAR, 0, 0);
10428 }
10429 break;
10430
10432 {
10433 /*
10434 * Normally we should never get here, since for expressions
10435 * that can contain this node type we attempt to avoid
10436 * recursing to it. But in an optimized expression we might
10437 * be unable to avoid that (see comments for CaseExpr). If we
10438 * do see one, print it as CASE_TEST_EXPR.
10439 */
10441 }
10442 break;
10443
10445 {
10447
10451
10452 /*
10453 * If the array isn't empty, we assume its elements are
10454 * coerced to the desired type. If it's empty, though, we
10455 * need an explicit coercion to the array type.
10456 */
10459 format_type_with_typemod(arrayexpr->array_typeid, -1));
10460 }
10461 break;
10462
10464 {
10470
10471 /*
10472 * If it's a named type and not RECORD, we may have to skip
10473 * dropped columns and/or claim there are NULLs for added
10474 * columns.
10475 */
10477 {
10478 tupdesc = lookup_rowtype_tupdesc(rowexpr->row_typeid, -1);
10480 }
10481
10482 /*
10483 * SQL99 allows "ROW" to be omitted when there is more than
10484 * one column, but for simplicity we always print it.
10485 */
10488 i = 0;
10490 {
10492
10495 {
10497 /* Whole-row Vars need special treatment here */
10500 }
10501 i++;
10502 }
10504 {
10506 {
10508 {
10512 }
10513 i++;
10514 }
10515
10516 ReleaseTupleDesc(tupdesc);
10517 }
10521 format_type_with_typemod(rowexpr->row_typeid, -1));
10522 }
10523 break;
10524
10526 {
10528
10529 /*
10530 * SQL99 allows "ROW" to be omitted when there is more than
10531 * one column, but for simplicity we always print it. Within
10532 * a ROW expression, whole-row Vars need special treatment, so
10533 * use get_rule_list_toplevel.
10534 */
10537
10538 /*
10539 * We assume that the name of the first-column operator will
10540 * do for all the rest too. This is definitely open to
10541 * failure, eg if some but not all operators were renamed
10542 * since the construct was parsed, but there seems no way to
10543 * be perfect.
10544 */
10551 }
10552 break;
10553
10555 {
10557
10561 }
10562 break;
10563
10565 {
10567
10569 {
10572 break;
10575 break;
10576 }
10579 }
10580 break;
10581
10583 {
10585
10586 /*
10587 * Note: this code knows that typmod for time, timestamp, and
10588 * timestamptz just prints as integer.
10589 */
10591 {
10594 break;
10597 break;
10600 break;
10603 break;
10606 svf->typmod);
10607 break;
10610 break;
10613 break;
10616 break;
10619 svf->typmod);
10620 break;
10623 break;
10626 break;
10629 break;
10632 break;
10635 break;
10638 break;
10639 }
10640 }
10641 break;
10642
10644 {
10649 Const *con;
10650
10652 {
10655 break;
10658 break;
10661 break;
10664 break;
10667 break;
10670 break;
10673 break;
10675 break;
10676 }
10678 {
10681 else
10683 }
10684 if (xexpr->name)
10685 {
10689 }
10691 {
10693 {
10698 }
10700 {
10703
10710 }
10713 }
10715 {
10719 {
10725 /* no extra decoration needed */
10727 break;
10730
10732 context, true);
10733
10735 Assert(!con->constisnull);
10738 " PRESERVE WHITESPACE");
10739 else
10741 " STRIP WHITESPACE");
10742 break;
10745
10747 context, true);
10748
10752 con->constisnull)
10754 else
10756
10758 if (con->constisnull)
10759 /* suppress STANDALONE NO VALUE */ ;
10760 else
10761 {
10763 {
10766 ", STANDALONE YES");
10767 break;
10770 ", STANDALONE NO");
10771 break;
10774 ", STANDALONE NO VALUE");
10775 break;
10776 default:
10777 break;
10778 }
10779 }
10780 break;
10783 break;
10784 }
10785 }
10787 {
10789 format_type_with_typemod(xexpr->type,
10790 xexpr->typmod));
10793 else
10795 }
10796
10799 else
10801 }
10802 break;
10803
10805 {
10807
10811
10812 /*
10813 * For scalar inputs, we prefer to print as IS [NOT] NULL,
10814 * which is shorter and traditional. If it's a rowtype input
10815 * but we're applying a scalar test, must print IS [NOT]
10816 * DISTINCT FROM NULL to be semantically correct.
10817 */
10820 {
10822 {
10825 break;
10828 break;
10829 default:
10832 }
10833 }
10834 else
10835 {
10837 {
10840 break;
10843 break;
10844 default:
10847 }
10848 }
10851 }
10852 break;
10853
10855 {
10857
10862 {
10865 break;
10868 break;
10871 break;
10874 break;
10877 break;
10880 break;
10881 default:
10884 }
10887 }
10888 break;
10889
10891 {
10894
10896 !showimplicit)
10897 {
10898 /* don't show the implicit cast */
10900 }
10901 else
10902 {
10904 ctest->resulttype,
10905 ctest->resulttypmod,
10906 node);
10907 }
10908 }
10909 break;
10910
10913 break;
10914
10917 break;
10918
10920 {
10922
10926 else
10928 cexpr->cursor_param);
10929 }
10930 break;
10931
10933 {
10935
10936 /*
10937 * This isn't exactly nextval(), but that seems close enough
10938 * for EXPLAIN's purposes.
10939 */
10943 NIL));
10945 }
10946 break;
10947
10949 {
10953
10954 /*
10955 * InferenceElem can only refer to target relation, so a
10956 * prefix is not useful, and indeed would cause parse errors.
10957 */
10960
10961 /*
10962 * Parenthesize the element unless it's a simple Var or a bare
10963 * function call. Follows pg_get_indexdef_worker().
10964 */
10968 COERCE_EXPLICIT_CALL)
10970
10974 context, false);
10977
10979
10983
10984 /* Add the operator class name, if not default */
10986 {
10989
10991 }
10992 }
10993 break;
10994
10996 {
10998
10999 /*
11000 * We cannot see a ReturningExpr in rule deparsing, only while
11001 * EXPLAINing a query plan (ReturningExpr nodes are only ever
11002 * adding during query rewriting). Just display the expression
11003 * returned (an expanded view column).
11004 */
11006 }
11007 break;
11008
11010 {
11012 ListCell *cell;
11014
11016 {
11018 break;
11019 }
11020
11022 {
11026
11030 break;
11031
11034
11038 {
11040
11044 }
11045
11047 break;
11048
11054
11058 break;
11059
11060 default:
11063 break;
11064 }
11065 }
11066 break;
11067
11069 {
11071
11074 }
11075 break;
11076
11079 break;
11080
11082 {
11084
11087
11089
11091
11092 /* TODO: handle FORMAT clause */
11093
11095 {
11098 break;
11101 break;
11104 break;
11105 default:
11106 break;
11107 }
11108
11111
11114 }
11115 break;
11116
11118 {
11120
11122 {
11125 break;
11128 break;
11131 break;
11132 default:
11135 }
11136
11138
11140
11142
11144 {
11146 *lc2;
11148
11150
11153 {
11157
11161 }
11162 }
11163
11168
11171 JSON_BEHAVIOR_NULL :
11172 JSON_BEHAVIOR_FALSE);
11173
11175 }
11176 break;
11177
11179 {
11181 ListCell *l;
11182
11185 {
11189 }
11190 }
11191 break;
11192
11195 break;
11196
11198 {
11200
11201 appendStringInfo(buf, "%s.%s", quote_identifier(gpr->elvarname), quote_identifier(get_propgraph_property_name(gpr->propid)));
11202 break;
11203 }
11204
11205 default:
11207 break;
11208 }
11209}
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_propgraph_property_name(), 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_for_portion_of(), get_from_clause_item(), get_func_expr(), get_func_sql_syntax(), get_graph_pattern_def(), get_insert_query_def(), get_json_behavior(), get_json_constructor(), get_json_path_spec(), get_json_table(), get_merge_query_def(), get_parameter(), get_path_pattern_expr_def(), 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 11271 of file ruleutils.c.
11273{
11276 else
11277 {
11279
11281 /* no point in showing any top-level implicit cast */
11285 exprTypmod(node)));
11286 }
11287}
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 9720 of file ruleutils.c.
9722{
9724
9727
9730
9732
9735}
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 11223 of file ruleutils.c.
11225{
11228 else
11230}
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 6999 of file ruleutils.c.
7001{
7002 ListCell *l;
7006
7008 {
7011 return;
7012
7014 {
7017
7019 {
7021
7024 false, context);
7026 }
7027
7030 }
7031 return;
7032
7035 break;
7038 break;
7042 break;
7043 }
7044
7046 {
7050 }
7051
7053}
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 11241 of file ruleutils.c.
11243{
11246
11249 {
11251
11255 }
11256}
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 7059 of file ruleutils.c.
7061{
7064 ListCell *l;
7065
7068 {
7072 TypeCacheEntry *typentry;
7073
7076 force_colno, context);
7078 /* See whether operator is default < or > for datatype */
7082 {
7083 /* ASC is default, so emit nothing for it */
7086 }
7088 {
7090 /* DESC defaults to NULLS FIRST */
7093 }
7094 else
7095 {
7098 sortcoltype,
7099 sortcoltype));
7100 /* be specific to eliminate ambiguity */
7103 else
7105 }
7107 }
7108}
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 6930 of file ruleutils.c.
6932{
6935 Node *expr;
6936
6939
6940 /*
6941 * Use column-number form if requested by caller. Otherwise, if
6942 * expression is a constant, force it to be dumped with an explicit cast
6943 * as decoration --- this is because a simple integer constant is
6944 * ambiguous (and will be misinterpreted by findTargetlistEntrySQL92()) if
6945 * we dump it without any decoration. Similarly, if it's just a Var,
6946 * there is risk of misinterpretation if the column name is reassigned in
6947 * the SELECT list, so we may need to force table qualification. And, if
6948 * it's anything more complex than a simple Var, then force extra parens
6949 * around it, to ensure it can't be misinterpreted as a cube() or rollup()
6950 * construct.
6951 */
6953 {
6956 }
6957 else if (!expr)
6958 /* do nothing, probably can't happen */ ;
6962 {
6963 /* Tell get_variable to check for name conflict */
6965
6969 }
6970 else
6971 {
6972 /*
6973 * We must force parens for function-like expressions even if
6974 * PRETTY_PAREN is off, since those are the ones in danger of
6975 * misparsing. For other expressions we need to force them only if
6976 * PRETTY_PAREN is on, since otherwise the expression will output them
6977 * itself. (We can't skip the parens.)
6978 */
6984
6990 }
6991
6992 return expr;
6993}
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 7117 of file ruleutils.c.
7118{
7121 ListCell *l;
7122
7125 {
7127
7129 continue; /* ignore anonymous windows */
7130
7134 else
7136
7138
7140
7142 }
7143}
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 7149 of file ruleutils.c.
7151{
7155 ListCell *l;
7156
7158 if (wc->refname)
7159 {
7162 }
7163 /* partition clauses are always inherited, so only print if no refname */
7165 {
7171 {
7173
7176 false, context);
7178 }
7180 }
7181 /* print ordering clause only if not inherited */
7183 {
7189 }
7190 /* framing clause is never inherited, so print unless it's default */
7192 {
7197 context);
7198 }
7200}
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 6273 of file ruleutils.c.
6274{
6277 ListCell *l;
6278
6279 /* Insert the WITH clause if given */
6280 get_with_clause(query, context);
6281
6282 /* Subroutines may need to consult the SELECT targetlist and windowClause */
6285
6286 /*
6287 * If the Query node has a setOperations tree, then it's the top level of
6288 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
6289 * fields are interesting in the top query itself.
6290 */
6292 {
6294 /* ORDER BY clauses must be simple in this case */
6296 }
6297 else
6298 {
6299 get_basic_select_query(query, context);
6301 }
6302
6303 /* Add the ORDER BY clause if given */
6305 {
6309 force_colno, context);
6310 }
6311
6312 /*
6313 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
6314 * standard spelling of LIMIT.
6315 */
6317 {
6321 }
6323 {
6325 {
6326 /*
6327 * The limitCount arg is a c_expr, so it needs parens. Simple
6328 * literals and function expressions would not need parens, but
6329 * unfortunately it's hard to tell if the expression will be
6330 * printed as a simple literal like 123 or as a typecast
6331 * expression, like '-123'::int4. The grammar accepts the former
6332 * without quoting, but not the latter.
6333 */
6340 }
6341 else
6342 {
6348 else
6350 }
6351 }
6352
6353 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
6354 if (query->hasForUpdate)
6355 {
6357 {
6359
6360 /* don't print implicit clauses */
6362 continue;
6363
6364 appendContextKeyword(context,
6367
6370 context)));
6375 }
6376 }
6377}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, fb(), get_basic_select_query(), get_lock_clause_strength(), get_rtable_name(), get_rule_expr(), get_rule_orderby(), get_setop_query(), get_with_clause(), IsA, lfirst, LIMIT_OPTION_WITH_TIES, Query::limitCount, Query::limitOffset, Query::limitOption, LockWaitError, LockWaitSkip, NIL, PRETTYINDENT_STD, RowMarkClause::pushedDown, quote_identifier(), Query::rowMarks, RowMarkClause::rti, Query::setOperations, Query::sortClause, RowMarkClause::strength, deparse_context::targetList, Query::targetList, RowMarkClause::waitPolicy, deparse_context::windowClause, and Query::windowClause.
Referenced by get_query_def().
◆ get_setop_query()
|
static |
Definition at line 6782 of file ruleutils.c.
6783{
6786
6787 /* Guard against excessively long or deeply-nested queries */
6788 CHECK_FOR_INTERRUPTS();
6789 check_stack_depth();
6790
6792 {
6796
6798
6799 /*
6800 * We need parens if WITH, ORDER BY, FOR UPDATE, or LIMIT; see gram.y.
6801 * Also add parens if the leaf query contains its own set operations.
6802 * (That shouldn't happen unless one of the other clauses is also
6803 * present, see transformSetOperationTree; but let's be safe.)
6804 */
6806 subquery->sortClause ||
6807 subquery->rowMarks ||
6808 subquery->limitOffset ||
6809 subquery->limitCount ||
6810 subquery->setOperations);
6816 context->indentLevel);
6819 }
6821 {
6825
6826 /*
6827 * We force parens when nesting two SetOperationStmts, except when the
6828 * lefthand input is another setop of the same kind. Syntactically,
6829 * we could omit parens in rather more cases, but it seems best to use
6830 * parens to flag cases where the setop operator changes. If we use
6831 * parens, we also increase the indentation level for the child query.
6832 *
6833 * There are some cases in which parens are needed around a leaf query
6834 * too, but those are more easily handled at the next level down (see
6835 * code above).
6836 */
6838 {
6840
6843 else
6845 }
6846 else
6848
6850 {
6854 }
6855 else
6856 subindent = 0;
6857
6859
6864 else
6866
6868 {
6871 break;
6874 break;
6877 break;
6878 default:
6881 }
6884
6885 /* Always parenthesize if RHS is another setop */
6887
6888 /*
6889 * The indentation code here is deliberately a bit different from that
6890 * for the lefthand input, because we want the line breaks in
6891 * different places.
6892 */
6894 {
6897 }
6898 else
6899 subindent = 0;
6901
6902 /*
6903 * The output column names of the RHS sub-select don't matter.
6904 */
6907
6909
6911
6916 }
6917 else
6918 {
6921 }
6922}
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 9389 of file ruleutils.c.
9390{
9392
9394 {
9395 /* binary operator */
9398 const char *op;
9399
9402 return op;
9403 }
9405}
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 6407 of file ruleutils.c.
6408{
6411
6412 /*
6413 * We want to detect a match even if the Query also contains OLD or NEW
6414 * rule RTEs. So the idea is to scan the rtable and see if there is only
6415 * one inFromCl RTE that is a VALUES RTE.
6416 */
6418 {
6420
6422 {
6426 }
6428 continue; /* ignore rule entries */
6429 else
6431 }
6432
6433 /*
6434 * We don't need to check the targetlist in any great detail, because
6435 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6436 * appear inside auto-generated sub-queries with very restricted
6437 * structure. However, DefineView might have modified the tlist by
6438 * injecting new column aliases, or we might have some other column
6439 * aliases forced by a resultDesc. We can only simplify if the RTE's
6440 * column names match the names that get_target_list() would select.
6441 */
6443 {
6445 int colno;
6446
6449 colno = 0;
6451 {
6454 char *colname;
6455
6458
6459 /* compute name that get_target_list would use for column */
6460 colno++;
6463 else
6464 colname = tle->resname;
6465
6466 /* does it match the VALUES RTE? */
6469 }
6470 }
6471
6473}
References attname, fb(), forboth, lfirst, list_length(), NameStr, result, Query::rtable, RTE_RELATION, RTE_VALUES, strVal, Query::targetList, and TupleDescAttr().
Referenced by get_basic_select_query().
◆ get_special_variable()
|
static |
Definition at line 8444 of file ruleutils.c.
8445{
8447
8448 /*
8449 * For a non-Var referent, force parentheses because our caller probably
8450 * assumed a Var is a simple expression.
8451 */
8457}
References appendStringInfoChar(), deparse_context::buf, buf, get_rule_expr(), and IsA.
Referenced by get_variable().
◆ get_sublink_expr()
|
static |
Definition at line 12456 of file ruleutils.c.
12457{
12462
12465 else
12467
12468 /*
12469 * Note that we print the name of only the first operator, when there are
12470 * multiple combining operators. This is an approximation that could go
12471 * wrong in various scenarios (operators in different schemas, renamed
12472 * operators, etc) but there is not a whole lot we can do about it, since
12473 * the syntax allows only one operator to be shown.
12474 */
12476 {
12478 {
12479 /* single combining operator */
12481
12486 }
12488 {
12489 /* multiple combining operators, = or <> cases */
12491 ListCell *l;
12492
12496 {
12498
12506 }
12508 }
12510 {
12511 /* multiple combining operators, < <= > >= cases */
12513
12520 }
12521 else
12524 }
12525
12527
12529 {
12532 break;
12533
12537 else
12539 break;
12540
12543 break;
12544
12547 break;
12548
12553 break;
12554
12556 default:
12559 break;
12560 }
12561
12564
12567 context->indentLevel);
12568
12571 else
12573}
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 12983 of file ruleutils.c.
12984{
12985 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12986
12991}
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 13605 of file ruleutils.c.
13606{
13608 Oid argtypes[1];
13609 int nargs;
13610 ListCell *l;
13611
13612 /*
13613 * We should qualify the handler's function name if it wouldn't be
13614 * resolved by lookup in the current search path.
13615 */
13616 argtypes[0] = INTERNALOID;
13619 NIL, argtypes,
13621
13622 nargs = 0;
13624 {
13625 if (nargs++ > 0)
13628 }
13630
13632 {
13636 }
13637}
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 6607 of file ruleutils.c.
6608{
6613 int colno;
6614 ListCell *l;
6615
6616 /* we use targetbuf to hold each TLE's text temporarily */
6618
6620 colno = 0;
6621 foreach(l, targetList)
6622 {
6624 char *colname;
6626
6628 continue; /* ignore junk entries */
6629
6632 colno++;
6633
6634 /*
6635 * Put the new field text into targetbuf so we can decide after we've
6636 * got it whether or not it needs to go on a new line.
6637 */
6640
6641 /*
6642 * We special-case Var nodes rather than using get_rule_expr. This is
6643 * needed because get_rule_expr will display a whole-row Var as
6644 * "foo.*", which is the preferred notation in most contexts, but at
6645 * the top level of a SELECT list it's not right (the parser will
6646 * expand that notation into multiple columns, yielding behavior
6647 * different from a whole-row Var). We need to call get_variable
6648 * directly so that we can tell it to do the right thing, and so that
6649 * we can get the attribute name which is the default AS label.
6650 */
6652 {
6654 }
6655 else
6656 {
6658
6659 /*
6660 * When colNamesVisible is true, we should always show the
6661 * assigned column name explicitly. Otherwise, show it only if
6662 * it's not FigureColname's fallback.
6663 */
6665 }
6666
6667 /*
6668 * Figure out what the result column should be called. In the context
6669 * of a view, use the view's tuple descriptor (so as to pick up the
6670 * effects of any column RENAME that's been done on the view).
6671 * Otherwise, just use what we can find in the TLE.
6672 */
6675 colno - 1)->attname);
6676 else
6677 colname = tle->resname;
6678
6679 /* Show AS unless the column's name is correct as-is */
6680 if (colname) /* resname could be NULL */
6681 {
6684 }
6685
6686 /* Restore context's output buffer */
6688
6689 /* Consider line-wrapping if enabled */
6691 {
6693
6694 /* Does the new field start with a new line? */
6696 leading_nl_pos = 0;
6697 else
6698 leading_nl_pos = -1;
6699
6700 /* If so, we shouldn't add anything */
6702 {
6703 /* instead, remove any trailing spaces currently in buf */
6705 }
6706 else
6707 {
6709
6710 /* Locate the start of the current line in the output buffer */
6714 else
6715 trailing_nl++;
6716
6717 /*
6718 * Add a newline, plus some indentation, if the new field is
6719 * not the first and either the new field would cause an
6720 * overflow or the last field used more than one line.
6721 */
6722 if (colno > 1 &&
6724 last_was_multiline))
6727 }
6728
6729 /* Remember this field's multiline status for next iteration */
6730 last_was_multiline =
6732 }
6733
6734 /* Add the new field */
6736 }
6737
6738 /* clean up */
6740}
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 7536 of file ruleutils.c.
7537{
7540
7541 /* Insert the WITH clause if given */
7542 get_with_clause(query, context);
7543
7544 /*
7545 * Start the query with UPDATE relname SET
7546 */
7550 {
7553 }
7557
7558 /* Print the FOR PORTION OF, if needed */
7560
7561 /* Print the relation alias, if needed */
7563
7565
7566 /* Deparse targetlist */
7568
7569 /* Add the FROM clause if needed */
7571
7572 /* Add a WHERE clause if given */
7574 {
7578 }
7579
7580 /* Add RETURNING if present */
7582 get_returning_clause(query, context);
7583}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, deparse_context::buf, buf, fb(), Query::forPortionOf, generate_relation_name(), get_for_portion_of(), 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 7591 of file ruleutils.c.
7593{
7595 ListCell *l;
7601
7602 /*
7603 * Prepare to deal with MULTIEXPR assignments: collect the source SubLinks
7604 * into a list. We expect them to appear, in ID order, in resjunk tlist
7605 * entries.
7606 */
7608 if (query->hasSubLinks) /* else there can't be any */
7609 {
7610 foreach(l, targetList)
7611 {
7613
7615 {
7617
7619 {
7622 }
7623 }
7624 }
7625 }
7628 remaining_ma_columns = 0;
7629
7630 /* Add the comma separated list of 'attname = value' */
7632 foreach(l, targetList)
7633 {
7635 Node *expr;
7636
7638 continue; /* ignore junk entries */
7639
7640 /* Emit separator (OK whether we're in multiassignment or not) */
7643
7644 /*
7645 * Check to see if we're starting a multiassignment group: if so,
7646 * output a left paren.
7647 */
7649 {
7650 /*
7651 * We must dig down into the expr to see if it's a PARAM_MULTIEXPR
7652 * Param. That could be buried under FieldStores and
7653 * SubscriptingRefs and CoerceToDomains (cf processIndirection()),
7654 * and underneath those there could be an implicit type coercion.
7655 * Because we would ignore implicit type coercions anyway, we
7656 * don't need to be as careful as processIndirection() is about
7657 * descending past implicit CoerceToDomains.
7658 */
7660 while (expr)
7661 {
7663 {
7665
7667 }
7669 {
7671
7673 break;
7674
7676 }
7678 {
7680
7682 break;
7684 }
7685 else
7686 break;
7687 }
7688 expr = strip_implicit_coercions(expr);
7689
7692 {
7695 remaining_ma_columns = count_nonjunk_tlist_entries(((Query *) cur_ma_sublink->subselect)->targetList);
7697 ((cur_ma_sublink->subLinkId << 16) | 1));
7699 }
7700 }
7701
7702 /*
7703 * Put out name of target column; look in the catalogs, not at
7704 * tle->resname, since resname will fail to track RENAME.
7705 */
7708 tle->resno,
7709 false)));
7710
7711 /*
7712 * Print any indirection needed (subfields or subscripts), and strip
7713 * off the top-level nodes representing the indirection assignments.
7714 */
7716
7717 /*
7718 * If we're in a multiassignment, skip printing anything more, unless
7719 * this is the last column; in which case, what we print should be the
7720 * sublink, not the Param.
7721 */
7723 {
7725 continue; /* not the last column of multiassignment */
7729 }
7730
7732
7734 }
7735}
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 7952 of file ruleutils.c.
7953{
7955
7957 {
7959
7961 0, PRETTYINDENT_STD, 1);
7965 {
7968 }
7969 }
7970 else
7971 {
7972 /* Currently only NOTIFY utility commands can appear in rules */
7974 }
7975}
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 6091 of file ruleutils.c.
6092{
6096
6098
6100 {
6104
6107 else
6109
6112 {
6114
6117 else
6119
6120 /*
6121 * Print the value. Whole-row Vars need special treatment.
6122 */
6124 }
6126 }
6127}
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 8162 of file ruleutils.c.
8163{
8169 int varno;
8170 AttrNumber varattno;
8172 char *refname;
8175
8176 /* Find appropriate nesting depth */
8180 var->varlevelsup, levelsup);
8182 netlevelsup);
8183
8184 /*
8185 * If we have a syntactic referent for the Var, and we're working from a
8186 * parse tree, prefer to use the syntactic referent. Otherwise, fall back
8187 * on the semantic referent. (Forcing use of the semantic referent when
8188 * printing plan trees is a design choice that's perhaps more motivated by
8189 * backwards compatibility than anything else. But it does have the
8190 * advantage of making plans more explicit.)
8191 */
8193 {
8194 varno = var->varnosyn;
8195 varattno = var->varattnosyn;
8196 }
8197 else
8198 {
8199 varno = var->varno;
8200 varattno = var->varattno;
8201 }
8202
8203 /*
8204 * Try to find the relevant RTE in this rtable. In a plan tree, it's
8205 * likely that varno is OUTER_VAR or INNER_VAR, in which case we must dig
8206 * down into the subplans, or INDEX_VAR, which is resolved similarly. Also
8207 * find the aliases previously assigned for this RTE.
8208 */
8210 {
8211 /*
8212 * We might have been asked to map child Vars to some parent relation.
8213 */
8215 {
8219 bool found = false;
8220
8221 /* Only map up to inheritance parents, not UNION ALL appendrels */
8225 {
8226 found = false;
8228 {
8230 break; /* safety check */
8233 break; /* Var is local to child */
8234 }
8235
8237 found = true;
8238
8239 /* If the parent is itself a child, continue up. */
8242 }
8243
8244 /*
8245 * If we found an ancestral rel, and that rel is included in
8246 * appendparents, print that column not the original one.
8247 */
8249 {
8250 varno = pvarno;
8251 varattno = pvarattno;
8252 }
8253 }
8254
8256
8257 /* might be returning old/new column value */
8259 refname = dpns->ret_old_alias;
8261 refname = dpns->ret_new_alias;
8262 else
8264
8266 attnum = varattno;
8267 }
8268 else
8269 {
8273 }
8274
8275 /*
8276 * The planner will sometimes emit Vars referencing resjunk elements of a
8277 * subquery's target list (this is currently only possible if it chooses
8278 * to generate a "physical tlist" for a SubqueryScan or CteScan node).
8279 * Although we prefer to print subquery-referencing Vars using the
8280 * subquery's alias, that's not possible for resjunk items since they have
8281 * no alias. So in that case, drill down to the subplan and print the
8282 * contents of the referenced tlist item. This works because in a plan
8283 * tree, such Vars can only occur in a SubqueryScan or CteScan node, and
8284 * we'll have set dpns->inner_plan to reference the child plan node.
8285 */
8288 dpns->inner_plan)
8289 {
8292
8297
8300
8301 /*
8302 * Force parentheses because our caller probably assumed a Var is a
8303 * simple expression.
8304 */
8310
8313 }
8314
8315 /*
8316 * If it's an unnamed join, look at the expansion of the alias variable.
8317 * If it's a simple reference to one of the input vars, then recursively
8318 * print the name of that var instead. When it's not a simple reference,
8319 * we have to just print the unqualified join column name. (This can only
8320 * happen with "dangerous" merged columns in a JOIN USING; we took pains
8321 * previously to make the unqualified column name unique in such cases.)
8322 *
8323 * This wouldn't work in decompiling plan trees, because we don't store
8324 * joinaliasvars lists after planning; but a plan tree should never
8325 * contain a join alias variable.
8326 */
8328 {
8332 {
8334
8336 /* we intentionally don't strip implicit coercions here */
8338 {
8340 istoplevel, context);
8341 }
8342 }
8343
8344 /*
8345 * Unnamed join has no refname. (Note: since it's unnamed, there is
8346 * no way the user could have referenced it to create a whole-row Var
8347 * for it. So we don't have to cover that case below.)
8348 */
8350 }
8351
8355 {
8356 /* Get column name to use from the colinfo struct */
8361
8362 /*
8363 * If we find a Var referencing a dropped column, it seems better to
8364 * print something (anything) than to fail. In general this should
8365 * not happen, but it used to be possible for some cases involving
8366 * functions returning named composite types, and perhaps there are
8367 * still bugs out there.
8368 */
8371 }
8372 else
8373 {
8374 /* System column - name is fixed, get it from the catalog */
8376 }
8377
8380
8381 /*
8382 * If we're considering a plain Var in an ORDER BY (but not GROUP BY)
8383 * clause, we may need to add a table-name prefix to prevent
8384 * findTargetlistEntrySQL92 from misinterpreting the name as an
8385 * output-column name. To avoid cluttering the output with unnecessary
8386 * prefixes, do so only if there is a name match to a SELECT tlist item
8387 * that is different from the Var.
8388 */
8390 {
8391 int colno = 0;
8392
8394 {
8395 char *colname;
8396
8398 continue; /* ignore junk entries */
8399 colno++;
8400
8401 /* This must match colname-choosing logic in get_target_list() */
8404 colno - 1)->attname);
8405 else
8406 colname = tle->resname;
8407
8410 {
8412 break;
8413 }
8414 }
8415 }
8416
8418 {
8421 }
8424 else
8425 {
8429 format_type_with_typemod(var->vartype,
8430 var->vartypmod));
8431 }
8432
8434}
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 7206 of file ruleutils.c.
7209{
7211
7213 {
7220 else
7229 {
7235 else
7237 }
7238 else
7241 {
7248 {
7254 else
7256 }
7257 else
7259 }
7266 /* we will now have a trailing space; remove it */
7268 }
7269}
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 7275 of file ruleutils.c.
7278{
7280 deparse_context context;
7281
7289 context.prettyFlags = 0;
7291 context.indentLevel = 0;
7296
7297 get_window_frame_options(frameOptions, startOffset, endOffset, &context);
7298
7300}
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 11613 of file ruleutils.c.
References fb(), and get_windowfunc_expr_helper().
Referenced by get_rule_expr().
◆ get_windowfunc_expr_helper()
|
static |
Definition at line 11624 of file ruleutils.c.
11627{
11630 int nargs;
11631 List *argnames;
11632 ListCell *l;
11633
11638 nargs = 0;
11639 argnames = NIL;
11641 {
11643
11647 nargs++;
11648 }
11649
11653 context->inGroupBy);
11654
11656
11657 /* winstar can be set only in zero-argument aggregates */
11658 if (wfunc->winstar)
11660 else
11661 {
11663 {
11667 }
11668 else
11670 }
11671
11674
11676 {
11679 }
11680
11682
11685
11687
11689 {
11690 /* Query-decompilation case: search the windowClause list */
11692 {
11694
11696 {
11697 if (wc->name)
11699 else
11701 break;
11702 }
11703 }
11706 wfunc->winref);
11707 }
11708 else
11709 {
11710 /*
11711 * In EXPLAIN, search the namespace stack for a matching WindowAgg
11712 * node (probably it's always the first entry), and print winname.
11713 */
11715 {
11717
11719 {
11721
11723 {
11725 break;
11726 }
11727 }
11728 }
11731 wfunc->winref);
11732 }
11733}
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 6134 of file ruleutils.c.
6135{
6138 ListCell *l;
6139
6141 return;
6142
6144 {
6147 }
6148
6149 if (query->hasRecursive)
6151 else
6154 {
6156
6159 if (cte->aliascolnames)
6160 {
6161 bool first = true;
6163
6166 {
6167 if (first)
6168 first = false;
6169 else
6173 }
6175 }
6178 {
6180 break;
6183 break;
6186 break;
6187 }
6192 true,
6194 context->indentLevel);
6198
6199 if (cte->search_clause)
6200 {
6201 bool first = true;
6203
6205 cte->search_clause->search_breadth_first ? "BREADTH" : "DEPTH");
6206
6208 {
6209 if (first)
6210 first = false;
6211 else
6215 }
6216
6218 }
6219
6220 if (cte->cycle_clause)
6221 {
6222 bool first = true;
6224
6226
6228 {
6229 if (first)
6230 first = false;
6231 else
6235 }
6236
6238
6239 {
6242
6243 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
6245 {
6250 }
6251 }
6252
6254 }
6255
6257 }
6258
6260 {
6263 }
6264 else
6266}
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 12581 of file ruleutils.c.
12582{
12584
12586
12588 {
12590 *lc2;
12591 bool first = true;
12592
12595 {
12598
12599 if (!first)
12601 else
12602 first = false;
12603
12605 {
12609 }
12610 else
12611 {
12614 }
12615 }
12617 }
12618
12624
12626 {
12627 ListCell *l1;
12628 ListCell *l2;
12629 ListCell *l3;
12630 ListCell *l4;
12631 ListCell *l5;
12632 int colnum = 0;
12633
12635 forfive(l1, tf->colnames, l2, tf->coltypes, l3, tf->coltypmods,
12636 l4, tf->colexprs, l5, tf->coldefexprs)
12637 {
12643 bool ordinality = (tf->ordinalitycol == colnum);
12645
12646 if (colnum > 0)
12648 colnum++;
12649
12651 ordinality ? "FOR ORDINALITY" :
12652 format_type_with_typemod(typid, typmod));
12653 if (ordinality)
12654 continue;
12655
12657 {
12661 }
12663 {
12667 }
12668 if (notnull)
12670 }
12671 }
12672
12674}
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 4504 of file ruleutils.c.
4505{
4507 {
4508 /* nothing to do here */
4509 }
4511 {
4514
4516 {
4518 return true;
4519 }
4520 }
4522 {
4524
4525 /* Is it an unnamed JOIN with USING? */
4527 {
4528 /*
4529 * Yes, so check each join alias var to see if any of them are not
4530 * simple references to underlying columns. If so, we have a
4531 * dangerous situation and must pick unique aliases.
4532 */
4534
4535 /* We need only examine the merged columns */
4537 {
4539
4541 return true;
4542 }
4543 }
4544
4545 /* Nope, but inspect children */
4547 return true;
4549 return true;
4550 }
4551 else
4554 return false;
4555}
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 5429 of file ruleutils.c.
5431{
5436
5437 /* Extract left/right child RT indexes */
5442 else
5449 else
5452
5453 /* Assert children will be processed earlier than join in second pass */
5456
5457 /* Initialize result arrays with zeroes */
5462
5463 /*
5464 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
5465 * Recall that the column(s) merged due to USING are the first column(s)
5466 * of the join output. We need not do anything special while scanning
5467 * joinleftcols, but while scanning joinrightcols we must distinguish
5468 * merged from unmerged columns.
5469 */
5470 jcolno = 0;
5472 {
5474
5476 }
5477 rcolno = 0;
5479 {
5481
5484 else
5486 rcolno++;
5487 }
5489}
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 3810 of file ruleutils.c.
3811{
3816}
References fb().
Referenced by pg_get_function_arg_default().
◆ isSimpleNode()
Definition at line 9415 of file ruleutils.c.
9416{
9417 if (!node)
9418 return false;
9419
9421 {
9428 /* single words: always simple */
9429 return true;
9430
9447 /* function-like: name(..) or name[..] */
9448 return true;
9449
9450 /* CASE keywords act as parentheses */
9452 return true;
9453
9455
9456 /*
9457 * appears simple since . has top precedence, unless parent is
9458 * T_FieldSelect itself!
9459 */
9461
9463
9464 /*
9465 * treat like FieldSelect (probably doesn't matter)
9466 */
9468
9470 /* maybe simple, check args */
9472 node, prettyFlags);
9475 node, prettyFlags);
9478 node, prettyFlags);
9481 node, prettyFlags);
9484 node, prettyFlags);
9487 node, prettyFlags);
9488
9490 {
9491 /* depends on parent node type; needs further checking */
9493 {
9494 const char *op;
9500
9502 if (!op)
9503 return false;
9504
9505 /* We know only the basic operators + - and * / % */
9509 return false;
9510
9513 return false;
9514
9518 return false;
9519
9521 return true; /* op binds tighter than parent */
9522
9524 return false;
9525
9526 /*
9527 * Operators are same priority --- can skip parens only if
9528 * we have (a - b) - c, not a - (b - c).
9529 */
9531 return true;
9532
9533 return false;
9534 }
9535 /* else do the same stuff as for T_SubLink et al. */
9536 }
9537 pg_fallthrough;
9538
9545 {
9547 {
9548 /* special handling for casts and COERCE_SQL_SYNTAX */
9550
9554 return false;
9555 return true; /* own parentheses */
9556 }
9569 return true;
9570 default:
9571 return false;
9572 }
9573
9576 {
9579 {
9582
9586 {
9590 return true;
9591 break;
9594 return true;
9595 break;
9596 }
9597 }
9598 return false;
9600 {
9601 /* special handling for casts and COERCE_SQL_SYNTAX */
9603
9607 return false;
9608 return true; /* own parentheses */
9609 }
9622 return true;
9623 default:
9624 return false;
9625 }
9626
9628 /* maybe simple, check args */
9630 node, prettyFlags);
9631
9632 default:
9633 break;
9634 }
9635 /* those we don't know: in dubio complexo */
9636 return false;
9637}
References AND_EXPR, arg, COERCE_EXPLICIT_CAST, COERCE_IMPLICIT_CAST, COERCE_SQL_SYNTAX, fb(), get_simple_binary_op_name(), IsA, isSimpleNode(), linitial, nodeTag, NOT_EXPR, OR_EXPR, pg_fallthrough, PRETTYFLAG_PAREN, and type.
Referenced by get_rule_expr_paren(), and isSimpleNode().
◆ json_table_plan_is_default()
|
static |
Definition at line 12722 of file ruleutils.c.
12723{
12725 {
12727
12729 {
12731 return false; /* INNER is not the default */
12733 }
12734
12735 return true;
12736 }
12737 else
12738 {
12740
12742 return false; /* CROSS is not the default */
12745 }
12746}
References castNode, JsonTablePathScan::child, JsonTableSiblingJoin::cross, IsA, json_table_plan_is_default(), JsonTableSiblingJoin::lplan, JsonTablePathScan::outerJoin, plan, and JsonTableSiblingJoin::rplan.
Referenced by get_json_table(), and json_table_plan_is_default().
◆ list_oid_str_pair_cmp_by_str()
Definition at line 1786 of file ruleutils.c.
1787{
1790
1792}
References fb(), lfirst, and oid_str_pair::str.
Referenced by make_propgraphdef_labels().
◆ looks_like_function()
Definition at line 11294 of file ruleutils.c.
11295{
11297 return false; /* probably shouldn't happen */
11299 {
11301 /* OK, unless it's going to deparse as a cast */
11310 /* these are all accepted by func_expr_common_subexpr */
11311 return true;
11312 default:
11313 break;
11314 }
11315 return false;
11316}
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 5287 of file ruleutils.c.
5289{
5290 /*
5291 * If the selected name isn't unique, append digits to make it so. For a
5292 * very long input name, we might have to truncate to stay within
5293 * NAMEDATALEN.
5294 */
5296 {
5300
5301 do
5302 {
5303 i++;
5304 for (;;)
5305 {
5309 break;
5310 /* drop chars from colname to keep all the digits */
5312 colnamelen - 1);
5313 }
5315 colname = modname;
5316 }
5317 return colname;
5318}
References colname_is_unique(), fb(), i, memcpy(), NAMEDATALEN, palloc(), pg_mbcliplen(), and sprintf.
Referenced by set_join_column_names(), set_relation_column_names(), and set_using_names().
◆ make_propgraphdef_elements()
|
static |
Definition at line 1662 of file ruleutils.c.
1663{
1666 SysScanDesc scan;
1667 bool first;
1669
1671
1676
1678
1679 first = true;
1681 {
1684 Datum datum;
1685 bool isnull;
1686
1688 continue;
1689
1690 if (first)
1691 {
1693 first = false;
1694 }
1695 else
1697
1702 else
1706
1707 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgekey, RelationGetDescr(pgerel), &isnull);
1708 if (!isnull)
1709 {
1713 }
1714 else
1716
1718 {
1719 Datum srckey;
1720 Datum srcref;
1721 Datum destkey;
1722 Datum destref;
1725
1726 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgesrckey, RelationGetDescr(pgerel), &isnull);
1727 srckey = isnull ? 0 : datum;
1728 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgesrcref, RelationGetDescr(pgerel), &isnull);
1729 srcref = isnull ? 0 : datum;
1730 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgedestkey, RelationGetDescr(pgerel), &isnull);
1731 destkey = isnull ? 0 : datum;
1732 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgedestref, RelationGetDescr(pgerel), &isnull);
1733 destref = isnull ? 0 : datum;
1734
1740 if (srckey)
1741 {
1747 }
1748 else
1751
1757 if (destkey)
1758 {
1764 }
1765 else
1768 }
1769
1771 }
1772 if (!first)
1774
1775 systable_endscan(scan);
1777}
References AccessShareLock, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), BTEqualStrategyNumber, buf, decompile_column_index_array(), elog, ERROR, fb(), Form_pg_propgraph_element, generate_relation_name(), get_rel_name(), GETSTRUCT(), heap_getattr(), make_propgraphdef_labels(), NameStr, NIL, ObjectIdGetDatum(), quote_identifier(), RelationGetDescr, ReleaseSysCache(), relname, ScanKeyInit(), SearchSysCache1(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().
Referenced by pg_get_propgraphdef().
◆ make_propgraphdef_labels()
|
static |
Definition at line 1799 of file ruleutils.c.
1800{
1803 SysScanDesc scan;
1804 int count;
1807
1809
1814
1815 /*
1816 * We want to output the labels in a deterministic order. So we first
1817 * read all the data, then sort, then print it.
1818 */
1819 scan = systable_beginscan(pglrel, PropgraphElementLabelElementLabelIndexId, true, NULL, 1, scankey);
1820
1822 {
1825
1829
1831 }
1832
1833 systable_endscan(scan);
1835
1837
1838 /* Each element has at least one label. */
1839 Assert(count > 0);
1840
1841 /*
1842 * It is enough for the comparison function to compare just labels, since
1843 * all the labels of an element table should have distinct names.
1844 */
1846
1848 {
1850 {
1851 /* If the default label is the only label, don't print anything. */
1852 if (count != 1)
1854 }
1855 else
1857
1859 }
1860}
References AccessShareLock, appendStringInfo(), appendStringInfoString(), Assert, BTEqualStrategyNumber, buf, fb(), foreach_ptr, Form_pg_propgraph_element_label, get_propgraph_label_name(), GETSTRUCT(), lappend(), list_length(), list_oid_str_pair_cmp_by_str(), list_sort(), make_propgraphdef_properties(), NIL, ObjectIdGetDatum(), palloc_object, quote_identifier(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().
Referenced by make_propgraphdef_elements().
◆ make_propgraphdef_properties()
|
static |
Definition at line 1883 of file ruleutils.c.
1884{
1887 SysScanDesc scan;
1890
1892
1897
1898 /*
1899 * We want to output the properties in a deterministic order. So we first
1900 * read all the data, then sort, then print it.
1901 */
1902 scan = systable_beginscan(plprel, PropgraphLabelPropertyLabelPropIndexId, true, NULL, 1, scankey);
1903
1905 {
1908 bool isnull;
1909 char *tmp;
1910 Node *expr;
1912
1913 exprDatum = heap_getattr(tup, Anum_pg_propgraph_label_property_plpexpr, RelationGetDescr(plprel), &isnull);
1914 Assert(!isnull);
1916 expr = stringToNode(tmp);
1917 pfree(tmp);
1918
1920
1922 }
1923
1924 systable_endscan(scan);
1926
1928
1929 if (outlist)
1930 {
1931 List *context;
1933 bool first = true;
1934
1936
1938
1940 {
1944
1945 if (first)
1946 first = false;
1947 else
1949
1950 if (IsA(expr, Var) && strcmp(propname, get_attname(elrelid, castNode(Var, expr)->varattno, false)) == 0)
1952 else
1956 }
1957
1959 }
1960 else
1962}
References AccessShareLock, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, BTEqualStrategyNumber, buf, castNode, data, deparse_context_for(), deparse_expression_pretty(), fb(), Form_pg_propgraph_label_property, get_attname(), get_propgraph_property_name(), get_relation_name(), GETSTRUCT(), heap_getattr(), IsA, lappend(), lfirst_node, linitial, list_make2, list_sort(), lsecond, makeString(), NIL, ObjectIdGetDatum(), pfree(), propdata_by_name_cmp(), quote_identifier(), RelationGetDescr, ScanKeyInit(), stringToNode(), strVal, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and TextDatumGetCString.
Referenced by make_propgraphdef_labels().
◆ make_ruledef()
|
static |
Definition at line 5711 of file ruleutils.c.
5713{
5714 char *rulename;
5715 char ev_type;
5717 bool is_instead;
5720 List *actions;
5725 bool isnull;
5726
5727 /*
5728 * Get the attribute values from the rules tuple
5729 */
5732 Assert(!isnull);
5734
5737 Assert(!isnull);
5739
5742 Assert(!isnull);
5744
5747 Assert(!isnull);
5749
5753
5760
5762
5763 /*
5764 * Build the rules definition text
5765 */
5767 quote_identifier(rulename));
5768
5771 else
5773
5774 /* The event the rule is fired for */
5775 switch (ev_type)
5776 {
5777 case '1':
5780 break;
5781
5782 case '2':
5784 break;
5785
5786 case '3':
5788 break;
5789
5790 case '4':
5792 break;
5793
5794 default:
5798 rulename, ev_type)));
5799 break;
5800 }
5801
5802 /* The relation the rule is fired on */
5804 (prettyFlags & PRETTYFLAG_SCHEMA) ?
5807
5808 /* If the rule has an event qualification, add it */
5810 {
5811 Node *qual;
5812 Query *query;
5813 deparse_context context;
5815
5819
5821
5822 /*
5823 * We need to make a context for recognizing any Vars in the qual
5824 * (which can only be references to OLD and NEW). Use the rtable of
5825 * the first query in the action list for this purpose.
5826 */
5828
5829 /*
5830 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5831 * into the SELECT, and that's what we need to look at. (Ugly kluge
5832 * ... try to fix this when we redesign querytrees.)
5833 */
5835
5836 /* Must acquire locks right away; see notes in get_query_def() */
5838
5845 context.prettyFlags = prettyFlags;
5852
5854
5856 }
5857
5859
5860 /* The INSTEAD keyword (if so) */
5861 if (is_instead)
5863
5864 /* Finally the rules actions */
5866 {
5868 Query *query;
5869
5871 foreach(action, actions)
5872 {
5875 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5876 if (prettyFlags)
5878 else
5880 }
5882 }
5883 else
5884 {
5885 Query *query;
5886
5889 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5891 }
5892
5894}
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 5903 of file ruleutils.c.
5905{
5906 Query *query;
5907 char ev_type;
5909 bool is_instead;
5912 List *actions;
5916 bool isnull;
5917
5918 /*
5919 * Get the attribute values from the rules tuple
5920 */
5923 Assert(!isnull);
5925
5928 Assert(!isnull);
5930
5933 Assert(!isnull);
5935
5939
5944
5946 {
5947 /* keep output buffer empty and leave */
5948 return;
5949 }
5950
5952
5953 if (ev_type != '1' || !is_instead ||
5955 {
5956 /* keep output buffer empty and leave */
5957 return;
5958 }
5959
5961
5963 prettyFlags, wrapColumn, 0);
5965
5967}
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 2506 of file ruleutils.c.
2507{
2509 int prettyFlags;
2510 char *res;
2511
2512 prettyFlags = PRETTYFLAG_INDENT;
2513
2515
2517 PG_RETURN_NULL();
2518
2520}
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 2544 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 2523 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 2553 of file ruleutils.c.
2555{
2559 SysScanDesc scandesc;
2563
2565 Anum_pg_constraint_oid,
2568
2569 scandesc = systable_beginscan(relation,
2570 ConstraintOidIndexId,
2571 true,
2572 snapshot,
2573 1,
2574 scankey);
2575
2576 /*
2577 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2578 * via SearchSysCache, which works fine.
2579 */
2581
2582 UnregisterSnapshot(snapshot);
2583
2585 {
2586 if (missing_ok)
2587 {
2588 systable_endscan(scandesc);
2591 }
2593 }
2594
2596
2598
2600 {
2602 {
2603 /*
2604 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2605 * constraints, and other types of constraints don't inherit
2606 * anyway so it doesn't matter whether we say ONLY or not. Someday
2607 * we might need to let callers specify whether to put ONLY in the
2608 * command.
2609 */
2613 }
2614 else
2615 {
2616 /* Must be a domain constraint */
2621 }
2622 }
2623
2625 {
2627 {
2629 bool isnull;
2631
2632 /* Start off the constraint definition */
2634
2635 /* Fetch and build referencing-column list */
2637 Anum_pg_constraint_conkey);
2638
2639 /* If it is a temporal foreign key then it uses PERIOD. */
2641
2642 /* add foreign relation name */
2645 NIL));
2646
2647 /* Fetch and build referenced-column list */
2649 Anum_pg_constraint_confkey);
2650
2652
2654
2655 /* Add match type */
2657 {
2659 string = " MATCH FULL";
2660 break;
2662 string = " MATCH PARTIAL";
2663 break;
2665 string = "";
2666 break;
2667 default:
2669 conForm->confmatchtype);
2670 string = ""; /* keep compiler quiet */
2671 break;
2672 }
2674
2675 /* Add ON UPDATE and ON DELETE clauses, if needed */
2677 {
2680 break;
2682 string = "RESTRICT";
2683 break;
2685 string = "CASCADE";
2686 break;
2688 string = "SET NULL";
2689 break;
2691 string = "SET DEFAULT";
2692 break;
2693 default:
2695 conForm->confupdtype);
2697 break;
2698 }
2699 if (string)
2701
2703 {
2706 break;
2708 string = "RESTRICT";
2709 break;
2711 string = "CASCADE";
2712 break;
2714 string = "SET NULL";
2715 break;
2717 string = "SET DEFAULT";
2718 break;
2719 default:
2721 conForm->confdeltype);
2723 break;
2724 }
2725 if (string)
2727
2728 /*
2729 * Add columns specified to SET NULL or SET DEFAULT if
2730 * provided.
2731 */
2733 Anum_pg_constraint_confdelsetcols, &isnull);
2734 if (!isnull)
2735 {
2739 }
2740
2741 break;
2742 }
2745 {
2750
2751 /* Start off the constraint definition */
2754 else
2756
2758
2765
2767
2768 /* Fetch and build target column list */
2770 Anum_pg_constraint_conkey);
2771
2775
2777
2778 /* Build including column list (from pg_index.indkeys) */
2780 Anum_pg_index_indnatts);
2782 {
2783 Datum cols;
2784 Datum *keys;
2785 int nKeys;
2787
2789
2791 Anum_pg_index_indkey);
2792
2794 &keys, NULL, &nKeys);
2795
2797 {
2799
2805 }
2806
2808 }
2810
2811 /* XXX why do we only print these bits if fullCommand? */
2813 {
2816
2818 {
2821 }
2822
2823 /*
2824 * Print the tablespace, unless it's the database default.
2825 * This is to help ALTER TABLE usage of this facility,
2826 * which needs this behavior to recreate exact catalog
2827 * state.
2828 */
2833 }
2834
2835 break;
2836 }
2838 {
2842 Node *expr;
2843 List *context;
2844
2845 /* Fetch constraint expression in parsetree form */
2847 Anum_pg_constraint_conbin);
2848
2851
2852 /* Set up deparsing context for Var nodes in constraint */
2854 {
2855 /* relation constraint */
2857 conForm->conrelid);
2858 }
2859 else
2860 {
2861 /* domain constraint --- can't have Vars */
2862 context = NIL;
2863 }
2864
2866 prettyFlags, 0);
2867
2868 /*
2869 * Now emit the constraint definition, adding NO INHERIT if
2870 * necessary.
2871 *
2872 * There are cases where the constraint expression will be
2873 * fully parenthesized and we don't need the outer parens ...
2874 * but there are other cases where we do need 'em. Be
2875 * conservative for now.
2876 *
2877 * Note that simply checking for leading '(' and trailing ')'
2878 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2879 */
2881 consrc,
2883 break;
2884 }
2886 {
2888 {
2890
2892
2898 }
2900 {
2901 /* conkey is null for domain not-null constraints */
2903 }
2904 break;
2905 }
2906
2908
2909 /*
2910 * There isn't an ALTER TABLE syntax for creating a user-defined
2911 * constraint trigger, but it seems better to print something than
2912 * throw an error; if we throw error then this function couldn't
2913 * safely be applied to all rows of pg_constraint.
2914 */
2916 break;
2918 {
2921 Datum *elems;
2922 int nElems;
2924 Oid *operators;
2925
2926 /* Extract operator OIDs from the pg_constraint tuple */
2928 Anum_pg_constraint_conexclop);
2929
2931 &elems, NULL, &nElems);
2932
2936
2937 /* pg_get_indexdef_worker does the rest */
2938 /* suppress tablespace because pg_dump wants it that way */
2940 pg_get_indexdef_worker(indexOid,
2941 0,
2942 operators,
2943 false,
2944 false,
2945 false,
2946 false,
2947 prettyFlags,
2948 false));
2949 break;
2950 }
2951 default:
2953 break;
2954 }
2955
2960
2961 /* Validated status is irrelevant when the constraint is NOT ENFORCED. */
2966
2967 /* Cleanup */
2968 systable_endscan(scandesc);
2970
2972}
References AccessShareLock, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attnum, BTEqualStrategyNumber, buf, DatumGetArrayTypeP, DatumGetInt16(), DatumGetInt32(), DatumGetObjectId(), decompile_column_index_array(), deconstruct_array_builtin(), deparse_context_for(), deparse_expression_pretty(), elog, ERROR, extractNotNullColumn(), fb(), FKCONSTR_ACTION_CASCADE, FKCONSTR_ACTION_NOACTION, FKCONSTR_ACTION_RESTRICT, FKCONSTR_ACTION_SETDEFAULT, FKCONSTR_ACTION_SETNULL, FKCONSTR_MATCH_FULL, FKCONSTR_MATCH_PARTIAL, FKCONSTR_MATCH_SIMPLE, flatten_reloptions(), Form_pg_constraint, Form_pg_index, generate_qualified_relation_name(), generate_qualified_type_name(), generate_relation_name(), get_attname(), get_rel_tablespace(), get_relation_name(), get_tablespace_name(), GETSTRUCT(), GetTransactionSnapshot(), HeapTupleIsValid, i, initStringInfo(), InvalidOid, j, NameStr, NIL, ObjectIdGetDatum(), OidIsValid, palloc(), pfree(), pg_get_indexdef_worker(), quote_identifier(), RegisterSnapshot(), ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), stringToNode(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TextDatumGetCString, UnregisterSnapshot(), and val.
Referenced by pg_get_constraintdef(), pg_get_constraintdef_command(), and pg_get_constraintdef_ext().
◆ pg_get_expr()
| Datum pg_get_expr | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3035 of file ruleutils.c.
3036{
3040 int prettyFlags;
3041
3042 prettyFlags = PRETTYFLAG_INDENT;
3043
3047 else
3048 PG_RETURN_NULL();
3049}
References pg_get_expr_worker(), PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, PRETTYFLAG_INDENT, and result.
Referenced by decompile_conbin().
◆ pg_get_expr_ext()
| Datum pg_get_expr_ext | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3052 of file ruleutils.c.
References fb(), GET_PRETTY_FLAGS, pg_get_expr_worker(), PG_GETARG_BOOL, PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and result.
◆ pg_get_expr_worker()
Definition at line 3070 of file ruleutils.c.
3071{
3072 Node *node;
3074 Relids relids;
3075 List *context;
3079
3080 /* Convert input pg_node_tree (really TEXT) object to C string */
3082
3083 /* Convert expression to node tree */
3085
3087
3088 /*
3089 * Throw error if the input is a querytree rather than an expression tree.
3090 * While we could support queries here, there seems no very good reason
3091 * to. In most such catalog columns, we'll see a List of Query nodes, or
3092 * even nested Lists, so drill down to a non-List node before checking.
3093 */
3094 tst = node;
3101
3102 /*
3103 * Throw error if the expression contains Vars we won't be able to
3104 * deparse.
3105 */
3108 {
3113 }
3114 else
3115 {
3120 }
3121
3122 /*
3123 * Prepare deparse context if needed. If we are deparsing with a relid,
3124 * we need to transiently open and lock the rel, to make sure it won't go
3125 * away underneath us. (set_relation_column_names would lock it anyway,
3126 * so this isn't really introducing any new behavior.)
3127 */
3129 {
3134 }
3135 else
3136 context = NIL;
3137
3138 /* Deparse */
3140 prettyFlags, 0);
3141
3144
3146}
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 3850 of file ruleutils.c.
3851{
3855 Form_pg_proc proc;
3856 int numargs;
3857 Oid *argtypes;
3858 char **argnames;
3862 Node *node;
3866 bool isnull;
3868
3871 PG_RETURN_NULL();
3872
3875 {
3877 PG_RETURN_NULL();
3878 }
3879
3880 nth_inputarg = 0;
3883 nth_inputarg++;
3884
3887 &isnull);
3888 if (isnull)
3889 {
3891 PG_RETURN_NULL();
3892 }
3893
3897
3899
3900 /*
3901 * Calculate index into proargdefaults: proargdefaults corresponds to the
3902 * last N input arguments, where N = pronargdefaults.
3903 */
3905
3907 {
3909 PG_RETURN_NULL();
3910 }
3913
3915
3917}
References castNode, deparse_expression(), fb(), Form_pg_proc, get_func_arg_info(), GETSTRUCT(), HeapTupleIsValid, i, is_input_argument(), list_length(), list_nth(), NIL, ObjectIdGetDatum(), pfree(), PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, ReleaseSysCache(), SearchSysCache1(), str, string_to_text(), stringToNode(), SysCacheGetAttr(), and TextDatumGetCString.
◆ pg_get_function_arguments()
| Datum pg_get_function_arguments | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3543 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 3569 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 3594 of file ruleutils.c.
3595{
3599
3602 PG_RETURN_NULL();
3603
3605 {
3607 PG_RETURN_NULL();
3608 }
3609
3611
3613
3615
3617}
References buf, fb(), Form_pg_proc, GETSTRUCT(), HeapTupleIsValid, initStringInfo(), ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, print_function_rettype(), ReleaseSysCache(), SearchSysCache1(), and string_to_text().
◆ pg_get_function_sqlbody()
| Datum pg_get_function_sqlbody | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3974 of file ruleutils.c.
3975{
3979 bool isnull;
3980
3982
3983 /* Look up the function */
3986 PG_RETURN_NULL();
3987
3989 if (isnull)
3990 {
3992 PG_RETURN_NULL();
3993 }
3994
3996
3998
4000}
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 3287 of file ruleutils.c.
3288{
3293 Form_pg_proc proc;
3295 Datum tmp;
3296 bool isnull;
3297 const char *prosrc;
3302
3304
3305 /* Look up the function */
3308 PG_RETURN_NULL();
3309
3312
3317
3319
3320 /*
3321 * We always qualify the function name, to ensure the right function gets
3322 * replaced.
3323 */
3331 {
3335 }
3336
3338
3341
3342 /* Emit some miscellaneous options on one line */
3344
3347 switch (proc->provolatile)
3348 {
3351 break;
3354 break;
3356 break;
3357 }
3358
3359 switch (proc->proparallel)
3360 {
3363 break;
3366 break;
3368 break;
3369 }
3370
3371 if (proc->proisstrict)
3373 if (proc->prosecdef)
3375 if (proc->proleakproof)
3377
3378 /* This code for the default cost and rows should match functioncmds.c */
3380 proc->prolang == ClanguageId)
3381 procost = 1;
3382 else
3383 procost = 100;
3386
3387 if (proc->prorows > 0 && proc->prorows != 1000)
3389
3390 if (proc->prosupport)
3391 {
3392 Oid argtypes[1];
3393
3394 /*
3395 * We should qualify the support function's name if it wouldn't be
3396 * resolved by lookup in the current search path.
3397 */
3398 argtypes[0] = INTERNALOID;
3400 generate_function_name(proc->prosupport, 1,
3401 NIL, argtypes,
3403 }
3404
3407
3408 /* Emit any proconfig options, one per line */
3410 if (!isnull)
3411 {
3414
3418
3420 {
3421 Datum d;
3422
3424 -1 /* varlenarray */ ,
3425 -1 /* TEXT's typlen */ ,
3426 false /* TEXT's typbyval */ ,
3428 &isnull);
3429 if (!isnull)
3430 {
3432 char *pos;
3433
3436 continue;
3437 *pos++ = '\0';
3438
3441
3442 /*
3443 * Variables that are marked GUC_LIST_QUOTE were already fully
3444 * quoted by flatten_set_variable_args() before they were put
3445 * into the proconfig array. However, because the quoting
3446 * rules used there aren't exactly like SQL's, we have to
3447 * break the list value apart and then quote the elements as
3448 * string literals. (The elements may be double-quoted as-is,
3449 * but we can't just feed them to the SQL parser; it would do
3450 * the wrong thing with elements that are zero-length or
3451 * longer than NAMEDATALEN.) Also, we need a special case for
3452 * empty lists.
3453 *
3454 * Variables that are not so marked should just be emitted as
3455 * simple string literals. If the variable is not known to
3456 * guc.c, we'll do that; this makes it unsafe to use
3457 * GUC_LIST_QUOTE for extension variables.
3458 */
3460 {
3463
3464 /* Parse string into list of identifiers */
3466 {
3467 /* this shouldn't fail really */
3469 }
3470 /* Special case: represent an empty list as NULL */
3474 {
3476
3480 }
3481 }
3482 else
3485 }
3486 }
3487 }
3488
3489 /* And finally the function definition ... */
3492 {
3494 }
3495 else
3496 {
3498
3500 if (!isnull)
3501 {
3504 }
3505
3507 prosrc = TextDatumGetCString(tmp);
3508
3509 /*
3510 * We always use dollar quoting. Figure out a suitable delimiter.
3511 *
3512 * Since the user is likely to be editing the function body string, we
3513 * shouldn't use a short delimiter that he might easily create a
3514 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3515 * if needed.
3516 */
3523
3527 }
3528
3530
3532
3534}
References a, appendBinaryStringInfo(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), Assert, buf, DatumGetArrayTypeP, elog, ereport, errcode(), errmsg, ERROR, fb(), Form_pg_proc, generate_function_name(), get_language_name(), get_namespace_name_or_temp(), GetConfigOptionFlags(), GETSTRUCT(), GUC_LIST_QUOTE, HeapTupleIsValid, i, initStringInfo(), lfirst, lnext(), name, NameStr, NIL, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, print_function_arguments(), print_function_rettype(), print_function_sqlbody(), print_function_trftypes(), quote_identifier(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), simple_quote_literal(), SplitGUCList(), string_to_text(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), and TextDatumGetCString.
◆ pg_get_indexdef()
| Datum pg_get_indexdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1191 of file ruleutils.c.
1192{
1194 int prettyFlags;
1195 char *res;
1196
1197 prettyFlags = PRETTYFLAG_INDENT;
1198
1200 false, false,
1201 false, false,
1202 prettyFlags, true);
1203
1205 PG_RETURN_NULL();
1206
1208}
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 1248 of file ruleutils.c.
1249{
1250 int prettyFlags;
1251
1253
1255 true, true,
1256 false, false,
1257 prettyFlags, false);
1258}
References fb(), GET_PRETTY_FLAGS, and pg_get_indexdef_worker().
Referenced by BuildIndexValueDescription().
◆ pg_get_indexdef_columns_extended()
Definition at line 1262 of file ruleutils.c.
1263{
1266 int prettyFlags;
1267
1269
1272 false, false,
1273 prettyFlags, false);
1274}
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 1211 of file ruleutils.c.
1212{
1216 int prettyFlags;
1217 char *res;
1218
1220
1222 colno != 0, false,
1223 false, false,
1224 prettyFlags, true);
1225
1227 PG_RETURN_NULL();
1228
1230}
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 1238 of file ruleutils.c.
1239{
1241 false, false,
1242 true, true,
1243 0, false);
1244}
References fb(), and pg_get_indexdef_worker().
Referenced by RememberIndexForRebuilding().
◆ pg_get_indexdef_worker()
|
static |
Definition at line 1283 of file ruleutils.c.
1288{
1289 /* might want a separate isConstraint parameter later */
1300 List *context;
1302 int keyno;
1312
1313 /*
1314 * Fetch the pg_index tuple by the Oid of the index
1315 */
1318 {
1319 if (missing_ok)
1322 }
1324
1327
1328 /* Must get indcollation, indclass, and indoption the hard way */
1330 Anum_pg_index_indcollation);
1332
1334 Anum_pg_index_indclass);
1336
1338 Anum_pg_index_indoption);
1340
1341 /*
1342 * Fetch the pg_class tuple of the index relation
1343 */
1348
1349 /*
1350 * Fetch the pg_am tuple of the index' access method
1351 */
1355 idxrelrec->relam);
1357
1358 /* Fetch the index AM's API struct */
1360
1361 /*
1362 * Get the index expressions, if any. (NOTE: we do not use the relcache
1363 * versions of the expressions and predicate, because we want to display
1364 * non-const-folded expressions.)
1365 */
1367 {
1370
1372 Anum_pg_index_indexprs);
1376 }
1377 else
1379
1381
1383
1384 /*
1385 * Start the index definition. Note that the index's name should never be
1386 * schema-qualified, but the indexed rel's name may be.
1387 */
1389
1391 {
1398 (prettyFlags & PRETTYFLAG_SCHEMA) ?
1402 else /* currently, must be EXCLUDE constraint */
1405 }
1406
1407 /*
1408 * Report the indexed attributes
1409 */
1412 {
1416
1417 /*
1418 * Ignore non-key attributes if told to.
1419 */
1421 break;
1422
1423 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1425 {
1428 }
1429
1430 if (!colno)
1433
1435 {
1436 /* Simple index column */
1439
1441 if (!colno || colno == keyno + 1)
1445 &keycolcollation);
1446 }
1447 else
1448 {
1449 /* expressional index */
1451
1456 /* Deparse */
1458 prettyFlags, 0);
1459 if (!colno || colno == keyno + 1)
1460 {
1461 /* Need parens if it's not a bare function call */
1464 else
1466 }
1469 }
1470
1471 /* Print additional decoration for (selected) key columns */
1473 (!colno || colno == keyno + 1))
1474 {
1479
1480 /* Add collation, if not default for column */
1484
1485 /* Add the operator class name, if not default */
1488
1490 {
1494 }
1495
1496 /* Add options if relevant */
1498 {
1499 /* if it supports sort ordering, report DESC and NULLS opts */
1501 {
1503 /* NULLS FIRST is the default in this case */
1506 }
1507 else
1508 {
1511 }
1512 }
1513
1514 /* Add the exclusion operator if relevant */
1518 keycoltype,
1519 keycoltype));
1520 }
1521 }
1522
1524 {
1526
1529
1530 /*
1531 * If it has options, append "WITH (options)"
1532 */
1535 {
1538 }
1539
1540 /*
1541 * Print tablespace, but only if requested
1542 */
1544 {
1546
1549 {
1554 }
1555 }
1556
1557 /*
1558 * If it's a partial index, decompile and append the predicate
1559 */
1561 {
1562 Node *node;
1565
1566 /* Convert text string to node tree */
1568 Anum_pg_index_indpred);
1572
1573 /* Deparse */
1575 prettyFlags, 0);
1578 else
1580 }
1581 }
1582
1583 /* Clean up */
1587
1589}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attname, attnum, buf, DatumGetPointer(), deparse_context_for(), deparse_expression_pretty(), elog, ERROR, exprCollation(), exprType(), fb(), flatten_reloptions(), Form_pg_am, Form_pg_index, generate_collation_name(), generate_operator_name(), generate_qualified_relation_name(), generate_relation_name(), get_attname(), get_attoptions(), get_atttypetypmodcoll(), get_opclass_name(), get_rel_tablespace(), get_relation_name(), get_reloptions(), get_tablespace_name(), GetIndexAmRoutine(), GETSTRUCT(), heap_attisnull(), HeapTupleIsValid, initStringInfo(), InvalidOid, lfirst, list_head(), lnext(), looks_like_function(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, pfree(), PRETTYFLAG_SCHEMA, quote_identifier(), ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), and TextDatumGetCString.
Referenced by pg_get_constraintdef_worker(), pg_get_indexdef(), pg_get_indexdef_columns(), pg_get_indexdef_columns_extended(), pg_get_indexdef_ext(), and pg_get_indexdef_string().
◆ pg_get_partconstrdef_string()
Definition at line 2488 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 2456 of file ruleutils.c.
2457{
2460 int prettyFlags;
2461 List *context;
2463
2465
2466 /* Quick exit if no partition constraint */
2468 PG_RETURN_NULL();
2469
2470 /*
2471 * Deparse and return the constraint expression.
2472 */
2473 prettyFlags = PRETTYFLAG_INDENT;
2476 false, prettyFlags, 0);
2477
2479}
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 2269 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 2284 of file ruleutils.c.
2285{
2286 int prettyFlags;
2287
2289
2291}
References fb(), GET_PRETTY_FLAGS, and pg_get_partkeydef_worker().
Referenced by ExecBuildSlotPartitionKeyDescription().
◆ pg_get_partkeydef_worker()
|
static |
Definition at line 2297 of file ruleutils.c.
2299{
2301 HeapTuple tuple;
2303 oidvector *partcollation;
2304 List *partexprs;
2306 List *context;
2307 Datum datum;
2309 int keyno;
2312
2315 {
2316 if (missing_ok)
2319 }
2320
2322
2324
2325 /* Must get partclass and partcollation the hard way */
2329
2333
2334
2335 /*
2336 * Get the expressions, if any. (NOTE: we do not use the relcache
2337 * versions of the expressions, because we want to display
2338 * non-const-folded expressions.)
2339 */
2341 {
2344
2349
2353
2355 }
2356 else
2357 partexprs = NIL;
2358
2361
2363
2365 {
2369 break;
2373 break;
2377 break;
2378 default:
2381 }
2382
2387 {
2392
2396 {
2397 /* Simple attribute reference */
2400
2405 &keycolcollation);
2406 }
2407 else
2408 {
2409 /* Expression */
2411
2416
2417 /* Deparse */
2419 prettyFlags, 0);
2420 /* Need parens if it's not a bare function call */
2423 else
2425
2428 }
2429
2430 /* Add collation, if not default for column */
2435
2436 /* Add the operator class name, if not default */
2439 }
2440
2443
2444 /* Clean up */
2445 ReleaseSysCache(tuple);
2446
2448}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attname, attnum, buf, DatumGetPointer(), deparse_context_for(), deparse_expression_pretty(), elog, ERROR, exprCollation(), exprType(), fb(), Form_pg_partitioned_table, generate_collation_name(), get_attname(), get_atttypetypmodcoll(), get_opclass_name(), get_relation_name(), GETSTRUCT(), heap_attisnull(), HeapTupleIsValid, initStringInfo(), IsA, lfirst, list_head(), lnext(), looks_like_function(), NIL, nodeTag, ObjectIdGetDatum(), OidIsValid, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, pfree(), quote_identifier(), ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), TextDatumGetCString, and oidvector::values.
Referenced by pg_get_partkeydef(), and pg_get_partkeydef_columns().
◆ pg_get_propgraphdef()
| Datum pg_get_propgraphdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1620 of file ruleutils.c.
References appendStringInfo(), buf, ereport, errcode(), errmsg, ERROR, fb(), get_namespace_name(), GETSTRUCT(), HeapTupleIsValid, initStringInfo(), make_propgraphdef_elements(), name, NameStr, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), and string_to_text().
◆ pg_get_querydef()
Definition at line 1601 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 573 of file ruleutils.c.
574{
576 int prettyFlags;
577 char *res;
578
579 prettyFlags = PRETTYFLAG_INDENT;
580
582
584 PG_RETURN_NULL();
585
587}
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 591 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 610 of file ruleutils.c.
611{
613 char nulls[1];
618
619 /*
620 * Do this first so that string is alloc'd in outer context not SPI's.
621 */
623
624 /*
625 * Connect to SPI manager
626 */
627 SPI_connect();
628
629 /*
630 * On the first call prepare the plan to lookup pg_rewrite. We read
631 * pg_rewrite over the SPI manager instead of using the syscache to be
632 * checked for read access on pg_rewrite.
633 */
635 {
636 Oid argtypes[1];
638
639 argtypes[0] = OIDOID;
645 }
646
647 /*
648 * Get the pg_rewrite tuple for this rule
649 */
651 nulls[0] = ' ';
656 {
657 /*
658 * There is no tuple data available here, just keep the output buffer
659 * empty.
660 */
661 }
662 else
663 {
664 /*
665 * Get the rule's definition and put it into executor's memory
666 */
670 }
671
672 /*
673 * Disconnect from SPI manager
674 */
677
680
682}
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 3193 of file ruleutils.c.
3194{
3198 Oid tableOid;
3204 SysScanDesc scan;
3206
3207 /* Look up table name. Can't lock it - we might not have privileges. */
3210
3211 /* Get the number of the column */
3213
3220
3221 /* Search the dependency table for the dependent sequence */
3223
3224 ScanKeyInit(&key[0],
3228 ScanKeyInit(&key[1],
3229 Anum_pg_depend_refobjid,
3231 ObjectIdGetDatum(tableOid));
3232 ScanKeyInit(&key[2],
3236
3238 NULL, 3, key);
3239
3241 {
3243
3244 /*
3245 * Look for an auto dependency (serial column) or internal dependency
3246 * (identity column) of a sequence on a column. (We need the relkind
3247 * test because indexes can also have auto dependencies on columns.)
3248 */
3250 deprec->objsubid == 0 &&
3254 {
3256 break;
3257 }
3258 }
3259
3260 systable_endscan(scan);
3262
3264 {
3266
3268
3270 }
3271
3272 PG_RETURN_NULL();
3273}
References AccessShareLock, attnum, BTEqualStrategyNumber, DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, ereport, errcode(), errmsg, ERROR, fb(), Form_pg_depend, generate_qualified_relation_name(), get_attnum(), get_rel_relkind(), GETSTRUCT(), HeapTupleIsValid, Int32GetDatum(), InvalidAttrNumber, InvalidOid, makeRangeVarFromNameList(), NoLock, ObjectIdGetDatum(), OidIsValid, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, RangeVarGetRelid, result, 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 2014 of file ruleutils.c.
2015{
2019 int colno;
2021 ArrayType *arr;
2022 char *enabled;
2023 Datum datum;
2028 List *context;
2032 int ncolumns;
2033
2035
2037 {
2038 if (missing_ok)
2041 }
2042
2043 /* has the statistics expressions? */
2045
2047
2048 /*
2049 * Get the statistics expressions, if any. (NOTE: we do not use the
2050 * relcache versions of the expressions, because we want to display
2051 * non-const-folded expressions.)
2052 */
2054 {
2057
2063 }
2064 else
2065 exprs = NIL;
2066
2067 /* count the number of columns (attributes and expressions) */
2069
2071
2073 {
2078
2079 /*
2080 * Decode the stxkind column so that we know which stats types to
2081 * print.
2082 */
2085 arr = DatumGetArrayTypeP(datum);
2087 ARR_HASNULL(arr) ||
2091
2095
2097 {
2104
2105 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
2106 }
2107
2108 /*
2109 * If any option is disabled, then we'll need to append the types
2110 * clause to show which options are enabled. We omit the types clause
2111 * on purpose when all options are enabled, so a pg_dump/pg_restore
2112 * will create all statistics types on a newer postgres version, if
2113 * the statistics had all options enabled on the original version.
2114 *
2115 * But if the statistics is defined on just a single column, it has to
2116 * be an expression statistics. In that case we don't need to specify
2117 * kinds.
2118 */
2120 (ncolumns > 1))
2121 {
2123
2125
2127 {
2130 }
2131
2133 {
2136 }
2137
2140
2142 }
2143
2145 }
2146
2147 /* decode simple column references */
2149 {
2152
2153 if (colno > 0)
2155
2157
2159 }
2160
2162 statextrec->stxrelid);
2163
2165 {
2169
2171 prettyFlags, 0);
2172
2173 if (colno > 0)
2175
2176 /* Need parens if it's not a bare function call */
2179 else
2181
2182 colno++;
2183 }
2184
2188
2190
2192}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, attname, attnum, buf, DatumGetArrayTypeP, deparse_context_for(), deparse_expression_pretty(), elog, ERROR, fb(), Form_pg_statistic_ext, generate_relation_name(), get_attname(), get_namespace_name_or_temp(), get_relation_name(), GETSTRUCT(), heap_attisnull(), HeapTupleIsValid, i, initStringInfo(), lfirst, list_length(), looks_like_function(), NameStr, NIL, ObjectIdGetDatum(), pfree(), PRETTYFLAG_PAREN, quote_identifier(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), and TextDatumGetCString.
Referenced by pg_get_statisticsobjdef(), pg_get_statisticsobjdef_columns(), and pg_get_statisticsobjdef_string().
◆ pg_get_statisticsobjdef()
| Datum pg_get_statisticsobjdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1969 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 1997 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 2198 of file ruleutils.c.
2199{
2203 Datum datum;
2204 List *context;
2208 char *tmp;
2210
2212
2214 PG_RETURN_NULL();
2215
2216 /* Does the stats object have expressions? */
2218
2219 /* no expressions? we're done */
2221 {
2223 PG_RETURN_NULL();
2224 }
2225
2227
2228 /*
2229 * Get the statistics expressions, and deparse them into text values.
2230 */
2233 tmp = TextDatumGetCString(datum);
2235 pfree(tmp);
2236
2238 statextrec->stxrelid);
2239
2241 {
2245
2247 prettyFlags, 0);
2248
2249 astate = accumArrayResult(astate,
2251 false,
2252 TEXTOID,
2253 CurrentMemoryContext);
2254 }
2255
2257
2259}
References accumArrayResult(), cstring_to_text(), CurrentMemoryContext, deparse_context_for(), deparse_expression_pretty(), fb(), Form_pg_statistic_ext, get_relation_name(), GETSTRUCT(), heap_attisnull(), HeapTupleIsValid, lfirst, makeArrayResult(), NIL, ObjectIdGetDatum(), pfree(), PG_GETARG_OID, PG_RETURN_DATUM, PG_RETURN_NULL, PointerGetDatum, PRETTYFLAG_INDENT, ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), and TextDatumGetCString.
◆ pg_get_statisticsobjdef_string()
Definition at line 1987 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 884 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 898 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 913 of file ruleutils.c.
914{
922 char *tgname;
923 char *tgoldtable;
924 char *tgnewtable;
926 bool isnull;
927
928 /*
929 * Fetch the pg_trigger tuple by the Oid of the trigger
930 */
932
934 Anum_pg_trigger_oid,
937
940
942
944 {
948 }
949
951
952 /*
953 * Start the trigger definition. Note that the trigger's name should never
954 * be schema-qualified, but the trigger rel's name may be.
955 */
957
961 quote_identifier(tgname));
962
969 else
971
973 {
975 findx++;
976 }
978 {
981 else
983 findx++;
984 }
986 {
989 else
991 findx++;
992 /* tgattr is first var-width field, so OK to access directly */
994 {
996
999 {
1001
1007 }
1008 }
1009 }
1011 {
1014 else
1016 findx++;
1017 }
1018
1019 /*
1020 * In non-pretty mode, always schema-qualify the target table name for
1021 * safety. In pretty mode, schema-qualify only if not visible.
1022 */
1024 pretty ?
1027
1029 {
1038 else
1040 }
1041
1043 tgrel->rd_att, &isnull);
1044 if (!isnull)
1046 else
1047 tgoldtable = NULL;
1049 tgrel->rd_att, &isnull);
1050 if (!isnull)
1052 else
1053 tgnewtable = NULL;
1055 {
1059 quote_identifier(tgoldtable));
1062 quote_identifier(tgnewtable));
1063 }
1064
1067 else
1069
1070 /* If the trigger has a WHEN qualification, add that */
1072 tgrel->rd_att, &isnull);
1073 if (!isnull)
1074 {
1075 Node *qual;
1076 char relkind;
1077 deparse_context context;
1081
1083
1085
1087
1088 /* Build minimal OLD and NEW RTEs for the rel */
1092 oldrte->relkind = relkind;
1099
1103 newrte->relkind = relkind;
1110
1111 /* Build two-element rtable */
1119
1120 /* Set up context with one-deep namespace stack */
1134
1136
1138 }
1139
1144
1146 {
1147 char *p;
1149
1151 tgrel->rd_att, &isnull);
1152 if (isnull)
1156 {
1160 /* advance p to next string embedded in tgargs */
1161 while (*p)
1162 p++;
1163 p++;
1164 }
1165 }
1166
1167 /* We deliberately do not put semi-colon at end */
1169
1170 /* Clean up */
1172
1174
1176}
References AccessShareLock, deparse_context::appendparents, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), attname, BTEqualStrategyNumber, deparse_context::buf, buf, deparse_context::colNamesVisible, DatumGetByteaPP, DatumGetName(), elog, ERROR, fastgetattr(), fb(), Form_pg_trigger, generate_function_name(), generate_qualified_relation_name(), generate_relation_name(), get_attname(), GET_PRETTY_FLAGS, get_rel_relkind(), get_rule_expr(), GETSTRUCT(), HeapTupleIsValid, i, deparse_context::indentLevel, deparse_context::inGroupBy, initStringInfo(), list_make1, list_make2, makeAlias(), makeNode, deparse_context::namespaces, NameStr, NIL, ObjectIdGetDatum(), OidIsValid, deparse_context::prettyFlags, PRETTYINDENT_STD, quote_identifier(), deparse_context::resultDesc, RTE_RELATION, ScanKeyInit(), set_rtable_names(), set_simple_column_names(), simple_quote_literal(), stringToNode(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), deparse_context::targetList, TextDatumGetCString, value, VARDATA_ANY(), deparse_context::varInOrderBy, deparse_context::varprefix, deparse_context::windowClause, WRAP_COLUMN_DEFAULT, and deparse_context::wrapColumn.
Referenced by pg_get_triggerdef(), and pg_get_triggerdef_ext().
◆ pg_get_userbyid()
| Datum pg_get_userbyid | ( | PG_FUNCTION_ARGS | ) |
Definition at line 3155 of file ruleutils.c.
3156{
3161
3162 /*
3163 * Allocate space for the result
3164 */
3167
3168 /*
3169 * Get the pg_authid entry and print the result
3170 */
3173 {
3177 }
3178 else
3180
3182}
References fb(), Form_pg_authid, GETSTRUCT(), HeapTupleIsValid, NAMEDATALEN, NameStr, ObjectIdGetDatum(), palloc(), PG_GETARG_OID, PG_RETURN_NAME, ReleaseSysCache(), result, SearchSysCache1(), and sprintf.
◆ pg_get_viewdef()
| Datum pg_get_viewdef | ( | PG_FUNCTION_ARGS | ) |
Definition at line 691 of file ruleutils.c.
692{
693 /* By OID */
695 int prettyFlags;
696 char *res;
697
698 prettyFlags = PRETTYFLAG_INDENT;
699
701
703 PG_RETURN_NULL();
704
706}
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 710 of file ruleutils.c.
711{
712 /* By OID */
715 int prettyFlags;
716 char *res;
717
719
721
723 PG_RETURN_NULL();
724
726}
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 749 of file ruleutils.c.
750{
751 /* By qualified name */
753 int prettyFlags;
755 Oid viewoid;
756 char *res;
757
758 prettyFlags = PRETTYFLAG_INDENT;
759
760 /* Look up view name. Can't lock it - we might not have privileges. */
763
765
767 PG_RETURN_NULL();
768
770}
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 774 of file ruleutils.c.
775{
776 /* By qualified name */
779 int prettyFlags;
781 Oid viewoid;
782 char *res;
783
785
786 /* Look up view name. Can't lock it - we might not have privileges. */
789
791
793 PG_RETURN_NULL();
794
796}
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 802 of file ruleutils.c.
803{
805 char nulls[2];
810
811 /*
812 * Do this first so that string is alloc'd in outer context not SPI's.
813 */
815
816 /*
817 * Connect to SPI manager
818 */
819 SPI_connect();
820
821 /*
822 * On the first call prepare the plan to lookup pg_rewrite. We read
823 * pg_rewrite over the SPI manager instead of using the syscache to be
824 * checked for read access on pg_rewrite.
825 */
827 {
828 Oid argtypes[2];
830
831 argtypes[0] = OIDOID;
832 argtypes[1] = NAMEOID;
838 }
839
840 /*
841 * Get the pg_rewrite tuple for the view's SELECT rule
842 */
845 nulls[0] = ' ';
846 nulls[1] = ' ';
851 {
852 /*
853 * There is no tuple data available here, just keep the output buffer
854 * empty.
855 */
856 }
857 else
858 {
859 /*
860 * Get the rule's definition and put it into executor's memory
861 */
865 }
866
867 /*
868 * Disconnect from SPI manager
869 */
872
875
877}
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 729 of file ruleutils.c.
730{
731 /* By OID */
734 int prettyFlags;
735 char *res;
736
737 /* calling this implies we want pretty printing */
739
741
743 PG_RETURN_NULL();
744
746}
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 5695 of file ruleutils.c.
5696{
5697 /* Free the ancestor list made in push_ancestor_plan */
5699
5700 /* Restore fields changed by push_ancestor_plan */
5702}
References fb(), and list_free().
Referenced by get_name_for_var_field(), and get_parameter().
◆ pop_child_plan()
|
static |
Definition at line 5644 of file ruleutils.c.
5645{
5646 List *ancestors;
5647
5648 /* Get rid of ancestors list cell added by push_child_plan */
5650
5651 /* Restore fields changed by push_child_plan */
5653
5654 /* Make sure dpns->ancestors is right (may be unnecessary) */
5655 dpns->ancestors = ancestors;
5656}
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 3662 of file ruleutils.c.
3664{
3666 int numargs;
3667 Oid *argtypes;
3668 char **argnames;
3677
3679 &argtypes, &argnames, &argmodes);
3680
3681 nlackdefaults = numargs;
3683 {
3685 bool isnull;
3686
3689 &isnull);
3690 if (!isnull)
3691 {
3693
3698 /* nlackdefaults counts only *input* arguments lacking defaults */
3700 }
3701 }
3702
3703 /* Check for special treatment of ordered-set aggregates */
3705 {
3708
3712 proc->oid);
3717 }
3718
3719 argsprinted = 0;
3720 inputargno = 0;
3722 {
3728
3730 {
3732
3733 /*
3734 * For procedures, explicitly mark all argument modes, so as
3735 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3736 */
3739 else
3742 break;
3746 break;
3750 break;
3754 break;
3758 break;
3759 default:
3763 break;
3764 }
3767
3769 continue;
3770
3772 {
3776 }
3779
3781 if (argname && argname[0])
3785 {
3786 Node *expr;
3787
3791
3794 }
3795 argsprinted++;
3796
3797 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3799 {
3800 i--;
3801 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3803 }
3804 }
3805
3807}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, buf, castNode, deparse_expression(), elog, ERROR, fb(), Form_pg_aggregate, Form_pg_proc, format_type_be(), get_func_arg_info(), GETSTRUCT(), HeapTupleIsValid, i, lfirst, list_head(), list_length(), lnext(), NIL, ObjectIdGetDatum(), pfree(), quote_identifier(), ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttr(), and TextDatumGetCString.
Referenced by pg_get_function_arguments(), pg_get_function_identity_arguments(), pg_get_functiondef(), and print_function_rettype().
◆ print_function_rettype()
|
static |
Definition at line 3624 of file ruleutils.c.
3625{
3629
3631
3632 if (proc->proretset)
3633 {
3634 /* It might be a table function; try to print the arguments */
3639 else
3641 }
3642
3644 {
3645 /* Not a table function, so do the normal thing */
3646 if (proc->proretset)
3649 }
3650
3652}
References appendBinaryStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, fb(), Form_pg_proc, format_type_be(), GETSTRUCT(), initStringInfo(), print_function_arguments(), and resetStringInfo().
Referenced by pg_get_function_result(), and pg_get_functiondef().
◆ print_function_sqlbody()
|
static |
Definition at line 3920 of file ruleutils.c.
3921{
3922 int numargs;
3923 Oid *argtypes;
3924 char **argnames;
3927 Datum tmp;
3928 Node *n;
3929
3932 &argtypes, &argnames, &argmodes);
3933 dpns.numargs = numargs;
3934 dpns.argnames = argnames;
3935
3938
3940 {
3941 List *stmts;
3943
3945
3947
3949 {
3951
3952 /* It seems advisable to get at least AccessShareLock on rels */
3958 }
3959
3961 }
3962 else
3963 {
3965
3966 /* It seems advisable to get at least AccessShareLock on rels */
3969 0, WRAP_COLUMN_DEFAULT, 0);
3970 }
3971}
References AcquireRewriteLocks(), appendStringInfoChar(), appendStringInfoString(), buf, castNode, fb(), Form_pg_proc, get_func_arg_info(), get_query_def(), GETSTRUCT(), IsA, lfirst_node, linitial, list_make1, NameStr, PRETTYFLAG_INDENT, proname, pstrdup(), stringToNode(), SysCacheGetAttrNotNull(), TextDatumGetCString, and WRAP_COLUMN_DEFAULT.
Referenced by pg_get_function_sqlbody(), and pg_get_functiondef().
◆ print_function_trftypes()
|
static |
Definition at line 3822 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 13787 of file ruleutils.c.
13788{
13792
13795 {
13798 {
13799 /* If subexpression is NULL, get_rule_expr prints nothing */
13803 }
13804 /* If subexpression is NULL, get_rule_expr prints nothing */
13807 }
13808}
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 13709 of file ruleutils.c.
13710{
13713
13714 for (;;)
13715 {
13717 break;
13719 {
13721 Oid typrelid;
13722 char *fieldname;
13723
13724 /* lookup tuple type */
13725 typrelid = get_typ_typrelid(fstore->resulttype);
13728 format_type_be(fstore->resulttype));
13729
13730 /*
13731 * Print the field name. There should only be one target field in
13732 * stored rules. There could be more than that in executable
13733 * target lists, but this function cannot be used for that case.
13734 */
13736 fieldname = get_attname(typrelid,
13739
13740 /*
13741 * We ignore arg since it should be an uninteresting reference to
13742 * the target column or subcolumn.
13743 */
13745 }
13747 {
13749
13751 break;
13752
13753 printSubscripts(sbsref, context);
13754
13755 /*
13756 * We ignore refexpr since it should be an uninteresting reference
13757 * to the target column or subcolumn.
13758 */
13760 }
13762 {
13764 /* If it's an explicit domain coercion, we're done */
13766 break;
13767 /* Tentatively descend past the CoerceToDomain */
13769 }
13770 else
13771 break;
13772 }
13773
13774 /*
13775 * If we descended past a CoerceToDomain whose argument turned out not to
13776 * be a FieldStore or array assignment, back up to the CoerceToDomain.
13777 * (This is not enough to be fully correct if there are nested implicit
13778 * CoerceToDomains, but such cases shouldn't ever occur.)
13779 */
13782
13783 return node;
13784}
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().
◆ propdata_by_name_cmp()
Definition at line 1867 of file ruleutils.c.
1868{
1873
1875}
References a, b, fb(), lfirst_node, linitial, and strVal.
Referenced by make_propgraphdef_properties().
◆ push_ancestor_plan()
|
static |
Definition at line 5674 of file ruleutils.c.
5676{
5678
5679 /* Save state for restoration later */
5681
5682 /* Build a new ancestor list with just this node's ancestors */
5683 dpns->ancestors =
5686
5687 /* Set attention on selected ancestor */
5689}
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 5627 of file ruleutils.c.
5629{
5630 /* Save state for restoration later */
5632
5633 /* Link current plan node into ancestors list */
5635
5636 /* Set attention on selected child */
5638}
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 13817 of file ruleutils.c.
13818{
13819 /*
13820 * Can avoid quoting if ident starts with a lowercase letter or underscore
13821 * and contains only lowercase letters, digits, and underscores, *and* is
13822 * not any SQL keyword. Otherwise, supply quotes.
13823 */
13826 const char *ptr;
13829
13830 /*
13831 * would like to use <ctype.h> macros here, but they might yield unwanted
13832 * locale-specific results...
13833 */
13835
13837 {
13839
13843 {
13844 /* okay */
13845 }
13846 else
13847 {
13850 nquotes++;
13851 }
13852 }
13853
13856
13858 {
13859 /*
13860 * Check for keyword. We quote keywords except for unreserved ones.
13861 * (In some cases we could avoid quoting a col_name or type_func_name
13862 * keyword, but it seems much harder than it's worth to tell that.)
13863 *
13864 * Note: ScanKeywordLookup() does case-insensitive comparison, but
13865 * that's fine, since we already know we have all-lower-case.
13866 */
13868
13871 }
13872
13875
13877
13881 {
13883
13887 }
13890
13892}
References fb(), ident, palloc(), quote_all_identifiers, result, ScanKeywordCategories, ScanKeywordLookup(), ScanKeywords, and UNRESERVED_KEYWORD.
Referenced by add_cast_to(), appendFunctionName(), ATPrepAlterColumnType(), CheckMyDatabase(), copy_table(), createdb(), CreateSchemaCommand(), decompile_column_index_array(), deparseAnalyzeSql(), deparseColumnRef(), deparseOperatorName(), deparseRelation(), execute_extension_script(), ExplainIndexScanDetails(), ExplainNode(), ExplainTargetRel(), flatten_set_variable_args(), format_operator_extended(), generate_operator_clause(), generate_operator_name(), get_column_alias_list(), get_for_portion_of(), get_from_clause_coldeflist(), get_from_clause_item(), get_graph_label_expr(), get_insert_query_def(), get_json_table(), get_json_table_columns(), get_json_table_nested_columns(), get_json_table_plan(), get_merge_query_def(), get_opclass_name(), get_parameter(), get_path_pattern_expr_def(), 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(), make_propgraphdef_elements(), make_propgraphdef_labels(), make_propgraphdef_properties(), make_ruledef(), NameListToQuotedString(), overexplain_alias(), overexplain_range_table(), pg_get_constraintdef_worker(), pg_get_database_ddl_internal(), pg_get_functiondef(), pg_get_indexdef_worker(), pg_get_partkeydef_worker(), pg_get_role_ddl_internal(), pg_get_statisticsobj_worker(), pg_get_tablespace_ddl_internal(), pg_get_triggerdef_worker(), pg_identify_object(), pgpa_format_index_target(), pgpa_identifier_string(), pgpa_output_relation_name(), PLy_quote_ident(), postgresExplainForeignScan(), postgresImportForeignSchema(), print_function_arguments(), process_extension_updates(), processIndirection(), quote_ident(), quote_object_name(), quote_qualified_identifier(), regdatabaseout(), regnamespaceout(), regoperout(), regroleout(), 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 13901 of file ruleutils.c.
13903{
13905
13911}
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_type_name(), generate_relation_name(), generate_relation_name(), get_qualified_objname(), getObjectDescription(), getObjectIdentityParts(), getOpFamilyDescription(), getOpFamilyIdentity(), getRelationDescription(), getRelationIdentity(), pg_decode_change(), pg_decode_truncate(), pg_get_functiondef(), pg_get_propgraphdef(), 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 9701 of file ruleutils.c.
9702{
9705}
References str.
Referenced by appendContextKeyword(), get_from_clause(), and get_target_list().
◆ resolve_special_varno()
|
static |
Definition at line 8465 of file ruleutils.c.
8467{
8468 Var *var;
8470
8471 /* This function is recursive, so let's be paranoid. */
8472 check_stack_depth();
8473
8474 /* If it's not a Var, invoke the callback. */
8476 {
8477 (*callback) (node, context, callback_arg);
8478 return;
8479 }
8480
8481 /* Find appropriate nesting depth */
8482 var = (Var *) node;
8484 var->varlevelsup);
8485
8486 /*
8487 * If varno is special, recurse. (Don't worry about varnosyn; if we're
8488 * here, we already decided not to use that.)
8489 */
8491 {
8495
8499
8500 /*
8501 * If we're descending to the first child of an Append or MergeAppend,
8502 * update appendparents. This will affect deparsing of all Vars
8503 * appearing within the eventually-resolved subexpression.
8504 */
8506
8513
8516 callback, callback_arg);
8519 return;
8520 }
8522 {
8525
8529
8532 callback, callback_arg);
8534 return;
8535 }
8537 {
8539
8543
8545 callback, callback_arg);
8546 return;
8547 }
8550
8551 /* Not special. Just invoke the callback. */
8552 (*callback) (node, context, callback_arg);
8553}
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_json_agg_constructor(), get_variable(), and resolve_special_varno().
◆ select_rtable_names_for_explain()
Definition at line 4219 of file ruleutils.c.
4220{
4222
4224 dpns.rtable = rtable;
4229 /* We needn't bother computing column aliases yet */
4230
4232}
References fb(), NIL, and set_rtable_names().
Referenced by ExplainPrintPlan().
◆ set_deparse_context_plan()
Definition at line 4189 of file ruleutils.c.
4190{
4192
4193 /* Should always have one-entry namespace list for Plan deparsing */
4196
4197 /* Set our attention on the specific plan node passed in */
4198 dpns->ancestors = ancestors;
4200
4201 /* For ModifyTable, set aliases for OLD and NEW in RETURNING */
4203 {
4206 }
4207
4209}
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 4393 of file ruleutils.c.
4395{
4398
4399 /* Initialize *dpns and fill rtable/ctes links */
4405 dpns->ret_old_alias = query->returningOldAlias;
4406 dpns->ret_new_alias = query->returningNewAlias;
4407
4408 /* Assign a unique relation alias to each RTE */
4410
4411 /* Initialize dpns->rtable_columns to contain zeroed structs */
4416
4417 /* If it's a utility query, it won't have a jointree */
4419 {
4420 /* Detect whether global uniqueness of USING names is needed */
4421 dpns->unique_using =
4423
4424 /*
4425 * Select names for columns merged by USING, via a recursive pass over
4426 * the query jointree.
4427 */
4429 }
4430
4431 /*
4432 * Now assign remaining column aliases for each RTE. We do this in a
4433 * linear scan of the rtable, so as to process RTEs whether or not they
4434 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4435 * etc). JOIN RTEs must be processed after their children, but this is
4436 * okay because they appear later in the rtable list than their children
4437 * (cf Asserts in identify_join_columns()).
4438 */
4440 {
4443
4446 else
4448 }
4449}
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 5516 of file ruleutils.c.
5517{
5519
5520 /*
5521 * We special-case Append and MergeAppend to pretend that the first child
5522 * plan is the OUTER referent; we have to interpret OUTER Vars in their
5523 * tlists according to one of the children, and the first one is the most
5524 * natural choice.
5525 */
5530 else
5532
5535 else
5537
5538 /*
5539 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
5540 * use OUTER because that could someday conflict with the normal meaning.)
5541 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
5542 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
5543 * that as INNER referent.
5544 *
5545 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
5546 * INNER referent. This is the join from the target relation to the data
5547 * source, and all INNER_VAR Vars in other parts of the query refer to its
5548 * targetlist.
5549 *
5550 * For ON CONFLICT DO SELECT/UPDATE we just need the inner tlist to point
5551 * to the excluded expression's tlist. (Similar to the SubqueryScan we
5552 * don't want to reuse OUTER, it's used for RETURNING in some modify table
5553 * cases, although not INSERT .. CONFLICT).
5554 */
5564 {
5567 else
5569 }
5570 else
5572
5577 else
5579
5580 /* Set up referent for INDEX_VAR Vars, if needed */
5587 else
5589}
References CMD_INSERT, CMD_MERGE, fb(), find_recursive_union(), innerPlan, IsA, linitial, list_nth(), NIL, operation, outerPlan, and plan.
Referenced by push_ancestor_plan(), push_child_plan(), and set_deparse_context_plan().
◆ set_join_column_names()
|
static |
Definition at line 4942 of file ruleutils.c.
4944{
4956
4957 /* Look up the previously-filled-in child deparse_columns structs */
4960
4961 /*
4962 * Ensure colinfo->colnames has a slot for each column. (It could be long
4963 * enough already, if we pushed down a name for the last column.) Note:
4964 * it's possible that one or both inputs now have more columns than there
4965 * were when the query was parsed, but we'll deal with that below. We
4966 * only need entries in colnames for pre-existing columns.
4967 */
4971
4972 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4974
4975 /*
4976 * Scan the join output columns, select an alias for each one, and store
4977 * it in colinfo->colnames. If there are USING columns, set_using_names()
4978 * already selected their names, so we can start the loop at the first
4979 * non-merged column.
4980 */
4983 {
4986
4987 /* Join column must refer to at least one input column */
4989
4990 /* Get the child column name */
4995 else
4996 {
4997 /* We're joining system columns --- use eref name */
4999 }
5000
5001 /* If child col has been dropped, no need to assign a join colname */
5003 {
5005 continue;
5006 }
5007
5008 /* In an unnamed join, just report child column names as-is */
5010 {
5013 continue;
5014 }
5015
5016 /* If alias already assigned, that's what to use */
5018 {
5019 /* If user wrote an alias, prefer that over real column name */
5022 else
5023 colname = real_colname;
5024
5025 /* Unique-ify and insert into colinfo */
5027
5030 }
5031
5032 /* Remember if any assigned aliases differ from "real" name */
5035 }
5036
5037 /*
5038 * Calculate number of columns the join would have if it were re-parsed
5039 * now, and create storage for the new_colnames and is_new_col arrays.
5040 *
5041 * Note: colname_is_unique will be consulting new_colnames[] during the
5042 * loops below, so its not-yet-filled entries must be zeroes.
5043 */
5049
5050 /*
5051 * Generating the new_colnames array is a bit tricky since any new columns
5052 * added since parse time must be inserted in the right places. This code
5053 * must match the parser, which will order a join's columns as merged
5054 * columns first (in USING-clause order), then non-merged columns from the
5055 * left input (in attnum order), then non-merged columns from the right
5056 * input (ditto). If one of the inputs is itself a join, its columns will
5057 * be ordered according to the same rule, which means newly-added columns
5058 * might not be at the end. We can figure out what's what by consulting
5059 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
5060 *
5061 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
5062 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
5063 * meanings for the current child RTE.
5064 */
5065
5066 /* Handle merged columns; they are first and can't be new */
5071 {
5072 /* column name is already determined and known unique */
5075
5076 /* build bitmapsets of child attnums of merged columns */
5081
5083 }
5084
5085 /* Handle non-merged left-child columns */
5086 ic = 0;
5088 {
5090
5092 {
5093 /* Advance ic to next non-dropped old column of left child */
5096 ic++;
5098 ic++;
5099 /* If it is a merged column, we already processed it */
5101 continue;
5102 /* Else, advance i to the corresponding existing join column */
5105 i++;
5108 /* Use the already-assigned name of this column */
5110 i++;
5111 }
5112 else
5113 {
5114 /*
5115 * Unique-ify the new child column name and assign, unless we're
5116 * in an unnamed join, in which case just copy
5117 */
5119 {
5125 }
5126 else
5129 }
5130
5132 j++;
5133 }
5134
5135 /* Handle non-merged right-child columns in exactly the same way */
5136 ic = 0;
5138 {
5140
5142 {
5143 /* Advance ic to next non-dropped old column of right child */
5146 ic++;
5148 ic++;
5149 /* If it is a merged column, we already processed it */
5151 continue;
5152 /* Else, advance i to the corresponding existing join column */
5155 i++;
5158 /* Use the already-assigned name of this column */
5160 i++;
5161 }
5162 else
5163 {
5164 /*
5165 * Unique-ify the new child column name and assign, unless we're
5166 * in an unnamed join, in which case just copy
5167 */
5169 {
5175 }
5176 else
5179 }
5180
5182 j++;
5183 }
5184
5185 /* Assert we processed the right number of columns */
5186#ifdef USE_ASSERT_CHECKING
5188 i++;
5191#endif
5192
5193 /* We're now done needing the colinfo's names_hash */
5195
5196 /*
5197 * For a named join, print column aliases if we changed any from the child
5198 * names. Unnamed joins cannot print aliases.
5199 */
5202 else
5204}
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 4739 of file ruleutils.c.
4741{
4742 int ncolumns;
4748
4749 /*
4750 * Construct an array of the current "real" column names of the RTE.
4751 * real_colnames[] will be indexed by physical column number, with NULL
4752 * entries for dropped columns.
4753 */
4755 {
4756 /* Relation --- look to the system catalogs for up-to-date info */
4757 Relation rel;
4758 TupleDesc tupdesc;
4759
4761 tupdesc = RelationGetDescr(rel);
4762
4763 ncolumns = tupdesc->natts;
4765
4767 {
4769
4770 if (attr->attisdropped)
4772 else
4774 }
4776 }
4777 else
4778 {
4779 /* Otherwise get the column names from eref or expandRTE() */
4780 List *colnames;
4782
4783 /*
4784 * Functions returning composites have the annoying property that some
4785 * of the composite type's columns might have been dropped since the
4786 * query was parsed. If possible, use expandRTE() to handle that
4787 * case, since it has the tedious logic needed to find out about
4788 * dropped columns. However, if we're explaining a plan, then we
4789 * don't have rte->functions because the planner thinks that won't be
4790 * needed later, and that breaks expandRTE(). So in that case we have
4791 * to rely on rte->eref, which may lead us to report a dropped
4792 * column's old name; that seems close enough for EXPLAIN's purposes.
4793 *
4794 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4795 * which should be sufficiently up-to-date: no other RTE types can
4796 * have columns get dropped from under them after parsing.
4797 */
4799 {
4800 /* Since we're not creating Vars, rtindex etc. don't matter */
4803 }
4804 else
4805 colnames = rte->eref->colnames;
4806
4807 ncolumns = list_length(colnames);
4809
4810 i = 0;
4812 {
4813 /*
4814 * If the column name we find here is an empty string, then it's a
4815 * dropped column, so change to NULL.
4816 */
4818
4822 i++;
4823 }
4824 }
4825
4826 /*
4827 * Ensure colinfo->colnames has a slot for each column. (It could be long
4828 * enough already, if we pushed down a name for the last column.) Note:
4829 * it's possible that there are now more columns than there were when the
4830 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4831 * We must assign unique aliases to the new columns too, else there could
4832 * be unresolved conflicts when the view/rule is reloaded.
4833 */
4836
4837 /*
4838 * Make sufficiently large new_colnames and is_new_col arrays, too.
4839 *
4840 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4841 * colname_is_unique will not consult that array, which is fine because it
4842 * would only be duplicate effort.
4843 */
4846
4847 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4849
4850 /*
4851 * Scan the columns, select a unique alias for each one, and store it in
4852 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4853 * entries for dropped columns, the latter omits them. Also mark
4854 * new_colnames entries as to whether they are new since parse time; this
4855 * is the case for entries beyond the length of rte->eref->colnames.
4856 */
4859 j = 0;
4861 {
4864
4865 /* Skip dropped columns */
4867 {
4869 continue;
4870 }
4871
4872 /* If alias already assigned, that's what to use */
4874 {
4875 /* If user wrote an alias, prefer that over real column name */
4878 else
4879 colname = real_colname;
4880
4881 /* Unique-ify and insert into colinfo */
4883
4886 }
4887
4888 /* Put names of non-dropped columns in new_colnames[] too */
4890 /* And mark them as new or not */
4892 j++;
4893
4894 /* Remember if any assigned aliases differ from "real" name */
4897 }
4898
4899 /* We're now done needing the colinfo's names_hash */
4901
4902 /*
4903 * Set correct length for new_colnames[] array. (Note: if columns have
4904 * been added, colinfo->num_cols includes them, which is not really quite
4905 * right but is harmless, since any new columns must be at the end where
4906 * they won't affect varattnos of pre-existing columns.)
4907 */
4909
4910 /*
4911 * For a relation RTE, we need only print the alias column names if any
4912 * are different from the underlying "real" names. For a function RTE,
4913 * always emit a complete column alias list; this is to protect against
4914 * possible instability of the default column names (eg, from altering
4915 * parameter names). For tablefunc RTEs, we never print aliases, because
4916 * the column names are part of the clause itself. For other RTE types,
4917 * print if we changed anything OR if there were user-written column
4918 * aliases (since the latter would be part of the underlying "reality").
4919 */
4928 else
4930}
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 4248 of file ruleutils.c.
4250{
4252 HTAB *names_hash;
4254 bool found;
4255 int rtindex;
4257
4259 /* nothing more to do if empty rtable */
4261 return;
4262
4263 /*
4264 * We use a hash table to hold known names, so that this process is O(N)
4265 * not O(N^2) for N names.
4266 */
4272 &hash_ctl,
4274
4275 /* Preload the hash table with names appearing in parent_namespaces */
4277 {
4280
4282 {
4284
4286 continue;
4288 oldname,
4289 HASH_ENTER,
4290 &found);
4291 /* we do not complain about duplicate names in parent namespaces */
4292 hentry->counter = 0;
4293 }
4294 }
4295
4296 /* Now we can scan the rtable */
4297 rtindex = 1;
4299 {
4301 char *refname;
4302
4303 /* Just in case this takes an unreasonable amount of time ... */
4304 CHECK_FOR_INTERRUPTS();
4305
4307 {
4308 /* Ignore unreferenced RTE */
4309 refname = NULL;
4310 }
4312 {
4313 /* If RTE has a user-defined alias, prefer that */
4314 refname = rte->alias->aliasname;
4315 }
4317 {
4318 /* Use the current actual name of the relation */
4320 }
4322 {
4323 /* Unnamed join has no refname */
4324 refname = NULL;
4325 }
4326 else
4327 {
4328 /* Otherwise use whatever the parser assigned */
4329 refname = rte->eref->aliasname;
4330 }
4331
4332 /*
4333 * If the selected name isn't unique, append digits to make it so, and
4334 * make a new hash entry for it once we've got a unique name. For a
4335 * very long input name, we might have to truncate to stay within
4336 * NAMEDATALEN.
4337 */
4338 if (refname)
4339 {
4341 refname,
4342 HASH_ENTER,
4343 &found);
4344 if (found)
4345 {
4346 /* Name already in use, must choose a new one */
4350
4351 do
4352 {
4354 for (;;)
4355 {
4359 break;
4360 /* drop chars from refname to keep all the digits */
4362 refnamelen - 1);
4363 }
4365 modname,
4366 HASH_ENTER,
4367 &found);
4368 } while (found);
4370 refname = modname;
4371 }
4372 else
4373 {
4374 /* Name not previously used, need only initialize hentry */
4375 hentry->counter = 0;
4376 }
4377 }
4378
4380 rtindex++;
4381 }
4382
4383 hash_destroy(names_hash);
4384}
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(), memcpy(), 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 4462 of file ruleutils.c.
4463{
4466
4467 /* Initialize dpns->rtable_columns to contain zeroed structs */
4472
4473 /* Assign unique column aliases within each non-join RTE */
4475 {
4478
4481 }
4482}
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 4574 of file ruleutils.c.
4575{
4577 {
4578 /* nothing to do now */
4579 }
4581 {
4584
4587 }
4589 {
4593 int *leftattnos;
4594 int *rightattnos;
4599
4600 /* Get info about the shape of the join */
4602 leftattnos = colinfo->leftattnos;
4603 rightattnos = colinfo->rightattnos;
4604
4605 /* Look up the not-yet-filled-in child deparse_columns structs */
4608
4609 /*
4610 * If this join is unnamed, then we cannot substitute new aliases at
4611 * this level, so any name requirements pushed down to here must be
4612 * pushed down again to the children.
4613 */
4615 {
4617 {
4619
4621 continue;
4622
4623 /* Push down to left column, unless it's a system column */
4625 {
4628 }
4629
4630 /* Same on the righthand side */
4632 {
4635 }
4636 }
4637 }
4638
4639 /*
4640 * If there's a USING clause, select the USING column names and push
4641 * those names down to the children. We have two strategies:
4642 *
4643 * If dpns->unique_using is true, we force all USING names to be
4644 * unique across the whole query level. In principle we'd only need
4645 * the names of dangerous USING columns to be globally unique, but to
4646 * safely assign all USING names in a single pass, we have to enforce
4647 * the same uniqueness rule for all of them. However, if a USING
4648 * column's name has been pushed down from the parent, we should use
4649 * it as-is rather than making a uniqueness adjustment. This is
4650 * necessary when we're at an unnamed join, and it creates no risk of
4651 * ambiguity. Also, if there's a user-written output alias for a
4652 * merged column, we prefer to use that rather than the input name;
4653 * this simplifies the logic and seems likely to lead to less aliasing
4654 * overall.
4655 *
4656 * If dpns->unique_using is false, we only need USING names to be
4657 * unique within their own join RTE. We still need to honor
4658 * pushed-down names, though.
4659 *
4660 * Though significantly different in results, these two strategies are
4661 * implemented by the same code, with only the difference of whether
4662 * to put assigned names into dpns->using_names.
4663 */
4665 {
4666 /* Copy the input parentUsing list so we don't modify it */
4667 parentUsing = list_copy(parentUsing);
4668
4669 /* USING names must correspond to the first join output columns */
4671 i = 0;
4673 {
4675
4676 /* Assert it's a merged column */
4678
4679 /* Adopt passed-down name if any, else select unique name */
4682 else
4683 {
4684 /* Prefer user-written output alias if any */
4687 /* Make it appropriately unique */
4691 colname);
4692 /* Save it as output column name, too */
4694 }
4695
4696 /* Remember selected names for use later */
4698 parentUsing = lappend(parentUsing, colname);
4699
4700 /* Push down to left column, unless it's a system column */
4702 {
4705 }
4706
4707 /* Same on the righthand side */
4709 {
4712 }
4713
4714 i++;
4715 }
4716 }
4717
4718 /* Mark child deparse_columns structs with correct parentUsing info */
4719 leftcolinfo->parentUsing = parentUsing;
4720 rightcolinfo->parentUsing = parentUsing;
4721
4722 /* Now recursively assign USING column names in children */
4725 }
4726 else
4729}
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 12431 of file ruleutils.c.
12432{
12434
12435 /*
12436 * We always form the string literal according to standard SQL rules.
12437 */
12440 {
12442
12446 }
12448}
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 14357 of file ruleutils.c.
14358{
14360
14364}
References cstring_to_text(), pfree(), result, 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_propgraphdef(), 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 338 of file ruleutils.c.
Referenced by pg_get_ruledef_worker().
◆ plan_getviewrule
|
static |
Definition at line 340 of file ruleutils.c.
Referenced by pg_get_viewdef_worker().
◆ query_getrulebyoid
Definition at line 339 of file ruleutils.c.
Referenced by pg_get_ruledef_worker().
◆ query_getviewrule
|
static |
Definition at line 341 of file ruleutils.c.
Referenced by pg_get_viewdef_worker().
◆ quote_all_identifiers
Definition at line 344 of file ruleutils.c.
Referenced by main(), main(), quote_identifier(), and setup_connection().
