The contents of command.c, creatinh.c, define.c, remove.c and rename.c

have been divided according to the type of object manipulated - so ALTER
TABLE code is in tablecmds.c, aggregate commands in aggregatecmds.c and
so on.

A few common support routines remain in define.c (prototypes in
src/include/commands/defrem.h).

No code has been changed except for includes to reflect the new files.
The prototypes for aggregatecmds.c, functioncmds.c, operatorcmds.c,
and typecmds.c remain in src/include/commands/defrem.h.

From John Gray <jgray@azuli.co.uk>

src/backend/commands/Makefile

 #-------------------------------------------------------------------------
 #
 # Makefile--
-#    Makefile for commands
+#    Makefile for backend/commands
 #
 # IDENTIFICATION
-#    $Header: /cvsroot/pgsql/src/backend/commands/Makefile,v 1.27 2001/07/13 22:55:59 tgl Exp $
+#    $Header: /cvsroot/pgsql/src/backend/commands/Makefile,v 1.28 2002/04/15 05:22:03 tgl Exp $
 #
 #-------------------------------------------------------------------------
 
@@ -12,10 +12,11 @@ subdir = src/backend/commands
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = async.o creatinh.o command.o comment.o copy.o indexcmds.o define.o \
-       remove.o rename.o vacuum.o vacuumlazy.o analyze.o view.o cluster.o \
-       explain.o sequence.o trigger.o user.o proclang.o \
-       dbcommands.o variable.o
+OBJS = aggregatecmds.o analyze.o async.o cluster.o comment.o copy.o \
+	dbcommands.o define.o explain.o functioncmds.o \
+	indexcmds.o lockcmds.o operatorcmds.o portalcmds.o proclang.o \
+	schemacmds.o sequence.o tablecmds.o trigger.o typecmds.o user.o \
+	vacuum.o vacuumlazy.o variable.o view.o
 
 all: SUBSYS.o
 

src/backend/commands/aggregatecmds.c

