database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-08-05 07:41:25 +03:00
Code Activity

Remove no-longer-needed ExecCountSlots infrastructure.

Browse Source
This commit is contained in:
Tom Lane
2009-09-27 21:10:53 +00:00
parent f92e8a4b5e
commit 421d7d8edb
56 changed files with 56 additions and 477 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
src/backend/executor/execProcnode.c
View File

@@ -12,13 +12,12 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/execProcnode.c,v 1.65 2009/01/01 17:23:41 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/execProcnode.c,v 1.66 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* INTERFACE ROUTINES
* ExecCountSlotsNode - count tuple slots needed by plan tree
* ExecInitNode - initialize a plan node and its subplans
* ExecProcNode - get a tuple by executing the plan node
* ExecEndNode - shut down a plan node and its subplans
@@ -519,122 +518,6 @@ MultiExecProcNode(PlanState *node)
}
/*
* ExecCountSlotsNode - count up the number of tuple table slots needed
*
* Note that this scans a Plan tree, not a PlanState tree, because we
* haven't built the PlanState tree yet ...
*/
int
ExecCountSlotsNode(Plan *node)
{
if (node == NULL)
return 0;
switch (nodeTag(node))
{
/*
* control nodes
*/
case T_Result:
return ExecCountSlotsResult((Result *) node);
case T_Append:
return ExecCountSlotsAppend((Append *) node);
case T_RecursiveUnion:
return ExecCountSlotsRecursiveUnion((RecursiveUnion *) node);
case T_BitmapAnd:
return ExecCountSlotsBitmapAnd((BitmapAnd *) node);
case T_BitmapOr:
return ExecCountSlotsBitmapOr((BitmapOr *) node);
/*
* scan nodes
*/
case T_SeqScan:
return ExecCountSlotsSeqScan((SeqScan *) node);
case T_IndexScan:
return ExecCountSlotsIndexScan((IndexScan *) node);
case T_BitmapIndexScan:
return ExecCountSlotsBitmapIndexScan((BitmapIndexScan *) node);
case T_BitmapHeapScan:
return ExecCountSlotsBitmapHeapScan((BitmapHeapScan *) node);
case T_TidScan:
return ExecCountSlotsTidScan((TidScan *) node);
case T_SubqueryScan:
return ExecCountSlotsSubqueryScan((SubqueryScan *) node);
case T_FunctionScan:
return ExecCountSlotsFunctionScan((FunctionScan *) node);
case T_ValuesScan:
return ExecCountSlotsValuesScan((ValuesScan *) node);
case T_CteScan:
return ExecCountSlotsCteScan((CteScan *) node);
case T_WorkTableScan:
return ExecCountSlotsWorkTableScan((WorkTableScan *) node);
/*
* join nodes
*/
case T_NestLoop:
return ExecCountSlotsNestLoop((NestLoop *) node);
case T_MergeJoin:
return ExecCountSlotsMergeJoin((MergeJoin *) node);
case T_HashJoin:
return ExecCountSlotsHashJoin((HashJoin *) node);
/*
* materialization nodes
*/
case T_Material:
return ExecCountSlotsMaterial((Material *) node);
case T_Sort:
return ExecCountSlotsSort((Sort *) node);
case T_Group:
return ExecCountSlotsGroup((Group *) node);
case T_Agg:
return ExecCountSlotsAgg((Agg *) node);
case T_WindowAgg:
return ExecCountSlotsWindowAgg((WindowAgg *) node);
break;
case T_Unique:
return ExecCountSlotsUnique((Unique *) node);
case T_Hash:
return ExecCountSlotsHash((Hash *) node);
case T_SetOp:
return ExecCountSlotsSetOp((SetOp *) node);
case T_Limit:
return ExecCountSlotsLimit((Limit *) node);
default:
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
break;
}
return 0;
}
/* ----------------------------------------------------------------
* ExecEndNode
*

12
src/backend/executor/nodeAgg.c
View File

@@ -63,7 +63,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeAgg.c,v 1.168 2009/07/23 20:45:27 tgl Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeAgg.c,v 1.169 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -1239,8 +1239,6 @@ ExecInitAgg(Agg *node, EState *estate, int eflags)
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
#define AGG_NSLOTS 3
/*
* tuple table initialization
*/
@@ -1604,14 +1602,6 @@ GetAggInitVal(Datum textInitVal, Oid transtype)
return initVal;
}
int
ExecCountSlotsAgg(Agg *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
AGG_NSLOTS;
}
void
ExecEndAgg(AggState *node)
{

15
src/backend/executor/nodeAppend.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeAppend.c,v 1.74 2009/01/01 17:23:41 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeAppend.c,v 1.75 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -192,8 +192,6 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
* ExecQual or ExecProject.
*/
#define APPEND_NSLOTS 1
/*
* append nodes still have Result slots, which hold pointers to tuples, so
* we have to initialize them.
@@ -233,17 +231,6 @@ ExecInitAppend(Append *node, EState *estate, int eflags)
return appendstate;
}
int
ExecCountSlotsAppend(Append *node)
{
ListCell *plan;
int nSlots = 0;
foreach(plan, node->appendplans)
nSlots += ExecCountSlotsNode((Plan *) lfirst(plan));
return nSlots + APPEND_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecAppend
*

15
src/backend/executor/nodeBitmapAnd.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeBitmapAnd.c,v 1.11 2009/01/01 17:23:41 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeBitmapAnd.c,v 1.12 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -74,8 +74,6 @@ ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags)
* ExecQual or ExecProject. They don't need any tuple slots either.
*/
#define BITMAPAND_NSLOTS 0
/*
* call ExecInitNode on each of the plans to be executed and save the
* results into the array "bitmapplanstates".
@@ -91,17 +89,6 @@ ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags)
return bitmapandstate;
}
int
ExecCountSlotsBitmapAnd(BitmapAnd *node)
{
ListCell *plan;
int nSlots = 0;
foreach(plan, node->bitmapplans)
nSlots += ExecCountSlotsNode((Plan *) lfirst(plan));
return nSlots + BITMAPAND_NSLOTS;
}
/* ----------------------------------------------------------------
* MultiExecBitmapAnd
* ----------------------------------------------------------------

11
src/backend/executor/nodeBitmapHeapscan.c
View File

@@ -21,7 +21,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeBitmapHeapscan.c,v 1.35 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeBitmapHeapscan.c,v 1.36 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -597,8 +597,6 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)
ExecInitExpr((Expr *) node->bitmapqualorig,
(PlanState *) scanstate);
#define BITMAPHEAPSCAN_NSLOTS 2
/*
* tuple table initialization
*/
@@ -646,10 +644,3 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)
*/
return scanstate;
}
int
ExecCountSlotsBitmapHeapScan(BitmapHeapScan *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) + BITMAPHEAPSCAN_NSLOTS;
}

