nodeTidrangescan.c File Reference

#include "postgres.h"
#include "access/relscan.h"
#include "access/sysattr.h"
#include "access/tableam.h"
#include "catalog/pg_operator.h"
#include "executor/execParallel.h"
#include "executor/executor.h"
#include "executor/instrument.h"
#include "executor/nodeTidrangescan.h"
#include "nodes/nodeFuncs.h"
#include "utils/rel.h"

Include dependency graph for nodeTidrangescan.c:

Go to the source code of this file.

Data Structures
struct	TidOpExpr

Macros
#define	IsCTIDVar(node)

Typedefs
typedef struct TidOpExpr	TidOpExpr

Enumerations
enum	TidExprType { TIDEXPR_UPPER_BOUND , TIDEXPR_LOWER_BOUND }

Functions
static TidOpExpr *	MakeTidOpExpr (OpExpr *expr, TidRangeScanState *tidstate)
static void	TidExprListCreate (TidRangeScanState *tidrangestate)
static bool	TidRangeEval (TidRangeScanState *node)
static TupleTableSlot *	TidRangeNext (TidRangeScanState *node)
static bool	TidRangeRecheck (TidRangeScanState *node, TupleTableSlot *slot)
static TupleTableSlot *	ExecTidRangeScan (PlanState *pstate)
void	ExecReScanTidRangeScan (TidRangeScanState *node)
void	ExecEndTidRangeScan (TidRangeScanState *node)
TidRangeScanState *	ExecInitTidRangeScan (TidRangeScan *node, EState *estate, int eflags)
void	ExecTidRangeScanEstimate (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanInitializeDSM (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanReInitializeDSM (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanInitializeWorker (TidRangeScanState *node, ParallelWorkerContext *pwcxt)
void	ExecTidRangeScanInstrumentEstimate (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanInstrumentInitDSM (TidRangeScanState *node, ParallelContext *pcxt)
void	ExecTidRangeScanInstrumentInitWorker (TidRangeScanState *node, ParallelWorkerContext *pwcxt)
void	ExecTidRangeScanRetrieveInstrumentation (TidRangeScanState *node)

Macro Definition Documentation

IsCTIDVar

#define IsCTIDVar

(

node

)

Value:

    ((node) != NULL && \
     IsA((node), Var) && \
     ((Var *) (node))->varattno == SelfItemPointerAttributeNumber)

Definition at line 35 of file nodeTidrangescan.c.

{
    TIDEXPR_UPPER_BOUND,
    TIDEXPR_LOWER_BOUND,
} TidExprType;
 
/* Upper or lower range bound for scan */
typedef struct TidOpExpr
{
    TidExprType exprtype;       /* type of op; lower or upper */
    ExprState  *exprstate;      /* ExprState for a TID-yielding subexpr */
    bool        inclusive;      /* whether op is inclusive */
} TidOpExpr;
 
/*
 * For the given 'expr', build and return an appropriate TidOpExpr taking into
 * account the expr's operator and operand order.
 */
static TidOpExpr *
MakeTidOpExpr(OpExpr *expr, TidRangeScanState *tidstate)
{
    Node       *arg1 = get_leftop((Expr *) expr);
    Node       *arg2 = get_rightop((Expr *) expr);
    ExprState  *exprstate = NULL;
    bool        invert = false;
    TidOpExpr  *tidopexpr;
 
    if (IsCTIDVar(arg1))
        exprstate = ExecInitExpr((Expr *) arg2, &tidstate->ss.ps);
    else if (IsCTIDVar(arg2))
    {
        exprstate = ExecInitExpr((Expr *) arg1, &tidstate->ss.ps);
        invert = true;
    }
    else
        elog(ERROR, "could not identify CTID variable");
 
    tidopexpr = palloc_object(TidOpExpr);
    tidopexpr->inclusive = false;   /* for now */
 
    switch (expr->opno)
    {
        case TIDLessEqOperator:
            tidopexpr->inclusive = true;
            pg_fallthrough;
        case TIDLessOperator:
            tidopexpr->exprtype = invert ? TIDEXPR_LOWER_BOUND : TIDEXPR_UPPER_BOUND;
            break;
        case TIDGreaterEqOperator:
            tidopexpr->inclusive = true;
            pg_fallthrough;
        case TIDGreaterOperator:
            tidopexpr->exprtype = invert ? TIDEXPR_UPPER_BOUND : TIDEXPR_LOWER_BOUND;
            break;
        default:
            elog(ERROR, "could not identify CTID operator");
    }
 
    tidopexpr->exprstate = exprstate;
 
    return tidopexpr;
}
 
/*
 * Extract the qual subexpressions that yield TIDs to search for,
 * and compile them into ExprStates if they're ordinary expressions.
 */
static void
TidExprListCreate(TidRangeScanState *tidrangestate)
{
    TidRangeScan *node = (TidRangeScan *) tidrangestate->ss.ps.plan;
    List       *tidexprs = NIL;
    ListCell   *l;
 
    foreach(l, node->tidrangequals)
    {
        OpExpr     *opexpr = lfirst(l);
        TidOpExpr  *tidopexpr;
 
        if (!IsA(opexpr, OpExpr))
            elog(ERROR, "could not identify CTID expression");
 
        tidopexpr = MakeTidOpExpr(opexpr, tidrangestate);
        tidexprs = lappend(tidexprs, tidopexpr);
    }
 
    tidrangestate->trss_tidexprs = tidexprs;
}
 
/* ----------------------------------------------------------------
 *      TidRangeEval
 *
 *      Compute and set node's block and offset range to scan by evaluating
 *      node->trss_tidexprs.  Returns false if we detect the range cannot
 *      contain any tuples.  Returns true if it's possible for the range to
 *      contain tuples.  We don't bother validating that trss_mintid is less
 *      than or equal to trss_maxtid, as the scan_set_tidrange() table AM
 *      function will handle that.
 * ----------------------------------------------------------------
 */
static bool
TidRangeEval(TidRangeScanState *node)
{
    ExprContext *econtext = node->ss.ps.ps_ExprContext;
    ItemPointerData lowerBound;
    ItemPointerData upperBound;
    ListCell   *l;
 
    /*
     * Set the upper and lower bounds to the absolute limits of the range of
     * the ItemPointer type.  Below we'll try to narrow this range on either
     * side by looking at the TidOpExprs.
     */
    ItemPointerSet(&lowerBound, 0, 0);
    ItemPointerSet(&upperBound, InvalidBlockNumber, PG_UINT16_MAX);
 
    foreach(l, node->trss_tidexprs)
    {
        TidOpExpr  *tidopexpr = (TidOpExpr *) lfirst(l);
        ItemPointer itemptr;
        bool        isNull;
 
        /* Evaluate this bound. */
        itemptr = (ItemPointer)
            DatumGetPointer(ExecEvalExprSwitchContext(tidopexpr->exprstate,
                                                      econtext,
                                                      &isNull));
 
        /* If the bound is NULL, *nothing* matches the qual. */
        if (isNull)
            return false;
 
        if (tidopexpr->exprtype == TIDEXPR_LOWER_BOUND)
        {
            ItemPointerData lb;
 
            ItemPointerCopy(itemptr, &lb);
 
            /*
             * Normalize non-inclusive ranges to become inclusive.  The
             * resulting ItemPointer here may not be a valid item pointer.
             */
            if (!tidopexpr->inclusive)
                ItemPointerInc(&lb);
 
            /* Check if we can narrow the range using this qual */
            if (ItemPointerCompare(&lb, &lowerBound) > 0)
                ItemPointerCopy(&lb, &lowerBound);
        }
 
        else if (tidopexpr->exprtype == TIDEXPR_UPPER_BOUND)
        {
            ItemPointerData ub;
 
            ItemPointerCopy(itemptr, &ub);
 
            /*
             * Normalize non-inclusive ranges to become inclusive.  The
             * resulting ItemPointer here may not be a valid item pointer.
             */
            if (!tidopexpr->inclusive)
                ItemPointerDec(&ub);
 
            /* Check if we can narrow the range using this qual */
            if (ItemPointerCompare(&ub, &upperBound) < 0)
                ItemPointerCopy(&ub, &upperBound);
        }
    }
 
    ItemPointerCopy(&lowerBound, &node->trss_mintid);
    ItemPointerCopy(&upperBound, &node->trss_maxtid);
 
    return true;
}
 
/* ----------------------------------------------------------------
 *      TidRangeNext
 *
 *      Retrieve a tuple from the TidRangeScan node's currentRelation
 *      using the TIDs in the TidRangeScanState information.
 *
 * ----------------------------------------------------------------
 */
static TupleTableSlot *
TidRangeNext(TidRangeScanState *node)
{
    TableScanDesc scandesc;
    EState     *estate;
    ScanDirection direction;
    TupleTableSlot *slot;
 
    /*
     * extract necessary information from TID scan node
     */
    scandesc = node->ss.ss_currentScanDesc;
    estate = node->ss.ps.state;
    slot = node->ss.ss_ScanTupleSlot;
    direction = estate->es_direction;
 
    if (!node->trss_inScan)
    {
        /* First time through, compute TID range to scan */
        if (!TidRangeEval(node))
            return NULL;
 
        if (scandesc == NULL)
        {
            uint32      flags = SO_NONE;
 
            if (ScanRelIsReadOnly(&node->ss))
                flags |= SO_HINT_REL_READ_ONLY;
 
            if (estate->es_instrument & INSTRUMENT_IO)
                flags |= SO_SCAN_INSTRUMENT;
 
            scandesc = table_beginscan_tidrange(node->ss.ss_currentRelation,
                                                estate->es_snapshot,
                                                &node->trss_mintid,
                                                &node->trss_maxtid,
                                                flags);
            node->ss.ss_currentScanDesc = scandesc;
        }
        else
        {
            /* rescan with the updated TID range */
            table_rescan_tidrange(scandesc, &node->trss_mintid,
                                  &node->trss_maxtid);
        }
 
        node->trss_inScan = true;
    }
 
    /* Fetch the next tuple. */
    if (!table_scan_getnextslot_tidrange(scandesc, direction, slot))
    {
        node->trss_inScan = false;
        ExecClearTuple(slot);
    }
 
    return slot;
}
 
/*
 * TidRangeRecheck -- access method routine to recheck a tuple in EvalPlanQual
 */
static bool
TidRangeRecheck(TidRangeScanState *node, TupleTableSlot *slot)
{
    if (!TidRangeEval(node))
        return false;
 
    Assert(ItemPointerIsValid(&slot->tts_tid));
 
    /* Recheck the ctid is still within range */
    if (ItemPointerCompare(&slot->tts_tid, &node->trss_mintid) < 0 ||
        ItemPointerCompare(&slot->tts_tid, &node->trss_maxtid) > 0)
        return false;
 
    return true;
}
 
/* ----------------------------------------------------------------
 *      ExecTidRangeScan(node)
 *
 *      Scans the relation using tids and returns the next qualifying tuple.
 *      We call the ExecScan() routine and pass it the appropriate
 *      access method functions.
 *
 *      Conditions:
 *        -- the "cursor" maintained by the AMI is positioned at the tuple
 *           returned previously.
 *
 *      Initial States:
 *        -- the relation indicated is opened for TID range scanning.
 * ----------------------------------------------------------------
 */
static TupleTableSlot *
ExecTidRangeScan(PlanState *pstate)
{
    TidRangeScanState *node = castNode(TidRangeScanState, pstate);
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) TidRangeNext,
                    (ExecScanRecheckMtd) TidRangeRecheck);
}
 
/* ----------------------------------------------------------------
 *      ExecReScanTidRangeScan(node)
 * ----------------------------------------------------------------
 */
void
ExecReScanTidRangeScan(TidRangeScanState *node)
{
    /* mark scan as not in progress, and tid range list as not computed yet */
    node->trss_inScan = false;
 
    /*
     * We must wait until TidRangeNext before calling table_rescan_tidrange.
     */
    ExecScanReScan(&node->ss);
}
 
/* ----------------------------------------------------------------
 *      ExecEndTidRangeScan
 *
 *      Releases any storage allocated through C routines.
 *      Returns nothing.
 * ----------------------------------------------------------------
 */
void
ExecEndTidRangeScan(TidRangeScanState *node)
{
    TableScanDesc scan = node->ss.ss_currentScanDesc;
 
    /* Collect IO stats for this process into shared instrumentation */
    if (node->trss_sinstrument != NULL && IsParallelWorker())
    {
        TidRangeScanInstrumentation *si;
 
        Assert(ParallelWorkerNumber < node->trss_sinstrument->num_workers);
        si = &node->trss_sinstrument->sinstrument[ParallelWorkerNumber];
 
        if (scan && scan->rs_instrument)
        {
            AccumulateIOStats(&si->stats.io, &scan->rs_instrument->io);
        }
    }
 
    if (scan != NULL)
        table_endscan(scan);
}
 
/* ----------------------------------------------------------------
 *      ExecInitTidRangeScan
 *
 *      Initializes the tid range scan's state information, creates
 *      scan keys, and opens the scan relation.
 *
 *      Parameters:
 *        node: TidRangeScan node produced by the planner.
 *        estate: the execution state initialized in InitPlan.
 * ----------------------------------------------------------------
 */
TidRangeScanState *
ExecInitTidRangeScan(TidRangeScan *node, EState *estate, int eflags)
{
    TidRangeScanState *tidrangestate;
    Relation    currentRelation;
 
    /*
     * create state structure
     */
    tidrangestate = makeNode(TidRangeScanState);
    tidrangestate->ss.ps.plan = (Plan *) node;
    tidrangestate->ss.ps.state = estate;
    tidrangestate->ss.ps.ExecProcNode = ExecTidRangeScan;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &tidrangestate->ss.ps);
 
    /*
     * mark scan as not in progress, and TID range as not computed yet
     */
    tidrangestate->trss_inScan = false;
 
    /*
     * open the scan relation
     */
    currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
 
    tidrangestate->ss.ss_currentRelation = currentRelation;
    tidrangestate->ss.ss_currentScanDesc = NULL;    /* no table scan here */
 
    /*
     * get the scan type from the relation descriptor.
     */
    ExecInitScanTupleSlot(estate, &tidrangestate->ss,
                          RelationGetDescr(currentRelation),
                          table_slot_callbacks(currentRelation),
                          TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS);
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&tidrangestate->ss.ps);
    ExecAssignScanProjectionInfo(&tidrangestate->ss);
 
    /*
     * initialize child expressions
     */
    tidrangestate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) tidrangestate);
 
    TidExprListCreate(tidrangestate);
 
    /*
     * all done.
     */
    return tidrangestate;
}
 