+/*-------------------------------------------------------------------------
+ *
+ * aggregatecmds.c
+ *
+ *	  Routines for aggregate-manipulation commands
+ *
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/aggregatecmds.c,v 1.1 2002/04/15 05:22:03 tgl Exp $
+ *
+ * DESCRIPTION
+ *	  The "DefineFoo" routines take the parse tree and pick out the
+ *	  appropriate arguments/flags, passing the results to the
+ *	  corresponding "FooDefine" routines (in src/catalog) that do
+ *	  the actual catalog-munging.  These routines also verify permission
+ *	  of the user to execute the command.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/catname.h"
+#include "catalog/namespace.h"
+#include "catalog/pg_aggregate.h"
+#include "commands/comment.h"
+#include "commands/defrem.h"
+#include "miscadmin.h"
+#include "parser/parse_func.h"
+#include "parser/parse_type.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+
+/*
+ *	DefineAggregate
+ */
+void
+DefineAggregate(List *names, List *parameters)
+{
+	char	   *aggName;
+	Oid			aggNamespace;
+	List	   *transfuncName = NIL;
+	List	   *finalfuncName = NIL;
+	TypeName   *baseType = NULL;
+	TypeName   *transType = NULL;
+	char	   *initval = NULL;
+	Oid			baseTypeId;
+	Oid			transTypeId;
+	List	   *pl;
+
+	/* Convert list of names to a name and namespace */
+	aggNamespace = QualifiedNameGetCreationNamespace(names, &aggName);
+
+	foreach(pl, parameters)
+	{
+		DefElem    *defel = (DefElem *) lfirst(pl);
+
+		/*
+		 * sfunc1, stype1, and initcond1 are accepted as obsolete
+		 * spellings for sfunc, stype, initcond.
+		 */
+		if (strcasecmp(defel->defname, "sfunc") == 0)
+			transfuncName = defGetQualifiedName(defel);
+		else if (strcasecmp(defel->defname, "sfunc1") == 0)
+			transfuncName = defGetQualifiedName(defel);
+		else if (strcasecmp(defel->defname, "finalfunc") == 0)
+			finalfuncName = defGetQualifiedName(defel);
+		else if (strcasecmp(defel->defname, "basetype") == 0)
+			baseType = defGetTypeName(defel);
+		else if (strcasecmp(defel->defname, "stype") == 0)
+			transType = defGetTypeName(defel);
+		else if (strcasecmp(defel->defname, "stype1") == 0)
+			transType = defGetTypeName(defel);
+		else if (strcasecmp(defel->defname, "initcond") == 0)
+			initval = defGetString(defel);
+		else if (strcasecmp(defel->defname, "initcond1") == 0)
+			initval = defGetString(defel);
+		else
+			elog(WARNING, "DefineAggregate: attribute \"%s\" not recognized",
+				 defel->defname);
+	}
+
+	/*
+	 * make sure we have our required definitions
+	 */
+	if (baseType == NULL)
+		elog(ERROR, "Define: \"basetype\" unspecified");
+	if (transType == NULL)
+		elog(ERROR, "Define: \"stype\" unspecified");
+	if (transfuncName == NIL)
+		elog(ERROR, "Define: \"sfunc\" unspecified");
+
+	/*
+	 * Handle the aggregate's base type (input data type).  This can be
+	 * specified as 'ANY' for a data-independent transition function, such
+	 * as COUNT(*).
+	 */
+	baseTypeId = LookupTypeName(baseType);
+	if (OidIsValid(baseTypeId))
+	{
+		/* no need to allow aggregates on as-yet-undefined types */
+		if (!get_typisdefined(baseTypeId))
+			elog(ERROR, "Type \"%s\" is only a shell",
+				 TypeNameToString(baseType));
+	}
+	else
+	{
+		char      *typnam = TypeNameToString(baseType);
+
+		if (strcasecmp(typnam, "ANY") != 0)
+			elog(ERROR, "Type \"%s\" does not exist", typnam);
+		baseTypeId = InvalidOid;
+	}
+
+	/* handle transtype --- no special cases here */
+	transTypeId = typenameTypeId(transType);
+
+	/*
+	 * Most of the argument-checking is done inside of AggregateCreate
+	 */
+	AggregateCreate(aggName,	/* aggregate name */
+					aggNamespace,	/* namespace */
+					transfuncName,		/* step function name */
+					finalfuncName,		/* final function name */
+					baseTypeId,	/* type of data being aggregated */
+					transTypeId,	/* transition data type */
+					initval);	/* initial condition */
+}
+
+
+void
+RemoveAggregate(List *aggName, TypeName *aggType)
+{
+	Relation	relation;
+	HeapTuple	tup;
+	Oid			basetypeID;
+	Oid			procOid;
+
+	/*
+	 * if a basetype is passed in, then attempt to find an aggregate for
+	 * that specific type.
+	 *
+	 * else if the basetype is blank, then attempt to find an aggregate with
+	 * a basetype of zero.	This is valid. It means that the aggregate is
+	 * to apply to all basetypes (eg, COUNT).
+	 */
+	if (aggType)
+		basetypeID = typenameTypeId(aggType);
+	else
+		basetypeID = InvalidOid;
+
+	procOid = find_aggregate_func("RemoveAggregate", aggName, basetypeID);
+
+	/* Permission check */
+
+	if (!pg_proc_ownercheck(procOid, GetUserId()))
+	{
+		if (basetypeID == InvalidOid)
+			elog(ERROR, "RemoveAggregate: aggregate %s for all types: permission denied",
+				 NameListToString(aggName));
+		else
+			elog(ERROR, "RemoveAggregate: aggregate %s for type %s: permission denied",
+				 NameListToString(aggName), format_type_be(basetypeID));
+	}
+
+	/* Remove the pg_proc tuple */
+
+	relation = heap_openr(ProcedureRelationName, RowExclusiveLock);
+
+	tup = SearchSysCache(PROCOID,
+						 ObjectIdGetDatum(procOid),
+						 0, 0, 0);
+	if (!HeapTupleIsValid(tup))	/* should not happen */
+		elog(ERROR, "RemoveAggregate: couldn't find pg_proc tuple for %s",
+			 NameListToString(aggName));
+
+	/* Delete any comments associated with this function */
+	DeleteComments(procOid, RelationGetRelid(relation));
+
+	simple_heap_delete(relation, &tup->t_self);
+
+	ReleaseSysCache(tup);
+
+	heap_close(relation, RowExclusiveLock);
+
+	/* Remove the pg_aggregate tuple */
+
+	relation = heap_openr(AggregateRelationName, RowExclusiveLock);
+
+	tup = SearchSysCache(AGGFNOID,
+						 ObjectIdGetDatum(procOid),
+						 0, 0, 0);
+	if (!HeapTupleIsValid(tup))	/* should not happen */
+		elog(ERROR, "RemoveAggregate: couldn't find pg_aggregate tuple for %s",
+			 NameListToString(aggName));
+
+	simple_heap_delete(relation, &tup->t_self);
+
+	ReleaseSysCache(tup);
+
+	heap_close(relation, RowExclusiveLock);
+}

src/backend/commands/cluster.c

@@ -15,7 +15,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.77 2002/03/31 07:49:30 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.78 2002/04/15 05:22:03 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -29,8 +29,7 @@
 #include "catalog/pg_index.h"
 #include "catalog/pg_proc.h"
 #include "commands/cluster.h"
-#include "commands/command.h"
-#include "commands/rename.h"
+#include "commands/tablecmds.h"
 #include "miscadmin.h"
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"

src/backend/commands/lockcmds.c

+/*-------------------------------------------------------------------------
+ *
+ * lockcmds.c
+ *	  Lock command support code
+ *
+ * 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/commands/lockcmds.c,v 1.1 2002/04/15 05:22:03 tgl Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/namespace.h"
+#include "commands/lockcmds.h"
+#include "miscadmin.h"
+#include "utils/acl.h"
+
+
+/*
+ * LOCK TABLE
+ */
+void
+LockTableCommand(LockStmt *lockstmt)
+{
+	List	   *p;
+
+	/*
+	 * Iterate over the list and open, lock, and close the relations one
+	 * at a time
+	 */
+
+	foreach(p, lockstmt->relations)
+	{
+		RangeVar   *relation = lfirst(p);
+		Oid			reloid;
+		int32		aclresult;
+		Relation	rel;
+
+		/*
+		 * We don't want to open the relation until we've checked privilege.
+		 * So, manually get the relation OID.
+		 */
+		reloid = RangeVarGetRelid(relation, false);
+
+		if (lockstmt->mode == AccessShareLock)
+			aclresult = pg_class_aclcheck(reloid, GetUserId(),
+										  ACL_SELECT);
+		else
+			aclresult = pg_class_aclcheck(reloid, GetUserId(),
+										  ACL_UPDATE | ACL_DELETE);
+
+		if (aclresult != ACLCHECK_OK)
+			elog(ERROR, "LOCK TABLE: permission denied");
+
+		rel = relation_open(reloid, lockstmt->mode);
+
+		/* Currently, we only allow plain tables to be locked */
+		if (rel->rd_rel->relkind != RELKIND_RELATION)
+			elog(ERROR, "LOCK TABLE: %s is not a table",
+				 relation->relname);
+
+		relation_close(rel, NoLock);	/* close rel, keep lock */
+	}
+}

