nodeTidscan.c File Reference

#include "postgres.h"
#include "access/sysattr.h"
#include "access/tableam.h"
#include "catalog/pg_type.h"
#include "executor/executor.h"
#include "executor/nodeTidscan.h"
#include "lib/qunique.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "utils/array.h"
#include "utils/rel.h"

Include dependency graph for nodeTidscan.c:

Go to the source code of this file.

Data Structures
struct	TidExpr

Macros
#define	IsCTIDVar(node)

Typedefs
typedef struct TidExpr	TidExpr

Functions
static void	TidExprListCreate (TidScanState *tidstate)
static void	TidListEval (TidScanState *tidstate)
static int	itemptr_comparator (const void *a, const void *b)
static TupleTableSlot *	TidNext (TidScanState *node)
static bool	TidRecheck (TidScanState *node, TupleTableSlot *slot)
static TupleTableSlot *	ExecTidScan (PlanState *pstate)
void	ExecReScanTidScan (TidScanState *node)
void	ExecEndTidScan (TidScanState *node)
TidScanState *	ExecInitTidScan (TidScan *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 43 of file nodeTidscan.c.

Typedef Documentation

TidExpr

typedef struct TidExpr TidExpr

Function Documentation

ExecEndTidScan()

void ExecEndTidScan

(

TidScanState *

node

)

Definition at line 470 of file nodeTidscan.c.

{
    if (node->ss.ss_currentScanDesc)
        table_endscan(node->ss.ss_currentScanDesc);
}

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

Referenced by ExecEndNode().

ExecInitTidScan()

TidScanState* ExecInitTidScan	(	TidScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 488 of file nodeTidscan.c.

{
    TidScanState *tidstate;
    Relation    currentRelation;
 
    /*
     * create state structure
     */
    tidstate = makeNode(TidScanState);
    tidstate->ss.ps.plan = (Plan *) node;
    tidstate->ss.ps.state = estate;
    tidstate->ss.ps.ExecProcNode = ExecTidScan;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &tidstate->ss.ps);
 
    /*
     * mark tid list as not computed yet
     */
    tidstate->tss_TidList = NULL;
    tidstate->tss_NumTids = 0;
    tidstate->tss_TidPtr = -1;
 
    /*
     * open the scan relation
     */
    currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
 
    tidstate->ss.ss_currentRelation = currentRelation;
    tidstate->ss.ss_currentScanDesc = NULL; /* no heap scan here */
 
    /*
     * get the scan type from the relation descriptor.
     */
    ExecInitScanTupleSlot(estate, &tidstate->ss,
                          RelationGetDescr(currentRelation),
                          table_slot_callbacks(currentRelation));
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&tidstate->ss.ps);
    ExecAssignScanProjectionInfo(&tidstate->ss);
 
    /*
     * initialize child expressions
     */
    tidstate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) tidstate);
 
    TidExprListCreate(tidstate);
 
    /*
     * all done.
     */
    return tidstate;
}

References ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), PlanState::ExecProcNode, ExecTidScan(), makeNode, PlanState::plan, ScanState::ps, PlanState::qual, RelationGetDescr, TidScan::scan, Scan::scanrelid, TidScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, table_slot_callbacks(), TidExprListCreate(), TidScanState::tss_NumTids, TidScanState::tss_TidList, and TidScanState::tss_TidPtr.

Referenced by ExecInitNode().

ExecReScanTidScan()

void ExecReScanTidScan

(

TidScanState *

node

)

Definition at line 447 of file nodeTidscan.c.

{
    if (node->tss_TidList)
        pfree(node->tss_TidList);
    node->tss_TidList = NULL;
    node->tss_NumTids = 0;
    node->tss_TidPtr = -1;
 
    /* not really necessary, but seems good form */
    if (node->ss.ss_currentScanDesc)
        table_rescan(node->ss.ss_currentScanDesc, NULL);
 
    ExecScanReScan(&node->ss);
}

References ExecScanReScan(), pfree(), TidScanState::ss, ScanState::ss_currentScanDesc, table_rescan(), TidScanState::tss_NumTids, TidScanState::tss_TidList, and TidScanState::tss_TidPtr.

Referenced by ExecReScan().

ExecTidScan()

static TupleTableSlot* ExecTidScan ( PlanState *  pstate )

static

Definition at line 433 of file nodeTidscan.c.

