#include "postgres.h"
#include <ctype.h>
#include "access/htup_details.h"
#include "catalog/namespace.h"
#include "catalog/pg_class.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 "miscadmin.h"
#include "parser/parse_type.h"
#include "parser/scansup.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#include "utils/acl.h"
#include "utils/regproc.h"
#include "utils/varlena.h"

Include dependency graph for regproc.c:

Functions
static char *	format_operator_internal (Oid operator_oid, bool force_qualify)

static char *	format_procedure_internal (Oid procedure_oid, bool force_qualify)

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

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)

void	format_procedure_parts (Oid procedure_oid, List objnames, List objargs)

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 (Oid operator_oid)

char *	format_operator_qualified (Oid operator_oid)

void	format_operator_parts (Oid operator_oid, List objnames, List objargs)

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

List *	stringToQualifiedNameList (const char *string)

Function Documentation

◆ format_operator()

char* format_operator ( Oid operator_oid )

Definition at line 820 of file regproc.c.

References format_operator_internal().

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

 {
     return format_operator_internal(operator_oid, false);
 }

◆ format_operator_internal()

static char * format_operator_internal	(	Oid	operator_oid,
		bool	force_qualify
	)

static

Definition at line 755 of file regproc.c.

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

Referenced by format_operator(), and format_operator_qualified().

 {
     char       *result;
     HeapTuple   opertup;
 
     opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operator_oid));
 
     if (HeapTupleIsValid(opertup))
     {
         Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
         char       *oprname = NameStr(operform->oprname);
         char       *nspname;
         StringInfoData buf;
 
         /* XXX no support here for bootstrap mode */
         Assert(!IsBootstrapProcessingMode());
 
         initStringInfo(&buf);
 
         /*
          * Would this oper be found (given the right args) by regoperatorin?
          * If not, or if caller explicitly requests it, we need to qualify it.
          */
         if (force_qualify || !OperatorIsVisible(operator_oid))
         {
             nspname = get_namespace_name(operform->oprnamespace);
             appendStringInfo(&buf, "%s.",
                              quote_identifier(nspname));
         }
 
         appendStringInfo(&buf, "%s(", oprname);
 
         if (operform->oprleft)
             appendStringInfo(&buf, "%s,",
                              force_qualify ?
                              format_type_be_qualified(operform->oprleft) :
                              format_type_be(operform->oprleft));
         else
             appendStringInfoString(&buf, "NONE,");
 
         if (operform->oprright)
             appendStringInfo(&buf, "%s)",
                              force_qualify ?
                              format_type_be_qualified(operform->oprright) :
                              format_type_be(operform->oprright));
         else
             appendStringInfoString(&buf, "NONE)");
 
         result = buf.data;
 
         ReleaseSysCache(opertup);
     }
     else
     {
         /*
          * If OID doesn't match any pg_operator entry, return it numerically
          */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", operator_oid);
     }
 
     return result;
 }

◆ format_operator_parts()

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

Definition at line 832 of file regproc.c.

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

Referenced by getObjectIdentityParts().

 {
     HeapTuple   opertup;
     Form_pg_operator oprForm;
 
     opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operator_oid));
     if (!HeapTupleIsValid(opertup))
         elog(ERROR, "cache lookup failed for operator with OID %u",
              operator_oid);
 
     oprForm = (Form_pg_operator) GETSTRUCT(opertup);
     *objnames = list_make2(get_namespace_name_or_temp(oprForm->oprnamespace),
                            pstrdup(NameStr(oprForm->oprname)));
     *objargs = NIL;
     if (oprForm->oprleft)
         *objargs = lappend(*objargs,
                            format_type_be_qualified(oprForm->oprleft));
     if (oprForm->oprright)
         *objargs = lappend(*objargs,
                            format_type_be_qualified(oprForm->oprright));
 
     ReleaseSysCache(opertup);
 }

◆ format_operator_qualified()

char* format_operator_qualified ( Oid operator_oid )

Definition at line 826 of file regproc.c.

References format_operator_internal().

Referenced by getObjectIdentityParts().

 {
     return format_operator_internal(operator_oid, true);
 }

◆ format_procedure()

char* format_procedure ( Oid procedure_oid )

Definition at line 323 of file regproc.c.

References format_procedure_internal().

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

 {
     return format_procedure_internal(procedure_oid, false);
 }

◆ format_procedure_internal()

static char * format_procedure_internal	(	Oid	procedure_oid,
		bool	force_qualify
	)

static

Definition at line 342 of file regproc.c.

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

Referenced by format_procedure(), and format_procedure_qualified().

 {
     char       *result;
     HeapTuple   proctup;
 
     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procedure_oid));
 
     if (HeapTupleIsValid(proctup))
     {
         Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
         char       *proname = NameStr(procform->proname);
         int         nargs = procform->pronargs;
         int         i;
         char       *nspname;
         StringInfoData buf;
 
         /* XXX no support here for bootstrap mode */
         Assert(!IsBootstrapProcessingMode());
 
         initStringInfo(&buf);
 
         /*
          * Would this proc be found (given the right args) by regprocedurein?
          * If not, or if caller requests it, we need to qualify it.
          */
         if (!force_qualify && FunctionIsVisible(procedure_oid))
             nspname = NULL;
         else
             nspname = get_namespace_name(procform->pronamespace);
 
         appendStringInfo(&buf, "%s(",
                          quote_qualified_identifier(nspname, proname));
         for (i = 0; i < nargs; i++)
         {
             Oid         thisargtype = procform->proargtypes.values[i];
 
             if (i > 0)
                 appendStringInfoChar(&buf, ',');
             appendStringInfoString(&buf,
                                    force_qualify ?
                                    format_type_be_qualified(thisargtype) :
                                    format_type_be(thisargtype));
         }
         appendStringInfoChar(&buf, ')');
 
         result = buf.data;
 
         ReleaseSysCache(proctup);
     }
     else
     {
         /* If OID doesn't match any pg_proc entry, return it numerically */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", procedure_oid);
     }
 
     return result;
 }

◆ format_procedure_parts()

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

Definition at line 408 of file regproc.c.

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

