PostgreSQL Source Code  git master
regproc.c File Reference
#include "postgres.h"
#include <ctype.h>
#include "access/htup_details.h"
#include "catalog/namespace.h"
#include "catalog/pg_class.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_type.h"
#include "lib/stringinfo.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
#include "parser/parse_type.h"
#include "parser/scansup.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/regproc.h"
#include "utils/syscache.h"
#include "utils/varlena.h"
Include dependency graph for regproc.c:

Go to the source code of this file.

Functions

static bool parseNumericOid (char *string, Oid *result, Node *escontext)
 
static bool parseDashOrOid (char *string, Oid *result, Node *escontext)
 
static bool parseNameAndArgTypes (const char *string, bool allowNone, List **names, int *nargs, Oid *argtypes, Node *escontext)
 
Datum regprocin (PG_FUNCTION_ARGS)
 
Datum to_regproc (PG_FUNCTION_ARGS)
 
Datum regprocout (PG_FUNCTION_ARGS)
 
Datum regprocrecv (PG_FUNCTION_ARGS)
 
Datum regprocsend (PG_FUNCTION_ARGS)
 
Datum regprocedurein (PG_FUNCTION_ARGS)
 
Datum to_regprocedure (PG_FUNCTION_ARGS)
 
char * format_procedure (Oid procedure_oid)
 
char * format_procedure_qualified (Oid procedure_oid)
 
char * format_procedure_extended (Oid procedure_oid, bits16 flags)
 
void format_procedure_parts (Oid procedure_oid, List **objnames, List **objargs, bool missing_ok)
 
Datum regprocedureout (PG_FUNCTION_ARGS)
 
Datum regprocedurerecv (PG_FUNCTION_ARGS)
 
Datum regproceduresend (PG_FUNCTION_ARGS)
 
Datum regoperin (PG_FUNCTION_ARGS)
 
Datum to_regoper (PG_FUNCTION_ARGS)
 
Datum regoperout (PG_FUNCTION_ARGS)
 
Datum regoperrecv (PG_FUNCTION_ARGS)
 
Datum regopersend (PG_FUNCTION_ARGS)
 
Datum regoperatorin (PG_FUNCTION_ARGS)
 
Datum to_regoperator (PG_FUNCTION_ARGS)
 
char * format_operator_extended (Oid operator_oid, bits16 flags)
 
char * format_operator (Oid operator_oid)
 
char * format_operator_qualified (Oid operator_oid)
 
void format_operator_parts (Oid operator_oid, List **objnames, List **objargs, bool missing_ok)
 
Datum regoperatorout (PG_FUNCTION_ARGS)
 
Datum regoperatorrecv (PG_FUNCTION_ARGS)
 
Datum regoperatorsend (PG_FUNCTION_ARGS)
 
Datum regclassin (PG_FUNCTION_ARGS)
 
Datum to_regclass (PG_FUNCTION_ARGS)
 
Datum regclassout (PG_FUNCTION_ARGS)
 
Datum regclassrecv (PG_FUNCTION_ARGS)
 
Datum regclasssend (PG_FUNCTION_ARGS)
 
Datum regcollationin (PG_FUNCTION_ARGS)
 
Datum to_regcollation (PG_FUNCTION_ARGS)
 
Datum regcollationout (PG_FUNCTION_ARGS)
 
Datum regcollationrecv (PG_FUNCTION_ARGS)
 
Datum regcollationsend (PG_FUNCTION_ARGS)
 
Datum regtypein (PG_FUNCTION_ARGS)
 
Datum to_regtype (PG_FUNCTION_ARGS)
 
Datum regtypeout (PG_FUNCTION_ARGS)
 
Datum regtyperecv (PG_FUNCTION_ARGS)
 
Datum regtypesend (PG_FUNCTION_ARGS)
 
Datum regconfigin (PG_FUNCTION_ARGS)
 
Datum regconfigout (PG_FUNCTION_ARGS)
 
Datum regconfigrecv (PG_FUNCTION_ARGS)
 
Datum regconfigsend (PG_FUNCTION_ARGS)
 
Datum regdictionaryin (PG_FUNCTION_ARGS)
 
Datum regdictionaryout (PG_FUNCTION_ARGS)
 
Datum regdictionaryrecv (PG_FUNCTION_ARGS)
 
Datum regdictionarysend (PG_FUNCTION_ARGS)
 
Datum regrolein (PG_FUNCTION_ARGS)
 
Datum to_regrole (PG_FUNCTION_ARGS)
 
Datum regroleout (PG_FUNCTION_ARGS)
 
Datum regrolerecv (PG_FUNCTION_ARGS)
 
Datum regrolesend (PG_FUNCTION_ARGS)
 
Datum regnamespacein (PG_FUNCTION_ARGS)
 
Datum to_regnamespace (PG_FUNCTION_ARGS)
 
Datum regnamespaceout (PG_FUNCTION_ARGS)
 
Datum regnamespacerecv (PG_FUNCTION_ARGS)
 
Datum regnamespacesend (PG_FUNCTION_ARGS)
 
Datum text_regclass (PG_FUNCTION_ARGS)
 
ListstringToQualifiedNameList (const char *string, Node *escontext)
 

Function Documentation

◆ format_operator()

char* format_operator ( Oid  operator_oid)

Definition at line 793 of file regproc.c.

794 {
795  return format_operator_extended(operator_oid, 0);
796 }
char * format_operator_extended(Oid operator_oid, bits16 flags)
Definition: regproc.c:722

References format_operator_extended().

Referenced by blvalidate(), brinvalidate(), btvalidate(), ComputeIndexAttrs(), getObjectDescription(), ginvalidate(), gistvalidate(), hashvalidate(), regoperatorout(), and spgvalidate().

◆ format_operator_extended()

char* format_operator_extended ( Oid  operator_oid,
bits16  flags 
)

Definition at line 722 of file regproc.c.

723 {
724  char *result;
725  HeapTuple opertup;
726 
727  opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operator_oid));
728 
729  if (HeapTupleIsValid(opertup))
730  {
731  Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
732  char *oprname = NameStr(operform->oprname);
733  char *nspname;
735 
736  /* XXX no support here for bootstrap mode */
738 
740 
741  /*
742  * Would this oper be found (given the right args) by regoperatorin?
743  * If not, or if caller explicitly requests it, we need to qualify it.
744  */
745  if ((flags & FORMAT_OPERATOR_FORCE_QUALIFY) != 0 ||
746  !OperatorIsVisible(operator_oid))
747  {
748  nspname = get_namespace_name(operform->oprnamespace);
749  appendStringInfo(&buf, "%s.",
750  quote_identifier(nspname));
751  }
752 
753  appendStringInfo(&buf, "%s(", oprname);
754 
755  if (operform->oprleft)
756  appendStringInfo(&buf, "%s,",
757  (flags & FORMAT_OPERATOR_FORCE_QUALIFY) != 0 ?
758  format_type_be_qualified(operform->oprleft) :
759  format_type_be(operform->oprleft));
760  else
761  appendStringInfoString(&buf, "NONE,");
762 
763  if (operform->oprright)
764  appendStringInfo(&buf, "%s)",
765  (flags & FORMAT_OPERATOR_FORCE_QUALIFY) != 0 ?
766  format_type_be_qualified(operform->oprright) :
767  format_type_be(operform->oprright));
768  else
769  appendStringInfoString(&buf, "NONE)");
770 
771  result = buf.data;
772 
773  ReleaseSysCache(opertup);
774  }
775  else if ((flags & FORMAT_OPERATOR_INVALID_AS_NULL) != 0)
776  {
777  /* If object is undefined, return NULL as wanted by caller */
778  result = NULL;
779  }
780  else
781  {
782  /*
783  * If OID doesn't match any pg_operator entry, return it numerically
784  */
785  result = (char *) palloc(NAMEDATALEN);
786  snprintf(result, NAMEDATALEN, "%u", operator_oid);
787  }
788 
789  return result;
790 }
#define NameStr(name)
Definition: c.h:735
char * format_type_be_qualified(Oid type_oid)
Definition: format_type.c:353
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
Assert(fmt[strlen(fmt) - 1] !='\n')
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3321
void * palloc(Size size)
Definition: mcxt.c:1201
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:416
bool OperatorIsVisible(Oid oprid)
Definition: namespace.c:2034
#define NAMEDATALEN
FormData_pg_operator * Form_pg_operator
Definition: pg_operator.h:83
static char * buf
Definition: pg_test_fsync.c:73
#define snprintf
Definition: port.h:238
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
#define FORMAT_OPERATOR_INVALID_AS_NULL
Definition: regproc.h:24
#define FORMAT_OPERATOR_FORCE_QUALIFY
Definition: regproc.h:25
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:11975
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:97
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:182
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:267
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:219

References appendStringInfo(), appendStringInfoString(), Assert(), buf, FORMAT_OPERATOR_FORCE_QUALIFY, FORMAT_OPERATOR_INVALID_AS_NULL, format_type_be(), format_type_be_qualified(), get_namespace_name(), GETSTRUCT, HeapTupleIsValid, initStringInfo(), IsBootstrapProcessingMode, NAMEDATALEN, NameStr, ObjectIdGetDatum(), OperatorIsVisible(), palloc(), quote_identifier(), ReleaseSysCache(), SearchSysCache1(), and snprintf.

Referenced by format_operator(), format_operator_qualified(), getObjectDescription(), and getObjectIdentityParts().

◆ format_operator_parts()

void format_operator_parts ( Oid  operator_oid,
List **  objnames,
List **  objargs,
bool  missing_ok 
)

Definition at line 806 of file regproc.c.

