nodeAppend.c File Reference

#include "postgres.h"
#include "executor/execdebug.h"
#include "executor/execPartition.h"
#include "executor/nodeAppend.h"
#include "miscadmin.h"

Include dependency graph for nodeAppend.c:

Go to the source code of this file.

Data Structures
struct	ParallelAppendState

Macros
#define	INVALID_SUBPLAN_INDEX   -1
#define	NO_MATCHING_SUBPLANS   -2

Functions
static TupleTableSlot *	ExecAppend (PlanState *pstate)
static bool	choose_next_subplan_locally (AppendState *node)
static bool	choose_next_subplan_for_leader (AppendState *node)
static bool	choose_next_subplan_for_worker (AppendState *node)
static void	mark_invalid_subplans_as_finished (AppendState *node)
AppendState *	ExecInitAppend (Append *node, EState *estate, int eflags)
void	ExecEndAppend (AppendState *node)
void	ExecReScanAppend (AppendState *node)
void	ExecAppendEstimate (AppendState *node, ParallelContext *pcxt)
void	ExecAppendInitializeDSM (AppendState *node, ParallelContext *pcxt)
void	ExecAppendReInitializeDSM (AppendState *node, ParallelContext *pcxt)
void	ExecAppendInitializeWorker (AppendState *node, ParallelWorkerContext *pwcxt)

Macro Definition Documentation

INVALID_SUBPLAN_INDEX

#define INVALID_SUBPLAN_INDEX   -1

Definition at line 80 of file nodeAppend.c.

Referenced by choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), choose_next_subplan_locally(), ExecAppend(), ExecInitAppend(), and ExecReScanAppend().

NO_MATCHING_SUBPLANS

#define NO_MATCHING_SUBPLANS   -2

Definition at line 81 of file nodeAppend.c.

Referenced by choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), choose_next_subplan_locally(), ExecAppend(), and ExecInitAppend().

Function Documentation

choose_next_subplan_for_leader()

static bool choose_next_subplan_for_leader ( AppendState *  node )

static

Definition at line 511 of file nodeAppend.c.

References AppendState::as_first_partial_plan, AppendState::as_nplans, AppendState::as_prune_state, AppendState::as_pstate, AppendState::as_valid_subplans, AppendState::as_whichplan, Assert, EState::es_direction, ExecFindMatchingSubPlans(), INVALID_SUBPLAN_INDEX, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), mark_invalid_subplans_as_finished(), NO_MATCHING_SUBPLANS, ParallelAppendState::pa_finished, ParallelAppendState::pa_lock, ParallelAppendState::pa_next_plan, AppendState::ps, ScanDirectionIsForward, and PlanState::state.

Referenced by ExecAppendInitializeDSM().

{
    ParallelAppendState *pstate = node->as_pstate;

    /* Backward scan is not supported by parallel-aware plans */
    Assert(ScanDirectionIsForward(node->ps.state->es_direction));

    /* We should never be called when there are no subplans */
    Assert(node->as_whichplan != NO_MATCHING_SUBPLANS);

    LWLockAcquire(&pstate->pa_lock, LW_EXCLUSIVE);

    if (node->as_whichplan != INVALID_SUBPLAN_INDEX)
    {
        /* Mark just-completed subplan as finished. */
        node->as_pstate->pa_finished[node->as_whichplan] = true;
    }
    else
    {
        /* Start with last subplan. */
        node->as_whichplan = node->as_nplans - 1;

        /*
         * If we've yet to determine the valid subplans for these parameters
         * then do so now.  If run-time pruning is disabled then the valid
         * subplans will always be set to all subplans.
         */
        if (node->as_valid_subplans == NULL)
        {
            node->as_valid_subplans =
                ExecFindMatchingSubPlans(node->as_prune_state);

            /*
             * Mark each invalid plan as finished to allow the loop below to
             * select the first valid subplan.
             */
            mark_invalid_subplans_as_finished(node);
        }
    }

    /* Loop until we find a subplan to execute. */
    while (pstate->pa_finished[node->as_whichplan])
    {
        if (node->as_whichplan == 0)
        {
            pstate->pa_next_plan = INVALID_SUBPLAN_INDEX;
            node->as_whichplan = INVALID_SUBPLAN_INDEX;
            LWLockRelease(&pstate->pa_lock);
            return false;
        }

        /*
         * We needn't pay attention to as_valid_subplans here as all invalid
         * plans have been marked as finished.
         */
        node->as_whichplan--;
    }

    /* If non-partial, immediately mark as finished. */
    if (node->as_whichplan < node->as_first_partial_plan)
        node->as_pstate->pa_finished[node->as_whichplan] = true;

    LWLockRelease(&pstate->pa_lock);

    return true;
}