11
src/backend/executor/nodeBitmapIndexscan.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeBitmapIndexscan.c,v 1.31 2009/07/18 19:15:41 tgl Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeBitmapIndexscan.c,v 1.32 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -235,8 +235,6 @@ ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags)
* sub-parts corresponding to runtime keys (see below).
*/
#define BITMAPINDEXSCAN_NSLOTS 0
/*
* We do not open or lock the base relation here. We assume that an
* ancestor BitmapHeapScan node is holding AccessShareLock (or better) on
@@ -318,10 +316,3 @@ ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags)
*/
return indexstate;
}
int
ExecCountSlotsBitmapIndexScan(BitmapIndexScan *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) + BITMAPINDEXSCAN_NSLOTS;
}

15
src/backend/executor/nodeBitmapOr.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeBitmapOr.c,v 1.10 2009/01/01 17:23:41 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeBitmapOr.c,v 1.11 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -75,8 +75,6 @@ ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags)
* ExecQual or ExecProject. They don't need any tuple slots either.
*/
#define BITMAPOR_NSLOTS 0
/*
* call ExecInitNode on each of the plans to be executed and save the
* results into the array "bitmapplanstates".
@@ -92,17 +90,6 @@ ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags)
return bitmaporstate;
}
int
ExecCountSlotsBitmapOr(BitmapOr *node)
{
ListCell *plan;
int nSlots = 0;
foreach(plan, node->bitmapplans)
nSlots += ExecCountSlotsNode((Plan *) lfirst(plan));
return nSlots + BITMAPOR_NSLOTS;
}
/* ----------------------------------------------------------------
* MultiExecBitmapOr
* ----------------------------------------------------------------

12
src/backend/executor/nodeCtescan.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeCtescan.c,v 1.5 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeCtescan.c,v 1.6 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -237,8 +237,6 @@ ExecInitCteScan(CteScan *node, EState *estate, int eflags)
ExecInitExpr((Expr *) node->scan.plan.qual,
(PlanState *) scanstate);
#define CTESCAN_NSLOTS 2
/*
* tuple table initialization
*/
@@ -263,14 +261,6 @@ ExecInitCteScan(CteScan *node, EState *estate, int eflags)
return scanstate;
}
int
ExecCountSlotsCteScan(CteScan *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
CTESCAN_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndCteScan
*

12
src/backend/executor/nodeFunctionscan.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeFunctionscan.c,v 1.52 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeFunctionscan.c,v 1.53 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -134,8 +134,6 @@ ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags)
*/
ExecAssignExprContext(estate, &scanstate->ss.ps);
#define FUNCTIONSCAN_NSLOTS 2
/*
* tuple table initialization
*/
@@ -220,14 +218,6 @@ ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags)
return scanstate;
}
int
ExecCountSlotsFunctionScan(FunctionScan *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
FUNCTIONSCAN_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndFunctionScan
*

10
src/backend/executor/nodeGroup.c
View File

@@ -15,7 +15,7 @@
* locate group boundaries.
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeGroup.c,v 1.75 2009/04/02 20:59:10 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeGroup.c,v 1.76 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -213,8 +213,6 @@ ExecInitGroup(Group *node, EState *estate, int eflags)
*/
ExecAssignExprContext(estate, &grpstate->ss.ps);
#define GROUP_NSLOTS 2
/*
* tuple table initialization
*/
@@ -259,12 +257,6 @@ ExecInitGroup(Group *node, EState *estate, int eflags)
return grpstate;
}
int
ExecCountSlotsGroup(Group *node)
{
return ExecCountSlotsNode(outerPlan(node)) + GROUP_NSLOTS;
}
/* ------------------------
* ExecEndGroup(node)
*

12
src/backend/executor/nodeHash.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeHash.c,v 1.121 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeHash.c,v 1.122 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -170,8 +170,6 @@ ExecInitHash(Hash *node, EState *estate, int eflags)
*/
ExecAssignExprContext(estate, &hashstate->ps);
#define HASH_NSLOTS 1
/*
* initialize our result slot
*/
@@ -202,14 +200,6 @@ ExecInitHash(Hash *node, EState *estate, int eflags)
return hashstate;
}
int
ExecCountSlotsHash(Hash *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
HASH_NSLOTS;
}
/* ---------------------------------------------------------------
* ExecEndHash
*

12
src/backend/executor/nodeHashjoin.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeHashjoin.c,v 1.101 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeHashjoin.c,v 1.102 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -400,8 +400,6 @@ ExecInitHashJoin(HashJoin *node, EState *estate, int eflags)
outerPlanState(hjstate) = ExecInitNode(outerNode, estate, eflags);
innerPlanState(hjstate) = ExecInitNode((Plan *) hashNode, estate, eflags);
#define HASHJOIN_NSLOTS 3
/*
* tuple table initialization
*/
@@ -494,14 +492,6 @@ ExecInitHashJoin(HashJoin *node, EState *estate, int eflags)
return hjstate;
}
int
ExecCountSlotsHashJoin(HashJoin *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
HASHJOIN_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndHashJoin
*

11
src/backend/executor/nodeIndexscan.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeIndexscan.c,v 1.134 2009/08/23 18:26:08 tgl Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeIndexscan.c,v 1.135 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -537,8 +537,6 @@ ExecInitIndexScan(IndexScan *node, EState *estate, int eflags)
ExecInitExpr((Expr *) node->indexqualorig,
(PlanState *) indexstate);
#define INDEXSCAN_NSLOTS 2
/*
* tuple table initialization
*/
@@ -1074,10 +1072,3 @@ ExecIndexBuildScanKeys(PlanState *planstate, Relation index, Index scanrelid,
else if (n_array_keys != 0)
elog(ERROR, "ScalarArrayOpExpr index qual found where not allowed");
}
int
ExecCountSlotsIndexScan(IndexScan *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) + INDEXSCAN_NSLOTS;
}

