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	to_regtypemod (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, Node *escontext)

Function Documentation

format_operator()

char* format_operator

(

Oid

operator_oid

)

Definition at line 793 of file regproc.c.

{
    return format_operator_extended(operator_oid, 0);
}

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.

{
    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 ((flags & FORMAT_OPERATOR_FORCE_QUALIFY) != 0 ||
            !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,",
                             (flags & FORMAT_OPERATOR_FORCE_QUALIFY) != 0 ?
                             format_type_be_qualified(operform->oprleft) :
                             format_type_be(operform->oprleft));
        else
            appendStringInfoString(&buf, "NONE,");
 
        if (operform->oprright)
            appendStringInfo(&buf, "%s)",
                             (flags & FORMAT_OPERATOR_FORCE_QUALIFY) != 0 ?
                             format_type_be_qualified(operform->oprright) :
                             format_type_be(operform->oprright));
        else
            appendStringInfoString(&buf, "NONE)");
 
        result = buf.data;
 
        ReleaseSysCache(opertup);
    }
    else if ((flags & FORMAT_OPERATOR_INVALID_AS_NULL) != 0)
    {
        /* If object is undefined, return NULL as wanted by caller */
        result = NULL;
    }
    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;
}

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.

{
    HeapTuple   opertup;
    Form_pg_operator oprForm;
 
    opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operator_oid));
    if (!HeapTupleIsValid(opertup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for operator with OID %u",
                 operator_oid);
        return;
    }
 
    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);
}

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.

{
    return format_operator_extended(operator_oid,
                                    FORMAT_OPERATOR_FORCE_QUALIFY);
}

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.

{
    return format_procedure_extended(procedure_oid, 0);
}

References format_procedure_extended().

Referenced by blvalidate(), brinvalidate(), btvalidate(), compile_pltcl_function(), 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.

{
    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 ((flags & FORMAT_PROC_FORCE_QUALIFY) == 0 &&
            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,
                                   (flags & FORMAT_PROC_FORCE_QUALIFY) != 0 ?
                                   format_type_be_qualified(thisargtype) :
                                   format_type_be(thisargtype));
        }
        appendStringInfoChar(&buf, ')');
 
        result = buf.data;
 
        ReleaseSysCache(proctup);
    }
    else if ((flags & FORMAT_PROC_INVALID_AS_NULL) != 0)
    {
        /* If object is undefined, return NULL as wanted by caller */
        result = NULL;
    }
    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;
}

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.

{
    HeapTuple   proctup;
    Form_pg_proc procform;
    int         nargs;
    int         i;
 
    proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procedure_oid));
 
    if (!HeapTupleIsValid(proctup))
    {
        if (!missing_ok)
            elog(ERROR, "cache lookup failed for procedure with OID %u", procedure_oid);
        return;
    }
 
    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);
}

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.

{
    return format_procedure_extended(procedure_oid, FORMAT_PROC_FORCE_QUALIFY);
}

References FORMAT_PROC_FORCE_QUALIFY, and format_procedure_extended().

parseDashOrOid()

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

static

Definition at line 1868 of file regproc.c.

{
    /* '-' ? */
    if (strcmp(string, "-") == 0)
    {
        *result = InvalidOid;
        return true;
    }
 
    /* Numeric OID? */
    return parseNumericOid(string, result, escontext);
}

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 1895 of file regproc.c.