choose_next_subplan_for_worker()

static bool choose_next_subplan_for_worker ( AppendState *  node )

static

Definition at line 592 of file nodeAppend.c.

References AppendState::as_first_partial_plan, AppendState::as_prune_state, AppendState::as_pstate, AppendState::as_valid_subplans, AppendState::as_whichplan, Assert, bms_next_member(), EState::es_direction, ExecFindMatchingSubPlans(), INVALID_SUBPLAN_INDEX, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), mark_invalid_subplans_as_finished(), NO_MATCHING_SUBPLANS, ParallelAppendState::pa_finished, ParallelAppendState::pa_lock, ParallelAppendState::pa_next_plan, AppendState::ps, ScanDirectionIsForward, and PlanState::state.

Referenced by ExecAppendInitializeWorker().

{
    ParallelAppendState *pstate = node->as_pstate;

    /* Backward scan is not supported by parallel-aware plans */
    Assert(ScanDirectionIsForward(node->ps.state->es_direction));

    /* We should never be called when there are no subplans */
    Assert(node->as_whichplan != NO_MATCHING_SUBPLANS);

    LWLockAcquire(&pstate->pa_lock, LW_EXCLUSIVE);

    /* Mark just-completed subplan as finished. */
    if (node->as_whichplan != INVALID_SUBPLAN_INDEX)
        node->as_pstate->pa_finished[node->as_whichplan] = true;

    /*
     * If we've yet to determine the valid subplans for these parameters then
     * do so now.  If run-time pruning is disabled then the valid subplans
     * will always be set to all subplans.
     */
    else if (node->as_valid_subplans == NULL)
    {
        node->as_valid_subplans =
            ExecFindMatchingSubPlans(node->as_prune_state);
        mark_invalid_subplans_as_finished(node);
    }

    /* If all the plans are already done, we have nothing to do */
    if (pstate->pa_next_plan == INVALID_SUBPLAN_INDEX)
    {
        LWLockRelease(&pstate->pa_lock);
        return false;
    }

    /* Save the plan from which we are starting the search. */
    node->as_whichplan = pstate->pa_next_plan;

    /* Loop until we find a valid subplan to execute. */
    while (pstate->pa_finished[pstate->pa_next_plan])
    {
        int         nextplan;

        nextplan = bms_next_member(node->as_valid_subplans,
                                   pstate->pa_next_plan);
        if (nextplan >= 0)
        {
            /* Advance to the next valid plan. */
            pstate->pa_next_plan = nextplan;
        }
        else if (node->as_whichplan > node->as_first_partial_plan)
        {
            /*
             * Try looping back to the first valid partial plan, if there is
             * one.  If there isn't, arrange to bail out below.
             */
            nextplan = bms_next_member(node->as_valid_subplans,
                                       node->as_first_partial_plan - 1);
            pstate->pa_next_plan =
                nextplan < 0 ? node->as_whichplan : nextplan;
        }
        else
        {
            /*
             * At last plan, and either there are no partial plans or we've
             * tried them all.  Arrange to bail out.
             */
            pstate->pa_next_plan = node->as_whichplan;
        }

        if (pstate->pa_next_plan == node->as_whichplan)
        {
            /* We've tried everything! */
            pstate->pa_next_plan = INVALID_SUBPLAN_INDEX;
            LWLockRelease(&pstate->pa_lock);
            return false;
        }
    }

    /* Pick the plan we found, and advance pa_next_plan one more time. */
    node->as_whichplan = pstate->pa_next_plan;
    pstate->pa_next_plan = bms_next_member(node->as_valid_subplans,
                                           pstate->pa_next_plan);

    /*
     * If there are no more valid plans then try setting the next plan to the
     * first valid partial plan.
     */
    if (pstate->pa_next_plan < 0)
    {
        int         nextplan = bms_next_member(node->as_valid_subplans,
                                               node->as_first_partial_plan - 1);

        if (nextplan >= 0)
            pstate->pa_next_plan = nextplan;
        else
        {
            /*
             * There are no valid partial plans, and we already chose the last
             * non-partial plan; so flag that there's nothing more for our
             * fellow workers to do.
             */
            pstate->pa_next_plan = INVALID_SUBPLAN_INDEX;
        }
    }

    /* If non-partial, immediately mark as finished. */
    if (node->as_whichplan < node->as_first_partial_plan)
        node->as_pstate->pa_finished[node->as_whichplan] = true;

    LWLockRelease(&pstate->pa_lock);

    return true;
}

