int feature;
QueryDesc *queryDesc;
MemoryContext oldcontext;
- Const limcount;
/* ----------------
* sanity checks
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
* ----------------
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)
feature = EXEC_BACK;
/* ----------------
- * tell the destination to prepare to recieve some tuples
+ * tell the destination to prepare to receive some tuples
* ----------------
*/
queryDesc = PortalGetQueryDesc(portal);
* 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);
break;
}
break;
+ case T_Limit:
+ pname = "Limit";
+ break;
case T_Hash:
pname = "Hash";
break;
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
#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"
ExecReScanSetOp((SetOp *) node, exprCtxt, parent);
break;
+ case T_Limit:
+ ExecReScanLimit((Limit *) node, exprCtxt, parent);
+ break;
+
case T_Sort:
ExecReScanSort((Sort *) node, exprCtxt, parent);
break;
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);
* 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
*/
(*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);
result = ExecutePlan(estate,
plan,
operation,
- offset,
count,
BackwardScanDirection,
destfunc);
result = ExecutePlan(estate,
plan,
operation,
- 0,
ONE_TUPLE,
ForwardScanDirection,
destfunc);
break;
+
default:
- result = NULL;
elog(DEBUG, "ExecutorRun: Unknown feature %d", feature);
+ result = NULL;
break;
}
/* ----------------------------------------------------------------
* 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)
{
TupleTableSlot *slot;
ItemPointer tupleid = NULL;
ItemPointerData tuple_ctid;
- int current_tuple_count;
+ long current_tuple_count;
TupleTableSlot *result;
/*
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.
}
/*
- * 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;
}
#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"
result = ExecInitSetOp((SetOp *) node, estate, parent);
break;
+ case T_Limit:
+ result = ExecInitLimit((Limit *) node, estate, parent);
+ break;
+
case T_Group:
result = ExecInitGroup((Group *) node, estate, parent);
break;
result = ExecSetOp((SetOp *) node);
break;
+ case T_Limit:
+ result = ExecLimit((Limit *) node);
+ break;
+
case T_Group:
result = ExecGroup((Group *) node);
break;
case T_SetOp:
return ExecCountSlotsSetOp((SetOp *) node);
+ case T_Limit:
+ return ExecCountSlotsLimit((Limit *) node);
+
case T_Group:
return ExecCountSlotsGroup((Group *) node);
ExecEndSetOp((SetOp *) node);
break;
+ case T_Limit:
+ ExecEndLimit((Limit *) node);
+ break;
+
case T_Group:
ExecEndGroup((Group *) node);
break;
}
break;
+ case T_Limit:
+ {
+ LimitState *limitstate = ((Limit *) node)->limitstate;
+
+ slot = limitstate->cstate.cs_ResultTupleSlot;
+ }
+ break;
+
case T_MergeJoin:
{
MergeJoinState *mergestate = ((MergeJoin *) node)->mergestate;
None);
estate = CreateExecutorState();
- if (queryTree->limitOffset != NULL || queryTree->limitCount != NULL)
- elog(ERROR, "LIMIT clause from SQL functions not yet implemented");
-
if (nargs > 0)
{
int i;
feature = (LAST_POSTQUEL_COMMAND(es)) ? EXEC_RETONE : EXEC_RUN;
- return ExecutorRun(es->qd, es->estate, feature, (Node *) NULL, (Node *) NULL);
+ return ExecutorRun(es->qd, es->estate, feature, 0L);
}
static void
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * nodeLimit.c
+ * Routines to handle limiting of query results where appropriate
+ *
+ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * $Header$
+ *
+ *-------------------------------------------------------------------------
+ */
+/*
+ * INTERFACE ROUTINES
+ * ExecLimit - extract a limited range of tuples
+ * ExecInitLimit - initialize node and subnodes..
+ * ExecEndLimit - shutdown node and subnodes
+ */
+
+#include "postgres.h"
+
+#include "executor/executor.h"
+#include "executor/nodeLimit.h"
+
+static void recompute_limits(Limit *node);
+
+
+/* ----------------------------------------------------------------
+ * ExecLimit
+ *
+ * This is a very simple node which just performs LIMIT/OFFSET
+ * filtering on the stream of tuples returned by a subplan.
+ * ----------------------------------------------------------------
+ */
+TupleTableSlot * /* return: a tuple or NULL */
+ExecLimit(Limit *node)
+{
+ LimitState *limitstate;
+ ScanDirection direction;
+ TupleTableSlot *resultTupleSlot;
+ TupleTableSlot *slot;
+ Plan *outerPlan;
+ long netlimit;
+
+ /* ----------------
+ * get information from the node
+ * ----------------
+ */
+ limitstate = node->limitstate;
+ direction = node->plan.state->es_direction;
+ outerPlan = outerPlan((Plan *) node);
+ resultTupleSlot = limitstate->cstate.cs_ResultTupleSlot;
+
+ /* ----------------
+ * If first call for this scan, compute limit/offset.
+ * (We can't do this any earlier, because parameters from upper nodes
+ * may not be set until now.)
+ * ----------------
+ */
+ if (! limitstate->parmsSet)
+ recompute_limits(node);
+ netlimit = limitstate->offset + limitstate->count;
+
+ /* ----------------
+ * now loop, returning only desired tuples.
+ * ----------------
+ */
+ for (;;)
+ {
+ /*----------------
+ * If we have reached the subplan EOF or the limit, just quit.
+ *
+ * NOTE: when scanning forwards, we must fetch one tuple beyond the
+ * COUNT limit before we can return NULL, else the subplan won't be
+ * properly positioned to start going backwards. Hence test here
+ * is for position > netlimit not position >= netlimit.
+ *
+ * Similarly, when scanning backwards, we must re-fetch the last
+ * tuple in the offset region before we can return NULL. Otherwise
+ * we won't be correctly aligned to start going forward again. So,
+ * although you might think we can quit when position = offset + 1,
+ * we have to fetch a subplan tuple first, and then exit when
+ * position = offset.
+ *----------------
+ */
+ if (ScanDirectionIsForward(direction))
+ {
+ if (limitstate->atEnd)
+ return NULL;
+ if (! limitstate->noCount && limitstate->position > netlimit)
+ return NULL;
+ }
+ else
+ {
+ if (limitstate->position <= limitstate->offset)
+ return NULL;
+ }
+ /* ----------------
+ * fetch a tuple from the outer subplan
+ * ----------------
+ */
+ slot = ExecProcNode(outerPlan, (Plan *) node);
+ if (TupIsNull(slot))
+ {
+ /*
+ * We are at start or end of the subplan. Update local state
+ * appropriately, but always return NULL.
+ */
+ if (ScanDirectionIsForward(direction))
+ {
+ Assert(! limitstate->atEnd);
+ /* must bump position to stay in sync for backwards fetch */
+ limitstate->position++;
+ limitstate->atEnd = true;
+ }
+ else
+ {
+ limitstate->position = 0;
+ limitstate->atEnd = false;
+ }
+ return NULL;
+ }
+ /*
+ * We got the next subplan tuple successfully, so adjust state.
+ */
+ if (ScanDirectionIsForward(direction))
+ limitstate->position++;
+ else
+ {
+ limitstate->position--;
+ Assert(limitstate->position > 0);
+ }
+ limitstate->atEnd = false;
+
+ /* ----------------
+ * Now, is this a tuple we want? If not, loop around to fetch
+ * another tuple from the subplan.
+ * ----------------
+ */
+ if (limitstate->position > limitstate->offset &&
+ (limitstate->noCount || limitstate->position <= netlimit))
+ break;
+ }
+
+ ExecStoreTuple(slot->val,
+ resultTupleSlot,
+ InvalidBuffer,
+ false); /* tuple does not belong to slot */
+
+ return resultTupleSlot;
+}
+
+/*
+ * Evaluate the limit/offset expressions --- done at start of each scan.
+ *
+ * This is also a handy place to reset the current-position state info.
+ */
+static void
+recompute_limits(Limit *node)
+{
+ LimitState *limitstate = node->limitstate;
+ ExprContext *econtext = limitstate->cstate.cs_ExprContext;
+ bool isNull;
+
+ if (node->limitOffset)
+ {
+ limitstate->offset = DatumGetInt32(ExecEvalExpr(node->limitOffset,
+ econtext,
+ &isNull,
+ NULL));
+ /* Interpret NULL offset as no offset */
+ if (isNull)
+ limitstate->offset = 0;
+ else if (limitstate->offset < 0)
+ limitstate->offset = 0;
+ }
+ else
+ {
+ /* No OFFSET supplied */
+ limitstate->offset = 0;
+ }
+
+ if (node->limitCount)
+ {
+ limitstate->count = DatumGetInt32(ExecEvalExpr(node->limitCount,
+ econtext,
+ &isNull,
+ NULL));
+ /* Interpret NULL count as no count */
+ if (isNull)
+ limitstate->noCount = true;
+ else
+ {
+ /* Currently, LIMIT 0 is specified as meaning no limit.
+ * I think this is pretty bogus, but ...
+ */
+ if (limitstate->count <= 0)
+ limitstate->noCount = true;
+ }
+ }
+ else
+ {
+ /* No COUNT supplied */
+ limitstate->count = 0;
+ limitstate->noCount = true;
+ }
+
+ /* Reset position data to start-of-scan */
+ limitstate->position = 0;
+ limitstate->atEnd = false;
+
+ /* Set flag that params are computed */
+ limitstate->parmsSet = true;
+}
+
+/* ----------------------------------------------------------------
+ * ExecInitLimit
+ *
+ * This initializes the limit node state structures and
+ * the node's subplan.
+ * ----------------------------------------------------------------
+ */
+bool /* return: initialization status */
+ExecInitLimit(Limit *node, EState *estate, Plan *parent)
+{
+ LimitState *limitstate;
+ Plan *outerPlan;
+
+ /* ----------------
+ * assign execution state to node
+ * ----------------
+ */
+ node->plan.state = estate;
+
+ /* ----------------
+ * create new LimitState for node
+ * ----------------
+ */
+ limitstate = makeNode(LimitState);
+ node->limitstate = limitstate;
+ limitstate->parmsSet = false;
+
+ /* ----------------
+ * Miscellaneous initialization
+ *
+ * Limit nodes never call ExecQual or ExecProject, but they need
+ * an exprcontext anyway to evaluate the limit/offset parameters in.
+ * ----------------
+ */
+ ExecAssignExprContext(estate, &limitstate->cstate);
+
+#define LIMIT_NSLOTS 1
+ /* ------------
+ * Tuple table initialization
+ * ------------
+ */
+ ExecInitResultTupleSlot(estate, &limitstate->cstate);
+
+ /* ----------------
+ * then initialize outer plan
+ * ----------------
+ */
+ outerPlan = outerPlan((Plan *) node);
+ ExecInitNode(outerPlan, estate, (Plan *) node);
+
+ /* ----------------
+ * limit nodes do no projections, so initialize
+ * projection info for this node appropriately
+ * ----------------
+ */
+ ExecAssignResultTypeFromOuterPlan((Plan *) node, &limitstate->cstate);
+ limitstate->cstate.cs_ProjInfo = NULL;
+
+ return TRUE;
+}
+
+int
+ExecCountSlotsLimit(Limit *node)
+{
+ return ExecCountSlotsNode(outerPlan(node)) +
+ ExecCountSlotsNode(innerPlan(node)) +
+ LIMIT_NSLOTS;
+}
+
+/* ----------------------------------------------------------------
+ * ExecEndLimit
+ *
+ * This shuts down the subplan and frees resources allocated
+ * to this node.
+ * ----------------------------------------------------------------
+ */
+void
+ExecEndLimit(Limit *node)
+{
+ LimitState *limitstate = node->limitstate;
+
+ ExecFreeExprContext(&limitstate->cstate);
+
+ ExecEndNode(outerPlan((Plan *) node), (Plan *) node);
+
+ /* clean up tuple table */
+ ExecClearTuple(limitstate->cstate.cs_ResultTupleSlot);
+}
+
+
+void
+ExecReScanLimit(Limit *node, ExprContext *exprCtxt, Plan *parent)
+{
+ LimitState *limitstate = node->limitstate;
+
+ ExecClearTuple(limitstate->cstate.cs_ResultTupleSlot);
+
+ /* force recalculation of limit expressions on first call */
+ limitstate->parmsSet = false;
+
+ /*
+ * if chgParam of subnode is not null then plan will be re-scanned by
+ * first ExecProcNode.
+ */
+ if (((Plan *) node)->lefttree->chgParam == NULL)
+ ExecReScan(((Plan *) node)->lefttree, exprCtxt, (Plan *) node);
+}
bool isRetrieveIntoRelation = false;
char *intoName = NULL;
int res;
- Const tcount_const;
- Node *count = NULL;
switch (operation)
{
return SPI_ERROR_OPUNKNOWN;
}
- /* ----------------
- * Get the query LIMIT tuple count
- * ----------------
- */
- if (parseTree->limitCount != NULL)
- {
- /* ----------------
- * A limit clause in the parsetree overrides the
- * tcount parameter
- * ----------------
- */
- count = parseTree->limitCount;
- }
- else
- {
- /* ----------------
- * No LIMIT clause in parsetree. Use a local Const node
- * to put tcount into it
- * ----------------
- */
- memset(&tcount_const, 0, sizeof(tcount_const));
- tcount_const.type = T_Const;
- tcount_const.consttype = INT4OID;
- tcount_const.constlen = sizeof(int4);
- tcount_const.constvalue = (Datum) tcount;
- tcount_const.constisnull = FALSE;
- tcount_const.constbyval = TRUE;
- tcount_const.constisset = FALSE;
- tcount_const.constiscast = FALSE;
-
- count = (Node *) &tcount_const;
- }
-
if (state == NULL) /* plan preparation */
return res;
#ifdef SPI_EXECUTOR_STATS
elog(FATAL, "SPI_select: retrieve into portal not implemented");
}
- ExecutorRun(queryDesc, state, EXEC_FOR, parseTree->limitOffset, count);
+ ExecutorRun(queryDesc, state, EXEC_FOR, (long) tcount);
_SPI_current->processed = state->es_processed;
if (operation == CMD_SELECT && queryDesc->dest == SPI)
return newnode;
}
+/* ----------------
+ * _copyLimit
+ * ----------------
+ */
+static Limit *
+_copyLimit(Limit *from)
+{
+ Limit *newnode = makeNode(Limit);
+
+ /* ----------------
+ * copy node superclass fields
+ * ----------------
+ */
+ CopyPlanFields((Plan *) from, (Plan *) newnode);
+
+ /* ----------------
+ * copy remainder of node
+ * ----------------
+ */
+ Node_Copy(from, newnode, limitOffset);
+ Node_Copy(from, newnode, limitCount);
+
+ return newnode;
+}
+
/* ----------------
* _copyHash
* ----------------
case T_SetOp:
retval = _copySetOp(from);
break;
+ case T_Limit:
+ retval = _copyLimit(from);
+ break;
case T_Hash:
retval = _copyHash(from);
break;
(int) node->flagColIdx);
}
+static void
+_outLimit(StringInfo str, Limit *node)
+{
+ appendStringInfo(str, " LIMIT ");
+ _outPlanInfo(str, (Plan *) node);
+
+ appendStringInfo(str, " :limitOffset ");
+ _outNode(str, node->limitOffset);
+ appendStringInfo(str, " :limitCount ");
+ _outNode(str, node->limitCount);
+}
+
/*
* Hash is a subclass of Plan
*/
case T_SetOp:
_outSetOp(str, obj);
break;
+ case T_Limit:
+ _outLimit(str, obj);
+ break;
case T_Hash:
_outHash(str, obj);
break;
return "UNIQUE";
case T_SetOp:
return "SETOP";
+ case T_Limit:
+ return "LIMIT";
case T_Hash:
return "HASH";
case T_Group:
return node;
}
+Limit *
+make_limit(List *tlist, Plan *lefttree,
+ Node *limitOffset, Node *limitCount)
+{
+ Limit *node = makeNode(Limit);
+ Plan *plan = &node->plan;
+
+ copy_plan_costsize(plan, lefttree);
+
+ plan->state = (EState *) NULL;
+ plan->targetlist = tlist;
+ plan->qual = NIL;
+ plan->lefttree = lefttree;
+ plan->righttree = NULL;
+
+ node->limitOffset = limitOffset;
+ node->limitCount = limitCount;
+
+ return node;
+}
+
Result *
make_result(List *tlist,
Node *resconstantqual,
*/
if (subquery->rowMarks)
elog(ERROR, "FOR UPDATE is not supported in subselects");
- if (subquery->limitOffset || subquery->limitCount)
- elog(ERROR, "LIMIT is not supported in subselects");
/*
* Can't currently pull up a query with setops.
* Maybe after querytree redesign...
if (subquery->setOperations)
return false;
/*
- * Can't pull up a subquery involving grouping, aggregation, or sorting.
+ * Can't pull up a subquery involving grouping, aggregation, sorting,
+ * or limiting.
*/
if (subquery->hasAggs ||
subquery->groupClause ||
subquery->havingQual ||
subquery->sortClause ||
- subquery->distinctClause)
+ subquery->distinctClause ||
+ subquery->limitOffset ||
+ subquery->limitCount)
return false;
/*
* Hack: don't try to pull up a subquery with an empty jointree.
}
else
{
- /* It's a PARAM ... punt ... */
+ /* It's an expression ... punt ... */
tuple_fraction = 0.10;
}
}
}
else
{
-
/*
- * COUNT is a PARAM ... don't know exactly what the
+ * COUNT is an expression ... don't know exactly what the
* limit will be, but for lack of a better idea assume
* 10% of the plan's result is wanted.
*/
}
/*
- * Finally, if there is a DISTINCT clause, add the UNIQUE node.
+ * If there is a DISTINCT clause, add the UNIQUE node.
*/
if (parse->distinctClause)
{
parse->distinctClause);
}
+ /*
+ * Finally, if there is a LIMIT/OFFSET clause, add the LIMIT node.
+ */
+ if (parse->limitOffset || parse->limitCount)
+ {
+ result_plan = (Plan *) make_limit(tlist, result_plan,
+ parse->limitOffset,
+ parse->limitCount);
+ }
+
return result_plan;
}
case T_Sort:
case T_Unique:
case T_SetOp:
+ case T_Limit:
case T_Hash:
/*
case T_Sort:
case T_Unique:
case T_SetOp:
+ case T_Limit:
case T_Group:
break;
}
}
- /*
- * LIMIT in view is not supported
- */
- if (query->limitOffset != NULL || query->limitCount != NULL)
- elog(ERROR, "LIMIT clause not supported in views");
-
/*
* ... and finally the rule must be named _RETviewname.
*/
* actually run the plan..
* ----------------
*/
- ExecutorRun(queryDesc, state, EXEC_RUN,
- parsetree->limitOffset, parsetree->limitCount);
+ ExecutorRun(queryDesc, state, EXEC_RUN, 0L);
/* save infos for EndCommand */
UpdateCommandInfo(operation, state->es_lastoid, state->es_processed);
/* ----------
* If the Query node has a setOperations tree, then it's the top
- * level of a UNION/INTERSECT/EXCEPT query; only the ORDER BY field
- * is interesting in the top query itself.
+ * level of a UNION/INTERSECT/EXCEPT query; only the ORDER BY and
+ * LIMIT fields are interesting in the top query itself.
* ----------
*/
if (query->setOperations)
sep = ", ";
}
}
+
+ /* Add the LIMIT clause if given */
+ if (query->limitOffset != NULL)
+ {
+ appendStringInfo(buf, " OFFSET ");
+ get_rule_expr(query->limitOffset, context);
+ }
+ if (query->limitCount != NULL)
+ {
+ appendStringInfo(buf, " LIMIT ");
+ get_rule_expr(query->limitCount, context);
+ }
}
static void
*/
extern TupleDesc ExecutorStart(QueryDesc *queryDesc, EState *estate);
extern TupleTableSlot *ExecutorRun(QueryDesc *queryDesc, EState *estate,
- int feature, Node *limoffset, Node *limcount);
+ int feature, long count);
extern void ExecutorEnd(QueryDesc *queryDesc, EState *estate);
extern void ExecConstraints(char *caller, Relation rel,
TupleTableSlot *slot, EState *estate);
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * nodeLimit.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id$
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODELIMIT_H
+#define NODELIMIT_H
+
+#include "nodes/plannodes.h"
+
+extern TupleTableSlot *ExecLimit(Limit *node);
+extern bool ExecInitLimit(Limit *node, EState *estate, Plan *parent);
+extern int ExecCountSlotsLimit(Limit *node);
+extern void ExecEndLimit(Limit *node);
+extern void ExecReScanLimit(Limit *node, ExprContext *exprCtxt, Plan *parent);
+
+#endif /* NODELIMIT_H */
MemoryContext tempContext; /* short-term context for comparisons */
} SetOpState;
+/* ----------------
+ * LimitState information
+ *
+ * Limit nodes are used to enforce LIMIT/OFFSET clauses.
+ * They just select the desired subrange of their subplan's output.
+ *
+ * offset is the number of initial tuples to skip (0 does nothing).
+ * count is the number of tuples to return after skipping the offset tuples.
+ * If no limit count was specified, count is undefined and noCount is true.
+ * ----------------
+ */
+typedef struct LimitState
+{
+ CommonState cstate; /* its first field is NodeTag */
+ long offset; /* current OFFSET value */
+ long count; /* current COUNT, if any */
+ long position; /* 1-based index of last tuple fetched */
+ bool parmsSet; /* have we calculated offset/limit yet? */
+ bool noCount; /* if true, ignore count */
+ bool atEnd; /* if true, we've reached EOF of subplan */
+} LimitState;
+
/* ----------------
* HashState information
T_NestLoop,
T_MergeJoin,
T_HashJoin,
- T_Noname_XXX, /* not used anymore; this tag# is available */
+ T_Limit,
T_Material,
T_Sort,
T_Agg,
T_TidScanState,
T_SubqueryScanState,
T_SetOpState,
+ T_LimitState,
/*---------------------
* TAGS FOR MEMORY NODES (memnodes.h)
* Sort SortState sortstate;
* Unique UniqueState uniquestate;
* SetOp SetOpState setopstate;
+ * Limit LimitState limitstate;
* Hash HashState hashstate;
*
* ----------------------------------------------------------------
SetOpState *setopstate;
} SetOp;
+/* ----------------
+ * limit node
+ * ----------------
+ */
+typedef struct Limit
+{
+ Plan plan;
+ Node *limitOffset; /* OFFSET parameter, or NULL if none */
+ Node *limitCount; /* COUNT parameter, or NULL if none */
+ LimitState *limitstate;
+} Limit;
+
/* ----------------
* hash build node
* ----------------
AttrNumber *grpColIdx, Plan *lefttree);
extern Material *make_material(List *tlist, Plan *lefttree);
extern Unique *make_unique(List *tlist, Plan *lefttree, List *distinctList);
+extern Limit *make_limit(List *tlist, Plan *lefttree,
+ Node *limitOffset, Node *limitCount);
extern SetOp *make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
List *distinctList, AttrNumber flagColIdx);
extern Result *make_result(List *tlist, Node *resconstantqual, Plan *subplan);
projects / users / bernd / postgres.git / commitdiff