{
    TidScanState *node = castNode(TidScanState, pstate);
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) TidNext,
                    (ExecScanRecheckMtd) TidRecheck);
}

References castNode, ExecScan(), TidScanState::ss, TidNext(), and TidRecheck().

Referenced by ExecInitTidScan().

itemptr_comparator()

static int itemptr_comparator ( const void *  a, const void *  b  )

static

Definition at line 283 of file nodeTidscan.c.

{
    const ItemPointerData *ipa = (const ItemPointerData *) a;
    const ItemPointerData *ipb = (const ItemPointerData *) b;
    BlockNumber ba = ItemPointerGetBlockNumber(ipa);
    BlockNumber bb = ItemPointerGetBlockNumber(ipb);
    OffsetNumber oa = ItemPointerGetOffsetNumber(ipa);
    OffsetNumber ob = ItemPointerGetOffsetNumber(ipb);
 
    if (ba < bb)
        return -1;
    if (ba > bb)
        return 1;
    if (oa < ob)
        return -1;
    if (oa > ob)
        return 1;
    return 0;
}

References a, b, ItemPointerGetBlockNumber(), and ItemPointerGetOffsetNumber().

Referenced by TidListEval().

TidExprListCreate()

static void TidExprListCreate ( TidScanState *  tidstate )

static

Definition at line 70 of file nodeTidscan.c.

{
    TidScan    *node = (TidScan *) tidstate->ss.ps.plan;
    ListCell   *l;
 
    tidstate->tss_tidexprs = NIL;
    tidstate->tss_isCurrentOf = false;
 
    foreach(l, node->tidquals)
    {
        Expr       *expr = (Expr *) lfirst(l);
        TidExpr    *tidexpr = (TidExpr *) palloc0(sizeof(TidExpr));
 
        if (is_opclause(expr))
        {
            Node       *arg1;
            Node       *arg2;
 
            arg1 = get_leftop(expr);
            arg2 = get_rightop(expr);
            if (IsCTIDVar(arg1))
                tidexpr->exprstate = ExecInitExpr((Expr *) arg2,
                                                  &tidstate->ss.ps);
            else if (IsCTIDVar(arg2))
                tidexpr->exprstate = ExecInitExpr((Expr *) arg1,
                                                  &tidstate->ss.ps);
            else
                elog(ERROR, "could not identify CTID variable");
            tidexpr->isarray = false;
        }
        else if (expr && IsA(expr, ScalarArrayOpExpr))
        {
            ScalarArrayOpExpr *saex = (ScalarArrayOpExpr *) expr;
 
            Assert(IsCTIDVar(linitial(saex->args)));
            tidexpr->exprstate = ExecInitExpr(lsecond(saex->args),
                                              &tidstate->ss.ps);
            tidexpr->isarray = true;
        }
        else if (expr && IsA(expr, CurrentOfExpr))
        {
            CurrentOfExpr *cexpr = (CurrentOfExpr *) expr;
 
            tidexpr->cexpr = cexpr;
            tidstate->tss_isCurrentOf = true;
        }
        else
            elog(ERROR, "could not identify CTID expression");
 
        tidstate->tss_tidexprs = lappend(tidstate->tss_tidexprs, tidexpr);
    }
 
    /* CurrentOfExpr could never appear OR'd with something else */
    Assert(list_length(tidstate->tss_tidexprs) == 1 ||
           !tidstate->tss_isCurrentOf);
}

References ScalarArrayOpExpr::args, Assert, TidExpr::cexpr, elog, ERROR, ExecInitExpr(), TidExpr::exprstate, get_leftop(), get_rightop(), is_opclause(), IsA, TidExpr::isarray, IsCTIDVar, lappend(), lfirst, linitial, list_length(), lsecond, NIL, palloc0(), PlanState::plan, ScanState::ps, TidScanState::ss, TidScan::tidquals, TidScanState::tss_isCurrentOf, and TidScanState::tss_tidexprs.

Referenced by ExecInitTidScan().

TidListEval()

static void TidListEval ( TidScanState *  tidstate )

static

Definition at line 134 of file nodeTidscan.c.