Referenced by getObjectIdentityParts().

 {
     HeapTuple   proctup;
     Form_pg_proc procform;
     int         nargs;
     int         i;
 
     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procedure_oid));
 
     if (!HeapTupleIsValid(proctup))
         elog(ERROR, "cache lookup failed for procedure with OID %u", procedure_oid);
 
     procform = (Form_pg_proc) GETSTRUCT(proctup);
     nargs = procform->pronargs;
 
     *objnames = list_make2(get_namespace_name_or_temp(procform->pronamespace),
                            pstrdup(NameStr(procform->proname)));
     *objargs = NIL;
     for (i = 0; i < nargs; i++)
     {
         Oid         thisargtype = procform->proargtypes.values[i];
 
         *objargs = lappend(*objargs, format_type_be_qualified(thisargtype));
     }
 
     ReleaseSysCache(proctup);
 }

◆ format_procedure_qualified()

char* format_procedure_qualified ( Oid procedure_oid )

Definition at line 329 of file regproc.c.

References format_procedure_internal().

Referenced by getObjectIdentityParts().

 {
     return format_procedure_internal(procedure_oid, true);
 }

◆ parseNameAndArgTypes()

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

static

Definition at line 1735 of file regproc.c.

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

Referenced by regoperatorin(), regprocedurein(), to_regoperator(), and to_regprocedure().

 {
     char       *rawname;
     char       *ptr;
     char       *ptr2;
     char       *typename;
     bool        in_quote;
     bool        had_comma;
     int         paren_count;
     Oid         typeid;
     int32       typmod;
 
     /* We need a modifiable copy of the input string. */
     rawname = pstrdup(string);
 
     /* Scan to find the expected left paren; mustn't be quoted */
     in_quote = false;
     for (ptr = rawname; *ptr; ptr++)
     {
         if (*ptr == '"')
             in_quote = !in_quote;
         else if (*ptr == '(' && !in_quote)
             break;
     }
     if (*ptr == '\0')
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("expected a left parenthesis")));
 
     /* Separate the name and parse it into a list */
     *ptr++ = '\0';
     *names = stringToQualifiedNameList(rawname);
 
     /* Check for the trailing right parenthesis and remove it */
     ptr2 = ptr + strlen(ptr);
     while (--ptr2 > ptr)
     {
         if (!scanner_isspace(*ptr2))
             break;
     }
     if (*ptr2 != ')')
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("expected a right parenthesis")));
 
     *ptr2 = '\0';
 
     /* Separate the remaining string into comma-separated type names */
     *nargs = 0;
     had_comma = false;
 
     for (;;)
     {
         /* allow leading whitespace */
         while (scanner_isspace(*ptr))
             ptr++;
         if (*ptr == '\0')
         {
             /* End of string.  Okay unless we had a comma before. */
             if (had_comma)
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                          errmsg("expected a type name")));
             break;
         }
         typename = ptr;
         /* Find end of type name --- end of string or comma */
         /* ... but not a quoted or parenthesized comma */
         in_quote = false;
         paren_count = 0;
         for (; *ptr; ptr++)
         {
             if (*ptr == '"')
                 in_quote = !in_quote;
             else if (*ptr == ',' && !in_quote && paren_count == 0)
                 break;
             else if (!in_quote)
             {
                 switch (*ptr)
                 {
                     case '(':
                     case '[':
                         paren_count++;
                         break;
                     case ')':
                     case ']':
                         paren_count--;
                         break;
                 }
             }
         }
         if (in_quote || paren_count != 0)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                      errmsg("improper type name")));
 
         ptr2 = ptr;
         if (*ptr == ',')
         {
             had_comma = true;
             *ptr++ = '\0';
         }
         else
         {
             had_comma = false;
             Assert(*ptr == '\0');
         }
         /* Lop off trailing whitespace */
         while (--ptr2 >= typename)
         {
             if (!scanner_isspace(*ptr2))
                 break;
             *ptr2 = '\0';
         }
 
         if (allowNone && pg_strcasecmp(typename, "none") == 0)
         {
             /* Special case for NONE */
             typeid = InvalidOid;
             typmod = -1;
         }
         else
         {
             /* Use full parser to resolve the type name */
             parseTypeString(typename, &typeid, &typmod, false);
         }
         if (*nargs >= FUNC_MAX_ARGS)
             ereport(ERROR,
                     (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                      errmsg("too many arguments")));
 
         argtypes[*nargs] = typeid;
         (*nargs)++;
     }
 
     pfree(rawname);
 }

◆ regclassin()

Datum regclassin ( PG_FUNCTION_ARGS )

Definition at line 903 of file regproc.c.

