Logo Search packages:      
Sourcecode: postgresql-8.4 version File versions  Download package

execProcnode.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-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *      $PostgreSQL: pgsql/src/backend/executor/execProcnode.c,v 1.65 2009/01/01 17:23:41 momjian 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
 *
 *     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
 *                      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 ExecRun() 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, ExecEnd() 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/instrument.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/nodeFunctionscan.h"
#include "executor/nodeGroup.h"
#include "executor/nodeHash.h"
#include "executor/nodeHashjoin.h"
#include "executor/nodeIndexscan.h"
#include "executor/nodeLimit.h"
#include "executor/nodeMaterial.h"
#include "executor/nodeMergejoin.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_Append:
                  result = (PlanState *) ExecInitAppend((Append *) 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_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;

                  /*
                   * 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_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);

      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, NULL); /* 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_AppendState:
                  result = ExecAppend((AppendState *) 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;

                  /* 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;

                  /*
                   * 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_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, NULL); /* 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;
}


/*
 * 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
 *
 *          Recursively cleans up all the nodes in the plan rooted
 *          at 'node'.
 *
 *          After this operation, the query plan will not be able to
 *          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_AppendState:
                  ExecEndAppend((AppendState *) 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_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;

                  /*
                   * 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_LimitState:
                  ExecEndLimit((LimitState *) node);
                  break;

            default:
                  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
                  break;
      }
}

Generated by  Doxygen 1.6.0   Back to index