Implement types regprocedure, regoper, regoperator, regclass, regtype

per pghackers discussion.  Add some more typsanity tests, and clean
up some problems exposed thereby (broken or missing array types for
some built-in types).  Also, clean up loose ends from unknownin/out
patch.

10 files changed, 1236 insertions, 125 deletions

diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c
index a4ab6fce614..07d013232c7 100644
--- a/src/backend/bootstrap/bootstrap.c
+++ b/src/backend/bootstrap/bootstrap.c
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.125 2002/03/26 19:15:16 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.126 2002/04/25 02:56:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -109,12 +109,14 @@ static struct typinfo Procid[] = {
 	{"int2vector", INT2VECTOROID, 0, INDEX_MAX_KEYS * 2, F_INT2VECTORIN, F_INT2VECTOROUT},
 	{"int4", INT4OID, 0, 4, F_INT4IN, F_INT4OUT},
 	{"regproc", REGPROCOID, 0, 4, F_REGPROCIN, F_REGPROCOUT},
+	{"regclass", REGCLASSOID, 0, 4, F_REGCLASSIN, F_REGCLASSOUT},
+	{"regtype", REGTYPEOID, 0, 4, F_REGTYPEIN, F_REGTYPEOUT},
 	{"text", TEXTOID, 0, -1, F_TEXTIN, F_TEXTOUT},
 	{"oid", OIDOID, 0, 4, F_OIDIN, F_OIDOUT},
 	{"tid", TIDOID, 0, 6, F_TIDIN, F_TIDOUT},
 	{"xid", XIDOID, 0, 4, F_XIDIN, F_XIDOUT},
 	{"cid", CIDOID, 0, 4, F_CIDIN, F_CIDOUT},
-	{"oidvector", 30, 0, INDEX_MAX_KEYS * 4, F_OIDVECTORIN, F_OIDVECTOROUT},
+	{"oidvector", OIDVECTOROID, 0, INDEX_MAX_KEYS * 4, F_OIDVECTORIN, F_OIDVECTOROUT},
 	{"smgr", 210, 0, 2, F_SMGRIN, F_SMGROUT},
 	{"_int4", 1007, INT4OID, -1, F_ARRAY_IN, F_ARRAY_OUT},
 	{"_aclitem", 1034, 1033, -1, F_ARRAY_IN, F_ARRAY_OUT}
@@ -600,7 +602,7 @@ DefineAttr(char *name, char *type, int attnum)
 		attrtypes[attnum]->attnum = 1 + attnum; /* fillatt */
 		attlen = attrtypes[attnum]->attlen = Ap->am_typ.typlen;
 		attrtypes[attnum]->attbyval = Ap->am_typ.typbyval;
-		attrtypes[attnum]->attstorage = Ap->am_typ.typstorage;;
+		attrtypes[attnum]->attstorage = Ap->am_typ.typstorage;
 		attrtypes[attnum]->attalign = Ap->am_typ.typalign;
 	}
 	else
@@ -610,28 +612,37 @@ DefineAttr(char *name, char *type, int attnum)
 		elog(DEBUG3, "column %s %s", NameStr(attrtypes[attnum]->attname), type);
 		attrtypes[attnum]->attnum = 1 + attnum; /* fillatt */
 		attlen = attrtypes[attnum]->attlen = Procid[typeoid].len;
-		attrtypes[attnum]->attstorage = 'p';
 
 		/*
 		 * Cheat like mad to fill in these items from the length only.
-		 * This only has to work for types used in the system catalogs...
+		 * This only has to work for types that appear in Procid[].
 		 */
 		switch (attlen)
 		{
 			case 1:
 				attrtypes[attnum]->attbyval = true;
+				attrtypes[attnum]->attstorage = 'p';
 				attrtypes[attnum]->attalign = 'c';
 				break;
 			case 2:
 				attrtypes[attnum]->attbyval = true;
+				attrtypes[attnum]->attstorage = 'p';
 				attrtypes[attnum]->attalign = 's';
 				break;
 			case 4:
 				attrtypes[attnum]->attbyval = true;
+				attrtypes[attnum]->attstorage = 'p';
+				attrtypes[attnum]->attalign = 'i';
+				break;
+			case -1:
+				attrtypes[attnum]->attbyval = false;
+				attrtypes[attnum]->attstorage = 'x';
 				attrtypes[attnum]->attalign = 'i';
 				break;
 			default:
+				/* TID and fixed-length arrays, such as oidvector */
 				attrtypes[attnum]->attbyval = false;
+				attrtypes[attnum]->attstorage = 'p';
 				attrtypes[attnum]->attalign = 'i';
 				break;
 		}
@@ -803,6 +814,13 @@ cleanup()
 
 /* ----------------
  *		gettype
+ *
+ * NB: this is really ugly; it will return an integer index into Procid[],
+ * and not an OID at all, until the first reference to a type not known in
+ * Procid[].  At that point it will read and cache pg_type in the Typ array,
+ * and subsequently return a real OID (and set the global pointer Ap to
+ * point at the found row in Typ).  So caller must check whether Typ is
+ * still NULL to determine what the return value is!
  * ----------------
  */
 static Oid
