tsm_system_rows.c File Reference

#include "postgres.h"
#include "access/tsmapi.h"
#include "catalog/pg_type.h"
#include "miscadmin.h"
#include "optimizer/optimizer.h"
#include "utils/sampling.h"

Include dependency graph for tsm_system_rows.c:

Go to the source code of this file.

Data Structures
struct	SystemRowsSamplerData

Functions
	PG_MODULE_MAGIC_EXT (.name="tsm_system_rows",.version=PG_VERSION)
	PG_FUNCTION_INFO_V1 (tsm_system_rows_handler)
static void	system_rows_samplescangetsamplesize (PlannerInfo *root, RelOptInfo *baserel, List *paramexprs, BlockNumber *pages, double *tuples)
static void	system_rows_initsamplescan (SampleScanState *node, int eflags)
static void	system_rows_beginsamplescan (SampleScanState *node, Datum *params, int nparams, uint32 seed)
static BlockNumber	system_rows_nextsampleblock (SampleScanState *node, BlockNumber nblocks)
static OffsetNumber	system_rows_nextsampletuple (SampleScanState *node, BlockNumber blockno, OffsetNumber maxoffset)
static uint32	random_relative_prime (uint32 n, pg_prng_state *randstate)
Datum	tsm_system_rows_handler (PG_FUNCTION_ARGS)
static uint32	gcd (uint32 a, uint32 b)

Function Documentation

gcd()

static uint32 gcd ( uint32  a, uint32  b  )

static

Definition at line 303 of file tsm_system_rows.c.

{
    uint32      c;
 
    while (a != 0)
    {
        c = a;
        a = b % a;
        b = c;
    }
 
    return b;
}

References a, and b.

Referenced by int4lcm(), int8lcm(), and random_relative_prime().

PG_FUNCTION_INFO_V1()

PG_FUNCTION_INFO_V1

(

tsm_system_rows_handler

)

PG_MODULE_MAGIC_EXT()

PG_MODULE_MAGIC_EXT	(	.	name = "tsm_system_rows",
		.	version = PG_VERSION
	)

random_relative_prime()

static uint32 random_relative_prime ( uint32  n, pg_prng_state *  randstate  )

static

Definition at line 322 of file tsm_system_rows.c.

{
    uint32      r;
 
    /* Safety check to avoid infinite loop or zero result for small n. */
    if (n <= 1)
        return 1;
 
    /*
     * This should only take 2 or 3 iterations as the probability of 2 numbers
     * being relatively prime is ~61%; but just in case, we'll include a
     * CHECK_FOR_INTERRUPTS in the loop.
     */
    do
    {
        CHECK_FOR_INTERRUPTS();
        r = (uint32) (sampler_random_fract(randstate) * n);
    } while (r == 0 || gcd(r, n) > 1);
 
    return r;
}

References CHECK_FOR_INTERRUPTS, gcd(), and sampler_random_fract().

Referenced by system_rows_nextsampleblock().

system_rows_beginsamplescan()

static void system_rows_beginsamplescan ( SampleScanState *  node, Datum *  params, int  nparams, uint32  seed  )

static

Definition at line 174 of file tsm_system_rows.c.

{
    SystemRowsSamplerData *sampler = (SystemRowsSamplerData *) node->tsm_state;
    int64       ntuples = DatumGetInt64(params[0]);
 
    if (ntuples < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLESAMPLE_ARGUMENT),
                 errmsg("sample size must not be negative")));
 
    sampler->seed = seed;
    sampler->ntuples = ntuples;
    sampler->lt = InvalidOffsetNumber;
    sampler->doneblocks = 0;
    /* lb will be initialized during first NextSampleBlock call */
    /* we intentionally do not change nblocks/firstblock/step here */
 
    /*
     * We *must* use pagemode visibility checking in this module, so force
     * that even though it's currently default.
     */
    node->use_pagemode = true;
}

References DatumGetInt64(), ereport, errcode(), errmsg(), ERROR, fb(), InvalidOffsetNumber, SampleScanState::tsm_state, and SampleScanState::use_pagemode.

Referenced by tsm_system_rows_handler().

system_rows_initsamplescan()

static void system_rows_initsamplescan ( SampleScanState *  node, int  eflags  )

static

Definition at line 164 of file tsm_system_rows.c.

{
    node->tsm_state = palloc0_object(SystemRowsSamplerData);
    /* Note the above leaves tsm_state->step equal to zero */
}

References palloc0_object, and SampleScanState::tsm_state.

Referenced by tsm_system_rows_handler().

system_rows_nextsampleblock()

static BlockNumber system_rows_nextsampleblock ( SampleScanState *  node, BlockNumber  nblocks  )

static

Definition at line 207 of file tsm_system_rows.c.