/* ----------------------------------------------------------------
 *                      Parallel Scan Support
 * ----------------------------------------------------------------
 */
 
/* ----------------------------------------------------------------
 *      ExecTidRangeScanEstimate
 *
 *      Compute the amount of space we'll need in the parallel
 *      query DSM, and inform pcxt->estimator about our needs.
 * ----------------------------------------------------------------
 */
void
ExecTidRangeScanEstimate(TidRangeScanState *node, ParallelContext *pcxt)
{
    EState     *estate = node->ss.ps.state;
 
    node->trss_pscanlen =
        table_parallelscan_estimate(node->ss.ss_currentRelation,
                                    estate->es_snapshot);
    shm_toc_estimate_chunk(&pcxt->estimator, node->trss_pscanlen);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}
 
/* ----------------------------------------------------------------
 *      ExecTidRangeScanInitializeDSM
 *
 *      Set up a parallel TID range scan descriptor.
 * ----------------------------------------------------------------
 */
void
ExecTidRangeScanInitializeDSM(TidRangeScanState *node, ParallelContext *pcxt)
{
    EState     *estate = node->ss.ps.state;
    ParallelTableScanDesc pscan;
    uint32      flags = SO_NONE;
 
    if (ScanRelIsReadOnly(&node->ss))
        flags |= SO_HINT_REL_READ_ONLY;
 
    if (estate->es_instrument & INSTRUMENT_IO)
        flags |= SO_SCAN_INSTRUMENT;
 
    pscan = shm_toc_allocate(pcxt->toc, node->trss_pscanlen);
    table_parallelscan_initialize(node->ss.ss_currentRelation,
                                  pscan,
                                  estate->es_snapshot);
    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, pscan);
    node->ss.ss_currentScanDesc =
        table_beginscan_parallel_tidrange(node->ss.ss_currentRelation,
                                          pscan, flags);
}
 
