src/backend/executor/nodeSeqscan.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * nodeSeqscan.c
   4  *        Support routines for sequential scans of relations.
   5  *
   6  * Portions Copyright (c) 1996-2008, 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  * INTERFACE ROUTINES
  17  *              ExecSeqScan                             sequentially scans a relation.
  18  *              ExecSeqNext                             retrieve next tuple in sequential order.
  19  *              ExecInitSeqScan                 creates and initializes a seqscan node.
  20  *              ExecEndSeqScan                  releases any storage allocated.
  21  *              ExecSeqReScan                   rescans the relation
  22  *              ExecSeqMarkPos                  marks scan position
  23  *              ExecSeqRestrPos                 restores scan position
  24  */
  25 #include "postgres.h"
  26
  27 #include "access/heapam.h"
  28 #include "access/relscan.h"
  29 #include "executor/execdebug.h"
  30 #include "executor/nodeSeqscan.h"
  31
  32 static void InitScanRelation(SeqScanState *node, EState *estate);
  33 static TupleTableSlot *SeqNext(SeqScanState *node);
  34
  35 /* ----------------------------------------------------------------
  36  *                                              Scan Support
  37  * ----------------------------------------------------------------
  38  */
  39 /* ----------------------------------------------------------------
  40  *              SeqNext
  41  *
  42  *              This is a workhorse for ExecSeqScan
  43  * ----------------------------------------------------------------
  44  */
  45 static TupleTableSlot *
  46 SeqNext(SeqScanState *node)
  47 {
  48         HeapTuple       tuple;
  49         HeapScanDesc scandesc;
  50         Index           scanrelid;
  51         EState     *estate;
  52         ScanDirection direction;
  53         TupleTableSlot *slot;
  54
  55         /*
  56          * get information from the estate and scan state
  57          */
  58         estate = node->ps.state;
  59         scandesc = node->ss_currentScanDesc;
  60         scanrelid = ((SeqScan *) node->ps.plan)->scanrelid;
  61         direction = estate->es_direction;
  62         slot = node->ss_ScanTupleSlot;
  63
  64         /*
  65          * Check if we are evaluating PlanQual for tuple of this relation.
  66          * Additional checking is not good, but no other way for now. We could
  67          * introduce new nodes for this case and handle SeqScan --> NewNode
  68          * switching in Init/ReScan plan...
  69          */
  70         if (estate->es_evTuple != NULL &&
  71                 estate->es_evTuple[scanrelid - 1] != NULL)
  72         {
  73                 if (estate->es_evTupleNull[scanrelid - 1])
  74                         return ExecClearTuple(slot);
  75
  76                 ExecStoreTuple(estate->es_evTuple[scanrelid - 1],
  77                                            slot, InvalidBuffer, false);
  78
  79                 /*
  80                  * Note that unlike IndexScan, SeqScan never use keys in
  81                  * heap_beginscan (and this is very bad) - so, here we do not check
  82                  * are keys ok or not.
  83                  */
  84
  85                 /* Flag for the next call that no more tuples */
  86                 estate->es_evTupleNull[scanrelid - 1] = true;
  87                 return slot;
  88         }
  89
  90         /*
  91          * get the next tuple from the access methods
  92          */
  93         tuple = heap_getnext(scandesc, direction);
  94
  95         /*
  96          * save the tuple and the buffer returned to us by the access methods in
  97          * our scan tuple slot and return the slot.  Note: we pass 'false' because
  98          * tuples returned by heap_getnext() are pointers onto disk pages and were
  99          * not created with palloc() and so should not be pfree()'d.  Note also
 100          * that ExecStoreTuple will increment the refcount of the buffer; the
 101          * refcount will not be dropped until the tuple table slot is cleared.
 102          */
 103         if (tuple)
 104                 ExecStoreTuple(tuple,   /* tuple to store */
 105                                            slot,        /* slot to store in */
 106                                            scandesc->rs_cbuf,           /* buffer associated with this
 107                                                                                                  * tuple */
 108                                            false);      /* don't pfree this pointer */
 109         else
 110                 ExecClearTuple(slot);
 111
 112         return slot;
 113 }
 114
 115 /* ----------------------------------------------------------------
 116  *              ExecSeqScan(node)
 117  *
 118  *              Scans the relation sequentially and returns the next qualifying
 119  *              tuple.
 120  *              It calls the ExecScan() routine and passes it the access method
 121  *              which retrieve tuples sequentially.
 122  *
 123  */
 124
 125 TupleTableSlot *
 126 ExecSeqScan(SeqScanState *node)
 127 {
 128         /*
 129          * use SeqNext as access method
 130          */
 131         return ExecScan((ScanState *) node, (ExecScanAccessMtd) SeqNext);
 132 }
 133
 134 /* ----------------------------------------------------------------
 135  *              InitScanRelation
 136  *
 137  *              This does the initialization for scan relations and
 138  *              subplans of scans.
 139  * ----------------------------------------------------------------
 140  */
 141 static void
 142 InitScanRelation(SeqScanState *node, EState *estate)
 143 {
 144         Relation        currentRelation;
 145         HeapScanDesc currentScanDesc;
 146
 147         /*
 148          * get the relation object id from the relid'th entry in the range table,
 149          * open that relation and acquire appropriate lock on it.
 150          */
 151         currentRelation = ExecOpenScanRelation(estate,
 152                                                                          ((SeqScan *) node->ps.plan)->scanrelid);
 153
 154         currentScanDesc = heap_beginscan(currentRelation,
 155                                                                          estate->es_snapshot,
 156                                                                          0,
 157                                                                          NULL);
 158
 159         node->ss_currentRelation = currentRelation;
 160         node->ss_currentScanDesc = currentScanDesc;
 161
 162         ExecAssignScanType(node, RelationGetDescr(currentRelation));
 163 }
 164
 165
 166 /* ----------------------------------------------------------------
 167  *              ExecInitSeqScan
 168  * ----------------------------------------------------------------
 169  */
 170 SeqScanState *
 171 ExecInitSeqScan(SeqScan *node, EState *estate, int eflags)
 172 {
 173         SeqScanState *scanstate;
 174
 175         /*
 176          * Once upon a time it was possible to have an outerPlan of a SeqScan, but
 177          * not any more.
 178          */
 179         Assert(outerPlan(node) == NULL);
 180         Assert(innerPlan(node) == NULL);
 181
 182         /*
 183          * create state structure
 184          */
 185         scanstate = makeNode(SeqScanState);
 186         scanstate->ps.plan = (Plan *) node;
 187         scanstate->ps.state = estate;
 188
 189         /*
 190          * Miscellaneous initialization
 191          *
 192          * create expression context for node
 193          */
 194         ExecAssignExprContext(estate, &scanstate->ps);
 195
 196         /*
 197          * initialize child expressions
 198          */
 199         scanstate->ps.targetlist = (List *)
 200                 ExecInitExpr((Expr *) node->plan.targetlist,
 201                                          (PlanState *) scanstate);
 202         scanstate->ps.qual = (List *)
 203                 ExecInitExpr((Expr *) node->plan.qual,
 204                                          (PlanState *) scanstate);
 205
 206 #define SEQSCAN_NSLOTS 2
 207
 208         /*
 209          * tuple table initialization
 210          */
 211         ExecInitResultTupleSlot(estate, &scanstate->ps);
 212         ExecInitScanTupleSlot(estate, scanstate);
 213
 214         /*
 215          * initialize scan relation
 216          */
 217         InitScanRelation(scanstate, estate);
 218
 219         scanstate->ps.ps_TupFromTlist = false;
 220
 221         /*
 222          * Initialize result tuple type and projection info.
 223          */
 224         ExecAssignResultTypeFromTL(&scanstate->ps);
 225         ExecAssignScanProjectionInfo(scanstate);
 226
 227         return scanstate;
 228 }
 229
 230 int
 231 ExecCountSlotsSeqScan(SeqScan *node)
 232 {
 233         return ExecCountSlotsNode(outerPlan(node)) +
 234                 ExecCountSlotsNode(innerPlan(node)) +
 235                 SEQSCAN_NSLOTS;
 236 }
 237
 238 /* ----------------------------------------------------------------
 239  *              ExecEndSeqScan
 240  *
 241  *              frees any storage allocated through C routines.
 242  * ----------------------------------------------------------------
 243  */
 244 void
 245 ExecEndSeqScan(SeqScanState *node)
 246 {
 247         Relation        relation;
 248         HeapScanDesc scanDesc;
 249
 250         /*
 251          * get information from node
 252          */
 253         relation = node->ss_currentRelation;
 254         scanDesc = node->ss_currentScanDesc;
 255
 256         /*
 257          * Free the exprcontext
 258          */
 259         ExecFreeExprContext(&node->ps);
 260
 261         /*
 262          * clean out the tuple table
 263          */
 264         ExecClearTuple(node->ps.ps_ResultTupleSlot);
 265         ExecClearTuple(node->ss_ScanTupleSlot);
 266
 267         /*
 268          * close heap scan
 269          */
 270         heap_endscan(scanDesc);
 271
 272         /*
 273          * close the heap relation.
 274          */
 275         ExecCloseScanRelation(relation);
 276 }
 277
 278 /* ----------------------------------------------------------------
 279  *                                              Join Support
 280  * ----------------------------------------------------------------
 281  */
 282
 283 /* ----------------------------------------------------------------
 284  *              ExecSeqReScan
 285  *
 286  *              Rescans the relation.
 287  * ----------------------------------------------------------------
 288  */
 289 void
 290 ExecSeqReScan(SeqScanState *node, ExprContext *exprCtxt)
 291 {
 292         EState     *estate;
 293         Index           scanrelid;
 294         HeapScanDesc scan;
 295
 296         estate = node->ps.state;
 297         scanrelid = ((SeqScan *) node->ps.plan)->scanrelid;
 298
 299         node->ps.ps_TupFromTlist = false;
 300
 301         /* If this is re-scanning of PlanQual ... */
 302         if (estate->es_evTuple != NULL &&
 303                 estate->es_evTuple[scanrelid - 1] != NULL)
 304         {
 305                 estate->es_evTupleNull[scanrelid - 1] = false;
 306                 return;
 307         }
 308
 309         scan = node->ss_currentScanDesc;
 310
 311         heap_rescan(scan,                       /* scan desc */
 312                                 NULL);                  /* new scan keys */
 313 }
 314
 315 /* ----------------------------------------------------------------
 316  *              ExecSeqMarkPos(node)
 317  *
 318  *              Marks scan position.
 319  * ----------------------------------------------------------------
 320  */
 321 void
 322 ExecSeqMarkPos(SeqScanState *node)
 323 {
 324         HeapScanDesc scan = node->ss_currentScanDesc;
 325
 326         heap_markpos(scan);
 327 }
 328
 329 /* ----------------------------------------------------------------
 330  *              ExecSeqRestrPos
 331  *
 332  *              Restores scan position.
 333  * ----------------------------------------------------------------
 334  */
 335 void
 336 ExecSeqRestrPos(SeqScanState *node)
 337 {
 338         HeapScanDesc scan = node->ss_currentScanDesc;
 339
 340         /*
 341          * Clear any reference to the previously returned tuple.  This is needed
 342          * because the slot is simply pointing at scan->rs_cbuf, which
 343          * heap_restrpos will change; we'd have an internally inconsistent slot if
 344          * we didn't do this.
 345          */
 346         ExecClearTuple(node->ss_ScanTupleSlot);
 347
 348         heap_restrpos(scan);
 349 }