src/backend/commands/operatorcmds.c

+/*-------------------------------------------------------------------------
+ *
+ * operatorcmds.c
+ *
+ *	  Routines for operator manipulation commands
+ *
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/operatorcmds.c,v 1.1 2002/04/15 05:22:03 tgl Exp $
+ *
+ * DESCRIPTION
+ *	  The "DefineFoo" routines take the parse tree and pick out the
+ *	  appropriate arguments/flags, passing the results to the
+ *	  corresponding "FooDefine" routines (in src/catalog) that do
+ *	  the actual catalog-munging.  These routines also verify permission
+ *	  of the user to execute the command.
+ *
+ * NOTES
+ *	  These things must be defined and committed in the following order:
+ *		"create function":
+ *				input/output, recv/send procedures
+ *		"create type":
+ *				type
+ *		"create operator":
+ *				operators
+ *
+ *		Most of the parse-tree manipulation routines are defined in
+ *		commands/manip.c.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/heapam.h"
+#include "catalog/catname.h"
+#include "catalog/namespace.h"
+#include "catalog/pg_operator.h"
+#include "commands/comment.h"
+#include "commands/defrem.h"
+#include "miscadmin.h"
+#include "parser/parse_type.h"
+#include "utils/acl.h"
+#include "utils/syscache.h"
+
+
+/*
+ * DefineOperator
+ *		this function extracts all the information from the
+ *		parameter list generated by the parser and then has
+ *		OperatorCreate() do all the actual work.
+ *
+ * 'parameters' is a list of DefElem
+ */
+void
+DefineOperator(List *names, List *parameters)
+{
+	char	   *oprName;
+	Oid			oprNamespace;
+	uint16		precedence = 0; /* operator precedence */
+	bool		canHash = false;	/* operator hashes */
+	bool		isLeftAssociative = true;		/* operator is left
+												 * associative */
+	char	   *functionName = NULL;	/* function for operator */
+	TypeName   *typeName1 = NULL;		/* first type name */
+	TypeName   *typeName2 = NULL;		/* second type name */
+	Oid			typeId1 = InvalidOid;	/* types converted to OID */
+	Oid			typeId2 = InvalidOid;
+	char	   *commutatorName = NULL;	/* optional commutator operator
+										 * name */
+	char	   *negatorName = NULL;		/* optional negator operator name */
+	char	   *restrictionName = NULL; /* optional restrict. sel.
+										 * procedure */
+	char	   *joinName = NULL;	/* optional join sel. procedure name */
+	char	   *sortName1 = NULL;		/* optional first sort operator */
+	char	   *sortName2 = NULL;		/* optional second sort operator */
+	List	   *pl;
+
+	/* Convert list of names to a name and namespace */
+	oprNamespace = QualifiedNameGetCreationNamespace(names, &oprName);
+
+	/*
+	 * loop over the definition list and extract the information we need.
+	 */
+	foreach(pl, parameters)
+	{
+		DefElem    *defel = (DefElem *) lfirst(pl);
+
+		if (strcasecmp(defel->defname, "leftarg") == 0)
+		{
+			typeName1 = defGetTypeName(defel);
+			if (typeName1->setof)
+				elog(ERROR, "setof type not implemented for leftarg");
+		}
+		else if (strcasecmp(defel->defname, "rightarg") == 0)
+		{
+			typeName2 = defGetTypeName(defel);
+			if (typeName2->setof)
+				elog(ERROR, "setof type not implemented for rightarg");
+		}
+		else if (strcasecmp(defel->defname, "procedure") == 0)
+			functionName = defGetString(defel);
+		else if (strcasecmp(defel->defname, "precedence") == 0)
+		{
+			/* NOT IMPLEMENTED (never worked in v4.2) */
+			elog(NOTICE, "CREATE OPERATOR: precedence not implemented");
+		}
+		else if (strcasecmp(defel->defname, "associativity") == 0)
+		{
+			/* NOT IMPLEMENTED (never worked in v4.2) */
+			elog(NOTICE, "CREATE OPERATOR: associativity not implemented");
+		}
+		else if (strcasecmp(defel->defname, "commutator") == 0)
+			commutatorName = defGetString(defel);
+		else if (strcasecmp(defel->defname, "negator") == 0)
+			negatorName = defGetString(defel);
+		else if (strcasecmp(defel->defname, "restrict") == 0)
+			restrictionName = defGetString(defel);
+		else if (strcasecmp(defel->defname, "join") == 0)
+			joinName = defGetString(defel);
+		else if (strcasecmp(defel->defname, "hashes") == 0)
+			canHash = TRUE;
+		else if (strcasecmp(defel->defname, "sort1") == 0)
+			sortName1 = defGetString(defel);
+		else if (strcasecmp(defel->defname, "sort2") == 0)
+			sortName2 = defGetString(defel);
+		else
+		{
+			elog(WARNING, "DefineOperator: attribute \"%s\" not recognized",
+				 defel->defname);
+		}
+	}
+
+	/*
+	 * make sure we have our required definitions
+	 */
+	if (functionName == NULL)
+		elog(ERROR, "Define: \"procedure\" unspecified");
+
+	/* Transform type names to type OIDs */
+	if (typeName1)
+		typeId1 = typenameTypeId(typeName1);
+	if (typeName2)
+		typeId2 = typenameTypeId(typeName2);
+
+	/*
+	 * now have OperatorCreate do all the work..
+	 */
+	OperatorCreate(oprName,		/* operator name */
+				   typeId1,		/* left type id */
+				   typeId2,		/* right type id */
+				   functionName,	/* function for operator */
+				   precedence,	/* operator precedence */
+				   isLeftAssociative,	/* operator is left associative */
+				   commutatorName,		/* optional commutator operator
+										 * name */
+				   negatorName, /* optional negator operator name */
+				   restrictionName,		/* optional restrict. sel.
+										 * procedure */
+				   joinName,	/* optional join sel. procedure name */
+				   canHash,		/* operator hashes */
+				   sortName1,	/* optional first sort operator */
+				   sortName2);	/* optional second sort operator */
+
+}
+
+
+/*
+ * RemoveOperator
+ *		Deletes an operator.
+ *
+ * Exceptions:
+ *		BadArg if name is invalid.
+ *		BadArg if type1 is invalid.
+ *		"ERROR" if operator nonexistent.
+ *		...
+ */
+void
+RemoveOperator(char *operatorName,		/* operator name */
+			   TypeName *typeName1, /* left argument type name */
+			   TypeName *typeName2) /* right argument type name */
+{
+	Relation	relation;
+	HeapTuple	tup;
+	Oid			typeId1 = InvalidOid;
+	Oid			typeId2 = InvalidOid;
+	char		oprtype;
+
+	if (typeName1)
+		typeId1 = typenameTypeId(typeName1);
+
+	if (typeName2)
+		typeId2 = typenameTypeId(typeName2);
+
+	if (OidIsValid(typeId1) && OidIsValid(typeId2))
+		oprtype = 'b';
+	else if (OidIsValid(typeId1))
+		oprtype = 'r';
+	else
+		oprtype = 'l';
+
+	relation = heap_openr(OperatorRelationName, RowExclusiveLock);
+
+	tup = SearchSysCacheCopy(OPERNAME,
+							 PointerGetDatum(operatorName),
+							 ObjectIdGetDatum(typeId1),
+							 ObjectIdGetDatum(typeId2),
+							 CharGetDatum(oprtype));
+
+	if (HeapTupleIsValid(tup))
+	{
+		if (!pg_oper_ownercheck(tup->t_data->t_oid, GetUserId()))
+			elog(ERROR, "RemoveOperator: operator '%s': permission denied",
+				 operatorName);
+
+		/* Delete any comments associated with this operator */
+		DeleteComments(tup->t_data->t_oid, RelationGetRelid(relation));
+
+		simple_heap_delete(relation, &tup->t_self);
+	}
+	else
+	{
+		if (OidIsValid(typeId1) && OidIsValid(typeId2))
+		{
+			elog(ERROR, "RemoveOperator: binary operator '%s' taking '%s' and '%s' does not exist",
+				 operatorName,
+				 TypeNameToString(typeName1),
+				 TypeNameToString(typeName2));
+		}
+		else if (OidIsValid(typeId1))
+		{
+			elog(ERROR, "RemoveOperator: right unary operator '%s' taking '%s' does not exist",
+				 operatorName,
+				 TypeNameToString(typeName1));
+		}
+		else
+		{
+			elog(ERROR, "RemoveOperator: left unary operator '%s' taking '%s' does not exist",
+				 operatorName,
+				 TypeNameToString(typeName2));
+		}
+	}
+	heap_freetuple(tup);
+	heap_close(relation, RowExclusiveLock);
+}