/* ----------------------------------------------------------------
 *      ExecTidRangeScanReInitializeDSM
 *
 *      Reset shared state before beginning a fresh scan.
 * ----------------------------------------------------------------
 */
void
ExecTidRangeScanReInitializeDSM(TidRangeScanState *node,
                                ParallelContext *pcxt)
{
    ParallelTableScanDesc pscan;
 
    pscan = node->ss.ss_currentScanDesc->rs_parallel;
    table_parallelscan_reinitialize(node->ss.ss_currentRelation, pscan);
}
 
/* ----------------------------------------------------------------
 *      ExecTidRangeScanInitializeWorker
 *
 *      Copy relevant information from TOC into planstate.
 * ----------------------------------------------------------------
 */
void
ExecTidRangeScanInitializeWorker(TidRangeScanState *node,
                                 ParallelWorkerContext *pwcxt)
{
    ParallelTableScanDesc pscan;
    uint32      flags = SO_NONE;
 
    if (ScanRelIsReadOnly(&node->ss))
        flags |= SO_HINT_REL_READ_ONLY;
 
    if (node->ss.ps.state->es_instrument & INSTRUMENT_IO)
        flags |= SO_SCAN_INSTRUMENT;
 
    pscan = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
    node->ss.ss_currentScanDesc =
        table_beginscan_parallel_tidrange(node->ss.ss_currentRelation,
                                          pscan, flags);
}
 