{
    SystemRowsSamplerData *sampler = (SystemRowsSamplerData *) node->tsm_state;
 
    /* First call within scan? */
    if (sampler->doneblocks == 0)
    {
        /* First scan within query? */
        if (sampler->step == 0)
        {
            /* Initialize now that we have scan descriptor */
            pg_prng_state randstate;
 
            /* If relation is empty, there's nothing to scan */
            if (nblocks == 0)
                return InvalidBlockNumber;
 
            /* We only need an RNG during this setup step */
            sampler_random_init_state(sampler->seed, &randstate);
 
            /* Compute nblocks/firstblock/step only once per query */
            sampler->nblocks = nblocks;
 
            /* Choose random starting block within the relation */
            /* (Actually this is the predecessor of the first block visited) */
            sampler->firstblock = sampler_random_fract(&randstate) *
                sampler->nblocks;
 
            /* Find relative prime as step size for linear probing */
            sampler->step = random_relative_prime(sampler->nblocks, &randstate);
        }
 
        /* Reinitialize lb */
        sampler->lb = sampler->firstblock;
    }
 
    /* If we've read all blocks or returned all needed tuples, we're done */
    if (++sampler->doneblocks > sampler->nblocks ||
        node->donetuples >= sampler->ntuples)
        return InvalidBlockNumber;
 
    /*
     * It's probably impossible for scan->rs_nblocks to decrease between scans
     * within a query; but just in case, loop until we select a block number
     * less than scan->rs_nblocks.  We don't care if scan->rs_nblocks has
     * increased since the first scan.
     */
    do
    {
        /* Advance lb, using uint64 arithmetic to forestall overflow */
        sampler->lb = ((uint64) sampler->lb + sampler->step) % sampler->nblocks;
    } while (sampler->lb >= nblocks);
 
    return sampler->lb;
}

References SampleScanState::donetuples, fb(), InvalidBlockNumber, random_relative_prime(), sampler_random_fract(), sampler_random_init_state(), and SampleScanState::tsm_state.

Referenced by tsm_system_rows_handler().

system_rows_nextsampletuple()

static OffsetNumber system_rows_nextsampletuple ( SampleScanState *  node, BlockNumber  blockno, OffsetNumber  maxoffset  )

static

Definition at line 273 of file tsm_system_rows.c.

{
    SystemRowsSamplerData *sampler = (SystemRowsSamplerData *) node->tsm_state;
    OffsetNumber tupoffset = sampler->lt;
 
    /* Quit if we've returned all needed tuples */
    if (node->donetuples >= sampler->ntuples)
        return InvalidOffsetNumber;
 
    /* Advance to next possible offset on page */
    if (tupoffset == InvalidOffsetNumber)
        tupoffset = FirstOffsetNumber;
    else
        tupoffset++;
 
    /* Done? */
    if (tupoffset > maxoffset)
        tupoffset = InvalidOffsetNumber;
 
    sampler->lt = tupoffset;
 
    return tupoffset;
}

References SampleScanState::donetuples, fb(), FirstOffsetNumber, InvalidOffsetNumber, and SampleScanState::tsm_state.

Referenced by tsm_system_rows_handler().

system_rows_samplescangetsamplesize()

static void system_rows_samplescangetsamplesize ( PlannerInfo *  root, RelOptInfo *  baserel, List *  paramexprs, BlockNumber *  pages, double *  tuples  )

static

Definition at line 105 of file tsm_system_rows.c.

{
    Node       *limitnode;
    int64       ntuples;
    double      npages;
 
    /* Try to extract an estimate for the limit rowcount */
    limitnode = (Node *) linitial(paramexprs);
    limitnode = estimate_expression_value(root, limitnode);
 
    if (IsA(limitnode, Const) &&
        !((Const *) limitnode)->constisnull)
    {
        ntuples = DatumGetInt64(((Const *) limitnode)->constvalue);
        if (ntuples < 0)
        {
            /* Default ntuples if the value is bogus */
            ntuples = 1000;
        }
    }
    else
    {
        /* Default ntuples if we didn't obtain a non-null Const */
        ntuples = 1000;
    }
 
    /* Clamp to the estimated relation size */
    if (ntuples > baserel->tuples)
        ntuples = (int64) baserel->tuples;
    ntuples = clamp_row_est(ntuples);
 
    if (baserel->tuples > 0 && baserel->pages > 0)
    {
        /* Estimate number of pages visited based on tuple density */
        double      density = baserel->tuples / (double) baserel->pages;
 
        npages = ntuples / density;
    }
    else
    {
        /* For lack of data, assume one tuple per page */
        npages = ntuples;
    }
 
    /* Clamp to sane value */
    npages = clamp_row_est(Min((double) baserel->pages, npages));
 
    *pages = npages;
    *tuples = ntuples;
}

References clamp_row_est(), DatumGetInt64(), estimate_expression_value(), fb(), IsA, linitial, Min, and root.

Referenced by tsm_system_rows_handler().

tsm_system_rows_handler()

Datum tsm_system_rows_handler

(

PG_FUNCTION_ARGS

)

Definition at line 81 of file tsm_system_rows.c.

{
    TsmRoutine *tsm = makeNode(TsmRoutine);
 
    tsm->parameterTypes = list_make1_oid(INT8OID);
 
    /* See notes at head of file */
    tsm->repeatable_across_queries = false;
    tsm->repeatable_across_scans = true;
 
    tsm->SampleScanGetSampleSize = system_rows_samplescangetsamplesize;
    tsm->InitSampleScan = system_rows_initsamplescan;
    tsm->BeginSampleScan = system_rows_beginsamplescan;
    tsm->NextSampleBlock = system_rows_nextsampleblock;
    tsm->NextSampleTuple = system_rows_nextsampletuple;
    tsm->EndSampleScan = NULL;
 
    PG_RETURN_POINTER(tsm);
}

References fb(), list_make1_oid, makeNode, PG_RETURN_POINTER, system_rows_beginsamplescan(), system_rows_initsamplescan(), system_rows_nextsampleblock(), system_rows_nextsampletuple(), and system_rows_samplescangetsamplesize().