Re-implement LIMIT/OFFSET as a plan node type, instead of a hack in

ExecutorRun.  This allows LIMIT to work in a view.  Also, LIMIT in a
cursor declaration will behave in a reasonable fashion, whereas before
it was overridden by the FETCH count.

Author: tglsfdc

src/backend/commands/command.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.107 2000/10/16 17:08:05 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.108 2000/10/26 21:34:44 tgl Exp $
  *
  * NOTES
  *	  The PerformAddAttribute() code, like most of the relation
@@ -111,7 +111,6 @@ PerformPortalFetch(char *name,
 	int			feature;
 	QueryDesc  *queryDesc;
 	MemoryContext oldcontext;
-	Const		limcount;
 
 	/* ----------------
 	 *	sanity checks
@@ -123,20 +122,6 @@ PerformPortalFetch(char *name,
 		return;
 	}
 
-	/* ----------------
-	 *	Create a const node from the given count value
-	 * ----------------
-	 */
-	memset(&limcount, 0, sizeof(limcount));
-	limcount.type = T_Const;
-	limcount.consttype = INT4OID;
-	limcount.constlen = sizeof(int4);
-	limcount.constvalue = Int32GetDatum(count);
-	limcount.constisnull = false;
-	limcount.constbyval = true;
-	limcount.constisset = false;
-	limcount.constiscast = false;
-
 	/* ----------------
 	 *	get the portal from the portal name
 	 * ----------------
@@ -156,8 +141,7 @@ PerformPortalFetch(char *name,
 	oldcontext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
 
 	/* ----------------
-	 *	setup "feature" to tell the executor what direction and
-	 *	how many tuples to fetch.
+	 *	setup "feature" to tell the executor which direction to go in.
 	 * ----------------
 	 */
 	if (forward)
@@ -166,7 +150,7 @@ PerformPortalFetch(char *name,
 		feature = EXEC_BACK;
 
 	/* ----------------
-	 *	tell the destination to prepare to recieve some tuples
+	 *	tell the destination to prepare to receive some tuples
 	 * ----------------
 	 */
 	queryDesc = PortalGetQueryDesc(portal);
@@ -194,8 +178,7 @@ PerformPortalFetch(char *name,
 	 *	execute the portal fetch operation
 	 * ----------------
 	 */
-	ExecutorRun(queryDesc, PortalGetState(portal), feature,
-				(Node *) NULL, (Node *) &limcount);
+	ExecutorRun(queryDesc, PortalGetState(portal), feature, (long) count);
 
 	if (dest == None)			/* MOVE */
 		pfree(queryDesc);

src/backend/commands/explain.c

@@ -5,7 +5,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994-5, Regents of the University of California
  *
- * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.60 2000/10/05 19:11:26 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.61 2000/10/26 21:34:44 tgl Exp $
  *
  */
 
@@ -217,6 +217,9 @@ explain_outNode(StringInfo str, Plan *plan, int indent, ExplainState *es)
 					break;
 			}
 			break;
+		case T_Limit:
+			pname = "Limit";
+			break;
 		case T_Hash:
 			pname = "Hash";
 			break;

src/backend/executor/Makefile

@@ -4,7 +4,7 @@
 #    Makefile for executor
 #
 # IDENTIFICATION
-#    $Header: /cvsroot/pgsql/src/backend/executor/Makefile,v 1.15 2000/10/05 19:11:26 tgl Exp $
+#    $Header: /cvsroot/pgsql/src/backend/executor/Makefile,v 1.16 2000/10/26 21:35:15 tgl Exp $
 #
 #-------------------------------------------------------------------------
 
@@ -17,8 +17,8 @@ OBJS = execAmi.o execFlatten.o execJunk.o execMain.o \
        execUtils.o functions.o nodeAppend.o nodeAgg.o nodeHash.o \
        nodeHashjoin.o nodeIndexscan.o nodeMaterial.o nodeMergejoin.o \
        nodeNestloop.o nodeResult.o nodeSeqscan.o nodeSetOp.o nodeSort.o \
-       nodeUnique.o nodeGroup.o spi.o nodeSubplan.o \
-       nodeSubqueryscan.o nodeTidscan.o
+       nodeUnique.o nodeLimit.o nodeGroup.o nodeSubplan.o \
+       nodeSubqueryscan.o nodeTidscan.o spi.o
 
 all: SUBSYS.o
 

src/backend/executor/execAmi.c

@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Id: execAmi.c,v 1.53 2000/10/05 19:11:26 tgl Exp $
+ *	$Id: execAmi.c,v 1.54 2000/10/26 21:35:15 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -37,6 +37,7 @@
 #include "executor/nodeHashjoin.h"
 #include "executor/nodeIndexscan.h"
 #include "executor/nodeTidscan.h"
+#include "executor/nodeLimit.h"
 #include "executor/nodeMaterial.h"
 #include "executor/nodeMergejoin.h"
 #include "executor/nodeNestloop.h"
@@ -350,6 +351,10 @@ ExecReScan(Plan *node, ExprContext *exprCtxt, Plan *parent)
 			ExecReScanSetOp((SetOp *) node, exprCtxt, parent);
 			break;
 
+		case T_Limit:
+			ExecReScanLimit((Limit *) node, exprCtxt, parent);
+			break;
+
 		case T_Sort:
 			ExecReScanSort((Sort *) node, exprCtxt, parent);
 			break;

src/backend/executor/execMain.c

@@ -27,7 +27,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.130 2000/10/16 17:08:06 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.131 2000/10/26 21:35:15 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -52,11 +52,10 @@ static TupleDesc InitPlan(CmdType operation,
 		 EState *estate);
 static void EndPlan(Plan *plan, EState *estate);
 static TupleTableSlot *ExecutePlan(EState *estate, Plan *plan,
-			CmdType operation,
-			int offsetTuples,
-			int numberTuples,
-			ScanDirection direction,
-			DestReceiver *destfunc);
+								   CmdType operation,
+								   long numberTuples,
+								   ScanDirection direction,
+								   DestReceiver *destfunc);
 static void ExecRetrieve(TupleTableSlot *slot,
 			 DestReceiver *destfunc,
 			 EState *estate);
@@ -153,19 +152,18 @@ ExecutorStart(QueryDesc *queryDesc, EState *estate)
  *			 EXEC_RETONE: return one tuple but don't 'retrieve' it
  *						   used in postquel function processing
  *
+ *		Note: count = 0 is interpreted as "no limit".
+ *
  * ----------------------------------------------------------------
  */
 TupleTableSlot *
-ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
-			Node *limoffset, Node *limcount)
+ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, long count)
 {
 	CmdType		operation;
 	Plan	   *plan;
 	TupleTableSlot *result;
 	CommandDest dest;
 	DestReceiver *destfunc;
-	int			offset = 0;
-	int			count = 0;
 
 	/*
 	 * sanity checks
@@ -191,111 +189,21 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
 	 */
 	(*destfunc->setup) (destfunc, (TupleDesc) NULL);
 
-	/*
-	 * if given get the offset of the LIMIT clause
-	 */
-	if (limoffset != NULL)
-	{
-		Const	   *coffset;
-		Param	   *poffset;
-		ParamListInfo paramLI;
-		int			i;
-
-		switch (nodeTag(limoffset))
-		{
-			case T_Const:
-				coffset = (Const *) limoffset;
-				offset = (int) (coffset->constvalue);
-				break;
-
-			case T_Param:
-				poffset = (Param *) limoffset;
-				paramLI = estate->es_param_list_info;
-
-				if (paramLI == NULL)
-					elog(ERROR, "parameter for limit offset not in executor state");
-				for (i = 0; paramLI[i].kind != PARAM_INVALID; i++)
-				{
-					if (paramLI[i].kind == PARAM_NUM && paramLI[i].id == poffset->paramid)
-						break;
-				}
-				if (paramLI[i].kind == PARAM_INVALID)
-					elog(ERROR, "parameter for limit offset not in executor state");
-				if (paramLI[i].isnull)
-					elog(ERROR, "limit offset cannot be NULL value");
-				offset = (int) (paramLI[i].value);
-
-				break;
-
-			default:
-				elog(ERROR, "unexpected node type %d as limit offset", nodeTag(limoffset));
-		}
-
-		if (offset < 0)
-			elog(ERROR, "limit offset cannot be negative");
-	}
-
-	/*
-	 * if given get the count of the LIMIT clause
-	 */
-	if (limcount != NULL)
-	{
-		Const	   *ccount;
-		Param	   *pcount;
-		ParamListInfo paramLI;
-		int			i;
-
-		switch (nodeTag(limcount))
-		{
-			case T_Const:
-				ccount = (Const *) limcount;
-				count = (int) (ccount->constvalue);
-				break;
-
-			case T_Param:
-				pcount = (Param *) limcount;
-				paramLI = estate->es_param_list_info;
-
-				if (paramLI == NULL)
-					elog(ERROR, "parameter for limit count not in executor state");
-				for (i = 0; paramLI[i].kind != PARAM_INVALID; i++)
-				{
-					if (paramLI[i].kind == PARAM_NUM && paramLI[i].id == pcount->paramid)
-						break;
-				}
-				if (paramLI[i].kind == PARAM_INVALID)
-					elog(ERROR, "parameter for limit count not in executor state");
-				if (paramLI[i].isnull)
-					elog(ERROR, "limit count cannot be NULL value");
-				count = (int) (paramLI[i].value);
-
-				break;
-
-			default:
-				elog(ERROR, "unexpected node type %d as limit count", nodeTag(limcount));
-		}
-
-		if (count < 0)
-			elog(ERROR, "limit count cannot be negative");
-	}
-
 	switch (feature)
 	{
-
 		case EXEC_RUN:
 			result = ExecutePlan(estate,
 								 plan,
 								 operation,
-								 offset,
 								 count,
 								 ForwardScanDirection,
 								 destfunc);
 			break;
+
 		case EXEC_FOR:
 			result = ExecutePlan(estate,
 								 plan,
 								 operation,
-								 offset,
 								 count,
 								 ForwardScanDirection,
 								 destfunc);
@@ -308,7 +216,6 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
 			result = ExecutePlan(estate,
 								 plan,
 								 operation,
-								 offset,
 								 count,
 								 BackwardScanDirection,
 								 destfunc);
@@ -322,14 +229,14 @@ ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature,
 			result = ExecutePlan(estate,
 								 plan,
 								 operation,
-								 0,
 								 ONE_TUPLE,
 								 ForwardScanDirection,
 								 destfunc);
 			break;
+
 		default:
-			result = NULL;
 			elog(DEBUG, "ExecutorRun: Unknown feature %d", feature);
+			result = NULL;
 			break;
 	}
 
@@ -917,33 +824,30 @@ EndPlan(Plan *plan, EState *estate)
 /* ----------------------------------------------------------------
  *		ExecutePlan
  *
- *		processes the query plan to retrieve 'tupleCount' tuples in the
+ *		processes the query plan to retrieve 'numberTuples' tuples in the
  *		direction specified.
  *		Retrieves all tuples if tupleCount is 0
  *
- *		result is either a slot containing a tuple in the case
+ *		result is either a slot containing the last tuple in the case
  *		of a RETRIEVE or NULL otherwise.
  *
+ * Note: the ctid attribute is a 'junk' attribute that is removed before the
+ * user can see it
  * ----------------------------------------------------------------
  */
-
-/* the ctid attribute is a 'junk' attribute that is removed before the
-   user can see it*/
-
 static TupleTableSlot *
 ExecutePlan(EState *estate,
 			Plan *plan,
 			CmdType operation,
-			int offsetTuples,
-			int numberTuples,
+			long numberTuples,
 			ScanDirection direction,
 			DestReceiver *destfunc)
 {
 	JunkFilter *junkfilter;
 	TupleTableSlot *slot;
 	ItemPointer tupleid = NULL;
 	ItemPointerData tuple_ctid;
-	int			current_tuple_count;
+	long		current_tuple_count;
 	TupleTableSlot *result;
 
 	/*
@@ -990,17 +894,6 @@ lnext:	;
 			break;
 		}
 
-		/*
-		 * For now we completely execute the plan and skip result tuples
-		 * if requested by LIMIT offset. Finally we should try to do it in
-		 * deeper levels if possible (during index scan) - Jan
-		 */
-		if (offsetTuples > 0)
-		{
-			--offsetTuples;
-			continue;
-		}
-
 		/*
 		 * if we have a junk filter, then project a new tuple with the
 		 * junk removed.
@@ -1152,10 +1045,10 @@ lnext:	;
 		}
 
 		/*
-		 * check our tuple count.. if we've returned the proper number
-		 * then return, else loop again and process more tuples..
+		 * check our tuple count.. if we've processed the proper number
+		 * then quit, else loop again and process more tuples..
 		 */
-		current_tuple_count += 1;
+		current_tuple_count++;
 		if (numberTuples == current_tuple_count)
 			break;
 	}