src/backend/commands/portalcmds.c

+/*-------------------------------------------------------------------------
+ *
+ * portalcmds.c
+ *	  portal support code
+ *
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/portalcmds.c,v 1.1 2002/04/15 05:22:03 tgl Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "commands/portalcmds.h"
+#include "executor/executor.h"
+
+
+/*
+ * PortalCleanup
+ */
+void
+PortalCleanup(Portal portal)
+{
+	MemoryContext oldcontext;
+
+	/*
+	 * sanity checks
+	 */
+	AssertArg(PortalIsValid(portal));
+	AssertArg(portal->cleanup == PortalCleanup);
+
+	/*
+	 * set proper portal-executor context before calling ExecMain.
+	 */
+	oldcontext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
+
+	/*
+	 * tell the executor to shutdown the query
+	 */
+	ExecutorEnd(PortalGetQueryDesc(portal), PortalGetState(portal));
+
+	/*
+	 * switch back to previous context
+	 */
+	MemoryContextSwitchTo(oldcontext);
+}
+
+
+/*
+ * PerformPortalFetch
+ *
+ *	name: name of portal
+ *	forward: forward or backward fetch?
+ *	count: # of tuples to fetch (0 implies all)
+ *	dest: where to send results
+ *	completionTag: points to a buffer of size COMPLETION_TAG_BUFSIZE
+ *		in which to store a command completion status string.
+ *
+ * completionTag may be NULL if caller doesn't want a status string.
+ */
+void
+PerformPortalFetch(char *name,
+				   bool forward,
+				   int count,
+				   CommandDest dest,
+				   char *completionTag)
+{
+	Portal		portal;
+	QueryDesc  *queryDesc;
+	EState	   *estate;
+	MemoryContext oldcontext;
+	ScanDirection direction;
+	CommandId	savedId;
+	bool		temp_desc = false;
+
+	/* initialize completion status in case of early exit */
+	if (completionTag)
+		strcpy(completionTag, (dest == None) ? "MOVE 0" : "FETCH 0");
+
+	/*
+	 * sanity checks
+	 */
+	if (name == NULL)
+	{
+		elog(WARNING, "PerformPortalFetch: missing portal name");
+		return;
+	}
+
+	/*
+	 * get the portal from the portal name
+	 */
+	portal = GetPortalByName(name);
+	if (!PortalIsValid(portal))
+	{
+		elog(WARNING, "PerformPortalFetch: portal \"%s\" not found",
+			 name);
+		return;
+	}
+
+	/*
+	 * switch into the portal context
+	 */
+	oldcontext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
+
+	queryDesc = PortalGetQueryDesc(portal);
+	estate = PortalGetState(portal);
+
+	/*
+	 * If the requested destination is not the same as the query's
+	 * original destination, make a temporary QueryDesc with the proper
+	 * destination.  This supports MOVE, for example, which will pass in
+	 * dest = None.
+	 *
+	 * EXCEPTION: if the query's original dest is RemoteInternal (ie, it's a
+	 * binary cursor) and the request is Remote, we do NOT override the
+	 * original dest.  This is necessary since a FETCH command will pass
+	 * dest = Remote, not knowing whether the cursor is binary or not.
+	 */
+	if (dest != queryDesc->dest &&
+		!(queryDesc->dest == RemoteInternal && dest == Remote))
+	{
+		QueryDesc  *qdesc = (QueryDesc *) palloc(sizeof(QueryDesc));
+
+		memcpy(qdesc, queryDesc, sizeof(QueryDesc));
+		qdesc->dest = dest;
+		queryDesc = qdesc;
+		temp_desc = true;
+	}
+
+	/*
+	 * Restore the scanCommandId that was current when the cursor was
+	 * opened.  This ensures that we see the same tuples throughout the
+	 * execution of the cursor.
+	 */
+	savedId = GetScanCommandId();
+	SetScanCommandId(PortalGetCommandId(portal));
+
+	/*
+	 * Determine which direction to go in, and check to see if we're
+	 * already at the end of the available tuples in that direction.  If
+	 * so, set the direction to NoMovement to avoid trying to fetch any
+	 * tuples.  (This check exists because not all plan node types
+	 * are robust about being called again if they've already returned
+	 * NULL once.)  Then call the executor (we must not skip this, because
+	 * the destination needs to see a setup and shutdown even if no tuples
+	 * are available).  Finally, update the atStart/atEnd state depending
+	 * on the number of tuples that were retrieved.
+	 */
+	if (forward)
+	{
+		if (portal->atEnd)
+			direction = NoMovementScanDirection;
+		else
+			direction = ForwardScanDirection;
+
+		ExecutorRun(queryDesc, estate, direction, (long) count);
+
+		if (estate->es_processed > 0)
+			portal->atStart = false; /* OK to back up now */
+		if (count <= 0 || (int) estate->es_processed < count)
+			portal->atEnd = true;	/* we retrieved 'em all */
+	}
+	else
+	{
+		if (portal->atStart)
+			direction = NoMovementScanDirection;
+		else
+			direction = BackwardScanDirection;
+
+		ExecutorRun(queryDesc, estate, direction, (long) count);
+
+		if (estate->es_processed > 0)
+			portal->atEnd = false;	/* OK to go forward now */
+		if (count <= 0 || (int) estate->es_processed < count)
+			portal->atStart = true; /* we retrieved 'em all */
+	}
+
+	/* Return command status if wanted */
+	if (completionTag)
+		snprintf(completionTag, COMPLETION_TAG_BUFSIZE, "%s %u",
+				 (dest == None) ? "MOVE" : "FETCH",
+				 estate->es_processed);
+
+	/*
+	 * Restore outer command ID.
+	 */
+	SetScanCommandId(savedId);
+
+	/*
+	 * Clean up and switch back to old context.
+	 */
+	if (temp_desc)
+		pfree(queryDesc);
+
+	MemoryContextSwitchTo(oldcontext);
+}
+
+/*
+ * PerformPortalClose
+ */
+void
+PerformPortalClose(char *name, CommandDest dest)
+{
+	Portal		portal;
+
+	/*
+	 * sanity checks
+	 */
+	if (name == NULL)
+	{
+		elog(WARNING, "PerformPortalClose: missing portal name");
+		return;
+	}
+
+	/*
+	 * get the portal from the portal name
+	 */
+	portal = GetPortalByName(name);
+	if (!PortalIsValid(portal))
+	{
+		elog(WARNING, "PerformPortalClose: portal \"%s\" not found",
+			 name);
+		return;
+	}
+
+	/*
+	 * Note: PortalCleanup is called as a side-effect
+	 */
+	PortalDrop(portal);
+}