choose_next_subplan_locally()

static bool choose_next_subplan_locally ( AppendState *  node )

static

Definition at line 462 of file nodeAppend.c.

References AppendState::as_prune_state, AppendState::as_valid_subplans, AppendState::as_whichplan, Assert, bms_next_member(), bms_prev_member(), EState::es_direction, ExecFindMatchingSubPlans(), INVALID_SUBPLAN_INDEX, NO_MATCHING_SUBPLANS, AppendState::ps, ScanDirectionIsForward, and PlanState::state.

Referenced by ExecInitAppend().

{
    int         whichplan = node->as_whichplan;
    int         nextplan;

    /* We should never be called when there are no subplans */
    Assert(whichplan != NO_MATCHING_SUBPLANS);

    /*
     * If first call then have the bms member function choose the first valid
     * subplan by initializing whichplan to -1.  If there happen to be no
     * valid subplans then the bms member function will handle that by
     * returning a negative number which will allow us to exit returning a
     * false value.
     */
    if (whichplan == INVALID_SUBPLAN_INDEX)
    {
        if (node->as_valid_subplans == NULL)
            node->as_valid_subplans =
                ExecFindMatchingSubPlans(node->as_prune_state);

        whichplan = -1;
    }

    /* Ensure whichplan is within the expected range */
    Assert(whichplan >= -1 && whichplan <= node->as_nplans);

    if (ScanDirectionIsForward(node->ps.state->es_direction))
        nextplan = bms_next_member(node->as_valid_subplans, whichplan);
    else
        nextplan = bms_prev_member(node->as_valid_subplans, whichplan);

    if (nextplan < 0)
        return false;

    node->as_whichplan = nextplan;

    return true;
}

ExecAppend()

static TupleTableSlot * ExecAppend ( PlanState *  pstate )

static

Definition at line 257 of file nodeAppend.c.

References AppendState::appendplans, AppendState::as_nplans, AppendState::as_whichplan, Assert, castNode, CHECK_FOR_INTERRUPTS, AppendState::choose_next_subplan, ExecClearTuple(), ExecProcNode(), INVALID_SUBPLAN_INDEX, NO_MATCHING_SUBPLANS, AppendState::ps, PlanState::ps_ResultTupleSlot, and TupIsNull.

Referenced by ExecInitAppend().

{
    AppendState *node = castNode(AppendState, pstate);

    if (node->as_whichplan < 0)
    {
        /*
         * If no subplan has been chosen, we must choose one before
         * proceeding.
         */
        if (node->as_whichplan == INVALID_SUBPLAN_INDEX &&
            !node->choose_next_subplan(node))
            return ExecClearTuple(node->ps.ps_ResultTupleSlot);

        /* Nothing to do if there are no matching subplans */
        else if (node->as_whichplan == NO_MATCHING_SUBPLANS)
            return ExecClearTuple(node->ps.ps_ResultTupleSlot);
    }

    for (;;)
    {
        PlanState  *subnode;
        TupleTableSlot *result;

        CHECK_FOR_INTERRUPTS();

        /*
         * figure out which subplan we are currently processing
         */
        Assert(node->as_whichplan >= 0 && node->as_whichplan < node->as_nplans);
        subnode = node->appendplans[node->as_whichplan];

        /*
         * get a tuple from the subplan
         */
        result = ExecProcNode(subnode);

        if (!TupIsNull(result))
        {
            /*
             * If the subplan gave us something then return it as-is. We do
             * NOT make use of the result slot that was set up in
             * ExecInitAppend; there's no need for it.
             */
            return result;
        }

        /* choose new subplan; if none, we're done */
        if (!node->choose_next_subplan(node))
            return ExecClearTuple(node->ps.ps_ResultTupleSlot);
    }
}