12
src/backend/executor/nodeLimit.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeLimit.c,v 1.39 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeLimit.c,v 1.40 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -367,8 +367,6 @@ ExecInitLimit(Limit *node, EState *estate, int eflags)
limitstate->limitCount = ExecInitExpr((Expr *) node->limitCount,
(PlanState *) limitstate);
#define LIMIT_NSLOTS 1
/*
* Tuple table initialization (XXX not actually used...)
*/
@@ -390,14 +388,6 @@ ExecInitLimit(Limit *node, EState *estate, int eflags)
return limitstate;
}
int
ExecCountSlotsLimit(Limit *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
LIMIT_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndLimit
*

12
src/backend/executor/nodeMaterial.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeMaterial.c,v 1.69 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeMaterial.c,v 1.70 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -202,8 +202,6 @@ ExecInitMaterial(Material *node, EState *estate, int eflags)
* ExecQual or ExecProject.
*/
#define MATERIAL_NSLOTS 2
/*
* tuple table initialization
*
@@ -234,14 +232,6 @@ ExecInitMaterial(Material *node, EState *estate, int eflags)
return matstate;
}
int
ExecCountSlotsMaterial(Material *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) +
MATERIAL_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndMaterial
* ----------------------------------------------------------------

12
src/backend/executor/nodeMergejoin.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeMergejoin.c,v 1.97 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeMergejoin.c,v 1.98 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -1466,8 +1466,6 @@ ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags)
else
mergestate->mj_ExtraMarks = false;
#define MERGEJOIN_NSLOTS 4
/*
* tuple table initialization
*/
@@ -1566,14 +1564,6 @@ ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags)
return mergestate;
}
int
ExecCountSlotsMergeJoin(MergeJoin *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) +
MERGEJOIN_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndMergeJoin
*

