open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove no-longer-needed ExecCountSlots infrastructure.

Browse Source
REL8_5_ALPHA2_BRANCH
Tom Lane 16 years ago
parent f92e8a4b5e
commit 421d7d8edb
56 changed files with 56 additions and 477 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 119
      src/backend/executor/execProcnode.c
  2. 12
      src/backend/executor/nodeAgg.c
  3. 15
      src/backend/executor/nodeAppend.c
  4. 15
      src/backend/executor/nodeBitmapAnd.c
  5. 11
      src/backend/executor/nodeBitmapHeapscan.c
  6. 11
      src/backend/executor/nodeBitmapIndexscan.c
  7. 15
      src/backend/executor/nodeBitmapOr.c
  8. 12
      src/backend/executor/nodeCtescan.c
  9. 12
      src/backend/executor/nodeFunctionscan.c
  10. 10
      src/backend/executor/nodeGroup.c
  11. 12
      src/backend/executor/nodeHash.c
  12. 12
      src/backend/executor/nodeHashjoin.c
  13. 11
      src/backend/executor/nodeIndexscan.c
  14. 12
      src/backend/executor/nodeLimit.c
  15. 12
      src/backend/executor/nodeMaterial.c
  16. 12
      src/backend/executor/nodeMergejoin.c
  17. 12
      src/backend/executor/nodeNestloop.c
  18. 12
      src/backend/executor/nodeRecursiveunion.c
  19. 10
      src/backend/executor/nodeResult.c
  20. 12
      src/backend/executor/nodeSeqscan.c
  21. 12
      src/backend/executor/nodeSetOp.c
  22. 12
      src/backend/executor/nodeSort.c
  23. 13
      src/backend/executor/nodeSubqueryscan.c
  24. 11
      src/backend/executor/nodeTidscan.c
  25. 12
      src/backend/executor/nodeUnique.c
  26. 12
      src/backend/executor/nodeValuesscan.c
  27. 16
      src/backend/executor/nodeWindowAgg.c
  28. 12
      src/backend/executor/nodeWorktablescan.c
  29. 3
      src/include/executor/executor.h
  30. 3
      src/include/executor/nodeAgg.h
  31. 3
      src/include/executor/nodeAppend.h
  32. 3
      src/include/executor/nodeBitmapAnd.h
  33. 3
      src/include/executor/nodeBitmapHeapscan.h
  34. 3
      src/include/executor/nodeBitmapIndexscan.h
  35. 3
      src/include/executor/nodeBitmapOr.h
  36. 3
      src/include/executor/nodeCtescan.h
  37. 3
      src/include/executor/nodeFunctionscan.h
  38. 3
      src/include/executor/nodeGroup.h
  39. 3
      src/include/executor/nodeHash.h
  40. 3
      src/include/executor/nodeHashjoin.h
  41. 3
      src/include/executor/nodeIndexscan.h
  42. 3
      src/include/executor/nodeLimit.h
  43. 3
      src/include/executor/nodeMaterial.h
  44. 3
      src/include/executor/nodeMergejoin.h
  45. 3
      src/include/executor/nodeNestloop.h
  46. 3
      src/include/executor/nodeRecursiveunion.h
  47. 3
      src/include/executor/nodeResult.h
  48. 3
      src/include/executor/nodeSeqscan.h
  49. 3
      src/include/executor/nodeSetOp.h
  50. 3
      src/include/executor/nodeSort.h
  51. 3
      src/include/executor/nodeSubqueryscan.h
  52. 3
      src/include/executor/nodeTidscan.h
  53. 3
      src/include/executor/nodeUnique.h
  54. 3
      src/include/executor/nodeValuesscan.h
  55. 3
      src/include/executor/nodeWindowAgg.h
  56. 3
      src/include/executor/nodeWorktablescan.h

119
src/backend/executor/execProcnode.c
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
*