{
    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')
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("expected a left parenthesis")));
 
    /* Separate the name and parse it into a list */
    *ptr++ = '\0';
    *names = stringToQualifiedNameList(rawname, escontext);
    if (*names == NIL)
        return false;
 
    /* Check for the trailing right parenthesis and remove it */
    ptr2 = ptr + strlen(ptr);
    while (--ptr2 > ptr)
    {
        if (!scanner_isspace(*ptr2))
            break;
    }
    if (*ptr2 != ')')
        ereturn(escontext, false,
                (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)
                ereturn(escontext, false,
                        (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)
            ereturn(escontext, false,
                    (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 */
            if (!parseTypeString(typename, &typeid, &typmod, escontext))
                return false;
        }
        if (*nargs >= FUNC_MAX_ARGS)
            ereturn(escontext, false,
                    (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                     errmsg("too many arguments")));
 
        argtypes[*nargs] = typeid;
        (*nargs)++;
    }
 
    pfree(rawname);
 
    return true;
}

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 1843 of file regproc.c.

{
    if (string[0] >= '0' && string[0] <= '9' &&
        strspn(string, "0123456789") == strlen(string))
    {
        Datum       oid_datum;
 
        /* We need not care here whether oidin() fails or not. */
        (void) DirectInputFunctionCallSafe(oidin, string,
                                           InvalidOid, -1,
                                           escontext,
                                           &oid_datum);
        *result = DatumGetObjectId(oid_datum);
        return true;
    }
 
    /* Prevent uninitialized-variable warnings from stupider compilers. */
    *result = InvalidOid;
    return false;
}

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.

{
    char       *class_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    Oid         result;
    List       *names;
 
    /* Handle "-" or numeric OID */
    if (parseDashOrOid(class_name_or_oid, &result, escontext))
        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, escontext);
    if (names == NIL)
        PG_RETURN_NULL();
 
    /* We might not even have permissions on this relation; don't lock it. */
    result = RangeVarGetRelid(makeRangeVarFromNameList(names), NoLock, true);
 
    if (!OidIsValid(result))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_TABLE),
                 errmsg("relation \"%s\" does not exist",
                        NameListToString(names))));
 
    PG_RETURN_OID(result);
}

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.

{
    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);
}

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.

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

References oidrecv().

regclasssend()

Datum regclasssend

(

PG_FUNCTION_ARGS

)

Definition at line 1010 of file regproc.c.

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

References oidsend().

regcollationin()

Datum regcollationin

(

PG_FUNCTION_ARGS

)

Definition at line 1026 of file regproc.c.

{
    char       *collation_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    Oid         result;
    List       *names;
 
    /* Handle "-" or numeric OID */
    if (parseDashOrOid(collation_name_or_oid, &result, escontext))
        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, "regcollation values must be OIDs in bootstrap mode");
 
    /*
     * Normal case: parse the name into components and see if it matches any
     * pg_collation entries in the current search path.
     */
    names = stringToQualifiedNameList(collation_name_or_oid, escontext);
    if (names == NIL)
        PG_RETURN_NULL();
 
    result = get_collation_oid(names, true);
 
    if (!OidIsValid(result))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("collation \"%s\" for encoding \"%s\" does not exist",
                        NameListToString(names), GetDatabaseEncodingName())));
 
    PG_RETURN_OID(result);
}

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.

{
    Oid         collationid = PG_GETARG_OID(0);
    char       *result;
    HeapTuple   collationtup;
 
    if (collationid == InvalidOid)
    {
        result = pstrdup("-");
        PG_RETURN_CSTRING(result);
    }
 
    collationtup = SearchSysCache1(COLLOID, ObjectIdGetDatum(collationid));
 
    if (HeapTupleIsValid(collationtup))
    {
        Form_pg_collation collationform = (Form_pg_collation) GETSTRUCT(collationtup);
        char       *collationname = NameStr(collationform->collname);
 
        /*
         * In bootstrap mode, skip the fancy namespace stuff and just return
         * the collation name.  (This path is only needed for debugging output
         * anyway.)
         */
        if (IsBootstrapProcessingMode())
            result = pstrdup(collationname);
        else
        {
            char       *nspname;
 
            /*
             * Would this collation be found by regcollationin? If not,
             * qualify it.
             */
            if (CollationIsVisible(collationid))
                nspname = NULL;
            else
                nspname = get_namespace_name(collationform->collnamespace);
 
            result = quote_qualified_identifier(nspname, collationname);
        }
 
        ReleaseSysCache(collationtup);
    }
    else
    {
        /* If OID doesn't match any pg_collation entry, return it numerically */
        result = (char *) palloc(NAMEDATALEN);
        snprintf(result, NAMEDATALEN, "%u", collationid);
    }
 
    PG_RETURN_CSTRING(result);
}

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.

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

References oidrecv().

regcollationsend()

Datum regcollationsend

(

PG_FUNCTION_ARGS

)

Definition at line 1154 of file regproc.c.

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

References oidsend().

regconfigin()

Datum regconfigin

