Restructure command destination handling so that we pass around

DestReceiver pointers instead of just CommandDest values.  The DestReceiver
is made at the point where the destination is selected, rather than
deep inside the executor.  This cleans up the original kluge implementation
of tstoreReceiver.c, and makes it easy to support retrieving results
from utility statements inside portals.  Thus, you can now do fun things
like Bind and Execute a FETCH or EXPLAIN command, and it'll all work
as expected (e.g., you can Describe the portal, or use Execute's count
parameter to suspend the output partway through).  Implementation involves
stuffing the utility command's output into a Tuplestore, which would be
kind of annoying for huge output sets, but should be quite acceptable
for typical uses of utility commands.

Author: tglsfdc

src/backend/access/common/printtup.c

@@ -2,14 +2,14 @@
  *
  * printtup.c
  *	  Routines to print out tuples to the destination (both frontend
- *	  clients and interactive backends are supported here).
+ *	  clients and standalone backends are supported here).
  *
  *
  * 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/access/common/printtup.c,v 1.69 2003/05/06 00:20:31 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.70 2003/05/06 20:26:26 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -22,11 +22,13 @@
 #include "utils/lsyscache.h"
 
 
-static void printtup_setup(DestReceiver *self, int operation,
+static void printtup_startup(DestReceiver *self, int operation,
 			   const char *portalName, TupleDesc typeinfo, List *targetlist);
 static void printtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self);
 static void printtup_internal(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self);
-static void printtup_cleanup(DestReceiver *self);
+static void printtup_shutdown(DestReceiver *self);
+static void printtup_destroy(DestReceiver *self);
+
 
 /* ----------------------------------------------------------------
  *		printtup / debugtup support
@@ -59,13 +61,41 @@ typedef struct
  * ----------------
  */
 DestReceiver *
-printtup_create_DR(bool isBinary, bool sendDescrip)
+printtup_create_DR(CommandDest dest)
 {
 	DR_printtup *self = (DR_printtup *) palloc(sizeof(DR_printtup));
+	bool	isBinary;
+	bool	sendDescrip;
+
+	switch (dest)
+	{
+		case Remote:
+			isBinary = false;
+			sendDescrip = true;
+			break;
+		case RemoteInternal:
+			isBinary = true;
+			sendDescrip = true;
+			break;
+		case RemoteExecute:
+			isBinary = false;
+			sendDescrip = false; /* no T message for Execute */
+			break;
+		case RemoteExecuteInternal:
+			isBinary = true;
+			sendDescrip = false; /* no T message for Execute */
+			break;
+
+		default:
+			elog(ERROR, "printtup_create_DR: unsupported dest");
+			return NULL;
+	}
 
 	self->pub.receiveTuple = isBinary ? printtup_internal : printtup;
-	self->pub.setup = printtup_setup;
-	self->pub.cleanup = printtup_cleanup;
+	self->pub.startup = printtup_startup;
+	self->pub.shutdown = printtup_shutdown;
+	self->pub.destroy = printtup_destroy;
+	self->pub.mydest = dest;
 
 	self->sendDescrip = sendDescrip;
 
@@ -77,8 +107,8 @@ printtup_create_DR(bool isBinary, bool sendDescrip)
 }
 
 static void
-printtup_setup(DestReceiver *self, int operation,
-			   const char *portalName, TupleDesc typeinfo, List *targetlist)
+printtup_startup(DestReceiver *self, int operation,
+				 const char *portalName, TupleDesc typeinfo, List *targetlist)
 {
 	DR_printtup *myState = (DR_printtup *) self;
 
@@ -288,17 +318,28 @@ printtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self)
 }
 
 /* ----------------
- *		printtup_cleanup
+ *		printtup_shutdown
  * ----------------
  */
 static void
-printtup_cleanup(DestReceiver *self)
+printtup_shutdown(DestReceiver *self)
 {
 	DR_printtup *myState = (DR_printtup *) self;
 
 	if (myState->myinfo)
 		pfree(myState->myinfo);
-	pfree(myState);
+	myState->myinfo = NULL;
+	myState->attrinfo = NULL;
+}
+
+/* ----------------
+ *		printtup_destroy
+ * ----------------
+ */
+static void
+printtup_destroy(DestReceiver *self)
+{
+	pfree(self);
 }
 
 /* ----------------
@@ -340,12 +381,12 @@ showatts(const char *name, TupleDesc tupleDesc)
 }
 
 /* ----------------
- *		debugSetup - prepare to print tuples for an interactive backend
+ *		debugStartup - prepare to print tuples for an interactive backend
  * ----------------
  */
 void