12
src/backend/executor/nodeNestloop.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeNestloop.c,v 1.53 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeNestloop.c,v 1.54 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -318,8 +318,6 @@ ExecInitNestLoop(NestLoop *node, EState *estate, int eflags)
innerPlanState(nlstate) = ExecInitNode(innerPlan(node), estate,
eflags | EXEC_FLAG_REWIND);
#define NESTLOOP_NSLOTS 2
/*
* tuple table initialization
*/
@@ -360,14 +358,6 @@ ExecInitNestLoop(NestLoop *node, EState *estate, int eflags)
return nlstate;
}
int
ExecCountSlotsNestLoop(NestLoop *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
NESTLOOP_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndNestLoop
*

12
src/backend/executor/nodeRecursiveunion.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeRecursiveunion.c,v 1.4 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeRecursiveunion.c,v 1.5 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -231,8 +231,6 @@ ExecInitRecursiveUnion(RecursiveUnion *node, EState *estate, int eflags)
*/
Assert(node->plan.qual == NIL);
#define RECURSIVEUNION_NSLOTS 1
/*
* RecursiveUnion nodes still have Result slots, which hold pointers to
* tuples, so we have to initialize them.
@@ -269,14 +267,6 @@ ExecInitRecursiveUnion(RecursiveUnion *node, EState *estate, int eflags)
return rustate;
}
int
ExecCountSlotsRecursiveUnion(RecursiveUnion *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
RECURSIVEUNION_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndRecursiveUnionScan
*

10
src/backend/executor/nodeResult.c
View File

@@ -38,7 +38,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeResult.c,v 1.43 2009/01/01 17:23:42 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeResult.c,v 1.44 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -230,8 +230,6 @@ ExecInitResult(Result *node, EState *estate, int eflags)
resstate->ps.ps_TupFromTlist = false;
#define RESULT_NSLOTS 1
/*
* tuple table initialization
*/
@@ -268,12 +266,6 @@ ExecInitResult(Result *node, EState *estate, int eflags)
return resstate;
}
int
ExecCountSlotsResult(Result *node)
{
return ExecCountSlotsNode(outerPlan(node)) + RESULT_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndResult
*

12
src/backend/executor/nodeSeqscan.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeSeqscan.c,v 1.66 2009/01/01 17:23:42 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeSeqscan.c,v 1.67 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -203,8 +203,6 @@ ExecInitSeqScan(SeqScan *node, EState *estate, int eflags)
ExecInitExpr((Expr *) node->plan.qual,
(PlanState *) scanstate);
#define SEQSCAN_NSLOTS 2
/*
* tuple table initialization
*/
@@ -227,14 +225,6 @@ ExecInitSeqScan(SeqScan *node, EState *estate, int eflags)
return scanstate;
}
int
ExecCountSlotsSeqScan(SeqScan *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
SEQSCAN_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndSeqScan
*

12
src/backend/executor/nodeSetOp.c
View File

@@ -37,7 +37,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeSetOp.c,v 1.31 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeSetOp.c,v 1.32 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -523,8 +523,6 @@ ExecInitSetOp(SetOp *node, EState *estate, int eflags)
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
#define SETOP_NSLOTS 1
/*
* Tuple table initialization
*/
@@ -576,14 +574,6 @@ ExecInitSetOp(SetOp *node, EState *estate, int eflags)
return setopstate;
}
int
ExecCountSlotsSetOp(SetOp *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
SETOP_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndSetOp
*

12
src/backend/executor/nodeSort.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeSort.c,v 1.65 2009/04/02 20:59:10 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeSort.c,v 1.66 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -182,8 +182,6 @@ ExecInitSort(Sort *node, EState *estate, int eflags)
* ExecQual or ExecProject.
*/
#define SORT_NSLOTS 2
/*
* tuple table initialization
*
@@ -216,14 +214,6 @@ ExecInitSort(Sort *node, EState *estate, int eflags)
return sortstate;
}
int
ExecCountSlotsSort(Sort *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) +
SORT_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndSort(node)
* ----------------------------------------------------------------

13
src/backend/executor/nodeSubqueryscan.c
View File

@@ -12,7 +12,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeSubqueryscan.c,v 1.40 2009/01/01 17:23:42 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeSubqueryscan.c,v 1.41 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -129,8 +129,6 @@ ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
ExecInitExpr((Expr *) node->scan.plan.qual,
(PlanState *) subquerystate);
#define SUBQUERYSCAN_NSLOTS 2
/*
* tuple table initialization
*/
@@ -159,15 +157,6 @@ ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
return subquerystate;
}
int
ExecCountSlotsSubqueryScan(SubqueryScan *node)
{
Assert(outerPlan(node) == NULL);
Assert(innerPlan(node) == NULL);
return ExecCountSlotsNode(node->subplan) +
SUBQUERYSCAN_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndSubqueryScan
*

11
src/backend/executor/nodeTidscan.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeTidscan.c,v 1.62 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeTidscan.c,v 1.63 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -548,8 +548,6 @@ ExecInitTidScan(TidScan *node, EState *estate, int eflags)
ExecInitExpr((Expr *) node->tidquals,
(PlanState *) tidstate);
#define TIDSCAN_NSLOTS 2
/*
* tuple table initialization
*/
@@ -587,10 +585,3 @@ ExecInitTidScan(TidScan *node, EState *estate, int eflags)
*/
return tidstate;
}
int
ExecCountSlotsTidScan(TidScan *node)
{
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
ExecCountSlotsNode(innerPlan((Plan *) node)) + TIDSCAN_NSLOTS;
}