{
    ExprContext *econtext = tidstate->ss.ps.ps_ExprContext;
    TableScanDesc scan;
    ItemPointerData *tidList;
    int         numAllocTids;
    int         numTids;
    ListCell   *l;
 
    /*
     * Start scan on-demand - initializing a scan isn't free (e.g. heap stats
     * the size of the table), so it makes sense to delay that until needed -
     * the node might never get executed.
     */
    if (tidstate->ss.ss_currentScanDesc == NULL)
        tidstate->ss.ss_currentScanDesc =
            table_beginscan_tid(tidstate->ss.ss_currentRelation,
                                tidstate->ss.ps.state->es_snapshot);
    scan = tidstate->ss.ss_currentScanDesc;
 
    /*
     * We initialize the array with enough slots for the case that all quals
     * are simple OpExprs or CurrentOfExprs.  If there are any
     * ScalarArrayOpExprs, we may have to enlarge the array.
     */
    numAllocTids = list_length(tidstate->tss_tidexprs);
    tidList = (ItemPointerData *)
        palloc(numAllocTids * sizeof(ItemPointerData));
    numTids = 0;
 
    foreach(l, tidstate->tss_tidexprs)
    {
        TidExpr    *tidexpr = (TidExpr *) lfirst(l);
        ItemPointer itemptr;
        bool        isNull;
 
        if (tidexpr->exprstate && !tidexpr->isarray)
        {
            itemptr = (ItemPointer)
                DatumGetPointer(ExecEvalExprSwitchContext(tidexpr->exprstate,
                                                          econtext,
                                                          &isNull));
            if (isNull)
                continue;
 
            /*
             * We silently discard any TIDs that the AM considers invalid
             * (E.g. for heap, they could be out of range at the time of scan
             * start.  Since we hold at least AccessShareLock on the table, it
             * won't be possible for someone to truncate away the blocks we
             * intend to visit.).
             */
            if (!table_tuple_tid_valid(scan, itemptr))
                continue;
 
            if (numTids >= numAllocTids)
            {
                numAllocTids *= 2;
                tidList = (ItemPointerData *)
                    repalloc(tidList,
                             numAllocTids * sizeof(ItemPointerData));
            }
            tidList[numTids++] = *itemptr;
        }
        else if (tidexpr->exprstate && tidexpr->isarray)
        {
            Datum       arraydatum;
            ArrayType  *itemarray;
            Datum      *ipdatums;
            bool       *ipnulls;
            int         ndatums;
            int         i;
 
            arraydatum = ExecEvalExprSwitchContext(tidexpr->exprstate,
                                                   econtext,
                                                   &isNull);
            if (isNull)
                continue;
            itemarray = DatumGetArrayTypeP(arraydatum);
            deconstruct_array_builtin(itemarray, TIDOID, &ipdatums, &ipnulls, &ndatums);
            if (numTids + ndatums > numAllocTids)
            {
                numAllocTids = numTids + ndatums;
                tidList = (ItemPointerData *)
                    repalloc(tidList,
                             numAllocTids * sizeof(ItemPointerData));
            }
            for (i = 0; i < ndatums; i++)
            {
                if (ipnulls[i])
                    continue;
 
                itemptr = (ItemPointer) DatumGetPointer(ipdatums[i]);
 
                if (!table_tuple_tid_valid(scan, itemptr))
                    continue;
 
                tidList[numTids++] = *itemptr;
            }
            pfree(ipdatums);
            pfree(ipnulls);
        }
        else
        {
            ItemPointerData cursor_tid;
 
            Assert(tidexpr->cexpr);
            if (execCurrentOf(tidexpr->cexpr, econtext,
                              RelationGetRelid(tidstate->ss.ss_currentRelation),
                              &cursor_tid))
            {
                if (numTids >= numAllocTids)
                {
                    numAllocTids *= 2;
                    tidList = (ItemPointerData *)
                        repalloc(tidList,
                                 numAllocTids * sizeof(ItemPointerData));
                }
                tidList[numTids++] = cursor_tid;
            }
        }
    }
 
    /*
     * Sort the array of TIDs into order, and eliminate duplicates.
     * Eliminating duplicates is necessary since we want OR semantics across
     * the list.  Sorting makes it easier to detect duplicates, and as a bonus
     * ensures that we will visit the heap in the most efficient way.
     */
    if (numTids > 1)
    {
        /* CurrentOfExpr could never appear OR'd with something else */
        Assert(!tidstate->tss_isCurrentOf);
 
        qsort(tidList, numTids, sizeof(ItemPointerData),
              itemptr_comparator);
        numTids = qunique(tidList, numTids, sizeof(ItemPointerData),
                          itemptr_comparator);
    }
 
    tidstate->tss_TidList = tidList;
    tidstate->tss_NumTids = numTids;
    tidstate->tss_TidPtr = -1;
}

