src/backend/executor/nodeWorktablescan.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * nodeWorktablescan.c
   4  *        routines to handle WorkTableScan nodes.
   5  *
   6  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $PostgreSQL$
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15
  16 #include "postgres.h"
  17
  18 #include "executor/execdebug.h"
  19 #include "executor/nodeWorktablescan.h"
  20
  21 static TupleTableSlot *WorkTableScanNext(WorkTableScanState *node);
  22
  23 /* ----------------------------------------------------------------
  24  *              WorkTableScanNext
  25  *
  26  *              This is a workhorse for ExecWorkTableScan
  27  * ----------------------------------------------------------------
  28  */
  29 static TupleTableSlot *
  30 WorkTableScanNext(WorkTableScanState *node)
  31 {
  32         TupleTableSlot *slot;
  33         EState     *estate;
  34         Tuplestorestate *tuplestorestate;
  35
  36         /*
  37          * get information from the estate and scan state
  38          *
  39          * Note: we intentionally do not support backward scan.  Although it would
  40          * take only a couple more lines here, it would force nodeRecursiveunion.c
  41          * to create the tuplestore with backward scan enabled, which has a
  42          * performance cost.  In practice backward scan is never useful for a
  43          * worktable plan node, since it cannot appear high enough in the plan
  44          * tree of a scrollable cursor to be exposed to a backward-scan
  45          * requirement.  So it's not worth expending effort to support it.
  46          *
  47          * Note: we are also assuming that this node is the only reader of the
  48          * worktable.  Therefore, we don't need a private read pointer for the
  49          * tuplestore, nor do we need to tell tuplestore_gettupleslot to copy.
  50          */
  51         estate = node->ss.ps.state;
  52         Assert(ScanDirectionIsForward(estate->es_direction));
  53
  54         tuplestorestate = node->rustate->working_table;
  55
  56         /*
  57          * Get the next tuple from tuplestore. Return NULL if no more tuples.
  58          */
  59         slot = node->ss.ss_ScanTupleSlot;
  60         (void) tuplestore_gettupleslot(tuplestorestate, true, false, slot);
  61         return slot;
  62 }
  63
  64 /* ----------------------------------------------------------------
  65  *              ExecWorkTableScan(node)
  66  *
  67  *              Scans the worktable sequentially and returns the next qualifying tuple.
  68  *              It calls the ExecScan() routine and passes it the access method
  69  *              which retrieves tuples sequentially.
  70  * ----------------------------------------------------------------
  71  */
  72 TupleTableSlot *
  73 ExecWorkTableScan(WorkTableScanState *node)
  74 {
  75         /*
  76          * On the first call, find the ancestor RecursiveUnion's state via the
  77          * Param slot reserved for it.  (We can't do this during node init because
  78          * there are corner cases where we'll get the init call before the
  79          * RecursiveUnion does.)
  80          */
  81         if (node->rustate == NULL)
  82         {
  83                 WorkTableScan *plan = (WorkTableScan *) node->ss.ps.plan;
  84                 EState     *estate = node->ss.ps.state;
  85                 ParamExecData *param;
  86
  87                 param = &(estate->es_param_exec_vals[plan->wtParam]);
  88                 Assert(param->execPlan == NULL);
  89                 Assert(!param->isnull);
  90                 node->rustate = (RecursiveUnionState *) DatumGetPointer(param->value);
  91                 Assert(node->rustate && IsA(node->rustate, RecursiveUnionState));
  92
  93                 /*
  94                  * The scan tuple type (ie, the rowtype we expect to find in the work
  95                  * table) is the same as the result rowtype of the ancestor
  96                  * RecursiveUnion node.  Note this depends on the assumption that
  97                  * RecursiveUnion doesn't allow projection.
  98                  */
  99                 ExecAssignScanType(&node->ss,
 100                                                    ExecGetResultType(&node->rustate->ps));
 101
 102                 /*
 103                  * Now we can initialize the projection info.  This must be completed
 104                  * before we can call ExecScan().
 105                  */
 106                 ExecAssignScanProjectionInfo(&node->ss);
 107         }
 108
 109         /*
 110          * use WorkTableScanNext as access method
 111          */
 112         return ExecScan(&node->ss, (ExecScanAccessMtd) WorkTableScanNext);
 113 }
 114
 115
 116 /* ----------------------------------------------------------------
 117  *              ExecInitWorkTableScan
 118  * ----------------------------------------------------------------
 119  */
 120 WorkTableScanState *
 121 ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags)
 122 {
 123         WorkTableScanState *scanstate;
 124
 125         /* check for unsupported flags */
 126         Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 127
 128         /*
 129          * WorkTableScan should not have any children.
 130          */
 131         Assert(outerPlan(node) == NULL);
 132         Assert(innerPlan(node) == NULL);
 133
 134         /*
 135          * create new WorkTableScanState for node
 136          */
 137         scanstate = makeNode(WorkTableScanState);
 138         scanstate->ss.ps.plan = (Plan *) node;
 139         scanstate->ss.ps.state = estate;
 140         scanstate->rustate = NULL;      /* we'll set this later */
 141
 142         /*
 143          * Miscellaneous initialization
 144          *
 145          * create expression context for node
 146          */
 147         ExecAssignExprContext(estate, &scanstate->ss.ps);
 148
 149         /*
 150          * initialize child expressions
 151          */
 152         scanstate->ss.ps.targetlist = (List *)
 153                 ExecInitExpr((Expr *) node->scan.plan.targetlist,
 154                                          (PlanState *) scanstate);
 155         scanstate->ss.ps.qual = (List *)
 156                 ExecInitExpr((Expr *) node->scan.plan.qual,
 157                                          (PlanState *) scanstate);
 158
 159 #define WORKTABLESCAN_NSLOTS 2
 160
 161         /*
 162          * tuple table initialization
 163          */
 164         ExecInitResultTupleSlot(estate, &scanstate->ss.ps);
 165         ExecInitScanTupleSlot(estate, &scanstate->ss);
 166
 167         /*
 168          * Initialize result tuple type, but not yet projection info.
 169          */
 170         ExecAssignResultTypeFromTL(&scanstate->ss.ps);
 171
 172         scanstate->ss.ps.ps_TupFromTlist = false;
 173
 174         return scanstate;
 175 }
 176
 177 int
 178 ExecCountSlotsWorkTableScan(WorkTableScan *node)
 179 {
 180         return ExecCountSlotsNode(outerPlan(node)) +
 181                 ExecCountSlotsNode(innerPlan(node)) +
 182                 WORKTABLESCAN_NSLOTS;
 183 }
 184
 185 /* ----------------------------------------------------------------
 186  *              ExecEndWorkTableScan
 187  *
 188  *              frees any storage allocated through C routines.
 189  * ----------------------------------------------------------------
 190  */
 191 void
 192 ExecEndWorkTableScan(WorkTableScanState *node)
 193 {
 194         /*
 195          * Free exprcontext
 196          */
 197         ExecFreeExprContext(&node->ss.ps);
 198
 199         /*
 200          * clean out the tuple table
 201          */
 202         ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 203         ExecClearTuple(node->ss.ss_ScanTupleSlot);
 204 }
 205
 206 /* ----------------------------------------------------------------
 207  *              ExecWorkTableScanReScan
 208  *
 209  *              Rescans the relation.
 210  * ----------------------------------------------------------------
 211  */
 212 void
 213 ExecWorkTableScanReScan(WorkTableScanState *node, ExprContext *exprCtxt)
 214 {
 215         ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 216         node->ss.ps.ps_TupFromTlist = false;
 217
 218         /* No need (or way) to rescan if ExecWorkTableScan not called yet */
 219         if (node->rustate)
 220                 tuplestore_rescan(node->rustate->working_table);
 221 }