(

PG_FUNCTION_ARGS

)

Definition at line 1321 of file regproc.c.

{
    char       *cfg_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    Oid         result;
    List       *names;
 
    /* Handle "-" or numeric OID */
    if (parseDashOrOid(cfg_name_or_oid, &result, escontext))
        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, escontext);
    if (names == NIL)
        PG_RETURN_NULL();
 
    result = get_ts_config_oid(names, true);
 
    if (!OidIsValid(result))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("text search configuration \"%s\" does not exist",
                        NameListToString(names))));
 
    PG_RETURN_OID(result);
}

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 1359 of file regproc.c.

{
    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);
}

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 1405 of file regproc.c.

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

References oidrecv().

regconfigsend()

Datum regconfigsend

(

PG_FUNCTION_ARGS

)

Definition at line 1415 of file regproc.c.

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

References oidsend().

regdictionaryin()

Datum regdictionaryin

(

PG_FUNCTION_ARGS

)

Definition at line 1431 of file regproc.c.

{
    char       *dict_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    Oid         result;
    List       *names;
 
    /* Handle "-" or numeric OID */
    if (parseDashOrOid(dict_name_or_oid, &result, escontext))
        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, escontext);
    if (names == NIL)
        PG_RETURN_NULL();
 
    result = get_ts_dict_oid(names, true);
 
    if (!OidIsValid(result))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("text search dictionary \"%s\" does not exist",
                        NameListToString(names))));
 
    PG_RETURN_OID(result);
}

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 1469 of file regproc.c.

{
    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);
}

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 1516 of file regproc.c.

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

References oidrecv().

regdictionarysend()

Datum regdictionarysend

(

PG_FUNCTION_ARGS

)

Definition at line 1526 of file regproc.c.

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

References oidsend().

regnamespacein()

Datum regnamespacein

(

PG_FUNCTION_ARGS

)

Definition at line 1658 of file regproc.c.

{
    char       *nsp_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    Oid         result;
    List       *names;
 
    /* Handle "-" or numeric OID */
    if (parseDashOrOid(nsp_name_or_oid, &result, escontext))
        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, escontext);
    if (names == NIL)
        PG_RETURN_NULL();
 
    if (list_length(names) != 1)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("invalid name syntax")));
 
    result = get_namespace_oid(strVal(linitial(names)), true);
 
    if (!OidIsValid(result))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_SCHEMA),
                 errmsg("schema \"%s\" does not exist",
                        strVal(linitial(names)))));
 
    PG_RETURN_OID(result);
}

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 1718 of file regproc.c.

{
    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);
}

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 1750 of file regproc.c.

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

References oidrecv().

regnamespacesend()

Datum regnamespacesend

(

PG_FUNCTION_ARGS

)

Definition at line 1760 of file regproc.c.

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

References oidsend().

regoperatorin()

Datum regoperatorin

(

PG_FUNCTION_ARGS

)

Definition at line 639 of file regproc.c.

{
    char       *opr_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    Oid         result;
    List       *names;
    int         nargs;
    Oid         argtypes[FUNC_MAX_ARGS];
 
    /* Handle "0" or numeric OID */
    if (parseNumericOid(opr_name_or_oid, &result, escontext))
        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.)
     */
    if (!parseNameAndArgTypes(opr_name_or_oid, true,
                              &names, &nargs, argtypes,
                              escontext))
        PG_RETURN_NULL();
 
    if (nargs == 1)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_PARAMETER),
                 errmsg("missing argument"),
                 errhint("Use NONE to denote the missing argument of a unary operator.")));
    if (nargs != 2)
        ereturn(escontext, (Datum) 0,
                (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))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("operator does not exist: %s", opr_name_or_oid)));
 
    PG_RETURN_OID(result);
}

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.

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

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.

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

References oidrecv().

regoperatorsend()

Datum regoperatorsend

(

PG_FUNCTION_ARGS

)

Definition at line 866 of file regproc.c.

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

References oidsend().

regoperin()

Datum regoperin

(

PG_FUNCTION_ARGS

)

Definition at line 478 of file regproc.c.