808 {
809  HeapTuple opertup;
810  Form_pg_operator oprForm;
811 
812  opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operator_oid));
813  if (!HeapTupleIsValid(opertup))
814  {
815  if (!missing_ok)
816  elog(ERROR, "cache lookup failed for operator with OID %u",
817  operator_oid);
818  return;
819  }
820 
821  oprForm = (Form_pg_operator) GETSTRUCT(opertup);
822  *objnames = list_make2(get_namespace_name_or_temp(oprForm->oprnamespace),
823  pstrdup(NameStr(oprForm->oprname)));
824  *objargs = NIL;
825  if (oprForm->oprleft)
826  *objargs = lappend(*objargs,
827  format_type_be_qualified(oprForm->oprleft));
828  if (oprForm->oprright)
829  *objargs = lappend(*objargs,
830  format_type_be_qualified(oprForm->oprright));
831 
832  ReleaseSysCache(opertup);
833 }
#define ERROR
Definition: elog.h:39
List * lappend(List *list, void *datum)
Definition: list.c:339
char * get_namespace_name_or_temp(Oid nspid)
Definition: lsyscache.c:3345
char * pstrdup(const char *in)
Definition: mcxt.c:1619
#define NIL
Definition: pg_list.h:68
#define list_make2(x1, x2)
Definition: pg_list.h:214

References elog(), ERROR, format_type_be_qualified(), get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, lappend(), list_make2, NameStr, NIL, ObjectIdGetDatum(), pstrdup(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getObjectIdentityParts().

◆ format_operator_qualified()

char* format_operator_qualified ( Oid  operator_oid)

Definition at line 799 of file regproc.c.

800 {
801  return format_operator_extended(operator_oid,
803 }

References format_operator_extended(), and FORMAT_OPERATOR_FORCE_QUALIFY.

◆ format_procedure()

char* format_procedure ( Oid  procedure_oid)

Definition at line 299 of file regproc.c.

300 {
301  return format_procedure_extended(procedure_oid, 0);
302 }
char * format_procedure_extended(Oid procedure_oid, bits16 flags)
Definition: regproc.c:326

References format_procedure_extended().

Referenced by blvalidate(), brinvalidate(), btvalidate(), do_compile(), getObjectDescription(), ginvalidate(), gistvalidate(), hashvalidate(), initialize_peragg(), pg_logical_slot_get_changes_guts(), ProcedureCreate(), regprocedureout(), and spgvalidate().

◆ format_procedure_extended()

char* format_procedure_extended ( Oid  procedure_oid,
bits16  flags 
)

Definition at line 326 of file regproc.c.

327 {
328  char *result;
329  HeapTuple proctup;
330 
331  proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procedure_oid));
332 
333  if (HeapTupleIsValid(proctup))
334  {
335  Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
336  char *proname = NameStr(procform->proname);
337  int nargs = procform->pronargs;
338  int i;
339  char *nspname;
341 
342  /* XXX no support here for bootstrap mode */
344 
346 
347  /*
348  * Would this proc be found (given the right args) by regprocedurein?
349  * If not, or if caller requests it, we need to qualify it.
350  */
351  if ((flags & FORMAT_PROC_FORCE_QUALIFY) == 0 &&
352  FunctionIsVisible(procedure_oid))
353  nspname = NULL;
354  else
355  nspname = get_namespace_name(procform->pronamespace);
356 
357  appendStringInfo(&buf, "%s(",
359  for (i = 0; i < nargs; i++)
360  {
361  Oid thisargtype = procform->proargtypes.values[i];
362 
363  if (i > 0)
364  appendStringInfoChar(&buf, ',');
366  (flags & FORMAT_PROC_FORCE_QUALIFY) != 0 ?
367  format_type_be_qualified(thisargtype) :
368  format_type_be(thisargtype));
369  }
370  appendStringInfoChar(&buf, ')');
371 
372  result = buf.data;
373 
374  ReleaseSysCache(proctup);
375  }
376  else if ((flags & FORMAT_PROC_INVALID_AS_NULL) != 0)
377  {
378  /* If object is undefined, return NULL as wanted by caller */
379  result = NULL;
380  }
381  else
382  {
383  /* If OID doesn't match any pg_proc entry, return it numerically */
384  result = (char *) palloc(NAMEDATALEN);
385  snprintf(result, NAMEDATALEN, "%u", procedure_oid);
386  }
387 
388  return result;
389 }
int i
Definition: isn.c:73
bool FunctionIsVisible(Oid funcid)
Definition: namespace.c:1681
FormData_pg_proc * Form_pg_proc
Definition: pg_proc.h:136
NameData proname
Definition: pg_proc.h:35
unsigned int Oid
Definition: postgres_ext.h:31
#define FORMAT_PROC_FORCE_QUALIFY
Definition: regproc.h:20
#define FORMAT_PROC_INVALID_AS_NULL
Definition: regproc.h:19
char * quote_qualified_identifier(const char *qualifier, const char *ident)
Definition: ruleutils.c:12059
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:194

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert(), buf, FORMAT_PROC_FORCE_QUALIFY, FORMAT_PROC_INVALID_AS_NULL, format_type_be(), format_type_be_qualified(), FunctionIsVisible(), get_namespace_name(), GETSTRUCT, HeapTupleIsValid, i, initStringInfo(), IsBootstrapProcessingMode, NAMEDATALEN, NameStr, ObjectIdGetDatum(), palloc(), proname, quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), and snprintf.

Referenced by format_procedure(), format_procedure_qualified(), getObjectDescription(), and getObjectIdentityParts().

◆ format_procedure_parts()

void format_procedure_parts ( Oid  procedure_oid,
List **  objnames,
List **  objargs,
bool  missing_ok 
)

Definition at line 398 of file regproc.c.

400 {
401  HeapTuple proctup;
402  Form_pg_proc procform;
403  int nargs;
404  int i;
405 
406  proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procedure_oid));
407 
408  if (!HeapTupleIsValid(proctup))
409  {
410  if (!missing_ok)
411  elog(ERROR, "cache lookup failed for procedure with OID %u", procedure_oid);
412  return;
413  }
414 
415  procform = (Form_pg_proc) GETSTRUCT(proctup);
416  nargs = procform->pronargs;
417 
418  *objnames = list_make2(get_namespace_name_or_temp(procform->pronamespace),
419  pstrdup(NameStr(procform->proname)));
420  *objargs = NIL;
421  for (i = 0; i < nargs; i++)
422  {
423  Oid thisargtype = procform->proargtypes.values[i];
424 
425  *objargs = lappend(*objargs, format_type_be_qualified(thisargtype));
426  }
427 
428  ReleaseSysCache(proctup);
429 }

References elog(), ERROR, format_type_be_qualified(), get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, i, lappend(), list_make2, NameStr, NIL, ObjectIdGetDatum(), pstrdup(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getObjectIdentityParts().

◆ format_procedure_qualified()

char* format_procedure_qualified ( Oid  procedure_oid)

Definition at line 305 of file regproc.c.

306 {
308 }

References FORMAT_PROC_FORCE_QUALIFY, and format_procedure_extended().

◆ parseDashOrOid()

static bool parseDashOrOid ( char *  string,
Oid result,
Node escontext 
)
static

Definition at line 1848 of file regproc.c.

1849 {
1850  /* '-' ? */
1851  if (strcmp(string, "-") == 0)
1852  {
1853  *result = InvalidOid;
1854  return true;
1855  }
1856 
1857  /* Numeric OID? */
1858  return parseNumericOid(string, result, escontext);
1859 }
#define InvalidOid
Definition: postgres_ext.h:36
static bool parseNumericOid(char *string, Oid *result, Node *escontext)
Definition: regproc.c:1823

References InvalidOid, and parseNumericOid().

Referenced by regclassin(), regcollationin(), regconfigin(), regdictionaryin(), regnamespacein(), regprocedurein(), regprocin(), regrolein(), and regtypein().

◆ parseNameAndArgTypes()

static bool parseNameAndArgTypes ( const char *  string,
bool  allowNone,
List **  names,
int *  nargs,
Oid argtypes,
Node escontext 
)
static

Definition at line 1875 of file regproc.c.

1878 {
1879  char *rawname;
1880  char *ptr;
1881  char *ptr2;
1882  char *typename;
1883  bool in_quote;
1884  bool had_comma;
1885  int paren_count;
1886  Oid typeid;
1887  int32 typmod;
1888 
1889  /* We need a modifiable copy of the input string. */
1890  rawname = pstrdup(string);
1891 
1892  /* Scan to find the expected left paren; mustn't be quoted */
1893  in_quote = false;
1894  for (ptr = rawname; *ptr; ptr++)
1895  {
1896  if (*ptr == '"')
1897  in_quote = !in_quote;
1898  else if (*ptr == '(' && !in_quote)
1899  break;
1900  }
1901  if (*ptr == '\0')
1902  ereturn(escontext, false,
1903  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1904  errmsg("expected a left parenthesis")));
1905 
1906  /* Separate the name and parse it into a list */
1907  *ptr++ = '\0';
1908  *names = stringToQualifiedNameList(rawname, escontext);
1909  if (*names == NIL)
1910  return false;
1911 
1912  /* Check for the trailing right parenthesis and remove it */
1913  ptr2 = ptr + strlen(ptr);
1914  while (--ptr2 > ptr)
1915  {
1916  if (!scanner_isspace(*ptr2))
1917  break;
1918  }
1919  if (*ptr2 != ')')
1920  ereturn(escontext, false,
1921  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1922  errmsg("expected a right parenthesis")));
1923 
1924  *ptr2 = '\0';
1925 
1926  /* Separate the remaining string into comma-separated type names */
1927  *nargs = 0;
1928  had_comma = false;
1929 
1930  for (;;)
1931  {
1932  /* allow leading whitespace */
1933  while (scanner_isspace(*ptr))
1934  ptr++;
1935  if (*ptr == '\0')
1936  {
1937  /* End of string. Okay unless we had a comma before. */
1938  if (had_comma)
1939  ereturn(escontext, false,
1940  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1941  errmsg("expected a type name")));
1942  break;
1943  }
1944  typename = ptr;
1945  /* Find end of type name --- end of string or comma */
1946  /* ... but not a quoted or parenthesized comma */
1947  in_quote = false;
1948  paren_count = 0;
1949  for (; *ptr; ptr++)
1950  {
1951  if (*ptr == '"')
1952  in_quote = !in_quote;
1953  else if (*ptr == ',' && !in_quote && paren_count == 0)
1954  break;
1955  else if (!in_quote)
1956  {
1957  switch (*ptr)
1958  {
1959  case '(':
1960  case '[':
1961  paren_count++;
1962  break;
1963  case ')':
1964  case ']':
1965  paren_count--;
1966  break;
1967  }
1968  }
1969  }
1970  if (in_quote || paren_count != 0)
1971  ereturn(escontext, false,
1972  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1973  errmsg("improper type name")));
1974 
1975  ptr2 = ptr;
1976  if (*ptr == ',')
1977  {
1978  had_comma = true;
1979  *ptr++ = '\0';
1980  }
1981  else
1982  {
1983  had_comma = false;
1984  Assert(*ptr == '\0');
1985  }
1986  /* Lop off trailing whitespace */
1987  while (--ptr2 >= typename)
1988  {
1989  if (!scanner_isspace(*ptr2))
1990  break;
1991  *ptr2 = '\0';
1992  }
1993 
1994  if (allowNone && pg_strcasecmp(typename, "none") == 0)
1995  {
1996  /* Special case for NONE */
1997  typeid = InvalidOid;
1998  typmod = -1;
1999  }
2000  else
2001  {
2002  /* Use full parser to resolve the type name */
2003  if (!parseTypeString(typename, &typeid, &typmod, escontext))
2004  return false;
2005  }
2006  if (*nargs >= FUNC_MAX_ARGS)
2007  ereturn(escontext, false,
2008  (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
2009  errmsg("too many arguments")));
2010 
2011  argtypes[*nargs] = typeid;
2012  (*nargs)++;
2013  }
2014 
2015  pfree(rawname);
2016 
2017  return true;
2018 }
signed int int32
Definition: c.h:483
int errcode(int sqlerrcode)
Definition: elog.c:860
int errmsg(const char *fmt,...)
Definition: elog.c:1075
#define ereturn(context, dummy_value,...)
Definition: elog.h:276
void pfree(void *pointer)
Definition: mcxt.c:1431
bool parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, Node *escontext)
Definition: parse_type.c:785
#define FUNC_MAX_ARGS
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
List * stringToQualifiedNameList(const char *string, Node *escontext)
Definition: regproc.c:1777
bool scanner_isspace(char ch)
Definition: scansup.c:117