@@ -827,7 +845,7 @@ gettype(char *type)
 	}
 	else
 	{
-		for (i = 0; i <= n_types; i++)
+		for (i = 0; i < n_types; i++)
 		{
 			if (strncmp(type, Procid[i].name, NAMEDATALEN) == 0)
 				return i;
diff --git a/src/backend/catalog/namespace.c b/src/backend/catalog/namespace.c
index 0a3aefeaf0f..c81b990b4e6 100644
--- a/src/backend/catalog/namespace.c
+++ b/src/backend/catalog/namespace.c
@@ -13,7 +13,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/namespace.c,v 1.11 2002/04/17 20:57:56 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/namespace.c,v 1.12 2002/04/25 02:56:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -365,9 +365,12 @@ OpclassnameGetOpcid(Oid amid, const char *opcname)
  *		Given a possibly-qualified function name and argument count,
  *		retrieve a list of the possible matches.
  *
+ * If nargs is -1, we return all functions matching the given name,
+ * regardless of argument count.
+ *
  * We search a single namespace if the function name is qualified, else
  * all namespaces in the search path.  The return list will never contain
- * multiple entries with identical argument types --- in the multiple-
+ * multiple entries with identical argument lists --- in the multiple-
  * namespace case, we arrange for entries in earlier namespaces to mask
  * identical entries in later namespaces.
  */
@@ -423,11 +426,16 @@ FuncnameGetCandidates(List *names, int nargs)
 		namespaceId = InvalidOid;
 	}
 
-	/* Search syscache by name and nargs only */
-	catlist = SearchSysCacheList(PROCNAMENSP, 2,
-								 CStringGetDatum(funcname),
-								 Int16GetDatum(nargs),
-								 0, 0);
+	/* Search syscache by name and (optionally) nargs only */
+	if (nargs >= 0)
+		catlist = SearchSysCacheList(PROCNAMENSP, 2,
+									 CStringGetDatum(funcname),
+									 Int16GetDatum(nargs),
+									 0, 0);
+	else
+		catlist = SearchSysCacheList(PROCNAMENSP, 1,
+									 CStringGetDatum(funcname),
+									 0, 0, 0);
 
 	for (i = 0; i < catlist->n_members; i++)
 	{
@@ -436,6 +444,8 @@ FuncnameGetCandidates(List *names, int nargs)
 		int			pathpos = 0;
 		FuncCandidateList newResult;
 
+		nargs = procform->pronargs;
+
 		if (OidIsValid(namespaceId))
 		{
 			/* Consider only procs in specified namespace */
@@ -478,7 +488,8 @@ FuncnameGetCandidates(List *names, int nargs)
 
 				if (catlist->ordered)
 				{
-					if (memcmp(procform->proargtypes, resultList->args,
+					if (nargs == resultList->nargs &&
+						memcmp(procform->proargtypes, resultList->args,
 							   nargs * sizeof(Oid)) == 0)
 						prevResult = resultList;
 					else
@@ -490,7 +501,8 @@ FuncnameGetCandidates(List *names, int nargs)
 						 prevResult;
 						 prevResult = prevResult->next)
 					{
-						if (memcmp(procform->proargtypes, prevResult->args,
+						if (nargs == prevResult->nargs &&
+							memcmp(procform->proargtypes, prevResult->args,
 								   nargs * sizeof(Oid)) == 0)
 							break;
 					}
@@ -517,6 +529,7 @@ FuncnameGetCandidates(List *names, int nargs)
 				   + nargs * sizeof(Oid));
 		newResult->pathpos = pathpos;
 		newResult->oid = proctup->t_data->t_oid;
+		newResult->nargs = nargs;
 		memcpy(newResult->args, procform->proargtypes, nargs * sizeof(Oid));
 
 		newResult->next = resultList;
@@ -533,14 +546,17 @@ FuncnameGetCandidates(List *names, int nargs)
  *		Given a possibly-qualified operator name and operator kind,
  *		retrieve a list of the possible matches.
  *
+ * If oprkind is '\0', we return all operators matching the given name,
+ * regardless of arguments.
+ *
  * We search a single namespace if the operator name is qualified, else
  * all namespaces in the search path.  The return list will never contain
- * multiple entries with identical argument types --- in the multiple-
+ * multiple entries with identical argument lists --- in the multiple-
  * namespace case, we arrange for entries in earlier namespaces to mask
  * identical entries in later namespaces.
  *
  * The returned items always have two args[] entries --- one or the other
- * will be InvalidOid for a prefix or postfix oprkind.
+ * will be InvalidOid for a prefix or postfix oprkind.  nargs is 2, too.
  */
 FuncCandidateList
 OpernameGetCandidates(List *names, char oprkind)
@@ -606,8 +622,8 @@ OpernameGetCandidates(List *names, char oprkind)
 		int			pathpos = 0;
 		FuncCandidateList newResult;
 
-		/* Ignore operators of wrong kind */
-		if (operform->oprkind != oprkind)
+		/* Ignore operators of wrong kind, if specific kind requested */
+		if (oprkind && operform->oprkind != oprkind)
 			continue;
 
 		if (OidIsValid(namespaceId))
@@ -690,6 +706,7 @@ OpernameGetCandidates(List *names, char oprkind)
 			palloc(sizeof(struct _FuncCandidateList) + sizeof(Oid));
 		newResult->pathpos = pathpos;
 		newResult->oid = opertup->t_data->t_oid;
+		newResult->nargs = 2;
 		newResult->args[0] = operform->oprleft;
 		newResult->args[1] = operform->oprright;
 		newResult->next = resultList;
diff --git a/src/backend/catalog/pg_operator.c b/src/backend/catalog/pg_operator.c
index 3a4bb1bba34..52cb26ee6a5 100644
--- a/src/backend/catalog/pg_operator.c
+++ b/src/backend/catalog/pg_operator.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.66 2002/04/16 23:08:10 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.67 2002/04/25 02:56:55 tgl Exp $
  *
  * NOTES
  *	  these routines moved here from commands/define.c and somewhat cleaned up.
@@ -138,7 +138,7 @@ OperatorGet(const char *operatorName,
 						 ObjectIdGetDatum(operatorNamespace));
 	if (HeapTupleIsValid(tup))
 	{
-		regproc		oprcode = ((Form_pg_operator) GETSTRUCT(tup))->oprcode;
+		RegProcedure oprcode = ((Form_pg_operator) GETSTRUCT(tup))->oprcode;
 
 		operatorObjectId = tup->t_data->t_oid;
 		*defined = RegProcedureIsValid(oprcode);
@@ -168,7 +168,7 @@ OperatorLookup(List *operatorName,
 			   bool *defined)
 {
 	Oid			operatorObjectId;
-	regproc		oprcode;
+	RegProcedure oprcode;
 
 	operatorObjectId = LookupOperName(operatorName, leftObjectId,
 									  rightObjectId);
diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_coerce.c
index aca5afc1243..57aad4dbf58 100644
--- a/src/backend/parser/parse_coerce.c
+++ b/src/backend/parser/parse_coerce.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.70 2002/04/11 20:00:00 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.71 2002/04/25 02:56:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -81,8 +81,7 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
 
 		if (!con->constisnull)
 		{
-			/* We know the source constant is really of type 'text' */
-			char	   *val = DatumGetCString(DirectFunctionCall1(textout,
+			char	   *val = DatumGetCString(DirectFunctionCall1(unknownout,
 													   con->constvalue));
 
 			newcon->constvalue = stringTypeDatum(targetType, val, atttypmod);
@@ -477,6 +476,11 @@ TypeCategory(Oid inType)
 
 		case (OIDOID):
 		case (REGPROCOID):
+		case (REGPROCEDUREOID):
+		case (REGOPEROID):
+		case (REGOPERATOROID):
+		case (REGCLASSOID):
+		case (REGTYPEOID):
 		case (INT2OID):
 		case (INT4OID):
 		case (INT8OID):
@@ -540,38 +544,72 @@ TypeCategory(Oid inType)
  * to allow for better type extensibility.
  */
 
+#define TypeIsTextGroup(t) \
+		((t) == TEXTOID || \
+		 (t) == BPCHAROID || \
+		 (t) == VARCHAROID)
+
+/* Notice OidGroup is a subset of Int4GroupA */
+#define TypeIsOidGroup(t) \
+		((t) == OIDOID || \
+		 (t) == REGPROCOID || \
+		 (t) == REGPROCEDUREOID || \
+		 (t) == REGOPEROID || \
+		 (t) == REGOPERATOROID || \
+		 (t) == REGCLASSOID || \
+		 (t) == REGTYPEOID)
+
 /*
- * This macro describes hard-coded knowledge of binary compatibility
- * for built-in types.
+ * INT4 is binary-compatible with many types, but we don't want to allow
+ * implicit coercion directly between, say, OID and AbsTime.  So we subdivide
+ * the categories.
  */
-#define IS_BINARY_COMPATIBLE(a,b) \
-		  (((a) == BPCHAROID && (b) == TEXTOID) \
-		|| ((a) == BPCHAROID && (b) == VARCHAROID) \
-		|| ((a) == VARCHAROID && (b) == TEXTOID) \
-		|| ((a) == VARCHAROID && (b) == BPCHAROID) \
-		|| ((a) == TEXTOID && (b) == BPCHAROID) \
-		|| ((a) == TEXTOID && (b) == VARCHAROID) \
-		|| ((a) == OIDOID && (b) == INT4OID) \
-		|| ((a) == OIDOID && (b) == REGPROCOID) \
-		|| ((a) == INT4OID && (b) == OIDOID) \
-		|| ((a) == INT4OID && (b) == REGPROCOID) \
-		|| ((a) == REGPROCOID && (b) == OIDOID) \
-		|| ((a) == REGPROCOID && (b) == INT4OID) \
-		|| ((a) == ABSTIMEOID && (b) == INT4OID) \
-		|| ((a) == INT4OID && (b) == ABSTIMEOID) \
-		|| ((a) == RELTIMEOID && (b) == INT4OID) \
-		|| ((a) == INT4OID && (b) == RELTIMEOID) \
-		|| ((a) == INETOID && (b) == CIDROID) \
-		|| ((a) == CIDROID && (b) == INETOID) \
-		|| ((a) == BITOID && (b) == VARBITOID) \
-		|| ((a) == VARBITOID && (b) == BITOID))
+#define TypeIsInt4GroupA(t) \
+		((t) == INT4OID || \
+		 TypeIsOidGroup(t))
 
-bool
-IsBinaryCompatible(Oid type1, Oid type2)
+#define TypeIsInt4GroupB(t) \
+		((t) == INT4OID || \
+		 (t) == ABSTIMEOID)
+
+#define TypeIsInt4GroupC(t) \
+		((t) == INT4OID || \
+		 (t) == RELTIMEOID)
+
+#define TypeIsInetGroup(t) \
+		((t) == INETOID || \
+		 (t) == CIDROID)
+
+#define TypeIsBitGroup(t) \
+		((t) == BITOID || \
+		 (t) == VARBITOID)
+
+
+static bool
+DirectlyBinaryCompatible(Oid type1, Oid type2)
 {
 	if (type1 == type2)
 		return true;
-	if (IS_BINARY_COMPATIBLE(type1, type2))
+	if (TypeIsTextGroup(type1) && TypeIsTextGroup(type2))
+		return true;
+	if (TypeIsInt4GroupA(type1) && TypeIsInt4GroupA(type2))
+		return true;
+	if (TypeIsInt4GroupB(type1) && TypeIsInt4GroupB(type2))
+		return true;
+	if (TypeIsInt4GroupC(type1) && TypeIsInt4GroupC(type2))
+		return true;
+	if (TypeIsInetGroup(type1) && TypeIsInetGroup(type2))
+		return true;
+	if (TypeIsBitGroup(type1) && TypeIsBitGroup(type2))
+		return true;
+	return false;
+}
+
+
+bool
+IsBinaryCompatible(Oid type1, Oid type2)
+{
+	if (DirectlyBinaryCompatible(type1, type2))
 		return true;
 	/*
 	 * Perhaps the types are domains; if so, look at their base types
@@ -580,9 +618,7 @@ IsBinaryCompatible(Oid type1, Oid type2)
 		type1 = getBaseType(type1);
 	if (OidIsValid(type2))
 		type2 = getBaseType(type2);
-	if (type1 == type2)
-		return true;
-	if (IS_BINARY_COMPATIBLE(type1, type2))
+	if (DirectlyBinaryCompatible(type1, type2))
 		return true;
 	return false;
 }
@@ -627,7 +663,7 @@ PreferredType(CATEGORY category, Oid type)
 			break;
 
 		case (NUMERIC_TYPE):
-			if (type == OIDOID)
+			if (TypeIsOidGroup(type))
 				result = OIDOID;
 			else if (type == NUMERICOID)
 				result = NUMERICOID;
diff --git a/src/backend/parser/parse_node.c b/src/backend/parser/parse_node.c
index 8a3dc4d5573..5c02e9b4bbb 100644
--- a/src/backend/parser/parse_node.c
+++ b/src/backend/parser/parse_node.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.62 2002/04/16 23:08:11 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.63 2002/04/25 02:56:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -424,7 +424,8 @@ make_const(Value *value)
 			break;
 
 		case T_String:
-			val = DirectFunctionCall1(textin, CStringGetDatum(strVal(value)));
+			val = DirectFunctionCall1(unknownin,
+									  CStringGetDatum(strVal(value)));
 
 			typeid = UNKNOWNOID;	/* will be coerced later */
 			typelen = -1;		/* variable len */
diff --git a/src/backend/utils/adt/regproc.c b/src/backend/utils/adt/regproc.c
index fd28c8fae77..89be1bac96b 100644
--- a/src/backend/utils/adt/regproc.c
+++ b/src/backend/utils/adt/regproc.c
@@ -1,51 +1,74 @@
- /*-------------------------------------------------------------------------
+/*-------------------------------------------------------------------------
  *
  * regproc.c
- *	  Functions for the built-in type "RegProcedure".
+ *	  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-2001, 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.65 2002/04/05 00:31:29 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.66 2002/04/25 02:56:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 #include "postgres.h"
 
+#include <ctype.h>
+
 #include "access/genam.h"
 #include "access/heapam.h"
 #include "catalog/catname.h"
 #include "catalog/indexing.h"
+#include "catalog/namespace.h"
+#include "catalog/pg_operator.h"
 #include "catalog/pg_proc.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"
 
 
+static List *stringToQualifiedNameList(const char *string, const char *caller);
+static void parseNameAndArgTypes(const char *string, const char *caller,
+								 bool allow_none,
+								 List **names, int *nargs, Oid *argtypes);
+
+
 /*****************************************************************************
  *	 USER I/O ROUTINES														 *
  *****************************************************************************/
 
 /*
- *		regprocin		- converts "proname" or "proid" to proid
+ * regprocin		- converts "proname" to proc OID
  *
- *		We need to accept an OID for cases where the name is ambiguous.
+ * We also accept a numeric OID, mostly for historical reasons.
  *
- *		proid of '-' signifies unknown, for consistency with regprocout
+ * '-' 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;
-	int			matches = 0;
+	List	   *names;
+	FuncCandidateList clist;
 
-	if (pro_name_or_oid[0] == '-' && pro_name_or_oid[1] == '\0')
+	/* '-' ? */
+	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))
@@ -59,13 +82,23 @@ regprocin(PG_FUNCTION_ARGS)
 											   0, 0, 0);
 		if (!RegProcedureIsValid(result))
 			elog(ERROR, "No procedure with oid %s", pro_name_or_oid);
-		matches = 1;
+		PG_RETURN_OID(result);
 	}
-	else
+
+	/* 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	funcscan;
+		SysScanDesc	sysscan;
 		HeapTuple	tuple;
 
 		ScanKeyEntryInitialize(&skey[0], 0x0,
@@ -74,46 +107,192 @@ regprocin(PG_FUNCTION_ARGS)
 							   CStringGetDatum(pro_name_or_oid));
 
 		hdesc = heap_openr(ProcedureRelationName, AccessShareLock);
+		sysscan = systable_beginscan(hdesc, ProcedureNameNspIndex, true,
+									 SnapshotNow, 1, skey);
 
-		funcscan = systable_beginscan(hdesc, ProcedureNameNspIndex, true,
-									  SnapshotNow, 1, skey);
-
-		while (HeapTupleIsValid(tuple = systable_getnext(funcscan)))
+		while (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
 		{
 			result = (RegProcedure) tuple->t_data->t_oid;
 			if (++matches > 1)
 				break;
 		}
 
-		systable_endscan(funcscan);
-
+		systable_endscan(sysscan);
 		heap_close(hdesc, AccessShareLock);
+
+		if (matches == 0)
+			elog(ERROR, "No procedure with name %s", pro_name_or_oid);
+		else if (matches > 1)
+			elog(ERROR, "There is more than one procedure named %s",
+				 pro_name_or_oid);
+		PG_RETURN_OID(result);
 	}
 
-	if (matches > 1)
-		elog(ERROR, "There is more than one procedure named %s.\n\tSupply the pg_proc oid inside single quotes.", pro_name_or_oid);
-	else if (matches == 0)
+	/*
+	 * 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);
+
+	if (clist == NULL)
 		elog(ERROR, "No procedure with name %s", pro_name_or_oid);
+	else if (clist->next != NULL)
+		elog(ERROR, "There is more than one procedure named %s",
+			 pro_name_or_oid);
+
+	result = clist->oid;
 
 	PG_RETURN_OID(result);
 }
 
 /*
- *		regprocout		- converts proid to "pro_name"
+ * regprocout		- converts proc OID to "pro_name"
  */
 Datum
 regprocout(PG_FUNCTION_ARGS)
 {
 	RegProcedure proid = PG_GETARG_OID(0);
-	HeapTuple	proctup;
 	char	   *result;
+	HeapTuple	proctup;
+
+	if (proid == InvalidOid)
+	{
+		result = pstrdup("-");
+		PG_RETURN_CSTRING(result);
+	}
+
+	proctup = SearchSysCache(PROCOID,
+							 ObjectIdGetDatum(proid),
+							 0, 0, 0);
+
+	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(makeList1(makeString(proname)), -1);
+			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);
+}
 
-	result = (char *) palloc(NAMEDATALEN);
+
+/*
+ * regprocedurein		- converts "proname(args)" to proc OID
+ *
+ * We also accept a numeric OID, mostly for historical reasons.
+ *
+ * '-' 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;
+	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))
+	{
+		Oid			searchOid;
+
+		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+									  CStringGetDatum(pro_name_or_oid)));
+		result = (RegProcedure) GetSysCacheOid(PROCOID,
+											 ObjectIdGetDatum(searchOid),
+											   0, 0, 0);
+		if (!RegProcedureIsValid(result))
+			elog(ERROR, "No procedure with oid %s", 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, "regprocedurein", false,
+						 &names, &nargs, argtypes);
+
+	clist = FuncnameGetCandidates(names, nargs);
+
+	for (; clist; clist = clist->next)
+	{
+		if (memcmp(clist->args, argtypes, nargs * sizeof(Oid)) == 0)
+			break;
+	}
+
+	if (clist == NULL)
+		elog(ERROR, "No procedure with name %s", pro_name_or_oid);
+
+	result = clist->oid;
+
+	PG_RETURN_OID(result);
+}
+
+/*
+ * regprocedureout		- converts proc OID to "pro_name(args)"
+ */
+Datum
+regprocedureout(PG_FUNCTION_ARGS)
+{
+	RegProcedure proid = PG_GETARG_OID(0);
+	char	   *result;
+	HeapTuple	proctup;
 
 	if (proid == InvalidOid)
 	{
-		result[0] = '-';
-		result[1] = '\0';
+		result = pstrdup("-");
 		PG_RETURN_CSTRING(result);
 	}
 
@@ -123,38 +302,862 @@ regprocout(PG_FUNCTION_ARGS)
 
 	if (HeapTupleIsValid(proctup))
 	{
-		char	   *s;
+		Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
+		char	   *proname = NameStr(procform->proname);
+		int			nargs = procform->pronargs;
+		int			i;
+		char	   *nspname;
+		FuncCandidateList clist;
+		StringInfoData buf;
+
+		/* XXX no support here for bootstrap mode */
+
+		/*
+		 * Would this proc be found (given the right args) by regprocedurein?
+		 * If not, we need to qualify it.
+		 */
+		clist = FuncnameGetCandidates(makeList1(makeString(proname)), nargs);
+
+		for (; clist; clist = clist->next)
+		{
+			if (memcmp(clist->args, procform->proargtypes,
+					   nargs * sizeof(Oid)) == 0)
+				break;
+		}
+
+		if (clist != NULL && clist->oid == proid)
+			nspname = NULL;
+		else
+			nspname = get_namespace_name(procform->pronamespace);
+
+		initStringInfo(&buf);
+
+		appendStringInfo(&buf, "%s(",
+						 quote_qualified_identifier(nspname, proname));
+		for (i = 0; i < nargs; i++)
+		{
+			appendStringInfo(&buf, "%s%s",
+							 (i > 0) ? "," : "",
+							 format_type_be(procform->proargtypes[i]));
+		}
+
+		appendStringInfo(&buf, ")");
+
+		result = buf.data;
 
-		s = NameStr(((Form_pg_proc) GETSTRUCT(proctup))->proname);
-		StrNCpy(result, s, NAMEDATALEN);
 		ReleaseSysCache(proctup);
 	}
 	else
 	{
-		result[0] = '-';
-		result[1] = '\0';
+		/* 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);
+}
+
+
+/*
+ * regoperin		- converts "oprname" to operator OID
+ *
+ * We also accept a numeric OID, mostly for historical reasons.
+ *
+ * '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;
+	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))
+	{
+		Oid			searchOid;
+
+		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+									  CStringGetDatum(opr_name_or_oid)));
+		result = GetSysCacheOid(OPEROID,
+								ObjectIdGetDatum(searchOid),
+								0, 0, 0);
+		if (!OidIsValid(result))
+			elog(ERROR, "No operator with oid %s", 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;
+
+		ScanKeyEntryInitialize(&skey[0], 0x0,
+							   (AttrNumber) Anum_pg_operator_oprname,
+							   (RegProcedure) F_NAMEEQ,
+							   CStringGetDatum(opr_name_or_oid));
+
+		hdesc = heap_openr(OperatorRelationName, AccessShareLock);
+		sysscan = systable_beginscan(hdesc, OperatorNameNspIndex, true,
+									 SnapshotNow, 1, skey);
+
+		while (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
+		{
+			result = tuple->t_data->t_oid;
+			if (++matches > 1)
+				break;
+		}
+
+		systable_endscan(sysscan);
+		heap_close(hdesc, AccessShareLock);
+
+		if (matches == 0)
+			elog(ERROR, "No operator with name %s", opr_name_or_oid);
+		else if (matches > 1)
+			elog(ERROR, "There is 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, "regoperin");
+	clist = OpernameGetCandidates(names, '\0');
+
+	if (clist == NULL)
+		elog(ERROR, "No operator with name %s", opr_name_or_oid);
+	else if (clist->next != NULL)
+		elog(ERROR, "There is more than one operator named %s",
+			 opr_name_or_oid);
+
+	result = clist->oid;
+
+	PG_RETURN_OID(result);
+}
+
+/*
+ * regoperout		- converts operator OID to "opr_name"
+ */
+Datum
+regoperout(PG_FUNCTION_ARGS)
+{
+	Oid			oprid = PG_GETARG_OID(0);
+	char	   *result;
+	HeapTuple	opertup;
+
+	if (oprid == InvalidOid)
+	{
+		result = pstrdup("0");
+		PG_RETURN_CSTRING(result);
+	}
+
+	opertup = SearchSysCache(OPEROID,
+							 ObjectIdGetDatum(oprid),
+							 0, 0, 0);
+
+	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(makeList1(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);
+}
+
+
+/*
+ * regoperatorin		- converts "oprname(args)" to operator OID
+ *
+ * We also accept a numeric OID, mostly for historical reasons.
+ *
+ * '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 = InvalidOid;
+	List	   *names;
+	int			nargs;
+	Oid			argtypes[FUNC_MAX_ARGS];
+	char		oprkind;
+	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))
+	{
+		Oid			searchOid;
+
+		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+									  CStringGetDatum(opr_name_or_oid)));
+		result = GetSysCacheOid(OPEROID,
+								ObjectIdGetDatum(searchOid),
+								0, 0, 0);
+		if (!OidIsValid(result))
+			elog(ERROR, "No operator with oid %s", 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, "regoperatorin", true,
+						 &names, &nargs, argtypes);
+	if (nargs == 1)
+		elog(ERROR, "regoperatorin: use NONE to denote the missing argument of a unary operator");
+	if (nargs != 2)
+		elog(ERROR, "regoperatorin: 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);
+
+	for (; clist; clist = clist->next)
+	{
+		if (memcmp(clist->args, argtypes, 2 * sizeof(Oid)) == 0)
+			break;
+	}
+
+	if (clist == NULL)
+		elog(ERROR, "No operator with name %s", opr_name_or_oid);
+
+	result = clist->oid;
+
+	PG_RETURN_OID(result);
+}
+
+/*
+ * regoperatorout		- converts operator OID to "opr_name(args)"
+ */
+Datum
+regoperatorout(PG_FUNCTION_ARGS)
+{
+	Oid			oprid = PG_GETARG_OID(0);
+	char	   *result;
+	HeapTuple	opertup;
+
+	if (oprid == InvalidOid)
+	{
+		result = pstrdup("0");
+		PG_RETURN_CSTRING(result);
+	}
+
+	opertup = SearchSysCache(OPEROID,
+							 ObjectIdGetDatum(oprid),
+							 0, 0, 0);
+
+	if (HeapTupleIsValid(opertup))
+	{
+		Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
+		char	   *oprname = NameStr(operform->oprname);
+		char	   *nspname;
+		FuncCandidateList clist;
+		StringInfoData buf;
+
+		/* XXX no support here for bootstrap mode */
+
+		/*
+		 * Would this oper be found (given the right args) by regoperatorin?
+		 * If not, we need to qualify it.
+		 */
+		clist = OpernameGetCandidates(makeList1(makeString(oprname)),
+									  operform->oprkind);
+
+		for (; clist; clist = clist->next)
+		{
+			if (clist->args[0] == operform->oprleft &&
+				clist->args[1] == operform->oprright)
+				break;
+		}
+
+		initStringInfo(&buf);
+
+		if (clist == NULL || clist->oid != oprid)
+		{
+			nspname = get_namespace_name(operform->oprnamespace);
+			appendStringInfo(&buf, "%s.",
+							 quote_identifier(nspname));
+		}
+
+		appendStringInfo(&buf, "%s(", oprname);
+
+		if (operform->oprleft)
+			appendStringInfo(&buf, "%s,",
+							 format_type_be(operform->oprleft));
+		else
+			appendStringInfo(&buf, "NONE,");
+
+		if (operform->oprright)
+			appendStringInfo(&buf, "%s)",
+							 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", oprid);
 	}
 
 	PG_RETURN_CSTRING(result);
 }
 
 
+/*
+ * regclassin		- converts "classname" to class OID
+ *
+ * We also accept a numeric OID, mostly for historical reasons.
+ *
+ * '-' 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;
+
+	/* '-' ? */
+	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))
+	{
+		Oid			searchOid;
+
+		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+									  CStringGetDatum(class_name_or_oid)));
+		result = GetSysCacheOid(RELOID,
+								ObjectIdGetDatum(searchOid),
+								0, 0, 0);
+		if (!OidIsValid(result))
+			elog(ERROR, "No class with oid %s", 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;
+
+		ScanKeyEntryInitialize(&skey[0], 0x0,
+							   (AttrNumber) Anum_pg_class_relname,
+							   (RegProcedure) F_NAMEEQ,
+							   CStringGetDatum(class_name_or_oid));
+
+		hdesc = heap_openr(RelationRelationName, AccessShareLock);
+		sysscan = systable_beginscan(hdesc, ClassNameNspIndex, true,
+									 SnapshotNow, 1, skey);
+
+		if (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
+			result = tuple->t_data->t_oid;
+		else
+			elog(ERROR, "No class with name %s", 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, "regclassin");
+
+	result = RangeVarGetRelid(makeRangeVarFromNameList(names), false);
+
+	PG_RETURN_OID(result);
+}
+
+/*
+ * regclassout		- converts class OID to "class_name"
+ */
+Datum
+regclassout(PG_FUNCTION_ARGS)
+{
+	Oid			classid = PG_GETARG_OID(0);
+	char	   *result;
+	HeapTuple	classtup;
+
+	if (classid == InvalidOid)
+	{
+		result = pstrdup("-");
+		PG_RETURN_CSTRING(result);
+	}
+
+	classtup = SearchSysCache(RELOID,
+							  ObjectIdGetDatum(classid),
+							  0, 0, 0);
+
+	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 (RelnameGetRelid(classname) == 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);
+}
+
+
+/*
+ * regtypein		- converts "typename" to type OID
+ *
+ * We also accept a numeric OID, mostly for historical reasons.
+ *
+ * '-' 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);
+
+	/* 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))
+	{
+		Oid			searchOid;
+
+		searchOid = DatumGetObjectId(DirectFunctionCall1(oidin,
+									  CStringGetDatum(typ_name_or_oid)));
+		result = GetSysCacheOid(TYPEOID,
+								ObjectIdGetDatum(searchOid),
+								0, 0, 0);
+		if (!OidIsValid(result))
+			elog(ERROR, "No type with oid %s", 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;
+
+		ScanKeyEntryInitialize(&skey[0], 0x0,
+							   (AttrNumber) Anum_pg_type_typname,
+							   (RegProcedure) F_NAMEEQ,
+							   CStringGetDatum(typ_name_or_oid));
+
+		hdesc = heap_openr(TypeRelationName, AccessShareLock);
+		sysscan = systable_beginscan(hdesc, TypeNameNspIndex, true,
+									 SnapshotNow, 1, skey);
+
+		if (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
+			result = tuple->t_data->t_oid;
+		else
+			elog(ERROR, "No type with name %s", 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);
+}
+
+/*
+ * regtypeout		- converts type OID to "typ_name"
+ */
+Datum
+regtypeout(PG_FUNCTION_ARGS)
+{
+	Oid			typid = PG_GETARG_OID(0);
+	char	   *result;
+	HeapTuple	typetup;
+
+	if (typid == InvalidOid)
+	{
+		result = pstrdup("-");
+		PG_RETURN_CSTRING(result);
+	}
+
+	typetup = SearchSysCache(TYPEOID,
+							 ObjectIdGetDatum(typid),
+							 0, 0, 0);
+
+	if (HeapTupleIsValid(typetup))
+	{
+		Form_pg_type typeform = (Form_pg_type) GETSTRUCT(typetup);
+		char	   *typname = NameStr(typeform->typname);
+
+		/*
+		 * 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())
+		{
+			result = pstrdup(typname);
+		}
+		else
+		{
+			char	   *nspname;
+
+			/*
+			 * Would this type be found by regtypein?
+			 * If not, qualify it.
+			 *
+			 * XXX shouldn't we use format_type instead?
+			 */
+			if (TypenameGetTypid(typname) == typid)
+				nspname = NULL;
+			else
+				nspname = get_namespace_name(typeform->typnamespace);
+
+			result = quote_qualified_identifier(nspname, typname);
+		}
+
+		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);
+}
+
 
 /*****************************************************************************
- *	 PUBLIC ROUTINES														 *
+ *	 SUPPORT ROUTINES														 *
  *****************************************************************************/
 
-/* regproctooid()
- * Lowercase version of RegprocToOid() to allow case-insensitive SQL.
- * Define RegprocToOid() as a macro in builtins.h.
- * Referenced in pg_proc.h. - tgl 97/04/26
+/*
+ * Given a C string, parse it into a qualified-name list.
  */
-Datum
-regproctooid(PG_FUNCTION_ARGS)
+static List *
+stringToQualifiedNameList(const char *string, const char *caller)
 {
-	RegProcedure rp = PG_GETARG_OID(0);
+	char	   *rawname;
+	List	   *result = NIL;
+	List	   *namelist;
+	List	   *l;
+
+	/* We need a modifiable copy of the input string. */
+	rawname = pstrdup(string);
+
+	if (!SplitIdentifierString(rawname, '.', &namelist))
+		elog(ERROR, "%s: invalid name syntax", caller);
+
+	if (namelist == NIL)
+		elog(ERROR, "%s: invalid name syntax", caller);
+
+	foreach(l, namelist)
+	{
+		char   *curname = (char *) lfirst(l);
 
-	PG_RETURN_OID((Oid) rp);
+		result = lappend(result, makeString(pstrdup(curname)));
+	}
+
+	pfree(rawname);
+	freeList(namelist);
+
+	return result;
 }
 
-/* (see int.c for comparison/operation 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.
+ *
+ * NONE is accepted as a placeholder for OID 0 if allow_none is true.
+ */
+static void
+parseNameAndArgTypes(const char *string, const char *caller, bool allow_none,
+					 List **names, int *nargs, Oid *argtypes)
+{
+	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')
+		elog(ERROR, "%s: expected a left parenthesis", caller);
+
+	/* Separate the name and parse it into a list */
+	*ptr++ = '\0';
+	*names = stringToQualifiedNameList(rawname, caller);
+
+	/* Check for the trailing right parenthesis and remove it */
+	ptr2 = ptr + strlen(ptr);
+	while (--ptr2 > ptr)
+	{
+		if (!isspace((unsigned char) *ptr2))
+			break;
+	}
+	if (*ptr2 != ')')
+		elog(ERROR, "%s: expected a right parenthesis", caller);
+	*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)
+				elog(ERROR, "%s: expected a type name", caller);
+			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)
+			elog(ERROR, "%s: improper type name", caller);
+		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 (allow_none && strcasecmp(typename, "none") == 0)
+		{
+			/* Report NONE as OID 0 */
+			typeid = InvalidOid;
+			typmod = -1;
+		}
+		else
+		{
+			/* Use full parser to resolve the type name */
+			parseTypeString(typename, &typeid, &typmod);
+		}
+		if (*nargs >= FUNC_MAX_ARGS)
+			elog(ERROR, "%s: too many argument datatypes", caller);
+		argtypes[*nargs] = typeid;
+		(*nargs)++;
+	}
+
+	pfree(rawname);
+}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index b99c886d8d1..580abead5d0 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -3,7 +3,7 @@
  *				back to source text
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.98 2002/04/19 23:13:54 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.99 2002/04/25 02:56:55 tgl Exp $
  *
  *	  This software is copyrighted by Jan Wieck - Hamburg.
  *
@@ -123,7 +123,7 @@ static void get_delete_query_def(Query *query, deparse_context *context);
 static void get_utility_query_def(Query *query, deparse_context *context);
 static void get_basic_select_query(Query *query, deparse_context *context);
 static void get_setop_query(Node *setOp, Query *query,
-				deparse_context *context, bool toplevel);
+							deparse_context *context);
 static void get_rule_sortgroupclause(SortClause *srt, List *tlist,
 						 bool force_colno,
 						 deparse_context *context);
@@ -142,7 +142,6 @@ static void get_from_clause_item(Node *jtnode, Query *query,
 static void get_opclass_name(Oid opclass, Oid actual_datatype,
 				 StringInfo buf);
 static bool tleIsArrayAssign(TargetEntry *tle);
-static char *quote_identifier(char *ident);
 static char *get_relid_attribute_name(Oid relid, AttrNumber attnum);
 
 #define only_marker(rte)  ((rte)->inh ? "" : "ONLY ")
@@ -1109,7 +1108,7 @@ get_select_query_def(Query *query, deparse_context *context)
 	 */
 	if (query->setOperations)
 	{
-		get_setop_query(query->setOperations, query, context, true);
+		get_setop_query(query->setOperations, query, context);
 		/* ORDER BY clauses must be simple in this case */
 		force_colno = true;
 	}
@@ -1266,8 +1265,7 @@ get_basic_select_query(Query *query, deparse_context *context)
 }
 
 static void
-get_setop_query(Node *setOp, Query *query, deparse_context *context,
-				bool toplevel)
+get_setop_query(Node *setOp, Query *query, deparse_context *context)
 {
 	StringInfo	buf = context->buf;
 
@@ -1284,33 +1282,29 @@ get_setop_query(Node *setOp, Query *query, deparse_context *context,
 	{
 		SetOperationStmt *op = (SetOperationStmt *) setOp;
 
-		/*
-		 * Must suppress parens at top level of a setop tree because of
-		 * grammar limitations...
-		 */
-		if (!toplevel)
-			appendStringInfo(buf, "(");
-		get_setop_query(op->larg, query, context, false);
+		appendStringInfo(buf, "((");
+		get_setop_query(op->larg, query, context);
 		switch (op->op)
 		{
 			case SETOP_UNION:
-				appendStringInfo(buf, " UNION ");
+				appendStringInfo(buf, ") UNION ");
 				break;
 			case SETOP_INTERSECT:
-				appendStringInfo(buf, " INTERSECT ");
+				appendStringInfo(buf, ") INTERSECT ");
 				break;
 			case SETOP_EXCEPT:
-				appendStringInfo(buf, " EXCEPT ");
+				appendStringInfo(buf, ") EXCEPT ");
 				break;
 			default:
 				elog(ERROR, "get_setop_query: unexpected set op %d",
 					 (int) op->op);
 		}
 		if (op->all)
-			appendStringInfo(buf, "ALL ");
-		get_setop_query(op->rarg, query, context, false);
-		if (!toplevel)
-			appendStringInfo(buf, ")");
+			appendStringInfo(buf, "ALL (");
+		else
+			appendStringInfo(buf, "(");
+		get_setop_query(op->rarg, query, context);
+		appendStringInfo(buf, "))");
 	}
 	else
 	{
@@ -2585,8 +2579,8 @@ tleIsArrayAssign(TargetEntry *tle)
  * space-wasteful but well worth it for notational simplicity.
  * ----------
  */
-static char *
-quote_identifier(char *ident)
+const char *
+quote_identifier(const char *ident)
 {
 	/*
 	 * Can avoid quoting if ident starts with a lowercase letter and
@@ -2603,7 +2597,7 @@ quote_identifier(char *ident)
 	safe = (ident[0] >= 'a' && ident[0] <= 'z');
 	if (safe)
 	{
-		char	   *ptr;
+		const char *ptr;
 
 		for (ptr = ident + 1; *ptr; ptr++)
 		{
@@ -2628,7 +2622,7 @@ quote_identifier(char *ident)
 		 * Note: ScanKeywordLookup() does case-insensitive comparison, but
 		 * that's fine, since we already know we have all-lower-case.
 		 */
-		if (ScanKeywordLookup(ident) != NULL)
+		if (ScanKeywordLookup((char *) ident) != NULL)
 			safe = false;
 	}
 
@@ -2641,6 +2635,26 @@ quote_identifier(char *ident)
 }
 
 /* ----------
+ * quote_qualified_identifier	- Quote a possibly-qualified identifier
+ *
+ * Return a name of the form namespace.ident, or just ident if namespace
+ * is NULL, quoting each component if necessary.  The result is palloc'd.
+ * ----------
+ */
+char *
+quote_qualified_identifier(const char *namespace,
+						   const char *ident)
+{
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+	if (namespace)
+		appendStringInfo(&buf, "%s.", quote_identifier(namespace));
+	appendStringInfo(&buf, "%s", quote_identifier(ident));
+	return buf.data;
+}
+
+/* ----------
  * get_relid_attribute_name
  *		Get an attribute name by its relations Oid and its attnum
  *
diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index d045705917d..8294612e137 100644
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -15,7 +15,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.109 2002/04/21 19:48:13 thomas Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.110 2002/04/25 02:56:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1991,6 +1991,11 @@ convert_to_scalar(Datum value, Oid valuetypid, double *scaledvalue,
 		case NUMERICOID:
 		case OIDOID:
 		case REGPROCOID:
+		case REGPROCEDUREOID:
+		case REGOPEROID:
+		case REGOPERATOROID:
+		case REGCLASSOID:
+		case REGTYPEOID:
 			*scaledvalue = convert_numeric_to_scalar(value, valuetypid);
 			*scaledlobound = convert_numeric_to_scalar(lobound, boundstypid);
 			*scaledhibound = convert_numeric_to_scalar(hibound, boundstypid);
@@ -2088,6 +2093,11 @@ convert_numeric_to_scalar(Datum value, Oid typid)
 												   value));
 		case OIDOID:
 		case REGPROCOID:
+		case REGPROCEDUREOID:
+		case REGOPEROID:
+		case REGOPERATOROID:
+		case REGCLASSOID:
+		case REGTYPEOID:
 			/* we can treat OIDs as integers... */
 			return (double) DatumGetObjectId(value);
 	}
diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c
index e7ac4b30b59..5c7aaf64b05 100644
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.84 2002/04/24 02:12:53 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.85 2002/04/25 02:56:56 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -21,6 +21,13 @@
 #include "utils/builtins.h"
 #include "utils/pg_locale.h"
 
+
+typedef struct varlena unknown;
+
+#define DatumGetUnknownP(X)			((unknown *) PG_DETOAST_DATUM(X))
+#define PG_GETARG_UNKNOWN_P(n)		DatumGetUnknownP(PG_GETARG_DATUM(n))
+#define PG_RETURN_UNKNOWN_P(x)		PG_RETURN_POINTER(x)
+
 static int	text_cmp(text *arg1, text *arg2);
 
 
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index efcb65dbfdf..a028d091c9b 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.94 2002/04/06 06:59:22 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.95 2002/04/25 02:56:56 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -136,8 +136,13 @@ GetCCHashFunc(Oid keytype)
 			return hashint4;
 		case TEXTOID:
 			return hashvarlena;
-		case REGPROCOID:
 		case OIDOID:
+		case REGPROCOID:
+		case REGPROCEDUREOID:
+		case REGOPEROID:
+		case REGOPERATOROID:
+		case REGCLASSOID:
+		case REGTYPEOID:
 			return hashoid;
 		case OIDVECTOROID:
 			return hashoidvector;