{
    char       *opr_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    Oid         result;
    List       *names;
    FuncCandidateList clist;
 
    /* Handle "0" or numeric OID */
    if (parseNumericOid(opr_name_or_oid, &result, escontext))
        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, escontext);
    if (names == NIL)
        PG_RETURN_NULL();
 
    clist = OpernameGetCandidates(names, '\0', true);
 
    if (clist == NULL)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("operator does not exist: %s", opr_name_or_oid)));
    else if (clist->next != NULL)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                 errmsg("more than one operator named %s",
                        opr_name_or_oid)));
 
    result = clist->oid;
 
    PG_RETURN_OID(result);
}

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.

{
    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);
}

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.

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

References oidrecv().

regopersend()

Datum regopersend

(

PG_FUNCTION_ARGS

)

Definition at line 623 of file regproc.c.

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

References oidsend().

regprocedurein()

Datum regprocedurein

(

PG_FUNCTION_ARGS

)

Definition at line 224 of file regproc.c.

{
    char       *pro_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    RegProcedure result;
    List       *names;
    int         nargs;
    Oid         argtypes[FUNC_MAX_ARGS];
    FuncCandidateList clist;
 
    /* Handle "-" or numeric OID */
    if (parseDashOrOid(pro_name_or_oid, &result, escontext))
        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.)
     */
    if (!parseNameAndArgTypes(pro_name_or_oid, false,
                              &names, &nargs, argtypes,
                              escontext))
        PG_RETURN_NULL();
 
    clist = FuncnameGetCandidates(names, nargs, NIL, false, false,
                                  false, true);
 
    for (; clist; clist = clist->next)
    {
        if (memcmp(clist->args, argtypes, nargs * sizeof(Oid)) == 0)
            break;
    }
 
    if (clist == NULL)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("function \"%s\" does not exist", pro_name_or_oid)));
 
    result = clist->oid;
 
    PG_RETURN_OID(result);
}

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.

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

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.

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

References oidrecv().

regproceduresend()

Datum regproceduresend

(

PG_FUNCTION_ARGS

)

Definition at line 462 of file regproc.c.

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

References oidsend().

regprocin()

Datum regprocin

(

PG_FUNCTION_ARGS

)

Definition at line 66 of file regproc.c.

{
    char       *pro_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    RegProcedure result;
    List       *names;
    FuncCandidateList clist;
 
    /* Handle "-" or numeric OID */
    if (parseDashOrOid(pro_name_or_oid, &result, escontext))
        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, escontext);
    if (names == NIL)
        PG_RETURN_NULL();
 
    clist = FuncnameGetCandidates(names, -1, NIL, false, false, false, true);
 
    if (clist == NULL)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("function \"%s\" does not exist", pro_name_or_oid)));
    else if (clist->next != NULL)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                 errmsg("more than one function named \"%s\"",
                        pro_name_or_oid)));
 
    result = clist->oid;
 
    PG_RETURN_OID(result);
}

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.

{
    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, 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);
}

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.

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

References oidrecv().

regprocsend()

Datum regprocsend

(

PG_FUNCTION_ARGS

)

Definition at line 208 of file regproc.c.

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

References oidsend().

regrolein()

Datum regrolein

(

PG_FUNCTION_ARGS

)

Definition at line 1541 of file regproc.c.

{
    char       *role_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    Oid         result;
    List       *names;
 
    /* Handle "-" or numeric OID */
    if (parseDashOrOid(role_name_or_oid, &result, escontext))
        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, escontext);
    if (names == NIL)
        PG_RETURN_NULL();
 
    if (list_length(names) != 1)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("invalid name syntax")));
 
    result = get_role_oid(strVal(linitial(names)), true);
 
    if (!OidIsValid(result))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("role \"%s\" does not exist",
                        strVal(linitial(names)))));
 
    PG_RETURN_OID(result);
}

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 1601 of file regproc.c.

{
    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);
}

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 1633 of file regproc.c.

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

References oidrecv().

regrolesend()

Datum regrolesend

(

PG_FUNCTION_ARGS

)

Definition at line 1643 of file regproc.c.

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

References oidsend().

regtypein()

Datum regtypein

(

PG_FUNCTION_ARGS

)

Definition at line 1176 of file regproc.c.

