nodeLockRows.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeLockRows.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
LockRowsState *	ExecInitLockRows (LockRows *node, EState *estate, int eflags)
void	ExecEndLockRows (LockRowsState *node)
void	ExecReScanLockRows (LockRowsState *node)

Function Documentation

ExecEndLockRows()

void ExecEndLockRows ( LockRowsState *  node )

extern

Definition at line 394 of file nodeLockRows.c.

{
    /* We may have shut down EPQ already, but no harm in another call */
    EvalPlanQualEnd(&node->lr_epqstate);
    ExecEndNode(outerPlanState(node));
}

References EvalPlanQualEnd(), ExecEndNode(), LockRowsState::lr_epqstate, and outerPlanState.

Referenced by ExecEndNode().

ExecInitLockRows()

LockRowsState * ExecInitLockRows ( LockRows *  node, EState *  estate, int  eflags  )

extern

Definition at line 291 of file nodeLockRows.c.

{
    LockRowsState *lrstate;
    Plan       *outerPlan = outerPlan(node);
    List       *epq_arowmarks;
    ListCell   *lc;
 
    /* check for unsupported flags */
    Assert(!(eflags & EXEC_FLAG_MARK));
 
    /*
     * create state structure
     */
    lrstate = makeNode(LockRowsState);
    lrstate->ps.plan = (Plan *) node;
    lrstate->ps.state = estate;
    lrstate->ps.ExecProcNode = ExecLockRows;
 
    /*
     * Miscellaneous initialization
     *
     * LockRows nodes never call ExecQual or ExecProject, therefore no
     * ExprContext is needed.
     */
 
    /*
     * Initialize result type.
     */
    ExecInitResultTypeTL(&lrstate->ps);
 
    /*
     * then initialize outer plan
     */
    outerPlanState(lrstate) = ExecInitNode(outerPlan, estate, eflags);
 
    /* node returns unmodified slots from the outer plan */
    lrstate->ps.resultopsset = true;
    lrstate->ps.resultops = ExecGetResultSlotOps(outerPlanState(lrstate),
                                                 &lrstate->ps.resultopsfixed);
 
    /*
     * LockRows nodes do no projections, so initialize projection info for
     * this node appropriately
     */
    lrstate->ps.ps_ProjInfo = NULL;
 
    /*
     * Locate the ExecRowMark(s) that this node is responsible for, and
     * construct ExecAuxRowMarks for them.  (InitPlan should already have
     * built the global list of ExecRowMarks.)
     */
    lrstate->lr_arowMarks = NIL;
    epq_arowmarks = NIL;
    foreach(lc, node->rowMarks)
    {
        PlanRowMark *rc = lfirst_node(PlanRowMark, lc);
        RangeTblEntry *rte = exec_rt_fetch(rc->rti, estate);
        ExecRowMark *erm;
        ExecAuxRowMark *aerm;
 
        /* ignore "parent" rowmarks; they are irrelevant at runtime */
        if (rc->isParent)
            continue;
 
        /*
         * Also ignore rowmarks belonging to child tables that have been
         * pruned in ExecDoInitialPruning().
         */
        if (rte->rtekind == RTE_RELATION &&
            !bms_is_member(rc->rti, estate->es_unpruned_relids))
            continue;
 
        /* find ExecRowMark and build ExecAuxRowMark */
        erm = ExecFindRowMark(estate, rc->rti, false);
        aerm = ExecBuildAuxRowMark(erm, outerPlan->targetlist);
 
        /*
         * Only locking rowmarks go into our own list.  Non-locking marks are
         * passed off to the EvalPlanQual machinery.  This is because we don't
         * want to bother fetching non-locked rows unless we actually have to
         * do an EPQ recheck.
         */
        if (RowMarkRequiresRowShareLock(erm->markType))
            lrstate->lr_arowMarks = lappend(lrstate->lr_arowMarks, aerm);
        else
            epq_arowmarks = lappend(epq_arowmarks, aerm);
    }
 
    /* Now we have the info needed to set up EPQ state */
    EvalPlanQualInit(&lrstate->lr_epqstate, estate,
                     outerPlan, epq_arowmarks, node->epqParam, NIL);
 
    return lrstate;
}

References Assert, bms_is_member(), LockRows::epqParam, EState::es_unpruned_relids, EvalPlanQualInit(), EXEC_FLAG_MARK, exec_rt_fetch(), ExecBuildAuxRowMark(), ExecFindRowMark(), ExecGetResultSlotOps(), ExecInitNode(), ExecInitResultTypeTL(), ExecLockRows(), fb(), PlanRowMark::isParent, lappend(), lfirst_node, makeNode, NIL, outerPlan, outerPlanState, RowMarkRequiresRowShareLock, LockRows::rowMarks, RTE_RELATION, and PlanRowMark::rti.

Referenced by ExecInitNode().

ExecReScanLockRows()

void ExecReScanLockRows ( LockRowsState *  node )

extern

Definition at line 403 of file nodeLockRows.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    /*
     * if chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
}

References ExecReScan(), fb(), outerPlan, and outerPlanState.

Referenced by ExecReScan().