Header And Logo
|
#include "postgres.h"#include <ctype.h>#include "access/genam.h"#include "access/heapam.h"#include "access/htup_details.h"#include "catalog/indexing.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 "utils/builtins.h"#include "utils/fmgroids.h"#include "utils/lsyscache.h"#include "utils/syscache.h"#include "utils/tqual.h"
Go to the source code of this file.
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 | regprocout (PG_FUNCTION_ARGS) |
| Datum | regprocrecv (PG_FUNCTION_ARGS) |
| Datum | regprocsend (PG_FUNCTION_ARGS) |
| Datum | regprocedurein (PG_FUNCTION_ARGS) |
| char * | format_procedure (Oid procedure_oid) |
| char * | format_procedure_qualified (Oid procedure_oid) |
| Datum | regprocedureout (PG_FUNCTION_ARGS) |
| Datum | regprocedurerecv (PG_FUNCTION_ARGS) |
| Datum | regproceduresend (PG_FUNCTION_ARGS) |
| Datum | regoperin (PG_FUNCTION_ARGS) |
| Datum | regoperout (PG_FUNCTION_ARGS) |
| Datum | regoperrecv (PG_FUNCTION_ARGS) |
| Datum | regopersend (PG_FUNCTION_ARGS) |
| Datum | regoperatorin (PG_FUNCTION_ARGS) |
| char * | format_operator (Oid operator_oid) |
| char * | format_operator_qualified (Oid operator_oid) |
| Datum | regoperatorout (PG_FUNCTION_ARGS) |
| Datum | regoperatorrecv (PG_FUNCTION_ARGS) |
| Datum | regoperatorsend (PG_FUNCTION_ARGS) |
| Datum | regclassin (PG_FUNCTION_ARGS) |
| Datum | regclassout (PG_FUNCTION_ARGS) |
| Datum | regclassrecv (PG_FUNCTION_ARGS) |
| Datum | regclasssend (PG_FUNCTION_ARGS) |
| Datum | regtypein (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 | text_regclass (PG_FUNCTION_ARGS) |
| List * | stringToQualifiedNameList (const char *string) |
| char* format_operator | ( | Oid | operator_oid | ) |
Definition at line 745 of file regproc.c.
References format_operator_internal().
Referenced by ComputeIndexAttrs(), getObjectDescription(), and regoperatorout().
{
return format_operator_internal(operator_oid, false);
}
Definition at line 681 of file regproc.c.
References appendStringInfo(), buf, StringInfoData::data, format_type_be(), format_type_be_qualified(), get_namespace_name(), GETSTRUCT, HeapTupleIsValid, initStringInfo(), 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 */
initStringInfo(&buf);
/*
* Would this oper be found (given the right args) by regoperatorin?
* If not, or if caller explicitely 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
appendStringInfo(&buf, "NONE,");
if (operform->oprright)
appendStringInfo(&buf, "%s)",
force_qualify ?
format_type_be_qualified(operform->oprright) :
format_type_be(operform->oprright));
else
appendStringInfo(&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;
}
| char* format_operator_qualified | ( | Oid | operator_oid | ) |
Definition at line 751 of file regproc.c.
References format_operator_internal().
Referenced by getObjectIdentity().
{
return format_operator_internal(operator_oid, true);
}
| char* format_procedure | ( | Oid | procedure_oid | ) |
Definition at line 307 of file regproc.c.
References format_procedure_internal().
Referenced by do_compile(), getObjectDescription(), ProcedureCreate(), and regprocedureout().
{
return format_procedure_internal(procedure_oid, false);
}
Definition at line 326 of file regproc.c.
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, StringInfoData::data, format_type_be(), format_type_be_qualified(), FunctionIsVisible(), get_namespace_name(), GETSTRUCT, HeapTupleIsValid, i, initStringInfo(), NAMEDATALEN, NameStr, ObjectIdGetDatum, palloc(), PROCOID, 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 */
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;
}
| char* format_procedure_qualified | ( | Oid | procedure_oid | ) |
Definition at line 313 of file regproc.c.
References format_procedure_internal().
Referenced by getObjectIdentity().
{
return format_procedure_internal(procedure_oid, true);
}
| static void parseNameAndArgTypes | ( | const char * | string, | |
| bool | allowNone, | |||
| List ** | names, | |||
| int * | nargs, | |||
| Oid * | argtypes | |||
| ) | [static] |
Definition at line 1400 of file regproc.c.
References Assert, ereport, errcode(), errmsg(), ERROR, FUNC_MAX_ARGS, parseTypeString(), pfree(), pg_strcasecmp(), pstrdup(), and stringToQualifiedNameList().
Referenced by regoperatorin(), and regprocedurein().
{
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 (!isspace((unsigned char) *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 (isspace((unsigned char) *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 (!isspace((unsigned char) *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);
}
if (*nargs >= FUNC_MAX_ARGS)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
errmsg("too many arguments")));
argtypes[*nargs] = typeid;
(*nargs)++;
}
pfree(rawname);
}
| Datum regclassin | ( | PG_FUNCTION_ARGS | ) |
Definition at line 803 of file regproc.c.
References AccessShareLock, Anum_pg_class_relname, BTEqualStrategyNumber, ClassNameNspIndexId, CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, heap_close, heap_open(), HeapTupleGetOid, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, makeRangeVarFromNameList(), NoLock, oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, RangeVarGetRelid, RelationRelationId, ScanKeyInit(), SnapshotNow, stringToQualifiedNameList(), systable_beginscan(), systable_endscan(), and systable_getnext().
{
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 */
/*
* In bootstrap mode we assume the given name is not schema-qualified, and
* just search pg_class for a match. This is needed for initializing
* other system catalogs (pg_namespace may not exist yet, and certainly
* there are no schemas other than pg_catalog).
*/
if (IsBootstrapProcessingMode())
{
Relation hdesc;
ScanKeyData skey[1];
SysScanDesc sysscan;
HeapTuple tuple;
ScanKeyInit(&skey[0],
Anum_pg_class_relname,
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(class_name_or_oid));
hdesc = heap_open(RelationRelationId, AccessShareLock);
sysscan = systable_beginscan(hdesc, ClassNameNspIndexId, true,
SnapshotNow, 1, skey);
if (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
result = HeapTupleGetOid(tuple);
else
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_TABLE),
errmsg("relation \"%s\" does not exist", class_name_or_oid)));
/* We assume there can be only one match */
systable_endscan(sysscan);
heap_close(hdesc, AccessShareLock);
PG_RETURN_OID(result);
}
/*
* 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);
}
| Datum regclassout | ( | PG_FUNCTION_ARGS | ) |
Definition at line 878 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);
}
| Datum regclassrecv | ( | PG_FUNCTION_ARGS | ) |
| Datum regclasssend | ( | PG_FUNCTION_ARGS | ) |
| Datum regconfigin | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1116 of file regproc.c.
References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, get_ts_config_oid(), InvalidOid, oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, and stringToQualifiedNameList().
Referenced by tsa_headline_byname(), tsa_plainto_tsquery_name(), tsa_to_tsquery_name(), and tsa_to_tsvector_name().
{
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);
}
/*
* 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);
}
| Datum regconfigout | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1151 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.
Referenced by tsa_set_curcfg().
{
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);
}
| Datum regconfigrecv | ( | PG_FUNCTION_ARGS | ) |
| Datum regconfigsend | ( | PG_FUNCTION_ARGS | ) |
| Datum regdictionaryin | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1226 of file regproc.c.
References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, get_ts_dict_oid(), InvalidOid, oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, and stringToQualifiedNameList().
Referenced by tsa_lexize_byname().
{
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);
}
/*
* 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);
}
| Datum regdictionaryout | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1261 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);
}
| Datum regdictionaryrecv | ( | PG_FUNCTION_ARGS | ) |
| Datum regdictionarysend | ( | PG_FUNCTION_ARGS | ) |
| Datum regoperatorin | ( | PG_FUNCTION_ARGS | ) |
Definition at line 620 of file regproc.c.
References CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, ereport, errcode(), errhint(), errmsg(), ERROR, InvalidOid, 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);
}
/*
* 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.)
*
* XXX at present, this code will not work in bootstrap mode, hence this
* datatype cannot be used for any system column that needs to receive
* data during bootstrap.
*/
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);
}
| Datum regoperatorout | ( | PG_FUNCTION_ARGS | ) |
Definition at line 760 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);
}
| Datum regoperatorrecv | ( | PG_FUNCTION_ARGS | ) |
| Datum regoperatorsend | ( | PG_FUNCTION_ARGS | ) |
| Datum regoperin | ( | PG_FUNCTION_ARGS | ) |
Definition at line 431 of file regproc.c.
References AccessShareLock, Anum_pg_operator_oprname, BTEqualStrategyNumber, CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, heap_close, heap_open(), HeapTupleGetOid, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, _FuncCandidateList::next, NULL, _FuncCandidateList::oid, oidin(), OperatorNameNspIndexId, OperatorRelationId, OpernameGetCandidates(), PG_GETARG_CSTRING, PG_RETURN_OID, ScanKeyInit(), SnapshotNow, stringToQualifiedNameList(), systable_beginscan(), systable_endscan(), and systable_getnext().
{
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 */
/*
* In bootstrap mode we assume the given name is not schema-qualified, and
* just search pg_operator for a unique match. This is needed for
* initializing other system catalogs (pg_namespace may not exist yet, and
* certainly there are no schemas other than pg_catalog).
*/
if (IsBootstrapProcessingMode())
{
int matches = 0;
Relation hdesc;
ScanKeyData skey[1];
SysScanDesc sysscan;
HeapTuple tuple;
ScanKeyInit(&skey[0],
Anum_pg_operator_oprname,
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(opr_name_or_oid));
hdesc = heap_open(OperatorRelationId, AccessShareLock);
sysscan = systable_beginscan(hdesc, OperatorNameNspIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
{
result = HeapTupleGetOid(tuple);
if (++matches > 1)
break;
}
systable_endscan(sysscan);
heap_close(hdesc, AccessShareLock);
if (matches == 0)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
errmsg("operator does not exist: %s", opr_name_or_oid)));
else if (matches > 1)
ereport(ERROR,
(errcode(ERRCODE_AMBIGUOUS_FUNCTION),
errmsg("more than one operator named %s",
opr_name_or_oid)));
PG_RETURN_OID(result);
}
/*
* 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');
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);
}
| Datum regoperout | ( | PG_FUNCTION_ARGS | ) |
Definition at line 526 of file regproc.c.
References get_namespace_name(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, list_make1, makeString(), NAMEDATALEN, NameStr, _FuncCandidateList::next, NULL, ObjectIdGetDatum, _FuncCandidateList::oid, OpernameGetCandidates(), OPEROID, oprid(), palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), quote_identifier(), ReleaseSysCache(), SearchSysCache1, and snprintf().
{
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');
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);
}
| Datum regoperrecv | ( | PG_FUNCTION_ARGS | ) |
| Datum regopersend | ( | PG_FUNCTION_ARGS | ) |
| Datum regprocedurein | ( | PG_FUNCTION_ARGS | ) |
Definition at line 247 of file regproc.c.
References _FuncCandidateList::args, CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, FuncnameGetCandidates(), InvalidOid, memcmp(), _FuncCandidateList::next, NIL, NULL, _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);
}
/*
* 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.)
*
* XXX at present, this code will not work in bootstrap mode, hence this
* datatype cannot be used for any system column that needs to receive
* data during bootstrap.
*/
parseNameAndArgTypes(pro_name_or_oid, false, &names, &nargs, argtypes);
clist = FuncnameGetCandidates(names, nargs, NIL, 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);
}
| Datum regprocedureout | ( | PG_FUNCTION_ARGS | ) |
Definition at line 388 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);
}
| Datum regprocedurerecv | ( | PG_FUNCTION_ARGS | ) |
| Datum regproceduresend | ( | PG_FUNCTION_ARGS | ) |
| Datum regprocin | ( | PG_FUNCTION_ARGS | ) |
Definition at line 63 of file regproc.c.
References AccessShareLock, Anum_pg_proc_proname, BTEqualStrategyNumber, CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, FuncnameGetCandidates(), heap_close, heap_open(), HeapTupleGetOid, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, _FuncCandidateList::next, NIL, NULL, _FuncCandidateList::oid, oidin(), PG_GETARG_CSTRING, PG_RETURN_OID, ProcedureNameArgsNspIndexId, ProcedureRelationId, ScanKeyInit(), SnapshotNow, stringToQualifiedNameList(), systable_beginscan(), systable_endscan(), and systable_getnext().
{
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 */
/*
* In bootstrap mode we assume the given name is not schema-qualified, and
* just search pg_proc for a unique match. This is needed for
* initializing other system catalogs (pg_namespace may not exist yet, and
* certainly there are no schemas other than pg_catalog).
*/
if (IsBootstrapProcessingMode())
{
int matches = 0;
Relation hdesc;
ScanKeyData skey[1];
SysScanDesc sysscan;
HeapTuple tuple;
ScanKeyInit(&skey[0],
Anum_pg_proc_proname,
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(pro_name_or_oid));
hdesc = heap_open(ProcedureRelationId, AccessShareLock);
sysscan = systable_beginscan(hdesc, ProcedureNameArgsNspIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
{
result = (RegProcedure) HeapTupleGetOid(tuple);
if (++matches > 1)
break;
}
systable_endscan(sysscan);
heap_close(hdesc, AccessShareLock);
if (matches == 0)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
errmsg("function \"%s\" does not exist", pro_name_or_oid)));
else if (matches > 1)
ereport(ERROR,
(errcode(ERRCODE_AMBIGUOUS_FUNCTION),
errmsg("more than one function named \"%s\"",
pro_name_or_oid)));
PG_RETURN_OID(result);
}
/*
* 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);
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);
}
| Datum regprocout | ( | PG_FUNCTION_ARGS | ) |
Definition at line 159 of file regproc.c.
References FuncnameGetCandidates(), get_namespace_name(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, list_make1, makeString(), NAMEDATALEN, NameStr, _FuncCandidateList::next, NIL, NULL, ObjectIdGetDatum, _FuncCandidateList::oid, palloc(), PG_GETARG_OID, PG_RETURN_CSTRING, PROCOID, 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);
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);
}
| Datum regprocrecv | ( | PG_FUNCTION_ARGS | ) |
| Datum regprocsend | ( | PG_FUNCTION_ARGS | ) |
| Datum regtypein | ( | PG_FUNCTION_ARGS | ) |
Definition at line 967 of file regproc.c.
References AccessShareLock, Anum_pg_type_typname, BTEqualStrategyNumber, CStringGetDatum, DatumGetObjectId, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, heap_close, heap_open(), HeapTupleGetOid, HeapTupleIsValid, InvalidOid, IsBootstrapProcessingMode, oidin(), parseTypeString(), PG_GETARG_CSTRING, PG_RETURN_OID, ScanKeyInit(), SnapshotNow, systable_beginscan(), systable_endscan(), systable_getnext(), TypeNameNspIndexId, and TypeRelationId.
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 */
/*
* In bootstrap mode we assume the given name is not schema-qualified, and
* just search pg_type for a match. This is needed for initializing other
* system catalogs (pg_namespace may not exist yet, and certainly there
* are no schemas other than pg_catalog).
*/
if (IsBootstrapProcessingMode())
{
Relation hdesc;
ScanKeyData skey[1];
SysScanDesc sysscan;
HeapTuple tuple;
ScanKeyInit(&skey[0],
Anum_pg_type_typname,
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(typ_name_or_oid));
hdesc = heap_open(TypeRelationId, AccessShareLock);
sysscan = systable_beginscan(hdesc, TypeNameNspIndexId, true,
SnapshotNow, 1, skey);
if (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
result = HeapTupleGetOid(tuple);
else
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("type \"%s\" does not exist", typ_name_or_oid)));
/* We assume there can be only one match */
systable_endscan(sysscan);
heap_close(hdesc, AccessShareLock);
PG_RETURN_OID(result);
}
/*
* Normal case: invoke the full parser to deal with special cases such as
* array syntax.
*/
parseTypeString(typ_name_or_oid, &result, &typmod);
PG_RETURN_OID(result);
}
| Datum regtypeout | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1039 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(), and TYPEOID.
{
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);
}
| Datum regtyperecv | ( | PG_FUNCTION_ARGS | ) |
| Datum regtypesend | ( | PG_FUNCTION_ARGS | ) |
| List* stringToQualifiedNameList | ( | const char * | string | ) |
Definition at line 1352 of file regproc.c.
References ereport, errcode(), errmsg(), ERROR, lappend(), lfirst, list_free(), makeString(), NIL, pfree(), pstrdup(), and SplitIdentifierString().
Referenced by check_TSCurrentConfig(), GetCurrentParser(), getTSCurrentConfig(), parseNameAndArgTypes(), regclassin(), regconfigin(), regdictionaryin(), regoperin(), regprocin(), RelationNameGetTupleDesc(), thesaurus_init(), tsa_set_curdict_byname(), tsa_set_curprs_byname(), tsvector_update_trigger(), and unaccent_dict().
{
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;
}
| Datum text_regclass | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1333 of file regproc.c.
References makeRangeVarFromNameList(), NoLock, PG_GETARG_TEXT_P, PG_RETURN_OID, RangeVarGetRelid, and textToQualifiedNameList().
{
text *relname = PG_GETARG_TEXT_P(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);
}
1.7.1