{
    char       *typ_name_or_oid = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    Oid         result;
    int32       typmod;
 
    /* Handle "-" or numeric OID */
    if (parseDashOrOid(typ_name_or_oid, &result, escontext))
        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.  We don't need to check for parseTypeString failure,
     * since we'll just return anyway.
     */
    (void) parseTypeString(typ_name_or_oid, &result, &typmod, escontext);
 
    PG_RETURN_OID(result);
}

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 1247 of file regproc.c.

{
    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);
}

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 1295 of file regproc.c.

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

References oidrecv().

regtypesend()

Datum regtypesend

(

PG_FUNCTION_ARGS

)

Definition at line 1305 of file regproc.c.

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

References oidsend().

stringToQualifiedNameList()

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

Definition at line 1797 of file regproc.c.

{
    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))
        ereturn(escontext, NIL,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("invalid name syntax")));
 
    if (namelist == NIL)
        ereturn(escontext, NIL,
                (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;
}

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 1774 of file regproc.c.

{
    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);
}

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.

{
    char       *class_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    if (!DirectInputFunctionCallSafe(regclassin, class_name,
                                     InvalidOid, -1,
                                     (Node *) &escontext,
                                     &result))
        PG_RETURN_NULL();
    PG_RETURN_DATUM(result);
}

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.

{
    char       *collation_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    if (!DirectInputFunctionCallSafe(regcollationin, collation_name,
                                     InvalidOid, -1,
                                     (Node *) &escontext,
                                     &result))
        PG_RETURN_NULL();
    PG_RETURN_DATUM(result);
}

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 1700 of file regproc.c.

{
    char       *nsp_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    if (!DirectInputFunctionCallSafe(regnamespacein, nsp_name,
                                     InvalidOid, -1,
                                     (Node *) &escontext,
                                     &result))
        PG_RETURN_NULL();
    PG_RETURN_DATUM(result);
}

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.

{
    char       *opr_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    if (!DirectInputFunctionCallSafe(regoperin, opr_name,
                                     InvalidOid, -1,
                                     (Node *) &escontext,
                                     &result))
        PG_RETURN_NULL();
    PG_RETURN_DATUM(result);
}

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.

{
    char       *opr_name_or_oid = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    if (!DirectInputFunctionCallSafe(regoperatorin, opr_name_or_oid,
                                     InvalidOid, -1,
                                     (Node *) &escontext,
                                     &result))
        PG_RETURN_NULL();
    PG_RETURN_DATUM(result);
}

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.

{
    char       *pro_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    if (!DirectInputFunctionCallSafe(regprocin, pro_name,
                                     InvalidOid, -1,
                                     (Node *) &escontext,
                                     &result))
        PG_RETURN_NULL();
    PG_RETURN_DATUM(result);
}

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.

{
    char       *pro_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    if (!DirectInputFunctionCallSafe(regprocedurein, pro_name,
                                     InvalidOid, -1,
                                     (Node *) &escontext,
                                     &result))
        PG_RETURN_NULL();
    PG_RETURN_DATUM(result);
}

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 1583 of file regproc.c.

{
    char       *role_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    if (!DirectInputFunctionCallSafe(regrolein, role_name,
                                     InvalidOid, -1,
                                     (Node *) &escontext,
                                     &result))
        PG_RETURN_NULL();
    PG_RETURN_DATUM(result);
}

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.

{
    char       *typ_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Datum       result;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    if (!DirectInputFunctionCallSafe(regtypein, typ_name,
                                     InvalidOid, -1,
                                     (Node *) &escontext,
                                     &result))
        PG_RETURN_NULL();
    PG_RETURN_DATUM(result);
}

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

to_regtypemod()

Datum to_regtypemod

(

PG_FUNCTION_ARGS

)

Definition at line 1229 of file regproc.c.

{
    char       *typ_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    Oid         typid;
    int32       typmod;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    /* We rely on parseTypeString to parse the input. */
    if (!parseTypeString(typ_name, &typid, &typmod, (Node *) &escontext))
        PG_RETURN_NULL();
 
    PG_RETURN_INT32(typmod);
}

References parseTypeString(), PG_GETARG_TEXT_PP, PG_RETURN_INT32, PG_RETURN_NULL, and text_to_cstring().