References Assert, TidExpr::cexpr, DatumGetArrayTypeP, DatumGetPointer(), deconstruct_array_builtin(), EState::es_snapshot, execCurrentOf(), ExecEvalExprSwitchContext(), TidExpr::exprstate, i, TidExpr::isarray, itemptr_comparator(), lfirst, list_length(), palloc(), pfree(), ScanState::ps, PlanState::ps_ExprContext, qsort, qunique(), RelationGetRelid, repalloc(), TidScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, PlanState::state, table_beginscan_tid(), table_tuple_tid_valid(), TidScanState::tss_isCurrentOf, TidScanState::tss_NumTids, TidScanState::tss_tidexprs, TidScanState::tss_TidList, and TidScanState::tss_TidPtr.

Referenced by TidNext().

TidNext()

static TupleTableSlot * TidNext ( TidScanState *  node )

static

Definition at line 312 of file nodeTidscan.c.

{
    EState     *estate;
    ScanDirection direction;
    Snapshot    snapshot;
    TableScanDesc scan;
    Relation    heapRelation;
    TupleTableSlot *slot;
    ItemPointerData *tidList;
    int         numTids;
    bool        bBackward;
 
    /*
     * extract necessary information from tid scan node
     */
    estate = node->ss.ps.state;
    direction = estate->es_direction;
    snapshot = estate->es_snapshot;
    heapRelation = node->ss.ss_currentRelation;
    slot = node->ss.ss_ScanTupleSlot;
 
    /*
     * First time through, compute the list of TIDs to be visited
     */
    if (node->tss_TidList == NULL)
        TidListEval(node);
 
    scan = node->ss.ss_currentScanDesc;
    tidList = node->tss_TidList;
    numTids = node->tss_NumTids;
 
    /*
     * Initialize or advance scan position, depending on direction.
     */
    bBackward = ScanDirectionIsBackward(direction);
    if (bBackward)
    {
        if (node->tss_TidPtr < 0)
        {
            /* initialize for backward scan */
            node->tss_TidPtr = numTids - 1;
        }
        else
            node->tss_TidPtr--;
    }
    else
    {
        if (node->tss_TidPtr < 0)
        {
            /* initialize for forward scan */
            node->tss_TidPtr = 0;
        }
        else
            node->tss_TidPtr++;
    }
 
    while (node->tss_TidPtr >= 0 && node->tss_TidPtr < numTids)
    {
        ItemPointerData tid = tidList[node->tss_TidPtr];
 
        /*
         * For WHERE CURRENT OF, the tuple retrieved from the cursor might
         * since have been updated; if so, we should fetch the version that is
         * current according to our snapshot.
         */
        if (node->tss_isCurrentOf)
            table_tuple_get_latest_tid(scan, &tid);
 
        if (table_tuple_fetch_row_version(heapRelation, &tid, snapshot, slot))
            return slot;
 
        /* Bad TID or failed snapshot qual; try next */
        if (bBackward)
            node->tss_TidPtr--;
        else
            node->tss_TidPtr++;
 
        CHECK_FOR_INTERRUPTS();
    }
 
    /*
     * if we get here it means the tid scan failed so we are at the end of the
     * scan..
     */
    return ExecClearTuple(slot);
}

References CHECK_FOR_INTERRUPTS, EState::es_direction, EState::es_snapshot, ExecClearTuple(), ScanState::ps, ScanDirectionIsBackward, TidScanState::ss, ScanState::ss_currentRelation, ScanState::ss_currentScanDesc, ScanState::ss_ScanTupleSlot, PlanState::state, table_tuple_fetch_row_version(), table_tuple_get_latest_tid(), TidListEval(), TidScanState::tss_isCurrentOf, TidScanState::tss_NumTids, TidScanState::tss_TidList, and TidScanState::tss_TidPtr.

Referenced by ExecTidScan().

TidRecheck()

static bool TidRecheck ( TidScanState *  node, TupleTableSlot *  slot  )

static

Definition at line 403 of file nodeTidscan.c.

{
    /*
     * XXX shouldn't we check here to make sure tuple matches TID list? In
     * runtime-key case this is not certain, is it?  However, in the WHERE
     * CURRENT OF case it might not match anyway ...
     */
    return true;
}

Referenced by ExecTidScan().