Header And Logo
|
#include "postgres.h"#include "access/relscan.h"#include "executor/execdebug.h"#include "executor/nodeSeqscan.h"#include "utils/rel.h"
Go to the source code of this file.
Functions | |
| static void | InitScanRelation (SeqScanState *node, EState *estate, int eflags) |
| static TupleTableSlot * | SeqNext (SeqScanState *node) |
| static bool | SeqRecheck (SeqScanState *node, TupleTableSlot *slot) |
| TupleTableSlot * | ExecSeqScan (SeqScanState *node) |
| SeqScanState * | ExecInitSeqScan (SeqScan *node, EState *estate, int eflags) |
| void | ExecEndSeqScan (SeqScanState *node) |
| void | ExecReScanSeqScan (SeqScanState *node) |
| void | ExecSeqMarkPos (SeqScanState *node) |
| void | ExecSeqRestrPos (SeqScanState *node) |
| void ExecEndSeqScan | ( | SeqScanState * | node | ) |
Definition at line 221 of file nodeSeqscan.c.
References ExecClearTuple(), ExecCloseScanRelation(), ExecFreeExprContext(), heap_endscan(), ScanState::ps, PlanState::ps_ResultTupleSlot, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, and ScanState::ss_ScanTupleSlot.
Referenced by ExecEndNode().
{
Relation relation;
HeapScanDesc scanDesc;
/*
* get information from node
*/
relation = node->ss_currentRelation;
scanDesc = node->ss_currentScanDesc;
/*
* Free the exprcontext
*/
ExecFreeExprContext(&node->ps);
/*
* clean out the tuple table
*/
ExecClearTuple(node->ps.ps_ResultTupleSlot);
ExecClearTuple(node->ss_ScanTupleSlot);
/*
* close heap scan
*/
heap_endscan(scanDesc);
/*
* close the heap relation.
*/
ExecCloseScanRelation(relation);
}
| SeqScanState* ExecInitSeqScan | ( | SeqScan * | node, | |
| EState * | estate, | |||
| int | eflags | |||
| ) |
Definition at line 157 of file nodeSeqscan.c.
References Assert, ExecAssignExprContext(), ExecAssignResultTypeFromTL(), ExecAssignScanProjectionInfo(), ExecInitExpr(), ExecInitResultTupleSlot(), ExecInitScanTupleSlot(), InitScanRelation(), innerPlan, makeNode, NULL, outerPlan, Scan::plan, PlanState::plan, ScanState::ps, PlanState::ps_TupFromTlist, Plan::qual, PlanState::qual, PlanState::state, Plan::targetlist, and PlanState::targetlist.
Referenced by ExecInitNode().
{
SeqScanState *scanstate;
/*
* Once upon a time it was possible to have an outerPlan of a SeqScan, but
* not any more.
*/
Assert(outerPlan(node) == NULL);
Assert(innerPlan(node) == NULL);
/*
* create state structure
*/
scanstate = makeNode(SeqScanState);
scanstate->ps.plan = (Plan *) node;
scanstate->ps.state = estate;
/*
* Miscellaneous initialization
*
* create expression context for node
*/
ExecAssignExprContext(estate, &scanstate->ps);
/*
* initialize child expressions
*/
scanstate->ps.targetlist = (List *)
ExecInitExpr((Expr *) node->plan.targetlist,
(PlanState *) scanstate);
scanstate->ps.qual = (List *)
ExecInitExpr((Expr *) node->plan.qual,
(PlanState *) scanstate);
/*
* tuple table initialization
*/
ExecInitResultTupleSlot(estate, &scanstate->ps);
ExecInitScanTupleSlot(estate, scanstate);
/*
* initialize scan relation
*/
InitScanRelation(scanstate, estate, eflags);
scanstate->ps.ps_TupFromTlist = false;
/*
* Initialize result tuple type and projection info.
*/
ExecAssignResultTypeFromTL(&scanstate->ps);
ExecAssignScanProjectionInfo(scanstate);
return scanstate;
}
| void ExecReScanSeqScan | ( | SeqScanState * | node | ) |
Definition at line 266 of file nodeSeqscan.c.
References ExecScanReScan(), heap_rescan(), NULL, and ScanState::ss_currentScanDesc.
Referenced by ExecReScan().
{
HeapScanDesc scan;
scan = node->ss_currentScanDesc;
heap_rescan(scan, /* scan desc */
NULL); /* new scan keys */
ExecScanReScan((ScanState *) node);
}
| void ExecSeqMarkPos | ( | SeqScanState * | node | ) |
Definition at line 285 of file nodeSeqscan.c.
References heap_markpos(), and ScanState::ss_currentScanDesc.
Referenced by ExecMarkPos().
{
HeapScanDesc scan = node->ss_currentScanDesc;
heap_markpos(scan);
}
| void ExecSeqRestrPos | ( | SeqScanState * | node | ) |
Definition at line 299 of file nodeSeqscan.c.
References ExecClearTuple(), heap_restrpos(), ScanState::ss_currentScanDesc, and ScanState::ss_ScanTupleSlot.
Referenced by ExecRestrPos().
{
HeapScanDesc scan = node->ss_currentScanDesc;
/*
* Clear any reference to the previously returned tuple. This is needed
* because the slot is simply pointing at scan->rs_cbuf, which
* heap_restrpos will change; we'd have an internally inconsistent slot if
* we didn't do this.
*/
ExecClearTuple(node->ss_ScanTupleSlot);
heap_restrpos(scan);
}
| TupleTableSlot* ExecSeqScan | ( | SeqScanState * | node | ) |
Definition at line 111 of file nodeSeqscan.c.
References ExecScan(), SeqNext(), and SeqRecheck().
Referenced by ExecProcNode().
{
return ExecScan((ScanState *) node,
(ExecScanAccessMtd) SeqNext,
(ExecScanRecheckMtd) SeqRecheck);
}
| static void InitScanRelation | ( | SeqScanState * | node, | |
| EState * | estate, | |||
| int | eflags | |||
| ) | [static] |
Definition at line 125 of file nodeSeqscan.c.
References EState::es_snapshot, ExecAssignScanType(), ExecOpenScanRelation(), heap_beginscan(), NULL, PlanState::plan, ScanState::ps, RelationGetDescr, ScanState::ss_currentRelation, and ScanState::ss_currentScanDesc.
Referenced by ExecInitSeqScan().
{
Relation currentRelation;
HeapScanDesc currentScanDesc;
/*
* get the relation object id from the relid'th entry in the range table,
* open that relation and acquire appropriate lock on it.
*/
currentRelation = ExecOpenScanRelation(estate,
((SeqScan *) node->ps.plan)->scanrelid,
eflags);
/* initialize a heapscan */
currentScanDesc = heap_beginscan(currentRelation,
estate->es_snapshot,
0,
NULL);
node->ss_currentRelation = currentRelation;
node->ss_currentScanDesc = currentScanDesc;
/* and report the scan tuple slot's rowtype */
ExecAssignScanType(node, RelationGetDescr(currentRelation));
}
| static TupleTableSlot * SeqNext | ( | SeqScanState * | node | ) | [static] |
Definition at line 47 of file nodeSeqscan.c.
References EState::es_direction, ExecClearTuple(), ExecStoreTuple(), heap_getnext(), ScanState::ps, HeapScanDescData::rs_cbuf, ScanState::ss_currentScanDesc, ScanState::ss_ScanTupleSlot, and PlanState::state.
Referenced by ExecSeqScan().
{
HeapTuple tuple;
HeapScanDesc scandesc;
EState *estate;
ScanDirection direction;
TupleTableSlot *slot;
/*
* get information from the estate and scan state
*/
scandesc = node->ss_currentScanDesc;
estate = node->ps.state;
direction = estate->es_direction;
slot = node->ss_ScanTupleSlot;
/*
* get the next tuple from the table
*/
tuple = heap_getnext(scandesc, direction);
/*
* save the tuple and the buffer returned to us by the access methods in
* our scan tuple slot and return the slot. Note: we pass 'false' because
* tuples returned by heap_getnext() are pointers onto disk pages and were
* not created with palloc() and so should not be pfree()'d. Note also
* that ExecStoreTuple will increment the refcount of the buffer; the
* refcount will not be dropped until the tuple table slot is cleared.
*/
if (tuple)
ExecStoreTuple(tuple, /* tuple to store */
slot, /* slot to store in */
scandesc->rs_cbuf, /* buffer associated with this
* tuple */
false); /* don't pfree this pointer */
else
ExecClearTuple(slot);
return slot;
}
| static bool SeqRecheck | ( | SeqScanState * | node, | |
| TupleTableSlot * | slot | |||
| ) | [static] |
Definition at line 92 of file nodeSeqscan.c.
Referenced by ExecSeqScan().
{
/*
* Note that unlike IndexScan, SeqScan never use keys in heap_beginscan
* (and this is very bad) - so, here we do not check are keys ok or not.
*/
return true;
}
1.7.1