mirror of
https://github.com/postgres/postgres.git
synced 2025-04-24 10:47:04 +03:00
0b03e5951b
This allows extension modules to define their own methods for scanning a relation, and get the core code to use them. It's unclear as yet how much use this capability will find, but we won't find out if we never commit it. KaiGai Kohei, reviewed at various times and in various levels of detail by Shigeru Hanada, Tom Lane, Andres Freund, Álvaro Herrera, and myself.
758 lines
18 KiB
C
758 lines
18 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* execProcnode.c
|
|
* contains dispatch functions which call the appropriate "initialize",
|
|
* "get a tuple", and "cleanup" routines for the given node type.
|
|
* If the node has children, then it will presumably call ExecInitNode,
|
|
* ExecProcNode, or ExecEndNode on its subnodes and do the appropriate
|
|
* processing.
|
|
*
|
|
* Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* src/backend/executor/execProcnode.c
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
/*
|
|
* INTERFACE ROUTINES
|
|
* 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
|
|
*
|
|
* NOTES
|
|
* This used to be three files. It is now all combined into
|
|
* one file so that it is easier to keep ExecInitNode, ExecProcNode,
|
|
* and ExecEndNode in sync when new nodes are added.
|
|
*
|
|
* EXAMPLE
|
|
* Suppose we want the age of the manager of the shoe department and
|
|
* the number of employees in that department. So we have the query:
|
|
*
|
|
* select DEPT.no_emps, EMP.age
|
|
* from DEPT, EMP
|
|
* where EMP.name = DEPT.mgr and
|
|
* DEPT.name = "shoe"
|
|
*
|
|
* Suppose the planner gives us the following plan:
|
|
*
|
|
* Nest Loop (DEPT.mgr = EMP.name)
|
|
* / \
|
|
* / \
|
|
* Seq Scan Seq Scan
|
|
* DEPT EMP
|
|
* (name = "shoe")
|
|
*
|
|
* ExecutorStart() is called first.
|
|
* It calls InitPlan() which calls ExecInitNode() on
|
|
* the root of the plan -- the nest loop node.
|
|
*
|
|
* * ExecInitNode() notices that it is looking at a nest loop and
|
|
* as the code below demonstrates, it calls ExecInitNestLoop().
|
|
* Eventually this calls ExecInitNode() on the right and left subplans
|
|
* and so forth until the entire plan is initialized. The result
|
|
* of ExecInitNode() is a plan state tree built with the same structure
|
|
* as the underlying plan tree.
|
|
*
|
|
* * Then when ExecutorRun() is called, it calls ExecutePlan() which calls
|
|
* ExecProcNode() repeatedly on the top node of the plan state tree.
|
|
* Each time this happens, ExecProcNode() will end up calling
|
|
* ExecNestLoop(), which calls ExecProcNode() on its subplans.
|
|
* Each of these subplans is a sequential scan so ExecSeqScan() is
|
|
* called. The slots returned by ExecSeqScan() may contain
|
|
* tuples which contain the attributes ExecNestLoop() uses to
|
|
* form the tuples it returns.
|
|
*
|
|
* * Eventually ExecSeqScan() stops returning tuples and the nest
|
|
* loop join ends. Lastly, ExecutorEnd() calls ExecEndNode() which
|
|
* calls ExecEndNestLoop() which in turn calls ExecEndNode() on
|
|
* its subplans which result in ExecEndSeqScan().
|
|
*
|
|
* This should show how the executor works by having
|
|
* ExecInitNode(), ExecProcNode() and ExecEndNode() dispatch
|
|
* their work to the appopriate node support routines which may
|
|
* in turn call these routines themselves on their subplans.
|
|
*/
|
|
#include "postgres.h"
|
|
|
|
#include "executor/executor.h"
|
|
#include "executor/nodeAgg.h"
|
|
#include "executor/nodeAppend.h"
|
|
#include "executor/nodeBitmapAnd.h"
|
|
#include "executor/nodeBitmapHeapscan.h"
|
|
#include "executor/nodeBitmapIndexscan.h"
|
|
#include "executor/nodeBitmapOr.h"
|
|
#include "executor/nodeCtescan.h"
|
|
#include "executor/nodeCustom.h"
|
|
#include "executor/nodeForeignscan.h"
|
|
#include "executor/nodeFunctionscan.h"
|
|
#include "executor/nodeGroup.h"
|
|
#include "executor/nodeHash.h"
|
|
#include "executor/nodeHashjoin.h"
|
|
#include "executor/nodeIndexonlyscan.h"
|
|
#include "executor/nodeIndexscan.h"
|
|
#include "executor/nodeLimit.h"
|
|
#include "executor/nodeLockRows.h"
|
|
#include "executor/nodeMaterial.h"
|
|
#include "executor/nodeMergeAppend.h"
|
|
#include "executor/nodeMergejoin.h"
|
|
#include "executor/nodeModifyTable.h"
|
|
#include "executor/nodeNestloop.h"
|
|
#include "executor/nodeRecursiveunion.h"
|
|
#include "executor/nodeResult.h"
|
|
#include "executor/nodeSeqscan.h"
|
|
#include "executor/nodeSetOp.h"
|
|
#include "executor/nodeSort.h"
|
|
#include "executor/nodeSubplan.h"
|
|
#include "executor/nodeSubqueryscan.h"
|
|
#include "executor/nodeTidscan.h"
|
|
#include "executor/nodeUnique.h"
|
|
#include "executor/nodeValuesscan.h"
|
|
#include "executor/nodeWindowAgg.h"
|
|
#include "executor/nodeWorktablescan.h"
|
|
#include "miscadmin.h"
|
|
|
|
|
|
/* ------------------------------------------------------------------------
|
|
* ExecInitNode
|
|
*
|
|
* Recursively initializes all the nodes in the plan tree rooted
|
|
* at 'node'.
|
|
*
|
|
* Inputs:
|
|
* 'node' is the current node of the plan produced by the query planner
|
|
* 'estate' is the shared execution state for the plan tree
|
|
* 'eflags' is a bitwise OR of flag bits described in executor.h
|
|
*
|
|
* Returns a PlanState node corresponding to the given Plan node.
|
|
* ------------------------------------------------------------------------
|
|
*/
|
|
PlanState *
|
|
ExecInitNode(Plan *node, EState *estate, int eflags)
|
|
{
|
|
PlanState *result;
|
|
List *subps;
|
|
ListCell *l;
|
|
|
|
/*
|
|
* do nothing when we get to the end of a leaf on tree.
|
|
*/
|
|
if (node == NULL)
|
|
return NULL;
|
|
|
|
switch (nodeTag(node))
|
|
{
|
|
/*
|
|
* control nodes
|
|
*/
|
|
case T_Result:
|
|
result = (PlanState *) ExecInitResult((Result *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_ModifyTable:
|
|
result = (PlanState *) ExecInitModifyTable((ModifyTable *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_Append:
|
|
result = (PlanState *) ExecInitAppend((Append *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_MergeAppend:
|
|
result = (PlanState *) ExecInitMergeAppend((MergeAppend *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_RecursiveUnion:
|
|
result = (PlanState *) ExecInitRecursiveUnion((RecursiveUnion *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_BitmapAnd:
|
|
result = (PlanState *) ExecInitBitmapAnd((BitmapAnd *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_BitmapOr:
|
|
result = (PlanState *) ExecInitBitmapOr((BitmapOr *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
/*
|
|
* scan nodes
|
|
*/
|
|
case T_SeqScan:
|
|
result = (PlanState *) ExecInitSeqScan((SeqScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_IndexScan:
|
|
result = (PlanState *) ExecInitIndexScan((IndexScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_IndexOnlyScan:
|
|
result = (PlanState *) ExecInitIndexOnlyScan((IndexOnlyScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_BitmapIndexScan:
|
|
result = (PlanState *) ExecInitBitmapIndexScan((BitmapIndexScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_BitmapHeapScan:
|
|
result = (PlanState *) ExecInitBitmapHeapScan((BitmapHeapScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_TidScan:
|
|
result = (PlanState *) ExecInitTidScan((TidScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_SubqueryScan:
|
|
result = (PlanState *) ExecInitSubqueryScan((SubqueryScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_FunctionScan:
|
|
result = (PlanState *) ExecInitFunctionScan((FunctionScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_ValuesScan:
|
|
result = (PlanState *) ExecInitValuesScan((ValuesScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_CteScan:
|
|
result = (PlanState *) ExecInitCteScan((CteScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_WorkTableScan:
|
|
result = (PlanState *) ExecInitWorkTableScan((WorkTableScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_ForeignScan:
|
|
result = (PlanState *) ExecInitForeignScan((ForeignScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_CustomScan:
|
|
result = (PlanState *) ExecInitCustomScan((CustomScan *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
/*
|
|
* join nodes
|
|
*/
|
|
case T_NestLoop:
|
|
result = (PlanState *) ExecInitNestLoop((NestLoop *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_MergeJoin:
|
|
result = (PlanState *) ExecInitMergeJoin((MergeJoin *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_HashJoin:
|
|
result = (PlanState *) ExecInitHashJoin((HashJoin *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
/*
|
|
* materialization nodes
|
|
*/
|
|
case T_Material:
|
|
result = (PlanState *) ExecInitMaterial((Material *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_Sort:
|
|
result = (PlanState *) ExecInitSort((Sort *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_Group:
|
|
result = (PlanState *) ExecInitGroup((Group *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_Agg:
|
|
result = (PlanState *) ExecInitAgg((Agg *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_WindowAgg:
|
|
result = (PlanState *) ExecInitWindowAgg((WindowAgg *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_Unique:
|
|
result = (PlanState *) ExecInitUnique((Unique *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_Hash:
|
|
result = (PlanState *) ExecInitHash((Hash *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_SetOp:
|
|
result = (PlanState *) ExecInitSetOp((SetOp *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_LockRows:
|
|
result = (PlanState *) ExecInitLockRows((LockRows *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
case T_Limit:
|
|
result = (PlanState *) ExecInitLimit((Limit *) node,
|
|
estate, eflags);
|
|
break;
|
|
|
|
default:
|
|
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
|
|
result = NULL; /* keep compiler quiet */
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Initialize any initPlans present in this node. The planner put them in
|
|
* a separate list for us.
|
|
*/
|
|
subps = NIL;
|
|
foreach(l, node->initPlan)
|
|
{
|
|
SubPlan *subplan = (SubPlan *) lfirst(l);
|
|
SubPlanState *sstate;
|
|
|
|
Assert(IsA(subplan, SubPlan));
|
|
sstate = ExecInitSubPlan(subplan, result);
|
|
subps = lappend(subps, sstate);
|
|
}
|
|
result->initPlan = subps;
|
|
|
|
/* Set up instrumentation for this node if requested */
|
|
if (estate->es_instrument)
|
|
result->instrument = InstrAlloc(1, estate->es_instrument);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
* ExecProcNode
|
|
*
|
|
* Execute the given node to return a(nother) tuple.
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
TupleTableSlot *
|
|
ExecProcNode(PlanState *node)
|
|
{
|
|
TupleTableSlot *result;
|
|
|
|
CHECK_FOR_INTERRUPTS();
|
|
|
|
if (node->chgParam != NULL) /* something changed */
|
|
ExecReScan(node); /* let ReScan handle this */
|
|
|
|
if (node->instrument)
|
|
InstrStartNode(node->instrument);
|
|
|
|
switch (nodeTag(node))
|
|
{
|
|
/*
|
|
* control nodes
|
|
*/
|
|
case T_ResultState:
|
|
result = ExecResult((ResultState *) node);
|
|
break;
|
|
|
|
case T_ModifyTableState:
|
|
result = ExecModifyTable((ModifyTableState *) node);
|
|
break;
|
|
|
|
case T_AppendState:
|
|
result = ExecAppend((AppendState *) node);
|
|
break;
|
|
|
|
case T_MergeAppendState:
|
|
result = ExecMergeAppend((MergeAppendState *) node);
|
|
break;
|
|
|
|
case T_RecursiveUnionState:
|
|
result = ExecRecursiveUnion((RecursiveUnionState *) node);
|
|
break;
|
|
|
|
/* BitmapAndState does not yield tuples */
|
|
|
|
/* BitmapOrState does not yield tuples */
|
|
|
|
/*
|
|
* scan nodes
|
|
*/
|
|
case T_SeqScanState:
|
|
result = ExecSeqScan((SeqScanState *) node);
|
|
break;
|
|
|
|
case T_IndexScanState:
|
|
result = ExecIndexScan((IndexScanState *) node);
|
|
break;
|
|
|
|
case T_IndexOnlyScanState:
|
|
result = ExecIndexOnlyScan((IndexOnlyScanState *) node);
|
|
break;
|
|
|
|
/* BitmapIndexScanState does not yield tuples */
|
|
|
|
case T_BitmapHeapScanState:
|
|
result = ExecBitmapHeapScan((BitmapHeapScanState *) node);
|
|
break;
|
|
|
|
case T_TidScanState:
|
|
result = ExecTidScan((TidScanState *) node);
|
|
break;
|
|
|
|
case T_SubqueryScanState:
|
|
result = ExecSubqueryScan((SubqueryScanState *) node);
|
|
break;
|
|
|
|
case T_FunctionScanState:
|
|
result = ExecFunctionScan((FunctionScanState *) node);
|
|
break;
|
|
|
|
case T_ValuesScanState:
|
|
result = ExecValuesScan((ValuesScanState *) node);
|
|
break;
|
|
|
|
case T_CteScanState:
|
|
result = ExecCteScan((CteScanState *) node);
|
|
break;
|
|
|
|
case T_WorkTableScanState:
|
|
result = ExecWorkTableScan((WorkTableScanState *) node);
|
|
break;
|
|
|
|
case T_ForeignScanState:
|
|
result = ExecForeignScan((ForeignScanState *) node);
|
|
break;
|
|
|
|
case T_CustomScanState:
|
|
result = ExecCustomScan((CustomScanState *) node);
|
|
break;
|
|
|
|
/*
|
|
* join nodes
|
|
*/
|
|
case T_NestLoopState:
|
|
result = ExecNestLoop((NestLoopState *) node);
|
|
break;
|
|
|
|
case T_MergeJoinState:
|
|
result = ExecMergeJoin((MergeJoinState *) node);
|
|
break;
|
|
|
|
case T_HashJoinState:
|
|
result = ExecHashJoin((HashJoinState *) node);
|
|
break;
|
|
|
|
/*
|
|
* materialization nodes
|
|
*/
|
|
case T_MaterialState:
|
|
result = ExecMaterial((MaterialState *) node);
|
|
break;
|
|
|
|
case T_SortState:
|
|
result = ExecSort((SortState *) node);
|
|
break;
|
|
|
|
case T_GroupState:
|
|
result = ExecGroup((GroupState *) node);
|
|
break;
|
|
|
|
case T_AggState:
|
|
result = ExecAgg((AggState *) node);
|
|
break;
|
|
|
|
case T_WindowAggState:
|
|
result = ExecWindowAgg((WindowAggState *) node);
|
|
break;
|
|
|
|
case T_UniqueState:
|
|
result = ExecUnique((UniqueState *) node);
|
|
break;
|
|
|
|
case T_HashState:
|
|
result = ExecHash((HashState *) node);
|
|
break;
|
|
|
|
case T_SetOpState:
|
|
result = ExecSetOp((SetOpState *) node);
|
|
break;
|
|
|
|
case T_LockRowsState:
|
|
result = ExecLockRows((LockRowsState *) node);
|
|
break;
|
|
|
|
case T_LimitState:
|
|
result = ExecLimit((LimitState *) node);
|
|
break;
|
|
|
|
default:
|
|
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
|
|
result = NULL;
|
|
break;
|
|
}
|
|
|
|
if (node->instrument)
|
|
InstrStopNode(node->instrument, TupIsNull(result) ? 0.0 : 1.0);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
* MultiExecProcNode
|
|
*
|
|
* Execute a node that doesn't return individual tuples
|
|
* (it might return a hashtable, bitmap, etc). Caller should
|
|
* check it got back the expected kind of Node.
|
|
*
|
|
* This has essentially the same responsibilities as ExecProcNode,
|
|
* but it does not do InstrStartNode/InstrStopNode (mainly because
|
|
* it can't tell how many returned tuples to count). Each per-node
|
|
* function must provide its own instrumentation support.
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
Node *
|
|
MultiExecProcNode(PlanState *node)
|
|
{
|
|
Node *result;
|
|
|
|
CHECK_FOR_INTERRUPTS();
|
|
|
|
if (node->chgParam != NULL) /* something changed */
|
|
ExecReScan(node); /* let ReScan handle this */
|
|
|
|
switch (nodeTag(node))
|
|
{
|
|
/*
|
|
* Only node types that actually support multiexec will be listed
|
|
*/
|
|
|
|
case T_HashState:
|
|
result = MultiExecHash((HashState *) node);
|
|
break;
|
|
|
|
case T_BitmapIndexScanState:
|
|
result = MultiExecBitmapIndexScan((BitmapIndexScanState *) node);
|
|
break;
|
|
|
|
case T_BitmapAndState:
|
|
result = MultiExecBitmapAnd((BitmapAndState *) node);
|
|
break;
|
|
|
|
case T_BitmapOrState:
|
|
result = MultiExecBitmapOr((BitmapOrState *) node);
|
|
break;
|
|
|
|
default:
|
|
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
|
|
result = NULL;
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
* ExecEndNode
|
|
*
|
|
* Recursively cleans up all the nodes in the plan rooted
|
|
* at 'node'.
|
|
*
|
|
* After this operation, the query plan will not be able to be
|
|
* processed any further. This should be called only after
|
|
* the query plan has been fully executed.
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
void
|
|
ExecEndNode(PlanState *node)
|
|
{
|
|
/*
|
|
* do nothing when we get to the end of a leaf on tree.
|
|
*/
|
|
if (node == NULL)
|
|
return;
|
|
|
|
if (node->chgParam != NULL)
|
|
{
|
|
bms_free(node->chgParam);
|
|
node->chgParam = NULL;
|
|
}
|
|
|
|
switch (nodeTag(node))
|
|
{
|
|
/*
|
|
* control nodes
|
|
*/
|
|
case T_ResultState:
|
|
ExecEndResult((ResultState *) node);
|
|
break;
|
|
|
|
case T_ModifyTableState:
|
|
ExecEndModifyTable((ModifyTableState *) node);
|
|
break;
|
|
|
|
case T_AppendState:
|
|
ExecEndAppend((AppendState *) node);
|
|
break;
|
|
|
|
case T_MergeAppendState:
|
|
ExecEndMergeAppend((MergeAppendState *) node);
|
|
break;
|
|
|
|
case T_RecursiveUnionState:
|
|
ExecEndRecursiveUnion((RecursiveUnionState *) node);
|
|
break;
|
|
|
|
case T_BitmapAndState:
|
|
ExecEndBitmapAnd((BitmapAndState *) node);
|
|
break;
|
|
|
|
case T_BitmapOrState:
|
|
ExecEndBitmapOr((BitmapOrState *) node);
|
|
break;
|
|
|
|
/*
|
|
* scan nodes
|
|
*/
|
|
case T_SeqScanState:
|
|
ExecEndSeqScan((SeqScanState *) node);
|
|
break;
|
|
|
|
case T_IndexScanState:
|
|
ExecEndIndexScan((IndexScanState *) node);
|
|
break;
|
|
|
|
case T_IndexOnlyScanState:
|
|
ExecEndIndexOnlyScan((IndexOnlyScanState *) node);
|
|
break;
|
|
|
|
case T_BitmapIndexScanState:
|
|
ExecEndBitmapIndexScan((BitmapIndexScanState *) node);
|
|
break;
|
|
|
|
case T_BitmapHeapScanState:
|
|
ExecEndBitmapHeapScan((BitmapHeapScanState *) node);
|
|
break;
|
|
|
|
case T_TidScanState:
|
|
ExecEndTidScan((TidScanState *) node);
|
|
break;
|
|
|
|
case T_SubqueryScanState:
|
|
ExecEndSubqueryScan((SubqueryScanState *) node);
|
|
break;
|
|
|
|
case T_FunctionScanState:
|
|
ExecEndFunctionScan((FunctionScanState *) node);
|
|
break;
|
|
|
|
case T_ValuesScanState:
|
|
ExecEndValuesScan((ValuesScanState *) node);
|
|
break;
|
|
|
|
case T_CteScanState:
|
|
ExecEndCteScan((CteScanState *) node);
|
|
break;
|
|
|
|
case T_WorkTableScanState:
|
|
ExecEndWorkTableScan((WorkTableScanState *) node);
|
|
break;
|
|
|
|
case T_ForeignScanState:
|
|
ExecEndForeignScan((ForeignScanState *) node);
|
|
break;
|
|
|
|
case T_CustomScanState:
|
|
ExecEndCustomScan((CustomScanState *) node);
|
|
break;
|
|
|
|
/*
|
|
* join nodes
|
|
*/
|
|
case T_NestLoopState:
|
|
ExecEndNestLoop((NestLoopState *) node);
|
|
break;
|
|
|
|
case T_MergeJoinState:
|
|
ExecEndMergeJoin((MergeJoinState *) node);
|
|
break;
|
|
|
|
case T_HashJoinState:
|
|
ExecEndHashJoin((HashJoinState *) node);
|
|
break;
|
|
|
|
/*
|
|
* materialization nodes
|
|
*/
|
|
case T_MaterialState:
|
|
ExecEndMaterial((MaterialState *) node);
|
|
break;
|
|
|
|
case T_SortState:
|
|
ExecEndSort((SortState *) node);
|
|
break;
|
|
|
|
case T_GroupState:
|
|
ExecEndGroup((GroupState *) node);
|
|
break;
|
|
|
|
case T_AggState:
|
|
ExecEndAgg((AggState *) node);
|
|
break;
|
|
|
|
case T_WindowAggState:
|
|
ExecEndWindowAgg((WindowAggState *) node);
|
|
break;
|
|
|
|
case T_UniqueState:
|
|
ExecEndUnique((UniqueState *) node);
|
|
break;
|
|
|
|
case T_HashState:
|
|
ExecEndHash((HashState *) node);
|
|
break;
|
|
|
|
case T_SetOpState:
|
|
ExecEndSetOp((SetOpState *) node);
|
|
break;
|
|
|
|
case T_LockRowsState:
|
|
ExecEndLockRows((LockRowsState *) node);
|
|
break;
|
|
|
|
case T_LimitState:
|
|
ExecEndLimit((LimitState *) node);
|
|
break;
|
|
|
|
default:
|
|
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
|
|
break;
|
|
}
|
|
}
|