12
src/backend/executor/nodeUnique.c
View File

@@ -16,7 +16,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeUnique.c,v 1.61 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeUnique.c,v 1.62 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -137,8 +137,6 @@ ExecInitUnique(Unique *node, EState *estate, int eflags)
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
#define UNIQUE_NSLOTS 1
/*
* Tuple table initialization
*/
@@ -166,14 +164,6 @@ ExecInitUnique(Unique *node, EState *estate, int eflags)
return uniquestate;
}
int
ExecCountSlotsUnique(Unique *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
UNIQUE_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndUnique
*

12
src/backend/executor/nodeValuesscan.c
View File

@@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeValuesscan.c,v 1.9 2009/01/01 17:23:42 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeValuesscan.c,v 1.10 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -213,8 +213,6 @@ ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags)
scanstate->rowcontext = planstate->ps_ExprContext;
ExecAssignExprContext(estate, planstate);
#define VALUESSCAN_NSLOTS 2
/*
* tuple table initialization
*/
@@ -265,14 +263,6 @@ ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags)
return scanstate;
}
int
ExecCountSlotsValuesScan(ValuesScan *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
VALUESSCAN_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndValuesScan
*

16
src/backend/executor/nodeWindowAgg.c
View File

@@ -27,7 +27,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeWindowAgg.c,v 1.6 2009/06/20 18:45:28 tgl Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeWindowAgg.c,v 1.7 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -1107,8 +1107,6 @@ ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags)
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
#define WINDOWAGG_NSLOTS 6
/*
* tuple table initialization
*/
@@ -1272,18 +1270,6 @@ ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags)
return winstate;
}
/* -----------------
* ExecCountSlotsWindowAgg
* -----------------
*/
int
ExecCountSlotsWindowAgg(WindowAgg *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
WINDOWAGG_NSLOTS;
}
/* -----------------
* ExecEndWindowAgg
* -----------------

12
src/backend/executor/nodeWorktablescan.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/nodeWorktablescan.c,v 1.7 2009/06/11 14:48:57 momjian Exp $
* $PostgreSQL: pgsql/src/backend/executor/nodeWorktablescan.c,v 1.8 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@@ -156,8 +156,6 @@ ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags)
ExecInitExpr((Expr *) node->scan.plan.qual,
(PlanState *) scanstate);
#define WORKTABLESCAN_NSLOTS 2
/*
* tuple table initialization
*/
@@ -174,14 +172,6 @@ ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags)
return scanstate;
}
int
ExecCountSlotsWorkTableScan(WorkTableScan *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
WORKTABLESCAN_NSLOTS;
}
/* ----------------------------------------------------------------
* ExecEndWorkTableScan
*