References Assert(), ereturn, errcode(), errmsg(), FUNC_MAX_ARGS, InvalidOid, NIL, parseTypeString(), pfree(), pg_strcasecmp(), pstrdup(), scanner_isspace(), and stringToQualifiedNameList().

Referenced by regoperatorin(), and regprocedurein().

◆ parseNumericOid()

static bool parseNumericOid ( char *  string,
Oid result,
Node escontext 
)
static

Definition at line 1823 of file regproc.c.

1824 {
1825  if (string[0] >= '0' && string[0] <= '9' &&
1826  strspn(string, "0123456789") == strlen(string))
1827  {
1828  Datum oid_datum;
1829 
1830  /* We need not care here whether oidin() fails or not. */
1831  (void) DirectInputFunctionCallSafe(oidin, string,
1832  InvalidOid, -1,
1833  escontext,
1834  &oid_datum);
1835  *result = DatumGetObjectId(oid_datum);
1836  return true;
1837  }
1838 
1839  /* Prevent uninitialized-variable warnings from stupider compilers. */
1840  *result = InvalidOid;
1841  return false;
1842 }
bool DirectInputFunctionCallSafe(PGFunction func, char *str, Oid typioparam, int32 typmod, fmNodePtr escontext, Datum *result)
Definition: fmgr.c:1640
Datum oidin(PG_FUNCTION_ARGS)
Definition: oid.c:37
uintptr_t Datum
Definition: postgres.h:64
static Oid DatumGetObjectId(Datum X)
Definition: postgres.h:242

References DatumGetObjectId(), DirectInputFunctionCallSafe(), InvalidOid, and oidin().

Referenced by parseDashOrOid(), regoperatorin(), and regoperin().

◆ regclassin()

Datum regclassin ( PG_FUNCTION_ARGS  )

Definition at line 882 of file regproc.c.

883 {
884  char *class_name_or_oid = PG_GETARG_CSTRING(0);
885  Node *escontext = fcinfo->context;
886  Oid result;
887  List *names;
888 
889  /* Handle "-" or numeric OID */
890  if (parseDashOrOid(class_name_or_oid, &result, escontext))
891  PG_RETURN_OID(result);
892 
893  /* Else it's a name, possibly schema-qualified */
894 
895  /* The rest of this wouldn't work in bootstrap mode */
897  elog(ERROR, "regclass values must be OIDs in bootstrap mode");
898 
899  /*
900  * Normal case: parse the name into components and see if it matches any
901  * pg_class entries in the current search path.
902  */
903  names = stringToQualifiedNameList(class_name_or_oid, escontext);
904  if (names == NIL)
905  PG_RETURN_NULL();
906 
907  /* We might not even have permissions on this relation; don't lock it. */
908  result = RangeVarGetRelid(makeRangeVarFromNameList(names), NoLock, true);
909 
910  if (!OidIsValid(result))
911  ereturn(escontext, (Datum) 0,
913  errmsg("relation \"%s\" does not exist",
914  NameListToString(names))));
915 
916  PG_RETURN_OID(result);
917 }
#define OidIsValid(objectId)
Definition: c.h:764
#define PG_GETARG_CSTRING(n)
Definition: fmgr.h:277
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_RETURN_OID(x)
Definition: fmgr.h:360
#define NoLock
Definition: lockdefs.h:34
RangeVar * makeRangeVarFromNameList(const List *names)
Definition: namespace.c:3539
char * NameListToString(const List *names)
Definition: namespace.c:3579
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Definition: namespace.h:79
#define ERRCODE_UNDEFINED_TABLE
Definition: pgbench.c:78
static bool parseDashOrOid(char *string, Oid *result, Node *escontext)
Definition: regproc.c:1848
Definition: pg_list.h:54
Definition: nodes.h:129