References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ERROR, InvalidOid, IsBootstrapProcessingMode, makeRangeVarFromNameList(), NoLock, oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, RangeVarGetRelid, and stringToQualifiedNameList().

 {
     char       *class_name_or_oid = PG_GETARG_CSTRING(0);
     Oid         result = InvalidOid;
     List       *names;
 
     /* '-' ? */
     if (strcmp(class_name_or_oid, "-") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (class_name_or_oid[0] >= '0' &&
         class_name_or_oid[0] <= '9' &&
         strspn(class_name_or_oid, "0123456789") == strlen(class_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(class_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* Else it's a name, possibly schema-qualified */
 
     /* The rest of this wouldn't work in bootstrap mode */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regclass values must be OIDs in bootstrap mode");
 
     /*
      * Normal case: parse the name into components and see if it matches any
      * pg_class entries in the current search path.
      */
     names = stringToQualifiedNameList(class_name_or_oid);
 
     /* We might not even have permissions on this relation; don't lock it. */
     result = RangeVarGetRelid(makeRangeVarFromNameList(names), NoLock, false);
 
     PG_RETURN_OID(result);
 }

◆ regclassout()

Datum regclassout ( PG_FUNCTION_ARGS )

Definition at line 972 of file regproc.c.

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

Referenced by table_to_xml_internal().

 {
     Oid         classid = PG_GETARG_OID(0);
     char       *result;
     HeapTuple   classtup;
 
     if (classid == InvalidOid)
     {
         result = pstrdup("-");
         PG_RETURN_CSTRING(result);
     }
 
     classtup = SearchSysCache1(RELOID, ObjectIdGetDatum(classid));
 
     if (HeapTupleIsValid(classtup))
     {
         Form_pg_class classform = (Form_pg_class) GETSTRUCT(classtup);
         char       *classname = NameStr(classform->relname);
 
         /*
          * In bootstrap mode, skip the fancy namespace stuff and just return
          * the class name.  (This path is only needed for debugging output
          * anyway.)
          */
         if (IsBootstrapProcessingMode())
             result = pstrdup(classname);
         else
         {
             char       *nspname;
 
             /*
              * Would this class be found by regclassin? If not, qualify it.
              */
             if (RelationIsVisible(classid))
                 nspname = NULL;
             else
                 nspname = get_namespace_name(classform->relnamespace);
 
             result = quote_qualified_identifier(nspname, classname);
         }
 
         ReleaseSysCache(classtup);
     }
     else
     {
         /* If OID doesn't match any pg_class entry, return it numerically */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", classid);
     }
 
     PG_RETURN_CSTRING(result);
 }

◆ regclassrecv()

Datum regclassrecv ( PG_FUNCTION_ARGS )

Definition at line 1029 of file regproc.c.

References oidrecv().

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

◆ regclasssend()

Datum regclasssend ( PG_FUNCTION_ARGS )

Definition at line 1039 of file regproc.c.

References oidsend().

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

◆ regconfigin()

Datum regconfigin ( PG_FUNCTION_ARGS )

Definition at line 1197 of file regproc.c.

References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ERROR, get_ts_config_oid(), InvalidOid, IsBootstrapProcessingMode, oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, and stringToQualifiedNameList().

 {
     char       *cfg_name_or_oid = PG_GETARG_CSTRING(0);
     Oid         result;
     List       *names;
 
     /* '-' ? */
     if (strcmp(cfg_name_or_oid, "-") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (cfg_name_or_oid[0] >= '0' &&
         cfg_name_or_oid[0] <= '9' &&
         strspn(cfg_name_or_oid, "0123456789") == strlen(cfg_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(cfg_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* The rest of this wouldn't work in bootstrap mode */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regconfig values must be OIDs in bootstrap mode");
 
     /*
      * Normal case: parse the name into components and see if it matches any
      * pg_ts_config entries in the current search path.
      */
     names = stringToQualifiedNameList(cfg_name_or_oid);
 
     result = get_ts_config_oid(names, false);
 
     PG_RETURN_OID(result);
 }

◆ regconfigout()

Datum regconfigout ( PG_FUNCTION_ARGS )

Definition at line 1236 of file regproc.c.

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

 {
     Oid         cfgid = PG_GETARG_OID(0);
     char       *result;
     HeapTuple   cfgtup;
 
     if (cfgid == InvalidOid)
     {
         result = pstrdup("-");
         PG_RETURN_CSTRING(result);
     }
 
     cfgtup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgid));
 
     if (HeapTupleIsValid(cfgtup))
     {
         Form_pg_ts_config cfgform = (Form_pg_ts_config) GETSTRUCT(cfgtup);
         char       *cfgname = NameStr(cfgform->cfgname);
         char       *nspname;
 
         /*
          * Would this config be found by regconfigin? If not, qualify it.
          */
         if (TSConfigIsVisible(cfgid))
             nspname = NULL;
         else
             nspname = get_namespace_name(cfgform->cfgnamespace);
 
         result = quote_qualified_identifier(nspname, cfgname);
 
         ReleaseSysCache(cfgtup);
     }
     else
     {
         /* If OID doesn't match any pg_ts_config row, return it numerically */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", cfgid);
     }
 
     PG_RETURN_CSTRING(result);
 }

◆ regconfigrecv()

Datum regconfigrecv ( PG_FUNCTION_ARGS )

Definition at line 1282 of file regproc.c.

References oidrecv().

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

◆ regconfigsend()

Datum regconfigsend ( PG_FUNCTION_ARGS )

Definition at line 1292 of file regproc.c.

References oidsend().

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

◆ regdictionaryin()

Datum regdictionaryin ( PG_FUNCTION_ARGS )

Definition at line 1308 of file regproc.c.

References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ERROR, get_ts_dict_oid(), InvalidOid, IsBootstrapProcessingMode, oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, and stringToQualifiedNameList().

 {
     char       *dict_name_or_oid = PG_GETARG_CSTRING(0);
     Oid         result;
     List       *names;
 
     /* '-' ? */
     if (strcmp(dict_name_or_oid, "-") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (dict_name_or_oid[0] >= '0' &&
         dict_name_or_oid[0] <= '9' &&
         strspn(dict_name_or_oid, "0123456789") == strlen(dict_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(dict_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* The rest of this wouldn't work in bootstrap mode */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regdictionary values must be OIDs in bootstrap mode");
 
     /*
      * Normal case: parse the name into components and see if it matches any
      * pg_ts_dict entries in the current search path.
      */
     names = stringToQualifiedNameList(dict_name_or_oid);
 
     result = get_ts_dict_oid(names, false);
 
     PG_RETURN_OID(result);
 }

◆ regdictionaryout()

Datum regdictionaryout ( PG_FUNCTION_ARGS )

Definition at line 1347 of file regproc.c.

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

 {
     Oid         dictid = PG_GETARG_OID(0);
     char       *result;
     HeapTuple   dicttup;
 
     if (dictid == InvalidOid)
     {
         result = pstrdup("-");
         PG_RETURN_CSTRING(result);
     }
 
     dicttup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictid));
 
     if (HeapTupleIsValid(dicttup))
     {
         Form_pg_ts_dict dictform = (Form_pg_ts_dict) GETSTRUCT(dicttup);
         char       *dictname = NameStr(dictform->dictname);
         char       *nspname;
 
         /*
          * Would this dictionary be found by regdictionaryin? If not, qualify
          * it.
          */
         if (TSDictionaryIsVisible(dictid))
             nspname = NULL;
         else
             nspname = get_namespace_name(dictform->dictnamespace);
 
         result = quote_qualified_identifier(nspname, dictname);
 
         ReleaseSysCache(dicttup);
     }
     else
     {
         /* If OID doesn't match any pg_ts_dict row, return it numerically */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", dictid);
     }
 
     PG_RETURN_CSTRING(result);
 }

◆ regdictionaryrecv()

Datum regdictionaryrecv ( PG_FUNCTION_ARGS )

Definition at line 1394 of file regproc.c.

References oidrecv().

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

◆ regdictionarysend()

Datum regdictionarysend ( PG_FUNCTION_ARGS )

Definition at line 1404 of file regproc.c.

References oidsend().

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

◆ regnamespacein()

Datum regnamespacein ( PG_FUNCTION_ARGS )

Definition at line 1544 of file regproc.c.

References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ereport, errcode(), errmsg(), ERROR, get_namespace_oid(), InvalidOid, IsBootstrapProcessingMode, linitial, list_length(), oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, stringToQualifiedNameList(), and strVal.

 {
     char       *nsp_name_or_oid = PG_GETARG_CSTRING(0);
     Oid         result;
     List       *names;
 
     /* '-' ? */
     if (strcmp(nsp_name_or_oid, "-") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (nsp_name_or_oid[0] >= '0' &&
         nsp_name_or_oid[0] <= '9' &&
         strspn(nsp_name_or_oid, "0123456789") == strlen(nsp_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(nsp_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* The rest of this wouldn't work in bootstrap mode */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regnamespace values must be OIDs in bootstrap mode");
 
     /* Normal case: see if the name matches any pg_namespace entry. */
     names = stringToQualifiedNameList(nsp_name_or_oid);
 
     if (list_length(names) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_NAME),
                  errmsg("invalid name syntax")));
 
     result = get_namespace_oid(strVal(linitial(names)), false);
 
     PG_RETURN_OID(result);
 }

◆ regnamespaceout()

Datum regnamespaceout ( PG_FUNCTION_ARGS )

Definition at line 1612 of file regproc.c.

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

 {
     Oid         nspid = PG_GETARG_OID(0);
     char       *result;
 
     if (nspid == InvalidOid)
     {
         result = pstrdup("-");
         PG_RETURN_CSTRING(result);
     }
 
     result = get_namespace_name(nspid);
 
     if (result)
     {
         /* pstrdup is not really necessary, but it avoids a compiler warning */
         result = pstrdup(quote_identifier(result));
     }
     else
     {
         /* If OID doesn't match any namespace, return it numerically */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", nspid);
     }
 
     PG_RETURN_CSTRING(result);
 }

◆ regnamespacerecv()

Datum regnamespacerecv ( PG_FUNCTION_ARGS )

Definition at line 1644 of file regproc.c.

References oidrecv().

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

◆ regnamespacesend()

Datum regnamespacesend ( PG_FUNCTION_ARGS )

Definition at line 1654 of file regproc.c.

References oidsend().

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

◆ regoperatorin()

Datum regoperatorin ( PG_FUNCTION_ARGS )

Definition at line 655 of file regproc.c.

References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ereport, errcode(), errhint(), errmsg(), ERROR, FUNC_MAX_ARGS, InvalidOid, IsBootstrapProcessingMode, oidin(), OidIsValid, OpernameGetOprid(), parseNameAndArgTypes(), PG_GETARG_CSTRING, and PG_RETURN_OID.

 {
     char       *opr_name_or_oid = PG_GETARG_CSTRING(0);
     Oid         result;
     List       *names;
     int         nargs;
     Oid         argtypes[FUNC_MAX_ARGS];
 
     /* '0' ? */
     if (strcmp(opr_name_or_oid, "0") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (opr_name_or_oid[0] >= '0' &&
         opr_name_or_oid[0] <= '9' &&
         strspn(opr_name_or_oid, "0123456789") == strlen(opr_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(opr_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* The rest of this wouldn't work in bootstrap mode */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regoperator values must be OIDs in bootstrap mode");
 
     /*
      * Else it's a name and arguments.  Parse the name and arguments, look up
      * potential matches in the current namespace search list, and scan to see
      * which one exactly matches the given argument types.  (There will not be
      * more than one match.)
      */
     parseNameAndArgTypes(opr_name_or_oid, true, &names, &nargs, argtypes);
     if (nargs == 1)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_PARAMETER),
                  errmsg("missing argument"),
                  errhint("Use NONE to denote the missing argument of a unary operator.")));
     if (nargs != 2)
         ereport(ERROR,
                 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                  errmsg("too many arguments"),
                  errhint("Provide two argument types for operator.")));
 
     result = OpernameGetOprid(names, argtypes[0], argtypes[1]);
 
     if (!OidIsValid(result))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_FUNCTION),
                  errmsg("operator does not exist: %s", opr_name_or_oid)));
 
     PG_RETURN_OID(result);
 }

◆ regoperatorout()

Datum regoperatorout ( PG_FUNCTION_ARGS )

Definition at line 860 of file regproc.c.

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

 {
     Oid         oprid = PG_GETARG_OID(0);
     char       *result;
 
     if (oprid == InvalidOid)
         result = pstrdup("0");
     else
         result = format_operator(oprid);
 
     PG_RETURN_CSTRING(result);
 }

◆ regoperatorrecv()

Datum regoperatorrecv ( PG_FUNCTION_ARGS )

Definition at line 877 of file regproc.c.

References oidrecv().

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

◆ regoperatorsend()

Datum regoperatorsend ( PG_FUNCTION_ARGS )

Definition at line 887 of file regproc.c.

References oidsend().

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

◆ regoperin()

Datum regoperin ( PG_FUNCTION_ARGS )

Definition at line 483 of file regproc.c.

References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ereport, errcode(), errmsg(), ERROR, InvalidOid, IsBootstrapProcessingMode, _FuncCandidateList::next, _FuncCandidateList::oid, oidin(), OpernameGetCandidates(), PG_GETARG_CSTRING, PG_RETURN_OID, and stringToQualifiedNameList().

 {
     char       *opr_name_or_oid = PG_GETARG_CSTRING(0);
     Oid         result = InvalidOid;
     List       *names;
     FuncCandidateList clist;
 
     /* '0' ? */
     if (strcmp(opr_name_or_oid, "0") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (opr_name_or_oid[0] >= '0' &&
         opr_name_or_oid[0] <= '9' &&
         strspn(opr_name_or_oid, "0123456789") == strlen(opr_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(opr_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* Else it's a name, possibly schema-qualified */
 
     /* The rest of this wouldn't work in bootstrap mode */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regoper values must be OIDs in bootstrap mode");
 
     /*
      * Normal case: parse the name into components and see if it matches any
      * pg_operator entries in the current search path.
      */
     names = stringToQualifiedNameList(opr_name_or_oid);
     clist = OpernameGetCandidates(names, '\0', false);
 
     if (clist == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_FUNCTION),
                  errmsg("operator does not exist: %s", opr_name_or_oid)));
     else if (clist->next != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                  errmsg("more than one operator named %s",
                         opr_name_or_oid)));
 
     result = clist->oid;
 
     PG_RETURN_OID(result);
 }

◆ regoperout()

Datum regoperout ( PG_FUNCTION_ARGS )

Definition at line 561 of file regproc.c.

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

 {
     Oid         oprid = PG_GETARG_OID(0);
     char       *result;
     HeapTuple   opertup;
 
     if (oprid == InvalidOid)
     {
         result = pstrdup("0");
         PG_RETURN_CSTRING(result);
     }
 
     opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(oprid));
 
     if (HeapTupleIsValid(opertup))
     {
         Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
         char       *oprname = NameStr(operform->oprname);
 
         /*
          * In bootstrap mode, skip the fancy namespace stuff and just return
          * the oper name.  (This path is only needed for debugging output
          * anyway.)
          */
         if (IsBootstrapProcessingMode())
             result = pstrdup(oprname);
         else
         {
             FuncCandidateList clist;
 
             /*
              * Would this oper be found (uniquely!) by regoperin? If not,
              * qualify it.
              */
             clist = OpernameGetCandidates(list_make1(makeString(oprname)),
                                           '\0', false);
             if (clist != NULL && clist->next == NULL &&
                 clist->oid == oprid)
                 result = pstrdup(oprname);
             else
             {
                 const char *nspname;
 
                 nspname = get_namespace_name(operform->oprnamespace);
                 nspname = quote_identifier(nspname);
                 result = (char *) palloc(strlen(nspname) + strlen(oprname) + 2);
                 sprintf(result, "%s.%s", nspname, oprname);
             }
         }
 
         ReleaseSysCache(opertup);
     }
     else
     {
         /*
          * If OID doesn't match any pg_operator entry, return it numerically
          */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", oprid);
     }
 
     PG_RETURN_CSTRING(result);
 }

◆ regoperrecv()

Datum regoperrecv ( PG_FUNCTION_ARGS )

Definition at line 629 of file regproc.c.

References oidrecv().

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

◆ regopersend()

Datum regopersend ( PG_FUNCTION_ARGS )

Definition at line 639 of file regproc.c.

References oidsend().

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

◆ regprocedurein()

Datum regprocedurein ( PG_FUNCTION_ARGS )

Definition at line 231 of file regproc.c.

References _FuncCandidateList::args, CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ereport, errcode(), errmsg(), ERROR, FUNC_MAX_ARGS, FuncnameGetCandidates(), InvalidOid, IsBootstrapProcessingMode, _FuncCandidateList::next, NIL, _FuncCandidateList::oid, oidin(), parseNameAndArgTypes(), PG_GETARG_CSTRING, and PG_RETURN_OID.

Referenced by convert_function_name().

 {
     char       *pro_name_or_oid = PG_GETARG_CSTRING(0);
     RegProcedure result = InvalidOid;
     List       *names;
     int         nargs;
     Oid         argtypes[FUNC_MAX_ARGS];
     FuncCandidateList clist;
 
     /* '-' ? */
     if (strcmp(pro_name_or_oid, "-") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (pro_name_or_oid[0] >= '0' &&
         pro_name_or_oid[0] <= '9' &&
         strspn(pro_name_or_oid, "0123456789") == strlen(pro_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(pro_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* The rest of this wouldn't work in bootstrap mode */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regprocedure values must be OIDs in bootstrap mode");
 
     /*
      * Else it's a name and arguments.  Parse the name and arguments, look up
      * potential matches in the current namespace search list, and scan to see
      * which one exactly matches the given argument types.  (There will not be
      * more than one match.)
      */
     parseNameAndArgTypes(pro_name_or_oid, false, &names, &nargs, argtypes);
 
     clist = FuncnameGetCandidates(names, nargs, NIL, false, false, false);
 
     for (; clist; clist = clist->next)
     {
         if (memcmp(clist->args, argtypes, nargs * sizeof(Oid)) == 0)
             break;
     }
 
     if (clist == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_FUNCTION),
                  errmsg("function \"%s\" does not exist", pro_name_or_oid)));
 
     result = clist->oid;
 
     PG_RETURN_OID(result);
 }

◆ regprocedureout()

Datum regprocedureout ( PG_FUNCTION_ARGS )

Definition at line 440 of file regproc.c.

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

 {
     RegProcedure proid = PG_GETARG_OID(0);
     char       *result;
 
     if (proid == InvalidOid)
         result = pstrdup("-");
     else
         result = format_procedure(proid);
 
     PG_RETURN_CSTRING(result);
 }

◆ regprocedurerecv()

Datum regprocedurerecv ( PG_FUNCTION_ARGS )

Definition at line 457 of file regproc.c.

References oidrecv().

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

◆ regproceduresend()

Datum regproceduresend ( PG_FUNCTION_ARGS )

Definition at line 467 of file regproc.c.

References oidsend().

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

◆ regprocin()

Datum regprocin ( PG_FUNCTION_ARGS )

Definition at line 62 of file regproc.c.

References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ereport, errcode(), errmsg(), ERROR, FuncnameGetCandidates(), InvalidOid, IsBootstrapProcessingMode, _FuncCandidateList::next, NIL, _FuncCandidateList::oid, oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, and stringToQualifiedNameList().

 {
     char       *pro_name_or_oid = PG_GETARG_CSTRING(0);
     RegProcedure result = InvalidOid;
     List       *names;
     FuncCandidateList clist;
 
     /* '-' ? */
     if (strcmp(pro_name_or_oid, "-") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (pro_name_or_oid[0] >= '0' &&
         pro_name_or_oid[0] <= '9' &&
         strspn(pro_name_or_oid, "0123456789") == strlen(pro_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(pro_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* Else it's a name, possibly schema-qualified */
 
     /*
      * We should never get here in bootstrap mode, as all references should
      * have been resolved by genbki.pl.
      */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regproc values must be OIDs in bootstrap mode");
 
     /*
      * Normal case: parse the name into components and see if it matches any
      * pg_proc entries in the current search path.
      */
     names = stringToQualifiedNameList(pro_name_or_oid);
     clist = FuncnameGetCandidates(names, -1, NIL, false, false, false);
 
     if (clist == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_FUNCTION),
                  errmsg("function \"%s\" does not exist", pro_name_or_oid)));
     else if (clist->next != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                  errmsg("more than one function named \"%s\"",
                         pro_name_or_oid)));
 
     result = clist->oid;
 
     PG_RETURN_OID(result);
 }

◆ regprocout()

Datum regprocout ( PG_FUNCTION_ARGS )

Definition at line 143 of file regproc.c.

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, PROCOID, proname, pstrdup(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), and snprintf.

 {
     RegProcedure proid = PG_GETARG_OID(0);
     char       *result;
     HeapTuple   proctup;
 
     if (proid == InvalidOid)
     {
         result = pstrdup("-");
         PG_RETURN_CSTRING(result);
     }
 
     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(proid));
 
     if (HeapTupleIsValid(proctup))
     {
         Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
         char       *proname = NameStr(procform->proname);
 
         /*
          * In bootstrap mode, skip the fancy namespace stuff and just return
          * the proc name.  (This path is only needed for debugging output
          * anyway.)
          */
         if (IsBootstrapProcessingMode())
             result = pstrdup(proname);
         else
         {
             char       *nspname;
             FuncCandidateList clist;
 
             /*
              * Would this proc be found (uniquely!) by regprocin? If not,
              * qualify it.
              */
             clist = FuncnameGetCandidates(list_make1(makeString(proname)),
                                           -1, NIL, false, false, false);
             if (clist != NULL && clist->next == NULL &&
                 clist->oid == proid)
                 nspname = NULL;
             else
                 nspname = get_namespace_name(procform->pronamespace);
 
             result = quote_qualified_identifier(nspname, proname);
         }
 
         ReleaseSysCache(proctup);
     }
     else
     {
         /* If OID doesn't match any pg_proc entry, return it numerically */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", proid);
     }
 
     PG_RETURN_CSTRING(result);
 }

◆ regprocrecv()

Datum regprocrecv ( PG_FUNCTION_ARGS )

Definition at line 205 of file regproc.c.

References oidrecv().

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

◆ regprocsend()

Datum regprocsend ( PG_FUNCTION_ARGS )

Definition at line 215 of file regproc.c.

References oidsend().

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

◆ regrolein()

Datum regrolein ( PG_FUNCTION_ARGS )

Definition at line 1419 of file regproc.c.

References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ereport, errcode(), errmsg(), ERROR, get_role_oid(), InvalidOid, IsBootstrapProcessingMode, linitial, list_length(), oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, stringToQualifiedNameList(), and strVal.

 {
     char       *role_name_or_oid = PG_GETARG_CSTRING(0);
     Oid         result;
     List       *names;
 
     /* '-' ? */
     if (strcmp(role_name_or_oid, "-") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (role_name_or_oid[0] >= '0' &&
         role_name_or_oid[0] <= '9' &&
         strspn(role_name_or_oid, "0123456789") == strlen(role_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(role_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* The rest of this wouldn't work in bootstrap mode */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regrole values must be OIDs in bootstrap mode");
 
     /* Normal case: see if the name matches any pg_authid entry. */
     names = stringToQualifiedNameList(role_name_or_oid);
 
     if (list_length(names) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_NAME),
                  errmsg("invalid name syntax")));
 
     result = get_role_oid(strVal(linitial(names)), false);
 
     PG_RETURN_OID(result);
 }

◆ regroleout()

Datum regroleout ( PG_FUNCTION_ARGS )

Definition at line 1487 of file regproc.c.

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

 {
     Oid         roleoid = PG_GETARG_OID(0);
     char       *result;
 
     if (roleoid == InvalidOid)
     {
         result = pstrdup("-");
         PG_RETURN_CSTRING(result);
     }
 
     result = GetUserNameFromId(roleoid, true);
 
     if (result)
     {
         /* pstrdup is not really necessary, but it avoids a compiler warning */
         result = pstrdup(quote_identifier(result));
     }
     else
     {
         /* If OID doesn't match any role, return it numerically */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", roleoid);
     }
 
     PG_RETURN_CSTRING(result);
 }

◆ regrolerecv()

Datum regrolerecv ( PG_FUNCTION_ARGS )

Definition at line 1519 of file regproc.c.

References oidrecv().

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

◆ regrolesend()

Datum regrolesend ( PG_FUNCTION_ARGS )

Definition at line 1529 of file regproc.c.

References oidsend().

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

◆ regtypein()

Datum regtypein ( PG_FUNCTION_ARGS )

Definition at line 1061 of file regproc.c.

References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, elog, ERROR, InvalidOid, IsBootstrapProcessingMode, oidin(), parseTypeString(), PG_GETARG_CSTRING, and PG_RETURN_OID.

Referenced by convert_type_name(), and plperl_sv_to_literal().

 {
     char       *typ_name_or_oid = PG_GETARG_CSTRING(0);
     Oid         result = InvalidOid;
     int32       typmod;
 
     /* '-' ? */
     if (strcmp(typ_name_or_oid, "-") == 0)
         PG_RETURN_OID(InvalidOid);
 
     /* Numeric OID? */
     if (typ_name_or_oid[0] >= '0' &&
         typ_name_or_oid[0] <= '9' &&
         strspn(typ_name_or_oid, "0123456789") == strlen(typ_name_or_oid))
     {
         result = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                       CStringGetDatum(typ_name_or_oid)));
         PG_RETURN_OID(result);
     }
 
     /* Else it's a type name, possibly schema-qualified or decorated */
 
     /* The rest of this wouldn't work in bootstrap mode */
     if (IsBootstrapProcessingMode())
         elog(ERROR, "regtype values must be OIDs in bootstrap mode");
 
     /*
      * Normal case: invoke the full parser to deal with special cases such as
      * array syntax.
      */
     parseTypeString(typ_name_or_oid, &result, &typmod, false);
 
     PG_RETURN_OID(result);
 }

◆ regtypeout()

Datum regtypeout ( PG_FUNCTION_ARGS )

Definition at line 1123 of file regproc.c.

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

 {
     Oid         typid = PG_GETARG_OID(0);
     char       *result;
     HeapTuple   typetup;
 
     if (typid == InvalidOid)
     {
         result = pstrdup("-");
         PG_RETURN_CSTRING(result);
     }
 
     typetup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
 
     if (HeapTupleIsValid(typetup))
     {
         Form_pg_type typeform = (Form_pg_type) GETSTRUCT(typetup);
 
         /*
          * In bootstrap mode, skip the fancy namespace stuff and just return
          * the type name.  (This path is only needed for debugging output
          * anyway.)
          */
         if (IsBootstrapProcessingMode())
         {
             char       *typname = NameStr(typeform->typname);
 
             result = pstrdup(typname);
         }
         else
             result = format_type_be(typid);
 
         ReleaseSysCache(typetup);
     }
     else
     {
         /* If OID doesn't match any pg_type entry, return it numerically */
         result = (char *) palloc(NAMEDATALEN);
         snprintf(result, NAMEDATALEN, "%u", typid);
     }
 
     PG_RETURN_CSTRING(result);
 }

◆ regtyperecv()

Datum regtyperecv ( PG_FUNCTION_ARGS )

Definition at line 1171 of file regproc.c.

References oidrecv().

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

◆ regtypesend()

Datum regtypesend ( PG_FUNCTION_ARGS )

Definition at line 1181 of file regproc.c.

References oidsend().

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

◆ stringToQualifiedNameList()

List* stringToQualifiedNameList ( const char * string )

Definition at line 1687 of file regproc.c.

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

Referenced by call_pltcl_start_proc(), check_TSCurrentConfig(), getTSCurrentConfig(), parseNameAndArgTypes(), regclassin(), regconfigin(), regdictionaryin(), regnamespacein(), regoperin(), regprocin(), regrolein(), RelationNameGetTupleDesc(), thesaurus_init(), to_regclass(), to_regnamespace(), to_regoper(), to_regproc(), to_regrole(), and tsvector_update_trigger().

 {
     char       *rawname;
     List       *result = NIL;
     List       *namelist;
     ListCell   *l;
 
     /* We need a modifiable copy of the input string. */
     rawname = pstrdup(string);
 
     if (!SplitIdentifierString(rawname, '.', &namelist))
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_NAME),
                  errmsg("invalid name syntax")));
 
     if (namelist == NIL)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_NAME),
                  errmsg("invalid name syntax")));
 
     foreach(l, namelist)
     {
         char       *curname = (char *) lfirst(l);
 
         result = lappend(result, makeString(pstrdup(curname)));
     }
 
     pfree(rawname);
     list_free(namelist);
 
     return result;
 }

◆ text_regclass()

Datum text_regclass ( PG_FUNCTION_ARGS )

Definition at line 1668 of file regproc.c.

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

 {
     text       *relname = PG_GETARG_TEXT_PP(0);
     Oid         result;
     RangeVar   *rv;
 
     rv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
 
     /* We might not even have permissions on this relation; don't lock it. */
     result = RangeVarGetRelid(rv, NoLock, false);
 
     PG_RETURN_OID(result);
 }

◆ to_regclass()

Datum to_regclass ( PG_FUNCTION_ARGS )

Definition at line 947 of file regproc.c.

References class_name, makeRangeVarFromNameList(), NoLock, OidIsValid, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_OID, RangeVarGetRelid, stringToQualifiedNameList(), and text_to_cstring().

 {
     char       *class_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
     Oid         result;
     List       *names;
 
     /*
      * Parse the name into components and see if it matches any pg_class
      * entries in the current search path.
      */
     names = stringToQualifiedNameList(class_name);
 
     /* We might not even have permissions on this relation; don't lock it. */
     result = RangeVarGetRelid(makeRangeVarFromNameList(names), NoLock, true);
 
     if (OidIsValid(result))
         PG_RETURN_OID(result);
     else
         PG_RETURN_NULL();
 }

◆ to_regnamespace()

Datum to_regnamespace ( PG_FUNCTION_ARGS )

Definition at line 1587 of file regproc.c.

References ereport, errcode(), errmsg(), ERROR, get_namespace_oid(), linitial, list_length(), OidIsValid, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_OID, stringToQualifiedNameList(), strVal, and text_to_cstring().

 {
     char       *nsp_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
     Oid         result;
     List       *names;
 
     names = stringToQualifiedNameList(nsp_name);
 
     if (list_length(names) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_NAME),
                  errmsg("invalid name syntax")));
 
     result = get_namespace_oid(strVal(linitial(names)), true);
 
     if (OidIsValid(result))
         PG_RETURN_OID(result);
     else
         PG_RETURN_NULL();
 }

◆ to_regoper()

Datum to_regoper ( PG_FUNCTION_ARGS )

Definition at line 538 of file regproc.c.

References _FuncCandidateList::next, _FuncCandidateList::oid, OpernameGetCandidates(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_OID, stringToQualifiedNameList(), and text_to_cstring().

 {
     char       *opr_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
     List       *names;
     FuncCandidateList clist;
 
     /*
      * Parse the name into components and see if it matches any pg_operator
      * entries in the current search path.
      */
     names = stringToQualifiedNameList(opr_name);
     clist = OpernameGetCandidates(names, '\0', true);
 
     if (clist == NULL || clist->next != NULL)
         PG_RETURN_NULL();
 
     PG_RETURN_OID(clist->oid);
 }

◆ to_regoperator()

Datum to_regoperator ( PG_FUNCTION_ARGS )

Definition at line 715 of file regproc.c.

References ereport, errcode(), errhint(), errmsg(), ERROR, FUNC_MAX_ARGS, OidIsValid, OpernameGetOprid(), parseNameAndArgTypes(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_OID, and text_to_cstring().

 {
     char       *opr_name_or_oid = text_to_cstring(PG_GETARG_TEXT_PP(0));
     Oid         result;
     List       *names;
     int         nargs;
     Oid         argtypes[FUNC_MAX_ARGS];
 
     /*
      * Parse the name and arguments, look up potential matches in the current
      * namespace search list, and scan to see which one exactly matches the
      * given argument types.    (There will not be more than one match.)
      */
     parseNameAndArgTypes(opr_name_or_oid, true, &names, &nargs, argtypes);
     if (nargs == 1)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_PARAMETER),
                  errmsg("missing argument"),
                  errhint("Use NONE to denote the missing argument of a unary operator.")));
     if (nargs != 2)
         ereport(ERROR,
                 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                  errmsg("too many arguments"),
                  errhint("Provide two argument types for operator.")));
 
     result = OpernameGetOprid(names, argtypes[0], argtypes[1]);
 
     if (!OidIsValid(result))
         PG_RETURN_NULL();
 
     PG_RETURN_OID(result);
 }