/*
 * Compute the amount of space we'll need for the shared instrumentation and
 * inform pcxt->estimator.
 */
void
ExecTidRangeScanInstrumentEstimate(TidRangeScanState *node,
                                   ParallelContext *pcxt)
{
    EState     *estate = node->ss.ps.state;
    Size        size;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0 || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedTidRangeScanInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(TidRangeScanInstrumentation)));
 
    shm_toc_estimate_chunk(&pcxt->estimator, size);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}
 
/*
 * Set up parallel scan instrumentation.
 */
void
ExecTidRangeScanInstrumentInitDSM(TidRangeScanState *node,
                                  ParallelContext *pcxt)
{
    EState     *estate = node->ss.ps.state;
    SharedTidRangeScanInstrumentation *sinstrument;
    Size        size;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0 || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedTidRangeScanInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(TidRangeScanInstrumentation)));
    sinstrument = shm_toc_allocate(pcxt->toc, size);
    memset(sinstrument, 0, size);
    sinstrument->num_workers = pcxt->nworkers;
    shm_toc_insert(pcxt->toc,
                   node->ss.ps.plan->plan_node_id +
                   PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
                   sinstrument);
    node->trss_sinstrument = sinstrument;
}
 
/*
 * Look up and save the location of the shared instrumentation.
 */
void
ExecTidRangeScanInstrumentInitWorker(TidRangeScanState *node,
                                     ParallelWorkerContext *pwcxt)
{
    EState     *estate = node->ss.ps.state;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0)
        return;
 
    node->trss_sinstrument = shm_toc_lookup(pwcxt->toc,
                                            node->ss.ps.plan->plan_node_id +
                                            PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
                                            false);
}
 
/*
 * Transfer scan instrumentation from DSM to private memory.
 */
void
ExecTidRangeScanRetrieveInstrumentation(TidRangeScanState *node)
{
    SharedTidRangeScanInstrumentation *sinstrument = node->trss_sinstrument;
    Size        size;
 
    if (sinstrument == NULL)
        return;
 
    size = offsetof(SharedTidRangeScanInstrumentation, sinstrument)
        + sinstrument->num_workers * sizeof(TidRangeScanInstrumentation);
 
    node->trss_sinstrument = palloc(size);
    memcpy(node->trss_sinstrument, sinstrument, size);
}

Typedef Documentation

TidOpExpr

typedef struct TidOpExpr TidOpExpr

Enumeration Type Documentation

TidExprType

enum TidExprType

Enumerator
TIDEXPR_UPPER_BOUND
TIDEXPR_LOWER_BOUND

Definition at line 40 of file nodeTidrangescan.c.

{
    TIDEXPR_UPPER_BOUND,
    TIDEXPR_LOWER_BOUND,
} TidExprType;

Function Documentation

ExecEndTidRangeScan()

void ExecEndTidRangeScan

(

TidRangeScanState *

node

)

