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,
519 deparse_context *context);
521 deparse_context *context);
523 deparse_context *context);
525 deparse_context *context);
527 deparse_context *context);
530 deparse_context *context);
532 deparse_context *context);
543 bool inGroupBy);
553 deparse_context *context,
556 deparse_context *context,
559
560#define only_marker(rte) ((rte)->inh ? "" : "ONLY ")
561
562
563/* ----------
564 * pg_get_ruledef - Do it all and return a text
565 * that could be used as a statement
566 * to recreate the rule
567 * ----------
568 */
569Datum
571{
573 int prettyFlags;
574 char *res;
575
576 prettyFlags = PRETTYFLAG_INDENT;
577
579
581 PG_RETURN_NULL();
582
584}
585
586
587Datum
589{
592 int prettyFlags;
593 char *res;
594
596
598
600 PG_RETURN_NULL();
601
603}
604
605
606static char *
608{
610 char nulls[1];
615
616 /*
617 * Do this first so that string is alloc'd in outer context not SPI's.
618 */
620
621 /*
622 * Connect to SPI manager
623 */
624 SPI_connect();
625
626 /*
627 * On the first call prepare the plan to lookup pg_rewrite. We read
628 * pg_rewrite over the SPI manager instead of using the syscache to be
629 * checked for read access on pg_rewrite.
630 */
632 {
633 Oid argtypes[1];
635
636 argtypes[0] = OIDOID;
642 }
643
644 /*
645 * Get the pg_rewrite tuple for this rule
646 */
648 nulls[0] = ' ';
653 {
654 /*
655 * There is no tuple data available here, just keep the output buffer
656 * empty.
657 */
658 }
659 else
660 {
661 /*
662 * Get the rule's definition and put it into executor's memory
663 */
667 }
668
669 /*
670 * Disconnect from SPI manager
671 */
674
677
679}
680
681
682/* ----------
683 * pg_get_viewdef - Mainly the same thing, but we
684 * only return the SELECT part of a view
685 * ----------
686 */
687Datum
689{
690 /* By OID */
692 int prettyFlags;
693 char *res;
694
695 prettyFlags = PRETTYFLAG_INDENT;
696
698
700 PG_RETURN_NULL();
701
703}
704
705
706Datum
708{
709 /* By OID */
712 int prettyFlags;
713 char *res;
714
716
718
720 PG_RETURN_NULL();
721
723}
724
725Datum
727{
728 /* By OID */
731 int prettyFlags;
732 char *res;
733
734 /* calling this implies we want pretty printing */
736
738
740 PG_RETURN_NULL();
741
743}
744
745Datum
747{
748 /* By qualified name */
750 int prettyFlags;
752 Oid viewoid;
753 char *res;
754
755 prettyFlags = PRETTYFLAG_INDENT;
756
757 /* Look up view name. Can't lock it - we might not have privileges. */
760
762
764 PG_RETURN_NULL();
765
767}
768
769
770Datum
772{
773 /* By qualified name */
776 int prettyFlags;
778 Oid viewoid;
779 char *res;
780
782
783 /* Look up view name. Can't lock it - we might not have privileges. */
786
788
790 PG_RETURN_NULL();
791
793}
794
795/*
796 * Common code for by-OID and by-name variants of pg_get_viewdef
797 */
798static char *
800{
802 char nulls[2];
807
808 /*
809 * Do this first so that string is alloc'd in outer context not SPI's.
810 */
812
813 /*
814 * Connect to SPI manager
815 */
816 SPI_connect();
817
818 /*
819 * On the first call prepare the plan to lookup pg_rewrite. We read
820 * pg_rewrite over the SPI manager instead of using the syscache to be
821 * checked for read access on pg_rewrite.
822 */
824 {
825 Oid argtypes[2];
827
828 argtypes[0] = OIDOID;
829 argtypes[1] = NAMEOID;
835 }
836
837 /*
838 * Get the pg_rewrite tuple for the view's SELECT rule
839 */
842 nulls[0] = ' ';
843 nulls[1] = ' ';
848 {
849 /*
850 * There is no tuple data available here, just keep the output buffer
851 * empty.
852 */
853 }
854 else
855 {
856 /*
857 * Get the rule's definition and put it into executor's memory
858 */
862 }
863
864 /*
865 * Disconnect from SPI manager
866 */
869
872
874}
875
876/* ----------
877 * pg_get_triggerdef - Get the definition of a trigger
878 * ----------
879 */
880Datum
882{
884 char *res;
885
887
889 PG_RETURN_NULL();
890
892}
893
894Datum
896{
899 char *res;
900
902
904 PG_RETURN_NULL();
905
907}
908
909static char *
911{
919 char *tgname;
920 char *tgoldtable;
921 char *tgnewtable;
923 bool isnull;
924
925 /*
926 * Fetch the pg_trigger tuple by the Oid of the trigger
927 */
929
931 Anum_pg_trigger_oid,
934
937
939
941 {
945 }
946
948
949 /*
950 * Start the trigger definition. Note that the trigger's name should never
951 * be schema-qualified, but the trigger rel's name may be.
952 */
954
958 quote_identifier(tgname));
959
966 else
968
970 {
972 findx++;
973 }
975 {
978 else
980 findx++;
981 }
983 {
986 else
988 findx++;
989 /* tgattr is first var-width field, so OK to access directly */
991 {
993
996 {
998
1004 }
1005 }
1006 }
1008 {
1011 else
1013 findx++;
1014 }
1015
1016 /*
1017 * In non-pretty mode, always schema-qualify the target table name for
1018 * safety. In pretty mode, schema-qualify only if not visible.
1019 */
1021 pretty ?
1024
1026 {
1035 else
1037 }
1038
1040 tgrel->rd_att, &isnull);
1041 if (!isnull)
1043 else
1044 tgoldtable = NULL;
1046 tgrel->rd_att, &isnull);
1047 if (!isnull)
1049 else
1050 tgnewtable = NULL;
1052 {
1056 quote_identifier(tgoldtable));
1059 quote_identifier(tgnewtable));
1060 }
1061
1064 else
1066
1067 /* If the trigger has a WHEN qualification, add that */
1069 tgrel->rd_att, &isnull);
1070 if (!isnull)
1071 {
1072 Node *qual;
1073 char relkind;
1074 deparse_context context;
1078
1080
1082
1084
1085 /* Build minimal OLD and NEW RTEs for the rel */
1089 oldrte->relkind = relkind;
1096
1100 newrte->relkind = relkind;
1107
1108 /* Build two-element rtable */
1116
1117 /* Set up context with one-deep namespace stack */
1131
1133
1135 }
1136
1141
1143 {
1144 char *p;
1146
1148 tgrel->rd_att, &isnull);
1149 if (isnull)
1153 {
1157 /* advance p to next string embedded in tgargs */
1158 while (*p)
1159 p++;
1160 p++;
1161 }
1162 }
1163
1164 /* We deliberately do not put semi-colon at end */
1166
1167 /* Clean up */
1169
1171
1173}
1174
1175/* ----------
1176 * pg_get_indexdef - Get the definition of an index
1177 *
1178 * In the extended version, there is a colno argument as well as pretty bool.
1179 * if colno == 0, we want a complete index definition.
1180 * if colno > 0, we only want the Nth index key's variable or expression.
1181 *
1182 * Note that the SQL-function versions of this omit any info about the
1183 * index tablespace; this is intentional because pg_dump wants it that way.
1184 * However pg_get_indexdef_string() includes the index tablespace.
1185 * ----------
1186 */
1187Datum
1189{
1191 int prettyFlags;
1192 char *res;
1193
1194 prettyFlags = PRETTYFLAG_INDENT;
1195
1197 false, false,
1198 false, false,
1199 prettyFlags, true);
1200
1202 PG_RETURN_NULL();
1203
1205}
1206
1207Datum
1209{
1213 int prettyFlags;
1214 char *res;
1215
1217
1219 colno != 0, false,
1220 false, false,
1221 prettyFlags, true);
1222
1224 PG_RETURN_NULL();
1225
1227}
1228
1229/*
1230 * Internal version for use by ALTER TABLE.
1231 * Includes a tablespace clause in the result.
1232 * Returns a palloc'd C string; no pretty-printing.
1233 */
1234char *
1236{
1238 false, false,
1239 true, true,
1240 0, false);
1241}
1242
1243/* Internal version that just reports the key-column definitions */
1244char *
1246{
1247 int prettyFlags;
1248
1250
1252 true, true,
1253 false, false,
1254 prettyFlags, false);
1255}
1256
1257/* Internal version, extensible with flags to control its behavior */
1258char *
1260{
1263 int prettyFlags;
1264
1266
1269 false, false,
1270 prettyFlags, false);
1271}
1272
1273/*
1274 * Internal workhorse to decompile an index definition.
1275 *
1276 * This is now used for exclusion constraints as well: if excludeOps is not
1277 * NULL then it points to an array of exclusion operator OIDs.
1278 */
1279static char *
1284 int prettyFlags, bool missing_ok)
1285{
1286 /* might want a separate isConstraint parameter later */
1297 List *context;
1299 int keyno;
1309
1310 /*
1311 * Fetch the pg_index tuple by the Oid of the index
1312 */
1315 {
1316 if (missing_ok)
1319 }
1321
1324
1325 /* Must get indcollation, indclass, and indoption the hard way */
1327 Anum_pg_index_indcollation);
1329
1331 Anum_pg_index_indclass);
1333
1335 Anum_pg_index_indoption);
1337
1338 /*
1339 * Fetch the pg_class tuple of the index relation
1340 */
1345
1346 /*
1347 * Fetch the pg_am tuple of the index' access method
1348 */
1352 idxrelrec->relam);
1354
1355 /* Fetch the index AM's API struct */
1357
1358 /*
1359 * Get the index expressions, if any. (NOTE: we do not use the relcache
1360 * versions of the expressions and predicate, because we want to display
1361 * non-const-folded expressions.)
1362 */
1364 {
1367
1369 Anum_pg_index_indexprs);
1373 }
1374 else
1376
1378
1380
1381 /*
1382 * Start the index definition. Note that the index's name should never be
1383 * schema-qualified, but the indexed rel's name may be.
1384 */
1386
1388 {
1395 (prettyFlags & PRETTYFLAG_SCHEMA) ?
1399 else /* currently, must be EXCLUDE constraint */
1402 }
1403
1404 /*
1405 * Report the indexed attributes
1406 */
1409 {
1413
1414 /*
1415 * Ignore non-key attributes if told to.
1416 */
1418 break;
1419
1420 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1422 {
1425 }
1426
1427 if (!colno)
1430
1432 {
1433 /* Simple index column */
1436
1438 if (!colno || colno == keyno + 1)
1442 &keycolcollation);
1443 }
1444 else
1445 {
1446 /* expressional index */
1448
1453 /* Deparse */
1455 prettyFlags, 0);
1456 if (!colno || colno == keyno + 1)
1457 {
1458 /* Need parens if it's not a bare function call */
1461 else
1463 }
1466 }
1467
1468 /* Print additional decoration for (selected) key columns */
1470 (!colno || colno == keyno + 1))
1471 {
1476
1477 /* Add collation, if not default for column */
1481
1482 /* Add the operator class name, if not default */
1485
1487 {
1491 }
1492
1493 /* Add options if relevant */
1495 {
1496 /* if it supports sort ordering, report DESC and NULLS opts */
1498 {
1500 /* NULLS FIRST is the default in this case */
1503 }
1504 else
1505 {
1508 }
1509 }
1510
1511 /* Add the exclusion operator if relevant */
1515 keycoltype,
1516 keycoltype));
1517 }
1518 }
1519
1521 {
1523
1526
1527 /*
1528 * If it has options, append "WITH (options)"
1529 */
1532 {
1535 }
1536
1537 /*
1538 * Print tablespace, but only if requested
1539 */
1541 {
1543
1546 {
1551 }
1552 }
1553
1554 /*
1555 * If it's a partial index, decompile and append the predicate
1556 */
1558 {
1559 Node *node;
1562
1563 /* Convert text string to node tree */
1565 Anum_pg_index_indpred);
1569
1570 /* Deparse */
1572 prettyFlags, 0);
1575 else
1577 }
1578 }
1579
1580 /* Clean up */
1584
1586}
1587
1588/* ----------
1589 * pg_get_querydef
1590 *
1591 * Public entry point to deparse one query parsetree.
1592 * The pretty flags are determined by GET_PRETTY_FLAGS(pretty).
1593 *
1594 * The result is a palloc'd C string.
1595 * ----------
1596 */
1597char *
1599{
1601 int prettyFlags;
1602
1604
1606
1608 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
1609
1611}
1612
1613/*
1614 * pg_get_propgraphdef - get the definition of a property graph
1615 */
1616Datum
1618{
1625
1627
1630 PG_RETURN_NULL();
1631
1634
1639
1641
1644
1646
1649
1651}
1652
1653/*
1654 * Generates a VERTEX TABLES (...) or EDGE TABLES (...) clause. Pass in the
1655 * property graph relation OID and the element kind (vertex or edge). Result
1656 * is appended to buf.
1657 */
1658static void
1660{
1663 SysScanDesc scan;
1664 bool first;
1666
1668
1673
1675
1676 first = true;
1678 {
1681 Datum datum;
1682 bool isnull;
1683
1685 continue;
1686
1687 if (first)
1688 {
1690 first = false;
1691 }
1692 else
1694
1699 else
1703
1704 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgekey, RelationGetDescr(pgerel), &isnull);
1705 if (!isnull)
1706 {
1710 }
1711 else
1713
1715 {
1716 Datum srckey;
1717 Datum srcref;
1718 Datum destkey;
1719 Datum destref;
1722
1723 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgesrckey, RelationGetDescr(pgerel), &isnull);
1724 srckey = isnull ? 0 : datum;
1725 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgesrcref, RelationGetDescr(pgerel), &isnull);
1726 srcref = isnull ? 0 : datum;
1727 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgedestkey, RelationGetDescr(pgerel), &isnull);
1728 destkey = isnull ? 0 : datum;
1729 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgedestref, RelationGetDescr(pgerel), &isnull);
1730 destref = isnull ? 0 : datum;
1731
1737 if (srckey)
1738 {
1744 }
1745 else
1748
1754 if (destkey)
1755 {
1761 }
1762 else
1765 }
1766
1768 }
1769 if (!first)
1771
1772 systable_endscan(scan);
1774}
1775
1777{
1780};
1781
1782static int
1784{
1787
1789}
1790
1791/*
1792 * Generates label and properties list. Pass in the element OID, the element
1793 * alias, and the graph relation OID. Result is appended to buf.
1794 */
1795static void
1797{
1800 SysScanDesc scan;
1801 int count;
1804
1806
1811
1812 /*
1813 * We want to output the labels in a deterministic order. So we first
1814 * read all the data, then sort, then print it.
1815 */
1816 scan = systable_beginscan(pglrel, PropgraphElementLabelElementLabelIndexId, true, NULL, 1, scankey);
1817
1819 {
1822
1826
1828 }
1829
1830 systable_endscan(scan);
1832
1834
1835 /* Each element has at least one label. */
1836 Assert(count > 0);
1837
1838 /*
1839 * It is enough for the comparison function to compare just labels, since
1840 * all the labels of an element table should have distinct names.
1841 */
1843
1845 {
1847 {
1848 /* If the default label is the only label, don't print anything. */
1849 if (count != 1)
1851 }
1852 else
1854
1856 }
1857}
1858
1859/*
1860 * Helper function for make_propgraphdef_properties(): Sort (propname, expr)
1861 * pairs by name.
1862 */
1863static int
1865{
1870
1872}
1873
1874/*
1875 * Generates element table properties clause (PROPERTIES (...) or NO
1876 * PROPERTIES). Pass in label OID and element table OID. Result is appended
1877 * to buf.
1878 */
1879static void
1881{
1884 SysScanDesc scan;
1887
1889
1894
1895 /*
1896 * We want to output the properties in a deterministic order. So we first
1897 * read all the data, then sort, then print it.
1898 */
1899 scan = systable_beginscan(plprel, PropgraphLabelPropertyLabelPropIndexId, true, NULL, 1, scankey);
1900
1902 {
1905 bool isnull;
1906 char *tmp;
1907 Node *expr;
1909
1910 exprDatum = heap_getattr(tup, Anum_pg_propgraph_label_property_plpexpr, RelationGetDescr(plprel), &isnull);
1911 Assert(!isnull);
1913 expr = stringToNode(tmp);
1914 pfree(tmp);
1915
1917
1919 }
1920
1921 systable_endscan(scan);
1923
1925
1926 if (outlist)
1927 {
1928 List *context;
1930 bool first = true;
1931
1933
1935
1937 {
1941
1942 if (first)
1943 first = false;
1944 else
1946
1947 if (IsA(expr, Var) && strcmp(propname, get_attname(elrelid, castNode(Var, expr)->varattno, false)) == 0)
1949 else
1953 }
1954
1956 }
1957 else
1959}
1960
1961/*
1962 * pg_get_statisticsobjdef
1963 * Get the definition of an extended statistics object
1964 */
1965Datum
1967{
1969 char *res;
1970
1972
1974 PG_RETURN_NULL();
1975
1977}
1978
1979/*
1980 * Internal version for use by ALTER TABLE.
1981 * Returns a palloc'd C string; no pretty-printing.
1982 */
1983char *
1985{
1987}
1988
1989/*
1990 * pg_get_statisticsobjdef_columns
1991 * Get columns and expressions for an extended statistics object
1992 */
1993Datum
1995{
1997 char *res;
1998
2000
2002 PG_RETURN_NULL();
2003
2005}
2006
2007/*
2008 * Internal workhorse to decompile an extended statistics object.
2009 */
2010static char *
2012{
2016 int colno;
2018 ArrayType *arr;
2019 char *enabled;
2020 Datum datum;
2025 List *context;
2029 int ncolumns;
2030
2032
2034 {
2035 if (missing_ok)
2038 }
2039
2040 /* has the statistics expressions? */
2042
2044
2045 /*
2046 * Get the statistics expressions, if any. (NOTE: we do not use the
2047 * relcache versions of the expressions, because we want to display
2048 * non-const-folded expressions.)
2049 */
2051 {
2054
2060 }
2061 else
2062 exprs = NIL;
2063
2064 /* count the number of columns (attributes and expressions) */
2066
2068
2070 {
2075
2076 /*
2077 * Decode the stxkind column so that we know which stats types to
2078 * print.
2079 */
2082 arr = DatumGetArrayTypeP(datum);
2084 ARR_HASNULL(arr) ||
2088
2092
2094 {
2101
2102 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
2103 }
2104
2105 /*
2106 * If any option is disabled, then we'll need to append the types
2107 * clause to show which options are enabled. We omit the types clause
2108 * on purpose when all options are enabled, so a pg_dump/pg_restore
2109 * will create all statistics types on a newer postgres version, if
2110 * the statistics had all options enabled on the original version.
2111 *
2112 * But if the statistics is defined on just a single column, it has to
2113 * be an expression statistics. In that case we don't need to specify
2114 * kinds.
2115 */
2117 (ncolumns > 1))
2118 {
2120
2122
2124 {
2127 }
2128
2130 {
2133 }
2134
2137
2139 }
2140
2142 }
2143
2144 /* decode simple column references */
2146 {
2149
2150 if (colno > 0)
2152
2154
2156 }
2157
2159 statextrec->stxrelid);
2160
2162 {
2166
2168 prettyFlags, 0);
2169
2170 if (colno > 0)
2172
2173 /* Need parens if it's not a bare function call */
2176 else
2178
2179 colno++;
2180 }
2181
2185
2187
2189}
2190
2191/*
2192 * Generate text array of expressions for statistics object.
2193 */
2194Datum
2196{
2200 Datum datum;
2201 List *context;
2205 char *tmp;
2207
2209
2211 PG_RETURN_NULL();
2212
2213 /* Does the stats object have expressions? */
2215
2216 /* no expressions? we're done */
2218 {
2220 PG_RETURN_NULL();
2221 }
2222
2224
2225 /*
2226 * Get the statistics expressions, and deparse them into text values.
2227 */
2230 tmp = TextDatumGetCString(datum);
2232 pfree(tmp);
2233
2235 statextrec->stxrelid);
2236
2238 {
2242
2244 prettyFlags, 0);
2245
2246 astate = accumArrayResult(astate,
2248 false,
2249 TEXTOID,
2250 CurrentMemoryContext);
2251 }
2252
2254
2256}
2257
2258/*
2259 * pg_get_partkeydef
2260 *
2261 * Returns the partition key specification, ie, the following:
2262 *
2263 * { RANGE | LIST | HASH } (column opt_collation opt_opclass [, ...])
2264 */
2265Datum
2267{
2269 char *res;
2270
2272
2274 PG_RETURN_NULL();
2275
2277}
2278
2279/* Internal version that just reports the column definitions */
2280char *
2282{
2283 int prettyFlags;
2284
2286
2288}
2289
2290/*
2291 * Internal workhorse to decompile a partition key definition.
2292 */
2293static char *
2296{
2298 HeapTuple tuple;
2300 oidvector *partcollation;
2301 List *partexprs;
2303 List *context;
2304 Datum datum;
2306 int keyno;
2309
2312 {
2313 if (missing_ok)
2316 }
2317
2319
2321
2322 /* Must get partclass and partcollation the hard way */
2326
2330
2331
2332 /*
2333 * Get the expressions, if any. (NOTE: we do not use the relcache
2334 * versions of the expressions, because we want to display
2335 * non-const-folded expressions.)
2336 */
2338 {
2341
2346
2350
2352 }
2353 else
2354 partexprs = NIL;
2355
2358
2360
2362 {
2366 break;
2370 break;
2374 break;
2375 default:
2378 }
2379
2384 {
2389
2393 {
2394 /* Simple attribute reference */
2397
2402 &keycolcollation);
2403 }
2404 else
2405 {
2406 /* Expression */
2408
2413
2414 /* Deparse */
2416 prettyFlags, 0);
2417 /* Need parens if it's not a bare function call */
2420 else
2422
2425 }
2426
2427 /* Add collation, if not default for column */
2432
2433 /* Add the operator class name, if not default */
2436 }
2437
2440
2441 /* Clean up */
2442 ReleaseSysCache(tuple);
2443
2445}
2446
2447/*
2448 * pg_get_partition_constraintdef
2449 *
2450 * Returns partition constraint expression as a string for the input relation
2451 */
2452Datum
2454{
2457 int prettyFlags;
2458 List *context;
2460
2462
2463 /* Quick exit if no partition constraint */
2465 PG_RETURN_NULL();
2466
2467 /*
2468 * Deparse and return the constraint expression.
2469 */
2470 prettyFlags = PRETTYFLAG_INDENT;
2473 false, prettyFlags, 0);
2474
2476}
2477
2478/*
2479 * pg_get_partconstrdef_string
2480 *
2481 * Returns the partition constraint as a C-string for the input relation, with
2482 * the given alias. No pretty-printing.
2483 */
2484char *
2486{
2488 List *context;
2489
2492
2494}
2495
2496/*
2497 * pg_get_constraintdef
2498 *
2499 * Returns the definition for the constraint, ie, everything that needs to
2500 * appear after "ALTER TABLE ... ADD CONSTRAINT <constraintname>".
2501 */
2502Datum
2504{
2506 int prettyFlags;
2507 char *res;
2508
2509 prettyFlags = PRETTYFLAG_INDENT;
2510
2512
2514 PG_RETURN_NULL();
2515
2517}
2518
2519Datum
2521{
2524 int prettyFlags;
2525 char *res;
2526
2528
2530
2532 PG_RETURN_NULL();
2533
2535}
2536
2537/*
2538 * Internal version that returns a full ALTER TABLE ... ADD CONSTRAINT command
2539 */
2540char *
2542{
2544}
2545
2546/*
2547 * As of 9.4, we now use an MVCC snapshot for this.
2548 */
2549static char *
2551 int prettyFlags, bool missing_ok)
2552{
2556 SysScanDesc scandesc;
2560
2562 Anum_pg_constraint_oid,
2565
2566 scandesc = systable_beginscan(relation,
2567 ConstraintOidIndexId,
2568 true,
2569 snapshot,
2570 1,
2571 scankey);
2572
2573 /*
2574 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2575 * via SearchSysCache, which works fine.
2576 */
2578
2579 UnregisterSnapshot(snapshot);
2580
2582 {
2583 if (missing_ok)
2584 {
2585 systable_endscan(scandesc);
2588 }
2590 }
2591
2593
2595
2597 {
2599 {
2600 /*
2601 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2602 * constraints, and other types of constraints don't inherit
2603 * anyway so it doesn't matter whether we say ONLY or not. Someday
2604 * we might need to let callers specify whether to put ONLY in the
2605 * command.
2606 */
2610 }
2611 else
2612 {
2613 /* Must be a domain constraint */
2618 }
2619 }
2620
2622 {
2624 {
2626 bool isnull;
2628
2629 /* Start off the constraint definition */
2631
2632 /* Fetch and build referencing-column list */
2634 Anum_pg_constraint_conkey);
2635
2636 /* If it is a temporal foreign key then it uses PERIOD. */
2638
2639 /* add foreign relation name */
2642 NIL));
2643
2644 /* Fetch and build referenced-column list */
2646 Anum_pg_constraint_confkey);
2647
2649
2651
2652 /* Add match type */
2654 {
2656 string = " MATCH FULL";
2657 break;
2659 string = " MATCH PARTIAL";
2660 break;
2662 string = "";
2663 break;
2664 default:
2666 conForm->confmatchtype);
2667 string = ""; /* keep compiler quiet */
2668 break;
2669 }
2671
2672 /* Add ON UPDATE and ON DELETE clauses, if needed */
2674 {
2677 break;
2679 string = "RESTRICT";
2680 break;
2682 string = "CASCADE";
2683 break;
2685 string = "SET NULL";
2686 break;
2688 string = "SET DEFAULT";
2689 break;
2690 default:
2692 conForm->confupdtype);
2694 break;
2695 }
2696 if (string)
2698
2700 {
2703 break;
2705 string = "RESTRICT";
2706 break;
2708 string = "CASCADE";
2709 break;
2711 string = "SET NULL";
2712 break;
2714 string = "SET DEFAULT";
2715 break;
2716 default:
2718 conForm->confdeltype);
2720 break;
2721 }
2722 if (string)
2724
2725 /*
2726 * Add columns specified to SET NULL or SET DEFAULT if
2727 * provided.
2728 */
2730 Anum_pg_constraint_confdelsetcols, &isnull);
2731 if (!isnull)
2732 {
2736 }
2737
2738 break;
2739 }
2742 {
2747
2748 /* Start off the constraint definition */
2751 else
2753
2755
2762
2764
2765 /* Fetch and build target column list */
2767 Anum_pg_constraint_conkey);
2768
2772
2774
2775 /* Build including column list (from pg_index.indkeys) */
2777 Anum_pg_index_indnatts);
2779 {
2780 Datum cols;
2781 Datum *keys;
2782 int nKeys;
2784
2786
2788 Anum_pg_index_indkey);
2789
2791 &keys, NULL, &nKeys);
2792
2794 {
2796
2802 }
2803
2805 }
2807
2808 /* XXX why do we only print these bits if fullCommand? */
2810 {
2813
2815 {
2818 }
2819
2820 /*
2821 * Print the tablespace, unless it's the database default.
2822 * This is to help ALTER TABLE usage of this facility,
2823 * which needs this behavior to recreate exact catalog
2824 * state.
2825 */
2830 }
2831
2832 break;
2833 }
2835 {
2839 Node *expr;
2840 List *context;
2841
2842 /* Fetch constraint expression in parsetree form */
2844 Anum_pg_constraint_conbin);
2845
2848
2849 /* Set up deparsing context for Var nodes in constraint */
2851 {
2852 /* relation constraint */
2854 conForm->conrelid);
2855 }
2856 else
2857 {
2858 /* domain constraint --- can't have Vars */
2859 context = NIL;
2860 }
2861
2863 prettyFlags, 0);
2864
2865 /*
2866 * Now emit the constraint definition, adding NO INHERIT if
2867 * necessary.
2868 *
2869 * There are cases where the constraint expression will be
2870 * fully parenthesized and we don't need the outer parens ...
2871 * but there are other cases where we do need 'em. Be
2872 * conservative for now.
2873 *
2874 * Note that simply checking for leading '(' and trailing ')'
2875 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2876 */
2878 consrc,
2880 break;
2881 }
2883 {
2885 {
2887
2889
2895 }
2897 {
2898 /* conkey is null for domain not-null constraints */
2900 }
2901 break;
2902 }
2903
2905
2906 /*
2907 * There isn't an ALTER TABLE syntax for creating a user-defined
2908 * constraint trigger, but it seems better to print something than
2909 * throw an error; if we throw error then this function couldn't
2910 * safely be applied to all rows of pg_constraint.
2911 */
2913 break;
2915 {
2918 Datum *elems;
2919 int nElems;
2921 Oid *operators;
2922
2923 /* Extract operator OIDs from the pg_constraint tuple */
2925 Anum_pg_constraint_conexclop);
2926
2928 &elems, NULL, &nElems);
2929
2933
2934 /* pg_get_indexdef_worker does the rest */
2935 /* suppress tablespace because pg_dump wants it that way */
2937 pg_get_indexdef_worker(indexOid,
2938 0,
2939 operators,
2940 false,
2941 false,
2942 false,
2943 false,
2944 prettyFlags,
2945 false));
2946 break;
2947 }
2948 default:
2950 break;
2951 }
2952
2957
2958 /* Validated status is irrelevant when the constraint is NOT ENFORCED. */
2963
2964 /* Cleanup */
2965 systable_endscan(scandesc);
2967
2969}
2970
2971
2972/*
2973 * Convert an int16[] Datum into a comma-separated list of column names
2974 * for the indicated relation; append the list to buf. Returns the number
2975 * of keys.
2976 */
2977static int
2980{
2981 Datum *keys;
2982 int nKeys;
2984
2985 /* Extract data from array of int16 */
2987 &keys, NULL, &nKeys);
2988
2990 {
2992
2994
2997 else
3001 }
3002
3003 return nKeys;
3004}
3005
3006
3007/* ----------
3008 * pg_get_expr - Decompile an expression tree
3009 *
3010 * Input: an expression tree in nodeToString form, and a relation OID
3011 *
3012 * Output: reverse-listed expression
3013 *
3014 * Currently, the expression can only refer to a single relation, namely
3015 * the one specified by the second parameter. This is sufficient for
3016 * partial indexes, column default expressions, etc. We also support
3017 * Var-free expressions, for which the OID can be InvalidOid.
3018 *
3019 * If the OID is nonzero but not actually valid, don't throw an error,
3020 * just return NULL. This is a bit questionable, but it's what we've
3021 * done historically, and it can help avoid unwanted failures when
3022 * examining catalog entries for just-deleted relations.
3023 *
3024 * We expect this function to work, or throw a reasonably clean error,
3025 * for any node tree that can appear in a catalog pg_node_tree column.
3026 * Query trees, such as those appearing in pg_rewrite.ev_action, are
3027 * not supported. Nor are expressions in more than one relation, which
3028 * can appear in places like pg_rewrite.ev_qual.
3029 * ----------
3030 */
3031Datum
3033{
3037 int prettyFlags;
3038
3039 prettyFlags = PRETTYFLAG_INDENT;
3040
3044 else
3045 PG_RETURN_NULL();
3046}
3047
3048Datum
3050{
3055 int prettyFlags;
3056
3058
3062 else
3063 PG_RETURN_NULL();
3064}
3065
3068{
3069 Node *node;
3071 Relids relids;
3072 List *context;
3076
3077 /* Convert input pg_node_tree (really TEXT) object to C string */
3079
3080 /* Convert expression to node tree */
3082
3084
3085 /*
3086 * Throw error if the input is a querytree rather than an expression tree.
3087 * While we could support queries here, there seems no very good reason
3088 * to. In most such catalog columns, we'll see a List of Query nodes, or
3089 * even nested Lists, so drill down to a non-List node before checking.
3090 */
3091 tst = node;
3098
3099 /*
3100 * Throw error if the expression contains Vars we won't be able to
3101 * deparse.
3102 */
3105 {
3110 }
3111 else
3112 {
3117 }
3118
3119 /*
3120 * Prepare deparse context if needed. If we are deparsing with a relid,
3121 * we need to transiently open and lock the rel, to make sure it won't go
3122 * away underneath us. (set_relation_column_names would lock it anyway,
3123 * so this isn't really introducing any new behavior.)
3124 */
3126 {
3131 }
3132 else
3133 context = NIL;
3134
3135 /* Deparse */
3137 prettyFlags, 0);
3138
3141
3143}
3144
3145
3146/* ----------
3147 * pg_get_userbyid - Get a user name by roleid and
3148 * fallback to 'unknown (OID=n)'
3149 * ----------
3150 */
3151Datum
3153{
3158
3159 /*
3160 * Allocate space for the result
3161 */
3164
3165 /*
3166 * Get the pg_authid entry and print the result
3167 */
3170 {
3174 }
3175 else
3177
3179}
3180
3181
3182/*
3183 * pg_get_serial_sequence
3184 * Get the name of the sequence used by an identity or serial column,
3185 * formatted suitably for passing to setval, nextval or currval.
3186 * First parameter is not treated as double-quoted, second parameter
3187 * is --- see documentation for reason.
3188 */
3189Datum
3191{
3195 Oid tableOid;
3201 SysScanDesc scan;
3203
3204 /* Look up table name. Can't lock it - we might not have privileges. */
3207
3208 /* Get the number of the column */
3210
3217
3218 /* Search the dependency table for the dependent sequence */
3220
3221 ScanKeyInit(&key[0],
3225 ScanKeyInit(&key[1],
3226 Anum_pg_depend_refobjid,
3228 ObjectIdGetDatum(tableOid));
3229 ScanKeyInit(&key[2],
3233
3235 NULL, 3, key);
3236
3238 {
3240
3241 /*
3242 * Look for an auto dependency (serial column) or internal dependency
3243 * (identity column) of a sequence on a column. (We need the relkind
3244 * test because indexes can also have auto dependencies on columns.)
3245 */
3247 deprec->objsubid == 0 &&
3251 {
3253 break;
3254 }
3255 }
3256
3257 systable_endscan(scan);
3259
3261 {
3263
3265
3267 }
3268
3269 PG_RETURN_NULL();
3270}
3271
3272
3273/*
3274 * pg_get_functiondef
3275 * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
3276 * the specified function.
3277 *
3278 * Note: if you change the output format of this function, be careful not
3279 * to break psql's rules (in \ef and \sf) for identifying the start of the
3280 * function body. To wit: the function body starts on a line that begins with
3281 * "AS ", "BEGIN ", or "RETURN ", and no preceding line will look like that.
3282 */
3283Datum
3285{
3290 Form_pg_proc proc;
3292 Datum tmp;
3293 bool isnull;
3294 const char *prosrc;
3299
3301
3302 /* Look up the function */
3305 PG_RETURN_NULL();
3306
3309
3314
3316
3317 /*
3318 * We always qualify the function name, to ensure the right function gets
3319 * replaced.
3320 */
3328 {
3332 }
3333
3335
3338
3339 /* Emit some miscellaneous options on one line */
3341
3344 switch (proc->provolatile)
3345 {
3348 break;
3351 break;
3353 break;
3354 }
3355
3356 switch (proc->proparallel)
3357 {
3360 break;
3363 break;
3365 break;
3366 }
3367
3368 if (proc->proisstrict)
3370 if (proc->prosecdef)
3372 if (proc->proleakproof)
3374
3375 /* This code for the default cost and rows should match functioncmds.c */
3377 proc->prolang == ClanguageId)
3378 procost = 1;
3379 else
3380 procost = 100;
3383
3384 if (proc->prorows > 0 && proc->prorows != 1000)
3386
3387 if (proc->prosupport)
3388 {
3389 Oid argtypes[1];
3390
3391 /*
3392 * We should qualify the support function's name if it wouldn't be
3393 * resolved by lookup in the current search path.
3394 */
3395 argtypes[0] = INTERNALOID;
3397 generate_function_name(proc->prosupport, 1,
3398 NIL, argtypes,
3400 }
3401
3404
3405 /* Emit any proconfig options, one per line */
3407 if (!isnull)
3408 {
3411
3415
3417 {
3418 Datum d;
3419
3421 -1 /* varlenarray */ ,
3422 -1 /* TEXT's typlen */ ,
3423 false /* TEXT's typbyval */ ,
3425 &isnull);
3426 if (!isnull)
3427 {
3429 char *pos;
3430
3433 continue;
3434 *pos++ = '\0';
3435
3438
3439 /*
3440 * Variables that are marked GUC_LIST_QUOTE were already fully
3441 * quoted by flatten_set_variable_args() before they were put
3442 * into the proconfig array. However, because the quoting
3443 * rules used there aren't exactly like SQL's, we have to
3444 * break the list value apart and then quote the elements as
3445 * string literals. (The elements may be double-quoted as-is,
3446 * but we can't just feed them to the SQL parser; it would do
3447 * the wrong thing with elements that are zero-length or
3448 * longer than NAMEDATALEN.) Also, we need a special case for
3449 * empty lists.
3450 *
3451 * Variables that are not so marked should just be emitted as
3452 * simple string literals. If the variable is not known to
3453 * guc.c, we'll do that; this makes it unsafe to use
3454 * GUC_LIST_QUOTE for extension variables.
3455 */
3457 {
3460
3461 /* Parse string into list of identifiers */
3463 {
3464 /* this shouldn't fail really */
3466 }
3467 /* Special case: represent an empty list as NULL */
3471 {
3473
3477 }
3478 }
3479 else
3482 }
3483 }
3484 }
3485
3486 /* And finally the function definition ... */
3489 {
3491 }
3492 else
3493 {
3495
3497 if (!isnull)
3498 {
3501 }
3502
3504 prosrc = TextDatumGetCString(tmp);
3505
3506 /*
3507 * We always use dollar quoting. Figure out a suitable delimiter.
3508 *
3509 * Since the user is likely to be editing the function body string, we
3510 * shouldn't use a short delimiter that he might easily create a
3511 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3512 * if needed.
3513 */
3520
3524 }
3525
3527
3529
3531}
3532
3533/*
3534 * pg_get_function_arguments
3535 * Get a nicely-formatted list of arguments for a function.
3536 * This is everything that would go between the parentheses in
3537 * CREATE FUNCTION.
3538 */
3539Datum
3541{
3545
3548 PG_RETURN_NULL();
3549
3551
3553
3555
3557}
3558
3559/*
3560 * pg_get_function_identity_arguments
3561 * Get a formatted list of arguments for a function.
3562 * This is everything that would go between the parentheses in
3563 * ALTER FUNCTION, etc. In particular, don't print defaults.
3564 */
3565Datum
3567{
3571
3574 PG_RETURN_NULL();
3575
3577
3579
3581
3583}
3584
3585/*
3586 * pg_get_function_result
3587 * Get a nicely-formatted version of the result type of a function.
3588 * This is what would appear after RETURNS in CREATE FUNCTION.
3589 */
3590Datum
3592{
3596
3599 PG_RETURN_NULL();
3600
3602 {
3604 PG_RETURN_NULL();
3605 }
3606
3608
3610
3612
3614}
3615
3616/*
3617 * Guts of pg_get_function_result: append the function's return type
3618 * to the specified buffer.
3619 */
3620static void
3622{
3626
3628
3629 if (proc->proretset)
3630 {
3631 /* It might be a table function; try to print the arguments */
3636 else
3638 }
3639
3641 {
3642 /* Not a table function, so do the normal thing */
3643 if (proc->proretset)
3646 }
3647
3649}
3650
3651/*
3652 * Common code for pg_get_function_arguments and pg_get_function_result:
3653 * append the desired subset of arguments to buf. We print only TABLE
3654 * arguments when print_table_args is true, and all the others when it's false.
3655 * We print argument defaults only if print_defaults is true.
3656 * Function return value is the number of arguments printed.
3657 */
3658static int
3661{
3663 int numargs;
3664 Oid *argtypes;
3665 char **argnames;
3674
3676 &argtypes, &argnames, &argmodes);
3677
3678 nlackdefaults = numargs;
3680 {
3682 bool isnull;
3683
3686 &isnull);
3687 if (!isnull)
3688 {
3690
3695 /* nlackdefaults counts only *input* arguments lacking defaults */
3697 }
3698 }
3699
3700 /* Check for special treatment of ordered-set aggregates */
3702 {
3705
3709 proc->oid);
3714 }
3715
3716 argsprinted = 0;
3717 inputargno = 0;
3719 {
3725
3727 {
3729
3730 /*
3731 * For procedures, explicitly mark all argument modes, so as
3732 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3733 */
3736 else
3739 break;
3743 break;
3747 break;
3751 break;
3755 break;
3756 default:
3760 break;
3761 }
3764
3766 continue;
3767
3769 {
3773 }
3776
3778 if (argname && argname[0])
3782 {
3783 Node *expr;
3784
3788
3791 }
3792 argsprinted++;
3793
3794 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3796 {
3797 i--;
3798 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3800 }
3801 }
3802
3804}
3805
3806static bool
3808{
3813}
3814
3815/*
3816 * Append used transformed types to specified buffer
3817 */
3818static void
3820{
3821 Oid *trftypes;
3823
3826 {
3828
3831 {
3835 }
3837 }
3838}
3839
3840/*
3841 * Get textual representation of a function argument's default value. The
3842 * second argument of this function is the argument number among all arguments
3843 * (i.e. proallargtypes, *not* proargtypes), starting with 1, because that's
3844 * how information_schema.sql uses it.
3845 */
3846Datum
3848{
3852 Form_pg_proc proc;
3853 int numargs;
3854 Oid *argtypes;
3855 char **argnames;
3859 Node *node;
3863 bool isnull;
3865
3868 PG_RETURN_NULL();
3869
3872 {
3874 PG_RETURN_NULL();
3875 }
3876
3877 nth_inputarg = 0;
3880 nth_inputarg++;
3881
3884 &isnull);
3885 if (isnull)
3886 {
3888 PG_RETURN_NULL();
3889 }
3890
3894
3896
3897 /*
3898 * Calculate index into proargdefaults: proargdefaults corresponds to the
3899 * last N input arguments, where N = pronargdefaults.
3900 */
3902
3904 {
3906 PG_RETURN_NULL();
3907 }
3910
3912
3914}
3915
3916static void
3918{
3919 int numargs;
3920 Oid *argtypes;
3921 char **argnames;
3924 Datum tmp;
3925 Node *n;
3926
3929 &argtypes, &argnames, &argmodes);
3930 dpns.numargs = numargs;
3931 dpns.argnames = argnames;
3932
3935
3937 {
3938 List *stmts;
3940
3942
3944
3946 {
3948
3949 /* It seems advisable to get at least AccessShareLock on rels */
3955 }
3956
3958 }
3959 else
3960 {
3962
3963 /* It seems advisable to get at least AccessShareLock on rels */
3966 0, WRAP_COLUMN_DEFAULT, 0);
3967 }
3968}
3969
3970Datum
3972{
3976 bool isnull;
3977
3979
3980 /* Look up the function */
3983 PG_RETURN_NULL();
3984
3986 if (isnull)
3987 {
3989 PG_RETURN_NULL();
3990 }
3991
3993
3995
3997}
3998
3999
4000/*
4001 * deparse_expression - General utility for deparsing expressions
4002 *
4003 * calls deparse_expression_pretty with all prettyPrinting disabled
4004 */
4005char *
4008{
4010 showimplicit, 0, 0);
4011}
4012
4013/* ----------
4014 * deparse_expression_pretty - General utility for deparsing expressions
4015 *
4016 * expr is the node tree to be deparsed. It must be a transformed expression
4017 * tree (ie, not the raw output of gram.y).
4018 *
4019 * dpcontext is a list of deparse_namespace nodes representing the context
4020 * for interpreting Vars in the node tree. It can be NIL if no Vars are
4021 * expected.
4022 *
4023 * forceprefix is true to force all Vars to be prefixed with their table names.
4024 *
4025 * showimplicit is true to force all implicit casts to be shown explicitly.
4026 *
4027 * Tries to pretty up the output according to prettyFlags and startIndent.
4028 *
4029 * The result is a palloc'd string.
4030 * ----------
4031 */
4032static char *
4036{
4038 deparse_context context;
4039
4047 context.prettyFlags = prettyFlags;
4054
4056
4058}
4059
4060/* ----------
4061 * deparse_context_for - Build deparse context for a single relation
4062 *
4063 * Given the reference name (alias) and OID of a relation, build deparsing
4064 * context for an expression referencing only that relation (as varno 1,
4065 * varlevelsup 0). This is sufficient for many uses of deparse_expression.
4066 * ----------
4067 */
4068List *
4070{
4073
4075
4076 /* Build a minimal RTE for the rel */
4079 rte->relid = relid;
4087
4088 /* Build one-element rtable */
4095
4096 /* Return a one-deep namespace stack */
4098}
4099
4100/*
4101 * deparse_context_for_plan_tree - Build deparse context for a Plan tree
4102 *
4103 * When deparsing an expression in a Plan tree, we use the plan's rangetable
4104 * to resolve names of simple Vars. The initialization of column names for
4105 * this is rather expensive if the rangetable is large, and it'll be the same
4106 * for every expression in the Plan tree; so we do it just once and re-use
4107 * the result of this function for each expression. (Note that the result
4108 * is not usable until set_deparse_context_plan() is applied to it.)
4109 *
4110 * In addition to the PlannedStmt, pass the per-RTE alias names
4111 * assigned by a previous call to select_rtable_names_for_explain.
4112 */
4113List *
4115{
4117
4119
4120 /* Initialize fields that stay the same across the whole plan tree */
4122 dpns->rtable_names = rtable_names;
4126 {
4127 /* Set up the array, indexed by child relid */
4130
4134 {
4137
4141 }
4142 }
4143 else
4145
4146 /*
4147 * Set up column name aliases, ignoring any join RTEs; they don't matter
4148 * because plan trees don't contain any join alias Vars.
4149 */
4151
4152 /* Return a one-deep namespace stack */
4154}
4155
4156/*
4157 * set_deparse_context_plan - Specify Plan node containing expression
4158 *
4159 * When deparsing an expression in a Plan tree, we might have to resolve
4160 * OUTER_VAR, INNER_VAR, or INDEX_VAR references. To do this, the caller must
4161 * provide the parent Plan node. Then OUTER_VAR and INNER_VAR references
4162 * can be resolved by drilling down into the left and right child plans.
4163 * Similarly, INDEX_VAR references can be resolved by reference to the
4164 * indextlist given in a parent IndexOnlyScan node, or to the scan tlist in
4165 * ForeignScan and CustomScan nodes. (Note that we don't currently support
4166 * deparsing of indexquals in regular IndexScan or BitmapIndexScan nodes;
4167 * for those, we can only deparse the indexqualorig fields, which won't
4168 * contain INDEX_VAR Vars.)
4169 *
4170 * The ancestors list is a list of the Plan's parent Plan and SubPlan nodes,
4171 * the most-closely-nested first. This is needed to resolve PARAM_EXEC
4172 * Params. Note we assume that all the Plan nodes share the same rtable.
4173 *
4174 * For a ModifyTable plan, we might also need to resolve references to OLD/NEW
4175 * variables in the RETURNING list, so we copy the alias names of the OLD and
4176 * NEW rows from the ModifyTable plan node.
4177 *
4178 * Once this function has been called, deparse_expression() can be called on
4179 * subsidiary expression(s) of the specified Plan node. To deparse
4180 * expressions of a different Plan node in the same Plan tree, re-call this
4181 * function to identify the new parent Plan node.
4182 *
4183 * The result is the same List passed in; this is a notational convenience.
4184 */
4185List *
4187{
4189
4190 /* Should always have one-entry namespace list for Plan deparsing */
4193
4194 /* Set our attention on the specific plan node passed in */
4195 dpns->ancestors = ancestors;
4197
4198 /* For ModifyTable, set aliases for OLD and NEW in RETURNING */
4200 {
4203 }
4204
4206}
4207
4208/*
4209 * select_rtable_names_for_explain - Select RTE aliases for EXPLAIN
4210 *
4211 * Determine the relation aliases we'll use during an EXPLAIN operation.
4212 * This is just a frontend to set_rtable_names. We have to expose the aliases
4213 * to EXPLAIN because EXPLAIN needs to know the right alias names to print.
4214 */
4215List *
4217{
4219
4221 dpns.rtable = rtable;
4226 /* We needn't bother computing column aliases yet */
4227
4229}
4230
4231/*
4232 * set_rtable_names: select RTE aliases to be used in printing a query
4233 *
4234 * We fill in dpns->rtable_names with a list of names that is one-for-one with
4235 * the already-filled dpns->rtable list. Each RTE name is unique among those
4236 * in the new namespace plus any ancestor namespaces listed in
4237 * parent_namespaces.
4238 *
4239 * If rels_used isn't NULL, only RTE indexes listed in it are given aliases.
4240 *
4241 * Note that this function is only concerned with relation names, not column
4242 * names.
4243 */
4244static void
4247{
4249 HTAB *names_hash;
4251 bool found;
4252 int rtindex;
4254
4256 /* nothing more to do if empty rtable */
4258 return;
4259
4260 /*
4261 * We use a hash table to hold known names, so that this process is O(N)
4262 * not O(N^2) for N names.
4263 */
4269 &hash_ctl,
4271
4272 /* Preload the hash table with names appearing in parent_namespaces */
4274 {
4277
4279 {
4281
4283 continue;
4285 oldname,
4286 HASH_ENTER,
4287 &found);
4288 /* we do not complain about duplicate names in parent namespaces */
4289 hentry->counter = 0;
4290 }
4291 }
4292
4293 /* Now we can scan the rtable */
4294 rtindex = 1;
4296 {
4298 char *refname;
4299
4300 /* Just in case this takes an unreasonable amount of time ... */
4301 CHECK_FOR_INTERRUPTS();
4302
4304 {
4305 /* Ignore unreferenced RTE */
4306 refname = NULL;
4307 }
4309 {
4310 /* If RTE has a user-defined alias, prefer that */
4311 refname = rte->alias->aliasname;
4312 }
4314 {
4315 /* Use the current actual name of the relation */
4317 }
4319 {
4320 /* Unnamed join has no refname */
4321 refname = NULL;
4322 }
4323 else
4324 {
4325 /* Otherwise use whatever the parser assigned */
4326 refname = rte->eref->aliasname;
4327 }
4328
4329 /*
4330 * If the selected name isn't unique, append digits to make it so, and
4331 * make a new hash entry for it once we've got a unique name. For a
4332 * very long input name, we might have to truncate to stay within
4333 * NAMEDATALEN.
4334 */
4335 if (refname)
4336 {
4338 refname,
4339 HASH_ENTER,
4340 &found);
4341 if (found)
4342 {
4343 /* Name already in use, must choose a new one */
4347
4348 do
4349 {
4351 for (;;)
4352 {
4356 break;
4357 /* drop chars from refname to keep all the digits */
4359 refnamelen - 1);
4360 }
4362 modname,
4363 HASH_ENTER,
4364 &found);
4365 } while (found);
4367 refname = modname;
4368 }
4369 else
4370 {
4371 /* Name not previously used, need only initialize hentry */
4372 hentry->counter = 0;
4373 }
4374 }
4375
4377 rtindex++;
4378 }
4379
4380 hash_destroy(names_hash);
4381}
4382
4383/*
4384 * set_deparse_for_query: set up deparse_namespace for deparsing a Query tree
4385 *
4386 * For convenience, this is defined to initialize the deparse_namespace struct
4387 * from scratch.
4388 */
4389static void
4392{
4395
4396 /* Initialize *dpns and fill rtable/ctes links */
4402 dpns->ret_old_alias = query->returningOldAlias;
4403 dpns->ret_new_alias = query->returningNewAlias;
4404
4405 /* Assign a unique relation alias to each RTE */
4407
4408 /* Initialize dpns->rtable_columns to contain zeroed structs */
4413
4414 /* If it's a utility query, it won't have a jointree */
4416 {
4417 /* Detect whether global uniqueness of USING names is needed */
4418 dpns->unique_using =
4420
4421 /*
4422 * Select names for columns merged by USING, via a recursive pass over
4423 * the query jointree.
4424 */
4426 }
4427
4428 /*
4429 * Now assign remaining column aliases for each RTE. We do this in a
4430 * linear scan of the rtable, so as to process RTEs whether or not they
4431 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4432 * etc). JOIN RTEs must be processed after their children, but this is
4433 * okay because they appear later in the rtable list than their children
4434 * (cf Asserts in identify_join_columns()).
4435 */
4437 {
4440
4443 else
4445 }
4446}
4447
4448/*
4449 * set_simple_column_names: fill in column aliases for non-query situations
4450 *
4451 * This handles EXPLAIN and cases where we only have relation RTEs. Without
4452 * a join tree, we can't do anything smart about join RTEs, but we don't
4453 * need to, because EXPLAIN should never see join alias Vars anyway.
4454 * If we find a join RTE we'll just skip it, leaving its deparse_columns
4455 * struct all-zero. If somehow we try to deparse a join alias Var, we'll
4456 * error out cleanly because the struct's num_cols will be zero.
4457 */
4458static void
4460{
4463
4464 /* Initialize dpns->rtable_columns to contain zeroed structs */
4469
4470 /* Assign unique column aliases within each non-join RTE */
4472 {
4475
4478 }
4479}
4480
4481/*
4482 * has_dangerous_join_using: search jointree for unnamed JOIN USING
4483 *
4484 * Merged columns of a JOIN USING may act differently from either of the input
4485 * columns, either because they are merged with COALESCE (in a FULL JOIN) or
4486 * because an implicit coercion of the underlying input column is required.
4487 * In such a case the column must be referenced as a column of the JOIN not as
4488 * a column of either input. And this is problematic if the join is unnamed
4489 * (alias-less): we cannot qualify the column's name with an RTE name, since
4490 * there is none. (Forcibly assigning an alias to the join is not a solution,
4491 * since that will prevent legal references to tables below the join.)
4492 * To ensure that every column in the query is unambiguously referenceable,
4493 * we must assign such merged columns names that are globally unique across
4494 * the whole query, aliasing other columns out of the way as necessary.
4495 *
4496 * Because the ensuing re-aliasing is fairly damaging to the readability of
4497 * the query, we don't do this unless we have to. So, we must pre-scan
4498 * the join tree to see if we have to, before starting set_using_names().
4499 */
4500static bool
4502{
4504 {
4505 /* nothing to do here */
4506 }
4508 {
4511
4513 {
4515 return true;
4516 }
4517 }
4519 {
4521
4522 /* Is it an unnamed JOIN with USING? */
4524 {
4525 /*
4526 * Yes, so check each join alias var to see if any of them are not
4527 * simple references to underlying columns. If so, we have a
4528 * dangerous situation and must pick unique aliases.
4529 */
4531
4532 /* We need only examine the merged columns */
4534 {
4536
4538 return true;
4539 }
4540 }
4541
4542 /* Nope, but inspect children */
4544 return true;
4546 return true;
4547 }
4548 else
4551 return false;
4552}
4553
4554/*
4555 * set_using_names: select column aliases to be used for merged USING columns
4556 *
4557 * We do this during a recursive descent of the query jointree.
4558 * dpns->unique_using must already be set to determine the global strategy.
4559 *
4560 * Column alias info is saved in the dpns->rtable_columns list, which is
4561 * assumed to be filled with pre-zeroed deparse_columns structs.
4562 *
4563 * parentUsing is a list of all USING aliases assigned in parent joins of
4564 * the current jointree node. (The passed-in list must not be modified.)
4565 *
4566 * Note that we do not use per-deparse_columns hash tables in this function.
4567 * The number of names that need to be assigned should be small enough that
4568 * we don't need to trouble with that.
4569 */
4570static void
4572{
4574 {
4575 /* nothing to do now */
4576 }
4578 {
4581
4584 }
4586 {
4590 int *leftattnos;
4591 int *rightattnos;
4596
4597 /* Get info about the shape of the join */
4599 leftattnos = colinfo->leftattnos;
4600 rightattnos = colinfo->rightattnos;
4601
4602 /* Look up the not-yet-filled-in child deparse_columns structs */
4605
4606 /*
4607 * If this join is unnamed, then we cannot substitute new aliases at
4608 * this level, so any name requirements pushed down to here must be
4609 * pushed down again to the children.
4610 */
4612 {
4614 {
4616
4618 continue;
4619
4620 /* Push down to left column, unless it's a system column */
4622 {
4625 }
4626
4627 /* Same on the righthand side */
4629 {
4632 }
4633 }
4634 }
4635
4636 /*
4637 * If there's a USING clause, select the USING column names and push
4638 * those names down to the children. We have two strategies:
4639 *
4640 * If dpns->unique_using is true, we force all USING names to be
4641 * unique across the whole query level. In principle we'd only need
4642 * the names of dangerous USING columns to be globally unique, but to
4643 * safely assign all USING names in a single pass, we have to enforce
4644 * the same uniqueness rule for all of them. However, if a USING
4645 * column's name has been pushed down from the parent, we should use
4646 * it as-is rather than making a uniqueness adjustment. This is
4647 * necessary when we're at an unnamed join, and it creates no risk of
4648 * ambiguity. Also, if there's a user-written output alias for a
4649 * merged column, we prefer to use that rather than the input name;
4650 * this simplifies the logic and seems likely to lead to less aliasing
4651 * overall.
4652 *
4653 * If dpns->unique_using is false, we only need USING names to be
4654 * unique within their own join RTE. We still need to honor
4655 * pushed-down names, though.
4656 *
4657 * Though significantly different in results, these two strategies are
4658 * implemented by the same code, with only the difference of whether
4659 * to put assigned names into dpns->using_names.
4660 */
4662 {
4663 /* Copy the input parentUsing list so we don't modify it */
4664 parentUsing = list_copy(parentUsing);
4665
4666 /* USING names must correspond to the first join output columns */
4668 i = 0;
4670 {
4672
4673 /* Assert it's a merged column */
4675
4676 /* Adopt passed-down name if any, else select unique name */
4679 else
4680 {
4681 /* Prefer user-written output alias if any */
4684 /* Make it appropriately unique */
4688 colname);
4689 /* Save it as output column name, too */
4691 }
4692
4693 /* Remember selected names for use later */
4695 parentUsing = lappend(parentUsing, colname);
4696
4697 /* Push down to left column, unless it's a system column */
4699 {
4702 }
4703
4704 /* Same on the righthand side */
4706 {
4709 }
4710
4711 i++;
4712 }
4713 }
4714
4715 /* Mark child deparse_columns structs with correct parentUsing info */
4716 leftcolinfo->parentUsing = parentUsing;
4717 rightcolinfo->parentUsing = parentUsing;
4718
4719 /* Now recursively assign USING column names in children */
4722 }
4723 else
4726}
4727
4728/*
4729 * set_relation_column_names: select column aliases for a non-join RTE
4730 *
4731 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4732 * If any colnames entries are already filled in, those override local
4733 * choices.
4734 */
4735static void
4738{
4739 int ncolumns;
4745
4746 /*
4747 * Construct an array of the current "real" column names of the RTE.
4748 * real_colnames[] will be indexed by physical column number, with NULL
4749 * entries for dropped columns.
4750 */
4752 {
4753 /* Relation --- look to the system catalogs for up-to-date info */
4754 Relation rel;
4755 TupleDesc tupdesc;
4756
4758 tupdesc = RelationGetDescr(rel);
4759
4760 ncolumns = tupdesc->natts;
4762
4764 {
4766
4767 if (attr->attisdropped)
4769 else
4771 }
4773 }
4774 else
4775 {
4776 /* Otherwise get the column names from eref or expandRTE() */
4777 List *colnames;
4779
4780 /*
4781 * Functions returning composites have the annoying property that some
4782 * of the composite type's columns might have been dropped since the
4783 * query was parsed. If possible, use expandRTE() to handle that
4784 * case, since it has the tedious logic needed to find out about
4785 * dropped columns. However, if we're explaining a plan, then we
4786 * don't have rte->functions because the planner thinks that won't be
4787 * needed later, and that breaks expandRTE(). So in that case we have
4788 * to rely on rte->eref, which may lead us to report a dropped
4789 * column's old name; that seems close enough for EXPLAIN's purposes.
4790 *
4791 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4792 * which should be sufficiently up-to-date: no other RTE types can
4793 * have columns get dropped from under them after parsing.
4794 */
4796 {
4797 /* Since we're not creating Vars, rtindex etc. don't matter */
4800 }
4801 else
4802 colnames = rte->eref->colnames;
4803
4804 ncolumns = list_length(colnames);
4806
4807 i = 0;
4809 {
4810 /*
4811 * If the column name we find here is an empty string, then it's a
4812 * dropped column, so change to NULL.
4813 */
4815
4819 i++;
4820 }
4821 }
4822
4823 /*
4824 * Ensure colinfo->colnames has a slot for each column. (It could be long
4825 * enough already, if we pushed down a name for the last column.) Note:
4826 * it's possible that there are now more columns than there were when the
4827 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4828 * We must assign unique aliases to the new columns too, else there could
4829 * be unresolved conflicts when the view/rule is reloaded.
4830 */
4833
4834 /*
4835 * Make sufficiently large new_colnames and is_new_col arrays, too.
4836 *
4837 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4838 * colname_is_unique will not consult that array, which is fine because it
4839 * would only be duplicate effort.
4840 */
4843
4844 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4846
4847 /*
4848 * Scan the columns, select a unique alias for each one, and store it in
4849 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4850 * entries for dropped columns, the latter omits them. Also mark
4851 * new_colnames entries as to whether they are new since parse time; this
4852 * is the case for entries beyond the length of rte->eref->colnames.
4853 */
4856 j = 0;
4858 {
4861
4862 /* Skip dropped columns */
4864 {
4866 continue;
4867 }
4868
4869 /* If alias already assigned, that's what to use */
4871 {
4872 /* If user wrote an alias, prefer that over real column name */
4875 else
4876 colname = real_colname;
4877
4878 /* Unique-ify and insert into colinfo */
4880
4883 }
4884
4885 /* Put names of non-dropped columns in new_colnames[] too */
4887 /* And mark them as new or not */
4889 j++;
4890
4891 /* Remember if any assigned aliases differ from "real" name */
4894 }
4895
4896 /* We're now done needing the colinfo's names_hash */
4898
4899 /*
4900 * Set correct length for new_colnames[] array. (Note: if columns have
4901 * been added, colinfo->num_cols includes them, which is not really quite
4902 * right but is harmless, since any new columns must be at the end where
4903 * they won't affect varattnos of pre-existing columns.)
4904 */
4906
4907 /*
4908 * For a relation RTE, we need only print the alias column names if any
4909 * are different from the underlying "real" names. For a function RTE,
4910 * always emit a complete column alias list; this is to protect against
4911 * possible instability of the default column names (eg, from altering
4912 * parameter names). For tablefunc RTEs, we never print aliases, because
4913 * the column names are part of the clause itself. For other RTE types,
4914 * print if we changed anything OR if there were user-written column
4915 * aliases (since the latter would be part of the underlying "reality").
4916 */
4925 else
4927}
4928
4929/*
4930 * set_join_column_names: select column aliases for a join RTE
4931 *
4932 * Column alias info is saved in *colinfo, which is assumed to be pre-zeroed.
4933 * If any colnames entries are already filled in, those override local
4934 * choices. Also, names for USING columns were already chosen by
4935 * set_using_names(). We further expect that column alias selection has been
4936 * completed for both input RTEs.
4937 */
4938static void
4941{
4953
4954 /* Look up the previously-filled-in child deparse_columns structs */
4957
4958 /*
4959 * Ensure colinfo->colnames has a slot for each column. (It could be long
4960 * enough already, if we pushed down a name for the last column.) Note:
4961 * it's possible that one or both inputs now have more columns than there
4962 * were when the query was parsed, but we'll deal with that below. We
4963 * only need entries in colnames for pre-existing columns.
4964 */
4968
4969 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4971
4972 /*
4973 * Scan the join output columns, select an alias for each one, and store
4974 * it in colinfo->colnames. If there are USING columns, set_using_names()
4975 * already selected their names, so we can start the loop at the first
4976 * non-merged column.
4977 */
4980 {
4983
4984 /* Join column must refer to at least one input column */
4986
4987 /* Get the child column name */
4992 else
4993 {
4994 /* We're joining system columns --- use eref name */
4996 }
4997
4998 /* If child col has been dropped, no need to assign a join colname */
5000 {
5002 continue;
5003 }
5004
5005 /* In an unnamed join, just report child column names as-is */
5007 {
5010 continue;
5011 }
5012
5013 /* If alias already assigned, that's what to use */
5015 {
5016 /* If user wrote an alias, prefer that over real column name */
5019 else
5020 colname = real_colname;
5021
5022 /* Unique-ify and insert into colinfo */
5024
5027 }
5028
5029 /* Remember if any assigned aliases differ from "real" name */
5032 }
5033
5034 /*
5035 * Calculate number of columns the join would have if it were re-parsed
5036 * now, and create storage for the new_colnames and is_new_col arrays.
5037 *
5038 * Note: colname_is_unique will be consulting new_colnames[] during the
5039 * loops below, so its not-yet-filled entries must be zeroes.
5040 */
5046
5047 /*
5048 * Generating the new_colnames array is a bit tricky since any new columns
5049 * added since parse time must be inserted in the right places. This code
5050 * must match the parser, which will order a join's columns as merged
5051 * columns first (in USING-clause order), then non-merged columns from the
5052 * left input (in attnum order), then non-merged columns from the right
5053 * input (ditto). If one of the inputs is itself a join, its columns will
5054 * be ordered according to the same rule, which means newly-added columns
5055 * might not be at the end. We can figure out what's what by consulting
5056 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
5057 *
5058 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
5059 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
5060 * meanings for the current child RTE.
5061 */
5062
5063 /* Handle merged columns; they are first and can't be new */
5068 {
5069 /* column name is already determined and known unique */
5072
5073 /* build bitmapsets of child attnums of merged columns */
5078
5080 }
5081
5082 /* Handle non-merged left-child columns */
5083 ic = 0;
5085 {
5087
5089 {
5090 /* Advance ic to next non-dropped old column of left child */
5093 ic++;
5095 ic++;
5096 /* If it is a merged column, we already processed it */
5098 continue;
5099 /* Else, advance i to the corresponding existing join column */
5102 i++;
5105 /* Use the already-assigned name of this column */
5107 i++;
5108 }
5109 else
5110 {
5111 /*
5112 * Unique-ify the new child column name and assign, unless we're
5113 * in an unnamed join, in which case just copy
5114 */
5116 {
5122 }
5123 else
5126 }
5127
5129 j++;
5130 }
5131
5132 /* Handle non-merged right-child columns in exactly the same way */
5133 ic = 0;
5135 {
5137
5139 {
5140 /* Advance ic to next non-dropped old column of right child */
5143 ic++;
5145 ic++;
5146 /* If it is a merged column, we already processed it */
5148 continue;
5149 /* Else, advance i to the corresponding existing join column */
5152 i++;
5155 /* Use the already-assigned name of this column */
5157 i++;
5158 }
5159 else
5160 {
5161 /*
5162 * Unique-ify the new child column name and assign, unless we're
5163 * in an unnamed join, in which case just copy
5164 */
5166 {
5172 }
5173 else
5176 }
5177
5179 j++;
5180 }
5181
5182 /* Assert we processed the right number of columns */
5183#ifdef USE_ASSERT_CHECKING
5185 i++;
5188#endif
5189
5190 /* We're now done needing the colinfo's names_hash */
5192
5193 /*
5194 * For a named join, print column aliases if we changed any from the child
5195 * names. Unnamed joins cannot print aliases.
5196 */
5199 else
5201}
5202
5203/*
5204 * colname_is_unique: is colname distinct from already-chosen column names?
5205 *
5206 * dpns is query-wide info, colinfo is for the column's RTE
5207 */
5208static bool
5211{
5214
5215 /*
5216 * If we have a hash table, consult that instead of linearly scanning the
5217 * colinfo's strings.
5218 */
5220 {
5222 colname,
5223 HASH_FIND,
5225 return false;
5226 }
5227 else
5228 {
5229 /* Check against already-assigned column aliases within RTE */
5231 {
5233
5235 return false;
5236 }
5237
5238 /*
5239 * If we're building a new_colnames array, check that too (this will
5240 * be partially but not completely redundant with the previous checks)
5241 */
5243 {
5245
5247 return false;
5248 }
5249
5250 /*
5251 * Also check against names already assigned for parent-join USING
5252 * cols
5253 */
5255 {
5257
5259 return false;
5260 }
5261 }
5262
5263 /*
5264 * Also check against USING-column names that must be globally unique.
5265 * These are not hashed, but there should be few of them.
5266 */
5268 {
5270
5272 return false;
5273 }
5274
5275 return true;
5276}
5277
5278/*
5279 * make_colname_unique: modify colname if necessary to make it unique
5280 *
5281 * dpns is query-wide info, colinfo is for the column's RTE
5282 */
5283static char *
5286{
5287 /*
5288 * If the selected name isn't unique, append digits to make it so. For a
5289 * very long input name, we might have to truncate to stay within
5290 * NAMEDATALEN.
5291 */
5293 {
5297
5298 do
5299 {
5300 i++;
5301 for (;;)
5302 {
5306 break;
5307 /* drop chars from colname to keep all the digits */
5309 colnamelen - 1);
5310 }
5312 colname = modname;
5313 }
5314 return colname;
5315}
5316
5317/*
5318 * expand_colnames_array_to: make colinfo->colnames at least n items long
5319 *
5320 * Any added array entries are initialized to zero.
5321 */
5322static void
5324{
5326 {
5329 else
5331 colinfo->num_cols = n;
5332 }
5333}
5334
5335/*
5336 * build_colinfo_names_hash: optionally construct a hash table for colinfo
5337 */
5338static void
5340{
5344
5345 /*
5346 * Use a hash table only for RTEs with at least 32 columns. (The cutoff
5347 * is somewhat arbitrary, but let's choose it so that this code does get
5348 * exercised in the regression tests.)
5349 */
5351 return;
5352
5353 /*
5354 * Set up the hash table. The entries are just strings with no other
5355 * payload.
5356 */
5362 &hash_ctl,
5364
5365 /*
5366 * Preload the hash table with any names already present (these would have
5367 * come from set_using_names).
5368 */
5370 {
5372
5375 }
5376
5378 {
5380
5383 }
5384
5386 {
5388
5390 }
5391}
5392
5393/*
5394 * add_to_names_hash: add a string to the names_hash, if we're using one
5395 */
5396static void
5398{
5401 name,
5402 HASH_ENTER,
5403 NULL);
5404}
5405
5406/*
5407 * destroy_colinfo_names_hash: destroy hash table when done with it
5408 */
5409static void
5411{
5413 {
5416 }
5417}
5418
5419/*
5420 * identify_join_columns: figure out where columns of a join come from
5421 *
5422 * Fills the join-specific fields of the colinfo struct, except for
5423 * usingNames which is filled later.
5424 */
5425static void
5428{
5433
5434 /* Extract left/right child RT indexes */
5439 else
5446 else
5449
5450 /* Assert children will be processed earlier than join in second pass */
5453
5454 /* Initialize result arrays with zeroes */
5459
5460 /*
5461 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
5462 * Recall that the column(s) merged due to USING are the first column(s)
5463 * of the join output. We need not do anything special while scanning
5464 * joinleftcols, but while scanning joinrightcols we must distinguish
5465 * merged from unmerged columns.
5466 */
5467 jcolno = 0;
5469 {
5471
5473 }
5474 rcolno = 0;
5476 {
5478
5481 else
5483 rcolno++;
5484 }
5486}
5487
5488/*
5489 * get_rtable_name: convenience function to get a previously assigned RTE alias
5490 *
5491 * The RTE must belong to the topmost namespace level in "context".
5492 */
5493static char *
5495{
5497
5500}
5501
5502/*
5503 * set_deparse_plan: set up deparse_namespace to parse subexpressions
5504 * of a given Plan node
5505 *
5506 * This sets the plan, outer_plan, inner_plan, outer_tlist, inner_tlist,
5507 * and index_tlist fields. Caller must already have adjusted the ancestors
5508 * list if necessary. Note that the rtable, subplans, and ctes fields do
5509 * not need to change when shifting attention to different plan nodes in a
5510 * single plan tree.
5511 */
5512static void
5514{
5516
5517 /*
5518 * We special-case Append and MergeAppend to pretend that the first child
5519 * plan is the OUTER referent; we have to interpret OUTER Vars in their
5520 * tlists according to one of the children, and the first one is the most
5521 * natural choice.
5522 */
5527 else
5529
5532 else
5534
5535 /*
5536 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
5537 * use OUTER because that could someday conflict with the normal meaning.)
5538 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
5539 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
5540 * that as INNER referent.
5541 *
5542 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
5543 * INNER referent. This is the join from the target relation to the data
5544 * source, and all INNER_VAR Vars in other parts of the query refer to its
5545 * targetlist.
5546 *
5547 * For ON CONFLICT DO SELECT/UPDATE we just need the inner tlist to point
5548 * to the excluded expression's tlist. (Similar to the SubqueryScan we
5549 * don't want to reuse OUTER, it's used for RETURNING in some modify table
5550 * cases, although not INSERT .. CONFLICT).
5551 */
5561 {
5564 else
5566 }
5567 else
5569
5574 else
5576
5577 /* Set up referent for INDEX_VAR Vars, if needed */
5584 else
5586}
5587
5588/*
5589 * Locate the ancestor plan node that is the RecursiveUnion generating
5590 * the WorkTableScan's work table. We can match on wtParam, since that
5591 * should be unique within the plan tree.
5592 */
5595{
5597
5599 {
5601
5605 }
5607 wtscan->wtParam);
5609}
5610
5611/*
5612 * push_child_plan: temporarily transfer deparsing attention to a child plan
5613 *
5614 * When expanding an OUTER_VAR or INNER_VAR reference, we must adjust the
5615 * deparse context in case the referenced expression itself uses
5616 * OUTER_VAR/INNER_VAR. We modify the top stack entry in-place to avoid
5617 * affecting levelsup issues (although in a Plan tree there really shouldn't
5618 * be any).
5619 *
5620 * Caller must provide a local deparse_namespace variable to save the
5621 * previous state for pop_child_plan.
5622 */
5623static void
5626{
5627 /* Save state for restoration later */
5629
5630 /* Link current plan node into ancestors list */
5632
5633 /* Set attention on selected child */
5635}
5636
5637/*
5638 * pop_child_plan: undo the effects of push_child_plan
5639 */
5640static void
5642{
5643 List *ancestors;
5644
5645 /* Get rid of ancestors list cell added by push_child_plan */
5647
5648 /* Restore fields changed by push_child_plan */
5650
5651 /* Make sure dpns->ancestors is right (may be unnecessary) */
5652 dpns->ancestors = ancestors;
5653}
5654
5655/*
5656 * push_ancestor_plan: temporarily transfer deparsing attention to an
5657 * ancestor plan
5658 *
5659 * When expanding a Param reference, we must adjust the deparse context
5660 * to match the plan node that contains the expression being printed;
5661 * otherwise we'd fail if that expression itself contains a Param or
5662 * OUTER_VAR/INNER_VAR/INDEX_VAR variable.
5663 *
5664 * The target ancestor is conveniently identified by the ListCell holding it
5665 * in dpns->ancestors.
5666 *
5667 * Caller must provide a local deparse_namespace variable to save the
5668 * previous state for pop_ancestor_plan.
5669 */
5670static void
5673{
5675
5676 /* Save state for restoration later */
5678
5679 /* Build a new ancestor list with just this node's ancestors */
5680 dpns->ancestors =
5683
5684 /* Set attention on selected ancestor */
5686}
5687
5688/*
5689 * pop_ancestor_plan: undo the effects of push_ancestor_plan
5690 */
5691static void
5693{
5694 /* Free the ancestor list made in push_ancestor_plan */
5696
5697 /* Restore fields changed by push_ancestor_plan */
5699}
5700
5701
5702/* ----------
5703 * make_ruledef - reconstruct the CREATE RULE command
5704 * for a given pg_rewrite tuple
5705 * ----------
5706 */
5707static void
5709 int prettyFlags)
5710{
5711 char *rulename;
5712 char ev_type;
5714 bool is_instead;
5717 List *actions;
5722 bool isnull;
5723
5724 /*
5725 * Get the attribute values from the rules tuple
5726 */
5729 Assert(!isnull);
5731
5734 Assert(!isnull);
5736
5739 Assert(!isnull);
5741
5744 Assert(!isnull);
5746
5750
5757
5759
5760 /*
5761 * Build the rules definition text
5762 */
5764 quote_identifier(rulename));
5765
5768 else
5770
5771 /* The event the rule is fired for */
5772 switch (ev_type)
5773 {
5774 case '1':
5777 break;
5778
5779 case '2':
5781 break;
5782
5783 case '3':
5785 break;
5786
5787 case '4':
5789 break;
5790
5791 default:
5795 rulename, ev_type)));
5796 break;
5797 }
5798
5799 /* The relation the rule is fired on */
5801 (prettyFlags & PRETTYFLAG_SCHEMA) ?
5804
5805 /* If the rule has an event qualification, add it */
5807 {
5808 Node *qual;
5809 Query *query;
5810 deparse_context context;
5812
5816
5818
5819 /*
5820 * We need to make a context for recognizing any Vars in the qual
5821 * (which can only be references to OLD and NEW). Use the rtable of
5822 * the first query in the action list for this purpose.
5823 */
5825
5826 /*
5827 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5828 * into the SELECT, and that's what we need to look at. (Ugly kluge
5829 * ... try to fix this when we redesign querytrees.)
5830 */
5832
5833 /* Must acquire locks right away; see notes in get_query_def() */
5835
5842 context.prettyFlags = prettyFlags;
5849
5851
5853 }
5854
5856
5857 /* The INSTEAD keyword (if so) */
5858 if (is_instead)
5860
5861 /* Finally the rules actions */
5863 {
5865 Query *query;
5866
5868 foreach(action, actions)
5869 {
5872 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5873 if (prettyFlags)
5875 else
5877 }
5879 }
5880 else
5881 {
5882 Query *query;
5883
5886 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5888 }
5889
5891}
5892
5893
5894/* ----------
5895 * make_viewdef - reconstruct the SELECT part of a
5896 * view rewrite rule
5897 * ----------
5898 */
5899static void
5901 int prettyFlags, int wrapColumn)
5902{
5903 Query *query;
5904 char ev_type;
5906 bool is_instead;
5909 List *actions;
5913 bool isnull;
5914
5915 /*
5916 * Get the attribute values from the rules tuple
5917 */
5920 Assert(!isnull);
5922
5925 Assert(!isnull);
5927
5930 Assert(!isnull);
5932
5936
5941
5943 {
5944 /* keep output buffer empty and leave */
5945 return;
5946 }
5947
5949
5950 if (ev_type != '1' || !is_instead ||
5952 {
5953 /* keep output buffer empty and leave */
5954 return;
5955 }
5956
5958
5960 prettyFlags, wrapColumn, 0);
5962
5964}
5965
5966
5967/* ----------
5968 * get_query_def - Parse back one query parsetree
5969 *
5970 * query: parsetree to be displayed
5971 * buf: output text is appended to buf
5972 * parentnamespace: list (initially empty) of outer-level deparse_namespace's
5973 * resultDesc: if not NULL, the output tuple descriptor for the view
5974 * represented by a SELECT query. We use the column names from it
5975 * to label SELECT output columns, in preference to names in the query
5976 * colNamesVisible: true if the surrounding context cares about the output
5977 * column names at all (as, for example, an EXISTS() context does not);
5978 * when false, we can suppress dummy column labels such as "?column?"
5979 * prettyFlags: bitmask of PRETTYFLAG_XXX options
5980 * wrapColumn: maximum line length, or -1 to disable wrapping
5981 * startIndent: initial indentation amount
5982 * ----------
5983 */
5984static void
5988{
5989 deparse_context context;
5991 int rtable_size;
5992
5993 /* Guard against excessively long or deeply-nested queries */
5994 CHECK_FOR_INTERRUPTS();
5995 check_stack_depth();
5996
5997 rtable_size = query->hasGroupRTE ?
6000
6001 /*
6002 * Replace any Vars in the query's targetlist and havingQual that
6003 * reference GROUP outputs with the underlying grouping expressions.
6004 *
6005 * We can safely pass NULL for the root here. Preserving varnullingrels
6006 * makes no difference to the deparsed source text.
6007 */
6008 if (query->hasGroupRTE)
6009 {
6012 query->havingQual =
6014 }
6015
6016 /*
6017 * Before we begin to examine the query, acquire locks on referenced
6018 * relations, and fix up deleted columns in JOIN RTEs. This ensures
6019 * consistent results. Note we assume it's OK to scribble on the passed
6020 * querytree!
6021 *
6022 * We are only deparsing the query (we are not about to execute it), so we
6023 * only need AccessShareLock on the relations it mentions.
6024 */
6026
6033 rtable_size != 1);
6034 context.prettyFlags = prettyFlags;
6035 context.wrapColumn = wrapColumn;
6037 context.colNamesVisible = colNamesVisible;
6041
6043
6045 {
6047 /* We set context.resultDesc only if it's a SELECT */
6048 context.resultDesc = resultDesc;
6049 get_select_query_def(query, &context);
6050 break;
6051
6053 get_update_query_def(query, &context);
6054 break;
6055
6057 get_insert_query_def(query, &context);
6058 break;
6059
6061 get_delete_query_def(query, &context);
6062 break;
6063
6065 get_merge_query_def(query, &context);
6066 break;
6067
6070 break;
6071
6073 get_utility_query_def(query, &context);
6074 break;
6075
6076 default:
6078 query->commandType);
6079 break;
6080 }
6081}
6082
6083/* ----------
6084 * get_values_def - Parse back a VALUES list
6085 * ----------
6086 */
6087static void
6089{
6093
6095
6097 {
6101
6104 else
6106
6109 {
6111
6114 else
6116
6117 /*
6118 * Print the value. Whole-row Vars need special treatment.
6119 */
6121 }
6123 }
6124}
6125
6126/* ----------
6127 * get_with_clause - Parse back a WITH clause
6128 * ----------
6129 */
6130static void
6132{
6135 ListCell *l;
6136
6138 return;
6139
6141 {
6144 }
6145
6146 if (query->hasRecursive)
6148 else
6151 {
6153
6156 if (cte->aliascolnames)
6157 {
6158 bool first = true;
6160
6163 {
6164 if (first)
6165 first = false;
6166 else
6170 }
6172 }
6175 {
6177 break;
6180 break;
6183 break;
6184 }
6189 true,
6191 context->indentLevel);
6195
6196 if (cte->search_clause)
6197 {
6198 bool first = true;
6200
6202 cte->search_clause->search_breadth_first ? "BREADTH" : "DEPTH");
6203
6205 {
6206 if (first)
6207 first = false;
6208 else
6212 }
6213
6215 }
6216
6217 if (cte->cycle_clause)
6218 {
6219 bool first = true;
6221
6223
6225 {
6226 if (first)
6227 first = false;
6228 else
6232 }
6233
6235
6236 {
6239
6240 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
6242 {
6247 }
6248 }
6249
6251 }
6252
6254 }
6255
6257 {
6260 }
6261 else
6263}
6264
6265/* ----------
6266 * get_select_query_def - Parse back a SELECT parsetree
6267 * ----------
6268 */
6269static void
6271{
6274 ListCell *l;
6275
6276 /* Insert the WITH clause if given */
6277 get_with_clause(query, context);
6278
6279 /* Subroutines may need to consult the SELECT targetlist and windowClause */
6282
6283 /*
6284 * If the Query node has a setOperations tree, then it's the top level of
6285 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
6286 * fields are interesting in the top query itself.
6287 */
6289 {
6291 /* ORDER BY clauses must be simple in this case */
6293 }
6294 else
6295 {
6296 get_basic_select_query(query, context);
6298 }
6299
6300 /* Add the ORDER BY clause if given */
6302 {
6306 force_colno, context);
6307 }
6308
6309 /*
6310 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
6311 * standard spelling of LIMIT.
6312 */
6314 {
6318 }
6320 {
6322 {
6323 /*
6324 * The limitCount arg is a c_expr, so it needs parens. Simple
6325 * literals and function expressions would not need parens, but
6326 * unfortunately it's hard to tell if the expression will be
6327 * printed as a simple literal like 123 or as a typecast
6328 * expression, like '-123'::int4. The grammar accepts the former
6329 * without quoting, but not the latter.
6330 */
6337 }
6338 else
6339 {
6345 else
6347 }
6348 }
6349
6350 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
6351 if (query->hasForUpdate)
6352 {
6354 {
6356
6357 /* don't print implicit clauses */
6359 continue;
6360
6361 appendContextKeyword(context,
6364
6367 context)));
6372 }
6373 }
6374}
6375
6376static char *
6378{
6379 switch (strength)
6380 {
6382 /* we intentionally throw an error for LCS_NONE */
6384 (int) strength);
6385 break;
6387 return " FOR KEY SHARE";
6389 return " FOR SHARE";
6391 return " FOR NO KEY UPDATE";
6393 return " FOR UPDATE";
6394 }
6396}
6397
6398/*
6399 * Detect whether query looks like SELECT ... FROM VALUES(),
6400 * with no need to rename the output columns of the VALUES RTE.
6401 * If so, return the VALUES RTE. Otherwise return NULL.
6402 */
6405{
6408
6409 /*
6410 * We want to detect a match even if the Query also contains OLD or NEW
6411 * rule RTEs. So the idea is to scan the rtable and see if there is only
6412 * one inFromCl RTE that is a VALUES RTE.
6413 */
6415 {
6417
6419 {
6423 }
6425 continue; /* ignore rule entries */
6426 else
6428 }
6429
6430 /*
6431 * We don't need to check the targetlist in any great detail, because
6432 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6433 * appear inside auto-generated sub-queries with very restricted
6434 * structure. However, DefineView might have modified the tlist by
6435 * injecting new column aliases, or we might have some other column
6436 * aliases forced by a resultDesc. We can only simplify if the RTE's
6437 * column names match the names that get_target_list() would select.
6438 */
6440 {
6442 int colno;
6443
6446 colno = 0;
6448 {
6451 char *colname;
6452
6455
6456 /* compute name that get_target_list would use for column */
6457 colno++;
6460 else
6461 colname = tle->resname;
6462
6463 /* does it match the VALUES RTE? */
6466 }
6467 }
6468
6470}
6471
6472static void
6474{
6478 ListCell *l;
6479
6481 {
6484 }
6485
6486 /*
6487 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6488 * VALUES part. This reverses what transformValuesClause() did at parse
6489 * time.
6490 */
6493 {
6495 return;
6496 }
6497
6498 /*
6499 * Build up the query string - first we say SELECT
6500 */
6501 if (query->isReturn)
6503 else
6505
6506 /* Add the DISTINCT clause if given */
6508 {
6509 if (query->hasDistinctOn)
6510 {
6514 {
6516
6519 false, context);
6521 }
6523 }
6524 else
6526 }
6527
6528 /* Then we tell what to select (the targetlist) */
6530
6531 /* Add the FROM clause if needed */
6533
6534 /* Add the WHERE clause if given */
6536 {
6540 }
6541
6542 /* Add the GROUP BY clause if given */
6544 {
6546
6551
6554
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);
12391 else
12394}
12395
12396/*
12397 * simple_quote_literal - Format a string as a SQL literal, append to buf
12398 */
12399static void
12401{
12403
12404 /*
12405 * We always form the string literal according to standard SQL rules.
12406 */
12409 {
12411
12415 }
12417}
12418
12419
12420/* ----------
12421 * get_sublink_expr - Parse back a sublink
12422 * ----------
12423 */
12424static void
12426{
12431
12434 else
12436
12437 /*
12438 * Note that we print the name of only the first operator, when there are
12439 * multiple combining operators. This is an approximation that could go
12440 * wrong in various scenarios (operators in different schemas, renamed
12441 * operators, etc) but there is not a whole lot we can do about it, since
12442 * the syntax allows only one operator to be shown.
12443 */
12445 {
12447 {
12448 /* single combining operator */
12450
12455 }
12457 {
12458 /* multiple combining operators, = or <> cases */
12460 ListCell *l;
12461
12465 {
12467
12475 }
12477 }
12479 {
12480 /* multiple combining operators, < <= > >= cases */
12482
12489 }
12490 else
12493 }
12494
12496
12498 {
12501 break;
12502
12506 else
12508 break;
12509
12512 break;
12513
12516 break;
12517
12522 break;
12523
12525 default:
12528 break;
12529 }
12530
12533
12536 context->indentLevel);
12537
12540 else
12542}
12543
12544
12545/* ----------
12546 * get_xmltable - Parse back a XMLTABLE function
12547 * ----------
12548 */
12549static void
12551{
12553
12555
12557 {
12559 *lc2;
12560 bool first = true;
12561
12564 {
12567
12568 if (!first)
12570 else
12571 first = false;
12572
12574 {
12578 }
12579 else
12580 {
12583 }
12584 }
12586 }
12587
12593
12595 {
12596 ListCell *l1;
12597 ListCell *l2;
12598 ListCell *l3;
12599 ListCell *l4;
12600 ListCell *l5;
12601 int colnum = 0;
12602
12604 forfive(l1, tf->colnames, l2, tf->coltypes, l3, tf->coltypmods,
12605 l4, tf->colexprs, l5, tf->coldefexprs)
12606 {
12612 bool ordinality = (tf->ordinalitycol == colnum);
12614
12615 if (colnum > 0)
12617 colnum++;
12618
12620 ordinality ? "FOR ORDINALITY" :
12621 format_type_with_typemod(typid, typmod));
12622 if (ordinality)
12623 continue;
12624
12626 {
12630 }
12632 {
12636 }
12637 if (notnull)
12639 }
12640 }
12641
12643}
12644
12645/*
12646 * get_json_table_nested_columns - Parse back nested JSON_TABLE columns
12647 */
12648static void
12652{
12654 {
12656
12659
12665 }
12667 {
12669
12671 needcomma);
12673 true);
12674 }
12675}
12676
12677/*
12678 * get_json_table_columns - Parse back JSON_TABLE columns
12679 */
12680static void
12682 deparse_context *context,
12684{
12690 int colnum = 0;
12691
12694
12697
12699 lc_coltype, tf->coltypes,
12700 lc_coltypmod, tf->coltypmods,
12701 lc_colvalexpr, tf->colvalexprs)
12702 {
12704 JsonExpr *colexpr;
12705 Oid typid;
12706 int32 typmod;
12707 bool ordinality;
12709
12713
12714 /* Skip columns that don't belong to this scan. */
12716 {
12717 colnum++;
12718 continue;
12719 }
12721 break;
12722
12725
12726 colnum++;
12727
12728 ordinality = !colexpr;
12729
12731
12733 ordinality ? "FOR ORDINALITY" :
12734 format_type_with_typemod(typid, typmod));
12735 if (ordinality)
12736 continue;
12737
12738 /*
12739 * Set default_behavior to guide get_json_expr_options() on whether to
12740 * emit the ON ERROR / EMPTY clauses.
12741 */
12743 {
12746 }
12747 else
12748 {
12750 {
12753
12755
12759 " FORMAT JSONB" : " FORMAT JSON");
12760 }
12761
12763 }
12764
12766
12768
12770 }
12771
12774 scan->colMin >= 0);
12775
12778
12780}
12781
12782/* ----------
12783 * get_json_table - Parse back a JSON_TABLE function
12784 * ----------
12785 */
12786static void
12788{
12792
12794
12797
12799
12801
12803
12805
12807
12809 {
12811 *lc2;
12813
12816
12819
12822 {
12826
12828
12832 );
12833 }
12834
12837 }
12838
12840 showimplicit);
12841
12844
12847
12849}
12850
12851/* ----------
12852 * get_tablefunc - Parse back a table function
12853 * ----------
12854 */
12855static void
12857{
12858 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12859
12864}
12865
12866/* ----------
12867 * get_from_clause - Parse back a FROM clause
12868 *
12869 * "prefix" is the keyword that denotes the start of the list of FROM
12870 * elements. It is FROM when used to parse back SELECT and UPDATE, but
12871 * is USING when parsing back DELETE.
12872 * ----------
12873 */
12874static void
12876{
12878 bool first = true;
12879 ListCell *l;
12880
12881 /*
12882 * We use the query's jointree as a guide to what to print. However, we
12883 * must ignore auto-added RTEs that are marked not inFromCl. (These can
12884 * only appear at the top level of the jointree, so it's sufficient to
12885 * check here.) This check also ensures we ignore the rule pseudo-RTEs
12886 * for NEW and OLD.
12887 */
12889 {
12891
12893 {
12896
12898 continue;
12899 }
12900
12901 if (first)
12902 {
12903 appendContextKeyword(context, prefix,
12905 first = false;
12906
12907 get_from_clause_item(jtnode, query, context);
12908 }
12909 else
12910 {
12912
12914
12915 /*
12916 * Put the new FROM item's text into itembuf so we can decide
12917 * after we've got it whether or not it needs to go on a new line.
12918 */
12921
12922 get_from_clause_item(jtnode, query, context);
12923
12924 /* Restore context's output buffer */
12926
12927 /* Consider line-wrapping if enabled */
12929 {
12930 /* Does the new item start with a new line? */
12932 {
12933 /* If so, we shouldn't add anything */
12934 /* instead, remove any trailing spaces currently in buf */
12936 }
12937 else
12938 {
12940
12941 /* Locate the start of the current line in the buffer */
12945 else
12946 trailing_nl++;
12947
12948 /*
12949 * Add a newline, plus some indentation, if the new item
12950 * would cause an overflow.
12951 */
12954 PRETTYINDENT_STD,
12955 PRETTYINDENT_VAR);
12956 }
12957 }
12958
12959 /* Add the new item */
12961
12962 /* clean up */
12964 }
12965 }
12966}
12967
12968static void
12970{
12973
12975 {
12980
12983
12984 /* Print the FROM item proper */
12986 {
12988 /* Normal relation RTE */
12992 context->namespaces));
12993 break;
12995 /* Subquery RTE */
12998 true,
13000 context->indentLevel);
13002 break;
13004 /* Function RTE */
13006
13007 /*
13008 * Omit ROWS FROM() syntax for just one function, unless it
13009 * has both a coldeflist and WITH ORDINALITY. If it has both,
13010 * we must use ROWS FROM() syntax to avoid ambiguity about
13011 * whether the coldeflist includes the ordinality column.
13012 */
13015 {
13017 /* we'll print the coldeflist below, if it has one */
13018 }
13019 else
13020 {
13023
13024 /*
13025 * If all the function calls in the list are to unnest,
13026 * and none need a coldeflist, then collapse the list back
13027 * down to UNNEST(args). (If we had more than one
13028 * built-in unnest function, this would get more
13029 * difficult.)
13030 *
13031 * XXX This is pretty ugly, since it makes not-terribly-
13032 * future-proof assumptions about what the parser would do
13033 * with the output; but the alternative is to emit our
13034 * nonstandard ROWS FROM() notation for what might have
13035 * been a perfectly spec-compliant multi-argument
13036 * UNNEST().
13037 */
13040 {
13042
13045 rtfunc->funccolnames != NIL)
13046 {
13048 break;
13049 }
13050 }
13051
13053 {
13055
13057 {
13060
13062 }
13063
13067 }
13068 else
13069 {
13071
13074 {
13076
13081 {
13082 /* Reconstruct the column definition list */
13084 get_from_clause_coldeflist(rtfunc,
13085 NULL,
13086 context);
13087 }
13088 funcno++;
13089 }
13091 }
13092 /* prevent printing duplicate coldeflist below */
13094 }
13097 break;
13100 break;
13107 {
13108 bool first = true;
13109
13111 {
13112 if (!first)
13114 else
13115 first = false;
13116
13120 }
13121 }
13123 break;
13125 /* Values list RTE */
13129 break;
13132 break;
13133 default:
13135 break;
13136 }
13137
13138 /* Print the relation alias, if needed */
13140
13141 /* Print the column definitions or aliases, if needed */
13143 {
13144 /* Reconstruct the columndef list, which is also the aliases */
13146 }
13147 else
13148 {
13149 /* Else print column aliases as needed */
13151 }
13152
13153 /* Tablesample clause must go after any alias */
13156 }
13158 {
13162
13166
13169
13171
13173 {
13177 -PRETTYINDENT_STD,
13178 PRETTYINDENT_STD,
13179 PRETTYINDENT_JOIN);
13180 else
13182 -PRETTYINDENT_STD,
13183 PRETTYINDENT_STD,
13184 PRETTYINDENT_JOIN);
13185 break;
13188 -PRETTYINDENT_STD,
13189 PRETTYINDENT_STD,
13190 PRETTYINDENT_JOIN);
13191 break;
13194 -PRETTYINDENT_STD,
13195 PRETTYINDENT_STD,
13196 PRETTYINDENT_JOIN);
13197 break;
13200 -PRETTYINDENT_STD,
13201 PRETTYINDENT_STD,
13202 PRETTYINDENT_JOIN);
13203 break;
13204 default:
13207 }
13208
13214
13216 {
13218 bool first = true;
13219
13221 /* Use the assigned names, not what's in usingClause */
13223 {
13225
13226 if (first)
13227 first = false;
13228 else
13231 }
13233
13237 }
13239 {
13246 }
13248 {
13249 /* If we didn't say CROSS JOIN above, we must provide an ON */
13251 }
13252
13255
13256 /* Yes, it's correct to put alias after the right paren ... */
13258 {
13259 /*
13260 * Note that it's correct to emit an alias clause if and only if
13261 * there was one originally. Otherwise we'd be converting a named
13262 * join to unnamed or vice versa, which creates semantic
13263 * subtleties we don't want. However, we might print a different
13264 * alias name than was there originally.
13265 */
13268 context)));
13270 }
13271 }
13272 else
13275}
13276
13277/*
13278 * get_rte_alias - print the relation's alias, if needed
13279 *
13280 * If printed, the alias is preceded by a space, or by " AS " if use_as is true.
13281 */
13282static void
13284 deparse_context *context)
13285{
13290
13292 {
13293 /* Always print alias if user provided one */
13295 }
13297 {
13298 /* Always print alias if we need to print column aliases */
13300 }
13302 {
13303 /*
13304 * No need to print alias if it's same as relation name (this would
13305 * normally be the case, but not if set_rtable_names had to resolve a
13306 * conflict).
13307 */
13310 }
13312 {
13313 /*
13314 * For a function RTE, always print alias. This covers possible
13315 * renaming of the function and/or instability of the FigureColname
13316 * rules for things that aren't simple functions. Note we'd need to
13317 * force it anyway for the columndef list case.
13318 */
13320 }
13323 {
13324 /*
13325 * For a subquery, always print alias. This makes the output
13326 * SQL-spec-compliant, even though we allow such aliases to be omitted
13327 * on input.
13328 */
13330 }
13332 {
13333 /*
13334 * No need to print alias if it's same as CTE name (this would
13335 * normally be the case, but not if set_rtable_names had to resolve a
13336 * conflict).
13337 */
13340 }
13341
13345 quote_identifier(refname));
13346}
13347
13348/*
13349 * get_for_portion_of - print FOR PORTION OF if needed
13350 * XXX: Newlines would help here, at least when pretty-printing. But then the
13351 * alias and SET will be on their own line with a leading space.
13352 */
13353static void
13355{
13356 if (forPortionOf)
13357 {
13360
13361 /*
13362 * Try to write it as FROM ... TO ... if we received it that way,
13363 * otherwise (targetRange).
13364 */
13366 {
13371 }
13372 else
13373 {
13377 }
13378 }
13379}
13380
13381/*
13382 * get_column_alias_list - print column alias list for an RTE
13383 *
13384 * Caller must already have printed the relation's alias name.
13385 */
13386static void
13388{
13391 bool first = true;
13392
13393 /* Don't print aliases if not needed */
13395 return;
13396
13398 {
13400
13401 if (first)
13402 {
13404 first = false;
13405 }
13406 else
13409 }
13410 if (!first)
13412}
13413
13414/*
13415 * get_from_clause_coldeflist - reproduce FROM clause coldeflist
13416 *
13417 * When printing a top-level coldeflist (which is syntactically also the
13418 * relation's column alias list), use column names from colinfo. But when
13419 * printing a coldeflist embedded inside ROWS FROM(), we prefer to use the
13420 * original coldeflist's names, which are available in rtfunc->funccolnames.
13421 * Pass NULL for colinfo to select the latter behavior.
13422 *
13423 * The coldeflist is appended immediately (no space) to buf. Caller is
13424 * responsible for ensuring that an alias or AS is present before it.
13425 */
13426static void
13429 deparse_context *context)
13430{
13432 ListCell *l1;
13433 ListCell *l2;
13434 ListCell *l3;
13435 ListCell *l4;
13437
13439
13440 i = 0;
13441 forfour(l1, rtfunc->funccoltypes,
13442 l2, rtfunc->funccoltypmods,
13443 l3, rtfunc->funccolcollations,
13444 l4, rtfunc->funccolnames)
13445 {
13450
13453 else
13455
13457
13466 generate_collation_name(attcollation));
13467
13468 i++;
13469 }
13470
13472}
13473
13474/*
13475 * get_tablesample_def - print a TableSampleClause
13476 */
13477static void
13479{
13481 Oid argtypes[1];
13482 int nargs;
13483 ListCell *l;
13484
13485 /*
13486 * We should qualify the handler's function name if it wouldn't be
13487 * resolved by lookup in the current search path.
13488 */
13489 argtypes[0] = INTERNALOID;
13492 NIL, argtypes,
13494
13495 nargs = 0;
13497 {
13498 if (nargs++ > 0)
13501 }
13503
13505 {
13509 }
13510}
13511
13512/*
13513 * get_opclass_name - fetch name of an index operator class
13514 *
13515 * The opclass name is appended (after a space) to buf.
13516 *
13517 * Output is suppressed if the opclass is the default for the given
13518 * actual_datatype. (If you don't want this behavior, just pass
13519 * InvalidOid for actual_datatype.)
13520 */
13521static void
13524{
13528 char *nspname;
13529
13534
13537 {
13538 /* Okay, we need the opclass name. Do we need to qualify it? */
13542 else
13543 {
13546 quote_identifier(nspname),
13548 }
13549 }
13551}
13552
13553/*
13554 * generate_opclass_name
13555 * Compute the name to display for an opclass specified by OID
13556 *
13557 * The result includes all necessary quoting and schema-prefixing.
13558 */
13559char *
13561{
13563
13566
13568}
13569
13570/*
13571 * processIndirection - take care of array and subfield assignment
13572 *
13573 * We strip any top-level FieldStore or assignment SubscriptingRef nodes that
13574 * appear in the input, printing them as decoration for the base column
13575 * name (which we assume the caller just printed). We might also need to
13576 * strip CoerceToDomain nodes, but only ones that appear above assignment
13577 * nodes.
13578 *
13579 * Returns the subexpression that's to be assigned.
13580 */
13583{
13586
13587 for (;;)
13588 {
13590 break;
13592 {
13594 Oid typrelid;
13595 char *fieldname;
13596
13597 /* lookup tuple type */
13598 typrelid = get_typ_typrelid(fstore->resulttype);
13601 format_type_be(fstore->resulttype));
13602
13603 /*
13604 * Print the field name. There should only be one target field in
13605 * stored rules. There could be more than that in executable
13606 * target lists, but this function cannot be used for that case.
13607 */
13609 fieldname = get_attname(typrelid,
13612
13613 /*
13614 * We ignore arg since it should be an uninteresting reference to
13615 * the target column or subcolumn.
13616 */
13618 }
13620 {
13622
13624 break;
13625
13626 printSubscripts(sbsref, context);
13627
13628 /*
13629 * We ignore refexpr since it should be an uninteresting reference
13630 * to the target column or subcolumn.
13631 */
13633 }
13635 {
13637 /* If it's an explicit domain coercion, we're done */
13639 break;
13640 /* Tentatively descend past the CoerceToDomain */
13642 }
13643 else
13644 break;
13645 }
13646
13647 /*
13648 * If we descended past a CoerceToDomain whose argument turned out not to
13649 * be a FieldStore or array assignment, back up to the CoerceToDomain.
13650 * (This is not enough to be fully correct if there are nested implicit
13651 * CoerceToDomains, but such cases shouldn't ever occur.)
13652 */
13655
13656 return node;
13657}
13658
13659static void
13661{
13665
13668 {
13671 {
13672 /* If subexpression is NULL, get_rule_expr prints nothing */
13676 }
13677 /* If subexpression is NULL, get_rule_expr prints nothing */
13680 }
13681}
13682
13683/*
13684 * quote_identifier - Quote an identifier only if needed
13685 *
13686 * When quotes are needed, we palloc the required space; slightly
13687 * space-wasteful but well worth it for notational simplicity.
13688 */
13689const char *
13691{
13692 /*
13693 * Can avoid quoting if ident starts with a lowercase letter or underscore
13694 * and contains only lowercase letters, digits, and underscores, *and* is
13695 * not any SQL keyword. Otherwise, supply quotes.
13696 */
13699 const char *ptr;
13702
13703 /*
13704 * would like to use <ctype.h> macros here, but they might yield unwanted
13705 * locale-specific results...
13706 */
13708
13710 {
13712
13716 {
13717 /* okay */
13718 }
13719 else
13720 {
13723 nquotes++;
13724 }
13725 }
13726
13729
13731 {
13732 /*
13733 * Check for keyword. We quote keywords except for unreserved ones.
13734 * (In some cases we could avoid quoting a col_name or type_func_name
13735 * keyword, but it seems much harder than it's worth to tell that.)
13736 *
13737 * Note: ScanKeywordLookup() does case-insensitive comparison, but
13738 * that's fine, since we already know we have all-lower-case.
13739 */
13741
13744 }
13745
13748
13750
13754 {
13756
13760 }
13763
13765}
13766
13767/*
13768 * quote_qualified_identifier - Quote a possibly-qualified identifier
13769 *
13770 * Return a name of the form qualifier.ident, or just ident if qualifier
13771 * is NULL, quoting each component if necessary. The result is palloc'd.
13772 */
13773char *
13776{
13778
13784}
13785
13786/*
13787 * get_relation_name
13788 * Get the unqualified name of a relation specified by OID
13789 *
13790 * This differs from the underlying get_rel_name() function in that it will
13791 * throw error instead of silently returning NULL if the OID is bad.
13792 */
13793static char *
13795{
13797
13801}
13802
13803/*
13804 * generate_relation_name
13805 * Compute the name to display for a relation specified by OID
13806 *
13807 * The result includes all necessary quoting and schema-prefixing.
13808 *
13809 * If namespaces isn't NIL, it must be a list of deparse_namespace nodes.
13810 * We will forcibly qualify the relation name if it equals any CTE name
13811 * visible in the namespace list.
13812 */
13813static char *
13815{
13816 HeapTuple tp;
13821 char *nspname;
13823
13829
13830 /* Check for conflicting CTE name */
13833 {
13836
13838 {
13840
13842 {
13844 break;
13845 }
13846 }
13848 break;
13849 }
13850
13851 /* Otherwise, qualify the name if not visible in search path */
13854
13857 else
13858 nspname = NULL;
13859
13861
13862 ReleaseSysCache(tp);
13863
13865}
13866
13867/*
13868 * generate_qualified_relation_name
13869 * Compute the name to display for a relation specified by OID
13870 *
13871 * As above, but unconditionally schema-qualify the name.
13872 */
13873static char *
13875{
13876 HeapTuple tp;
13879
13884
13887 ReleaseSysCache(tp);
13888
13890}
13891
13892/*
13893 * generate_function_name
13894 * Compute the name to display for a function specified by OID,
13895 * given that it is being called with the specified actual arg names and
13896 * types. (Those matter because of ambiguous-function resolution rules.)
13897 *
13898 * If we're dealing with a potentially variadic function (in practice, this
13899 * means a FuncExpr or Aggref, not some other way of calling a function), then
13900 * has_variadic must specify whether variadic arguments have been merged,
13901 * and *use_variadic_p will be set to indicate whether to print VARIADIC in
13902 * the output. For non-FuncExpr cases, has_variadic should be false and
13903 * use_variadic_p can be NULL.
13904 *
13905 * inGroupBy must be true if we're deparsing a GROUP BY clause.
13906 *
13907 * The result includes all necessary quoting and schema-prefixing.
13908 */
13909static char *
13912 bool inGroupBy)
13913{
13919 char *nspname;
13929
13935
13936 /*
13937 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
13938 * qualification of some function names within GROUP BY.
13939 */
13940 if (inGroupBy)
13941 {
13944 }
13945
13946 /*
13947 * Determine whether VARIADIC should be printed. We must do this first
13948 * since it affects the lookup rules in func_get_detail().
13949 *
13950 * We always print VARIADIC if the function has a merged variadic-array
13951 * argument. Note that this is always the case for functions taking a
13952 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
13953 * and printed the array elements as separate arguments, the call could
13954 * match a newer non-VARIADIC function.
13955 */
13957 {
13958 /* Parser should not have set funcvariadic unless fn is variadic */
13962 }
13963 else
13964 {
13967 }
13968
13969 /*
13970 * The idea here is to schema-qualify only if the parser would fail to
13971 * resolve the correct function given the unqualified func name with the
13972 * specified argtypes and VARIADIC flag. But if we already decided to
13973 * force qualification, then we can skip the lookup and pretend we didn't
13974 * find it.
13975 */
13978 NIL, argnames, nargs, argtypes,
13980 &fgc_flags,
13984 else
13985 {
13988 }
13989
13993 p_funcid == funcid)
13994 nspname = NULL;
13995 else
13997
13999
14001
14003}
14004
14005/*
14006 * generate_operator_name
14007 * Compute the name to display for an operator specified by OID,
14008 * given that it is being called with the specified actual arg types.
14009 * (Arg types matter because of ambiguous-operator resolution rules.
14010 * Pass InvalidOid for unused arg of a unary operator.)
14011 *
14012 * The result includes all necessary quoting and schema-prefixing,
14013 * plus the OPERATOR() decoration needed to use a qualified operator name
14014 * in an expression.
14015 */
14016static char *
14018{
14022 char *oprname;
14023 char *nspname;
14025
14027
14033
14034 /*
14035 * The idea here is to schema-qualify only if the parser would fail to
14036 * resolve the correct operator given the unqualified op name with the
14037 * specified argtypes.
14038 */
14040 {
14041 case 'b':
14043 true, -1);
14044 break;
14045 case 'l':
14047 true, -1);
14048 break;
14049 default:
14052 break;
14053 }
14054
14056 nspname = NULL;
14057 else
14058 {
14061 }
14062
14064
14065 if (nspname)
14067
14070
14072
14074}
14075
14076/*
14077 * generate_operator_clause --- generate a binary-operator WHERE clause
14078 *
14079 * This is used for internally-generated-and-executed SQL queries, where
14080 * precision is essential and readability is secondary. The basic
14081 * requirement is to append "leftop op rightop" to buf, where leftop and
14082 * rightop are given as strings and are assumed to yield types leftoptype
14083 * and rightoptype; the operator is identified by OID. The complexity
14084 * comes from needing to be sure that the parser will select the desired
14085 * operator when the query is parsed. We always name the operator using
14086 * OPERATOR(schema.op) syntax, so as to avoid search-path uncertainties.
14087 * We have to emit casts too, if either input isn't already the input type
14088 * of the operator; else we are at the mercy of the parser's heuristics for
14089 * ambiguous-operator resolution. The caller must ensure that leftop and
14090 * rightop are suitable arguments for a cast operation; it's best to insert
14091 * parentheses if they aren't just variables or parameters.
14092 */
14093void
14098{
14101 char *oprname;
14102 char *nspname;
14103
14110
14112
14121
14123}
14124
14125/*
14126 * Add a cast specification to buf. We spell out the type name the hard way,
14127 * intentionally not using format_type_be(). This is to avoid corner cases
14128 * for CHARACTER, BIT, and perhaps other types, where specifying the type
14129 * using SQL-standard syntax results in undesirable data truncation. By
14130 * doing it this way we can be certain that the cast will have default (-1)
14131 * target typmod.
14132 */
14133static void
14135{
14139 char *nspname;
14140
14145
14148
14151
14153}
14154
14155/*
14156 * generate_qualified_type_name
14157 * Compute the name to display for a type specified by OID
14158 *
14159 * This is different from format_type_be() in that we unconditionally
14160 * schema-qualify the name. That also means no special syntax for
14161 * SQL-standard type names ... although in current usage, this should
14162 * only get used for domains, so such cases wouldn't occur anyway.
14163 */
14164static char *
14166{
14167 HeapTuple tp;
14170 char *nspname;
14172
14178
14180 if (!nspname)
14182 typtup->typnamespace);
14183
14185
14186 ReleaseSysCache(tp);
14187
14189}
14190
14191/*
14192 * generate_collation_name
14193 * Compute the name to display for a collation specified by OID
14194 *
14195 * The result includes all necessary quoting and schema-prefixing.
14196 */
14197char *
14199{
14200 HeapTuple tp;
14202 char *collname;
14203 char *nspname;
14205
14211
14214 else
14215 nspname = NULL;
14216
14218
14219 ReleaseSysCache(tp);
14220
14222}
14223
14224/*
14225 * Given a C string, produce a TEXT datum.
14226 *
14227 * We assume that the input was palloc'd and may be freed.
14228 */
14231{
14233
14237}
14238
14239/*
14240 * Generate a C string representing a relation options from text[] datum.
14241 */
14242void
14244{
14248
14251
14253 {
14258
14259 /*
14260 * Each array element should have the form name=value. If the "=" is
14261 * missing for some reason, treat it like an empty value.
14262 */
14266 {
14269 }
14270 else
14272
14276
14277 /*
14278 * In general we need to quote the value; but to avoid unnecessary
14279 * clutter, do not quote if it is an identifier that would not need
14280 * quoting. (We could also allow numbers, but that is a bit trickier
14281 * than it looks --- for example, are leading zeroes significant? We
14282 * don't want to assume very much here about what custom reloptions
14283 * might mean.)
14284 */
14287 else
14289
14291 }
14292}
14293
14294/*
14295 * Generate a C string representing a relation's reloptions, or NULL if none.
14296 */
14297static char *
14299{
14301 HeapTuple tuple;
14302 Datum reloptions;
14303 bool isnull;
14304
14308
14310 Anum_pg_class_reloptions, &isnull);
14311 if (!isnull)
14312 {
14314
14317
14319 }
14320
14321 ReleaseSysCache(tuple);
14322
14324}
14325
14326/*
14327 * get_range_partbound_string
14328 * A C string representation of one range partition bound
14329 */
14330char *
14332{
14333 deparse_context context;
14335 ListCell *cell;
14337
14341
14345 {
14346 PartitionRangeDatum *datum =
14348
14354 else
14355 {
14357
14359 }
14361 }
14363
14365}
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 @177 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:4015
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition lsyscache.c:3140
char * get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
Definition lsyscache.c:984
char * get_qualified_objname(Oid nspid, char *objname)
Definition lsyscache.c:3637
void get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
Definition lsyscache.c:2943
void get_atttypetypmodcoll(Oid relid, AttrNumber attnum, Oid *typid, int32 *typmod, Oid *collid)
Definition lsyscache.c:1100
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:1516
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:3442
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
Definition parse_relation.c:3630
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:2834
#define FRAMEOPTION_START_UNBOUNDED_PRECEDING
Definition parsenodes.h:617
#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING
Definition parsenodes.h:620
#define FRAMEOPTION_START_OFFSET_PRECEDING
Definition parsenodes.h:623
#define FRAMEOPTION_START_OFFSET_FOLLOWING
Definition parsenodes.h:625
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:1102
static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags, int wrapColumn)
Definition ruleutils.c:5901
Datum pg_get_partition_constraintdef(PG_FUNCTION_ARGS)
Definition ruleutils.c:2454
static char * get_rtable_name(int rtindex, deparse_context *context)
Definition ruleutils.c:5495
static int decompile_column_index_array(Datum column_index_array, Oid relId, bool withPeriod, StringInfo buf)
Definition ruleutils.c:2979
static void make_propgraphdef_labels(StringInfo buf, Oid elid, const char *elalias, Oid elrelid)
Definition ruleutils.c:1797
static void set_relation_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition ruleutils.c:4737
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:4115
char * pg_get_statisticsobjdef_string(Oid statextid)
Definition ruleutils.c:1985
static void set_using_names(deparse_namespace *dpns, Node *jtnode, List *parentUsing)
Definition ruleutils.c:4572
static Plan * find_recursive_union(deparse_namespace *dpns, WorkTableScan *wtscan)
Definition ruleutils.c:5595
static void get_values_def(List *values_lists, deparse_context *context)
Definition ruleutils.c:6089
static char * make_colname_unique(char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition ruleutils.c:5285
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:4391
static void print_function_trftypes(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3820
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:13775
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:3808
static void get_query_def(Query *query, StringInfo buf, List *parentnamespace, TupleDesc resultDesc, bool colNamesVisible, int prettyFlags, int wrapColumn, int startIndent)
Definition ruleutils.c:5986
static void get_tablesample_def(TableSampleClause *tablesample, deparse_context *context)
Definition ruleutils.c:13479
static void get_sublink_expr(SubLink *sublink, deparse_context *context)
Definition ruleutils.c:12426
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:6378
static void get_rte_alias(RangeTblEntry *rte, int varno, bool use_as, deparse_context *context)
Definition ruleutils.c:13284
Datum pg_get_function_arg_default(PG_FUNCTION_ARGS)
Definition ruleutils.c:3848
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:5340
Datum pg_get_statisticsobjdef_expressions(PG_FUNCTION_ARGS)
Definition ruleutils.c:2196
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:12682
static void get_column_alias_list(deparse_columns *colinfo, deparse_context *context)
Definition ruleutils.c:13388
Datum pg_get_statisticsobjdef_columns(PG_FUNCTION_ARGS)
Definition ruleutils.c:1995
static void add_to_names_hash(deparse_columns *colinfo, const char *name)
Definition ruleutils.c:5398
static void simple_quote_literal(StringInfo buf, const char *val)
Definition ruleutils.c:12401
static bool colname_is_unique(const char *colname, deparse_namespace *dpns, deparse_columns *colinfo)
Definition ruleutils.c:5210
static void get_from_clause_coldeflist(RangeTblFunction *rtfunc, deparse_columns *colinfo, deparse_context *context)
Definition ruleutils.c:13428
char * pg_get_indexdef_columns_extended(Oid indexrelid, uint16 flags)
Definition ruleutils.c:1260
char * pg_get_partkeydef_columns(Oid relid, bool pretty)
Definition ruleutils.c:2282
static void get_from_clause(Query *query, const char *prefix, deparse_context *context)
Definition ruleutils.c:12876
List * deparse_context_for(const char *aliasname, Oid relid)
Definition ruleutils.c:4070
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:13875
static void set_simple_column_names(deparse_namespace *dpns)
Definition ruleutils.c:4460
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:1246
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:1865
static void get_for_portion_of(ForPortionOfExpr *forPortionOf, deparse_context *context)
Definition ruleutils.c:13355
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:1281
static char * pg_get_constraintdef_worker(Oid constraintId, bool fullCommand, int prettyFlags, bool missing_ok)
Definition ruleutils.c:2551
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:13911
static void expand_colnames_array_to(deparse_columns *colinfo, int n)
Definition ruleutils.c:5324
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:4187
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:2012
#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:13661
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:5693
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:12650
static char * deparse_expression_pretty(Node *expr, List *dpcontext, bool forceprefix, bool showimplicit, int prettyFlags, int startIndent)
Definition ruleutils.c:4034
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:3918
static bool has_dangerous_join_using(deparse_namespace *dpns, Node *jtnode)
Definition ruleutils.c:4502
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:800
static void push_ancestor_plan(deparse_namespace *dpns, ListCell *ancestor_cell, deparse_namespace *save_dpns)
Definition ruleutils.c:5672
static text * pg_get_expr_worker(text *expr, Oid relid, int prettyFlags)
Definition ruleutils.c:3068
static Node * processIndirection(Node *node, deparse_context *context)
Definition ruleutils.c:13583
static void get_agg_combine_expr(Node *node, deparse_context *context, void *callback_arg)
Definition ruleutils.c:11597
List * select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used)
Definition ruleutils.c:4217
static void get_path_pattern_expr_def(List *path_pattern_expr, deparse_context *context)
Definition ruleutils.c:8031
static char * generate_qualified_type_name(Oid typid)
Definition ruleutils.c:14166
static void get_xmltable(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12551
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:1784
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:5642
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:2542
char * pg_get_partconstrdef_string(Oid partitionId, char *aliasname)
Definition ruleutils.c:2486
static void set_join_column_names(deparse_namespace *dpns, RangeTblEntry *rte, deparse_columns *colinfo)
Definition ruleutils.c:4940
static void make_propgraphdef_properties(StringInfo buf, Oid ellabelid, Oid elrelid)
Definition ruleutils.c:1881
static void set_rtable_names(deparse_namespace *dpns, List *parent_namespaces, Bitmapset *rels_used)
Definition ruleutils.c:4246
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:2295
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:3567
static char * pg_get_triggerdef_worker(Oid trigid, bool pretty)
Definition ruleutils.c:911
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:4007
void generate_operator_clause(StringInfo buf, const char *leftop, Oid leftoptype, Oid opoid, const char *rightop, Oid rightoptype)
Definition ruleutils.c:14095
static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc, int prettyFlags)
Definition ruleutils.c:5709
static char * pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)
Definition ruleutils.c:608
static int print_function_arguments(StringInfo buf, HeapTuple proctup, bool print_table_args, bool print_defaults)
Definition ruleutils.c:3660
static void identify_join_columns(JoinExpr *j, RangeTblEntry *jrte, deparse_columns *colinfo)
Definition ruleutils.c:5427
static void print_function_rettype(StringInfo buf, HeapTuple proctup)
Definition ruleutils.c:3622
static void set_deparse_plan(deparse_namespace *dpns, Plan *plan)
Definition ruleutils.c:5514
static void make_propgraphdef_elements(StringInfo buf, Oid pgrelid, char pgekind)
Definition ruleutils.c:1660
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:14332
static void get_tablefunc(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12857
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:6405
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:5625
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:6474
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:6132
static void destroy_colinfo_names_hash(deparse_columns *colinfo)
Definition ruleutils.c:5411
static char * generate_relation_name(Oid relid, List *namespaces)
Definition ruleutils.c:13815
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:14018
static void get_from_clause_item(Node *jtnode, Query *query, deparse_context *context)
Definition ruleutils.c:12970
Datum pg_get_function_arguments(PG_FUNCTION_ARGS)
Definition ruleutils.c:3541
static void get_json_table(TableFunc *tf, deparse_context *context, bool showimplicit)
Definition ruleutils.c:12788
static void get_select_query_def(Query *query, deparse_context *context)
Definition ruleutils.c:6271
static void get_opclass_name(Oid opclass, Oid actual_datatype, StringInfo buf)
Definition ruleutils.c:13523
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
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:460
Definition primnodes.h:1144
Definition pathnodes.h:3290
Definition plannodes.h:399
Definition array.h:188
Definition primnodes.h:1266
Definition primnodes.h:1406
Definition array.h:93
Definition bitmapset.h:50
Definition primnodes.h:968
Definition primnodes.h:2020
Definition primnodes.h:1342
Definition primnodes.h:1388
Definition primnodes.h:1358
Definition primnodes.h:1512
Definition primnodes.h:2066
Definition primnodes.h:1240
Definition primnodes.h:1312
Definition parsenodes.h:1804
Definition primnodes.h:325
Definition primnodes.h:1294
Definition plannodes.h:820
Definition primnodes.h:2135
Definition plannodes.h:933
Definition primnodes.h:190
Definition primnodes.h:1161
Definition primnodes.h:1192
Definition primnodes.h:2450
Definition plannodes.h:891
Definition primnodes.h:2394
Definition primnodes.h:780
Definition parsenodes.h:1047
Definition primnodes.h:2199
Definition parsenodes.h:1027
Definition primnodes.h:2209
Definition primnodes.h:558
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:2164
Definition primnodes.h:2366
Definition primnodes.h:1827
Definition primnodes.h:1742
Definition primnodes.h:1854
Definition primnodes.h:1676
Definition primnodes.h:1772
Definition primnodes.h:1688
Definition primnodes.h:1934
Definition primnodes.h:1923
Definition primnodes.h:1964
Definition primnodes.h:1708
Definition pg_list.h:54
Definition primnodes.h:2044
Definition plannodes.h:434
Definition primnodes.h:1534
Definition plannodes.h:337
Definition ruleutils.c:324
Definition primnodes.h:821
Definition plannodes.h:1014
Definition plannodes.h:1007
Definition primnodes.h:2150
Definition nodes.h:135
Definition parsenodes.h:3868
Definition primnodes.h:1996
Definition primnodes.h:2410
Definition primnodes.h:847
Definition primnodes.h:392
Definition parsenodes.h:942
Definition parsenodes.h:975
Definition plannodes.h:192
Definition plannodes.h:60
Definition parsenodes.h:118
Definition parsenodes.h:1138
Definition parsenodes.h:1434
Definition primnodes.h:2332
Definition primnodes.h:74
Definition plannodes.h:480
Definition primnodes.h:1217
Definition rel.h:56
Definition plannodes.h:302
Definition primnodes.h:2188
Definition primnodes.h:1491
Definition primnodes.h:1448
Definition parsenodes.h:1695
Definition primnodes.h:1581
Definition primnodes.h:927
Definition skey.h:65
Definition parsenodes.h:2359
Definition snapshot.h:139
Definition parsenodes.h:1554
Definition stringinfo.h:47
Definition value.h:64
Definition primnodes.h:1042
Definition primnodes.h:1093
Definition plannodes.h:774
Definition primnodes.h:713
Definition relscan.h:220
Definition primnodes.h:112
Definition parsenodes.h:1461
Definition primnodes.h:2275
Definition tupdesc.h:149
Definition typcache.h:32
Definition primnodes.h:263
Definition plannodes.h:1252
Definition parsenodes.h:1655
Definition primnodes.h:595
Definition plannodes.h:844
Definition primnodes.h:1624
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:804
Definition ruleutils.c:1778
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:1947
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 561 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 14135 of file ruleutils.c.
14136{
14140 char *nspname;
14141
14146
14149
14152
14154}
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 5398 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 5340 of file ruleutils.c.
5341{
5345
5346 /*
5347 * Use a hash table only for RTEs with at least 32 columns. (The cutoff
5348 * is somewhat arbitrary, but let's choose it so that this code does get
5349 * exercised in the regression tests.)
5350 */
5352 return;
5353
5354 /*
5355 * Set up the hash table. The entries are just strings with no other
5356 * payload.
5357 */
5363 &hash_ctl,
5365
5366 /*
5367 * Preload the hash table with any names already present (these would have
5368 * come from set_using_names).
5369 */
5371 {
5373
5376 }
5377
5379 {
5381
5384 }
5385
5387 {
5389
5391 }
5392}
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 5210 of file ruleutils.c.
5212{
5215
5216 /*
5217 * If we have a hash table, consult that instead of linearly scanning the
5218 * colinfo's strings.
5219 */
5221 {
5223 colname,
5224 HASH_FIND,
5226 return false;
5227 }
5228 else
5229 {
5230 /* Check against already-assigned column aliases within RTE */
5232 {
5234
5236 return false;
5237 }
5238
5239 /*
5240 * If we're building a new_colnames array, check that too (this will
5241 * be partially but not completely redundant with the previous checks)
5242 */
5244 {
5246
5248 return false;
5249 }
5250
5251 /*
5252 * Also check against names already assigned for parent-join USING
5253 * cols
5254 */
5256 {
5258
5260 return false;
5261 }
5262 }
5263
5264 /*
5265 * Also check against USING-column names that must be globally unique.
5266 * These are not hashed, but there should be few of them.
5267 */
5269 {
5271
5273 return false;
5274 }
5275
5276 return true;
5277}
References fb(), HASH_FIND, hash_search(), i, and lfirst.
Referenced by make_colname_unique().
◆ decompile_column_index_array()
|
static |
Definition at line 2979 of file ruleutils.c.
2981{
2982 Datum *keys;
2983 int nKeys;
2985
2986 /* Extract data from array of int16 */
2988 &keys, NULL, &nKeys);
2989
2991 {
2993
2995
2998 else
3002 }
3003
3004 return nKeys;
3005}
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 4070 of file ruleutils.c.
4071{
4074
4076
4077 /* Build a minimal RTE for the rel */
4080 rte->relid = relid;
4088
4089 /* Build one-element rtable */
4096
4097 /* Return a one-deep namespace stack */
4099}
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 4115 of file ruleutils.c.
4116{
4118
4120
4121 /* Initialize fields that stay the same across the whole plan tree */
4123 dpns->rtable_names = rtable_names;
4127 {
4128 /* Set up the array, indexed by child relid */
4131
4135 {
4138
4142 }
4143 }
4144 else
4146
4147 /*
4148 * Set up column name aliases, ignoring any join RTEs; they don't matter
4149 * because plan trees don't contain any join alias Vars.
4150 */
4152
4153 /* Return a one-deep namespace stack */
4155}
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 4007 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 4034 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 5411 of file ruleutils.c.
5412{
5414 {
5417 }
5418}
References fb(), and hash_destroy().
Referenced by set_join_column_names(), and set_relation_column_names().
◆ expand_colnames_array_to()
|
static |
Definition at line 5324 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 5595 of file ruleutils.c.
References elog, ERROR, fb(), IsA, and lfirst.
Referenced by set_deparse_plan().
◆ flatten_reloptions()
Definition at line 14299 of file ruleutils.c.
14300{
14302 HeapTuple tuple;
14303 Datum reloptions;
14304 bool isnull;
14305
14309
14311 Anum_pg_class_reloptions, &isnull);
14312 if (!isnull)
14313 {
14315
14318
14320 }
14321
14322 ReleaseSysCache(tuple);
14323
14325}
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 14199 of file ruleutils.c.
14200{
14201 HeapTuple tp;
14203 char *collname;
14204 char *nspname;
14206
14212
14215 else
14216 nspname = NULL;
14217
14219
14220 ReleaseSysCache(tp);
14221
14223}
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 13911 of file ruleutils.c.
13914{
13920 char *nspname;
13930
13936
13937 /*
13938 * Due to parser hacks to avoid needing to reserve CUBE, we need to force
13939 * qualification of some function names within GROUP BY.
13940 */
13941 if (inGroupBy)
13942 {
13945 }
13946
13947 /*
13948 * Determine whether VARIADIC should be printed. We must do this first
13949 * since it affects the lookup rules in func_get_detail().
13950 *
13951 * We always print VARIADIC if the function has a merged variadic-array
13952 * argument. Note that this is always the case for functions taking a
13953 * VARIADIC argument type other than VARIADIC ANY. If we omitted VARIADIC
13954 * and printed the array elements as separate arguments, the call could
13955 * match a newer non-VARIADIC function.
13956 */
13958 {
13959 /* Parser should not have set funcvariadic unless fn is variadic */
13963 }
13964 else
13965 {
13968 }
13969
13970 /*
13971 * The idea here is to schema-qualify only if the parser would fail to
13972 * resolve the correct function given the unqualified func name with the
13973 * specified argtypes and VARIADIC flag. But if we already decided to
13974 * force qualification, then we can skip the lookup and pretend we didn't
13975 * find it.
13976 */
13979 NIL, argnames, nargs, argtypes,
13981 &fgc_flags,
13985 else
13986 {
13989 }
13990
13994 p_funcid == funcid)
13995 nspname = NULL;
13996 else
13998
14000
14002
14004}
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 13561 of file ruleutils.c.
13562{
13564
13567
13569}
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 14095 of file ruleutils.c.
14099{
14102 char *oprname;
14103 char *nspname;
14104
14111
14113
14122
14124}
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 14018 of file ruleutils.c.
14019{
14023 char *oprname;
14024 char *nspname;
14026
14028
14034
14035 /*
14036 * The idea here is to schema-qualify only if the parser would fail to
14037 * resolve the correct operator given the unqualified op name with the
14038 * specified argtypes.
14039 */
14041 {
14042 case 'b':
14044 true, -1);
14045 break;
14046 case 'l':
14048 true, -1);
14049 break;
14050 default:
14053 break;
14054 }
14055
14057 nspname = NULL;
14058 else
14059 {
14062 }
14063
14065
14066 if (nspname)
14068
14071
14073
14075}
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 13875 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 14166 of file ruleutils.c.
14167{
14168 HeapTuple tp;
14171 char *nspname;
14173
14179
14181 if (!nspname)
14183 typtup->typnamespace);
14184
14186
14187 ReleaseSysCache(tp);
14188
14190}
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 13815 of file ruleutils.c.
13816{
13817 HeapTuple tp;
13822 char *nspname;
13824
13830
13831 /* Check for conflicting CTE name */
13834 {
13837
13839 {
13841
13843 {
13845 break;
13846 }
13847 }
13849 break;
13850 }
13851
13852 /* Otherwise, qualify the name if not visible in search path */
13855
13858 else
13859 nspname = NULL;
13860
13862
13863 ReleaseSysCache(tp);
13864
13866}
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 6474 of file ruleutils.c.
6475{
6479 ListCell *l;
6480
6482 {
6485 }
6486
6487 /*
6488 * If the query looks like SELECT * FROM (VALUES ...), then print just the
6489 * VALUES part. This reverses what transformValuesClause() did at parse
6490 * time.
6491 */
6494 {
6496 return;
6497 }
6498
6499 /*
6500 * Build up the query string - first we say SELECT
6501 */
6502 if (query->isReturn)
6504 else
6506
6507 /* Add the DISTINCT clause if given */
6509 {
6510 if (query->hasDistinctOn)
6511 {
6515 {
6517
6520 false, context);
6522 }
6524 }
6525 else
6527 }
6528
6529 /* Then we tell what to select (the targetlist) */
6531
6532 /* Add the FROM clause if needed */
6534
6535 /* Add the WHERE clause if given */
6537 {
6541 }
6542
6543 /* Add the GROUP BY clause if given */
6545 {
6547
6552
6555
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::groupByAll, Query::groupClause, Query::groupDistinct, Query::groupingSets, Query::havingQual, deparse_context::indentLevel, deparse_context::inGroupBy, Query::jointree, lfirst, NIL, PRETTY_INDENT, PRETTYINDENT_STD, FromExpr::quals, deparse_context::resultDesc, Query::targetList, and Query::windowClause.
Referenced by get_select_query_def().
◆ get_coercion_expr()
|
static |
Definition at line 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 13388 of file ruleutils.c.
13389{
13392 bool first = true;
13393
13394 /* Don't print aliases if not needed */
13396 return;
13397
13399 {
13401
13402 if (first)
13403 {
13405 first = false;
13406 }
13407 else
13410 }
13411 if (!first)
13413}
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 13355 of file ruleutils.c.
13356{
13357 if (forPortionOf)
13358 {
13361
13362 /*
13363 * Try to write it as FROM ... TO ... if we received it that way,
13364 * otherwise (targetRange).
13365 */
13367 {
13372 }
13373 else
13374 {
13378 }
13379 }
13380}
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 12876 of file ruleutils.c.
12877{
12879 bool first = true;
12880 ListCell *l;
12881
12882 /*
12883 * We use the query's jointree as a guide to what to print. However, we
12884 * must ignore auto-added RTEs that are marked not inFromCl. (These can
12885 * only appear at the top level of the jointree, so it's sufficient to
12886 * check here.) This check also ensures we ignore the rule pseudo-RTEs
12887 * for NEW and OLD.
12888 */
12890 {
12892
12894 {
12897
12899 continue;
12900 }
12901
12902 if (first)
12903 {
12904 appendContextKeyword(context, prefix,
12906 first = false;
12907
12908 get_from_clause_item(jtnode, query, context);
12909 }
12910 else
12911 {
12913
12915
12916 /*
12917 * Put the new FROM item's text into itembuf so we can decide
12918 * after we've got it whether or not it needs to go on a new line.
12919 */
12922
12923 get_from_clause_item(jtnode, query, context);
12924
12925 /* Restore context's output buffer */
12927
12928 /* Consider line-wrapping if enabled */
12930 {
12931 /* Does the new item start with a new line? */
12933 {
12934 /* If so, we shouldn't add anything */
12935 /* instead, remove any trailing spaces currently in buf */
12937 }
12938 else
12939 {
12941
12942 /* Locate the start of the current line in the buffer */
12946 else
12947 trailing_nl++;
12948
12949 /*
12950 * Add a newline, plus some indentation, if the new item
12951 * would cause an overflow.
12952 */
12955 PRETTYINDENT_STD,
12956 PRETTYINDENT_VAR);
12957 }
12958 }
12959
12960 /* Add the new item */
12962
12963 /* clean up */
12965 }
12966 }
12967}
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 13428 of file ruleutils.c.
13431{
13433 ListCell *l1;
13434 ListCell *l2;
13435 ListCell *l3;
13436 ListCell *l4;
13438
13440
13441 i = 0;
13442 forfour(l1, rtfunc->funccoltypes,
13443 l2, rtfunc->funccoltypmods,
13444 l3, rtfunc->funccolcollations,
13445 l4, rtfunc->funccolnames)
13446 {
13451
13454 else
13456
13458
13467 generate_collation_name(attcollation));
13468
13469 i++;
13470 }
13471
13473}
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 12970 of file ruleutils.c.
12971{
12974
12976 {
12981
12984
12985 /* Print the FROM item proper */
12987 {
12989 /* Normal relation RTE */
12993 context->namespaces));
12994 break;
12996 /* Subquery RTE */
12999 true,
13001 context->indentLevel);
13003 break;
13005 /* Function RTE */
13007
13008 /*
13009 * Omit ROWS FROM() syntax for just one function, unless it
13010 * has both a coldeflist and WITH ORDINALITY. If it has both,
13011 * we must use ROWS FROM() syntax to avoid ambiguity about
13012 * whether the coldeflist includes the ordinality column.
13013 */
13016 {
13018 /* we'll print the coldeflist below, if it has one */
13019 }
13020 else
13021 {
13024
13025 /*
13026 * If all the function calls in the list are to unnest,
13027 * and none need a coldeflist, then collapse the list back
13028 * down to UNNEST(args). (If we had more than one
13029 * built-in unnest function, this would get more
13030 * difficult.)
13031 *
13032 * XXX This is pretty ugly, since it makes not-terribly-
13033 * future-proof assumptions about what the parser would do
13034 * with the output; but the alternative is to emit our
13035 * nonstandard ROWS FROM() notation for what might have
13036 * been a perfectly spec-compliant multi-argument
13037 * UNNEST().
13038 */
13041 {
13043
13046 rtfunc->funccolnames != NIL)
13047 {
13049 break;
13050 }
13051 }
13052
13054 {
13056
13058 {
13061
13063 }
13064
13068 }
13069 else
13070 {
13072
13075 {
13077
13082 {
13083 /* Reconstruct the column definition list */
13085 get_from_clause_coldeflist(rtfunc,
13086 NULL,
13087 context);
13088 }
13089 funcno++;
13090 }
13092 }
13093 /* prevent printing duplicate coldeflist below */
13095 }
13098 break;
13101 break;
13108 {
13109 bool first = true;
13110
13112 {
13113 if (!first)
13115 else
13116 first = false;
13117
13121 }
13122 }
13124 break;
13126 /* Values list RTE */
13130 break;
13133 break;
13134 default:
13136 break;
13137 }
13138
13139 /* Print the relation alias, if needed */
13141
13142 /* Print the column definitions or aliases, if needed */
13144 {
13145 /* Reconstruct the columndef list, which is also the aliases */
13147 }
13148 else
13149 {
13150 /* Else print column aliases as needed */
13152 }
13153
13154 /* Tablesample clause must go after any alias */
13157 }
13159 {
13163
13167
13170
13172
13174 {
13178 -PRETTYINDENT_STD,
13179 PRETTYINDENT_STD,
13180 PRETTYINDENT_JOIN);
13181 else
13183 -PRETTYINDENT_STD,
13184 PRETTYINDENT_STD,
13185 PRETTYINDENT_JOIN);
13186 break;
13189 -PRETTYINDENT_STD,
13190 PRETTYINDENT_STD,
13191 PRETTYINDENT_JOIN);
13192 break;
13195 -PRETTYINDENT_STD,
13196 PRETTYINDENT_STD,
13197 PRETTYINDENT_JOIN);
13198 break;
13201 -PRETTYINDENT_STD,
13202 PRETTYINDENT_STD,
13203 PRETTYINDENT_JOIN);
13204 break;
13205 default:
13208 }
13209
13215
13217 {
13219 bool first = true;
13220
13222 /* Use the assigned names, not what's in usingClause */
13224 {
13226
13227 if (first)
13228 first = false;
13229 else
13232 }
13234
13238 }
13240 {
13247 }
13249 {
13250 /* If we didn't say CROSS JOIN above, we must provide an ON */
13252 }
13253
13256
13257 /* Yes, it's correct to put alias after the right paren ... */
13259 {
13260 /*
13261 * Note that it's correct to emit an alias clause if and only if
13262 * there was one originally. Otherwise we'd be converting a named
13263 * join to unnamed or vice versa, which creates semantic
13264 * subtleties we don't want. However, we might print a different
13265 * alias name than was there originally.
13266 */
13269 context)));
13271 }
13272 }
13273 else
13276}
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.
References elog, ERROR, fb(), funcname, get_agg_expr_helper(), get_json_constructor_options(), get_windowfunc_expr_helper(), initStringInfo(), IsA, and nodeTag.
Referenced by get_json_constructor().
◆ get_json_behavior()
|
static |
Definition at line 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_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 12788 of file ruleutils.c.
12789{
12793
12795
12798
12800
12802
12804
12806
12808
12810 {
12812 *lc2;
12814
12817
12820
12823 {
12827
12829
12833 );
12834 }
12835
12838 }
12839
12841 showimplicit);
12842
12845
12848
12850}
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_context::buf, buf, castNode, TableFunc::docexpr, fb(), forboth, get_const_expr(), get_json_behavior(), get_json_table_columns(), get_rule_expr(), deparse_context::indentLevel, JSON_BEHAVIOR_EMPTY_ARRAY, lfirst, lfirst_node, PRETTY_INDENT, PRETTYINDENT_VAR, quote_identifier(), and root.
Referenced by get_tablefunc().
◆ get_json_table_columns()
|
static |
Definition at line 12682 of file ruleutils.c.
12685{
12691 int colnum = 0;
12692
12695
12698
12700 lc_coltype, tf->coltypes,
12701 lc_coltypmod, tf->coltypmods,
12702 lc_colvalexpr, tf->colvalexprs)
12703 {
12705 JsonExpr *colexpr;
12706 Oid typid;
12707 int32 typmod;
12708 bool ordinality;
12710
12714
12715 /* Skip columns that don't belong to this scan. */
12717 {
12718 colnum++;
12719 continue;
12720 }
12722 break;
12723
12726
12727 colnum++;
12728
12729 ordinality = !colexpr;
12730
12732
12734 ordinality ? "FOR ORDINALITY" :
12735 format_type_with_typemod(typid, typmod));
12736 if (ordinality)
12737 continue;
12738
12739 /*
12740 * Set default_behavior to guide get_json_expr_options() on whether to
12741 * emit the ON ERROR / EMPTY clauses.
12742 */
12744 {
12747 }
12748 else
12749 {
12751 {
12754
12756
12760 " FORMAT JSONB" : " FORMAT JSON");
12761 }
12762
12764 }
12765
12767
12769
12771 }
12772
12775 scan->colMin >= 0);
12776
12779
12781}
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 12650 of file ruleutils.c.
References appendContextKeyword(), appendStringInfo(), appendStringInfoChar(), deparse_context::buf, castNode, fb(), get_const_expr(), get_json_table_columns(), get_json_table_nested_columns(), IsA, JsonTableSiblingJoin::lplan, JsonTablePath::name, JsonTablePathScan::path, plan, quote_identifier(), JsonTableSiblingJoin::rplan, and JsonTablePath::value.
Referenced by get_json_table_columns(), and get_json_table_nested_columns().
◆ get_lock_clause_strength()
|
static |
Definition at line 6378 of file ruleutils.c.
6379{
6380 switch (strength)
6381 {
6383 /* we intentionally throw an error for LCS_NONE */
6385 (int) strength);
6386 break;
6388 return " FOR KEY SHARE";
6390 return " FOR SHARE";
6392 return " FOR NO KEY UPDATE";
6394 return " FOR UPDATE";
6395 }
6397}
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 13523 of file ruleutils.c.
13525{
13529 char *nspname;
13530
13535
13538 {
13539 /* Okay, we need the opclass name. Do we need to qualify it? */
13543 else
13544 {
13547 quote_identifier(nspname),
13549 }
13550 }
13552}
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 5986 of file ruleutils.c.
5989{
5990 deparse_context context;
5992 int rtable_size;
5993
5994 /* Guard against excessively long or deeply-nested queries */
5995 CHECK_FOR_INTERRUPTS();
5996 check_stack_depth();
5997
5998 rtable_size = query->hasGroupRTE ?
6001
6002 /*
6003 * Replace any Vars in the query's targetlist and havingQual that
6004 * reference GROUP outputs with the underlying grouping expressions.
6005 *
6006 * We can safely pass NULL for the root here. Preserving varnullingrels
6007 * makes no difference to the deparsed source text.
6008 */
6009 if (query->hasGroupRTE)
6010 {
6013 query->havingQual =
6015 }
6016
6017 /*
6018 * Before we begin to examine the query, acquire locks on referenced
6019 * relations, and fix up deleted columns in JOIN RTEs. This ensures
6020 * consistent results. Note we assume it's OK to scribble on the passed
6021 * querytree!
6022 *
6023 * We are only deparsing the query (we are not about to execute it), so we
6024 * only need AccessShareLock on the relations it mentions.
6025 */
6027
6034 rtable_size != 1);
6035 context.prettyFlags = prettyFlags;
6036 context.wrapColumn = wrapColumn;
6038 context.colNamesVisible = colNamesVisible;
6042
6044
6046 {
6048 /* We set context.resultDesc only if it's a SELECT */
6049 context.resultDesc = resultDesc;
6050 get_select_query_def(query, &context);
6051 break;
6052
6054 get_update_query_def(query, &context);
6055 break;
6056
6058 get_insert_query_def(query, &context);
6059 break;
6060
6062 get_delete_query_def(query, &context);
6063 break;
6064
6066 get_merge_query_def(query, &context);
6067 break;
6068
6071 break;
6072
6074 get_utility_query_def(query, &context);
6075 break;
6076
6077 default:
6079 query->commandType);
6080 break;
6081 }
6082}
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 14332 of file ruleutils.c.
14333{
14334 deparse_context context;
14336 ListCell *cell;
14338
14342
14346 {
14347 PartitionRangeDatum *datum =
14349
14355 else
14356 {
14358
14360 }
14362 }
14364
14366}
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 13795 of file ruleutils.c.
13796{
13798
13802}
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 14244 of file ruleutils.c.
14245{
14249
14252
14254 {
14259
14260 /*
14261 * Each array element should have the form name=value. If the "=" is
14262 * missing for some reason, treat it like an empty value.
14263 */
14267 {
14270 }
14271 else
14273
14277
14278 /*
14279 * In general we need to quote the value; but to avoid unnecessary
14280 * clutter, do not quote if it is an identifier that would not need
14281 * quoting. (We could also allow numbers, but that is a bit trickier
14282 * than it looks --- for example, are leading zeroes significant? We
14283 * don't want to assume very much here about what custom reloptions
14284 * might mean.)
14285 */
14288 else
14290
14292 }
14293}
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 5495 of file ruleutils.c.
5496{
5498
5501}
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 13284 of file ruleutils.c.
13286{
13291
13293 {
13294 /* Always print alias if user provided one */
13296 }
13298 {
13299 /* Always print alias if we need to print column aliases */
13301 }
13303 {
13304 /*
13305 * No need to print alias if it's same as relation name (this would
13306 * normally be the case, but not if set_rtable_names had to resolve a
13307 * conflict).
13308 */
13311 }
13313 {
13314 /*
13315 * For a function RTE, always print alias. This covers possible
13316 * renaming of the function and/or instability of the FigureColname
13317 * rules for things that aren't simple functions. Note we'd need to
13318 * force it anyway for the columndef list case.
13319 */
13321 }
13324 {
13325 /*
13326 * For a subquery, always print alias. This makes the output
13327 * SQL-spec-compliant, even though we allow such aliases to be omitted
13328 * on input.
13329 */
13331 }
13333 {
13334 /*
13335 * No need to print alias if it's same as CTE name (this would
13336 * normally be the case, but not if set_rtable_names had to resolve a
13337 * conflict).
13338 */
13341 }
13342
13346 quote_identifier(refname));
13347}
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 6271 of file ruleutils.c.
6272{
6275 ListCell *l;
6276
6277 /* Insert the WITH clause if given */
6278 get_with_clause(query, context);
6279
6280 /* Subroutines may need to consult the SELECT targetlist and windowClause */
6283
6284 /*
6285 * If the Query node has a setOperations tree, then it's the top level of
6286 * a UNION/INTERSECT/EXCEPT query; only the WITH, ORDER BY and LIMIT
6287 * fields are interesting in the top query itself.
6288 */
6290 {
6292 /* ORDER BY clauses must be simple in this case */
6294 }
6295 else
6296 {
6297 get_basic_select_query(query, context);
6299 }
6300
6301 /* Add the ORDER BY clause if given */
6303 {
6307 force_colno, context);
6308 }
6309
6310 /*
6311 * Add the LIMIT/OFFSET clauses if given. If non-default options, use the
6312 * standard spelling of LIMIT.
6313 */
6315 {
6319 }
6321 {
6323 {
6324 /*
6325 * The limitCount arg is a c_expr, so it needs parens. Simple
6326 * literals and function expressions would not need parens, but
6327 * unfortunately it's hard to tell if the expression will be
6328 * printed as a simple literal like 123 or as a typecast
6329 * expression, like '-123'::int4. The grammar accepts the former
6330 * without quoting, but not the latter.
6331 */
6338 }
6339 else
6340 {
6346 else
6348 }
6349 }
6350
6351 /* Add FOR [KEY] UPDATE/SHARE clauses if present */
6352 if (query->hasForUpdate)
6353 {
6355 {
6357
6358 /* don't print implicit clauses */
6360 continue;
6361
6362 appendContextKeyword(context,
6365
6368 context)));
6373 }
6374 }
6375}
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 6405 of file ruleutils.c.
6406{
6409
6410 /*
6411 * We want to detect a match even if the Query also contains OLD or NEW
6412 * rule RTEs. So the idea is to scan the rtable and see if there is only
6413 * one inFromCl RTE that is a VALUES RTE.
6414 */
6416 {
6418
6420 {
6424 }
6426 continue; /* ignore rule entries */
6427 else
6429 }
6430
6431 /*
6432 * We don't need to check the targetlist in any great detail, because
6433 * parser/analyze.c will never generate a "bare" VALUES RTE --- they only
6434 * appear inside auto-generated sub-queries with very restricted
6435 * structure. However, DefineView might have modified the tlist by
6436 * injecting new column aliases, or we might have some other column
6437 * aliases forced by a resultDesc. We can only simplify if the RTE's
6438 * column names match the names that get_target_list() would select.
6439 */
6441 {
6443 int colno;
6444
6447 colno = 0;
6449 {
6452 char *colname;
6453
6456
6457 /* compute name that get_target_list would use for column */
6458 colno++;
6461 else
6462 colname = tle->resname;
6463
6464 /* does it match the VALUES RTE? */
6467 }
6468 }
6469
6471}
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 12426 of file ruleutils.c.
12427{
12432
12435 else
12437
12438 /*
12439 * Note that we print the name of only the first operator, when there are
12440 * multiple combining operators. This is an approximation that could go
12441 * wrong in various scenarios (operators in different schemas, renamed
12442 * operators, etc) but there is not a whole lot we can do about it, since
12443 * the syntax allows only one operator to be shown.
12444 */
12446 {
12448 {
12449 /* single combining operator */
12451
12456 }
12458 {
12459 /* multiple combining operators, = or <> cases */
12461 ListCell *l;
12462
12466 {
12468
12476 }
12478 }
12480 {
12481 /* multiple combining operators, < <= > >= cases */
12483
12490 }
12491 else
12494 }
12495
12497
12499 {
12502 break;
12503
12507 else
12509 break;
12510
12513 break;
12514
12517 break;
12518
12523 break;
12524
12526 default:
12529 break;
12530 }
12531
12534
12537 context->indentLevel);
12538
12541 else
12543}
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 12857 of file ruleutils.c.
12858{
12859 /* XMLTABLE and JSON_TABLE are the only existing implementations. */
12860
12865}
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 13479 of file ruleutils.c.
13480{
13482 Oid argtypes[1];
13483 int nargs;
13484 ListCell *l;
13485
13486 /*
13487 * We should qualify the handler's function name if it wouldn't be
13488 * resolved by lookup in the current search path.
13489 */
13490 argtypes[0] = INTERNALOID;
13493 NIL, argtypes,
13495
13496 nargs = 0;
13498 {
13499 if (nargs++ > 0)
13502 }
13504
13506 {
13510 }
13511}
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 6089 of file ruleutils.c.
6090{
6094
6096
6098 {
6102
6105 else
6107
6110 {
6112
6115 else
6117
6118 /*
6119 * Print the value. Whole-row Vars need special treatment.
6120 */
6122 }
6124 }
6125}
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 6132 of file ruleutils.c.
6133{
6136 ListCell *l;
6137
6139 return;
6140
6142 {
6145 }
6146
6147 if (query->hasRecursive)
6149 else
6152 {
6154
6157 if (cte->aliascolnames)
6158 {
6159 bool first = true;
6161
6164 {
6165 if (first)
6166 first = false;
6167 else
6171 }
6173 }
6176 {
6178 break;
6181 break;
6184 break;
6185 }
6190 true,
6192 context->indentLevel);
6196
6197 if (cte->search_clause)
6198 {
6199 bool first = true;
6201
6203 cte->search_clause->search_breadth_first ? "BREADTH" : "DEPTH");
6204
6206 {
6207 if (first)
6208 first = false;
6209 else
6213 }
6214
6216 }
6217
6218 if (cte->cycle_clause)
6219 {
6220 bool first = true;
6222
6224
6226 {
6227 if (first)
6228 first = false;
6229 else
6233 }
6234
6236
6237 {
6240
6241 if (!(cmv->consttype == BOOLOID && !cmv->constisnull && DatumGetBool(cmv->constvalue) == true &&
6243 {
6248 }
6249 }
6250
6252 }
6253
6255 }
6256
6258 {
6261 }
6262 else
6264}
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 12551 of file ruleutils.c.
12552{
12554
12556
12558 {
12560 *lc2;
12561 bool first = true;
12562
12565 {
12568
12569 if (!first)
12571 else
12572 first = false;
12573
12575 {
12579 }
12580 else
12581 {
12584 }
12585 }
12587 }
12588
12594
12596 {
12597 ListCell *l1;
12598 ListCell *l2;
12599 ListCell *l3;
12600 ListCell *l4;
12601 ListCell *l5;
12602 int colnum = 0;
12603
12605 forfive(l1, tf->colnames, l2, tf->coltypes, l3, tf->coltypmods,
12606 l4, tf->colexprs, l5, tf->coldefexprs)
12607 {
12613 bool ordinality = (tf->ordinalitycol == colnum);
12615
12616 if (colnum > 0)
12618 colnum++;
12619
12621 ordinality ? "FOR ORDINALITY" :
12622 format_type_with_typemod(typid, typmod));
12623 if (ordinality)
12624 continue;
12625
12627 {
12631 }
12633 {
12637 }
12638 if (notnull)
12640 }
12641 }
12642
12644}
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 4502 of file ruleutils.c.
4503{
4505 {
4506 /* nothing to do here */
4507 }
4509 {
4512
4514 {
4516 return true;
4517 }
4518 }
4520 {
4522
4523 /* Is it an unnamed JOIN with USING? */
4525 {
4526 /*
4527 * Yes, so check each join alias var to see if any of them are not
4528 * simple references to underlying columns. If so, we have a
4529 * dangerous situation and must pick unique aliases.
4530 */
4532
4533 /* We need only examine the merged columns */
4535 {
4537
4539 return true;
4540 }
4541 }
4542
4543 /* Nope, but inspect children */
4545 return true;
4547 return true;
4548 }
4549 else
4552 return false;
4553}
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 5427 of file ruleutils.c.
5429{
5434
5435 /* Extract left/right child RT indexes */
5440 else
5447 else
5450
5451 /* Assert children will be processed earlier than join in second pass */
5454
5455 /* Initialize result arrays with zeroes */
5460
5461 /*
5462 * Deconstruct RTE's joinleftcols/joinrightcols into desired format.
5463 * Recall that the column(s) merged due to USING are the first column(s)
5464 * of the join output. We need not do anything special while scanning
5465 * joinleftcols, but while scanning joinrightcols we must distinguish
5466 * merged from unmerged columns.
5467 */
5468 jcolno = 0;
5470 {
5472
5474 }
5475 rcolno = 0;
5477 {
5479
5482 else
5484 rcolno++;
5485 }
5487}
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 3808 of file ruleutils.c.
3809{
3814}
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().
◆ list_oid_str_pair_cmp_by_str()
Definition at line 1784 of file ruleutils.c.
1785{
1788
1790}
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 5285 of file ruleutils.c.
5287{
5288 /*
5289 * If the selected name isn't unique, append digits to make it so. For a
5290 * very long input name, we might have to truncate to stay within
5291 * NAMEDATALEN.
5292 */
5294 {
5298
5299 do
5300 {
5301 i++;
5302 for (;;)
5303 {
5307 break;
5308 /* drop chars from colname to keep all the digits */
5310 colnamelen - 1);
5311 }
5313 colname = modname;
5314 }
5315 return colname;
5316}
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 1660 of file ruleutils.c.
1661{
1664 SysScanDesc scan;
1665 bool first;
1667
1669
1674
1676
1677 first = true;
1679 {
1682 Datum datum;
1683 bool isnull;
1684
1686 continue;
1687
1688 if (first)
1689 {
1691 first = false;
1692 }
1693 else
1695
1700 else
1704
1705 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgekey, RelationGetDescr(pgerel), &isnull);
1706 if (!isnull)
1707 {
1711 }
1712 else
1714
1716 {
1717 Datum srckey;
1718 Datum srcref;
1719 Datum destkey;
1720 Datum destref;
1723
1724 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgesrckey, RelationGetDescr(pgerel), &isnull);
1725 srckey = isnull ? 0 : datum;
1726 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgesrcref, RelationGetDescr(pgerel), &isnull);
1727 srcref = isnull ? 0 : datum;
1728 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgedestkey, RelationGetDescr(pgerel), &isnull);
1729 destkey = isnull ? 0 : datum;
1730 datum = heap_getattr(tup, Anum_pg_propgraph_element_pgedestref, RelationGetDescr(pgerel), &isnull);
1731 destref = isnull ? 0 : datum;
1732
1738 if (srckey)
1739 {
1745 }
1746 else
1749
1755 if (destkey)
1756 {
1762 }
1763 else
1766 }
1767
1769 }
1770 if (!first)
1772
1773 systable_endscan(scan);
1775}
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 1797 of file ruleutils.c.
1798{
1801 SysScanDesc scan;
1802 int count;
1805
1807
1812
1813 /*
1814 * We want to output the labels in a deterministic order. So we first
1815 * read all the data, then sort, then print it.
1816 */
1817 scan = systable_beginscan(pglrel, PropgraphElementLabelElementLabelIndexId, true, NULL, 1, scankey);
1818
1820 {
1823
1827
1829 }
1830
1831 systable_endscan(scan);
1833
1835
1836 /* Each element has at least one label. */
1837 Assert(count > 0);
1838
1839 /*
1840 * It is enough for the comparison function to compare just labels, since
1841 * all the labels of an element table should have distinct names.
1842 */
1844
1846 {
1848 {
1849 /* If the default label is the only label, don't print anything. */
1850 if (count != 1)
1852 }
1853 else
1855
1857 }
1858}
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 1881 of file ruleutils.c.
1882{
1885 SysScanDesc scan;
1888
1890
1895
1896 /*
1897 * We want to output the properties in a deterministic order. So we first
1898 * read all the data, then sort, then print it.
1899 */
1900 scan = systable_beginscan(plprel, PropgraphLabelPropertyLabelPropIndexId, true, NULL, 1, scankey);
1901
1903 {
1906 bool isnull;
1907 char *tmp;
1908 Node *expr;
1910
1911 exprDatum = heap_getattr(tup, Anum_pg_propgraph_label_property_plpexpr, RelationGetDescr(plprel), &isnull);
1912 Assert(!isnull);
1914 expr = stringToNode(tmp);
1915 pfree(tmp);
1916
1918
1920 }
1921
1922 systable_endscan(scan);
1924
1926
1927 if (outlist)
1928 {
1929 List *context;
1931 bool first = true;
1932
1934
1936
1938 {
1942
1943 if (first)
1944 first = false;
1945 else
1947
1948 if (IsA(expr, Var) && strcmp(propname, get_attname(elrelid, castNode(Var, expr)->varattno, false)) == 0)
1950 else
1954 }
1955
1957 }
1958 else
1960}
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 5709 of file ruleutils.c.
5711{
5712 char *rulename;
5713 char ev_type;
5715 bool is_instead;
5718 List *actions;
5723 bool isnull;
5724
5725 /*
5726 * Get the attribute values from the rules tuple
5727 */
5730 Assert(!isnull);
5732
5735 Assert(!isnull);
5737
5740 Assert(!isnull);
5742
5745 Assert(!isnull);
5747
5751
5758
5760
5761 /*
5762 * Build the rules definition text
5763 */
5765 quote_identifier(rulename));
5766
5769 else
5771
5772 /* The event the rule is fired for */
5773 switch (ev_type)
5774 {
5775 case '1':
5778 break;
5779
5780 case '2':
5782 break;
5783
5784 case '3':
5786 break;
5787
5788 case '4':
5790 break;
5791
5792 default:
5796 rulename, ev_type)));
5797 break;
5798 }
5799
5800 /* The relation the rule is fired on */
5802 (prettyFlags & PRETTYFLAG_SCHEMA) ?
5805
5806 /* If the rule has an event qualification, add it */
5808 {
5809 Node *qual;
5810 Query *query;
5811 deparse_context context;
5813
5817
5819
5820 /*
5821 * We need to make a context for recognizing any Vars in the qual
5822 * (which can only be references to OLD and NEW). Use the rtable of
5823 * the first query in the action list for this purpose.
5824 */
5826
5827 /*
5828 * If the action is INSERT...SELECT, OLD/NEW have been pushed down
5829 * into the SELECT, and that's what we need to look at. (Ugly kluge
5830 * ... try to fix this when we redesign querytrees.)
5831 */
5833
5834 /* Must acquire locks right away; see notes in get_query_def() */
5836
5843 context.prettyFlags = prettyFlags;
5850
5852
5854 }
5855
5857
5858 /* The INSTEAD keyword (if so) */
5859 if (is_instead)
5861
5862 /* Finally the rules actions */
5864 {
5866 Query *query;
5867
5869 foreach(action, actions)
5870 {
5873 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5874 if (prettyFlags)
5876 else
5878 }
5880 }
5881 else
5882 {
5883 Query *query;
5884
5887 prettyFlags, WRAP_COLUMN_DEFAULT, 0);
5889 }
5890
5892}
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 5901 of file ruleutils.c.
5903{
5904 Query *query;
5905 char ev_type;
5907 bool is_instead;
5910 List *actions;
5914 bool isnull;
5915
5916 /*
5917 * Get the attribute values from the rules tuple
5918 */
5921 Assert(!isnull);
5923
5926 Assert(!isnull);
5928
5931 Assert(!isnull);
5933
5937
5942
5944 {
5945 /* keep output buffer empty and leave */
5946 return;
5947 }
5948
5950
5951 if (ev_type != '1' || !is_instead ||
5953 {
5954 /* keep output buffer empty and leave */
5955 return;
5956 }
5957
5959
5961 prettyFlags, wrapColumn, 0);
5963
5965}
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 2504 of file ruleutils.c.
2505{
2507 int prettyFlags;
2508 char *res;
2509
2510 prettyFlags = PRETTYFLAG_INDENT;
2511
2513
2515 PG_RETURN_NULL();
2516
2518}
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 2542 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 2521 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 2551 of file ruleutils.c.
2553{
2557 SysScanDesc scandesc;
2561
2563 Anum_pg_constraint_oid,
2566
2567 scandesc = systable_beginscan(relation,
2568 ConstraintOidIndexId,
2569 true,
2570 snapshot,
2571 1,
2572 scankey);
2573
2574 /*
2575 * We later use the tuple with SysCacheGetAttr() as if we had obtained it
2576 * via SearchSysCache, which works fine.
2577 */
2579
2580 UnregisterSnapshot(snapshot);
2581
2583 {
2584 if (missing_ok)
2585 {
2586 systable_endscan(scandesc);
2589 }
2591 }
2592
2594
2596
2598 {
2600 {
2601 /*
2602 * Currently, callers want ALTER TABLE (without ONLY) for CHECK
2603 * constraints, and other types of constraints don't inherit
2604 * anyway so it doesn't matter whether we say ONLY or not. Someday
2605 * we might need to let callers specify whether to put ONLY in the
2606 * command.
2607 */
2611 }
2612 else
2613 {
2614 /* Must be a domain constraint */
2619 }
2620 }
2621
2623 {
2625 {
2627 bool isnull;
2629
2630 /* Start off the constraint definition */
2632
2633 /* Fetch and build referencing-column list */
2635 Anum_pg_constraint_conkey);
2636
2637 /* If it is a temporal foreign key then it uses PERIOD. */
2639
2640 /* add foreign relation name */
2643 NIL));
2644
2645 /* Fetch and build referenced-column list */
2647 Anum_pg_constraint_confkey);
2648
2650
2652
2653 /* Add match type */
2655 {
2657 string = " MATCH FULL";
2658 break;
2660 string = " MATCH PARTIAL";
2661 break;
2663 string = "";
2664 break;
2665 default:
2667 conForm->confmatchtype);
2668 string = ""; /* keep compiler quiet */
2669 break;
2670 }
2672
2673 /* Add ON UPDATE and ON DELETE clauses, if needed */
2675 {
2678 break;
2680 string = "RESTRICT";
2681 break;
2683 string = "CASCADE";
2684 break;
2686 string = "SET NULL";
2687 break;
2689 string = "SET DEFAULT";
2690 break;
2691 default:
2693 conForm->confupdtype);
2695 break;
2696 }
2697 if (string)
2699
2701 {
2704 break;
2706 string = "RESTRICT";
2707 break;
2709 string = "CASCADE";
2710 break;
2712 string = "SET NULL";
2713 break;
2715 string = "SET DEFAULT";
2716 break;
2717 default:
2719 conForm->confdeltype);
2721 break;
2722 }
2723 if (string)
2725
2726 /*
2727 * Add columns specified to SET NULL or SET DEFAULT if
2728 * provided.
2729 */
2731 Anum_pg_constraint_confdelsetcols, &isnull);
2732 if (!isnull)
2733 {
2737 }
2738
2739 break;
2740 }
2743 {
2748
2749 /* Start off the constraint definition */
2752 else
2754
2756
2763
2765
2766 /* Fetch and build target column list */
2768 Anum_pg_constraint_conkey);
2769
2773
2775
2776 /* Build including column list (from pg_index.indkeys) */
2778 Anum_pg_index_indnatts);
2780 {
2781 Datum cols;
2782 Datum *keys;
2783 int nKeys;
2785
2787
2789 Anum_pg_index_indkey);
2790
2792 &keys, NULL, &nKeys);
2793
2795 {
2797
2803 }
2804
2806 }
2808
2809 /* XXX why do we only print these bits if fullCommand? */
2811 {
2814
2816 {
2819 }
2820
2821 /*
2822 * Print the tablespace, unless it's the database default.
2823 * This is to help ALTER TABLE usage of this facility,
2824 * which needs this behavior to recreate exact catalog
2825 * state.
2826 */
2831 }
2832
2833 break;
2834 }
2836 {
2840 Node *expr;
2841 List *context;
2842
2843 /* Fetch constraint expression in parsetree form */
2845 Anum_pg_constraint_conbin);
2846
2849
2850 /* Set up deparsing context for Var nodes in constraint */
2852 {
2853 /* relation constraint */
2855 conForm->conrelid);
2856 }
2857 else
2858 {
2859 /* domain constraint --- can't have Vars */
2860 context = NIL;
2861 }
2862
2864 prettyFlags, 0);
2865
2866 /*
2867 * Now emit the constraint definition, adding NO INHERIT if
2868 * necessary.
2869 *
2870 * There are cases where the constraint expression will be
2871 * fully parenthesized and we don't need the outer parens ...
2872 * but there are other cases where we do need 'em. Be
2873 * conservative for now.
2874 *
2875 * Note that simply checking for leading '(' and trailing ')'
2876 * would NOT be good enough, consider "(x > 0) AND (y > 0)".
2877 */
2879 consrc,
2881 break;
2882 }
2884 {
2886 {
2888
2890
2896 }
2898 {
2899 /* conkey is null for domain not-null constraints */
2901 }
2902 break;
2903 }
2904
2906
2907 /*
2908 * There isn't an ALTER TABLE syntax for creating a user-defined
2909 * constraint trigger, but it seems better to print something than
2910 * throw an error; if we throw error then this function couldn't
2911 * safely be applied to all rows of pg_constraint.
2912 */
2914 break;
2916 {
2919 Datum *elems;
2920 int nElems;
2922 Oid *operators;
2923
2924 /* Extract operator OIDs from the pg_constraint tuple */
2926 Anum_pg_constraint_conexclop);
2927
2929 &elems, NULL, &nElems);
2930
2934
2935 /* pg_get_indexdef_worker does the rest */
2936 /* suppress tablespace because pg_dump wants it that way */
2938 pg_get_indexdef_worker(indexOid,
2939 0,
2940 operators,
2941 false,
2942 false,
2943 false,
2944 false,
2945 prettyFlags,
2946 false));
2947 break;
2948 }
2949 default:
2951 break;
2952 }
2953
2958
2959 /* Validated status is irrelevant when the constraint is NOT ENFORCED. */
2964
2965 /* Cleanup */
2966 systable_endscan(scandesc);
2968
2970}
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 3033 of file ruleutils.c.
3034{
3038 int prettyFlags;
3039
3040 prettyFlags = PRETTYFLAG_INDENT;
3041
3045 else
3046 PG_RETURN_NULL();
3047}
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 3050 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 3068 of file ruleutils.c.
3069{
3070 Node *node;
3072 Relids relids;
3073 List *context;
3077
3078 /* Convert input pg_node_tree (really TEXT) object to C string */
3080
3081 /* Convert expression to node tree */
3083
3085
3086 /*
3087 * Throw error if the input is a querytree rather than an expression tree.
3088 * While we could support queries here, there seems no very good reason
3089 * to. In most such catalog columns, we'll see a List of Query nodes, or
3090 * even nested Lists, so drill down to a non-List node before checking.
3091 */
3092 tst = node;
3099
3100 /*
3101 * Throw error if the expression contains Vars we won't be able to
3102 * deparse.
3103 */
3106 {
3111 }
3112 else
3113 {
3118 }
3119
3120 /*
3121 * Prepare deparse context if needed. If we are deparsing with a relid,
3122 * we need to transiently open and lock the rel, to make sure it won't go
3123 * away underneath us. (set_relation_column_names would lock it anyway,
3124 * so this isn't really introducing any new behavior.)
3125 */
3127 {
3132 }
3133 else
3134 context = NIL;
3135
3136 /* Deparse */
3138 prettyFlags, 0);
3139
3142
3144}
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 3848 of file ruleutils.c.
3849{
3853 Form_pg_proc proc;
3854 int numargs;
3855 Oid *argtypes;
3856 char **argnames;
3860 Node *node;
3864 bool isnull;
3866
3869 PG_RETURN_NULL();
3870
3873 {
3875 PG_RETURN_NULL();
3876 }
3877
3878 nth_inputarg = 0;
3881 nth_inputarg++;
3882
3885 &isnull);
3886 if (isnull)
3887 {
3889 PG_RETURN_NULL();
3890 }
3891
3895
3897
3898 /*
3899 * Calculate index into proargdefaults: proargdefaults corresponds to the
3900 * last N input arguments, where N = pronargdefaults.
3901 */
3903
3905 {
3907 PG_RETURN_NULL();
3908 }
3911
3913
3915}
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 3541 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 3567 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 3592 of file ruleutils.c.
3593{
3597
3600 PG_RETURN_NULL();
3601
3603 {
3605 PG_RETURN_NULL();
3606 }
3607
3609
3611
3613
3615}
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 3972 of file ruleutils.c.
3973{
3977 bool isnull;
3978
3980
3981 /* Look up the function */
3984 PG_RETURN_NULL();
3985
3987 if (isnull)
3988 {
3990 PG_RETURN_NULL();
3991 }
3992
3994
3996
3998}
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 3285 of file ruleutils.c.
3286{
3291 Form_pg_proc proc;
3293 Datum tmp;
3294 bool isnull;
3295 const char *prosrc;
3300
3302
3303 /* Look up the function */
3306 PG_RETURN_NULL();
3307
3310
3315
3317
3318 /*
3319 * We always qualify the function name, to ensure the right function gets
3320 * replaced.
3321 */
3329 {
3333 }
3334
3336
3339
3340 /* Emit some miscellaneous options on one line */
3342
3345 switch (proc->provolatile)
3346 {
3349 break;
3352 break;
3354 break;
3355 }
3356
3357 switch (proc->proparallel)
3358 {
3361 break;
3364 break;
3366 break;
3367 }
3368
3369 if (proc->proisstrict)
3371 if (proc->prosecdef)
3373 if (proc->proleakproof)
3375
3376 /* This code for the default cost and rows should match functioncmds.c */
3378 proc->prolang == ClanguageId)
3379 procost = 1;
3380 else
3381 procost = 100;
3384
3385 if (proc->prorows > 0 && proc->prorows != 1000)
3387
3388 if (proc->prosupport)
3389 {
3390 Oid argtypes[1];
3391
3392 /*
3393 * We should qualify the support function's name if it wouldn't be
3394 * resolved by lookup in the current search path.
3395 */
3396 argtypes[0] = INTERNALOID;
3398 generate_function_name(proc->prosupport, 1,
3399 NIL, argtypes,
3401 }
3402
3405
3406 /* Emit any proconfig options, one per line */
3408 if (!isnull)
3409 {
3412
3416
3418 {
3419 Datum d;
3420
3422 -1 /* varlenarray */ ,
3423 -1 /* TEXT's typlen */ ,
3424 false /* TEXT's typbyval */ ,
3426 &isnull);
3427 if (!isnull)
3428 {
3430 char *pos;
3431
3434 continue;
3435 *pos++ = '\0';
3436
3439
3440 /*
3441 * Variables that are marked GUC_LIST_QUOTE were already fully
3442 * quoted by flatten_set_variable_args() before they were put
3443 * into the proconfig array. However, because the quoting
3444 * rules used there aren't exactly like SQL's, we have to
3445 * break the list value apart and then quote the elements as
3446 * string literals. (The elements may be double-quoted as-is,
3447 * but we can't just feed them to the SQL parser; it would do
3448 * the wrong thing with elements that are zero-length or
3449 * longer than NAMEDATALEN.) Also, we need a special case for
3450 * empty lists.
3451 *
3452 * Variables that are not so marked should just be emitted as
3453 * simple string literals. If the variable is not known to
3454 * guc.c, we'll do that; this makes it unsafe to use
3455 * GUC_LIST_QUOTE for extension variables.
3456 */
3458 {
3461
3462 /* Parse string into list of identifiers */
3464 {
3465 /* this shouldn't fail really */
3467 }
3468 /* Special case: represent an empty list as NULL */
3472 {
3474
3478 }
3479 }
3480 else
3483 }
3484 }
3485 }
3486
3487 /* And finally the function definition ... */
3490 {
3492 }
3493 else
3494 {
3496
3498 if (!isnull)
3499 {
3502 }
3503
3505 prosrc = TextDatumGetCString(tmp);
3506
3507 /*
3508 * We always use dollar quoting. Figure out a suitable delimiter.
3509 *
3510 * Since the user is likely to be editing the function body string, we
3511 * shouldn't use a short delimiter that he might easily create a
3512 * conflict with. Hence prefer "$function$"/"$procedure$", but extend
3513 * if needed.
3514 */
3521
3525 }
3526
3528
3530
3532}
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 1189 of file ruleutils.c.
1190{
1192 int prettyFlags;
1193 char *res;
1194
1195 prettyFlags = PRETTYFLAG_INDENT;
1196
1198 false, false,
1199 false, false,
1200 prettyFlags, true);
1201
1203 PG_RETURN_NULL();
1204
1206}
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 1246 of file ruleutils.c.
1247{
1248 int prettyFlags;
1249
1251
1253 true, true,
1254 false, false,
1255 prettyFlags, false);
1256}
References fb(), GET_PRETTY_FLAGS, and pg_get_indexdef_worker().
Referenced by BuildIndexValueDescription().
◆ pg_get_indexdef_columns_extended()
Definition at line 1260 of file ruleutils.c.
1261{
1264 int prettyFlags;
1265
1267
1270 false, false,
1271 prettyFlags, false);
1272}
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 1209 of file ruleutils.c.
1210{
1214 int prettyFlags;
1215 char *res;
1216
1218
1220 colno != 0, false,
1221 false, false,
1222 prettyFlags, true);
1223
1225 PG_RETURN_NULL();
1226
1228}
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 1236 of file ruleutils.c.
1237{
1239 false, false,
1240 true, true,
1241 0, false);
1242}
References fb(), and pg_get_indexdef_worker().
Referenced by RememberIndexForRebuilding().
◆ pg_get_indexdef_worker()
|
static |
Definition at line 1281 of file ruleutils.c.
1286{
1287 /* might want a separate isConstraint parameter later */
1298 List *context;
1300 int keyno;
1310
1311 /*
1312 * Fetch the pg_index tuple by the Oid of the index
1313 */
1316 {
1317 if (missing_ok)
1320 }
1322
1325
1326 /* Must get indcollation, indclass, and indoption the hard way */
1328 Anum_pg_index_indcollation);
1330
1332 Anum_pg_index_indclass);
1334
1336 Anum_pg_index_indoption);
1338
1339 /*
1340 * Fetch the pg_class tuple of the index relation
1341 */
1346
1347 /*
1348 * Fetch the pg_am tuple of the index' access method
1349 */
1353 idxrelrec->relam);
1355
1356 /* Fetch the index AM's API struct */
1358
1359 /*
1360 * Get the index expressions, if any. (NOTE: we do not use the relcache
1361 * versions of the expressions and predicate, because we want to display
1362 * non-const-folded expressions.)
1363 */
1365 {
1368
1370 Anum_pg_index_indexprs);
1374 }
1375 else
1377
1379
1381
1382 /*
1383 * Start the index definition. Note that the index's name should never be
1384 * schema-qualified, but the indexed rel's name may be.
1385 */
1387
1389 {
1396 (prettyFlags & PRETTYFLAG_SCHEMA) ?
1400 else /* currently, must be EXCLUDE constraint */
1403 }
1404
1405 /*
1406 * Report the indexed attributes
1407 */
1410 {
1414
1415 /*
1416 * Ignore non-key attributes if told to.
1417 */
1419 break;
1420
1421 /* Otherwise, print INCLUDE to divide key and non-key attrs. */
1423 {
1426 }
1427
1428 if (!colno)
1431
1433 {
1434 /* Simple index column */
1437
1439 if (!colno || colno == keyno + 1)
1443 &keycolcollation);
1444 }
1445 else
1446 {
1447 /* expressional index */
1449
1454 /* Deparse */
1456 prettyFlags, 0);
1457 if (!colno || colno == keyno + 1)
1458 {
1459 /* Need parens if it's not a bare function call */
1462 else
1464 }
1467 }
1468
1469 /* Print additional decoration for (selected) key columns */
1471 (!colno || colno == keyno + 1))
1472 {
1477
1478 /* Add collation, if not default for column */
1482
1483 /* Add the operator class name, if not default */
1486
1488 {
1492 }
1493
1494 /* Add options if relevant */
1496 {
1497 /* if it supports sort ordering, report DESC and NULLS opts */
1499 {
1501 /* NULLS FIRST is the default in this case */
1504 }
1505 else
1506 {
1509 }
1510 }
1511
1512 /* Add the exclusion operator if relevant */
1516 keycoltype,
1517 keycoltype));
1518 }
1519 }
1520
1522 {
1524
1527
1528 /*
1529 * If it has options, append "WITH (options)"
1530 */
1533 {
1536 }
1537
1538 /*
1539 * Print tablespace, but only if requested
1540 */
1542 {
1544
1547 {
1552 }
1553 }
1554
1555 /*
1556 * If it's a partial index, decompile and append the predicate
1557 */
1559 {
1560 Node *node;
1563
1564 /* Convert text string to node tree */
1566 Anum_pg_index_indpred);
1570
1571 /* Deparse */
1573 prettyFlags, 0);
1576 else
1578 }
1579 }
1580
1581 /* Clean up */
1585
1587}
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 2486 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 2454 of file ruleutils.c.
2455{
2458 int prettyFlags;
2459 List *context;
2461
2463
2464 /* Quick exit if no partition constraint */
2466 PG_RETURN_NULL();
2467
2468 /*
2469 * Deparse and return the constraint expression.
2470 */
2471 prettyFlags = PRETTYFLAG_INDENT;
2474 false, prettyFlags, 0);
2475
2477}
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 2267 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 2282 of file ruleutils.c.
2283{
2284 int prettyFlags;
2285
2287
2289}
References fb(), GET_PRETTY_FLAGS, and pg_get_partkeydef_worker().
Referenced by ExecBuildSlotPartitionKeyDescription().
◆ pg_get_partkeydef_worker()
|
static |
Definition at line 2295 of file ruleutils.c.
2297{
2299 HeapTuple tuple;
2301 oidvector *partcollation;
2302 List *partexprs;
2304 List *context;
2305 Datum datum;
2307 int keyno;
2310
2313 {
2314 if (missing_ok)
2317 }
2318
2320
2322
2323 /* Must get partclass and partcollation the hard way */
2327
2331
2332
2333 /*
2334 * Get the expressions, if any. (NOTE: we do not use the relcache
2335 * versions of the expressions, because we want to display
2336 * non-const-folded expressions.)
2337 */
2339 {
2342
2347
2351
2353 }
2354 else
2355 partexprs = NIL;
2356
2359
2361
2363 {
2367 break;
2371 break;
2375 break;
2376 default:
2379 }
2380
2385 {
2390
2394 {
2395 /* Simple attribute reference */
2398
2403 &keycolcollation);
2404 }
2405 else
2406 {
2407 /* Expression */
2409
2414
2415 /* Deparse */
2417 prettyFlags, 0);
2418 /* Need parens if it's not a bare function call */
2421 else
2423
2426 }
2427
2428 /* Add collation, if not default for column */
2433
2434 /* Add the operator class name, if not default */
2437 }
2438
2441
2442 /* Clean up */
2443 ReleaseSysCache(tuple);
2444
2446}
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 1618 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 1599 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 571 of file ruleutils.c.
572{
574 int prettyFlags;
575 char *res;
576
577 prettyFlags = PRETTYFLAG_INDENT;
578
580
582 PG_RETURN_NULL();
583
585}
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 589 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 608 of file ruleutils.c.
609{
611 char nulls[1];
616
617 /*
618 * Do this first so that string is alloc'd in outer context not SPI's.
619 */
621
622 /*
623 * Connect to SPI manager
624 */
625 SPI_connect();
626
627 /*
628 * On the first call prepare the plan to lookup pg_rewrite. We read
629 * pg_rewrite over the SPI manager instead of using the syscache to be
630 * checked for read access on pg_rewrite.
631 */
633 {
634 Oid argtypes[1];
636
637 argtypes[0] = OIDOID;
643 }
644
645 /*
646 * Get the pg_rewrite tuple for this rule
647 */
649 nulls[0] = ' ';
654 {
655 /*
656 * There is no tuple data available here, just keep the output buffer
657 * empty.
658 */
659 }
660 else
661 {
662 /*
663 * Get the rule's definition and put it into executor's memory
664 */
668 }
669
670 /*
671 * Disconnect from SPI manager
672 */
675
678
680}
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 3191 of file ruleutils.c.
3192{
3196 Oid tableOid;
3202 SysScanDesc scan;
3204
3205 /* Look up table name. Can't lock it - we might not have privileges. */
3208
3209 /* Get the number of the column */
3211
3218
3219 /* Search the dependency table for the dependent sequence */
3221
3222 ScanKeyInit(&key[0],
3226 ScanKeyInit(&key[1],
3227 Anum_pg_depend_refobjid,
3229 ObjectIdGetDatum(tableOid));
3230 ScanKeyInit(&key[2],
3234
3236 NULL, 3, key);
3237
3239 {
3241
3242 /*
3243 * Look for an auto dependency (serial column) or internal dependency
3244 * (identity column) of a sequence on a column. (We need the relkind
3245 * test because indexes can also have auto dependencies on columns.)
3246 */
3248 deprec->objsubid == 0 &&
3252 {
3254 break;
3255 }
3256 }
3257
3258 systable_endscan(scan);
3260
3262 {
3264
3266
3268 }
3269
3270 PG_RETURN_NULL();
3271}
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 2012 of file ruleutils.c.
2013{
2017 int colno;
2019 ArrayType *arr;
2020 char *enabled;
2021 Datum datum;
2026 List *context;
2030 int ncolumns;
2031
2033
2035 {
2036 if (missing_ok)
2039 }
2040
2041 /* has the statistics expressions? */
2043
2045
2046 /*
2047 * Get the statistics expressions, if any. (NOTE: we do not use the
2048 * relcache versions of the expressions, because we want to display
2049 * non-const-folded expressions.)
2050 */
2052 {
2055
2061 }
2062 else
2063 exprs = NIL;
2064
2065 /* count the number of columns (attributes and expressions) */
2067
2069
2071 {
2076
2077 /*
2078 * Decode the stxkind column so that we know which stats types to
2079 * print.
2080 */
2083 arr = DatumGetArrayTypeP(datum);
2085 ARR_HASNULL(arr) ||
2089
2093
2095 {
2102
2103 /* ignore STATS_EXT_EXPRESSIONS (it's built automatically) */
2104 }
2105
2106 /*
2107 * If any option is disabled, then we'll need to append the types
2108 * clause to show which options are enabled. We omit the types clause
2109 * on purpose when all options are enabled, so a pg_dump/pg_restore
2110 * will create all statistics types on a newer postgres version, if
2111 * the statistics had all options enabled on the original version.
2112 *
2113 * But if the statistics is defined on just a single column, it has to
2114 * be an expression statistics. In that case we don't need to specify
2115 * kinds.
2116 */
2118 (ncolumns > 1))
2119 {
2121
2123
2125 {
2128 }
2129
2131 {
2134 }
2135
2138
2140 }
2141
2143 }
2144
2145 /* decode simple column references */
2147 {
2150
2151 if (colno > 0)
2153
2155
2157 }
2158
2160 statextrec->stxrelid);
2161
2163 {
2167
2169 prettyFlags, 0);
2170
2171 if (colno > 0)
2173
2174 /* Need parens if it's not a bare function call */
2177 else
2179
2180 colno++;
2181 }
2182
2186
2188
2190}
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 1967 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 1995 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 2196 of file ruleutils.c.
2197{
2201 Datum datum;
2202 List *context;
2206 char *tmp;
2208
2210
2212 PG_RETURN_NULL();
2213
2214 /* Does the stats object have expressions? */
2216
2217 /* no expressions? we're done */
2219 {
2221 PG_RETURN_NULL();
2222 }
2223
2225
2226 /*
2227 * Get the statistics expressions, and deparse them into text values.
2228 */
2231 tmp = TextDatumGetCString(datum);
2233 pfree(tmp);
2234
2236 statextrec->stxrelid);
2237
2239 {
2243
2245 prettyFlags, 0);
2246
2247 astate = accumArrayResult(astate,
2249 false,
2250 TEXTOID,
2251 CurrentMemoryContext);
2252 }
2253
2255
2257}
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 1985 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 882 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 896 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 911 of file ruleutils.c.
912{
920 char *tgname;
921 char *tgoldtable;
922 char *tgnewtable;
924 bool isnull;
925
926 /*
927 * Fetch the pg_trigger tuple by the Oid of the trigger
928 */
930
932 Anum_pg_trigger_oid,
935
938
940
942 {
946 }
947
949
950 /*
951 * Start the trigger definition. Note that the trigger's name should never
952 * be schema-qualified, but the trigger rel's name may be.
953 */
955
959 quote_identifier(tgname));
960
967 else
969
971 {
973 findx++;
974 }
976 {
979 else
981 findx++;
982 }
984 {
987 else
989 findx++;
990 /* tgattr is first var-width field, so OK to access directly */
992 {
994
997 {
999
1005 }
1006 }
1007 }
1009 {
1012 else
1014 findx++;
1015 }
1016
1017 /*
1018 * In non-pretty mode, always schema-qualify the target table name for
1019 * safety. In pretty mode, schema-qualify only if not visible.
1020 */
1022 pretty ?
1025
1027 {
1036 else
1038 }
1039
1041 tgrel->rd_att, &isnull);
1042 if (!isnull)
1044 else
1045 tgoldtable = NULL;
1047 tgrel->rd_att, &isnull);
1048 if (!isnull)
1050 else
1051 tgnewtable = NULL;
1053 {
1057 quote_identifier(tgoldtable));
1060 quote_identifier(tgnewtable));
1061 }
1062
1065 else
1067
1068 /* If the trigger has a WHEN qualification, add that */
1070 tgrel->rd_att, &isnull);
1071 if (!isnull)
1072 {
1073 Node *qual;
1074 char relkind;
1075 deparse_context context;
1079
1081
1083
1085
1086 /* Build minimal OLD and NEW RTEs for the rel */
1090 oldrte->relkind = relkind;
1097
1101 newrte->relkind = relkind;
1108
1109 /* Build two-element rtable */
1117
1118 /* Set up context with one-deep namespace stack */
1132
1134
1136 }
1137
1142
1144 {
1145 char *p;
1147
1149 tgrel->rd_att, &isnull);
1150 if (isnull)
1154 {
1158 /* advance p to next string embedded in tgargs */
1159 while (*p)
1160 p++;
1161 p++;
1162 }
1163 }
1164
1165 /* We deliberately do not put semi-colon at end */
1167
1168 /* Clean up */
1170
1172
1174}
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 3153 of file ruleutils.c.
3154{
3159
3160 /*
3161 * Allocate space for the result
3162 */
3165
3166 /*
3167 * Get the pg_authid entry and print the result
3168 */
3171 {
3175 }
3176 else
3178
3180}
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 689 of file ruleutils.c.
690{
691 /* By OID */
693 int prettyFlags;
694 char *res;
695
696 prettyFlags = PRETTYFLAG_INDENT;
697
699
701 PG_RETURN_NULL();
702
704}
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 708 of file ruleutils.c.
709{
710 /* By OID */
713 int prettyFlags;
714 char *res;
715
717
719
721 PG_RETURN_NULL();
722
724}
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 747 of file ruleutils.c.
748{
749 /* By qualified name */
751 int prettyFlags;
753 Oid viewoid;
754 char *res;
755
756 prettyFlags = PRETTYFLAG_INDENT;
757
758 /* Look up view name. Can't lock it - we might not have privileges. */
761
763
765 PG_RETURN_NULL();
766
768}
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 772 of file ruleutils.c.
773{
774 /* By qualified name */
777 int prettyFlags;
779 Oid viewoid;
780 char *res;
781
783
784 /* Look up view name. Can't lock it - we might not have privileges. */
787
789
791 PG_RETURN_NULL();
792
794}
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 800 of file ruleutils.c.
801{
803 char nulls[2];
808
809 /*
810 * Do this first so that string is alloc'd in outer context not SPI's.
811 */
813
814 /*
815 * Connect to SPI manager
816 */
817 SPI_connect();
818
819 /*
820 * On the first call prepare the plan to lookup pg_rewrite. We read
821 * pg_rewrite over the SPI manager instead of using the syscache to be
822 * checked for read access on pg_rewrite.
823 */
825 {
826 Oid argtypes[2];
828
829 argtypes[0] = OIDOID;
830 argtypes[1] = NAMEOID;
836 }
837
838 /*
839 * Get the pg_rewrite tuple for the view's SELECT rule
840 */
843 nulls[0] = ' ';
844 nulls[1] = ' ';
849 {
850 /*
851 * There is no tuple data available here, just keep the output buffer
852 * empty.
853 */
854 }
855 else
856 {
857 /*
858 * Get the rule's definition and put it into executor's memory
859 */
863 }
864
865 /*
866 * Disconnect from SPI manager
867 */
870
873
875}
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 727 of file ruleutils.c.
728{
729 /* By OID */
732 int prettyFlags;
733 char *res;
734
735 /* calling this implies we want pretty printing */
737
739
741 PG_RETURN_NULL();
742
744}
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 5693 of file ruleutils.c.
5694{
5695 /* Free the ancestor list made in push_ancestor_plan */
5697
5698 /* Restore fields changed by push_ancestor_plan */
5700}
References fb(), and list_free().
Referenced by get_name_for_var_field(), and get_parameter().
◆ pop_child_plan()
|
static |
Definition at line 5642 of file ruleutils.c.
5643{
5644 List *ancestors;
5645
5646 /* Get rid of ancestors list cell added by push_child_plan */
5648
5649 /* Restore fields changed by push_child_plan */
5651
5652 /* Make sure dpns->ancestors is right (may be unnecessary) */
5653 dpns->ancestors = ancestors;
5654}
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 3660 of file ruleutils.c.
3662{
3664 int numargs;
3665 Oid *argtypes;
3666 char **argnames;
3675
3677 &argtypes, &argnames, &argmodes);
3678
3679 nlackdefaults = numargs;
3681 {
3683 bool isnull;
3684
3687 &isnull);
3688 if (!isnull)
3689 {
3691
3696 /* nlackdefaults counts only *input* arguments lacking defaults */
3698 }
3699 }
3700
3701 /* Check for special treatment of ordered-set aggregates */
3703 {
3706
3710 proc->oid);
3715 }
3716
3717 argsprinted = 0;
3718 inputargno = 0;
3720 {
3726
3728 {
3730
3731 /*
3732 * For procedures, explicitly mark all argument modes, so as
3733 * to avoid ambiguity with the SQL syntax for DROP PROCEDURE.
3734 */
3737 else
3740 break;
3744 break;
3748 break;
3752 break;
3756 break;
3757 default:
3761 break;
3762 }
3765
3767 continue;
3768
3770 {
3774 }
3777
3779 if (argname && argname[0])
3783 {
3784 Node *expr;
3785
3789
3792 }
3793 argsprinted++;
3794
3795 /* nasty hack: print the last arg twice for variadic ordered-set agg */
3797 {
3798 i--;
3799 /* aggs shouldn't have defaults anyway, but just to be sure ... */
3801 }
3802 }
3803
3805}
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 3622 of file ruleutils.c.
3623{
3627
3629
3630 if (proc->proretset)
3631 {
3632 /* It might be a table function; try to print the arguments */
3637 else
3639 }
3640
3642 {
3643 /* Not a table function, so do the normal thing */
3644 if (proc->proretset)
3647 }
3648
3650}
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 3918 of file ruleutils.c.
3919{
3920 int numargs;
3921 Oid *argtypes;
3922 char **argnames;
3925 Datum tmp;
3926 Node *n;
3927
3930 &argtypes, &argnames, &argmodes);
3931 dpns.numargs = numargs;
3932 dpns.argnames = argnames;
3933
3936
3938 {
3939 List *stmts;
3941
3943
3945
3947 {
3949
3950 /* It seems advisable to get at least AccessShareLock on rels */
3956 }
3957
3959 }
3960 else
3961 {
3963
3964 /* It seems advisable to get at least AccessShareLock on rels */
3967 0, WRAP_COLUMN_DEFAULT, 0);
3968 }
3969}
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 3820 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 13661 of file ruleutils.c.
13662{
13666
13669 {
13672 {
13673 /* If subexpression is NULL, get_rule_expr prints nothing */
13677 }
13678 /* If subexpression is NULL, get_rule_expr prints nothing */
13681 }
13682}
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 13583 of file ruleutils.c.
13584{
13587
13588 for (;;)
13589 {
13591 break;
13593 {
13595 Oid typrelid;
13596 char *fieldname;
13597
13598 /* lookup tuple type */
13599 typrelid = get_typ_typrelid(fstore->resulttype);
13602 format_type_be(fstore->resulttype));
13603
13604 /*
13605 * Print the field name. There should only be one target field in
13606 * stored rules. There could be more than that in executable
13607 * target lists, but this function cannot be used for that case.
13608 */
13610 fieldname = get_attname(typrelid,
13613
13614 /*
13615 * We ignore arg since it should be an uninteresting reference to
13616 * the target column or subcolumn.
13617 */
13619 }
13621 {
13623
13625 break;
13626
13627 printSubscripts(sbsref, context);
13628
13629 /*
13630 * We ignore refexpr since it should be an uninteresting reference
13631 * to the target column or subcolumn.
13632 */
13634 }
13636 {
13638 /* If it's an explicit domain coercion, we're done */
13640 break;
13641 /* Tentatively descend past the CoerceToDomain */
13643 }
13644 else
13645 break;
13646 }
13647
13648 /*
13649 * If we descended past a CoerceToDomain whose argument turned out not to
13650 * be a FieldStore or array assignment, back up to the CoerceToDomain.
13651 * (This is not enough to be fully correct if there are nested implicit
13652 * CoerceToDomains, but such cases shouldn't ever occur.)
13653 */
13656
13657 return node;
13658}
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 1865 of file ruleutils.c.
1866{
1871
1873}
References a, b, fb(), lfirst_node, linitial, and strVal.
Referenced by make_propgraphdef_properties().
◆ push_ancestor_plan()
|
static |
Definition at line 5672 of file ruleutils.c.
5674{
5676
5677 /* Save state for restoration later */
5679
5680 /* Build a new ancestor list with just this node's ancestors */
5681 dpns->ancestors =
5684
5685 /* Set attention on selected ancestor */
5687}
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 5625 of file ruleutils.c.
5627{
5628 /* Save state for restoration later */
5630
5631 /* Link current plan node into ancestors list */
5633
5634 /* Set attention on selected child */
5636}
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 13691 of file ruleutils.c.
13692{
13693 /*
13694 * Can avoid quoting if ident starts with a lowercase letter or underscore
13695 * and contains only lowercase letters, digits, and underscores, *and* is
13696 * not any SQL keyword. Otherwise, supply quotes.
13697 */
13700 const char *ptr;
13703
13704 /*
13705 * would like to use <ctype.h> macros here, but they might yield unwanted
13706 * locale-specific results...
13707 */
13709
13711 {
13713
13717 {
13718 /* okay */
13719 }
13720 else
13721 {
13724 nquotes++;
13725 }
13726 }
13727
13730
13732 {
13733 /*
13734 * Check for keyword. We quote keywords except for unreserved ones.
13735 * (In some cases we could avoid quoting a col_name or type_func_name
13736 * keyword, but it seems much harder than it's worth to tell that.)
13737 *
13738 * Note: ScanKeywordLookup() does case-insensitive comparison, but
13739 * that's fine, since we already know we have all-lower-case.
13740 */
13742
13745 }
13746
13749
13751
13755 {
13757
13761 }
13764
13766}
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_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(), libpqrcv_alter_slot(), make_propgraphdef_elements(), make_propgraphdef_labels(), make_propgraphdef_properties(), make_ruledef(), NameListToQuotedString(), old_9_6_invalidate_hash_indexes(), 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(), ReplicationSlotDropAtPubNode(), sepgsql_attribute_post_create(), sepgsql_database_post_create(), sepgsql_relation_post_create(), sepgsql_schema_post_create(), serialize_deflist(), set_frozenxids(), show_sortorder_options(), show_window_def(), test_inline_in_from_support_func(), text_format_string_conversion(), tuple_to_stringinfo(), and worker_spi_main().
◆ quote_qualified_identifier()
Definition at line 13775 of file ruleutils.c.
13777{
13779
13785}
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_variable(), and resolve_special_varno().
◆ select_rtable_names_for_explain()
Definition at line 4217 of file ruleutils.c.
4218{
4220
4222 dpns.rtable = rtable;
4227 /* We needn't bother computing column aliases yet */
4228
4230}
References fb(), NIL, and set_rtable_names().
Referenced by ExplainPrintPlan().
◆ set_deparse_context_plan()
Definition at line 4187 of file ruleutils.c.
4188{
4190
4191 /* Should always have one-entry namespace list for Plan deparsing */
4194
4195 /* Set our attention on the specific plan node passed in */
4196 dpns->ancestors = ancestors;
4198
4199 /* For ModifyTable, set aliases for OLD and NEW in RETURNING */
4201 {
4204 }
4205
4207}
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 4391 of file ruleutils.c.
4393{
4396
4397 /* Initialize *dpns and fill rtable/ctes links */
4403 dpns->ret_old_alias = query->returningOldAlias;
4404 dpns->ret_new_alias = query->returningNewAlias;
4405
4406 /* Assign a unique relation alias to each RTE */
4408
4409 /* Initialize dpns->rtable_columns to contain zeroed structs */
4414
4415 /* If it's a utility query, it won't have a jointree */
4417 {
4418 /* Detect whether global uniqueness of USING names is needed */
4419 dpns->unique_using =
4421
4422 /*
4423 * Select names for columns merged by USING, via a recursive pass over
4424 * the query jointree.
4425 */
4427 }
4428
4429 /*
4430 * Now assign remaining column aliases for each RTE. We do this in a
4431 * linear scan of the rtable, so as to process RTEs whether or not they
4432 * are in the jointree (we mustn't miss NEW.*, INSERT target relations,
4433 * etc). JOIN RTEs must be processed after their children, but this is
4434 * okay because they appear later in the rtable list than their children
4435 * (cf Asserts in identify_join_columns()).
4436 */
4438 {
4441
4444 else
4446 }
4447}
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 5514 of file ruleutils.c.
5515{
5517
5518 /*
5519 * We special-case Append and MergeAppend to pretend that the first child
5520 * plan is the OUTER referent; we have to interpret OUTER Vars in their
5521 * tlists according to one of the children, and the first one is the most
5522 * natural choice.
5523 */
5528 else
5530
5533 else
5535
5536 /*
5537 * For a SubqueryScan, pretend the subplan is INNER referent. (We don't
5538 * use OUTER because that could someday conflict with the normal meaning.)
5539 * Likewise, for a CteScan, pretend the subquery's plan is INNER referent.
5540 * For a WorkTableScan, locate the parent RecursiveUnion plan node and use
5541 * that as INNER referent.
5542 *
5543 * For MERGE, pretend the ModifyTable's source plan (its outer plan) is
5544 * INNER referent. This is the join from the target relation to the data
5545 * source, and all INNER_VAR Vars in other parts of the query refer to its
5546 * targetlist.
5547 *
5548 * For ON CONFLICT DO SELECT/UPDATE we just need the inner tlist to point
5549 * to the excluded expression's tlist. (Similar to the SubqueryScan we
5550 * don't want to reuse OUTER, it's used for RETURNING in some modify table
5551 * cases, although not INSERT .. CONFLICT).
5552 */
5562 {
5565 else
5567 }
5568 else
5570
5575 else
5577
5578 /* Set up referent for INDEX_VAR Vars, if needed */
5585 else
5587}
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 4940 of file ruleutils.c.
4942{
4954
4955 /* Look up the previously-filled-in child deparse_columns structs */
4958
4959 /*
4960 * Ensure colinfo->colnames has a slot for each column. (It could be long
4961 * enough already, if we pushed down a name for the last column.) Note:
4962 * it's possible that one or both inputs now have more columns than there
4963 * were when the query was parsed, but we'll deal with that below. We
4964 * only need entries in colnames for pre-existing columns.
4965 */
4969
4970 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4972
4973 /*
4974 * Scan the join output columns, select an alias for each one, and store
4975 * it in colinfo->colnames. If there are USING columns, set_using_names()
4976 * already selected their names, so we can start the loop at the first
4977 * non-merged column.
4978 */
4981 {
4984
4985 /* Join column must refer to at least one input column */
4987
4988 /* Get the child column name */
4993 else
4994 {
4995 /* We're joining system columns --- use eref name */
4997 }
4998
4999 /* If child col has been dropped, no need to assign a join colname */
5001 {
5003 continue;
5004 }
5005
5006 /* In an unnamed join, just report child column names as-is */
5008 {
5011 continue;
5012 }
5013
5014 /* If alias already assigned, that's what to use */
5016 {
5017 /* If user wrote an alias, prefer that over real column name */
5020 else
5021 colname = real_colname;
5022
5023 /* Unique-ify and insert into colinfo */
5025
5028 }
5029
5030 /* Remember if any assigned aliases differ from "real" name */
5033 }
5034
5035 /*
5036 * Calculate number of columns the join would have if it were re-parsed
5037 * now, and create storage for the new_colnames and is_new_col arrays.
5038 *
5039 * Note: colname_is_unique will be consulting new_colnames[] during the
5040 * loops below, so its not-yet-filled entries must be zeroes.
5041 */
5047
5048 /*
5049 * Generating the new_colnames array is a bit tricky since any new columns
5050 * added since parse time must be inserted in the right places. This code
5051 * must match the parser, which will order a join's columns as merged
5052 * columns first (in USING-clause order), then non-merged columns from the
5053 * left input (in attnum order), then non-merged columns from the right
5054 * input (ditto). If one of the inputs is itself a join, its columns will
5055 * be ordered according to the same rule, which means newly-added columns
5056 * might not be at the end. We can figure out what's what by consulting
5057 * the leftattnos and rightattnos arrays plus the input is_new_col arrays.
5058 *
5059 * In these loops, i indexes leftattnos/rightattnos (so it's join varattno
5060 * less one), j indexes new_colnames/is_new_col, and ic/jc have similar
5061 * meanings for the current child RTE.
5062 */
5063
5064 /* Handle merged columns; they are first and can't be new */
5069 {
5070 /* column name is already determined and known unique */
5073
5074 /* build bitmapsets of child attnums of merged columns */
5079
5081 }
5082
5083 /* Handle non-merged left-child columns */
5084 ic = 0;
5086 {
5088
5090 {
5091 /* Advance ic to next non-dropped old column of left child */
5094 ic++;
5096 ic++;
5097 /* If it is a merged column, we already processed it */
5099 continue;
5100 /* Else, advance i to the corresponding existing join column */
5103 i++;
5106 /* Use the already-assigned name of this column */
5108 i++;
5109 }
5110 else
5111 {
5112 /*
5113 * Unique-ify the new child column name and assign, unless we're
5114 * in an unnamed join, in which case just copy
5115 */
5117 {
5123 }
5124 else
5127 }
5128
5130 j++;
5131 }
5132
5133 /* Handle non-merged right-child columns in exactly the same way */
5134 ic = 0;
5136 {
5138
5140 {
5141 /* Advance ic to next non-dropped old column of right child */
5144 ic++;
5146 ic++;
5147 /* If it is a merged column, we already processed it */
5149 continue;
5150 /* Else, advance i to the corresponding existing join column */
5153 i++;
5156 /* Use the already-assigned name of this column */
5158 i++;
5159 }
5160 else
5161 {
5162 /*
5163 * Unique-ify the new child column name and assign, unless we're
5164 * in an unnamed join, in which case just copy
5165 */
5167 {
5173 }
5174 else
5177 }
5178
5180 j++;
5181 }
5182
5183 /* Assert we processed the right number of columns */
5184#ifdef USE_ASSERT_CHECKING
5186 i++;
5189#endif
5190
5191 /* We're now done needing the colinfo's names_hash */
5193
5194 /*
5195 * For a named join, print column aliases if we changed any from the child
5196 * names. Unnamed joins cannot print aliases.
5197 */
5200 else
5202}
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 4737 of file ruleutils.c.
4739{
4740 int ncolumns;
4746
4747 /*
4748 * Construct an array of the current "real" column names of the RTE.
4749 * real_colnames[] will be indexed by physical column number, with NULL
4750 * entries for dropped columns.
4751 */
4753 {
4754 /* Relation --- look to the system catalogs for up-to-date info */
4755 Relation rel;
4756 TupleDesc tupdesc;
4757
4759 tupdesc = RelationGetDescr(rel);
4760
4761 ncolumns = tupdesc->natts;
4763
4765 {
4767
4768 if (attr->attisdropped)
4770 else
4772 }
4774 }
4775 else
4776 {
4777 /* Otherwise get the column names from eref or expandRTE() */
4778 List *colnames;
4780
4781 /*
4782 * Functions returning composites have the annoying property that some
4783 * of the composite type's columns might have been dropped since the
4784 * query was parsed. If possible, use expandRTE() to handle that
4785 * case, since it has the tedious logic needed to find out about
4786 * dropped columns. However, if we're explaining a plan, then we
4787 * don't have rte->functions because the planner thinks that won't be
4788 * needed later, and that breaks expandRTE(). So in that case we have
4789 * to rely on rte->eref, which may lead us to report a dropped
4790 * column's old name; that seems close enough for EXPLAIN's purposes.
4791 *
4792 * For non-RELATION, non-FUNCTION RTEs, we can just look at rte->eref,
4793 * which should be sufficiently up-to-date: no other RTE types can
4794 * have columns get dropped from under them after parsing.
4795 */
4797 {
4798 /* Since we're not creating Vars, rtindex etc. don't matter */
4801 }
4802 else
4803 colnames = rte->eref->colnames;
4804
4805 ncolumns = list_length(colnames);
4807
4808 i = 0;
4810 {
4811 /*
4812 * If the column name we find here is an empty string, then it's a
4813 * dropped column, so change to NULL.
4814 */
4816
4820 i++;
4821 }
4822 }
4823
4824 /*
4825 * Ensure colinfo->colnames has a slot for each column. (It could be long
4826 * enough already, if we pushed down a name for the last column.) Note:
4827 * it's possible that there are now more columns than there were when the
4828 * query was parsed, ie colnames could be longer than rte->eref->colnames.
4829 * We must assign unique aliases to the new columns too, else there could
4830 * be unresolved conflicts when the view/rule is reloaded.
4831 */
4834
4835 /*
4836 * Make sufficiently large new_colnames and is_new_col arrays, too.
4837 *
4838 * Note: because we leave colinfo->num_new_cols zero until after the loop,
4839 * colname_is_unique will not consult that array, which is fine because it
4840 * would only be duplicate effort.
4841 */
4844
4845 /* If the RTE is wide enough, use a hash table to avoid O(N^2) costs */
4847
4848 /*
4849 * Scan the columns, select a unique alias for each one, and store it in
4850 * colinfo->colnames and colinfo->new_colnames. The former array has NULL
4851 * entries for dropped columns, the latter omits them. Also mark
4852 * new_colnames entries as to whether they are new since parse time; this
4853 * is the case for entries beyond the length of rte->eref->colnames.
4854 */
4857 j = 0;
4859 {
4862
4863 /* Skip dropped columns */
4865 {
4867 continue;
4868 }
4869
4870 /* If alias already assigned, that's what to use */
4872 {
4873 /* If user wrote an alias, prefer that over real column name */
4876 else
4877 colname = real_colname;
4878
4879 /* Unique-ify and insert into colinfo */
4881
4884 }
4885
4886 /* Put names of non-dropped columns in new_colnames[] too */
4888 /* And mark them as new or not */
4890 j++;
4891
4892 /* Remember if any assigned aliases differ from "real" name */
4895 }
4896
4897 /* We're now done needing the colinfo's names_hash */
4899
4900 /*
4901 * Set correct length for new_colnames[] array. (Note: if columns have
4902 * been added, colinfo->num_cols includes them, which is not really quite
4903 * right but is harmless, since any new columns must be at the end where
4904 * they won't affect varattnos of pre-existing columns.)
4905 */
4907
4908 /*
4909 * For a relation RTE, we need only print the alias column names if any
4910 * are different from the underlying "real" names. For a function RTE,
4911 * always emit a complete column alias list; this is to protect against
4912 * possible instability of the default column names (eg, from altering
4913 * parameter names). For tablefunc RTEs, we never print aliases, because
4914 * the column names are part of the clause itself. For other RTE types,
4915 * print if we changed anything OR if there were user-written column
4916 * aliases (since the latter would be part of the underlying "reality").
4917 */
4926 else
4928}
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 4246 of file ruleutils.c.
4248{
4250 HTAB *names_hash;
4252 bool found;
4253 int rtindex;
4255
4257 /* nothing more to do if empty rtable */
4259 return;
4260
4261 /*
4262 * We use a hash table to hold known names, so that this process is O(N)
4263 * not O(N^2) for N names.
4264 */
4270 &hash_ctl,
4272
4273 /* Preload the hash table with names appearing in parent_namespaces */
4275 {
4278
4280 {
4282
4284 continue;
4286 oldname,
4287 HASH_ENTER,
4288 &found);
4289 /* we do not complain about duplicate names in parent namespaces */
4290 hentry->counter = 0;
4291 }
4292 }
4293
4294 /* Now we can scan the rtable */
4295 rtindex = 1;
4297 {
4299 char *refname;
4300
4301 /* Just in case this takes an unreasonable amount of time ... */
4302 CHECK_FOR_INTERRUPTS();
4303
4305 {
4306 /* Ignore unreferenced RTE */
4307 refname = NULL;
4308 }
4310 {
4311 /* If RTE has a user-defined alias, prefer that */
4312 refname = rte->alias->aliasname;
4313 }
4315 {
4316 /* Use the current actual name of the relation */
4318 }
4320 {
4321 /* Unnamed join has no refname */
4322 refname = NULL;
4323 }
4324 else
4325 {
4326 /* Otherwise use whatever the parser assigned */
4327 refname = rte->eref->aliasname;
4328 }
4329
4330 /*
4331 * If the selected name isn't unique, append digits to make it so, and
4332 * make a new hash entry for it once we've got a unique name. For a
4333 * very long input name, we might have to truncate to stay within
4334 * NAMEDATALEN.
4335 */
4336 if (refname)
4337 {
4339 refname,
4340 HASH_ENTER,
4341 &found);
4342 if (found)
4343 {
4344 /* Name already in use, must choose a new one */
4348
4349 do
4350 {
4352 for (;;)
4353 {
4357 break;
4358 /* drop chars from refname to keep all the digits */
4360 refnamelen - 1);
4361 }
4363 modname,
4364 HASH_ENTER,
4365 &found);
4366 } while (found);
4368 refname = modname;
4369 }
4370 else
4371 {
4372 /* Name not previously used, need only initialize hentry */
4373 hentry->counter = 0;
4374 }
4375 }
4376
4378 rtindex++;
4379 }
4380
4381 hash_destroy(names_hash);
4382}
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 4460 of file ruleutils.c.
4461{
4464
4465 /* Initialize dpns->rtable_columns to contain zeroed structs */
4470
4471 /* Assign unique column aliases within each non-join RTE */
4473 {
4476
4479 }
4480}
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 4572 of file ruleutils.c.
4573{
4575 {
4576 /* nothing to do now */
4577 }
4579 {
4582
4585 }
4587 {
4591 int *leftattnos;
4592 int *rightattnos;
4597
4598 /* Get info about the shape of the join */
4600 leftattnos = colinfo->leftattnos;
4601 rightattnos = colinfo->rightattnos;
4602
4603 /* Look up the not-yet-filled-in child deparse_columns structs */
4606
4607 /*
4608 * If this join is unnamed, then we cannot substitute new aliases at
4609 * this level, so any name requirements pushed down to here must be
4610 * pushed down again to the children.
4611 */
4613 {
4615 {
4617
4619 continue;
4620
4621 /* Push down to left column, unless it's a system column */
4623 {
4626 }
4627
4628 /* Same on the righthand side */
4630 {
4633 }
4634 }
4635 }
4636
4637 /*
4638 * If there's a USING clause, select the USING column names and push
4639 * those names down to the children. We have two strategies:
4640 *
4641 * If dpns->unique_using is true, we force all USING names to be
4642 * unique across the whole query level. In principle we'd only need
4643 * the names of dangerous USING columns to be globally unique, but to
4644 * safely assign all USING names in a single pass, we have to enforce
4645 * the same uniqueness rule for all of them. However, if a USING
4646 * column's name has been pushed down from the parent, we should use
4647 * it as-is rather than making a uniqueness adjustment. This is
4648 * necessary when we're at an unnamed join, and it creates no risk of
4649 * ambiguity. Also, if there's a user-written output alias for a
4650 * merged column, we prefer to use that rather than the input name;
4651 * this simplifies the logic and seems likely to lead to less aliasing
4652 * overall.
4653 *
4654 * If dpns->unique_using is false, we only need USING names to be
4655 * unique within their own join RTE. We still need to honor
4656 * pushed-down names, though.
4657 *
4658 * Though significantly different in results, these two strategies are
4659 * implemented by the same code, with only the difference of whether
4660 * to put assigned names into dpns->using_names.
4661 */
4663 {
4664 /* Copy the input parentUsing list so we don't modify it */
4665 parentUsing = list_copy(parentUsing);
4666
4667 /* USING names must correspond to the first join output columns */
4669 i = 0;
4671 {
4673
4674 /* Assert it's a merged column */
4676
4677 /* Adopt passed-down name if any, else select unique name */
4680 else
4681 {
4682 /* Prefer user-written output alias if any */
4685 /* Make it appropriately unique */
4689 colname);
4690 /* Save it as output column name, too */
4692 }
4693
4694 /* Remember selected names for use later */
4696 parentUsing = lappend(parentUsing, colname);
4697
4698 /* Push down to left column, unless it's a system column */
4700 {
4703 }
4704
4705 /* Same on the righthand side */
4707 {
4710 }
4711
4712 i++;
4713 }
4714 }
4715
4716 /* Mark child deparse_columns structs with correct parentUsing info */
4717 leftcolinfo->parentUsing = parentUsing;
4718 rightcolinfo->parentUsing = parentUsing;
4719
4720 /* Now recursively assign USING column names in children */
4723 }
4724 else
4727}
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 12401 of file ruleutils.c.
12402{
12404
12405 /*
12406 * We always form the string literal according to standard SQL rules.
12407 */
12410 {
12412
12416 }
12418}
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 14231 of file ruleutils.c.
14232{
14234
14238}
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().