References elog(), ereturn, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, IsBootstrapProcessingMode, makeRangeVarFromNameList(), NameListToString(), NIL, NoLock, OidIsValid, parseDashOrOid(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_OID, RangeVarGetRelid, and stringToQualifiedNameList().

Referenced by to_regclass().

◆ regclassout()

Datum regclassout ( PG_FUNCTION_ARGS  )

Definition at line 943 of file regproc.c.

944 {
945  Oid classid = PG_GETARG_OID(0);
946  char *result;
947  HeapTuple classtup;
948 
949  if (classid == InvalidOid)
950  {
951  result = pstrdup("-");
952  PG_RETURN_CSTRING(result);
953  }
954 
955  classtup = SearchSysCache1(RELOID, ObjectIdGetDatum(classid));
956 
957  if (HeapTupleIsValid(classtup))
958  {
959  Form_pg_class classform = (Form_pg_class) GETSTRUCT(classtup);
960  char *classname = NameStr(classform->relname);
961 
962  /*
963  * In bootstrap mode, skip the fancy namespace stuff and just return
964  * the class name. (This path is only needed for debugging output
965  * anyway.)
966  */
968  result = pstrdup(classname);
969  else
970  {
971  char *nspname;
972 
973  /*
974  * Would this class be found by regclassin? If not, qualify it.
975  */
976  if (RelationIsVisible(classid))
977  nspname = NULL;
978  else
979  nspname = get_namespace_name(classform->relnamespace);
980 
981  result = quote_qualified_identifier(nspname, classname);
982  }
983 
984  ReleaseSysCache(classtup);
985  }
986  else
987  {
988  /* If OID doesn't match any pg_class entry, return it numerically */
989  result = (char *) palloc(NAMEDATALEN);
990  snprintf(result, NAMEDATALEN, "%u", classid);
991  }
992 
993  PG_RETURN_CSTRING(result);
994 }
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_RETURN_CSTRING(x)
Definition: fmgr.h:362
bool RelationIsVisible(Oid relid)
Definition: namespace.c:898
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153

References get_namespace_name(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, NAMEDATALEN, NameStr, ObjectIdGetDatum(), palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), quote_qualified_identifier(), RelationIsVisible(), ReleaseSysCache(), SearchSysCache1(), and snprintf.

Referenced by table_to_xml_internal().

◆ regclassrecv()

Datum regclassrecv ( PG_FUNCTION_ARGS  )

Definition at line 1000 of file regproc.c.

1001 {
1002  /* Exactly the same as oidrecv, so share code */
1003  return oidrecv(fcinfo);
1004 }
Datum oidrecv(PG_FUNCTION_ARGS)
Definition: oid.c:60

References oidrecv().

◆ regclasssend()

Datum regclasssend ( PG_FUNCTION_ARGS  )

Definition at line 1010 of file regproc.c.

1011 {
1012  /* Exactly the same as oidsend, so share code */
1013  return oidsend(fcinfo);
1014 }
Datum oidsend(PG_FUNCTION_ARGS)
Definition: oid.c:71

References oidsend().

◆ regcollationin()

Datum regcollationin ( PG_FUNCTION_ARGS  )

Definition at line 1026 of file regproc.c.

1027 {
1028  char *collation_name_or_oid = PG_GETARG_CSTRING(0);
1029  Node *escontext = fcinfo->context;
1030  Oid result;
1031  List *names;
1032 
1033  /* Handle "-" or numeric OID */
1034  if (parseDashOrOid(collation_name_or_oid, &result, escontext))
1035  PG_RETURN_OID(result);
1036 
1037  /* Else it's a name, possibly schema-qualified */
1038 
1039  /* The rest of this wouldn't work in bootstrap mode */
1041  elog(ERROR, "regcollation values must be OIDs in bootstrap mode");
1042 
1043  /*
1044  * Normal case: parse the name into components and see if it matches any
1045  * pg_collation entries in the current search path.
1046  */
1047  names = stringToQualifiedNameList(collation_name_or_oid, escontext);
1048  if (names == NIL)
1049  PG_RETURN_NULL();
1050 
1051  result = get_collation_oid(names, true);
1052 
1053  if (!OidIsValid(result))
1054  ereturn(escontext, (Datum) 0,
1055  (errcode(ERRCODE_UNDEFINED_OBJECT),
1056  errmsg("collation \"%s\" for encoding \"%s\" does not exist",
1058 
1059  PG_RETURN_OID(result);
1060 }
const char * GetDatabaseEncodingName(void)
Definition: mbutils.c:1274
Oid get_collation_oid(List *collname, bool missing_ok)
Definition: namespace.c:3956

References elog(), ereturn, errcode(), errmsg(), ERROR, get_collation_oid(), GetDatabaseEncodingName(), IsBootstrapProcessingMode, NameListToString(), NIL, OidIsValid, parseDashOrOid(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_OID, and stringToQualifiedNameList().

Referenced by to_regcollation().

◆ regcollationout()

Datum regcollationout ( PG_FUNCTION_ARGS  )

Definition at line 1086 of file regproc.c.

1087 {
1088  Oid collationid = PG_GETARG_OID(0);
1089  char *result;
1090  HeapTuple collationtup;
1091 
1092  if (collationid == InvalidOid)
1093  {
1094  result = pstrdup("-");
1095  PG_RETURN_CSTRING(result);
1096  }
1097 
1098  collationtup = SearchSysCache1(COLLOID, ObjectIdGetDatum(collationid));
1099 
1100  if (HeapTupleIsValid(collationtup))
1101  {
1102  Form_pg_collation collationform = (Form_pg_collation) GETSTRUCT(collationtup);
1103  char *collationname = NameStr(collationform->collname);
1104 
1105  /*
1106  * In bootstrap mode, skip the fancy namespace stuff and just return
1107  * the collation name. (This path is only needed for debugging output
1108  * anyway.)
1109  */
1111  result = pstrdup(collationname);
1112  else
1113  {
1114  char *nspname;
1115 
1116  /*
1117  * Would this collation be found by regcollationin? If not,
1118  * qualify it.
1119  */
1120  if (CollationIsVisible(collationid))
1121  nspname = NULL;
1122  else
1123  nspname = get_namespace_name(collationform->collnamespace);
1124 
1125  result = quote_qualified_identifier(nspname, collationname);
1126  }
1127 
1128  ReleaseSysCache(collationtup);
1129  }
1130  else
1131  {
1132  /* If OID doesn't match any pg_collation entry, return it numerically */
1133  result = (char *) palloc(NAMEDATALEN);
1134  snprintf(result, NAMEDATALEN, "%u", collationid);
1135  }
1136 
1137  PG_RETURN_CSTRING(result);
1138 }
bool CollationIsVisible(Oid collid)
Definition: namespace.c:2392
FormData_pg_collation * Form_pg_collation
Definition: pg_collation.h:58

References CollationIsVisible(), get_namespace_name(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, NAMEDATALEN, NameStr, ObjectIdGetDatum(), palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), and snprintf.

◆ regcollationrecv()

Datum regcollationrecv ( PG_FUNCTION_ARGS  )

Definition at line 1144 of file regproc.c.

1145 {
1146  /* Exactly the same as oidrecv, so share code */
1147  return oidrecv(fcinfo);
1148 }

References oidrecv().

◆ regcollationsend()

Datum regcollationsend ( PG_FUNCTION_ARGS  )

Definition at line 1154 of file regproc.c.

1155 {
1156  /* Exactly the same as oidsend, so share code */
1157  return oidsend(fcinfo);
1158 }

References oidsend().

◆ regconfigin()

Datum regconfigin ( PG_FUNCTION_ARGS  )

Definition at line 1301 of file regproc.c.

1302 {
1303  char *cfg_name_or_oid = PG_GETARG_CSTRING(0);
1304  Node *escontext = fcinfo->context;
1305  Oid result;
1306  List *names;
1307 
1308  /* Handle "-" or numeric OID */
1309  if (parseDashOrOid(cfg_name_or_oid, &result, escontext))
1310  PG_RETURN_OID(result);
1311 
1312  /* The rest of this wouldn't work in bootstrap mode */
1314  elog(ERROR, "regconfig values must be OIDs in bootstrap mode");
1315 
1316  /*
1317  * Normal case: parse the name into components and see if it matches any
1318  * pg_ts_config entries in the current search path.
1319  */
1320  names = stringToQualifiedNameList(cfg_name_or_oid, escontext);
1321  if (names == NIL)
1322  PG_RETURN_NULL();
1323 
1324  result = get_ts_config_oid(names, true);
1325 
1326  if (!OidIsValid(result))
1327  ereturn(escontext, (Datum) 0,
1328  (errcode(ERRCODE_UNDEFINED_OBJECT),
1329  errmsg("text search configuration \"%s\" does not exist",
1330  NameListToString(names))));
1331 
1332  PG_RETURN_OID(result);
1333 }
Oid get_ts_config_oid(List *names, bool missing_ok)
Definition: namespace.c:3137

References elog(), ereturn, errcode(), errmsg(), ERROR, get_ts_config_oid(), IsBootstrapProcessingMode, NameListToString(), NIL, OidIsValid, parseDashOrOid(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_OID, and stringToQualifiedNameList().

◆ regconfigout()

Datum regconfigout ( PG_FUNCTION_ARGS  )

Definition at line 1339 of file regproc.c.

1340 {
1341  Oid cfgid = PG_GETARG_OID(0);
1342  char *result;
1343  HeapTuple cfgtup;
1344 
1345  if (cfgid == InvalidOid)
1346  {
1347  result = pstrdup("-");
1348  PG_RETURN_CSTRING(result);
1349  }
1350 
1351  cfgtup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgid));
1352 
1353  if (HeapTupleIsValid(cfgtup))
1354  {
1355  Form_pg_ts_config cfgform = (Form_pg_ts_config) GETSTRUCT(cfgtup);
1356  char *cfgname = NameStr(cfgform->cfgname);
1357  char *nspname;
1358 
1359  /*
1360  * Would this config be found by regconfigin? If not, qualify it.
1361  */
1362  if (TSConfigIsVisible(cfgid))
1363  nspname = NULL;
1364  else
1365  nspname = get_namespace_name(cfgform->cfgnamespace);
1366 
1367  result = quote_qualified_identifier(nspname, cfgname);
1368 
1369  ReleaseSysCache(cfgtup);
1370  }
1371  else
1372  {
1373  /* If OID doesn't match any pg_ts_config row, return it numerically */
1374  result = (char *) palloc(NAMEDATALEN);
1375  snprintf(result, NAMEDATALEN, "%u", cfgid);
1376  }
1377 
1378  PG_RETURN_CSTRING(result);
1379 }
bool TSConfigIsVisible(Oid cfgid)
Definition: namespace.c:3195
FormData_pg_ts_config * Form_pg_ts_config
Definition: pg_ts_config.h:48

References get_namespace_name(), GETSTRUCT, HeapTupleIsValid, InvalidOid, NAMEDATALEN, NameStr, ObjectIdGetDatum(), palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), snprintf, and TSConfigIsVisible().

◆ regconfigrecv()

Datum regconfigrecv ( PG_FUNCTION_ARGS  )

Definition at line 1385 of file regproc.c.

1386 {
1387  /* Exactly the same as oidrecv, so share code */
1388  return oidrecv(fcinfo);
1389 }

References oidrecv().

◆ regconfigsend()

Datum regconfigsend ( PG_FUNCTION_ARGS  )

Definition at line 1395 of file regproc.c.

1396 {
1397  /* Exactly the same as oidsend, so share code */
1398  return oidsend(fcinfo);
1399 }

References oidsend().

◆ regdictionaryin()

Datum regdictionaryin ( PG_FUNCTION_ARGS  )

Definition at line 1411 of file regproc.c.

1412 {
1413  char *dict_name_or_oid = PG_GETARG_CSTRING(0);
1414  Node *escontext = fcinfo->context;
1415  Oid result;
1416  List *names;
1417 
1418  /* Handle "-" or numeric OID */
1419  if (parseDashOrOid(dict_name_or_oid, &result, escontext))
1420  PG_RETURN_OID(result);
1421 
1422  /* The rest of this wouldn't work in bootstrap mode */
1424  elog(ERROR, "regdictionary values must be OIDs in bootstrap mode");
1425 
1426  /*
1427  * Normal case: parse the name into components and see if it matches any
1428  * pg_ts_dict entries in the current search path.
1429  */
1430  names = stringToQualifiedNameList(dict_name_or_oid, escontext);
1431  if (names == NIL)
1432  PG_RETURN_NULL();
1433 
1434  result = get_ts_dict_oid(names, true);
1435 
1436  if (!OidIsValid(result))
1437  ereturn(escontext, (Datum) 0,
1438  (errcode(ERRCODE_UNDEFINED_OBJECT),
1439  errmsg("text search dictionary \"%s\" does not exist",
1440  NameListToString(names))));
1441 
1442  PG_RETURN_OID(result);
1443 }
Oid get_ts_dict_oid(List *names, bool missing_ok)
Definition: namespace.c:2846

References elog(), ereturn, errcode(), errmsg(), ERROR, get_ts_dict_oid(), IsBootstrapProcessingMode, NameListToString(), NIL, OidIsValid, parseDashOrOid(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_OID, and stringToQualifiedNameList().

◆ regdictionaryout()

Datum regdictionaryout ( PG_FUNCTION_ARGS  )

Definition at line 1449 of file regproc.c.

1450 {
1451  Oid dictid = PG_GETARG_OID(0);
1452  char *result;
1453  HeapTuple dicttup;
1454 
1455  if (dictid == InvalidOid)
1456  {
1457  result = pstrdup("-");
1458  PG_RETURN_CSTRING(result);
1459  }
1460 
1461  dicttup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictid));
1462 
1463  if (HeapTupleIsValid(dicttup))
1464  {
1465  Form_pg_ts_dict dictform = (Form_pg_ts_dict) GETSTRUCT(dicttup);
1466  char *dictname = NameStr(dictform->dictname);
1467  char *nspname;
1468 
1469  /*
1470  * Would this dictionary be found by regdictionaryin? If not, qualify
1471  * it.
1472  */
1473  if (TSDictionaryIsVisible(dictid))
1474  nspname = NULL;
1475  else
1476  nspname = get_namespace_name(dictform->dictnamespace);
1477 
1478  result = quote_qualified_identifier(nspname, dictname);
1479 
1480  ReleaseSysCache(dicttup);
1481  }
1482  else
1483  {
1484  /* If OID doesn't match any pg_ts_dict row, return it numerically */
1485  result = (char *) palloc(NAMEDATALEN);
1486  snprintf(result, NAMEDATALEN, "%u", dictid);
1487  }
1488 
1489  PG_RETURN_CSTRING(result);
1490 }
bool TSDictionaryIsVisible(Oid dictId)
Definition: namespace.c:2904
FormData_pg_ts_dict * Form_pg_ts_dict
Definition: pg_ts_dict.h:52

References get_namespace_name(), GETSTRUCT, HeapTupleIsValid, InvalidOid, NAMEDATALEN, NameStr, ObjectIdGetDatum(), palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), snprintf, and TSDictionaryIsVisible().

◆ regdictionaryrecv()

Datum regdictionaryrecv ( PG_FUNCTION_ARGS  )

Definition at line 1496 of file regproc.c.

1497 {
1498  /* Exactly the same as oidrecv, so share code */
1499  return oidrecv(fcinfo);
1500 }

References oidrecv().

◆ regdictionarysend()

Datum regdictionarysend ( PG_FUNCTION_ARGS  )

Definition at line 1506 of file regproc.c.

1507 {
1508  /* Exactly the same as oidsend, so share code */
1509  return oidsend(fcinfo);
1510 }

References oidsend().

◆ regnamespacein()

Datum regnamespacein ( PG_FUNCTION_ARGS  )

Definition at line 1638 of file regproc.c.

1639 {
1640  char *nsp_name_or_oid = PG_GETARG_CSTRING(0);
1641  Node *escontext = fcinfo->context;
1642  Oid result;
1643  List *names;
1644 
1645  /* Handle "-" or numeric OID */
1646  if (parseDashOrOid(nsp_name_or_oid, &result, escontext))
1647  PG_RETURN_OID(result);
1648 
1649  /* The rest of this wouldn't work in bootstrap mode */
1651  elog(ERROR, "regnamespace values must be OIDs in bootstrap mode");
1652 
1653  /* Normal case: see if the name matches any pg_namespace entry. */
1654  names = stringToQualifiedNameList(nsp_name_or_oid, escontext);
1655  if (names == NIL)
1656  PG_RETURN_NULL();
1657 
1658  if (list_length(names) != 1)
1659  ereturn(escontext, (Datum) 0,
1660  (errcode(ERRCODE_INVALID_NAME),
1661  errmsg("invalid name syntax")));
1662 
1663  result = get_namespace_oid(strVal(linitial(names)), true);
1664 
1665  if (!OidIsValid(result))
1666  ereturn(escontext, (Datum) 0,
1667  (errcode(ERRCODE_UNDEFINED_SCHEMA),
1668  errmsg("schema \"%s\" does not exist",
1669  strVal(linitial(names)))));
1670 
1671  PG_RETURN_OID(result);
1672 }
Oid get_namespace_oid(const char *nspname, bool missing_ok)
Definition: namespace.c:3520
static int list_length(const List *l)
Definition: pg_list.h:152
#define linitial(l)
Definition: pg_list.h:178
#define strVal(v)
Definition: value.h:82

References elog(), ereturn, errcode(), errmsg(), ERROR, get_namespace_oid(), IsBootstrapProcessingMode, linitial, list_length(), NIL, OidIsValid, parseDashOrOid(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_OID, stringToQualifiedNameList(), and strVal.

Referenced by to_regnamespace().

◆ regnamespaceout()

Datum regnamespaceout ( PG_FUNCTION_ARGS  )

Definition at line 1698 of file regproc.c.

1699 {
1700  Oid nspid = PG_GETARG_OID(0);
1701  char *result;
1702 
1703  if (nspid == InvalidOid)
1704  {
1705  result = pstrdup("-");
1706  PG_RETURN_CSTRING(result);
1707  }
1708 
1709  result = get_namespace_name(nspid);
1710 
1711  if (result)
1712  {
1713  /* pstrdup is not really necessary, but it avoids a compiler warning */
1714  result = pstrdup(quote_identifier(result));
1715  }
1716  else
1717  {
1718  /* If OID doesn't match any namespace, return it numerically */
1719  result = (char *) palloc(NAMEDATALEN);
1720  snprintf(result, NAMEDATALEN, "%u", nspid);
1721  }
1722 
1723  PG_RETURN_CSTRING(result);
1724 }
int nspid

References get_namespace_name(), InvalidOid, NAMEDATALEN, nspid, palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), quote_identifier(), and snprintf.

◆ regnamespacerecv()

Datum regnamespacerecv ( PG_FUNCTION_ARGS  )

Definition at line 1730 of file regproc.c.

1731 {
1732  /* Exactly the same as oidrecv, so share code */
1733  return oidrecv(fcinfo);
1734 }

References oidrecv().

◆ regnamespacesend()

Datum regnamespacesend ( PG_FUNCTION_ARGS  )

Definition at line 1740 of file regproc.c.

1741 {
1742  /* Exactly the same as oidsend, so share code */
1743  return oidsend(fcinfo);
1744 }

References oidsend().

◆ regoperatorin()

Datum regoperatorin ( PG_FUNCTION_ARGS  )

Definition at line 639 of file regproc.c.

640 {
641  char *opr_name_or_oid = PG_GETARG_CSTRING(0);
642  Node *escontext = fcinfo->context;
643  Oid result;
644  List *names;
645  int nargs;
646  Oid argtypes[FUNC_MAX_ARGS];
647 
648  /* Handle "0" or numeric OID */
649  if (parseNumericOid(opr_name_or_oid, &result, escontext))
650  PG_RETURN_OID(result);
651 
652  /* The rest of this wouldn't work in bootstrap mode */
654  elog(ERROR, "regoperator values must be OIDs in bootstrap mode");
655 
656  /*
657  * Else it's a name and arguments. Parse the name and arguments, look up
658  * potential matches in the current namespace search list, and scan to see
659  * which one exactly matches the given argument types. (There will not be
660  * more than one match.)
661  */
662  if (!parseNameAndArgTypes(opr_name_or_oid, true,
663  &names, &nargs, argtypes,
664  escontext))
665  PG_RETURN_NULL();
666 
667  if (nargs == 1)
668  ereturn(escontext, (Datum) 0,
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)
673  ereturn(escontext, (Datum) 0,
674  (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
675  errmsg("too many arguments"),
676  errhint("Provide two argument types for operator.")));
677 
678  result = OpernameGetOprid(names, argtypes[0], argtypes[1]);
679 
680  if (!OidIsValid(result))
681  ereturn(escontext, (Datum) 0,
682  (errcode(ERRCODE_UNDEFINED_FUNCTION),
683  errmsg("operator does not exist: %s", opr_name_or_oid)));
684 
685  PG_RETURN_OID(result);
686 }
int errhint(const char *fmt,...)
Definition: elog.c:1322
Oid OpernameGetOprid(List *names, Oid oprleft, Oid oprright)
Definition: namespace.c:1770
static bool parseNameAndArgTypes(const char *string, bool allowNone, List **names, int *nargs, Oid *argtypes, Node *escontext)
Definition: regproc.c:1875

References elog(), ereturn, errcode(), errhint(), errmsg(), ERROR, FUNC_MAX_ARGS, IsBootstrapProcessingMode, OidIsValid, OpernameGetOprid(), parseNameAndArgTypes(), parseNumericOid(), PG_GETARG_CSTRING, PG_RETURN_NULL, and PG_RETURN_OID.

Referenced by to_regoperator().

◆ regoperatorout()

Datum regoperatorout ( PG_FUNCTION_ARGS  )

Definition at line 839 of file regproc.c.

840 {
841  Oid oprid = PG_GETARG_OID(0);
842  char *result;
843 
844  if (oprid == InvalidOid)
845  result = pstrdup("0");
846  else
847  result = format_operator(oprid);
848 
849  PG_RETURN_CSTRING(result);
850 }
Oid oprid(Operator op)
Definition: parse_oper.c:238
char * format_operator(Oid operator_oid)
Definition: regproc.c:793

References format_operator(), InvalidOid, oprid(), PG_GETARG_OID, PG_RETURN_CSTRING, and pstrdup().

◆ regoperatorrecv()

Datum regoperatorrecv ( PG_FUNCTION_ARGS  )

Definition at line 856 of file regproc.c.

857 {
858  /* Exactly the same as oidrecv, so share code */
859  return oidrecv(fcinfo);
860 }

References oidrecv().

◆ regoperatorsend()

Datum regoperatorsend ( PG_FUNCTION_ARGS  )

Definition at line 866 of file regproc.c.

867 {
868  /* Exactly the same as oidsend, so share code */
869  return oidsend(fcinfo);
870 }

References oidsend().

◆ regoperin()

Datum regoperin ( PG_FUNCTION_ARGS  )

Definition at line 478 of file regproc.c.

479 {
480  char *opr_name_or_oid = PG_GETARG_CSTRING(0);
481  Node *escontext = fcinfo->context;
482  Oid result;
483  List *names;
484  FuncCandidateList clist;
485 
486  /* Handle "0" or numeric OID */
487  if (parseNumericOid(opr_name_or_oid, &result, escontext))
488  PG_RETURN_OID(result);
489 
490  /* Else it's a name, possibly schema-qualified */
491 
492  /* The rest of this wouldn't work in bootstrap mode */
494  elog(ERROR, "regoper values must be OIDs in bootstrap mode");
495 
496  /*
497  * Normal case: parse the name into components and see if it matches any
498  * pg_operator entries in the current search path.
499  */
500  names = stringToQualifiedNameList(opr_name_or_oid, escontext);
501  if (names == NIL)
502  PG_RETURN_NULL();
503 
504  clist = OpernameGetCandidates(names, '\0', true);
505 
506  if (clist == NULL)
507  ereturn(escontext, (Datum) 0,
508  (errcode(ERRCODE_UNDEFINED_FUNCTION),
509  errmsg("operator does not exist: %s", opr_name_or_oid)));
510  else if (clist->next != NULL)
511  ereturn(escontext, (Datum) 0,
512  (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
513  errmsg("more than one operator named %s",
514  opr_name_or_oid)));
515 
516  result = clist->oid;
517 
518  PG_RETURN_OID(result);
519 }
FuncCandidateList OpernameGetCandidates(List *names, char oprkind, bool missing_schema_ok)
Definition: namespace.c:1873
struct _FuncCandidateList * next
Definition: namespace.h:30

References elog(), ereturn, errcode(), errmsg(), ERROR, IsBootstrapProcessingMode, _FuncCandidateList::next, NIL, _FuncCandidateList::oid, OpernameGetCandidates(), parseNumericOid(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_OID, and stringToQualifiedNameList().

Referenced by to_regoper().

◆ regoperout()

Datum regoperout ( PG_FUNCTION_ARGS  )

Definition at line 545 of file regproc.c.

546 {
547  Oid oprid = PG_GETARG_OID(0);
548  char *result;
549  HeapTuple opertup;
550 
551  if (oprid == InvalidOid)
552  {
553  result = pstrdup("0");
554  PG_RETURN_CSTRING(result);
555  }
556 
557  opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(oprid));
558 
559  if (HeapTupleIsValid(opertup))
560  {
561  Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
562  char *oprname = NameStr(operform->oprname);
563 
564  /*
565  * In bootstrap mode, skip the fancy namespace stuff and just return
566  * the oper name. (This path is only needed for debugging output
567  * anyway.)
568  */
570  result = pstrdup(oprname);
571  else
572  {
573  FuncCandidateList clist;
574 
575  /*
576  * Would this oper be found (uniquely!) by regoperin? If not,
577  * qualify it.
578  */
579  clist = OpernameGetCandidates(list_make1(makeString(oprname)),
580  '\0', false);
581  if (clist != NULL && clist->next == NULL &&
582  clist->oid == oprid)
583  result = pstrdup(oprname);
584  else
585  {
586  const char *nspname;
587 
588  nspname = get_namespace_name(operform->oprnamespace);
589  nspname = quote_identifier(nspname);
590  result = (char *) palloc(strlen(nspname) + strlen(oprname) + 2);
591  sprintf(result, "%s.%s", nspname, oprname);
592  }
593  }
594 
595  ReleaseSysCache(opertup);
596  }
597  else
598  {
599  /*
600  * If OID doesn't match any pg_operator entry, return it numerically
601  */
602  result = (char *) palloc(NAMEDATALEN);
603  snprintf(result, NAMEDATALEN, "%u", oprid);
604  }
605 
606  PG_RETURN_CSTRING(result);
607 }
#define list_make1(x1)
Definition: pg_list.h:212
#define sprintf
Definition: port.h:240
String * makeString(char *str)
Definition: value.c:63

References get_namespace_name(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, list_make1, makeString(), NAMEDATALEN, NameStr, _FuncCandidateList::next, ObjectIdGetDatum(), _FuncCandidateList::oid, OpernameGetCandidates(), oprid(), palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), quote_identifier(), ReleaseSysCache(), SearchSysCache1(), snprintf, and sprintf.

◆ regoperrecv()

Datum regoperrecv ( PG_FUNCTION_ARGS  )

Definition at line 613 of file regproc.c.

614 {
615  /* Exactly the same as oidrecv, so share code */
616  return oidrecv(fcinfo);
617 }

References oidrecv().

◆ regopersend()

Datum regopersend ( PG_FUNCTION_ARGS  )

Definition at line 623 of file regproc.c.

624 {
625  /* Exactly the same as oidsend, so share code */
626  return oidsend(fcinfo);
627 }

References oidsend().

◆ regprocedurein()

Datum regprocedurein ( PG_FUNCTION_ARGS  )

Definition at line 224 of file regproc.c.

225 {
226  char *pro_name_or_oid = PG_GETARG_CSTRING(0);
227  Node *escontext = fcinfo->context;
228  RegProcedure result;
229  List *names;
230  int nargs;
231  Oid argtypes[FUNC_MAX_ARGS];
232  FuncCandidateList clist;
233 
234  /* Handle "-" or numeric OID */
235  if (parseDashOrOid(pro_name_or_oid, &result, escontext))
236  PG_RETURN_OID(result);
237 
238  /* The rest of this wouldn't work in bootstrap mode */
240  elog(ERROR, "regprocedure values must be OIDs in bootstrap mode");
241 
242  /*
243  * Else it's a name and arguments. Parse the name and arguments, look up
244  * potential matches in the current namespace search list, and scan to see
245  * which one exactly matches the given argument types. (There will not be
246  * more than one match.)
247  */
248  if (!parseNameAndArgTypes(pro_name_or_oid, false,
249  &names, &nargs, argtypes,
250  escontext))
251  PG_RETURN_NULL();
252 
253  clist = FuncnameGetCandidates(names, nargs, NIL, false, false,
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)
263  ereturn(escontext, (Datum) 0,
264  (errcode(ERRCODE_UNDEFINED_FUNCTION),
265  errmsg("function \"%s\" does not exist", pro_name_or_oid)));
266 
267  result = clist->oid;
268 
269  PG_RETURN_OID(result);
270 }
regproc RegProcedure
Definition: c.h:639
FuncCandidateList FuncnameGetCandidates(List *names, int nargs, List *argnames, bool expand_variadic, bool expand_defaults, bool include_out_arguments, bool missing_ok)
Definition: namespace.c:1177
Oid args[FLEXIBLE_ARRAY_MEMBER]
Definition: namespace.h:38

References _FuncCandidateList::args, elog(), ereturn, errcode(), errmsg(), ERROR, FUNC_MAX_ARGS, FuncnameGetCandidates(), IsBootstrapProcessingMode, _FuncCandidateList::next, NIL, _FuncCandidateList::oid, parseDashOrOid(), parseNameAndArgTypes(), PG_GETARG_CSTRING, PG_RETURN_NULL, and PG_RETURN_OID.

Referenced by convert_function_name(), and to_regprocedure().

◆ regprocedureout()

Datum regprocedureout ( PG_FUNCTION_ARGS  )

Definition at line 435 of file regproc.c.

436 {
437  RegProcedure proid = PG_GETARG_OID(0);
438  char *result;
439 
440  if (proid == InvalidOid)
441  result = pstrdup("-");
442  else
443  result = format_procedure(proid);
444 
445  PG_RETURN_CSTRING(result);
446 }
char * format_procedure(Oid procedure_oid)
Definition: regproc.c:299

References format_procedure(), InvalidOid, PG_GETARG_OID, PG_RETURN_CSTRING, and pstrdup().

◆ regprocedurerecv()

Datum regprocedurerecv ( PG_FUNCTION_ARGS  )

Definition at line 452 of file regproc.c.

453 {
454  /* Exactly the same as oidrecv, so share code */
455  return oidrecv(fcinfo);
456 }

References oidrecv().

◆ regproceduresend()

Datum regproceduresend ( PG_FUNCTION_ARGS  )

Definition at line 462 of file regproc.c.

463 {
464  /* Exactly the same as oidsend, so share code */
465  return oidsend(fcinfo);
466 }

References oidsend().

◆ regprocin()

Datum regprocin ( PG_FUNCTION_ARGS  )

Definition at line 66 of file regproc.c.

67 {
68  char *pro_name_or_oid = PG_GETARG_CSTRING(0);
69  Node *escontext = fcinfo->context;
70  RegProcedure result;
71  List *names;
72  FuncCandidateList clist;
73 
74  /* Handle "-" or numeric OID */
75  if (parseDashOrOid(pro_name_or_oid, &result, escontext))
76  PG_RETURN_OID(result);
77 
78  /* Else it's a name, possibly schema-qualified */
79 
80  /*
81  * We should never get here in bootstrap mode, as all references should
82  * have been resolved by genbki.pl.
83  */
85  elog(ERROR, "regproc values must be OIDs in bootstrap mode");
86 
87  /*
88  * Normal case: parse the name into components and see if it matches any
89  * pg_proc entries in the current search path.
90  */
91  names = stringToQualifiedNameList(pro_name_or_oid, escontext);
92  if (names == NIL)
94 
95  clist = FuncnameGetCandidates(names, -1, NIL, false, false, false, true);
96 
97  if (clist == NULL)
98  ereturn(escontext, (Datum) 0,
99  (errcode(ERRCODE_UNDEFINED_FUNCTION),
100  errmsg("function \"%s\" does not exist", pro_name_or_oid)));
101  else if (clist->next != NULL)
102  ereturn(escontext, (Datum) 0,
103  (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
104  errmsg("more than one function named \"%s\"",
105  pro_name_or_oid)));
106 
107  result = clist->oid;
108 
109  PG_RETURN_OID(result);
110 }

References elog(), ereturn, errcode(), errmsg(), ERROR, FuncnameGetCandidates(), IsBootstrapProcessingMode, _FuncCandidateList::next, NIL, _FuncCandidateList::oid, parseDashOrOid(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_OID, and stringToQualifiedNameList().

Referenced by to_regproc().

◆ regprocout()

Datum regprocout ( PG_FUNCTION_ARGS  )

Definition at line 136 of file regproc.c.

137 {
138  RegProcedure proid = PG_GETARG_OID(0);
139  char *result;
140  HeapTuple proctup;
141 
142  if (proid == InvalidOid)
143  {
144  result = pstrdup("-");
145  PG_RETURN_CSTRING(result);
146  }
147 
148  proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(proid));
149 
150  if (HeapTupleIsValid(proctup))
151  {
152  Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
153  char *proname = NameStr(procform->proname);
154 
155  /*
156  * In bootstrap mode, skip the fancy namespace stuff and just return
157  * the proc name. (This path is only needed for debugging output
158  * anyway.)
159  */
161  result = pstrdup(proname);
162  else
163  {
164  char *nspname;
165  FuncCandidateList clist;
166 
167  /*
168  * Would this proc be found (uniquely!) by regprocin? If not,
169  * qualify it.
170  */
172  -1, NIL, false, false, false, false);
173  if (clist != NULL && clist->next == NULL &&
174  clist->oid == proid)
175  nspname = NULL;
176  else
177  nspname = get_namespace_name(procform->pronamespace);
178 
179  result = quote_qualified_identifier(nspname, proname);
180  }
181 
182  ReleaseSysCache(proctup);
183  }
184  else
185  {
186  /* If OID doesn't match any pg_proc entry, return it numerically */
187  result = (char *) palloc(NAMEDATALEN);
188  snprintf(result, NAMEDATALEN, "%u", proid);
189  }
190 
191  PG_RETURN_CSTRING(result);
192 }