ExecAppendEstimate()

void ExecAppendEstimate	(	AppendState *	node,
		ParallelContext *	pcxt
	)

Definition at line 392 of file nodeAppend.c.

References add_size(), AppendState::as_nplans, ParallelContext::estimator, offsetof, ParallelAppendState::pa_finished, AppendState::pstate_len, shm_toc_estimate_chunk, and shm_toc_estimate_keys.

Referenced by ExecParallelEstimate().

{
    node->pstate_len =
        add_size(offsetof(ParallelAppendState, pa_finished),
                 sizeof(bool) * node->as_nplans);

    shm_toc_estimate_chunk(&pcxt->estimator, node->pstate_len);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

ExecAppendInitializeDSM()

void ExecAppendInitializeDSM	(	AppendState *	node,
		ParallelContext *	pcxt
	)

Definition at line 411 of file nodeAppend.c.

References AppendState::as_pstate, AppendState::choose_next_subplan, choose_next_subplan_for_leader(), LWLockInitialize(), LWTRANCHE_PARALLEL_APPEND, ParallelAppendState::pa_lock, PlanState::plan, Plan::plan_node_id, AppendState::ps, AppendState::pstate_len, shm_toc_allocate(), shm_toc_insert(), and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

{
    ParallelAppendState *pstate;

    pstate = shm_toc_allocate(pcxt->toc, node->pstate_len);
    memset(pstate, 0, node->pstate_len);
    LWLockInitialize(&pstate->pa_lock, LWTRANCHE_PARALLEL_APPEND);
    shm_toc_insert(pcxt->toc, node->ps.plan->plan_node_id, pstate);

    node->as_pstate = pstate;
    node->choose_next_subplan = choose_next_subplan_for_leader;
}

ExecAppendInitializeWorker()

void ExecAppendInitializeWorker	(	AppendState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 448 of file nodeAppend.c.

References AppendState::as_pstate, AppendState::choose_next_subplan, choose_next_subplan_for_worker(), PlanState::plan, Plan::plan_node_id, AppendState::ps, shm_toc_lookup(), and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

{
    node->as_pstate = shm_toc_lookup(pwcxt->toc, node->ps.plan->plan_node_id, false);
    node->choose_next_subplan = choose_next_subplan_for_worker;
}

ExecAppendReInitializeDSM()

void ExecAppendReInitializeDSM	(	AppendState *	node,
		ParallelContext *	pcxt
	)

Definition at line 432 of file nodeAppend.c.

References AppendState::as_nplans, AppendState::as_pstate, ParallelAppendState::pa_finished, and ParallelAppendState::pa_next_plan.

Referenced by ExecParallelReInitializeDSM().

{
    ParallelAppendState *pstate = node->as_pstate;

    pstate->pa_next_plan = 0;
    memset(pstate->pa_finished, 0, sizeof(bool) * node->as_nplans);
}

ExecEndAppend()

void ExecEndAppend

(

AppendState *

node

)

Definition at line 319 of file nodeAppend.c.

References AppendState::appendplans, AppendState::as_nplans, ExecEndNode(), and i.

Referenced by ExecEndNode().

{
    PlanState **appendplans;
    int         nplans;
    int         i;

    /*
     * get information from the node
     */
    appendplans = node->appendplans;
    nplans = node->as_nplans;

    /*
     * shut down each of the subscans
     */
    for (i = 0; i < nplans; i++)
        ExecEndNode(appendplans[i]);
}

ExecInitAppend()

AppendState* ExecInitAppend	(	Append *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 101 of file nodeAppend.c.

References Append::appendplans, AppendState::appendplans, AppendState::as_first_partial_plan, AppendState::as_nplans, AppendState::as_prune_state, AppendState::as_valid_subplans, AppendState::as_whichplan, Assert, bms_add_range(), bms_is_empty(), bms_is_member(), bms_make_singleton(), bms_num_members(), AppendState::choose_next_subplan, choose_next_subplan_locally(), EXEC_FLAG_MARK, ExecAppend(), ExecAssignExprContext(), ExecFindInitialMatchingSubPlans(), ExecInitNode(), ExecInitResultTupleSlotTL(), ExecLockNonLeafAppendTables(), PartitionPruneState::execparams, PlanState::ExecProcNode, ExecSetupPartitionPruneState(), PartitionPruneState::extparams, Append::first_partial_plan, i, INVALID_SUBPLAN_INDEX, lfirst, list_length(), makeNode, NIL, NO_MATCHING_SUBPLANS, palloc(), Append::part_prune_infos, Append::partitioned_rels, PlanState::plan, AppendState::ps, PlanState::ps_ProjInfo, and PlanState::state.

Referenced by ExecInitNode().

{
    AppendState *appendstate = makeNode(AppendState);
    PlanState **appendplanstates;
    Bitmapset  *validsubplans;
    int         nplans;
    int         firstvalid;
    int         i,
                j;
    ListCell   *lc;

    /* check for unsupported flags */
    Assert(!(eflags & EXEC_FLAG_MARK));

    /*
     * Lock the non-leaf tables in the partition tree controlled by this node.
     * It's a no-op for non-partitioned parent tables.
     */
    ExecLockNonLeafAppendTables(node->partitioned_rels, estate);

    /*
     * create new AppendState for our append node
     */
    appendstate->ps.plan = (Plan *) node;
    appendstate->ps.state = estate;
    appendstate->ps.ExecProcNode = ExecAppend;

    /* Let choose_next_subplan_* function handle setting the first subplan */
    appendstate->as_whichplan = INVALID_SUBPLAN_INDEX;

    /* If run-time partition pruning is enabled, then set that up now */
    if (node->part_prune_infos != NIL)
    {
        PartitionPruneState *prunestate;

        ExecAssignExprContext(estate, &appendstate->ps);

        prunestate = ExecSetupPartitionPruneState(&appendstate->ps,
                                                  node->part_prune_infos);

        /*
         * When there are external params matching the partition key we may be
         * able to prune away Append subplans now.
         */
        if (!bms_is_empty(prunestate->extparams))
        {
            /* Determine which subplans match the external params */
            validsubplans = ExecFindInitialMatchingSubPlans(prunestate,
                                                            list_length(node->appendplans));

            /*
             * If no subplans match the given parameters then we must handle
             * this case in a special way.  The problem here is that code in
             * explain.c requires an Append to have at least one subplan in
             * order for it to properly determine the Vars in that subplan's
             * targetlist.  We sidestep this issue by just initializing the
             * first subplan and setting as_whichplan to NO_MATCHING_SUBPLANS
             * to indicate that we don't need to scan any subnodes.
             */
            if (bms_is_empty(validsubplans))
            {
                appendstate->as_whichplan = NO_MATCHING_SUBPLANS;

                /* Mark the first as valid so that it's initialized below */
                validsubplans = bms_make_singleton(0);
            }

            nplans = bms_num_members(validsubplans);
        }
        else
        {
            /* We'll need to initialize all subplans */
            nplans = list_length(node->appendplans);
            validsubplans = bms_add_range(NULL, 0, nplans - 1);
        }

        /*
         * If there's no exec params then no further pruning can be done, we
         * can just set the valid subplans to all remaining subplans.
         */
        if (bms_is_empty(prunestate->execparams))
            appendstate->as_valid_subplans = bms_add_range(NULL, 0, nplans - 1);

        appendstate->as_prune_state = prunestate;

    }
    else
    {
        nplans = list_length(node->appendplans);

        /*
         * When run-time partition pruning is not enabled we can just mark all
         * subplans as valid, they must also all be initialized.
         */
        appendstate->as_valid_subplans = validsubplans =
            bms_add_range(NULL, 0, nplans - 1);
        appendstate->as_prune_state = NULL;
    }

    /*
     * Initialize result tuple type and slot.
     */
    ExecInitResultTupleSlotTL(estate, &appendstate->ps);

    appendplanstates = (PlanState **) palloc(nplans *
                                             sizeof(PlanState *));

    /*
     * call ExecInitNode on each of the valid plans to be executed and save
     * the results into the appendplanstates array.
     *
     * While at it, find out the first valid partial plan.
     */
    j = i = 0;
    firstvalid = nplans;
    foreach(lc, node->appendplans)
    {
        if (bms_is_member(i, validsubplans))
        {
            Plan       *initNode = (Plan *) lfirst(lc);

            /*
             * Record the lowest appendplans index which is a valid partial
             * plan.
             */
            if (i >= node->first_partial_plan && j < firstvalid)
                firstvalid = j;

            appendplanstates[j++] = ExecInitNode(initNode, estate, eflags);
        }
        i++;
    }

    appendstate->as_first_partial_plan = firstvalid;
    appendstate->appendplans = appendplanstates;
    appendstate->as_nplans = nplans;

    /*
     * Miscellaneous initialization
     */

    appendstate->ps.ps_ProjInfo = NULL;

    /* For parallel query, this will be overridden later. */
    appendstate->choose_next_subplan = choose_next_subplan_locally;

    return appendstate;
}

ExecReScanAppend()

void ExecReScanAppend

(

AppendState *

node

)

Definition at line 339 of file nodeAppend.c.

References AppendState::appendplans, AppendState::as_nplans, AppendState::as_prune_state, AppendState::as_valid_subplans, AppendState::as_whichplan, bms_free(), bms_overlap(), PlanState::chgParam, PartitionPruneState::execparams, ExecReScan(), i, INVALID_SUBPLAN_INDEX, AppendState::ps, and UpdateChangedParamSet().

Referenced by ExecReScan().

{
    int         i;

    /*
     * If any of the parameters being used for partition pruning have changed,
     * then we'd better unset the valid subplans so that they are reselected
     * for the new parameter values.
     */
    if (node->as_prune_state &&
        bms_overlap(node->ps.chgParam,
                    node->as_prune_state->execparams))
    {
        bms_free(node->as_valid_subplans);
        node->as_valid_subplans = NULL;
    }

    for (i = 0; i < node->as_nplans; i++)
    {
        PlanState  *subnode = node->appendplans[i];

        /*
         * ExecReScan doesn't know about my subplans, so I have to do
         * changed-parameter signaling myself.
         */
        if (node->ps.chgParam != NULL)
            UpdateChangedParamSet(subnode, node->ps.chgParam);

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

    /* Let choose_next_subplan_* function handle setting the first subplan */
    node->as_whichplan = INVALID_SUBPLAN_INDEX;
}

mark_invalid_subplans_as_finished()

static void mark_invalid_subplans_as_finished ( AppendState *  node )

static

Definition at line 716 of file nodeAppend.c.

References AppendState::as_nplans, AppendState::as_prune_state, AppendState::as_pstate, AppendState::as_valid_subplans, Assert, bms_is_member(), bms_num_members(), i, and ParallelAppendState::pa_finished.

Referenced by choose_next_subplan_for_leader(), and choose_next_subplan_for_worker().

{
    int         i;

    /* Only valid to call this while in parallel Append mode */
    Assert(node->as_pstate);

    /* Shouldn't have been called when run-time pruning is not enabled */
    Assert(node->as_prune_state);

    /* Nothing to do if all plans are valid */
    if (bms_num_members(node->as_valid_subplans) == node->as_nplans)
        return;

    /* Mark all non-valid plans as finished */
    for (i = 0; i < node->as_nplans; i++)
    {
        if (!bms_is_member(i, node->as_valid_subplans))
            node->as_pstate->pa_finished[i] = true;
    }
}