Definition at line 350 of file nodeTidrangescan.c.

{
    TableScanDesc scan = node->ss.ss_currentScanDesc;
 
    /* Collect IO stats for this process into shared instrumentation */
    if (node->trss_sinstrument != NULL && IsParallelWorker())
    {
        TidRangeScanInstrumentation *si;
 
        Assert(ParallelWorkerNumber < node->trss_sinstrument->num_workers);
        si = &node->trss_sinstrument->sinstrument[ParallelWorkerNumber];
 
        if (scan && scan->rs_instrument)
        {
            AccumulateIOStats(&si->stats.io, &scan->rs_instrument->io);
        }
    }
 
    if (scan != NULL)
        table_endscan(scan);
}

References AccumulateIOStats(), Assert, fb(), TableScanInstrumentation::io, IsParallelWorker, ParallelWorkerNumber, TableScanDescData::rs_instrument, SharedTidRangeScanInstrumentation::sinstrument, TidRangeScanState::ss, ScanState::ss_currentScanDesc, table_endscan(), and TidRangeScanState::trss_sinstrument.

Referenced by ExecEndNode().

ExecInitTidRangeScan()

TidRangeScanState * ExecInitTidRangeScan	(	TidRangeScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 384 of file nodeTidrangescan.c.

{
    TidRangeScanState *tidrangestate;
    Relation    currentRelation;
 
    /*
     * create state structure
     */
    tidrangestate = makeNode(TidRangeScanState);
    tidrangestate->ss.ps.plan = (Plan *) node;
    tidrangestate->ss.ps.state = estate;
    tidrangestate->ss.ps.ExecProcNode = ExecTidRangeScan;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &tidrangestate->ss.ps);
 
    /*
     * mark scan as not in progress, and TID range as not computed yet
     */
    tidrangestate->trss_inScan = false;
 
    /*
     * open the scan relation
     */
    currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
 
    tidrangestate->ss.ss_currentRelation = currentRelation;
    tidrangestate->ss.ss_currentScanDesc = NULL;    /* no table scan here */
 
    /*
     * get the scan type from the relation descriptor.
     */
    ExecInitScanTupleSlot(estate, &tidrangestate->ss,
                          RelationGetDescr(currentRelation),
                          table_slot_callbacks(currentRelation),
                          TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS);
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&tidrangestate->ss.ps);
    ExecAssignScanProjectionInfo(&tidrangestate->ss);
 
    /*
     * initialize child expressions
     */
    tidrangestate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) tidrangestate);
 
    TidExprListCreate(tidrangestate);
 
    /*
     * all done.
     */
    return tidrangestate;
}

References ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), ExecTidRangeScan(), fb(), makeNode, RelationGetDescr, TidRangeScan::scan, Scan::scanrelid, table_slot_callbacks(), TidExprListCreate(), and TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS.

Referenced by ExecInitNode().

ExecReScanTidRangeScan()

void ExecReScanTidRangeScan

(

TidRangeScanState *

node

)

Definition at line 331 of file nodeTidrangescan.c.

{
    /* mark scan as not in progress, and tid range list as not computed yet */
    node->trss_inScan = false;
 
    /*
     * We must wait until TidRangeNext before calling table_rescan_tidrange.
     */
    ExecScanReScan(&node->ss);
}

References ExecScanReScan(), TidRangeScanState::ss, and TidRangeScanState::trss_inScan.

Referenced by ExecReScan().

ExecTidRangeScan()

static TupleTableSlot * ExecTidRangeScan ( PlanState *  pstate )

static

Definition at line 317 of file nodeTidrangescan.c.

{
    TidRangeScanState *node = castNode(TidRangeScanState, pstate);
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) TidRangeNext,
                    (ExecScanRecheckMtd) TidRangeRecheck);
}

References castNode, ExecScan(), TidRangeScanState::ss, TidRangeNext(), and TidRangeRecheck().

Referenced by ExecInitTidRangeScan().

ExecTidRangeScanEstimate()

