*
* regproc.c
* Functions for the built-in types regproc, regclass, regtype, etc.
*
* These types are all binary-compatible with type Oid, and rely on Oid
* for comparison and so forth. Their only interesting behavior is in
* special I/O conversion routines.
*
*
* Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* src/backend/utils/adt/regproc.c
*
* -------------------------------------------------------------------------
*/
#include "postgres.h"
#include "knl/knl_variable.h"
#include <ctype.h>
#include "access/genam.h"
#include "access/heapam.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 "miscadmin.h"
#include "parser/parse_type.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/fmgrtab.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#include "utils/snapmgr.h"
#include "catalog/pg_proc_fn.h"
#include "catalog/pg_type_fn.h"
static void parseNameAndArgTypes(const char* string, bool allowNone, List** names, int* nargs, Oid* argtypes);
static char *format_operator_internal(Oid operator_oid, bool force_qualify);
static char *format_procedure_internal(Oid procedure_oid, bool force_qualify);
static Datum regprocin_booststrap(char* procname)
{
RegProcedure result = InvalidOid;
int matches = 0;
Relation hdesc;
ScanKeyData skey[1];
SysScanDesc sysscan;
HeapTuple tuple;
const FuncGroup* gfuncs = NULL;
ScanKeyInit(&skey[0], Anum_pg_proc_proname, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(procname));
hdesc = heap_open(ProcedureRelationId, AccessShareLock);
#ifndef ENABLE_MULTIPLE_NODES
sysscan = systable_beginscan(hdesc, ProcedureNameArgsNspNewIndexId, true, NULL, 1, skey);
#else
sysscan = systable_beginscan(hdesc, ProcedureNameArgsNspIndexId, true, NULL, 1, skey);
#endif
while (HeapTupleIsValid(tuple = systable_getnext(sysscan))) {
result = (RegProcedure)HeapTupleGetOid(tuple);
if (++matches > 1)
break;
}
systable_endscan(sysscan);
heap_close(hdesc, AccessShareLock);
if (BootUsingBuiltinFunc && matches < 1) {
gfuncs = SearchBuiltinFuncByName(procname);
if (gfuncs != NULL) {
matches += gfuncs->fnums;
result = gfuncs->funcs[0].foid;
}
}
if (matches == 0) {
ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("function \"%s\" does not exist", procname)));
} else if (matches > 1) {
ereport(ERROR,
(errcode(ERRCODE_AMBIGUOUS_FUNCTION),
errmsg("more than one function named \"%s\", %d functions are found", procname, matches)));
}
PG_RETURN_OID(result);
}
* USER I/O ROUTINES *
*****************************************************************************/
* regprocin - converts "proname" to proc 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_proc entry.
*/
Datum regprocin(PG_FUNCTION_ARGS)
{
char* pro_name_or_oid = PG_GETARG_CSTRING(0);
RegProcedure result = InvalidOid;
List* names = NIL;
FuncCandidateList clist;
if (strcmp(pro_name_or_oid, "-") == 0)
PG_RETURN_OID(InvalidOid);
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);
}
* 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()) {
return regprocin_booststrap(pro_name_or_oid);
}
if (u_sess->attr.attr_sql.enable_ignore_case_in_dquotes) {
int length = strlen(pro_name_or_oid);
if(length > 0 && pro_name_or_oid[0] == '\"' && pro_name_or_oid[length-1] == '\"')
pro_name_or_oid = pg_strtolower(pro_name_or_oid);
}
* Normal case: parse the name into components and see if it matches any
* pg_proc entries in the current search path.
*/
names = stringToQualifiedNameList(pro_name_or_oid);
clist = FuncnameGetCandidates(names, -1, NIL, false, false, false);
if (clist == NULL) {
ereport(
ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("function \"%s\" does not exist", pro_name_or_oid)));
} else if (clist->next != NULL) {
ereport(ERROR,
(errcode(ERRCODE_AMBIGUOUS_FUNCTION), errmsg("more than one function named \"%s\"", pro_name_or_oid)));
}
result = clist->oid;
list_free_ext(names);
PG_RETURN_OID(result);
}
* regprocout - converts proc OID to "pro_name"
*/
Datum regprocout(PG_FUNCTION_ARGS)
{
RegProcedure proid = PG_GETARG_OID(0);
char* result = NULL;
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 = NULL;
FuncCandidateList clist;
* Would this proc be found (uniquely!) by regprocin? If not,
* qualify it.
*/
clist = FuncnameGetCandidates(list_make1(makeString(proname)), -1, NIL, false, false, false);
if (clist != NULL && clist->next == NULL && clist->oid == proid)
nspname = NULL;
else
nspname = get_namespace_name(procform->pronamespace);
result = quote_qualified_identifier(nspname, proname);
}
ReleaseSysCache(proctup);
} else {
result = (char*)palloc(NAMEDATALEN);
errno_t rc = snprintf_s(result, NAMEDATALEN, NAMEDATALEN - 1, "%u", proid);
securec_check_ss(rc, "\0", "\0");
}
PG_RETURN_CSTRING(result);
}
* regprocrecv - converts external binary format to regproc
*/
Datum regprocrecv(PG_FUNCTION_ARGS)
{
return oidrecv(fcinfo);
}
* regprocsend - converts regproc to binary format
*/
Datum regprocsend(PG_FUNCTION_ARGS)
{
return oidsend(fcinfo);
}
* regprocedurein - converts "proname(args)" to proc 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_proc entry.
*/
Datum regprocedurein(PG_FUNCTION_ARGS)
{
char* pro_name_or_oid = PG_GETARG_CSTRING(0);
RegProcedure result = InvalidOid;
List* names = NIL;
int nargs;
Oid argtypes[FUNC_MAX_ARGS];
FuncCandidateList clist;
if (strcmp(pro_name_or_oid, "-") == 0)
PG_RETURN_OID(InvalidOid);
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);
}
if (u_sess->attr.attr_sql.enable_ignore_case_in_dquotes) {
int length = strlen(pro_name_or_oid);
int count = 0;
if (length > 0) {
for(int i = 0; i< length; i++) {
if(pro_name_or_oid[i] == '\"')
count++;
}
if(count % 2 == 0)
pro_name_or_oid = pg_strtolower(pro_name_or_oid);
}
}
* 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, 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;
list_free_ext(names);
PG_RETURN_OID(result);
}
* format_procedure - converts proc OID to "pro_name(args)"
*
* This exports the useful functionality of regprocedureout for use
* in other backend modules. The result is a palloc'd string.
*/
char* format_procedure(Oid procedure_oid)
{
return format_procedure_internal(procedure_oid, false);
}
char *
format_procedure_qualified(Oid procedure_oid)
{
return format_procedure_internal(procedure_oid, true);
}
* Output an objname/objargs representation for the procedure with the
* given OID. If it doesn't exist, an error is thrown.
*
* This can be used to feed get_object_address.
*/
void
format_procedure_parts(Oid procedure_oid, List **objnames, List **objargs)
{
HeapTuple proctup;
Form_pg_proc procform;
int nargs;
int i;
proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(procedure_oid));
if (!HeapTupleIsValid(proctup))
elog(ERROR, "cache lookup failed for procedure with OID %u", procedure_oid);
procform = (Form_pg_proc) GETSTRUCT(proctup);
nargs = procform->pronargs;
*objnames = list_make2(get_namespace_name_or_temp(procform->pronamespace),
pstrdup(NameStr(procform->proname)));
*objargs = NIL;
for (i = 0; i < nargs; i++)
{
Oid thisargtype = procform->proargtypes.values[i];
*objargs = lappend(*objargs, format_type_be_qualified(thisargtype));
}
ReleaseSysCache(proctup);
}
char * format_procedure_no_visible(Oid procedure_oid)
{
char* result = NULL;
HeapTuple proctup;
proctup = SearchSysCacheCopy1(PROCOID, ObjectIdGetDatum(procedure_oid));
if (HeapTupleIsValid(proctup)) {
Form_pg_proc procform = (Form_pg_proc)GETSTRUCT(proctup);
char* proname = NameStr(procform->proname);
StringInfoData buf;
initStringInfo(&buf);
appendStringInfo(&buf, "%s(", proname);
bool isNull = false;
Datum argTypeDtum = ProcedureGetAllArgTypes(proctup, &isNull);
oidvector* proargs = (oidvector*)PG_DETOAST_DATUM(argTypeDtum);
int nargs = proargs->dim1;
int i;
for (i = 0; i < nargs; i++) {
if (i > 0)
appendStringInfoChar(&buf, ',');
MakeTypeNamesStrForTypeOid(&buf, proargs->values[i]);
}
appendStringInfoChar(&buf, ')');
result = buf.data;
heap_freetuple(proctup);
} else {
result = (char*)palloc(NAMEDATALEN);
errno_t rc = snprintf_s(result, NAMEDATALEN, NAMEDATALEN - 1, "%u", procedure_oid);
securec_check_ss(rc, "\0", "\0");
}
return result;
}
* Routine to produce regprocedure names; see format_procedure above.
*
* force_qualify says whether to schema-qualify; if true, the name is always
* qualified regardless of search_path visibility. Otherwise the name is only
* qualified if the function is not in path.
*/
static char *
format_procedure_internal(Oid procedure_oid, bool force_qualify)
{
char* result = NULL;
HeapTuple proctup;
proctup = SearchSysCacheCopy1(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 = NULL;
StringInfoData buf;
oidvector* proargs = ProcedureGetArgTypes(proctup);
initStringInfo(&buf);
* Would this proc be found (given the right args) by regprocedurein?
* If not, we need to qualify it.
*/
if (FunctionIsVisible(procedure_oid) && !force_qualify)
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 = proargs->values[i];
if (i > 0)
appendStringInfoChar(&buf, ',');
appendStringInfoString(&buf, format_type_be(thisargtype));
}
appendStringInfoChar(&buf, ')');
result = buf.data;
heap_freetuple(proctup);
} else {
result = (char*)palloc(NAMEDATALEN);
errno_t rc = snprintf_s(result, NAMEDATALEN, NAMEDATALEN - 1, "%u", procedure_oid);
securec_check_ss(rc, "\0", "\0");
}
return result;
}
* regprocedureout - converts proc OID to "pro_name(args)"
*/
Datum regprocedureout(PG_FUNCTION_ARGS)
{
RegProcedure proid = PG_GETARG_OID(0);
char* result = NULL;
if (proid == InvalidOid)
result = pstrdup("-");
else
result = format_procedure(proid);
PG_RETURN_CSTRING(result);
}
* regprocedurerecv - converts external binary format to regprocedure
*/
Datum regprocedurerecv(PG_FUNCTION_ARGS)
{
return oidrecv(fcinfo);
}
* regproceduresend - converts regprocedure to binary format
*/
Datum regproceduresend(PG_FUNCTION_ARGS)
{
return oidsend(fcinfo);
}
* regoperin - converts "oprname" to operator OID
*
* We also accept a numeric OID, for symmetry with the output routine.
*
* '0' signifies unknown (OID 0). In all other cases, the input must
* match an existing pg_operator entry.
*/
Datum regoperin(PG_FUNCTION_ARGS)
{
char* opr_name_or_oid = PG_GETARG_CSTRING(0);
Oid result = InvalidOid;
List* names = NIL;
FuncCandidateList clist;
if (strcmp(opr_name_or_oid, "0") == 0)
PG_RETURN_OID(InvalidOid);
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);
}
* 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, NULL, 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;
list_free_ext(names);
PG_RETURN_OID(result);
}
* regoperout - converts operator OID to "opr_name"
*/
Datum regoperout(PG_FUNCTION_ARGS)
{
Oid oprid = PG_GETARG_OID(0);
char* result = NULL;
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 = NULL;
nspname = get_namespace_name(operform->oprnamespace);
nspname = quote_identifier(nspname);
const size_t len = strlen(nspname) + strlen(oprname) + 2;
result = (char*)palloc(len);
errno_t ret = sprintf_s(result, len, "%s.%s", nspname, oprname);
securec_check_ss(ret, "", "");
}
}
ReleaseSysCache(opertup);
} else {
* If OID doesn't match any pg_operator entry, return it numerically
*/
result = (char*)palloc(NAMEDATALEN);
errno_t rc = snprintf_s(result, NAMEDATALEN, NAMEDATALEN - 1, "%u", oprid);
securec_check_ss(rc, "\0", "\0");
}
PG_RETURN_CSTRING(result);
}
* regoperrecv - converts external binary format to regoper
*/
Datum regoperrecv(PG_FUNCTION_ARGS)
{
return oidrecv(fcinfo);
}
* regopersend - converts regoper to binary format
*/
Datum regopersend(PG_FUNCTION_ARGS)
{
return oidsend(fcinfo);
}
* regoperatorin - converts "oprname(args)" to operator OID
*
* We also accept a numeric OID, for symmetry with the output routine.
*
* '0' signifies unknown (OID 0). In all other cases, the input must
* match an existing pg_operator entry.
*/
Datum regoperatorin(PG_FUNCTION_ARGS)
{
char* opr_name_or_oid = PG_GETARG_CSTRING(0);
Oid result;
List* names = NIL;
int nargs;
Oid argtypes[FUNC_MAX_ARGS];
if (strcmp(opr_name_or_oid, "0") == 0)
PG_RETURN_OID(InvalidOid);
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);
}
if (u_sess->attr.attr_sql.enable_ignore_case_in_dquotes) {
int length = strlen(opr_name_or_oid);
int count = 0;
if (length > 0) {
for(int i = 0; i< length; i++) {
if(opr_name_or_oid[i] == '\"')
count++;
}
if(count % 2 == 0)
opr_name_or_oid = pg_strtolower(opr_name_or_oid);
}
}
* 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);
}
* format_operator_internal - converts operator OID to "opr_name(args)"
*
* This exports the useful functionality of regoperatorout for use
* in other backend modules. The result is a palloc'd string.
*/
char* format_operator_internal(Oid operator_oid, bool force_qualify)
{
char* result = NULL;
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 = NULL;
StringInfoData buf;
initStringInfo(&buf);
* Would this oper be found (given the right args) by regoperatorin?
* If not, 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->oprleft):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);
errno_t rc = snprintf_s(result, NAMEDATALEN, NAMEDATALEN - 1, "%u", operator_oid);
securec_check_ss(rc, "\0", "\0");
}
return result;
}
char *
format_operator(Oid operator_oid)
{
return format_operator_internal(operator_oid, false);
}
char *
format_operator_qualified(Oid operator_oid)
{
return format_operator_internal(operator_oid, true);
}
* regoperatorout - converts operator OID to "opr_name(args)"
*/
Datum regoperatorout(PG_FUNCTION_ARGS)
{
Oid oprid = PG_GETARG_OID(0);
char* result = NULL;
if (oprid == InvalidOid)
result = pstrdup("0");
else
result = format_operator(oprid);
PG_RETURN_CSTRING(result);
}
* regoperatorrecv - converts external binary format to regoperator
*/
Datum regoperatorrecv(PG_FUNCTION_ARGS)
{
return oidrecv(fcinfo);
}
* regoperatorsend - converts regoperator to binary format
*/
Datum regoperatorsend(PG_FUNCTION_ARGS)
{
return oidsend(fcinfo);
}
void
format_operator_parts(Oid operator_oid, List **objnames, List **objargs)
{
HeapTuple opertup;
Form_pg_operator oprForm;
opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operator_oid));
if (!HeapTupleIsValid(opertup))
elog(ERROR, "cache lookup failed for operator with OID %u",
operator_oid);
oprForm = (Form_pg_operator) GETSTRUCT(opertup);
*objnames = list_make2(get_namespace_name_or_temp(oprForm->oprnamespace),
pstrdup(NameStr(oprForm->oprname)));
*objargs = NIL;
if (oprForm->oprleft)
*objargs = lappend(*objargs,
format_type_be_qualified(oprForm->oprleft));
if (oprForm->oprright)
*objargs = lappend(*objargs,
format_type_be_qualified(oprForm->oprright));
ReleaseSysCache(opertup);
}
* regclassin - converts "classname" to class 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_class entry.
*/
Datum regclassin(PG_FUNCTION_ARGS)
{
char* class_name_or_oid = PG_GETARG_CSTRING(0);
Oid result = InvalidOid;
List* names = NIL;
if (strcmp(class_name_or_oid, "-") == 0)
PG_RETURN_OID(InvalidOid);
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);
}
* 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, NULL, 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)));
systable_endscan(sysscan);
heap_close(hdesc, AccessShareLock);
PG_RETURN_OID(result);
}
if (u_sess->attr.attr_sql.enable_ignore_case_in_dquotes) {
int length = strlen(class_name_or_oid);
if(length > 0 && class_name_or_oid[0] == '\"' && class_name_or_oid[length-1] == '\"')
class_name_or_oid = pg_strtolower(class_name_or_oid);
}
* 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);
result = RangeVarGetRelidExtended(makeRangeVarFromNameList(names), NoLock, false, false, false, true, NULL, NULL);
list_free_ext(names);
PG_RETURN_OID(result);
}
* regclassout - converts class OID to "class_name"
*/
Datum regclassout(PG_FUNCTION_ARGS)
{
Oid classid = PG_GETARG_OID(0);
char* result = NULL;
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 = NULL;
* 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 {
result = (char*)palloc(NAMEDATALEN);
errno_t rc = snprintf_s(result, NAMEDATALEN, NAMEDATALEN - 1, "%u", classid);
securec_check_ss(rc, "\0", "\0");
}
PG_RETURN_CSTRING(result);
}
* regclassrecv - converts external binary format to regclass
*/
Datum regclassrecv(PG_FUNCTION_ARGS)
{
return oidrecv(fcinfo);
}
* regclasssend - converts regclass to binary format
*/
Datum regclasssend(PG_FUNCTION_ARGS)
{
return oidsend(fcinfo);
}
* regtypein - converts "typename" to type 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_type entry.
*
* In bootstrap mode the name must just equal some existing name in pg_type.
* In normal mode the type name can be specified using the full type syntax
* recognized by the parser; for example, DOUBLE PRECISION and INTEGER[] will
* work and be translated to the correct type names. (We ignore any typmod
* info generated by the parser, however.)
*/
Datum regtypein(PG_FUNCTION_ARGS)
{
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);
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);
}
if (u_sess->attr.attr_sql.enable_ignore_case_in_dquotes) {
int length = strlen(typ_name_or_oid);
if(length > 0 && typ_name_or_oid[0] == '\"' && typ_name_or_oid[length-1] == '\"')
typ_name_or_oid = pg_strtolower(typ_name_or_oid);
}
* 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, NULL, 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)));
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);
}
* regtypeout - converts type OID to "typ_name"
*/
Datum regtypeout(PG_FUNCTION_ARGS)
{
Oid typid = PG_GETARG_OID(0);
char* result = NULL;
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 {
result = (char*)palloc(NAMEDATALEN);
errno_t rc = snprintf_s(result, NAMEDATALEN, NAMEDATALEN - 1, "%u", typid);
securec_check_ss(rc, "\0", "\0");
}
PG_RETURN_CSTRING(result);
}
* regtyperecv - converts external binary format to regtype
*/
Datum regtyperecv(PG_FUNCTION_ARGS)
{
return oidrecv(fcinfo);
}
* regtypesend - converts regtype to binary format
*/
Datum regtypesend(PG_FUNCTION_ARGS)
{
return oidsend(fcinfo);
}
* 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 = NIL;
if (strcmp(cfg_name_or_oid, "-") == 0)
PG_RETURN_OID(InvalidOid);
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);
}
if (u_sess->attr.attr_sql.enable_ignore_case_in_dquotes) {
int length = strlen(cfg_name_or_oid);
if(length > 0 && cfg_name_or_oid[0] == '\"' && cfg_name_or_oid[length-1] == '\"')
cfg_name_or_oid = pg_strtolower(cfg_name_or_oid);
}
* 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);
list_free_ext(names);
PG_RETURN_OID(result);
}
* regconfigout - converts tsconfig OID to "tsconfigname"
*/
Datum regconfigout(PG_FUNCTION_ARGS)
{
Oid cfgid = PG_GETARG_OID(0);
char* result = NULL;
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 = NULL;
* 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 {
result = (char*)palloc(NAMEDATALEN);
errno_t rc = snprintf_s(result, NAMEDATALEN, NAMEDATALEN - 1, "%u", cfgid);
securec_check_ss(rc, "\0", "\0");
}
PG_RETURN_CSTRING(result);
}
* regconfigrecv - converts external binary format to regconfig
*/
Datum regconfigrecv(PG_FUNCTION_ARGS)
{
return oidrecv(fcinfo);
}
* regconfigsend - converts regconfig to binary format
*/
Datum regconfigsend(PG_FUNCTION_ARGS)
{
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 = NIL;
if (strcmp(dict_name_or_oid, "-") == 0)
PG_RETURN_OID(InvalidOid);
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);
}
if (u_sess->attr.attr_sql.enable_ignore_case_in_dquotes) {
int length = strlen(dict_name_or_oid);
if(length > 0 && dict_name_or_oid[0] == '\"' && dict_name_or_oid[length-1] == '\"')
dict_name_or_oid = pg_strtolower(dict_name_or_oid);
}
* 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);
list_free_ext(names);
PG_RETURN_OID(result);
}
* regdictionaryout - converts tsdictionary OID to "tsdictionaryname"
*/
Datum regdictionaryout(PG_FUNCTION_ARGS)
{
Oid dictid = PG_GETARG_OID(0);
char* result = NULL;
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 = NULL;
* 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 {
result = (char*)palloc(NAMEDATALEN);
errno_t rc = snprintf_s(result, NAMEDATALEN, NAMEDATALEN - 1, "%u", dictid);
securec_check_ss(rc, "\0", "\0");
}
PG_RETURN_CSTRING(result);
}
* regdictionaryrecv - converts external binary format to regdictionary
*/
Datum regdictionaryrecv(PG_FUNCTION_ARGS)
{
return oidrecv(fcinfo);
}
* regdictionarysend - converts regdictionary to binary format
*/
Datum regdictionarysend(PG_FUNCTION_ARGS)
{
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 = NULL;
rv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
result = RangeVarGetRelid(rv, NoLock, false);
PG_RETURN_OID(result);
}
* Given a C string, parse it into a qualified-name list.
*/
List* stringToQualifiedNameList(const char* string)
{
char* rawname = NULL;
List* result = NIL;
List* namelist = NIL;
ListCell* l = NULL;
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_ext(rawname);
list_free_ext(namelist);
return result;
}
* SUPPORT ROUTINES *
*****************************************************************************/
* Given a C string, parse it into a qualified function or operator name
* followed by a parenthesized list of type names. Reduce the
* type names to an array of OIDs (returned into *nargs and *argtypes;
* the argtypes array should be of size FUNC_MAX_ARGS). The function or
* operator name is returned to *names as a List of Strings.
*
* If allowNone is TRUE, accept "NONE" and return it as InvalidOid (this is
* for unary operators).
*/
static void parseNameAndArgTypes(const char* string, bool allowNone, List** names, int* nargs, Oid* argtypes)
{
char* rawname = NULL;
char* ptr = NULL;
char* ptr2 = NULL;
char* typname = NULL;
bool in_quote = false;
bool had_comma = false;
int paren_count;
Oid typeId;
int32 typmod;
rawname = pstrdup(string);
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")));
*ptr++ = '\0';
*names = stringToQualifiedNameList(rawname);
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';
*nargs = 0;
had_comma = false;
for (;;) {
while (isspace((unsigned char)*ptr)) {
ptr++;
}
if (*ptr == '\0') {
if (had_comma)
ereport(ERROR, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("expected a type name")));
break;
}
typname = ptr;
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;
default:
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');
}
while (--ptr2 >= typname) {
if (!isspace((unsigned char)*ptr2)) {
break;
}
*ptr2 = '\0';
}
if (allowNone && pg_strcasecmp(typname, "none") == 0) {
typeId = InvalidOid;
typmod = -1;
} else {
parseTypeString(typname, &typeId, &typmod);
}
if (*nargs >= FUNC_MAX_ARGS)
ereport(ERROR, (errcode(ERRCODE_TOO_MANY_ARGUMENTS), errmsg("too many arguments")));
argtypes[*nargs] = typeId;
(*nargs)++;
}
pfree_ext(rawname);
}