◆ to_regproc()

Datum to_regproc ( PG_FUNCTION_ARGS )

Definition at line 120 of file regproc.c.

References FuncnameGetCandidates(), _FuncCandidateList::next, NIL, _FuncCandidateList::oid, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_OID, stringToQualifiedNameList(), and text_to_cstring().

 {
     char       *pro_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
     List       *names;
     FuncCandidateList clist;
 
     /*
      * Parse the name into components and see if it matches any pg_proc
      * entries in the current search path.
      */
     names = stringToQualifiedNameList(pro_name);
     clist = FuncnameGetCandidates(names, -1, NIL, false, false, true);
 
     if (clist == NULL || clist->next != NULL)
         PG_RETURN_NULL();
 
     PG_RETURN_OID(clist->oid);
 }

◆ to_regprocedure()

Datum to_regprocedure ( PG_FUNCTION_ARGS )

Definition at line 290 of file regproc.c.

References _FuncCandidateList::args, FUNC_MAX_ARGS, FuncnameGetCandidates(), _FuncCandidateList::next, NIL, _FuncCandidateList::oid, parseNameAndArgTypes(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_OID, and text_to_cstring().

 {
     char       *pro_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
     List       *names;
     int         nargs;
     Oid         argtypes[FUNC_MAX_ARGS];
     FuncCandidateList clist;
 
     /*
      * Parse the name and arguments, look up potential matches in the current
      * namespace search list, and scan to see which one exactly matches the
      * given argument types.    (There will not be more than one match.)
      */
     parseNameAndArgTypes(pro_name, false, &names, &nargs, argtypes);
 
     clist = FuncnameGetCandidates(names, nargs, NIL, false, false, true);
 
     for (; clist; clist = clist->next)
     {
         if (memcmp(clist->args, argtypes, nargs * sizeof(Oid)) == 0)
             PG_RETURN_OID(clist->oid);
     }
 
     PG_RETURN_NULL();
 }

◆ to_regrole()

Datum to_regrole ( PG_FUNCTION_ARGS )

Definition at line 1462 of file regproc.c.

References ereport, errcode(), errmsg(), ERROR, get_role_oid(), linitial, list_length(), OidIsValid, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_OID, stringToQualifiedNameList(), strVal, and text_to_cstring().

 {
     char       *role_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
     Oid         result;
     List       *names;
 
     names = stringToQualifiedNameList(role_name);
 
     if (list_length(names) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_NAME),
                  errmsg("invalid name syntax")));
 
     result = get_role_oid(strVal(linitial(names)), true);
 
     if (OidIsValid(result))
         PG_RETURN_OID(result);
     else
         PG_RETURN_NULL();
 }

