PostgreSQL Source Code: src/backend/utils/adt/regproc.c Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
21
22#include <ctype.h>
23
45
49 List **names, int *nargs, Oid *argtypes,
50 Node *escontext);
51
52
53
54
55
56
57
58
59
60
61
62
63
64
67{
69 Node *escontext = fcinfo->context;
73
74
75 if (parseDashOrOid(pro_name_or_oid, &result, escontext))
77
78
79
80
81
82
83
85 elog(ERROR, "regproc values must be OIDs in bootstrap mode");
86
87
88
89
90
92 if (names == NIL)
94
96
97 if (clist == NULL)
99 (errcode(ERRCODE_UNDEFINED_FUNCTION),
100 errmsg("function \"%s\" does not exist", pro_name_or_oid)));
101 else if (clist->next != NULL)
103 (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
104 errmsg("more than one function named \"%s\"",
105 pro_name_or_oid)));
106
107 result = clist->oid;
108
110}
111
112
113
114
115
116
119{
123
126 (Node *) &escontext,
127 &result))
130}
131
132
133
134
137{
139 char *result;
141
143 {
146 }
147
149
151 {
154
155
156
157
158
159
162 else
163 {
164 char *nspname;
166
167
168
169
170
172 -1, NIL, false, false, false, false);
173 if (clist != NULL && clist->next == NULL &&
174 clist->oid == proid)
175 nspname = NULL;
176 else
178
180 }
181
183 }
184 else
185 {
186
189 }
190
192}
193
194
195
196
199{
200
202}
203
204
205
206
209{
210
212}
213
214
215
216
217
218
219
220
221
222
225{
227 Node *escontext = fcinfo->context;
230 int nargs;
233
234
235 if (parseDashOrOid(pro_name_or_oid, &result, escontext))
237
238
240 elog(ERROR, "regprocedure values must be OIDs in bootstrap mode");
241
242
243
244
245
246
247
249 &names, &nargs, argtypes,
250 escontext))
252
254 false, true);
255
256 for (; clist; clist = clist->next)
257 {
258 if (memcmp(clist->args, argtypes, nargs * sizeof(Oid)) == 0)
259 break;
260 }
261
262 if (clist == NULL)
264 (errcode(ERRCODE_UNDEFINED_FUNCTION),
265 errmsg("function \"%s\" does not exist", pro_name_or_oid)));
266
267 result = clist->oid;
268
270}
271
272
273
274
275
276
279{
283
286 (Node *) &escontext,
287 &result))
290}
291
292
293
294
295
296
297
298char *
300{
302}
303
304char *
306{
308}
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325char *
327{
328 char *result;
330
332
334 {
337 int nargs = procform->pronargs;
338 int i;
339 char *nspname;
341
342
344
346
347
348
349
350
353 nspname = NULL;
354 else
356
359 for (i = 0; i < nargs; i++)
360 {
361 Oid thisargtype = procform->proargtypes.values[i];
362
363 if (i > 0)
369 }
371
372 result = buf.data;
373
375 }
377 {
378
379 result = NULL;
380 }
381 else
382 {
383
386 }
387
388 return result;
389}
390
391
392
393
394
395
396
397void
399 bool missing_ok)
400{
403 int nargs;
404 int i;
405
407
409 {
410 if (!missing_ok)
411 elog(ERROR, "cache lookup failed for procedure with OID %u", procedure_oid);
412 return;
413 }
414
416 nargs = procform->pronargs;
417
420 *objargs = NIL;
421 for (i = 0; i < nargs; i++)
422 {
423 Oid thisargtype = procform->proargtypes.values[i];
424
426 }
427
429}
430
431
432
433
436{
438 char *result;
439
442 else
444
446}
447
448
449
450
453{
454
456}
457
458
459
460
463{
464
466}
467
468
469
470
471
472
473
474
475
476
479{
481 Node *escontext = fcinfo->context;
482 Oid result;
485
486
487 if (parseNumericOid(opr_name_or_oid, &result, escontext))
489
490
491
492
494 elog(ERROR, "regoper values must be OIDs in bootstrap mode");
495
496
497
498
499
501 if (names == NIL)
503
505
506 if (clist == NULL)
508 (errcode(ERRCODE_UNDEFINED_FUNCTION),
509 errmsg("operator does not exist: %s", opr_name_or_oid)));
510 else if (clist->next != NULL)
512 (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
513 errmsg("more than one operator named %s",
514 opr_name_or_oid)));
515
516 result = clist->oid;
517
519}
520
521
522
523
524
525
528{
532
535 (Node *) &escontext,
536 &result))
539}
540
541
542
543
546{
548 char *result;
550
552 {
555 }
556
558
560 {
562 char *oprname = NameStr(operform->oprname);
563
564
565
566
567
568
570 result = pstrdup(oprname);
571 else
572 {
574
575
576
577
578
580 '\0', false);
581 if (clist != NULL && clist->next == NULL &&
583 result = pstrdup(oprname);
584 else
585 {
586 const char *nspname;
587
590 result = (char *) palloc(strlen(nspname) + strlen(oprname) + 2);
591 sprintf(result, "%s.%s", nspname, oprname);
592 }
593 }
594
596 }
597 else
598 {
599
600
601
604 }
605
607}
608
609
610
611
614{
615
617}
618
619
620
621
624{
625
627}
628
629
630
631
632
633
634
635
636
637
640{
642 Node *escontext = fcinfo->context;
643 Oid result;
645 int nargs;
647
648
649 if (parseNumericOid(opr_name_or_oid, &result, escontext))
651
652
654 elog(ERROR, "regoperator values must be OIDs in bootstrap mode");
655
656
657
658
659
660
661
663 &names, &nargs, argtypes,
664 escontext))
666
667 if (nargs == 1)
669 (errcode(ERRCODE_UNDEFINED_PARAMETER),
670 errmsg("missing argument"),
671 errhint("Use NONE to denote the missing argument of a unary operator.")));
672 if (nargs != 2)
674 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
675 errmsg("too many arguments"),
676 errhint("Provide two argument types for operator.")));
677
679
682 (errcode(ERRCODE_UNDEFINED_FUNCTION),
683 errmsg("operator does not exist: %s", opr_name_or_oid)));
684
686}
687
688
689
690
691
692
695{
699
702 (Node *) &escontext,
703 &result))
706}
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721char *
723{
724 char *result;
726
728
730 {
732 char *oprname = NameStr(operform->oprname);
733 char *nspname;
735
736
738
740
741
742
743
744
747 {
751 }
752
754
755 if (operform->oprleft)
760 else
762
763 if (operform->oprright)
768 else
770
771 result = buf.data;
772
774 }
776 {
777
778 result = NULL;
779 }
780 else
781 {
782
783
784
787 }
788
789 return result;
790}
791
792char *
794{
796}
797
798char *
800{
803}
804
805void
807 bool missing_ok)
808{
811
814 {
815 if (!missing_ok)
816 elog(ERROR, "cache lookup failed for operator with OID %u",
817 operator_oid);
818 return;
819 }
820
824 *objargs = NIL;
825 if (oprForm->oprleft)
826 *objargs = lappend(*objargs,
828 if (oprForm->oprright)
829 *objargs = lappend(*objargs,
831
833}
834
835
836
837
840{
842 char *result;
843
846 else
848
850}
851
852
853
854
857{
858
860}
861
862
863
864
867{
868
870}
871
872
873
874
875
876
877
878
879
880
883{
885 Node *escontext = fcinfo->context;
886 Oid result;
888
889
890 if (parseDashOrOid(class_name_or_oid, &result, escontext))
892
893
894
895
897 elog(ERROR, "regclass values must be OIDs in bootstrap mode");
898
899
900
901
902
904 if (names == NIL)
906
907
909
913 errmsg("relation \"%s\" does not exist",
915
917}
918
919
920
921
922
923
926{
930
933 (Node *) &escontext,
934 &result))
937}
938
939
940
941
944{
946 char *result;
948
950 {
953 }
954
956
958 {
960 char *classname = NameStr(classform->relname);
961
962
963
964
965
966
968 result = pstrdup(classname);
969 else
970 {
971 char *nspname;
972
973
974
975
977 nspname = NULL;
978 else
980
982 }
983
985 }
986 else
987 {
988
991 }
992
994}
995
996
997
998
1001{
1002
1004}
1005
1006
1007
1008
1011{
1012
1014}
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1027{
1029 Node *escontext = fcinfo->context;
1030 Oid result;
1031 List *names;
1032
1033
1034 if (parseDashOrOid(collation_name_or_oid, &result, escontext))
1036
1037
1038
1039
1041 elog(ERROR, "regcollation values must be OIDs in bootstrap mode");
1042
1043
1044
1045
1046
1048 if (names == NIL)
1050
1052
1055 (errcode(ERRCODE_UNDEFINED_OBJECT),
1056 errmsg("collation \"%s\" for encoding \"%s\" does not exist",
1058
1060}
1061
1062
1063
1064
1065
1066
1069{
1073
1076 (Node *) &escontext,
1077 &result))
1080}
1081
1082
1083
1084
1087{
1089 char *result;
1091
1093 {
1096 }
1097
1099
1101 {
1103 char *collationname = NameStr(collationform->collname);
1104
1105
1106
1107
1108
1109
1111 result = pstrdup(collationname);
1112 else
1113 {
1114 char *nspname;
1115
1116
1117
1118
1119
1121 nspname = NULL;
1122 else
1124
1126 }
1127
1129 }
1130 else
1131 {
1132
1135 }
1136
1138}
1139
1140
1141
1142
1145{
1146
1148}
1149
1150
1151
1152
1155{
1156
1158}
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1177{
1179 Node *escontext = fcinfo->context;
1180 Oid result;
1182
1183
1184 if (parseDashOrOid(typ_name_or_oid, &result, escontext))
1186
1187
1188
1189
1191 elog(ERROR, "regtype values must be OIDs in bootstrap mode");
1192
1193
1194
1195
1196
1197
1198 (void) parseTypeString(typ_name_or_oid, &result, &typmod, escontext);
1199
1201}
1202
1203
1204
1205
1206
1207
1210{
1214
1217 (Node *) &escontext,
1218 &result))
1221}
1222
1223
1224
1225
1226
1227
1230{
1232 Oid typid;
1235
1236
1239
1241}
1242
1243
1244
1245
1248{
1250 char *result;
1252
1254 {
1257 }
1258
1260
1262 {
1264
1265
1266
1267
1268
1269
1271 {
1273
1275 }
1276 else
1278
1280 }
1281 else
1282 {
1283
1286 }
1287
1289}
1290
1291
1292
1293
1296{
1297
1299}
1300
1301
1302
1303
1306{
1307
1309}
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1322{
1324 Node *escontext = fcinfo->context;
1325 Oid result;
1326 List *names;
1327
1328
1329 if (parseDashOrOid(cfg_name_or_oid, &result, escontext))
1331
1332
1334 elog(ERROR, "regconfig values must be OIDs in bootstrap mode");
1335
1336
1337
1338
1339
1341 if (names == NIL)
1343
1345
1348 (errcode(ERRCODE_UNDEFINED_OBJECT),
1349 errmsg("text search configuration \"%s\" does not exist",
1351
1353}
1354
1355
1356
1357
1360{
1362 char *result;
1364
1366 {
1369 }
1370
1372
1374 {
1376 char *cfgname = NameStr(cfgform->cfgname);
1377 char *nspname;
1378
1379
1380
1381
1383 nspname = NULL;
1384 else
1386
1388
1390 }
1391 else
1392 {
1393
1396 }
1397
1399}
1400
1401
1402
1403
1406{
1407
1409}
1410
1411
1412
1413
1416{
1417
1419}
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1432{
1434 Node *escontext = fcinfo->context;
1435 Oid result;
1436 List *names;
1437
1438
1439 if (parseDashOrOid(dict_name_or_oid, &result, escontext))
1441
1442
1444 elog(ERROR, "regdictionary values must be OIDs in bootstrap mode");
1445
1446
1447
1448
1449
1451 if (names == NIL)
1453
1455
1458 (errcode(ERRCODE_UNDEFINED_OBJECT),
1459 errmsg("text search dictionary \"%s\" does not exist",
1461
1463}
1464
1465
1466
1467
1470{
1472 char *result;
1474
1476 {
1479 }
1480
1482
1484 {
1486 char *dictname = NameStr(dictform->dictname);
1487 char *nspname;
1488
1489
1490
1491
1492
1494 nspname = NULL;
1495 else
1497
1499
1501 }
1502 else
1503 {
1504
1507 }
1508
1510}
1511
1512
1513
1514
1517{
1518
1520}
1521
1522
1523
1524
1527{
1528
1530}
1531
1532
1533
1534
1535
1536
1537
1538
1539
1542{
1544 Node *escontext = fcinfo->context;
1545 Oid result;
1546 List *names;
1547
1548
1549 if (parseDashOrOid(role_name_or_oid, &result, escontext))
1551
1552
1554 elog(ERROR, "regrole values must be OIDs in bootstrap mode");
1555
1556
1558 if (names == NIL)
1560
1563 (errcode(ERRCODE_INVALID_NAME),
1564 errmsg("invalid name syntax")));
1565
1567
1570 (errcode(ERRCODE_UNDEFINED_OBJECT),
1571 errmsg("role \"%s\" does not exist",
1573
1575}
1576
1577
1578
1579
1580
1581
1584{
1588
1591 (Node *) &escontext,
1592 &result))
1595}
1596
1597
1598
1599
1602{
1604 char *result;
1605
1607 {
1610 }
1611
1613
1614 if (result)
1615 {
1616
1618 }
1619 else
1620 {
1621
1624 }
1625
1627}
1628
1629
1630
1631
1634{
1635
1637}
1638
1639
1640
1641
1644{
1645
1647}
1648
1649
1650
1651
1652
1653
1654
1655
1656
1659{
1661 Node *escontext = fcinfo->context;
1662 Oid result;
1663 List *names;
1664
1665
1666 if (parseDashOrOid(nsp_name_or_oid, &result, escontext))
1668
1669
1671 elog(ERROR, "regnamespace values must be OIDs in bootstrap mode");
1672
1673
1675 if (names == NIL)
1677
1680 (errcode(ERRCODE_INVALID_NAME),
1681 errmsg("invalid name syntax")));
1682
1684
1687 (errcode(ERRCODE_UNDEFINED_SCHEMA),
1688 errmsg("schema \"%s\" does not exist",
1690
1692}
1693
1694
1695
1696
1697
1698
1701{
1705
1708 (Node *) &escontext,
1709 &result))
1712}
1713
1714
1715
1716
1719{
1721 char *result;
1722
1724 {
1727 }
1728
1730
1731 if (result)
1732 {
1733
1735 }
1736 else
1737 {
1738
1741 }
1742
1744}
1745
1746
1747
1748
1751{
1752
1754}
1755
1756
1757
1758
1761{
1762
1764}
1765
1766
1767
1768
1769
1770
1771
1772
1775{
1777 Oid result;
1779
1781
1782
1784
1786}
1787
1788
1789
1790
1791
1792
1793
1794
1795
1798{
1799 char *rawname;
1801 List *namelist;
1803
1804
1805 rawname = pstrdup(string);
1806
1809 (errcode(ERRCODE_INVALID_NAME),
1810 errmsg("invalid name syntax")));
1811
1812 if (namelist == NIL)
1814 (errcode(ERRCODE_INVALID_NAME),
1815 errmsg("invalid name syntax")));
1816
1817 foreach(l, namelist)
1818 {
1819 char *curname = (char *) lfirst(l);
1820
1822 }
1823
1826
1827 return result;
1828}
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842static bool
1844{
1845 if (string[0] >= '0' && string[0] <= '9' &&
1846 strspn(string, "0123456789") == strlen(string))
1847 {
1848 Datum oid_datum;
1849
1850
1853 escontext,
1854 &oid_datum);
1856 return true;
1857 }
1858
1859
1861 return false;
1862}
1863
1864
1865
1866
1867static bool
1869{
1870
1871 if (strcmp(string, "-") == 0)
1872 {
1874 return true;
1875 }
1876
1877
1879}
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894static bool
1896 int *nargs, Oid *argtypes,
1897 Node *escontext)
1898{
1899 char *rawname;
1900 char *ptr;
1901 char *ptr2;
1902 char *typename;
1903 bool in_quote;
1904 bool had_comma;
1905 int paren_count;
1906 Oid typeid;
1908
1909
1910 rawname = pstrdup(string);
1911
1912
1913 in_quote = false;
1914 for (ptr = rawname; *ptr; ptr++)
1915 {
1916 if (*ptr == '"')
1917 in_quote = !in_quote;
1918 else if (*ptr == '(' && !in_quote)
1919 break;
1920 }
1921 if (*ptr == '\0')
1922 ereturn(escontext, false,
1923 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1924 errmsg("expected a left parenthesis")));
1925
1926
1927 *ptr++ = '\0';
1929 if (*names == NIL)
1930 return false;
1931
1932
1933 ptr2 = ptr + strlen(ptr);
1934 while (--ptr2 > ptr)
1935 {
1937 break;
1938 }
1939 if (*ptr2 != ')')
1940 ereturn(escontext, false,
1941 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1942 errmsg("expected a right parenthesis")));
1943
1944 *ptr2 = '\0';
1945
1946
1947 *nargs = 0;
1948 had_comma = false;
1949
1950 for (;;)
1951 {
1952
1954 ptr++;
1955 if (*ptr == '\0')
1956 {
1957
1958 if (had_comma)
1959 ereturn(escontext, false,
1960 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1961 errmsg("expected a type name")));
1962 break;
1963 }
1964 typename = ptr;
1965
1966
1967 in_quote = false;
1968 paren_count = 0;
1969 for (; *ptr; ptr++)
1970 {
1971 if (*ptr == '"')
1972 in_quote = !in_quote;
1973 else if (*ptr == ',' && !in_quote && paren_count == 0)
1974 break;
1975 else if (!in_quote)
1976 {
1977 switch (*ptr)
1978 {
1979 case '(':
1980 case '[':
1981 paren_count++;
1982 break;
1983 case ')':
1984 case ']':
1985 paren_count--;
1986 break;
1987 }
1988 }
1989 }
1990 if (in_quote || paren_count != 0)
1991 ereturn(escontext, false,
1992 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1993 errmsg("improper type name")));
1994
1995 ptr2 = ptr;
1996 if (*ptr == ',')
1997 {
1998 had_comma = true;
1999 *ptr++ = '\0';
2000 }
2001 else
2002 {
2003 had_comma = false;
2004 Assert(*ptr == '\0');
2005 }
2006
2007 while (--ptr2 >= typename)
2008 {
2010 break;
2011 *ptr2 = '\0';
2012 }
2013
2014 if (allowNone && pg_strcasecmp(typename, "none") == 0)
2015 {
2016
2018 typmod = -1;
2019 }
2020 else
2021 {
2022
2023 if ((typename, &typeid, &typmod, escontext))
2024 return false;
2025 }
2027 ereturn(escontext, false,
2028 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
2029 errmsg("too many arguments")));
2030
2031 argtypes[*nargs] = typeid;
2032 (*nargs)++;
2033 }
2034
2036
2037 return true;
2038}
Oid get_role_oid(const char *rolname, bool missing_ok)
#define OidIsValid(objectId)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereturn(context, dummy_value,...)
bool DirectInputFunctionCallSafe(PGFunction func, char *str, Oid typioparam, int32 typmod, fmNodePtr escontext, Datum *result)
#define PG_GETARG_TEXT_PP(n)
#define PG_RETURN_CSTRING(x)
#define PG_GETARG_CSTRING(n)
#define PG_RETURN_INT32(x)
#define PG_RETURN_DATUM(x)
char * format_type_be_qualified(Oid type_oid)
char * format_type_be(Oid type_oid)
Assert(PointerIsAligned(start, uint64))
#define HeapTupleIsValid(tuple)
static void * GETSTRUCT(const HeapTupleData *tuple)
List * lappend(List *list, void *datum)
void list_free(List *list)
char * get_namespace_name_or_temp(Oid nspid)
char * get_namespace_name(Oid nspid)
const char * GetDatabaseEncodingName(void)
char * pstrdup(const char *in)
void pfree(void *pointer)
#define IsBootstrapProcessingMode()
char * GetUserNameFromId(Oid roleid, bool noerr)
Oid OpernameGetOprid(List *names, Oid oprleft, Oid oprright)
char * NameListToString(const List *names)
bool CollationIsVisible(Oid collid)
Oid get_collation_oid(List *collname, bool missing_ok)
FuncCandidateList FuncnameGetCandidates(List *names, int nargs, List *argnames, bool expand_variadic, bool expand_defaults, bool include_out_arguments, bool missing_ok)
Oid get_namespace_oid(const char *nspname, bool missing_ok)
bool RelationIsVisible(Oid relid)
bool OperatorIsVisible(Oid oprid)
bool FunctionIsVisible(Oid funcid)
Oid get_ts_dict_oid(List *names, bool missing_ok)
RangeVar * makeRangeVarFromNameList(const List *names)
Oid get_ts_config_oid(List *names, bool missing_ok)
FuncCandidateList OpernameGetCandidates(List *names, char oprkind, bool missing_schema_ok)
bool TSConfigIsVisible(Oid cfgid)
bool TSDictionaryIsVisible(Oid dictId)
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Datum oidrecv(PG_FUNCTION_ARGS)
Datum oidin(PG_FUNCTION_ARGS)
Datum oidsend(PG_FUNCTION_ARGS)
bool parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, Node *escontext)
FormData_pg_class * Form_pg_class
FormData_pg_collation * Form_pg_collation
static int list_length(const List *l)
#define list_make2(x1, x2)
FormData_pg_operator * Form_pg_operator
FormData_pg_proc * Form_pg_proc
FormData_pg_ts_config * Form_pg_ts_config
FormData_pg_ts_dict * Form_pg_ts_dict
FormData_pg_type * Form_pg_type
#define ERRCODE_UNDEFINED_TABLE
int pg_strcasecmp(const char *s1, const char *s2)
static Oid DatumGetObjectId(Datum X)
static Datum ObjectIdGetDatum(Oid X)
static bool parseNameAndArgTypes(const char *string, bool allowNone, List **names, int *nargs, Oid *argtypes, Node *escontext)
Datum regtypesend(PG_FUNCTION_ARGS)
Datum regoperout(PG_FUNCTION_ARGS)
Datum regnamespacein(PG_FUNCTION_ARGS)
Datum regtypein(PG_FUNCTION_ARGS)
Datum regprocrecv(PG_FUNCTION_ARGS)
Datum to_regoperator(PG_FUNCTION_ARGS)
Datum regnamespaceout(PG_FUNCTION_ARGS)
char * format_operator_qualified(Oid operator_oid)
Datum regoperatorsend(PG_FUNCTION_ARGS)
char * format_procedure_extended(Oid procedure_oid, bits16 flags)
Datum regoperin(PG_FUNCTION_ARGS)
Datum regoperatorrecv(PG_FUNCTION_ARGS)
Datum regproceduresend(PG_FUNCTION_ARGS)
Datum regdictionarysend(PG_FUNCTION_ARGS)
Datum regprocout(PG_FUNCTION_ARGS)
Datum to_regoper(PG_FUNCTION_ARGS)
Datum to_regprocedure(PG_FUNCTION_ARGS)
char * format_procedure(Oid procedure_oid)
Datum regcollationrecv(PG_FUNCTION_ARGS)
Datum regcollationin(PG_FUNCTION_ARGS)
Datum regprocedureout(PG_FUNCTION_ARGS)
Datum regtyperecv(PG_FUNCTION_ARGS)
Datum regdictionaryrecv(PG_FUNCTION_ARGS)
Datum regrolerecv(PG_FUNCTION_ARGS)
Datum regclassrecv(PG_FUNCTION_ARGS)
static bool parseDashOrOid(char *string, Oid *result, Node *escontext)
Datum to_regrole(PG_FUNCTION_ARGS)
Datum regconfigrecv(PG_FUNCTION_ARGS)
Datum regdictionaryout(PG_FUNCTION_ARGS)
Datum regdictionaryin(PG_FUNCTION_ARGS)
Datum regoperatorout(PG_FUNCTION_ARGS)
Datum regcollationout(PG_FUNCTION_ARGS)
Datum regprocsend(PG_FUNCTION_ARGS)
Datum regoperatorin(PG_FUNCTION_ARGS)
Datum regconfigsend(PG_FUNCTION_ARGS)
Datum regclassin(PG_FUNCTION_ARGS)
Datum regconfigin(PG_FUNCTION_ARGS)
char * format_operator_extended(Oid operator_oid, bits16 flags)
List * stringToQualifiedNameList(const char *string, Node *escontext)
void format_operator_parts(Oid operator_oid, List **objnames, List **objargs, bool missing_ok)
Datum to_regcollation(PG_FUNCTION_ARGS)
Datum regconfigout(PG_FUNCTION_ARGS)
Datum to_regtype(PG_FUNCTION_ARGS)
Datum regroleout(PG_FUNCTION_ARGS)
Datum to_regclass(PG_FUNCTION_ARGS)
Datum regopersend(PG_FUNCTION_ARGS)
static bool parseNumericOid(char *string, Oid *result, Node *escontext)
Datum regoperrecv(PG_FUNCTION_ARGS)
Datum regnamespacesend(PG_FUNCTION_ARGS)
Datum regprocedurein(PG_FUNCTION_ARGS)
Datum regrolein(PG_FUNCTION_ARGS)
Datum regcollationsend(PG_FUNCTION_ARGS)
Datum to_regproc(PG_FUNCTION_ARGS)
Datum regprocin(PG_FUNCTION_ARGS)
Datum regrolesend(PG_FUNCTION_ARGS)
char * format_procedure_qualified(Oid procedure_oid)
Datum to_regnamespace(PG_FUNCTION_ARGS)
void format_procedure_parts(Oid procedure_oid, List **objnames, List **objargs, bool missing_ok)
Datum to_regtypemod(PG_FUNCTION_ARGS)
Datum regclasssend(PG_FUNCTION_ARGS)
Datum regtypeout(PG_FUNCTION_ARGS)
char * format_operator(Oid operator_oid)
Datum text_regclass(PG_FUNCTION_ARGS)
Datum regprocedurerecv(PG_FUNCTION_ARGS)
Datum regnamespacerecv(PG_FUNCTION_ARGS)
Datum regclassout(PG_FUNCTION_ARGS)
#define FORMAT_OPERATOR_INVALID_AS_NULL
#define FORMAT_OPERATOR_FORCE_QUALIFY
#define FORMAT_PROC_FORCE_QUALIFY
#define FORMAT_PROC_INVALID_AS_NULL
char * quote_qualified_identifier(const char *qualifier, const char *ident)
const char * quote_identifier(const char *ident)
bool scanner_isspace(char ch)
void appendStringInfo(StringInfo str, const char *fmt,...)
void appendStringInfoString(StringInfo str, const char *s)
void appendStringInfoChar(StringInfo str, char ch)
void initStringInfo(StringInfo str)
struct _FuncCandidateList * next
Oid args[FLEXIBLE_ARRAY_MEMBER]
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
String * makeString(char *str)
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
char * text_to_cstring(const text *t)
List * textToQualifiedNameList(text *textval)