system.c File Reference

#include "postgres.h"
#include <math.h>
#include "access/relscan.h"
#include "access/tsmapi.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "optimizer/optimizer.h"
#include "utils/builtins.h"

Include dependency graph for system.c:

Go to the source code of this file.

Data Structures
struct	SystemSamplerData

Functions
static void	system_samplescangetsamplesize (PlannerInfo *root, RelOptInfo *baserel, List *paramexprs, BlockNumber *pages, double *tuples)
static void	system_initsamplescan (SampleScanState *node, int eflags)
static void	system_beginsamplescan (SampleScanState *node, Datum *params, int nparams, uint32 seed)
static BlockNumber	system_nextsampleblock (SampleScanState *node, BlockNumber nblocks)
static OffsetNumber	system_nextsampletuple (SampleScanState *node, BlockNumber blockno, OffsetNumber maxoffset)
Datum	tsm_system_handler (PG_FUNCTION_ARGS)

Function Documentation

system_beginsamplescan()

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

static

Definition at line 140 of file system.c.

{
    SystemSamplerData *sampler = (SystemSamplerData *) node->tsm_state;
    double      percent = DatumGetFloat4(params[0]);
    double      dcutoff;
 
    if (percent < 0 || percent > 100 || isnan(percent))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLESAMPLE_ARGUMENT),
                 errmsg("sample percentage must be between 0 and 100")));
 
    /*
     * The cutoff is sample probability times (PG_UINT32_MAX + 1); we have to
     * store that as a uint64, of course.  Note that this gives strictly
     * correct behavior at the limits of zero or one probability.
     */
    dcutoff = rint(((double) PG_UINT32_MAX + 1) * percent / 100);
    sampler->cutoff = (uint64) dcutoff;
    sampler->seed = seed;
    sampler->nextblock = 0;
    sampler->lt = InvalidOffsetNumber;
 
    /*
     * Bulkread buffer access strategy probably makes sense unless we're
     * scanning a very small fraction of the table.  The 1% cutoff here is a
     * guess.  We should use pagemode visibility checking, since we scan all
     * tuples on each selected page.
     */
    node->use_bulkread = (percent >= 1);
    node->use_pagemode = true;
}

References SystemSamplerData::cutoff, DatumGetFloat4(), ereport, errcode(), errmsg(), ERROR, InvalidOffsetNumber, SystemSamplerData::lt, SystemSamplerData::nextblock, PG_UINT32_MAX, SystemSamplerData::seed, SampleScanState::tsm_state, SampleScanState::use_bulkread, and SampleScanState::use_pagemode.

Referenced by tsm_system_handler().

system_initsamplescan()

static void system_initsamplescan ( SampleScanState *  node, int  eflags  )

static

Definition at line 131 of file system.c.

{
    node->tsm_state = palloc0(sizeof(SystemSamplerData));
}

References palloc0(), and SampleScanState::tsm_state.

Referenced by tsm_system_handler().

system_nextsampleblock()

static BlockNumber system_nextsampleblock ( SampleScanState *  node, BlockNumber  nblocks  )

static

Definition at line 179 of file system.c.

{
    SystemSamplerData *sampler = (SystemSamplerData *) node->tsm_state;
    BlockNumber nextblock = sampler->nextblock;
    uint32      hashinput[2];
 
    /*
     * We compute the hash by applying hash_any to an array of 2 uint32's
     * containing the block number and seed.  This is efficient to set up, and
     * with the current implementation of hash_any, it gives
     * machine-independent results, which is a nice property for regression
     * testing.
     *
     * These words in the hash input are the same throughout the block:
     */
    hashinput[1] = sampler->seed;
 
    /*
     * Loop over block numbers until finding suitable block or reaching end of
     * relation.
     */
    for (; nextblock < nblocks; nextblock++)
    {
        uint32      hash;
 
        hashinput[0] = nextblock;
 
        hash = DatumGetUInt32(hash_any((const unsigned char *) hashinput,
                                       (int) sizeof(hashinput)));
        if (hash < sampler->cutoff)
            break;
    }
 
    if (nextblock < nblocks)
    {
        /* Found a suitable block; remember where we should start next time */
        sampler->nextblock = nextblock + 1;
        return nextblock;
    }
 
    /* Done, but let's reset nextblock to 0 for safety. */
    sampler->nextblock = 0;
    return InvalidBlockNumber;
}

