nodeSamplescan.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeSamplescan.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
SampleScanState *	ExecInitSampleScan (SampleScan *node, EState *estate, int eflags)
void	ExecEndSampleScan (SampleScanState *node)
void	ExecReScanSampleScan (SampleScanState *node)

Function Documentation

ExecEndSampleScan()

void ExecEndSampleScan

(

SampleScanState *

node

)

Definition at line 202 of file nodeSamplescan.c.

References TsmRoutine::EndSampleScan, ExecClearTuple(), ExecCloseScanRelation(), ExecFreeExprContext(), heap_endscan(), ScanState::ps, PlanState::ps_ResultTupleSlot, SampleScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, ScanState::ss_ScanTupleSlot, and SampleScanState::tsmroutine.

Referenced by ExecEndNode().

{
    /*
     * Tell sampling function that we finished the scan.
     */
    if (node->tsmroutine->EndSampleScan)
        node->tsmroutine->EndSampleScan(node);

    /*
     * Free the exprcontext
     */
    ExecFreeExprContext(&node->ss.ps);

    /*
     * clean out the tuple table
     */
    ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
    ExecClearTuple(node->ss.ss_ScanTupleSlot);

    /*
     * close heap scan
     */
    if (node->ss.ss_currentScanDesc)
        heap_endscan(node->ss.ss_currentScanDesc);

    /*
     * close the heap relation.
     */
    ExecCloseScanRelation(node->ss.ss_currentRelation);
}

ExecInitSampleScan()

SampleScanState* ExecInitSampleScan	(	SampleScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 113 of file nodeSamplescan.c.

References TableSampleClause::args, Assert, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitExpr(), ExecInitExprList(), ExecInitQual(), ExecInitResultTupleSlotTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), PlanState::ExecProcNode, ExecSampleScan(), GetTsmRoutine(), TsmRoutine::InitSampleScan, innerPlan, makeNode, outerPlan, Scan::plan, PlanState::plan, ScanState::ps, Plan::qual, PlanState::qual, random(), RelationGetDescr, TableSampleClause::repeatable, SampleScan::scan, Scan::scanrelid, SampleScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, SampleScan::tablesample, and TableSampleClause::tsmhandler.

Referenced by ExecInitNode().

{
    SampleScanState *scanstate;
    TableSampleClause *tsc = node->tablesample;
    TsmRoutine *tsm;

    Assert(outerPlan(node) == NULL);
    Assert(innerPlan(node) == NULL);

    /*
     * create state structure
     */
    scanstate = makeNode(SampleScanState);
    scanstate->ss.ps.plan = (Plan *) node;
    scanstate->ss.ps.state = estate;
    scanstate->ss.ps.ExecProcNode = ExecSampleScan;

    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &scanstate->ss.ps);

    /*
     * Initialize scan relation.
     *
     * Get the relation object id from the relid'th entry in the range table,
     * open that relation and acquire appropriate lock on it.
     */
    scanstate->ss.ss_currentRelation =
        ExecOpenScanRelation(estate,
                             node->scan.scanrelid,
                             eflags);

    /* we won't set up the HeapScanDesc till later */
    scanstate->ss.ss_currentScanDesc = NULL;

    /* and create slot with appropriate rowtype */
    ExecInitScanTupleSlot(estate, &scanstate->ss,
                          RelationGetDescr(scanstate->ss.ss_currentRelation));

    /*
     * Initialize result slot, type and projection.
     * tuple table and result tuple initialization
     */
    ExecInitResultTupleSlotTL(estate, &scanstate->ss.ps);
    ExecAssignScanProjectionInfo(&scanstate->ss);

    /*
     * initialize child expressions
     */
    scanstate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);

    scanstate->args = ExecInitExprList(tsc->args, (PlanState *) scanstate);
    scanstate->repeatable =
        ExecInitExpr(tsc->repeatable, (PlanState *) scanstate);

    /*
     * If we don't have a REPEATABLE clause, select a random seed.  We want to
     * do this just once, since the seed shouldn't change over rescans.
     */
    if (tsc->repeatable == NULL)
        scanstate->seed = random();

    /*
     * Finally, initialize the TABLESAMPLE method handler.
     */
    tsm = GetTsmRoutine(tsc->tsmhandler);
    scanstate->tsmroutine = tsm;
    scanstate->tsm_state = NULL;

    if (tsm->InitSampleScan)
        tsm->InitSampleScan(scanstate, eflags);

    /* We'll do BeginSampleScan later; we can't evaluate params yet */
    scanstate->begun = false;

    return scanstate;
}

ExecReScanSampleScan()

void ExecReScanSampleScan

(

SampleScanState *

node

)

Definition at line 241 of file nodeSamplescan.c.

References SampleScanState::begun, ExecScanReScan(), and SampleScanState::ss.

Referenced by ExecReScan().

{
    /* Remember we need to do BeginSampleScan again (if we did it at all) */
    node->begun = false;

    ExecScanReScan(&node->ss);
}