References FuncnameGetCandidates(), get_namespace_name(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, list_make1, makeString(), NAMEDATALEN, NameStr, _FuncCandidateList::next, NIL, ObjectIdGetDatum(), _FuncCandidateList::oid, palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, proname, pstrdup(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), and snprintf.

◆ regprocrecv()

Datum regprocrecv ( PG_FUNCTION_ARGS  )

Definition at line 198 of file regproc.c.

199 {
200  /* Exactly the same as oidrecv, so share code */
201  return oidrecv(fcinfo);
202 }

References oidrecv().

◆ regprocsend()

Datum regprocsend ( PG_FUNCTION_ARGS  )

Definition at line 208 of file regproc.c.

209 {
210  /* Exactly the same as oidsend, so share code */
211  return oidsend(fcinfo);
212 }

References oidsend().

◆ regrolein()

Datum regrolein ( PG_FUNCTION_ARGS  )

Definition at line 1521 of file regproc.c.

1522 {
1523  char *role_name_or_oid = PG_GETARG_CSTRING(0);
1524  Node *escontext = fcinfo->context;
1525  Oid result;
1526  List *names;
1527 
1528  /* Handle "-" or numeric OID */
1529  if (parseDashOrOid(role_name_or_oid, &result, escontext))
1530  PG_RETURN_OID(result);
1531 
1532  /* The rest of this wouldn't work in bootstrap mode */
1534  elog(ERROR, "regrole values must be OIDs in bootstrap mode");
1535 
1536  /* Normal case: see if the name matches any pg_authid entry. */
1537  names = stringToQualifiedNameList(role_name_or_oid, escontext);
1538  if (names == NIL)
1539  PG_RETURN_NULL();
1540 
1541  if (list_length(names) != 1)
1542  ereturn(escontext, (Datum) 0,
1543  (errcode(ERRCODE_INVALID_NAME),
1544  errmsg("invalid name syntax")));
1545 
1546  result = get_role_oid(strVal(linitial(names)), true);
1547 
1548  if (!OidIsValid(result))
1549  ereturn(escontext, (Datum) 0,
1550  (errcode(ERRCODE_UNDEFINED_OBJECT),
1551  errmsg("role \"%s\" does not exist",
1552  strVal(linitial(names)))));
1553 
1554  PG_RETURN_OID(result);
1555 }
Oid get_role_oid(const char *rolname, bool missing_ok)
Definition: acl.c:5346

References elog(), ereturn, errcode(), errmsg(), ERROR, get_role_oid(), IsBootstrapProcessingMode, linitial, list_length(), NIL, OidIsValid, parseDashOrOid(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_OID, stringToQualifiedNameList(), and strVal.

Referenced by to_regrole().

◆ regroleout()

Datum regroleout ( PG_FUNCTION_ARGS  )

Definition at line 1581 of file regproc.c.

1582 {
1583  Oid roleoid = PG_GETARG_OID(0);
1584  char *result;
1585 
1586  if (roleoid == InvalidOid)
1587  {
1588  result = pstrdup("-");
1589  PG_RETURN_CSTRING(result);
1590  }
1591 
1592  result = GetUserNameFromId(roleoid, true);
1593 
1594  if (result)
1595  {
1596  /* pstrdup is not really necessary, but it avoids a compiler warning */
1597  result = pstrdup(quote_identifier(result));
1598  }
1599  else
1600  {
1601  /* If OID doesn't match any role, return it numerically */
1602  result = (char *) palloc(NAMEDATALEN);
1603  snprintf(result, NAMEDATALEN, "%u", roleoid);
1604  }
1605 
1606  PG_RETURN_CSTRING(result);
1607 }
char * GetUserNameFromId(Oid roleid, bool noerr)
Definition: miscinit.c:981

References GetUserNameFromId(), InvalidOid, NAMEDATALEN, palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), quote_identifier(), and snprintf.

◆ regrolerecv()

Datum regrolerecv ( PG_FUNCTION_ARGS  )

Definition at line 1613 of file regproc.c.

1614 {
1615  /* Exactly the same as oidrecv, so share code */
1616  return oidrecv(fcinfo);
1617 }

References oidrecv().

◆ regrolesend()

Datum regrolesend ( PG_FUNCTION_ARGS  )

Definition at line 1623 of file regproc.c.

1624 {
1625  /* Exactly the same as oidsend, so share code */
1626  return oidsend(fcinfo);
1627 }

References oidsend().

◆ regtypein()

Datum regtypein ( PG_FUNCTION_ARGS  )

Definition at line 1176 of file regproc.c.

1177 {
1178  char *typ_name_or_oid = PG_GETARG_CSTRING(0);
1179  Node *escontext = fcinfo->context;
1180  Oid result;
1181  int32 typmod;
1182 
1183  /* Handle "-" or numeric OID */
1184  if (parseDashOrOid(typ_name_or_oid, &result, escontext))
1185  PG_RETURN_OID(result);
1186 
1187  /* Else it's a type name, possibly schema-qualified or decorated */
1188 
1189  /* The rest of this wouldn't work in bootstrap mode */
1191  elog(ERROR, "regtype values must be OIDs in bootstrap mode");
1192 
1193  /*
1194  * Normal case: invoke the full parser to deal with special cases such as
1195  * array syntax. We don't need to check for parseTypeString failure,
1196  * since we'll just return anyway.
1197  */
1198  (void) parseTypeString(typ_name_or_oid, &result, &typmod, escontext);
1199 
1200  PG_RETURN_OID(result);
1201 }

References elog(), ERROR, IsBootstrapProcessingMode, parseDashOrOid(), parseTypeString(), PG_GETARG_CSTRING, and PG_RETURN_OID.

Referenced by convert_type_name(), plperl_sv_to_literal(), and to_regtype().

◆ regtypeout()

Datum regtypeout ( PG_FUNCTION_ARGS  )

Definition at line 1227 of file regproc.c.

1228 {
1229  Oid typid = PG_GETARG_OID(0);
1230  char *result;
1231  HeapTuple typetup;
1232 
1233  if (typid == InvalidOid)
1234  {
1235  result = pstrdup("-");
1236  PG_RETURN_CSTRING(result);
1237  }
1238 
1239  typetup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
1240 
1241  if (HeapTupleIsValid(typetup))
1242  {
1243  Form_pg_type typeform = (Form_pg_type) GETSTRUCT(typetup);
1244 
1245  /*
1246  * In bootstrap mode, skip the fancy namespace stuff and just return
1247  * the type name. (This path is only needed for debugging output
1248  * anyway.)
1249  */
1251  {
1252  char *typname = NameStr(typeform->typname);
1253 
1254  result = pstrdup(typname);
1255  }
1256  else
1257  result = format_type_be(typid);
1258 
1259  ReleaseSysCache(typetup);
1260  }
1261  else
1262  {
1263  /* If OID doesn't match any pg_type entry, return it numerically */
1264  result = (char *) palloc(NAMEDATALEN);
1265  snprintf(result, NAMEDATALEN, "%u", typid);
1266  }
1267 
1268  PG_RETURN_CSTRING(result);
1269 }
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
NameData typname
Definition: pg_type.h:41

References format_type_be(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, NAMEDATALEN, NameStr, ObjectIdGetDatum(), palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), ReleaseSysCache(), SearchSysCache1(), snprintf, and typname.

◆ regtyperecv()

Datum regtyperecv ( PG_FUNCTION_ARGS  )

Definition at line 1275 of file regproc.c.

1276 {
1277  /* Exactly the same as oidrecv, so share code */
1278  return oidrecv(fcinfo);
1279 }

References oidrecv().

◆ regtypesend()

Datum regtypesend ( PG_FUNCTION_ARGS  )

Definition at line 1285 of file regproc.c.

1286 {
1287  /* Exactly the same as oidsend, so share code */
1288  return oidsend(fcinfo);
1289 }

References oidsend().

◆ stringToQualifiedNameList()

List* stringToQualifiedNameList ( const char *  string,
Node escontext 
)

Definition at line 1777 of file regproc.c.

1778 {
1779  char *rawname;
1780  List *result = NIL;
1781  List *namelist;
1782  ListCell *l;
1783 
1784  /* We need a modifiable copy of the input string. */
1785  rawname = pstrdup(string);
1786 
1787  if (!SplitIdentifierString(rawname, '.', &namelist))
1788  ereturn(escontext, NIL,
1789  (errcode(ERRCODE_INVALID_NAME),
1790  errmsg("invalid name syntax")));
1791 
1792  if (namelist == NIL)
1793  ereturn(escontext, NIL,
1794  (errcode(ERRCODE_INVALID_NAME),
1795  errmsg("invalid name syntax")));
1796 
1797  foreach(l, namelist)
1798  {
1799  char *curname = (char *) lfirst(l);
1800 
1801  result = lappend(result, makeString(pstrdup(curname)));
1802  }
1803 
1804  pfree(rawname);
1805  list_free(namelist);
1806 
1807  return result;
1808 }
void list_free(List *list)
Definition: list.c:1546
#define lfirst(lc)
Definition: pg_list.h:172
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
Definition: varlena.c:3456

References ereturn, errcode(), errmsg(), lappend(), lfirst, list_free(), makeString(), NIL, pfree(), pstrdup(), and SplitIdentifierString().

Referenced by call_pltcl_start_proc(), check_default_text_search_config(), getTSCurrentConfig(), parseNameAndArgTypes(), regclassin(), regcollationin(), regconfigin(), regdictionaryin(), regnamespacein(), regoperin(), regprocin(), regrolein(), RelationNameGetTupleDesc(), thesaurus_init(), and tsvector_update_trigger().

◆ text_regclass()

Datum text_regclass ( PG_FUNCTION_ARGS  )

Definition at line 1754 of file regproc.c.

1755 {
1757  Oid result;
1758  RangeVar *rv;
1759 
1761 
1762  /* We might not even have permissions on this relation; don't lock it. */
1763  result = RangeVarGetRelid(rv, NoLock, false);
1764 
1765  PG_RETURN_OID(result);
1766 }
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
NameData relname
Definition: pg_class.h:38
Definition: c.h:676
List * textToQualifiedNameList(text *textval)
Definition: varlena.c:3398

References makeRangeVarFromNameList(), NoLock, PG_GETARG_TEXT_PP, PG_RETURN_OID, RangeVarGetRelid, relname, and textToQualifiedNameList().

◆ to_regclass()

Datum to_regclass ( PG_FUNCTION_ARGS  )

Definition at line 925 of file regproc.c.

926 {
928  Datum result;
929  ErrorSaveContext escontext = {T_ErrorSaveContext};
930 
932  InvalidOid, -1,
933  (Node *) &escontext,
934  &result))
935  PG_RETURN_NULL();
936  PG_RETURN_DATUM(result);
937 }
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
Datum regclassin(PG_FUNCTION_ARGS)
Definition: regproc.c:882
const char * class_name
Definition: selinux.c:32
char * text_to_cstring(const text *t)
Definition: varlena.c:217