References DatumGetUInt32(), hash(), hash_any(), InvalidBlockNumber, SystemSamplerData::nextblock, SystemSamplerData::seed, and SampleScanState::tsm_state.

Referenced by tsm_system_handler().

system_nextsampletuple()

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

static

Definition at line 237 of file system.c.

{
    SystemSamplerData *sampler = (SystemSamplerData *) node->tsm_state;
    OffsetNumber tupoffset = sampler->lt;
 
    /* 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 FirstOffsetNumber, if(), InvalidOffsetNumber, SystemSamplerData::lt, and SampleScanState::tsm_state.

Referenced by tsm_system_handler().

system_samplescangetsamplesize()

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

static

Definition at line 89 of file system.c.

{
    Node       *pctnode;
    float4      samplefract;
 
    /* Try to extract an estimate for the sample percentage */
    pctnode = (Node *) linitial(paramexprs);
    pctnode = estimate_expression_value(root, pctnode);
 
    if (IsA(pctnode, Const) &&
        !((Const *) pctnode)->constisnull)
    {
        samplefract = DatumGetFloat4(((Const *) pctnode)->constvalue);
        if (samplefract >= 0 && samplefract <= 100 && !isnan(samplefract))
            samplefract /= 100.0f;
        else
        {
            /* Default samplefract if the value is bogus */
            samplefract = 0.1f;
        }
    }
    else
    {
        /* Default samplefract if we didn't obtain a non-null Const */
        samplefract = 0.1f;
    }
 
    /* We'll visit a sample of the pages ... */
    *pages = clamp_row_est(baserel->pages * samplefract);
 
    /* ... and hopefully get a representative number of tuples from them */
    *tuples = clamp_row_est(baserel->tuples * samplefract);
}

References clamp_row_est(), DatumGetFloat4(), estimate_expression_value(), IsA, linitial, RelOptInfo::pages, and RelOptInfo::tuples.

Referenced by tsm_system_handler().

tsm_system_handler()

Datum tsm_system_handler

(

PG_FUNCTION_ARGS

)

Definition at line 68 of file system.c.

{
    TsmRoutine *tsm = makeNode(TsmRoutine);
 
    tsm->parameterTypes = list_make1_oid(FLOAT4OID);
    tsm->repeatable_across_queries = true;
    tsm->repeatable_across_scans = true;
    tsm->SampleScanGetSampleSize = system_samplescangetsamplesize;
    tsm->InitSampleScan = system_initsamplescan;
    tsm->BeginSampleScan = system_beginsamplescan;
    tsm->NextSampleBlock = system_nextsampleblock;
    tsm->NextSampleTuple = system_nextsampletuple;
    tsm->EndSampleScan = NULL;
 
    PG_RETURN_POINTER(tsm);
}

References TsmRoutine::BeginSampleScan, TsmRoutine::EndSampleScan, TsmRoutine::InitSampleScan, list_make1_oid, makeNode, TsmRoutine::NextSampleBlock, TsmRoutine::NextSampleTuple, TsmRoutine::parameterTypes, PG_RETURN_POINTER, TsmRoutine::repeatable_across_queries, TsmRoutine::repeatable_across_scans, TsmRoutine::SampleScanGetSampleSize, system_beginsamplescan(), system_initsamplescan(), system_nextsampleblock(), system_nextsampletuple(), and system_samplescangetsamplesize().