nodeSamplescan.c File Reference

#include "postgres.h"
#include "access/relscan.h"
#include "access/tableam.h"
#include "access/tsmapi.h"
#include "common/pg_prng.h"
#include "executor/executor.h"
#include "executor/nodeSamplescan.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/bufmgr.h"
#include "storage/predicate.h"
#include "utils/builtins.h"
#include "utils/rel.h"

Include dependency graph for nodeSamplescan.c:

Go to the source code of this file.

Functions
static TupleTableSlot *	SampleNext (SampleScanState *node)
static void	tablesample_init (SampleScanState *scanstate)
static TupleTableSlot *	tablesample_getnext (SampleScanState *scanstate)
static bool	SampleRecheck (SampleScanState *node, TupleTableSlot *slot)
static TupleTableSlot *	ExecSampleScan (PlanState *pstate)
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 183 of file nodeSamplescan.c.

{
    /*
     * 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
     */
    if (node->ss.ps.ps_ResultTupleSlot)
        ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
    ExecClearTuple(node->ss.ss_ScanTupleSlot);
 
    /*
     * close heap scan
     */
    if (node->ss.ss_currentScanDesc)
        table_endscan(node->ss.ss_currentScanDesc);
}

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

Referenced by ExecEndNode().

ExecInitSampleScan()

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

Definition at line 97 of file nodeSamplescan.c.

{
    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);
 
    /*
     * open the scan relation
     */
    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),
                          table_slot_callbacks(scanstate->ss.ss_currentRelation));
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&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 = pg_prng_uint32(&pg_global_prng_state);
 
    /*
     * 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;
}

References SampleScanState::args, TableSampleClause::args, Assert(), SampleScanState::begun, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitExpr(), ExecInitExprList(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), PlanState::ExecProcNode, ExecSampleScan(), GetTsmRoutine(), TsmRoutine::InitSampleScan, innerPlan, makeNode, outerPlan, pg_global_prng_state, pg_prng_uint32(), PlanState::plan, ScanState::ps, PlanState::qual, RelationGetDescr, SampleScanState::repeatable, TableSampleClause::repeatable, SampleScan::scan, Scan::scanrelid, SampleScanState::seed, SampleScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, table_slot_callbacks(), SampleScan::tablesample, SampleScanState::tsm_state, TableSampleClause::tsmhandler, and SampleScanState::tsmroutine.

Referenced by ExecInitNode().

ExecReScanSampleScan()

void ExecReScanSampleScan

(

SampleScanState *

node

)

Definition at line 218 of file nodeSamplescan.c.

{
    /* Remember we need to do BeginSampleScan again (if we did it at all) */
    node->begun = false;
    node->done = false;
    node->haveblock = false;
    node->donetuples = 0;
 
    ExecScanReScan(&node->ss);
}

References SampleScanState::begun, SampleScanState::done, SampleScanState::donetuples, ExecScanReScan(), SampleScanState::haveblock, and SampleScanState::ss.

Referenced by ExecReScan().

ExecSampleScan()

static TupleTableSlot* ExecSampleScan ( PlanState *  pstate )

static

Definition at line 83 of file nodeSamplescan.c.

{
    SampleScanState *node = castNode(SampleScanState, pstate);
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) SampleNext,
                    (ExecScanRecheckMtd) SampleRecheck);
}

References castNode, ExecScan(), SampleNext(), SampleRecheck(), and SampleScanState::ss.

Referenced by ExecInitSampleScan().

SampleNext()

static TupleTableSlot * SampleNext ( SampleScanState *  node )

static

Definition at line 46 of file nodeSamplescan.c.

{
    /*
     * if this is first call within a scan, initialize
     */
    if (!node->begun)
        tablesample_init(node);
 
    /*
     * get the next tuple, and store it in our result slot
     */
    return tablesample_getnext(node);
}

References SampleScanState::begun, tablesample_getnext(), and tablesample_init().

Referenced by ExecSampleScan().

SampleRecheck()

static bool SampleRecheck ( SampleScanState *  node, TupleTableSlot *  slot  )

static

Definition at line 64 of file nodeSamplescan.c.

{
    /*
     * No need to recheck for SampleScan, since like SeqScan we don't pass any
     * checkable keys to heap_beginscan.
     */
    return true;
}

Referenced by ExecSampleScan().

tablesample_getnext()

static TupleTableSlot * tablesample_getnext ( SampleScanState *  scanstate )

static

Definition at line 336 of file nodeSamplescan.c.