void ExecTidRangeScanEstimate	(	TidRangeScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 458 of file nodeTidrangescan.c.

{
    EState     *estate = node->ss.ps.state;
 
    node->trss_pscanlen =
        table_parallelscan_estimate(node->ss.ss_currentRelation,
                                    estate->es_snapshot);
    shm_toc_estimate_chunk(&pcxt->estimator, node->trss_pscanlen);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References EState::es_snapshot, ParallelContext::estimator, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, TidRangeScanState::ss, ScanState::ss_currentRelation, PlanState::state, table_parallelscan_estimate(), and TidRangeScanState::trss_pscanlen.

Referenced by ExecParallelEstimate().

ExecTidRangeScanInitializeDSM()

void ExecTidRangeScanInitializeDSM	(	TidRangeScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 476 of file nodeTidrangescan.c.

{
    EState     *estate = node->ss.ps.state;
    ParallelTableScanDesc pscan;
    uint32      flags = SO_NONE;
 
    if (ScanRelIsReadOnly(&node->ss))
        flags |= SO_HINT_REL_READ_ONLY;
 
    if (estate->es_instrument & INSTRUMENT_IO)
        flags |= SO_SCAN_INSTRUMENT;
 
    pscan = shm_toc_allocate(pcxt->toc, node->trss_pscanlen);
    table_parallelscan_initialize(node->ss.ss_currentRelation,
                                  pscan,
                                  estate->es_snapshot);
    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, pscan);
    node->ss.ss_currentScanDesc =
        table_beginscan_parallel_tidrange(node->ss.ss_currentRelation,
                                          pscan, flags);
}

References EState::es_instrument, EState::es_snapshot, fb(), INSTRUMENT_IO, PlanState::plan, Plan::plan_node_id, ScanState::ps, ScanRelIsReadOnly(), shm_toc_allocate(), shm_toc_insert(), SO_HINT_REL_READ_ONLY, SO_NONE, SO_SCAN_INSTRUMENT, TidRangeScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, table_beginscan_parallel_tidrange(), table_parallelscan_initialize(), ParallelContext::toc, and TidRangeScanState::trss_pscanlen.

Referenced by ExecParallelInitializeDSM().

ExecTidRangeScanInitializeWorker()

void ExecTidRangeScanInitializeWorker	(	TidRangeScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 521 of file nodeTidrangescan.c.

{
    ParallelTableScanDesc pscan;
    uint32      flags = SO_NONE;
 
    if (ScanRelIsReadOnly(&node->ss))
        flags |= SO_HINT_REL_READ_ONLY;
 
    if (node->ss.ps.state->es_instrument & INSTRUMENT_IO)
        flags |= SO_SCAN_INSTRUMENT;
 
    pscan = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
    node->ss.ss_currentScanDesc =
        table_beginscan_parallel_tidrange(node->ss.ss_currentRelation,
                                          pscan, flags);
}

References EState::es_instrument, fb(), INSTRUMENT_IO, PlanState::plan, Plan::plan_node_id, ScanState::ps, ScanRelIsReadOnly(), shm_toc_lookup(), SO_HINT_REL_READ_ONLY, SO_NONE, SO_SCAN_INSTRUMENT, TidRangeScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, and table_beginscan_parallel_tidrange().

Referenced by ExecParallelInitializeWorker().

ExecTidRangeScanInstrumentEstimate()

void ExecTidRangeScanInstrumentEstimate	(	TidRangeScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 544 of file nodeTidrangescan.c.

{
    EState     *estate = node->ss.ps.state;
    Size        size;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0 || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedTidRangeScanInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(TidRangeScanInstrumentation)));
 
    shm_toc_estimate_chunk(&pcxt->estimator, size);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References add_size(), EState::es_instrument, ParallelContext::estimator, fb(), INSTRUMENT_IO, mul_size(), ParallelContext::nworkers, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, TidRangeScanState::ss, and PlanState::state.

Referenced by ExecParallelEstimate().

ExecTidRangeScanInstrumentInitDSM()

void ExecTidRangeScanInstrumentInitDSM	(	TidRangeScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 564 of file nodeTidrangescan.c.

{
    EState     *estate = node->ss.ps.state;
    SharedTidRangeScanInstrumentation *sinstrument;
    Size        size;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0 || pcxt->nworkers == 0)
        return;
 
    size = add_size(offsetof(SharedTidRangeScanInstrumentation, sinstrument),
                    mul_size(pcxt->nworkers, sizeof(TidRangeScanInstrumentation)));
    sinstrument = shm_toc_allocate(pcxt->toc, size);
    memset(sinstrument, 0, size);
    sinstrument->num_workers = pcxt->nworkers;
    shm_toc_insert(pcxt->toc,
                   node->ss.ps.plan->plan_node_id +
                   PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
                   sinstrument);
    node->trss_sinstrument = sinstrument;
}

References add_size(), EState::es_instrument, fb(), INSTRUMENT_IO, mul_size(), SharedTidRangeScanInstrumentation::num_workers, ParallelContext::nworkers, PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_allocate(), shm_toc_insert(), TidRangeScanState::ss, PlanState::state, ParallelContext::toc, and TidRangeScanState::trss_sinstrument.

Referenced by ExecParallelInitializeDSM().

ExecTidRangeScanInstrumentInitWorker()

void ExecTidRangeScanInstrumentInitWorker	(	TidRangeScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 590 of file nodeTidrangescan.c.

{
    EState     *estate = node->ss.ps.state;
 
    if ((estate->es_instrument & INSTRUMENT_IO) == 0)
        return;
 
    node->trss_sinstrument = shm_toc_lookup(pwcxt->toc,
                                            node->ss.ps.plan->plan_node_id +
                                            PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET,
                                            false);
}

References EState::es_instrument, fb(), INSTRUMENT_IO, PARALLEL_KEY_SCAN_INSTRUMENT_OFFSET, PlanState::plan, Plan::plan_node_id, ScanState::ps, shm_toc_lookup(), TidRangeScanState::ss, PlanState::state, and TidRangeScanState::trss_sinstrument.

Referenced by ExecParallelInitializeWorker().

ExecTidRangeScanReInitializeDSM()

void ExecTidRangeScanReInitializeDSM	(	TidRangeScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 505 of file nodeTidrangescan.c.

{
    ParallelTableScanDesc pscan;
 
    pscan = node->ss.ss_currentScanDesc->rs_parallel;
    table_parallelscan_reinitialize(node->ss.ss_currentRelation, pscan);
}

References fb(), TableScanDescData::rs_parallel, TidRangeScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, and table_parallelscan_reinitialize().

Referenced by ExecParallelReInitializeDSM().

ExecTidRangeScanRetrieveInstrumentation()

void ExecTidRangeScanRetrieveInstrumentation

(

TidRangeScanState *

node

)

Definition at line 608 of file nodeTidrangescan.c.

{
    SharedTidRangeScanInstrumentation *sinstrument = node->trss_sinstrument;
    Size        size;
 
    if (sinstrument == NULL)
        return;
 
    size = offsetof(SharedTidRangeScanInstrumentation, sinstrument)
        + sinstrument->num_workers * sizeof(TidRangeScanInstrumentation);
 
    node->trss_sinstrument = palloc(size);
    memcpy(node->trss_sinstrument, sinstrument, size);
}

References fb(), memcpy(), SharedTidRangeScanInstrumentation::num_workers, palloc(), and TidRangeScanState::trss_sinstrument.

Referenced by ExecParallelRetrieveInstrumentation().

MakeTidOpExpr()

static TidOpExpr * MakeTidOpExpr ( OpExpr *  expr, TidRangeScanState *  tidstate  )

static

Definition at line 59 of file nodeTidrangescan.c.

{
    Node       *arg1 = get_leftop((Expr *) expr);
    Node       *arg2 = get_rightop((Expr *) expr);
    ExprState  *exprstate = NULL;
    bool        invert = false;
    TidOpExpr  *tidopexpr;
 
    if (IsCTIDVar(arg1))
        exprstate = ExecInitExpr((Expr *) arg2, &tidstate->ss.ps);
    else if (IsCTIDVar(arg2))
    {
        exprstate = ExecInitExpr((Expr *) arg1, &tidstate->ss.ps);
        invert = true;
    }
    else
        elog(ERROR, "could not identify CTID variable");
 
    tidopexpr = palloc_object(TidOpExpr);
    tidopexpr->inclusive = false;   /* for now */
 
    switch (expr->opno)
    {
        case TIDLessEqOperator:
            tidopexpr->inclusive = true;
            pg_fallthrough;
        case TIDLessOperator:
            tidopexpr->exprtype = invert ? TIDEXPR_LOWER_BOUND : TIDEXPR_UPPER_BOUND;
            break;
        case TIDGreaterEqOperator:
            tidopexpr->inclusive = true;
            pg_fallthrough;
        case TIDGreaterOperator:
            tidopexpr->exprtype = invert ? TIDEXPR_UPPER_BOUND : TIDEXPR_LOWER_BOUND;
            break;
        default:
            elog(ERROR, "could not identify CTID operator");
    }
 
    tidopexpr->exprstate = exprstate;
 
    return tidopexpr;
}

References elog, ERROR, ExecInitExpr(), fb(), get_leftop(), get_rightop(), IsCTIDVar, OpExpr::opno, palloc_object, pg_fallthrough, TIDEXPR_LOWER_BOUND, and TIDEXPR_UPPER_BOUND.

Referenced by TidExprListCreate().

TidExprListCreate()

static void TidExprListCreate ( TidRangeScanState *  tidrangestate )

static

Definition at line 108 of file nodeTidrangescan.c.

{
    TidRangeScan *node = (TidRangeScan *) tidrangestate->ss.ps.plan;
    List       *tidexprs = NIL;
    ListCell   *l;
 
    foreach(l, node->tidrangequals)
    {
        OpExpr     *opexpr = lfirst(l);
        TidOpExpr  *tidopexpr;
 
        if (!IsA(opexpr, OpExpr))
            elog(ERROR, "could not identify CTID expression");
 
        tidopexpr = MakeTidOpExpr(opexpr, tidrangestate);
        tidexprs = lappend(tidexprs, tidopexpr);
    }
 
    tidrangestate->trss_tidexprs = tidexprs;
}

References elog, ERROR, fb(), IsA, lappend(), lfirst, MakeTidOpExpr(), NIL, and TidRangeScan::tidrangequals.

Referenced by ExecInitTidRangeScan().

TidRangeEval()

static bool TidRangeEval ( TidRangeScanState *  node )

static

Definition at line 141 of file nodeTidrangescan.c.

{
    ExprContext *econtext = node->ss.ps.ps_ExprContext;
    ItemPointerData lowerBound;
    ItemPointerData upperBound;
    ListCell   *l;
 
    /*
     * Set the upper and lower bounds to the absolute limits of the range of
     * the ItemPointer type.  Below we'll try to narrow this range on either
     * side by looking at the TidOpExprs.
     */
    ItemPointerSet(&lowerBound, 0, 0);
    ItemPointerSet(&upperBound, InvalidBlockNumber, PG_UINT16_MAX);
 
    foreach(l, node->trss_tidexprs)
    {
        TidOpExpr  *tidopexpr = (TidOpExpr *) lfirst(l);
        ItemPointer itemptr;
        bool        isNull;
 
        /* Evaluate this bound. */
        itemptr = (ItemPointer)
            DatumGetPointer(ExecEvalExprSwitchContext(tidopexpr->exprstate,
                                                      econtext,
                                                      &isNull));
 
        /* If the bound is NULL, *nothing* matches the qual. */
        if (isNull)
            return false;
 
        if (tidopexpr->exprtype == TIDEXPR_LOWER_BOUND)
        {
            ItemPointerData lb;
 
            ItemPointerCopy(itemptr, &lb);
 
            /*
             * Normalize non-inclusive ranges to become inclusive.  The
             * resulting ItemPointer here may not be a valid item pointer.
             */
            if (!tidopexpr->inclusive)
                ItemPointerInc(&lb);
 
            /* Check if we can narrow the range using this qual */
            if (ItemPointerCompare(&lb, &lowerBound) > 0)
                ItemPointerCopy(&lb, &lowerBound);
        }
 
        else if (tidopexpr->exprtype == TIDEXPR_UPPER_BOUND)
        {
            ItemPointerData ub;
 
            ItemPointerCopy(itemptr, &ub);
 
            /*
             * Normalize non-inclusive ranges to become inclusive.  The
             * resulting ItemPointer here may not be a valid item pointer.
             */
            if (!tidopexpr->inclusive)
                ItemPointerDec(&ub);
 
            /* Check if we can narrow the range using this qual */
            if (ItemPointerCompare(&ub, &upperBound) < 0)
                ItemPointerCopy(&ub, &upperBound);
        }
    }
 
    ItemPointerCopy(&lowerBound, &node->trss_mintid);
    ItemPointerCopy(&upperBound, &node->trss_maxtid);
 
    return true;
}

References DatumGetPointer(), ExecEvalExprSwitchContext(), fb(), InvalidBlockNumber, ItemPointerCompare(), ItemPointerCopy(), ItemPointerDec(), ItemPointerInc(), ItemPointerSet(), lfirst, PG_UINT16_MAX, ScanState::ps, PlanState::ps_ExprContext, TidRangeScanState::ss, TIDEXPR_LOWER_BOUND, TIDEXPR_UPPER_BOUND, TidRangeScanState::trss_maxtid, TidRangeScanState::trss_mintid, and TidRangeScanState::trss_tidexprs.

Referenced by TidRangeNext(), and TidRangeRecheck().

TidRangeNext()

static TupleTableSlot * TidRangeNext ( TidRangeScanState *  node )

static

Definition at line 224 of file nodeTidrangescan.c.

{
    TableScanDesc scandesc;
    EState     *estate;
    ScanDirection direction;
    TupleTableSlot *slot;
 
    /*
     * extract necessary information from TID scan node
     */
    scandesc = node->ss.ss_currentScanDesc;
    estate = node->ss.ps.state;
    slot = node->ss.ss_ScanTupleSlot;
    direction = estate->es_direction;
 
    if (!node->trss_inScan)
    {
        /* First time through, compute TID range to scan */
        if (!TidRangeEval(node))
            return NULL;
 
        if (scandesc == NULL)
        {
            uint32      flags = SO_NONE;
 
            if (ScanRelIsReadOnly(&node->ss))
                flags |= SO_HINT_REL_READ_ONLY;
 
            if (estate->es_instrument & INSTRUMENT_IO)
                flags |= SO_SCAN_INSTRUMENT;
 
            scandesc = table_beginscan_tidrange(node->ss.ss_currentRelation,
                                                estate->es_snapshot,
                                                &node->trss_mintid,
                                                &node->trss_maxtid,
                                                flags);
            node->ss.ss_currentScanDesc = scandesc;
        }
        else
        {
            /* rescan with the updated TID range */
            table_rescan_tidrange(scandesc, &node->trss_mintid,
                                  &node->trss_maxtid);
        }
 
        node->trss_inScan = true;
    }
 
    /* Fetch the next tuple. */
    if (!table_scan_getnextslot_tidrange(scandesc, direction, slot))
    {
        node->trss_inScan = false;
        ExecClearTuple(slot);
    }
 
    return slot;
}

References EState::es_direction, EState::es_instrument, EState::es_snapshot, ExecClearTuple(), fb(), INSTRUMENT_IO, ScanState::ps, ScanRelIsReadOnly(), SO_HINT_REL_READ_ONLY, SO_NONE, SO_SCAN_INSTRUMENT, TidRangeScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, ScanState::ss_ScanTupleSlot, PlanState::state, table_beginscan_tidrange(), table_rescan_tidrange(), table_scan_getnextslot_tidrange(), TidRangeEval(), TidRangeScanState::trss_inScan, TidRangeScanState::trss_maxtid, and TidRangeScanState::trss_mintid.

Referenced by ExecTidRangeScan().

TidRangeRecheck()

static bool TidRangeRecheck ( TidRangeScanState *  node, TupleTableSlot *  slot  )

static

Definition at line 286 of file nodeTidrangescan.c.

{
    if (!TidRangeEval(node))
        return false;
 
    Assert(ItemPointerIsValid(&slot->tts_tid));
 
    /* Recheck the ctid is still within range */
    if (ItemPointerCompare(&slot->tts_tid, &node->trss_mintid) < 0 ||
        ItemPointerCompare(&slot->tts_tid, &node->trss_maxtid) > 0)
        return false;
 
    return true;
}

References Assert, ItemPointerCompare(), ItemPointerIsValid(), TidRangeEval(), TidRangeScanState::trss_maxtid, TidRangeScanState::trss_mintid, and TupleTableSlot::tts_tid.

Referenced by ExecTidRangeScan().