src/backend/commands/proclang.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/proclang.c,v 1.30 2002/04/09 20:35:48 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/proclang.c,v 1.31 2002/04/15 05:22:03 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -22,6 +22,7 @@
 #include "catalog/pg_language.h"
 #include "catalog/pg_proc.h"
 #include "commands/proclang.h"
+#include "commands/defrem.h"
 #include "fmgr.h"
 #include "miscadmin.h"
 #include "parser/parse_func.h"
@@ -30,21 +31,6 @@
 #include "utils/syscache.h"
 
 
-/*
- * Translate the input language name to lower case.
- */
-static void
-case_translate_language_name(const char *input, char *output)
-{
-	int			i;
-
-	for (i = 0; i < NAMEDATALEN && input[i]; ++i)
-		output[i] = tolower((unsigned char) input[i]);
-
-	output[i] = '\0';
-}
-
-
 /* ---------------------------------------------------------------------
  * CREATE PROCEDURAL LANGUAGE
  * ---------------------------------------------------------------------

src/backend/commands/schemacmds.c

+/*-------------------------------------------------------------------------
+ *
+ * schemacmds.c
+ *	  schema creation command support code
+ *
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/schemacmds.c,v 1.1 2002/04/15 05:22:03 tgl Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "catalog/catalog.h"
+#include "catalog/pg_namespace.h"
+#include "commands/schemacmds.h"
+#include "miscadmin.h"
+#include "parser/analyze.h"
+#include "tcop/utility.h"
+#include "utils/lsyscache.h"
+
+
+/*
+ * CREATE SCHEMA
+ */
+void
+CreateSchemaCommand(CreateSchemaStmt *stmt)
+{
+	const char *schemaName = stmt->schemaname;
+	const char *authId = stmt->authid;
+	List	   *parsetree_list;
+	List	   *parsetree_item;
+	const char *owner_name;
+	Oid			owner_userid;
+	Oid			saved_userid;
+
+	saved_userid = GetUserId();
+
+	if (!authId)
+	{
+		owner_userid = saved_userid;
+		owner_name = GetUserName(owner_userid);
+	}
+	else if (superuser())
+	{
+		owner_name = authId;
+		/* The following will error out if user does not exist */
+		owner_userid = get_usesysid(owner_name);
+		/*
+		 * Set the current user to the requested authorization so
+		 * that objects created in the statement have the requested
+		 * owner.  (This will revert to session user on error or at
+		 * the end of this routine.)
+		 */
+		SetUserId(owner_userid);
+	}
+	else /* not superuser */
+	{
+		owner_userid = saved_userid;
+		owner_name = GetUserName(owner_userid);
+		if (strcmp(authId, owner_name) != 0)
+			elog(ERROR, "CREATE SCHEMA: permission denied"
+				 "\n\t\"%s\" is not a superuser, so cannot create a schema for \"%s\"",
+				 owner_name, authId);
+	}
+
+	if (!allowSystemTableMods && IsReservedName(schemaName))
+		elog(ERROR, "CREATE SCHEMA: Illegal schema name: \"%s\" -- pg_ is reserved for system schemas",
+			 schemaName);
+
+	/* Create the schema's namespace */
+	NamespaceCreate(schemaName, owner_userid);
+
+	/* Let commands in the schema-element-list know about the schema */
+	CommandCounterIncrement();
+
+	/*
+	 * Examine the list of commands embedded in the CREATE SCHEMA command,
+	 * and reorganize them into a sequentially executable order with no
+	 * forward references.  Note that the result is still a list of raw
+	 * parsetrees in need of parse analysis --- we cannot, in general,
+	 * run analyze.c on one statement until we have actually executed the
+	 * prior ones.
+	 */
+	parsetree_list = analyzeCreateSchemaStmt(stmt);
+
+	/*
+	 * Analyze and execute each command contained in the CREATE SCHEMA
+	 */
+	foreach(parsetree_item, parsetree_list)
+	{
+		Node	   *parsetree = (Node *) lfirst(parsetree_item);
+		List	   *querytree_list,
+				   *querytree_item;
+
+		querytree_list = parse_analyze(parsetree, NULL);
+
+		foreach(querytree_item, querytree_list)
+		{
+			Query	   *querytree = (Query *) lfirst(querytree_item);
+
+			/* schemas should contain only utility stmts */
+			Assert(querytree->commandType == CMD_UTILITY);
+			/* do this step */
+			ProcessUtility(querytree->utilityStmt, None, NULL);
+			/* make sure later steps can see the object created here */
+			CommandCounterIncrement();
+		}
+	}
+
+	/* Reset current user */
+	SetUserId(saved_userid);
+}

