* special I/O conversion routines.
*
*
- * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.79 2003/07/28 00:09:16 tgl Exp $
+ * src/backend/utils/adt/regproc.c
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.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"
-static void parseNameAndArgTypes(const char *string, const char *caller,
- bool allowNone,
+static void parseNameAndArgTypes(const char *string, bool allowNone,
List **names, int *nargs, Oid *argtypes);
strspn(pro_name_or_oid, "0123456789") == strlen(pro_name_or_oid))
{
result = DatumGetObjectId(DirectFunctionCall1(oidin,
- CStringGetDatum(pro_name_or_oid)));
+ 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).
+ * 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())
{
SysScanDesc sysscan;
HeapTuple tuple;
- ScanKeyEntryInitialize(&skey[0], 0x0,
- (AttrNumber) Anum_pg_proc_proname,
- (RegProcedure) F_NAMEEQ,
- CStringGetDatum(pro_name_or_oid));
+ ScanKeyInit(&skey[0],
+ Anum_pg_proc_proname,
+ BTEqualStrategyNumber, F_NAMEEQ,
+ CStringGetDatum(pro_name_or_oid));
- hdesc = heap_openr(ProcedureRelationName, AccessShareLock);
- sysscan = systable_beginscan(hdesc, ProcedureNameNspIndex, true,
+ hdesc = heap_open(ProcedureRelationId, AccessShareLock);
+ sysscan = systable_beginscan(hdesc, ProcedureNameArgsNspIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
if (matches == 0)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
- errmsg("no procedure with name %s", pro_name_or_oid)));
+ errmsg("function \"%s\" does not exist", pro_name_or_oid)));
else if (matches > 1)
ereport(ERROR,
(errcode(ERRCODE_AMBIGUOUS_FUNCTION),
- errmsg("more than one procedure named %s",
- pro_name_or_oid)));
+ 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.
+ * 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, "regprocin");
- clist = FuncnameGetCandidates(names, -1);
+ names = stringToQualifiedNameList(pro_name_or_oid);
+ clist = FuncnameGetCandidates(names, -1, NIL, false, false);
if (clist == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
- errmsg("no procedure with name %s", pro_name_or_oid)));
+ 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 procedure named %s",
- pro_name_or_oid)));
+ errmsg("more than one function named \"%s\"",
+ pro_name_or_oid)));
result = clist->oid;
PG_RETURN_CSTRING(result);
}
- proctup = SearchSysCache(PROCOID,
- ObjectIdGetDatum(proid),
- 0, 0, 0);
+ proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(proid));
if (HeapTupleIsValid(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.)
+ * 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);
* Would this proc be found (uniquely!) by regprocin? If not,
* qualify it.
*/
- clist = FuncnameGetCandidates(makeList1(makeString(proname)), -1);
+ clist = FuncnameGetCandidates(list_make1(makeString(proname)),
+ -1, NIL, false, false);
if (clist != NULL && clist->next == NULL &&
clist->oid == proid)
nspname = NULL;
strspn(pro_name_or_oid, "0123456789") == strlen(pro_name_or_oid))
{
result = DatumGetObjectId(DirectFunctionCall1(oidin,
- CStringGetDatum(pro_name_or_oid)));
+ 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.)
+ * 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, "regprocedurein", false,
- &names, &nargs, argtypes);
+ parseNameAndArgTypes(pro_name_or_oid, false, &names, &nargs, argtypes);
- clist = FuncnameGetCandidates(names, nargs);
+ clist = FuncnameGetCandidates(names, nargs, NIL, false, false);
for (; clist; clist = clist->next)
{
if (clist == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
- errmsg("no procedure with name %s", pro_name_or_oid)));
+ errmsg("function \"%s\" does not exist", pro_name_or_oid)));
result = clist->oid;
char *result;
HeapTuple proctup;
- proctup = SearchSysCache(PROCOID,
- ObjectIdGetDatum(procedure_oid),
- 0, 0, 0);
+ proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procedure_oid));
if (HeapTupleIsValid(proctup))
{
initStringInfo(&buf);
/*
- * Would this proc be found (given the right args) by
- * regprocedurein? If not, we need to qualify it.
+ * Would this proc be found (given the right args) by regprocedurein?
+ * If not, we need to qualify it.
*/
if (FunctionIsVisible(procedure_oid))
nspname = NULL;
quote_qualified_identifier(nspname, proname));
for (i = 0; i < nargs; i++)
{
- Oid thisargtype = procform->proargtypes[i];
+ Oid thisargtype = procform->proargtypes.values[i];
if (i > 0)
appendStringInfoChar(&buf, ',');
- appendStringInfo(&buf, "%s", format_type_be(thisargtype));
+ appendStringInfoString(&buf, format_type_be(thisargtype));
}
appendStringInfoChar(&buf, ')');
strspn(opr_name_or_oid, "0123456789") == strlen(opr_name_or_oid))
{
result = DatumGetObjectId(DirectFunctionCall1(oidin,
- CStringGetDatum(opr_name_or_oid)));
+ 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).
+ * 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())
{
SysScanDesc sysscan;
HeapTuple tuple;
- ScanKeyEntryInitialize(&skey[0], 0x0,
- (AttrNumber) Anum_pg_operator_oprname,
- (RegProcedure) F_NAMEEQ,
- CStringGetDatum(opr_name_or_oid));
+ ScanKeyInit(&skey[0],
+ Anum_pg_operator_oprname,
+ BTEqualStrategyNumber, F_NAMEEQ,
+ CStringGetDatum(opr_name_or_oid));
- hdesc = heap_openr(OperatorRelationName, AccessShareLock);
- sysscan = systable_beginscan(hdesc, OperatorNameNspIndex, true,
+ hdesc = heap_open(OperatorRelationId, AccessShareLock);
+ sysscan = systable_beginscan(hdesc, OperatorNameNspIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
if (matches == 0)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
- errmsg("no operator with name %s", opr_name_or_oid)));
+ 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)));
+ 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.
+ * 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, "regoperin");
+ names = stringToQualifiedNameList(opr_name_or_oid);
clist = OpernameGetCandidates(names, '\0');
if (clist == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
- errmsg("no operator with name %s", opr_name_or_oid)));
+ 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)));
+ opr_name_or_oid)));
result = clist->oid;
PG_RETURN_CSTRING(result);
}
- opertup = SearchSysCache(OPEROID,
- ObjectIdGetDatum(oprid),
- 0, 0, 0);
+ opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(oprid));
if (HeapTupleIsValid(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.)
+ * 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);
* Would this oper be found (uniquely!) by regoperin? If not,
* qualify it.
*/
- clist = OpernameGetCandidates(makeList1(makeString(oprname)),
+ clist = OpernameGetCandidates(list_make1(makeString(oprname)),
'\0');
if (clist != NULL && clist->next == NULL &&
clist->oid == oprid)
else
{
/*
- * If OID doesn't match any pg_operator entry, return it
- * numerically
+ * If OID doesn't match any pg_operator entry, return it numerically
*/
result = (char *) palloc(NAMEDATALEN);
snprintf(result, NAMEDATALEN, "%u", oprid);
regoperatorin(PG_FUNCTION_ARGS)
{
char *opr_name_or_oid = PG_GETARG_CSTRING(0);
- Oid result = InvalidOid;
+ Oid result;
List *names;
int nargs;
Oid argtypes[FUNC_MAX_ARGS];
- char oprkind;
- FuncCandidateList clist;
/* '0' ? */
if (strcmp(opr_name_or_oid, "0") == 0)
strspn(opr_name_or_oid, "0123456789") == strlen(opr_name_or_oid))
{
result = DatumGetObjectId(DirectFunctionCall1(oidin,
- CStringGetDatum(opr_name_or_oid)));
+ 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.)
+ * 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, "regoperatorin", true,
- &names, &nargs, argtypes);
+ parseNameAndArgTypes(opr_name_or_oid, true, &names, &nargs, argtypes);
if (nargs == 1)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_PARAMETER),
errmsg("too many arguments"),
errhint("Provide two argument types for operator.")));
- if (argtypes[0] == InvalidOid)
- oprkind = 'l';
- else if (argtypes[1] == InvalidOid)
- oprkind = 'r';
- else
- oprkind = 'b';
-
- clist = OpernameGetCandidates(names, oprkind);
+ result = OpernameGetOprid(names, argtypes[0], argtypes[1]);
- for (; clist; clist = clist->next)
- {
- if (memcmp(clist->args, argtypes, 2 * sizeof(Oid)) == 0)
- break;
- }
-
- if (clist == NULL)
+ if (!OidIsValid(result))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
- errmsg("no operator with name %s", opr_name_or_oid)));
-
- result = clist->oid;
+ errmsg("operator does not exist: %s", opr_name_or_oid)));
PG_RETURN_OID(result);
}
char *result;
HeapTuple opertup;
- opertup = SearchSysCache(OPEROID,
- ObjectIdGetDatum(operator_oid),
- 0, 0, 0);
+ opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operator_oid));
if (HeapTupleIsValid(opertup))
{
initStringInfo(&buf);
/*
- * Would this oper be found (given the right args) by
- * regoperatorin? If not, we need to qualify it.
+ * Would this oper be found (given the right args) by regoperatorin?
+ * If not, we need to qualify it.
*/
if (!OperatorIsVisible(operator_oid))
{
else
{
/*
- * If OID doesn't match any pg_operator entry, return it
- * numerically
+ * If OID doesn't match any pg_operator entry, return it numerically
*/
result = (char *) palloc(NAMEDATALEN);
snprintf(result, NAMEDATALEN, "%u", operator_oid);
/* 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))
+ strspn(class_name_or_oid, "0123456789") == strlen(class_name_or_oid))
{
result = DatumGetObjectId(DirectFunctionCall1(oidin,
- CStringGetDatum(class_name_or_oid)));
+ 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).
+ * 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())
{
SysScanDesc sysscan;
HeapTuple tuple;
- ScanKeyEntryInitialize(&skey[0], 0x0,
- (AttrNumber) Anum_pg_class_relname,
- (RegProcedure) F_NAMEEQ,
- CStringGetDatum(class_name_or_oid));
+ ScanKeyInit(&skey[0],
+ Anum_pg_class_relname,
+ BTEqualStrategyNumber, F_NAMEEQ,
+ CStringGetDatum(class_name_or_oid));
- hdesc = heap_openr(RelationRelationName, AccessShareLock);
- sysscan = systable_beginscan(hdesc, ClassNameNspIndex, true,
+ hdesc = heap_open(RelationRelationId, AccessShareLock);
+ sysscan = systable_beginscan(hdesc, ClassNameNspIndexId, true,
SnapshotNow, 1, skey);
if (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
else
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_TABLE),
- errmsg("no class with name %s", class_name_or_oid)));
+ errmsg("relation \"%s\" does not exist", class_name_or_oid)));
/* We assume there can be only one match */
}
/*
- * Normal case: parse the name into components and see if it matches
- * any pg_class entries in the current search path.
+ * 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, "regclassin");
+ names = stringToQualifiedNameList(class_name_or_oid);
result = RangeVarGetRelid(makeRangeVarFromNameList(names), false);
PG_RETURN_CSTRING(result);
}
- classtup = SearchSysCache(RELOID,
- ObjectIdGetDatum(classid),
- 0, 0, 0);
+ classtup = SearchSysCache1(RELOID, ObjectIdGetDatum(classid));
if (HeapTupleIsValid(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.)
+ * 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);
char *nspname;
/*
- * Would this class be found by regclassin? If not, qualify
- * it.
+ * Would this class be found by regclassin? If not, qualify it.
*/
if (RelationIsVisible(classid))
nspname = NULL;
strspn(typ_name_or_oid, "0123456789") == strlen(typ_name_or_oid))
{
result = DatumGetObjectId(DirectFunctionCall1(oidin,
- CStringGetDatum(typ_name_or_oid)));
+ 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).
+ * 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())
{
SysScanDesc sysscan;
HeapTuple tuple;
- ScanKeyEntryInitialize(&skey[0], 0x0,
- (AttrNumber) Anum_pg_type_typname,
- (RegProcedure) F_NAMEEQ,
- CStringGetDatum(typ_name_or_oid));
+ ScanKeyInit(&skey[0],
+ Anum_pg_type_typname,
+ BTEqualStrategyNumber, F_NAMEEQ,
+ CStringGetDatum(typ_name_or_oid));
- hdesc = heap_openr(TypeRelationName, AccessShareLock);
- sysscan = systable_beginscan(hdesc, TypeNameNspIndex, true,
+ hdesc = heap_open(TypeRelationId, AccessShareLock);
+ sysscan = systable_beginscan(hdesc, TypeNameNspIndexId, true,
SnapshotNow, 1, skey);
if (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
else
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("no type with name %s", typ_name_or_oid)));
+ errmsg("type \"%s\" does not exist", typ_name_or_oid)));
/* We assume there can be only one match */
}
/*
- * Normal case: invoke the full parser to deal with special cases such
- * as array syntax.
+ * Normal case: invoke the full parser to deal with special cases such as
+ * array syntax.
*/
parseTypeString(typ_name_or_oid, &result, &typmod);
PG_RETURN_CSTRING(result);
}
- typetup = SearchSysCache(TYPEOID,
- ObjectIdGetDatum(typid),
- 0, 0, 0);
+ 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.)
+ * 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())
{
}
+/*
+ * regconfigin - converts "tsconfigname" to tsconfig OID
+ *
+ * We also accept a numeric OID, for symmetry with the output routine.
+ *
+ * '-' signifies unknown (OID 0). In all other cases, the input must
+ * match an existing pg_ts_config entry.
+ *
+ * This function is not needed in bootstrap mode, so we don't worry about
+ * making it work then.
+ */
+Datum
+regconfigin(PG_FUNCTION_ARGS)
+{
+ 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);
+}
+
+/*
+ * regconfigout - converts tsconfig OID to "tsconfigname"
+ */
+Datum
+regconfigout(PG_FUNCTION_ARGS)
+{
+ Oid cfgid = PG_GETARG_OID(0);
+ char *result;
+ HeapTuple cfgtup;
+
+ if (cfgid == InvalidOid)
+ {
+ result = pstrdup("-");
+ PG_RETURN_CSTRING(result);
+ }
+
+ cfgtup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgid));
+
+ if (HeapTupleIsValid(cfgtup))
+ {
+ Form_pg_ts_config cfgform = (Form_pg_ts_config) GETSTRUCT(cfgtup);
+ char *cfgname = NameStr(cfgform->cfgname);
+ char *nspname;
+
+ /*
+ * Would this config be found by regconfigin? If not, qualify it.
+ */
+ if (TSConfigIsVisible(cfgid))
+ nspname = NULL;
+ else
+ nspname = get_namespace_name(cfgform->cfgnamespace);
+
+ result = quote_qualified_identifier(nspname, cfgname);
+
+ ReleaseSysCache(cfgtup);
+ }
+ else
+ {
+ /* If OID doesn't match any pg_ts_config row, return it numerically */
+ result = (char *) palloc(NAMEDATALEN);
+ snprintf(result, NAMEDATALEN, "%u", cfgid);
+ }
+
+ PG_RETURN_CSTRING(result);
+}
+
+/*
+ * regconfigrecv - converts external binary format to regconfig
+ */
+Datum
+regconfigrecv(PG_FUNCTION_ARGS)
+{
+ /* Exactly the same as oidrecv, so share code */
+ return oidrecv(fcinfo);
+}
+
+/*
+ * regconfigsend - converts regconfig to binary format
+ */
+Datum
+regconfigsend(PG_FUNCTION_ARGS)
+{
+ /* Exactly the same as oidsend, so share code */
+ return oidsend(fcinfo);
+}
+
+
+/*
+ * regdictionaryin - converts "tsdictionaryname" to tsdictionary OID
+ *
+ * We also accept a numeric OID, for symmetry with the output routine.
+ *
+ * '-' signifies unknown (OID 0). In all other cases, the input must
+ * match an existing pg_ts_dict entry.
+ *
+ * This function is not needed in bootstrap mode, so we don't worry about
+ * making it work then.
+ */
+Datum
+regdictionaryin(PG_FUNCTION_ARGS)
+{
+ 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);
+}
+
+/*
+ * regdictionaryout - converts tsdictionary OID to "tsdictionaryname"
+ */
+Datum
+regdictionaryout(PG_FUNCTION_ARGS)
+{
+ Oid dictid = PG_GETARG_OID(0);
+ char *result;
+ HeapTuple dicttup;
+
+ if (dictid == InvalidOid)
+ {
+ result = pstrdup("-");
+ PG_RETURN_CSTRING(result);
+ }
+
+ dicttup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictid));
+
+ if (HeapTupleIsValid(dicttup))
+ {
+ Form_pg_ts_dict dictform = (Form_pg_ts_dict) GETSTRUCT(dicttup);
+ char *dictname = NameStr(dictform->dictname);
+ char *nspname;
+
+ /*
+ * Would this dictionary be found by regdictionaryin? If not, qualify
+ * it.
+ */
+ if (TSDictionaryIsVisible(dictid))
+ nspname = NULL;
+ else
+ nspname = get_namespace_name(dictform->dictnamespace);
+
+ result = quote_qualified_identifier(nspname, dictname);
+
+ ReleaseSysCache(dicttup);
+ }
+ else
+ {
+ /* If OID doesn't match any pg_ts_dict row, return it numerically */
+ result = (char *) palloc(NAMEDATALEN);
+ snprintf(result, NAMEDATALEN, "%u", dictid);
+ }
+
+ PG_RETURN_CSTRING(result);
+}
+
+/*
+ * regdictionaryrecv - converts external binary format to regdictionary
+ */
+Datum
+regdictionaryrecv(PG_FUNCTION_ARGS)
+{
+ /* Exactly the same as oidrecv, so share code */
+ return oidrecv(fcinfo);
+}
+
+/*
+ * regdictionarysend - converts regdictionary to binary format
+ */
+Datum
+regdictionarysend(PG_FUNCTION_ARGS)
+{
+ /* Exactly the same as oidsend, so share code */
+ return oidsend(fcinfo);
+}
+
+
+/*
+ * text_regclass: convert text to regclass
+ *
+ * This could be replaced by CoerceViaIO, except that we need to treat
+ * text-to-regclass as an implicit cast to support legacy forms of nextval()
+ * and related functions.
+ */
+Datum
+text_regclass(PG_FUNCTION_ARGS)
+{
+ text *relname = PG_GETARG_TEXT_P(0);
+ Oid result;
+ RangeVar *rv;
+
+ rv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
+ result = RangeVarGetRelid(rv, false);
+
+ PG_RETURN_OID(result);
+}
+
+
/*
* Given a C string, parse it into a qualified-name list.
*/
List *
-stringToQualifiedNameList(const char *string, const char *caller)
+stringToQualifiedNameList(const char *string)
{
char *rawname;
List *result = NIL;
List *namelist;
- List *l;
+ ListCell *l;
/* We need a modifiable copy of the input string. */
rawname = pstrdup(string);
}
pfree(rawname);
- freeList(namelist);
+ list_free(namelist);
return result;
}
* for unary operators).
*/
static void
-parseNameAndArgTypes(const char *string, const char *caller,
- bool allowNone,
- List **names, int *nargs, Oid *argtypes)
+parseNameAndArgTypes(const char *string, bool allowNone, List **names,
+ int *nargs, Oid *argtypes)
{
char *rawname;
char *ptr;
/* Separate the name and parse it into a list */
*ptr++ = '\0';
- *names = stringToQualifiedNameList(rawname, caller);
+ *names = stringToQualifiedNameList(rawname);
/* Check for the trailing right parenthesis and remove it */
ptr2 = ptr + strlen(ptr);
*ptr2 = '\0';
}
- if (allowNone && strcasecmp(typename, "none") == 0)
+ if (allowNone && pg_strcasecmp(typename, "none") == 0)
{
/* Special case for NONE */
typeid = InvalidOid;
projects / postgresql / blobdiff