References class_name, DirectInputFunctionCallSafe(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, regclassin(), and text_to_cstring().

◆ to_regcollation()

Datum to_regcollation ( PG_FUNCTION_ARGS  )

Definition at line 1068 of file regproc.c.

1069 {
1070  char *collation_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
1071  Datum result;
1072  ErrorSaveContext escontext = {T_ErrorSaveContext};
1073 
1074  if (!DirectInputFunctionCallSafe(regcollationin, collation_name,
1075  InvalidOid, -1,
1076  (Node *) &escontext,
1077  &result))
1078  PG_RETURN_NULL();
1079  PG_RETURN_DATUM(result);
1080 }
Datum regcollationin(PG_FUNCTION_ARGS)
Definition: regproc.c:1026

References DirectInputFunctionCallSafe(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, regcollationin(), and text_to_cstring().

◆ to_regnamespace()

Datum to_regnamespace ( PG_FUNCTION_ARGS  )

Definition at line 1680 of file regproc.c.

1681 {
1682  char *nsp_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
1683  Datum result;
1684  ErrorSaveContext escontext = {T_ErrorSaveContext};
1685 
1687  InvalidOid, -1,
1688  (Node *) &escontext,
1689  &result))
1690  PG_RETURN_NULL();
1691  PG_RETURN_DATUM(result);
1692 }
Datum regnamespacein(PG_FUNCTION_ARGS)
Definition: regproc.c:1638