src/backend/commands/sequence.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.76 2002/03/30 01:02:41 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.77 2002/04/15 05:22:03 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -17,7 +17,7 @@
 #include "access/heapam.h"
 #include "catalog/namespace.h"
 #include "catalog/pg_type.h"
-#include "commands/creatinh.h"
+#include "commands/tablecmds.h"
 #include "commands/sequence.h"
 #include "miscadmin.h"
 #include "utils/acl.h"

src/backend/commands/view.c

@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Id: view.c,v 1.61 2002/03/29 19:06:08 tgl Exp $
+ *	$Id: view.c,v 1.62 2002/04/15 05:22:03 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -15,7 +15,7 @@
 #include "access/xact.h"
 #include "catalog/heap.h"
 #include "catalog/namespace.h"
-#include "commands/creatinh.h"
+#include "commands/tablecmds.h"
 #include "commands/view.h"
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"

src/backend/executor/execMain.c

@@ -27,7 +27,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.157 2002/04/08 22:42:18 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.158 2002/04/15 05:22:04 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -36,7 +36,7 @@
 #include "access/heapam.h"
 #include "catalog/heap.h"
 #include "catalog/namespace.h"
-#include "commands/command.h"
+#include "commands/tablecmds.h"
 #include "commands/trigger.h"
 #include "executor/execdebug.h"
 #include "executor/execdefs.h"