{
    TableScanDesc scan = scanstate->ss.ss_currentScanDesc;
    TupleTableSlot *slot = scanstate->ss.ss_ScanTupleSlot;
 
    ExecClearTuple(slot);
 
    if (scanstate->done)
        return NULL;
 
    for (;;)
    {
        if (!scanstate->haveblock)
        {
            if (!table_scan_sample_next_block(scan, scanstate))
            {
                scanstate->haveblock = false;
                scanstate->done = true;
 
                /* exhausted relation */
                return NULL;
            }
 
            scanstate->haveblock = true;
        }
 
        if (!table_scan_sample_next_tuple(scan, scanstate, slot))
        {
            /*
             * If we get here, it means we've exhausted the items on this page
             * and it's time to move to the next.
             */
            scanstate->haveblock = false;
            continue;
        }
 
        /* Found visible tuple, return it. */
        break;
    }
 
    scanstate->donetuples++;
 
    return slot;
}

References SampleScanState::done, SampleScanState::donetuples, ExecClearTuple(), SampleScanState::haveblock, SampleScanState::ss, ScanState::ss_currentScanDesc, ScanState::ss_ScanTupleSlot, table_scan_sample_next_block(), and table_scan_sample_next_tuple().

Referenced by SampleNext().

tablesample_init()

static void tablesample_init ( SampleScanState *  scanstate )

static

Definition at line 234 of file nodeSamplescan.c.

{
    TsmRoutine *tsm = scanstate->tsmroutine;
    ExprContext *econtext = scanstate->ss.ps.ps_ExprContext;
    Datum      *params;
    Datum       datum;
    bool        isnull;
    uint32      seed;
    bool        allow_sync;
    int         i;
    ListCell   *arg;
 
    scanstate->donetuples = 0;
    params = (Datum *) palloc(list_length(scanstate->args) * sizeof(Datum));
 
    i = 0;
    foreach(arg, scanstate->args)
    {
        ExprState  *argstate = (ExprState *) lfirst(arg);
 
        params[i] = ExecEvalExprSwitchContext(argstate,
                                              econtext,
                                              &isnull);
        if (isnull)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLESAMPLE_ARGUMENT),
                     errmsg("TABLESAMPLE parameter cannot be null")));
        i++;
    }
 
    if (scanstate->repeatable)
    {
        datum = ExecEvalExprSwitchContext(scanstate->repeatable,
                                          econtext,
                                          &isnull);
        if (isnull)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLESAMPLE_REPEAT),
                     errmsg("TABLESAMPLE REPEATABLE parameter cannot be null")));
 
        /*
         * The REPEATABLE parameter has been coerced to float8 by the parser.
         * The reason for using float8 at the SQL level is that it will
         * produce unsurprising results both for users used to databases that
         * accept only integers in the REPEATABLE clause and for those who
         * might expect that REPEATABLE works like setseed() (a float in the
         * range from -1 to 1).
         *
         * We use hashfloat8() to convert the supplied value into a suitable
         * seed.  For regression-testing purposes, that has the convenient
         * property that REPEATABLE(0) gives a machine-independent result.
         */
        seed = DatumGetUInt32(DirectFunctionCall1(hashfloat8, datum));
    }
    else
    {
        /* Use the seed selected by ExecInitSampleScan */
        seed = scanstate->seed;
    }
 
    /* Set default values for params that BeginSampleScan can adjust */
    scanstate->use_bulkread = true;
    scanstate->use_pagemode = true;
 
    /* Let tablesample method do its thing */
    tsm->BeginSampleScan(scanstate,
                         params,
                         list_length(scanstate->args),
                         seed);
 
    /* We'll use syncscan if there's no NextSampleBlock function */
    allow_sync = (tsm->NextSampleBlock == NULL);
 
    /* Now we can create or reset the HeapScanDesc */
    if (scanstate->ss.ss_currentScanDesc == NULL)
    {
        scanstate->ss.ss_currentScanDesc =
            table_beginscan_sampling(scanstate->ss.ss_currentRelation,
                                     scanstate->ss.ps.state->es_snapshot,
                                     0, NULL,
                                     scanstate->use_bulkread,
                                     allow_sync,
                                     scanstate->use_pagemode);
    }
    else
    {
        table_rescan_set_params(scanstate->ss.ss_currentScanDesc, NULL,
                                scanstate->use_bulkread,
                                allow_sync,
                                scanstate->use_pagemode);
    }
 
    pfree(params);
 
    /* And we're initialized. */
    scanstate->begun = true;
}

References arg, SampleScanState::args, TsmRoutine::BeginSampleScan, SampleScanState::begun, DatumGetUInt32(), DirectFunctionCall1, SampleScanState::donetuples, ereport, errcode(), errmsg(), ERROR, EState::es_snapshot, ExecEvalExprSwitchContext(), hashfloat8(), i, lfirst, list_length(), TsmRoutine::NextSampleBlock, palloc(), pfree(), ScanState::ps, PlanState::ps_ExprContext, SampleScanState::repeatable, SampleScanState::seed, SampleScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, table_beginscan_sampling(), table_rescan_set_params(), SampleScanState::tsmroutine, SampleScanState::use_bulkread, and SampleScanState::use_pagemode.

Referenced by SampleNext().