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/executor.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)

Macro Definition Documentation

IsCTIDVar

#define IsCTIDVar

(

node

)

Value:

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

Definition at line 33 of file nodeTidrangescan.c.

Typedef Documentation

TidOpExpr

typedef struct TidOpExpr TidOpExpr

Enumeration Type Documentation

TidExprType

enum TidExprType

Enumerator
TIDEXPR_UPPER_BOUND
TIDEXPR_LOWER_BOUND

Definition at line 38 of file nodeTidrangescan.c.

{
    TIDEXPR_UPPER_BOUND,
    TIDEXPR_LOWER_BOUND,
} TidExprType;

Function Documentation

ExecEndTidRangeScan()

void ExecEndTidRangeScan

(

TidRangeScanState *

node

)

Definition at line 327 of file nodeTidrangescan.c.

{
    TableScanDesc scan = node->ss.ss_currentScanDesc;
 
    if (scan != NULL)
        table_endscan(scan);
}

References TidRangeScanState::ss, ScanState::ss_currentScanDesc, and table_endscan().

Referenced by ExecEndNode().

ExecInitTidRangeScan()

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

Definition at line 347 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));
 
    /*
     * 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(), PlanState::ExecProcNode, ExecTidRangeScan(), makeNode, PlanState::plan, ScanState::ps, PlanState::qual, RelationGetDescr, TidRangeScan::scan, Scan::scanrelid, TidRangeScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, table_slot_callbacks(), TidExprListCreate(), and TidRangeScanState::trss_inScan.

Referenced by ExecInitNode().

ExecReScanTidRangeScan()

void ExecReScanTidRangeScan

(

TidRangeScanState *

node

)

Definition at line 308 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 294 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().

MakeTidOpExpr()

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

static

Definition at line 57 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 = (TidOpExpr *) palloc(sizeof(TidOpExpr));
    tidopexpr->inclusive = false;   /* for now */
 
    switch (expr->opno)
    {
        case TIDLessEqOperator:
            tidopexpr->inclusive = true;
            /* fall through */
        case TIDLessOperator:
            tidopexpr->exprtype = invert ? TIDEXPR_LOWER_BOUND : TIDEXPR_UPPER_BOUND;
            break;
        case TIDGreaterEqOperator:
            tidopexpr->inclusive = true;
            /* fall through */
        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(), TidOpExpr::exprstate, TidOpExpr::exprtype, get_leftop(), get_rightop(), TidOpExpr::inclusive, IsCTIDVar, OpExpr::opno, palloc(), ScanState::ps, TidRangeScanState::ss, TIDEXPR_LOWER_BOUND, and TIDEXPR_UPPER_BOUND.

Referenced by TidExprListCreate().

TidExprListCreate()

static void TidExprListCreate ( TidRangeScanState *  tidrangestate )

static

Definition at line 106 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, IsA, lappend(), lfirst, MakeTidOpExpr(), NIL, PlanState::plan, ScanState::ps, TidRangeScanState::ss, TidRangeScan::tidrangequals, and TidRangeScanState::trss_tidexprs.

Referenced by ExecInitTidRangeScan().

TidRangeEval()

static bool TidRangeEval ( TidRangeScanState *  node )

static

Definition at line 137 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(), TidOpExpr::exprstate, TidOpExpr::exprtype, TidOpExpr::inclusive, 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().

TidRangeNext()

static TupleTableSlot * TidRangeNext ( TidRangeScanState *  node )

static

Definition at line 220 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)
        {
            scandesc = table_beginscan_tidrange(node->ss.ss_currentRelation,
                                                estate->es_snapshot,
                                                &node->trss_mintid,
                                                &node->trss_maxtid);
            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_snapshot, ExecClearTuple(), ScanState::ps, 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 273 of file nodeTidrangescan.c.

{
    return true;
}

Referenced by ExecTidRangeScan().