3
src/include/executor/executor.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.159 2009/09/12 22:12:04 tgl Exp $
* $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.160 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -177,7 +177,6 @@ extern DestReceiver *CreateIntoRelDestReceiver(void);
extern PlanState *ExecInitNode(Plan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecProcNode(PlanState *node);
extern Node *MultiExecProcNode(PlanState *node);
extern int ExecCountSlotsNode(Plan *node);
extern void ExecEndNode(PlanState *node);
/*

3
src/include/executor/nodeAgg.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeAgg.h,v 1.30 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeAgg.h,v 1.31 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsAgg(Agg *node);
extern AggState *ExecInitAgg(Agg *node, EState *estate, int eflags);
extern TupleTableSlot *ExecAgg(AggState *node);
extern void ExecEndAgg(AggState *node);

3
src/include/executor/nodeAppend.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeAppend.h,v 1.28 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeAppend.h,v 1.29 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsAppend(Append *node);
extern AppendState *ExecInitAppend(Append *node, EState *estate, int eflags);
extern TupleTableSlot *ExecAppend(AppendState *node);
extern void ExecEndAppend(AppendState *node);

3
src/include/executor/nodeBitmapAnd.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeBitmapAnd.h,v 1.6 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeBitmapAnd.h,v 1.7 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsBitmapAnd(BitmapAnd *node);
extern BitmapAndState *ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags);
extern Node *MultiExecBitmapAnd(BitmapAndState *node);
extern void ExecEndBitmapAnd(BitmapAndState *node);

3
src/include/executor/nodeBitmapHeapscan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeBitmapHeapscan.h,v 1.6 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeBitmapHeapscan.h,v 1.7 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsBitmapHeapScan(BitmapHeapScan *node);
extern BitmapHeapScanState *ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecBitmapHeapScan(BitmapHeapScanState *node);
extern void ExecEndBitmapHeapScan(BitmapHeapScanState *node);

3
src/include/executor/nodeBitmapIndexscan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeBitmapIndexscan.h,v 1.6 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeBitmapIndexscan.h,v 1.7 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsBitmapIndexScan(BitmapIndexScan *node);
extern BitmapIndexScanState *ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags);
extern Node *MultiExecBitmapIndexScan(BitmapIndexScanState *node);
extern void ExecEndBitmapIndexScan(BitmapIndexScanState *node);

3
src/include/executor/nodeBitmapOr.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeBitmapOr.h,v 1.6 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeBitmapOr.h,v 1.7 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsBitmapOr(BitmapOr *node);
extern BitmapOrState *ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags);
extern Node *MultiExecBitmapOr(BitmapOrState *node);
extern void ExecEndBitmapOr(BitmapOrState *node);

3
src/include/executor/nodeCtescan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeCtescan.h,v 1.2 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeCtescan.h,v 1.3 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsCteScan(CteScan *node);
extern CteScanState *ExecInitCteScan(CteScan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecCteScan(CteScanState *node);
extern void ExecEndCteScan(CteScanState *node);

3
src/include/executor/nodeFunctionscan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeFunctionscan.h,v 1.13 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeFunctionscan.h,v 1.14 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsFunctionScan(FunctionScan *node);
extern FunctionScanState *ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecFunctionScan(FunctionScanState *node);
extern void ExecEndFunctionScan(FunctionScanState *node);

3
src/include/executor/nodeGroup.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeGroup.h,v 1.33 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeGroup.h,v 1.34 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsGroup(Group *node);
extern GroupState *ExecInitGroup(Group *node, EState *estate, int eflags);
extern TupleTableSlot *ExecGroup(GroupState *node);
extern void ExecEndGroup(GroupState *node);

3
src/include/executor/nodeHash.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeHash.h,v 1.47 2009/03/21 00:04:40 tgl Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeHash.h,v 1.48 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsHash(Hash *node);
extern HashState *ExecInitHash(Hash *node, EState *estate, int eflags);
extern TupleTableSlot *ExecHash(HashState *node);
extern Node *MultiExecHash(HashState *node);

3
src/include/executor/nodeHashjoin.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeHashjoin.h,v 1.38 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeHashjoin.h,v 1.39 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
#include "storage/buffile.h"
extern int ExecCountSlotsHashJoin(HashJoin *node);
extern HashJoinState *ExecInitHashJoin(HashJoin *node, EState *estate, int eflags);
extern TupleTableSlot *ExecHashJoin(HashJoinState *node);
extern void ExecEndHashJoin(HashJoinState *node);

3
src/include/executor/nodeIndexscan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeIndexscan.h,v 1.34 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeIndexscan.h,v 1.35 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsIndexScan(IndexScan *node);
extern IndexScanState *ExecInitIndexScan(IndexScan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecIndexScan(IndexScanState *node);
extern void ExecEndIndexScan(IndexScanState *node);

3
src/include/executor/nodeLimit.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeLimit.h,v 1.16 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeLimit.h,v 1.17 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsLimit(Limit *node);
extern LimitState *ExecInitLimit(Limit *node, EState *estate, int eflags);
extern TupleTableSlot *ExecLimit(LimitState *node);
extern void ExecEndLimit(LimitState *node);

3
src/include/executor/nodeMaterial.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeMaterial.h,v 1.28 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeMaterial.h,v 1.29 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsMaterial(Material *node);
extern MaterialState *ExecInitMaterial(Material *node, EState *estate, int eflags);
extern TupleTableSlot *ExecMaterial(MaterialState *node);
extern void ExecEndMaterial(MaterialState *node);

3
src/include/executor/nodeMergejoin.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeMergejoin.h,v 1.27 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeMergejoin.h,v 1.28 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsMergeJoin(MergeJoin *node);
extern MergeJoinState *ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags);
extern TupleTableSlot *ExecMergeJoin(MergeJoinState *node);
extern void ExecEndMergeJoin(MergeJoinState *node);

3
src/include/executor/nodeNestloop.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeNestloop.h,v 1.28 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeNestloop.h,v 1.29 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsNestLoop(NestLoop *node);
extern NestLoopState *ExecInitNestLoop(NestLoop *node, EState *estate, int eflags);
extern TupleTableSlot *ExecNestLoop(NestLoopState *node);
extern void ExecEndNestLoop(NestLoopState *node);

3
src/include/executor/nodeRecursiveunion.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeRecursiveunion.h,v 1.2 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeRecursiveunion.h,v 1.3 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsRecursiveUnion(RecursiveUnion *node);
extern RecursiveUnionState *ExecInitRecursiveUnion(RecursiveUnion *node, EState *estate, int eflags);
extern TupleTableSlot *ExecRecursiveUnion(RecursiveUnionState *node);
extern void ExecEndRecursiveUnion(RecursiveUnionState *node);

3
src/include/executor/nodeResult.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeResult.h,v 1.26 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeResult.h,v 1.27 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsResult(Result *node);
extern ResultState *ExecInitResult(Result *node, EState *estate, int eflags);
extern TupleTableSlot *ExecResult(ResultState *node);
extern void ExecEndResult(ResultState *node);

3
src/include/executor/nodeSeqscan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeSeqscan.h,v 1.27 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeSeqscan.h,v 1.28 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsSeqScan(SeqScan *node);
extern SeqScanState *ExecInitSeqScan(SeqScan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecSeqScan(SeqScanState *node);
extern void ExecEndSeqScan(SeqScanState *node);

3
src/include/executor/nodeSetOp.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeSetOp.h,v 1.16 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeSetOp.h,v 1.17 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsSetOp(SetOp *node);
extern SetOpState *ExecInitSetOp(SetOp *node, EState *estate, int eflags);
extern TupleTableSlot *ExecSetOp(SetOpState *node);
extern void ExecEndSetOp(SetOpState *node);

3
src/include/executor/nodeSort.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeSort.h,v 1.25 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeSort.h,v 1.26 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsSort(Sort *node);
extern SortState *ExecInitSort(Sort *node, EState *estate, int eflags);
extern TupleTableSlot *ExecSort(SortState *node);
extern void ExecEndSort(SortState *node);

3
src/include/executor/nodeSubqueryscan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeSubqueryscan.h,v 1.16 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeSubqueryscan.h,v 1.17 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsSubqueryScan(SubqueryScan *node);
extern SubqueryScanState *ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecSubqueryScan(SubqueryScanState *node);
extern void ExecEndSubqueryScan(SubqueryScanState *node);

3
src/include/executor/nodeTidscan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeTidscan.h,v 1.20 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeTidscan.h,v 1.21 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsTidScan(TidScan *node);
extern TidScanState *ExecInitTidScan(TidScan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecTidScan(TidScanState *node);
extern void ExecEndTidScan(TidScanState *node);

3
src/include/executor/nodeUnique.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeUnique.h,v 1.25 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeUnique.h,v 1.26 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsUnique(Unique *node);
extern UniqueState *ExecInitUnique(Unique *node, EState *estate, int eflags);
extern TupleTableSlot *ExecUnique(UniqueState *node);
extern void ExecEndUnique(UniqueState *node);

3
src/include/executor/nodeValuesscan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeValuesscan.h,v 1.5 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeValuesscan.h,v 1.6 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsValuesScan(ValuesScan *node);
extern ValuesScanState *ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecValuesScan(ValuesScanState *node);
extern void ExecEndValuesScan(ValuesScanState *node);

3
src/include/executor/nodeWindowAgg.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeWindowAgg.h,v 1.2 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeWindowAgg.h,v 1.3 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsWindowAgg(WindowAgg *node);
extern WindowAggState *ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags);
extern TupleTableSlot *ExecWindowAgg(WindowAggState *node);
extern void ExecEndWindowAgg(WindowAggState *node);

3
src/include/executor/nodeWorktablescan.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/executor/nodeWorktablescan.h,v 1.2 2009/01/01 17:23:59 momjian Exp $
* $PostgreSQL: pgsql/src/include/executor/nodeWorktablescan.h,v 1.3 2009/09/27 21:10:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,7 +16,6 @@
#include "nodes/execnodes.h"
extern int ExecCountSlotsWorkTableScan(WorkTableScan *node);
extern WorkTableScanState *ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags);
extern TupleTableSlot *ExecWorkTableScan(WorkTableScanState *node);
extern void ExecEndWorkTableScan(WorkTableScanState *node);

Write Preview
Loading…
Cancel
Save