src/backend/executor/spi.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.68 2002/03/21 16:00:38 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/spi.c,v 1.69 2002/04/15 05:22:04 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -16,7 +16,7 @@
 
 #include "access/printtup.h"
 #include "catalog/heap.h"
-#include "commands/command.h"
+#include "commands/portalcmds.h"
 #include "executor/spi_priv.h"
 #include "tcop/tcopprot.h"
 #include "utils/lsyscache.h"

src/backend/tcop/pquery.c

@@ -8,14 +8,14 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.51 2002/03/21 16:01:27 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.52 2002/04/15 05:22:04 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 
 #include "postgres.h"
 
-#include "commands/command.h"
+#include "commands/portalcmds.h"
 #include "executor/execdefs.h"
 #include "executor/executor.h"
 #include "tcop/pquery.h"

src/backend/tcop/utility.c

@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.148 2002/04/12 20:38:27 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.149 2002/04/15 05:22:04 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -22,16 +22,17 @@
 #include "catalog/pg_shadow.h"
 #include "commands/async.h"
 #include "commands/cluster.h"
-#include "commands/command.h"
 #include "commands/comment.h"
 #include "commands/copy.h"
-#include "commands/creatinh.h"
 #include "commands/dbcommands.h"
 #include "commands/defrem.h"
 #include "commands/explain.h"
+#include "commands/lockcmds.h"
+#include "commands/portalcmds.h"
 #include "commands/proclang.h"
-#include "commands/rename.h"
+#include "commands/schemacmds.h"
 #include "commands/sequence.h"
+#include "commands/tablecmds.h"
 #include "commands/trigger.h"
 #include "commands/user.h"
 #include "commands/vacuum.h"

src/include/commands/defrem.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: defrem.h,v 1.34 2002/04/09 20:35:54 tgl Exp $
+ * $Id: defrem.h,v 1.35 2002/04/15 05:22:03 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -16,6 +16,8 @@
 
 #include "nodes/parsenodes.h"
 
+#define DEFAULT_TYPDELIM		','
+
 /*
  * prototypes in indexcmds.c
  */
@@ -33,22 +35,33 @@ extern void ReindexTable(RangeVar *relation, bool force);
 extern void ReindexDatabase(const char *databaseName, bool force, bool all);
 
 /*
- * prototypes in define.c
+ * DefineFoo and RemoveFoo are now both in foocmds.c
  */
+
 extern void CreateFunction(ProcedureStmt *stmt);
+extern void RemoveFunction(List *functionName, List *argTypes);
+
 extern void DefineOperator(List *names, List *parameters);
+extern void RemoveOperator(char *operatorName,
+						   TypeName *typeName1, TypeName *typeName2);
+
 extern void DefineAggregate(List *names, List *parameters);
+extern void RemoveAggregate(List *aggName, TypeName *aggType);
+
 extern void DefineType(List *names, List *parameters);
+extern void RemoveType(List *names);
 extern void DefineDomain(CreateDomainStmt *stmt);
-
-/*
- * prototypes in remove.c
- */
 extern void RemoveDomain(List *names, int behavior);
-extern void RemoveFunction(List *functionName, List *argTypes);
-extern void RemoveOperator(char *operatorName,
-			   TypeName *typeName1, TypeName *typeName2);
-extern void RemoveType(List *names);
-extern void RemoveAggregate(List *aggName, TypeName *aggType);
+
+
+/* support routines in define.c */
+
+extern void case_translate_language_name(const char *input, char *output);
+
+extern char *defGetString(DefElem *def);
+extern double defGetNumeric(DefElem *def);
+extern List *defGetQualifiedName(DefElem *def);
+extern TypeName *defGetTypeName(DefElem *def);
+extern int	defGetTypeLength(DefElem *def);
 
 #endif   /* DEFREM_H */

src/include/commands/creatinh.h → src/include/commands/lockcmds.h

 /*-------------------------------------------------------------------------
  *
- * creatinh.h
- *	  prototypes for creatinh.c.
+ * lockcmds.h
+ *	  prototypes for lockcmds.c.
  *
  *
- * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: creatinh.h,v 1.20 2002/03/29 19:06:22 tgl Exp $
+ * $Id: lockcmds.h,v 1.1 2002/04/15 05:22:03 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-#ifndef CREATINH_H
-#define CREATINH_H
+#ifndef LOCKCMDS_H
+#define LOCKCMDS_H
 
 #include "nodes/parsenodes.h"
 
-extern Oid	DefineRelation(CreateStmt *stmt, char relkind);
-extern void RemoveRelation(const RangeVar *relation);
-extern void TruncateRelation(const RangeVar *relation);
+/*
+ * LOCK
+ */
+extern void LockTableCommand(LockStmt *lockstmt);
 
-#endif   /* CREATINH_H */
+#endif  /* LOCKCMDS_H */