References DirectInputFunctionCallSafe(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, regnamespacein(), and text_to_cstring().

◆ to_regoper()

Datum to_regoper ( PG_FUNCTION_ARGS  )

Definition at line 527 of file regproc.c.

528 {
529  char *opr_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
530  Datum result;
531  ErrorSaveContext escontext = {T_ErrorSaveContext};
532 
533  if (!DirectInputFunctionCallSafe(regoperin, opr_name,
534  InvalidOid, -1,
535  (Node *) &escontext,
536  &result))
537  PG_RETURN_NULL();
538  PG_RETURN_DATUM(result);
539 }
Datum regoperin(PG_FUNCTION_ARGS)
Definition: regproc.c:478

References DirectInputFunctionCallSafe(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, regoperin(), and text_to_cstring().

◆ to_regoperator()

Datum to_regoperator ( PG_FUNCTION_ARGS  )

Definition at line 694 of file regproc.c.

695 {
696  char *opr_name_or_oid = text_to_cstring(PG_GETARG_TEXT_PP(0));
697  Datum result;
698  ErrorSaveContext escontext = {T_ErrorSaveContext};
699 
700  if (!DirectInputFunctionCallSafe(regoperatorin, opr_name_or_oid,
701  InvalidOid, -1,
702  (Node *) &escontext,
703  &result))
704  PG_RETURN_NULL();
705  PG_RETURN_DATUM(result);
706 }
Datum regoperatorin(PG_FUNCTION_ARGS)
Definition: regproc.c:639

References DirectInputFunctionCallSafe(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, regoperatorin(), and text_to_cstring().

◆ to_regproc()

Datum to_regproc ( PG_FUNCTION_ARGS  )

Definition at line 118 of file regproc.c.

119 {
120  char *pro_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
121  Datum result;
122  ErrorSaveContext escontext = {T_ErrorSaveContext};
123 
124  if (!DirectInputFunctionCallSafe(regprocin, pro_name,
125  InvalidOid, -1,
126  (Node *) &escontext,
127  &result))
128  PG_RETURN_NULL();
129  PG_RETURN_DATUM(result);
130 }
Datum regprocin(PG_FUNCTION_ARGS)
Definition: regproc.c:66

References DirectInputFunctionCallSafe(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, regprocin(), and text_to_cstring().

◆ to_regprocedure()

Datum to_regprocedure ( PG_FUNCTION_ARGS  )

Definition at line 278 of file regproc.c.

279 {
280  char *pro_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
281  Datum result;
282  ErrorSaveContext escontext = {T_ErrorSaveContext};
283 
285  InvalidOid, -1,
286  (Node *) &escontext,
287  &result))
288  PG_RETURN_NULL();
289  PG_RETURN_DATUM(result);
290 }
Datum regprocedurein(PG_FUNCTION_ARGS)
Definition: regproc.c:224

References DirectInputFunctionCallSafe(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, regprocedurein(), and text_to_cstring().

◆ to_regrole()

Datum to_regrole ( PG_FUNCTION_ARGS  )

Definition at line 1563 of file regproc.c.

1564 {
1565  char *role_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
1566  Datum result;
1567  ErrorSaveContext escontext = {T_ErrorSaveContext};
1568 
1569  if (!DirectInputFunctionCallSafe(regrolein, role_name,
1570  InvalidOid, -1,
1571  (Node *) &escontext,
1572  &result))
1573  PG_RETURN_NULL();
1574  PG_RETURN_DATUM(result);
1575 }
Datum regrolein(PG_FUNCTION_ARGS)
Definition: regproc.c:1521

References DirectInputFunctionCallSafe(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, regrolein(), and text_to_cstring().

◆ to_regtype()

Datum to_regtype ( PG_FUNCTION_ARGS  )

Definition at line 1209 of file regproc.c.

1210 {
1211  char *typ_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
1212  Datum result;
1213  ErrorSaveContext escontext = {T_ErrorSaveContext};
1214 
1215  if (!DirectInputFunctionCallSafe(regtypein, typ_name,
1216  InvalidOid, -1,
1217  (Node *) &escontext,
1218  &result))
1219  PG_RETURN_NULL();
1220  PG_RETURN_DATUM(result);
1221 }
Datum regtypein(PG_FUNCTION_ARGS)
Definition: regproc.c:1176

References DirectInputFunctionCallSafe(), InvalidOid, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, regtypein(), and text_to_cstring().