-debugSetup(DestReceiver *self, int operation,
-		   const char *portalName, TupleDesc typeinfo, List *targetlist)
+debugStartup(DestReceiver *self, int operation,
+			 const char *portalName, TupleDesc typeinfo, List *targetlist)
 {
 	/*
 	 * show the return type of the tuples

src/backend/commands/explain.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994-5, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.107 2003/05/06 00:20:31 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.108 2003/05/06 20:26:26 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -67,21 +67,15 @@ static Node *make_ors_ands_explicit(List *orclauses);
  *	  execute an EXPLAIN command
  */
 void
-ExplainQuery(ExplainStmt *stmt, CommandDest dest)
+ExplainQuery(ExplainStmt *stmt, DestReceiver *dest)
 {
 	Query	   *query = stmt->query;
 	TupOutputState *tstate;
-	TupleDesc	tupdesc;
 	List	   *rewritten;
 	List	   *l;
 
-	/* need a tuple descriptor representing a single TEXT column */
-	tupdesc = CreateTemplateTupleDesc(1, false);
-	TupleDescInitEntry(tupdesc, (AttrNumber) 1, "QUERY PLAN",
-					   TEXTOID, -1, 0, false);
-
 	/* prepare for projection of tuples */
-	tstate = begin_tup_output_tupdesc(dest, tupdesc);
+	tstate = begin_tup_output_tupdesc(dest, ExplainResultDesc(stmt));
 
 	if (query->commandType == CMD_UTILITY)
 	{
@@ -119,6 +113,22 @@ ExplainQuery(ExplainStmt *stmt, CommandDest dest)
 	end_tup_output(tstate);
 }
 
+/*
+ * ExplainResultDesc -
+ *	  construct the result tupledesc for an EXPLAIN
+ */
+TupleDesc
+ExplainResultDesc(ExplainStmt *stmt)
+{
+	TupleDesc	tupdesc;
+
+	/* need a tuple descriptor representing a single TEXT column */
+	tupdesc = CreateTemplateTupleDesc(1, false);
+	TupleDescInitEntry(tupdesc, (AttrNumber) 1, "QUERY PLAN",
+					   TEXTOID, -1, 0, false);
+	return tupdesc;
+}
+
 /*
  * ExplainOneQuery -
  *	  print out the execution plan for one query
@@ -169,7 +179,7 @@ ExplainOneQuery(Query *query, ExplainStmt *stmt, TupOutputState *tstate)
 	plan = planner(query, isCursor, cursorOptions);
 
 	/* Create a QueryDesc requesting no output */
-	queryDesc = CreateQueryDesc(query, plan, None, NULL, NULL,
+	queryDesc = CreateQueryDesc(query, plan, None_Receiver, NULL, NULL,
 								stmt->analyze);
 
 	ExplainOnePlan(queryDesc, stmt, tstate);

src/backend/commands/portalcmds.c

@@ -14,7 +14,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/portalcmds.c,v 1.14 2003/05/05 00:44:55 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/portalcmds.c,v 1.15 2003/05/06 20:26:26 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -23,9 +23,9 @@
 
 #include <limits.h>
 
-#include "miscadmin.h"
 #include "commands/portalcmds.h"
 #include "executor/executor.h"
+#include "executor/tstoreReceiver.h"
 #include "optimizer/planner.h"
 #include "rewrite/rewriteHandler.h"
 #include "tcop/pquery.h"
@@ -37,7 +37,7 @@
  *		Execute SQL DECLARE CURSOR command.
  */
 void
-PerformCursorOpen(DeclareCursorStmt *stmt, CommandDest dest)
+PerformCursorOpen(DeclareCursorStmt *stmt)
 {
 	List	   *rewritten;
 	Query	   *query;
@@ -142,9 +142,10 @@ PerformCursorOpen(DeclareCursorStmt *stmt, CommandDest dest)
  */
 void
 PerformPortalFetch(FetchStmt *stmt,
-				   CommandDest dest,
+				   DestReceiver *dest,
 				   char *completionTag)
 {
+	DestReceiver *mydest = dest;
 	Portal		portal;
 	long		nprocessed;
 
@@ -168,29 +169,34 @@ PerformPortalFetch(FetchStmt *stmt,
 	}
 
 	/*
-	 * Adjust dest if needed.  MOVE wants dest = None.
+	 * Adjust dest if needed.  MOVE wants destination None.
 	 *
 	 * If fetching from a binary cursor and the requested destination is
 	 * Remote, change it to RemoteInternal.  Note we do NOT change if the
 	 * destination is RemoteExecute --- so the Execute message's format
 	 * specification wins out over the cursor's type.
 	 */
 	if (stmt->ismove)
-		dest = None;
-	else if (dest == Remote && (portal->cursorOptions & CURSOR_OPT_BINARY))
-		dest = RemoteInternal;
+		mydest = CreateDestReceiver(None);
+	else if (dest->mydest == Remote &&
+			 (portal->cursorOptions & CURSOR_OPT_BINARY))
+		mydest = CreateDestReceiver(RemoteInternal);
 
 	/* Do it */
 	nprocessed = PortalRunFetch(portal,
 								stmt->direction,
 								stmt->howMany,
-								dest);
+								mydest);
 
 	/* Return command status if wanted */
 	if (completionTag)
 		snprintf(completionTag, COMPLETION_TAG_BUFSIZE, "%s %ld",
 				 stmt->ismove ? "MOVE" : "FETCH",
 				 nprocessed);
+
+	/* Clean up if we created a local destination */
+	if (mydest != dest)
+		(mydest->destroy) (mydest);
 }
 
 /*
@@ -243,21 +249,6 @@ PortalCleanup(Portal portal, bool isError)
 	AssertArg(PortalIsValid(portal));
 	AssertArg(portal->cleanup == PortalCleanup);
 
-	/*
-	 * Delete tuplestore if present.  (Note: portalmem.c is responsible
-	 * for removing holdContext.)  We should do this even under error
-	 * conditions; since the tuplestore would have been using cross-
-	 * transaction storage, its temp files need to be explicitly deleted.
-	 */
-	if (portal->holdStore)
-	{
-		MemoryContext oldcontext;
-
-		oldcontext = MemoryContextSwitchTo(portal->holdContext);
-		tuplestore_end(portal->holdStore);
-		MemoryContextSwitchTo(oldcontext);
-		portal->holdStore = NULL;
-	}
 	/*
 	 * Shut down executor, if still running.  We skip this during error
 	 * abort, since other mechanisms will take care of releasing executor
@@ -284,7 +275,6 @@ void
 PersistHoldablePortal(Portal portal)
 {
 	QueryDesc *queryDesc = PortalGetQueryDesc(portal);
-	Portal		saveCurrentPortal;
 	MemoryContext savePortalContext;
 	MemoryContext saveQueryContext;
 	MemoryContext oldcxt;
@@ -294,26 +284,22 @@ PersistHoldablePortal(Portal portal)
 	 * inside the transaction that originally created it.
 	 */
 	Assert(portal->createXact == GetCurrentTransactionId());
-	Assert(portal->holdStore == NULL);
 	Assert(queryDesc != NULL);
 	Assert(portal->portalReady);
 	Assert(!portal->portalDone);
 
 	/*
-	 * This context is used to store the tuple set.
-	 * Caller must have created it already.
+	 * Caller must have created the tuplestore already.
 	 */
 	Assert(portal->holdContext != NULL);
-	oldcxt = MemoryContextSwitchTo(portal->holdContext);
-
-	/* XXX: Should SortMem be used for this? */
-	portal->holdStore = tuplestore_begin_heap(true, true, SortMem);
+	Assert(portal->holdStore != NULL);
 
 	/*
-	 * Before closing down the executor, we must copy the tupdesc, since
-	 * it was created in executor memory.  Note we are copying it into
-	 * the holdContext.
+	 * Before closing down the executor, we must copy the tupdesc into
+	 * long-term memory, since it was created in executor memory.
 	 */
+	oldcxt = MemoryContextSwitchTo(portal->holdContext);
+
 	portal->tupDesc = CreateTupleDescCopy(portal->tupDesc);
 
 	MemoryContextSwitchTo(oldcxt);
@@ -326,10 +312,8 @@ PersistHoldablePortal(Portal portal)
 	portal->portalActive = true;
 
 	/*
-	 * Set global portal and context pointers.
+	 * Set global portal context pointers.
 	 */
-	saveCurrentPortal = CurrentPortal;
-	CurrentPortal = portal;
 	savePortalContext = PortalContext;
 	PortalContext = PortalGetHeapMemory(portal);
 	saveQueryContext = QueryContext;
@@ -344,12 +328,16 @@ PersistHoldablePortal(Portal portal)
 	 */
 	ExecutorRewind(queryDesc);
 
-	/* Set the destination to output to the tuplestore */
-	queryDesc->dest = Tuplestore;
+	/* Change the destination to output to the tuplestore */
+	queryDesc->dest = CreateTuplestoreDestReceiver(portal->holdStore,
+												   portal->holdContext);
 
 	/* Fetch the result set into the tuplestore */
 	ExecutorRun(queryDesc, ForwardScanDirection, 0L);
 
+	(*queryDesc->dest->destroy) (queryDesc->dest);
+	queryDesc->dest = NULL;
+
 	/*
 	 * Now shut down the inner executor.
 	 */
@@ -359,7 +347,6 @@ PersistHoldablePortal(Portal portal)
 	/* Mark portal not active */
 	portal->portalActive = false;
 
-	CurrentPortal = saveCurrentPortal;
 	PortalContext = savePortalContext;
 	QueryContext = saveQueryContext;