src/include/commands/command.h → src/include/commands/portalcmds.h

 /*-------------------------------------------------------------------------
  *
- * command.h
- *	  prototypes for command.c.
+ * portalcmds.h
+ *	  prototypes for portalcmds.c.
  *
  *
- * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: command.h,v 1.37 2002/04/01 04:35:39 tgl Exp $
+ * $Id: portalcmds.h,v 1.1 2002/04/15 05:22:03 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-#ifndef COMMAND_H
-#define COMMAND_H
+#ifndef PORTALCMDS_H
+#define PORTALCMDS_H
 
 #include "utils/portal.h"
 
-
 /*
  * PerformPortalFetch
  *		Performs the POSTQUEL function FETCH.  Fetches count (or all if 0)
@@ -37,45 +36,4 @@ extern void PerformPortalClose(char *name, CommandDest dest);
 
 extern void PortalCleanup(Portal portal);
 
-/*
- * ALTER TABLE variants
- */
-extern void AlterTableAddColumn(Oid myrelid, bool inherits, ColumnDef *colDef);
-
-extern void AlterTableAlterColumnDefault(Oid myrelid, bool inh,
-										 const char *colName, Node *newDefault);
-
-extern void AlterTableAlterColumnDropNotNull(Oid myrelid,
-							 bool inh, const char *colName);
-
-extern void AlterTableAlterColumnSetNotNull(Oid myrelid,
-							 bool inh, const char *colName);
-
-extern void AlterTableAlterColumnFlags(Oid myrelid,
-									   bool inh, const char *colName,
-									   Node *flagValue, const char *flagType);
-
-extern void AlterTableDropColumn(Oid myrelid, bool inh,
-					 			 const char *colName, int behavior);
-
-extern void AlterTableAddConstraint(Oid myrelid,
-									bool inh, List *newConstraints);
-
-extern void AlterTableDropConstraint(Oid myrelid,
-									 bool inh, const char *constrName, int behavior);
-
-extern void AlterTableCreateToastTable(Oid relOid, bool silent);
-
-extern void AlterTableOwner(Oid relationOid, int32 newOwnerSysId);
-
-/*
- * LOCK
- */
-extern void LockTableCommand(LockStmt *lockstmt);
-
-/*
- * SCHEMA
- */
-extern void CreateSchemaCommand(CreateSchemaStmt *parsetree);
-
-#endif   /* COMMAND_H */
+#endif  /* PORTALCMDS_H */

src/include/commands/rename.h → src/include/commands/schemacmds.h

 /*-------------------------------------------------------------------------
  *
- * rename.h
+ * schemacmds.h
+ *	  prototypes for schemacmds.c.
  *
  *
- *
- * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: rename.h,v 1.16 2002/03/31 07:49:30 tgl Exp $
+ * $Id: schemacmds.h,v 1.1 2002/04/15 05:22:04 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-#ifndef RENAME_H
-#define RENAME_H
 
-extern void renameatt(Oid relid,
-		  const char *oldattname,
-		  const char *newattname,
-		  bool recurse);
+#ifndef SCHEMACMDS_H
+#define SCHEMACMDS_H
+
+#include "nodes/parsenodes.h"
 
-extern void renamerel(Oid relid,
-		  const char *newrelname);
+extern void CreateSchemaCommand(CreateSchemaStmt *parsetree);
 
-#endif   /* RENAME_H */
+#endif  /* SCHEMACMDS_H */

src/include/commands/tablecmds.h

+/*-------------------------------------------------------------------------
+ *
+ * tablecmds.h
+ *	  prototypes for tablecmds.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: tablecmds.h,v 1.1 2002/04/15 05:22:04 tgl Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef TABLECMDS_H
+#define TABLECMDS_H
+
+#include "nodes/parsenodes.h"
+
+extern void AlterTableAddColumn(Oid myrelid, bool inherits,
+								ColumnDef *colDef);
+
+extern void AlterTableAlterColumnDefault(Oid myrelid, bool inh,
+										 const char *colName,
+										 Node *newDefault);
+
+extern void AlterTableAlterColumnDropNotNull(Oid myrelid, bool inh,
+											 const char *colName);
+
+extern void AlterTableAlterColumnSetNotNull(Oid myrelid, bool inh,
+											const char *colName);
+
+extern void AlterTableAlterColumnFlags(Oid myrelid, bool inh,
+									   const char *colName,
+									   Node *flagValue, const char *flagType);
+
+extern void AlterTableDropColumn(Oid myrelid, bool inh,
+					 			 const char *colName, int behavior);
+
+extern void AlterTableAddConstraint(Oid myrelid, bool inh,
+									List *newConstraints);
+
+extern void AlterTableDropConstraint(Oid myrelid, bool inh,
+									 const char *constrName, int behavior);
+
+extern void AlterTableCreateToastTable(Oid relOid, bool silent);
+
+extern void AlterTableOwner(Oid relationOid, int32 newOwnerSysId);
+
+extern Oid	DefineRelation(CreateStmt *stmt, char relkind);
+
+extern void RemoveRelation(const RangeVar *relation);
+
+extern void TruncateRelation(const RangeVar *relation);
+
+extern void renameatt(Oid relid,
+		  const char *oldattname,
+		  const char *newattname,
+		  bool recurse);
+
+extern void renamerel(Oid relid,
+		  const char *newrelname);
+
+#endif   /* TABLECMDS_H */