regproc.c Source File (original) (raw)

22#include <ctype.h>

49 List **names, int *nargs, Oid *argtypes,

50 Node *escontext);

67{

69 Node *escontext = fcinfo->context;

75 if (parseDashOrOid(pro_name_or_oid, &result, escontext))

85 elog(ERROR, "regproc values must be OIDs in bootstrap mode");

92 if (names == NIL)

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 ( parseTypeString (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)