◆ to_regtype()

Datum to_regtype ( PG_FUNCTION_ARGS )

Definition at line 1102 of file regproc.c.

References OidIsValid, parseTypeString(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_OID, and text_to_cstring().

 {
     char       *typ_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
     Oid         result;
     int32       typmod;
 
     /*
      * Invoke the full parser to deal with special cases such as array syntax.
      */
     parseTypeString(typ_name, &result, &typmod, true);
 
     if (OidIsValid(result))
         PG_RETURN_OID(result);
     else
         PG_RETURN_NULL();
 }

Functions

Function Documentation

◆ format_operator()

◆ format_operator_internal()

◆ format_operator_parts()

◆ format_operator_qualified()

◆ format_procedure()

◆ format_procedure_internal()

◆ format_procedure_parts()

◆ format_procedure_qualified()

◆ parseNameAndArgTypes()

◆ regclassin()

◆ regclassout()

◆ regclassrecv()

◆ regclasssend()

◆ regconfigin()

◆ regconfigout()

◆ regconfigrecv()

◆ regconfigsend()

◆ regdictionaryin()

◆ regdictionaryout()

◆ regdictionaryrecv()

◆ regdictionarysend()

◆ regnamespacein()

◆ regnamespaceout()

◆ regnamespacerecv()

◆ regnamespacesend()

◆ regoperatorin()

◆ regoperatorout()

◆ regoperatorrecv()

◆ regoperatorsend()

◆ regoperin()

◆ regoperout()

◆ regoperrecv()

◆ regopersend()

◆ regprocedurein()

◆ regprocedureout()

◆ regprocedurerecv()

◆ regproceduresend()

◆ regprocin()

◆ regprocout()

◆ regprocrecv()

◆ regprocsend()

◆ regrolein()

◆ regroleout()

◆ regrolerecv()

◆ regrolesend()

◆ regtypein()

◆ regtypeout()

◆ regtyperecv()

◆ regtypesend()

◆ stringToQualifiedNameList()

◆ text_regclass()

◆ to_regclass()

◆ to_regnamespace()

◆ to_regoper()

◆ to_regoperator()

◆ to_regproc()

◆ to_regprocedure()

◆ to_regrole()

◆ to_regtype()