src/backend/executor/nodeValuesscan.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * nodeValuesscan.c
   4  *        Support routines for scanning Values lists
   5  *        ("VALUES (...), (...), ..." in rangetable).
   6  *
   7  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  *
  11  * IDENTIFICATION
  12  *        $PostgreSQL$
  13  *
  14  *-------------------------------------------------------------------------
  15  */
  16 /*
  17  * INTERFACE ROUTINES
  18  *              ExecValuesScan                  scans a values list.
  19  *              ExecValuesNext                  retrieve next tuple in sequential order.
  20  *              ExecInitValuesScan              creates and initializes a valuesscan node.
  21  *              ExecEndValuesScan               releases any storage allocated.
  22  *              ExecValuesReScan                rescans the values list
  23  */
  24 #include "postgres.h"
  25
  26 #include "executor/executor.h"
  27 #include "executor/nodeValuesscan.h"
  28 #include "utils/memutils.h"
  29
  30
  31 static TupleTableSlot *ValuesNext(ValuesScanState *node);
  32
  33
  34 /* ----------------------------------------------------------------
  35  *                                              Scan Support
  36  * ----------------------------------------------------------------
  37  */
  38
  39 /* ----------------------------------------------------------------
  40  *              ValuesNext
  41  *
  42  *              This is a workhorse for ExecValuesScan
  43  * ----------------------------------------------------------------
  44  */
  45 static TupleTableSlot *
  46 ValuesNext(ValuesScanState *node)
  47 {
  48         TupleTableSlot *slot;
  49         EState     *estate;
  50         ExprContext *econtext;
  51         ScanDirection direction;
  52         List       *exprlist;
  53
  54         /*
  55          * get information from the estate and scan state
  56          */
  57         estate = node->ss.ps.state;
  58         direction = estate->es_direction;
  59         slot = node->ss.ss_ScanTupleSlot;
  60         econtext = node->rowcontext;
  61
  62         /*
  63          * Get the next tuple. Return NULL if no more tuples.
  64          */
  65         if (ScanDirectionIsForward(direction))
  66         {
  67                 if (node->curr_idx < node->array_len)
  68                         node->curr_idx++;
  69                 if (node->curr_idx < node->array_len)
  70                         exprlist = node->exprlists[node->curr_idx];
  71                 else
  72                         exprlist = NIL;
  73         }
  74         else
  75         {
  76                 if (node->curr_idx >= 0)
  77                         node->curr_idx--;
  78                 if (node->curr_idx >= 0)
  79                         exprlist = node->exprlists[node->curr_idx];
  80                 else
  81                         exprlist = NIL;
  82         }
  83
  84         /*
  85          * Always clear the result slot; this is appropriate if we are at the end
  86          * of the data, and if we're not, we still need it as the first step of
  87          * the store-virtual-tuple protocol.  It seems wise to clear the slot
  88          * before we reset the context it might have pointers into.
  89          */
  90         ExecClearTuple(slot);
  91
  92         if (exprlist)
  93         {
  94                 MemoryContext oldContext;
  95                 List       *exprstatelist;
  96                 Datum      *values;
  97                 bool       *isnull;
  98                 ListCell   *lc;
  99                 int                     resind;
 100
 101                 /*
 102                  * Get rid of any prior cycle's leftovers.  We use ReScanExprContext
 103                  * not just ResetExprContext because we want any registered shutdown
 104                  * callbacks to be called.
 105                  */
 106                 ReScanExprContext(econtext);
 107
 108                 /*
 109                  * Build the expression eval state in the econtext's per-tuple memory.
 110                  * This is a tad unusual, but we want to delete the eval state again
 111                  * when we move to the next row, to avoid growth of memory
 112                  * requirements over a long values list.
 113                  */
 114                 oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
 115
 116                 /*
 117                  * Pass NULL, not my plan node, because we don't want anything in this
 118                  * transient state linking into permanent state.  The only possibility
 119                  * is a SubPlan, and there shouldn't be any (any subselects in the
 120                  * VALUES list should be InitPlans).
 121                  */
 122                 exprstatelist = (List *) ExecInitExpr((Expr *) exprlist, NULL);
 123
 124                 /* parser should have checked all sublists are the same length */
 125                 Assert(list_length(exprstatelist) == slot->tts_tupleDescriptor->natts);
 126
 127                 /*
 128                  * Compute the expressions and build a virtual result tuple. We
 129                  * already did ExecClearTuple(slot).
 130                  */
 131                 values = slot->tts_values;
 132                 isnull = slot->tts_isnull;
 133
 134                 resind = 0;
 135                 foreach(lc, exprstatelist)
 136                 {
 137                         ExprState  *estate = (ExprState *) lfirst(lc);
 138
 139                         values[resind] = ExecEvalExpr(estate,
 140                                                                                   econtext,
 141                                                                                   &isnull[resind],
 142                                                                                   NULL);
 143                         resind++;
 144                 }
 145
 146                 MemoryContextSwitchTo(oldContext);
 147
 148                 /*
 149                  * And return the virtual tuple.
 150                  */
 151                 ExecStoreVirtualTuple(slot);
 152         }
 153
 154         return slot;
 155 }
 156
 157
 158 /* ----------------------------------------------------------------
 159  *              ExecValuesScan(node)
 160  *
 161  *              Scans the values lists sequentially and returns the next qualifying
 162  *              tuple.
 163  *              It calls the ExecScan() routine and passes it the access method
 164  *              which retrieves tuples sequentially.
 165  * ----------------------------------------------------------------
 166  */
 167 TupleTableSlot *
 168 ExecValuesScan(ValuesScanState *node)
 169 {
 170         /*
 171          * use ValuesNext as access method
 172          */
 173         return ExecScan(&node->ss, (ExecScanAccessMtd) ValuesNext);
 174 }
 175
 176 /* ----------------------------------------------------------------
 177  *              ExecInitValuesScan
 178  * ----------------------------------------------------------------
 179  */
 180 ValuesScanState *
 181 ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags)
 182 {
 183         ValuesScanState *scanstate;
 184         TupleDesc       tupdesc;
 185         ListCell   *vtl;
 186         int                     i;
 187         PlanState  *planstate;
 188
 189         /*
 190          * ValuesScan should not have any children.
 191          */
 192         Assert(outerPlan(node) == NULL);
 193         Assert(innerPlan(node) == NULL);
 194
 195         /*
 196          * create new ScanState for node
 197          */
 198         scanstate = makeNode(ValuesScanState);
 199         scanstate->ss.ps.plan = (Plan *) node;
 200         scanstate->ss.ps.state = estate;
 201
 202         /*
 203          * Miscellaneous initialization
 204          */
 205         planstate = &scanstate->ss.ps;
 206
 207         /*
 208          * Create expression contexts.  We need two, one for per-sublist
 209          * processing and one for execScan.c to use for quals and projections. We
 210          * cheat a little by using ExecAssignExprContext() to build both.
 211          */
 212         ExecAssignExprContext(estate, planstate);
 213         scanstate->rowcontext = planstate->ps_ExprContext;
 214         ExecAssignExprContext(estate, planstate);
 215
 216 #define VALUESSCAN_NSLOTS 2
 217
 218         /*
 219          * tuple table initialization
 220          */
 221         ExecInitResultTupleSlot(estate, &scanstate->ss.ps);
 222         ExecInitScanTupleSlot(estate, &scanstate->ss);
 223
 224         /*
 225          * initialize child expressions
 226          */
 227         scanstate->ss.ps.targetlist = (List *)
 228                 ExecInitExpr((Expr *) node->scan.plan.targetlist,
 229                                          (PlanState *) scanstate);
 230         scanstate->ss.ps.qual = (List *)
 231                 ExecInitExpr((Expr *) node->scan.plan.qual,
 232                                          (PlanState *) scanstate);
 233
 234         /*
 235          * get info about values list
 236          */
 237         tupdesc = ExecTypeFromExprList((List *) linitial(node->values_lists));
 238
 239         ExecAssignScanType(&scanstate->ss, tupdesc);
 240
 241         /*
 242          * Other node-specific setup
 243          */
 244         scanstate->marked_idx = -1;
 245         scanstate->curr_idx = -1;
 246         scanstate->array_len = list_length(node->values_lists);
 247
 248         /* convert list of sublists into array of sublists for easy addressing */
 249         scanstate->exprlists = (List **)
 250                 palloc(scanstate->array_len * sizeof(List *));
 251         i = 0;
 252         foreach(vtl, node->values_lists)
 253         {
 254                 scanstate->exprlists[i++] = (List *) lfirst(vtl);
 255         }
 256
 257         scanstate->ss.ps.ps_TupFromTlist = false;
 258
 259         /*
 260          * Initialize result tuple type and projection info.
 261          */
 262         ExecAssignResultTypeFromTL(&scanstate->ss.ps);
 263         ExecAssignScanProjectionInfo(&scanstate->ss);
 264
 265         return scanstate;
 266 }
 267
 268 int
 269 ExecCountSlotsValuesScan(ValuesScan *node)
 270 {
 271         return ExecCountSlotsNode(outerPlan(node)) +
 272                 ExecCountSlotsNode(innerPlan(node)) +
 273                 VALUESSCAN_NSLOTS;
 274 }
 275
 276 /* ----------------------------------------------------------------
 277  *              ExecEndValuesScan
 278  *
 279  *              frees any storage allocated through C routines.
 280  * ----------------------------------------------------------------
 281  */
 282 void
 283 ExecEndValuesScan(ValuesScanState *node)
 284 {
 285         /*
 286          * Free both exprcontexts
 287          */
 288         ExecFreeExprContext(&node->ss.ps);
 289         node->ss.ps.ps_ExprContext = node->rowcontext;
 290         ExecFreeExprContext(&node->ss.ps);
 291
 292         /*
 293          * clean out the tuple table
 294          */
 295         ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 296         ExecClearTuple(node->ss.ss_ScanTupleSlot);
 297 }
 298
 299 /* ----------------------------------------------------------------
 300  *              ExecValuesMarkPos
 301  *
 302  *              Marks scan position.
 303  * ----------------------------------------------------------------
 304  */
 305 void
 306 ExecValuesMarkPos(ValuesScanState *node)
 307 {
 308         node->marked_idx = node->curr_idx;
 309 }
 310
 311 /* ----------------------------------------------------------------
 312  *              ExecValuesRestrPos
 313  *
 314  *              Restores scan position.
 315  * ----------------------------------------------------------------
 316  */
 317 void
 318 ExecValuesRestrPos(ValuesScanState *node)
 319 {
 320         node->curr_idx = node->marked_idx;
 321 }
 322
 323 /* ----------------------------------------------------------------
 324  *              ExecValuesReScan
 325  *
 326  *              Rescans the relation.
 327  * ----------------------------------------------------------------
 328  */
 329 void
 330 ExecValuesReScan(ValuesScanState *node, ExprContext *exprCtxt)
 331 {
 332         ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 333         node->ss.ps.ps_TupFromTlist = false;
 334
 335         node->curr_idx = -1;
 336 }