nodeAppend.h File Reference

#include "access/parallel.h"
#include "nodes/execnodes.h"

Include dependency graph for nodeAppend.h:

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

Go to the source code of this file.

Functions
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)
void	ExecAsyncAppendResponse (AsyncRequest *areq)

Function Documentation

ExecAppendEstimate()

void ExecAppendEstimate	(	AppendState *	node,
		ParallelContext *	pcxt
	)

Definition at line 495 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 514 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 551 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 535 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);
}

ExecAsyncAppendResponse()

void ExecAsyncAppendResponse

(

AsyncRequest *

areq

)

Definition at line 1108 of file nodeAppend.c.

References AppendState::as_asyncresults, AppendState::as_nasyncplans, AppendState::as_nasyncremain, AppendState::as_nasyncresults, AppendState::as_needrequest, Assert, bms_add_member(), AsyncRequest::callback_pending, IsA, AsyncRequest::request_complete, AsyncRequest::request_index, AsyncRequest::requestor, AsyncRequest::result, and TupIsNull.

Referenced by ExecAsyncResponse().

{
    AppendState *node = (AppendState *) areq->requestor;
    TupleTableSlot *slot = areq->result;

    /* The result should be a TupleTableSlot or NULL. */
    Assert(slot == NULL || IsA(slot, TupleTableSlot));

    /* Nothing to do if the request is pending. */
    if (!areq->request_complete)
    {
        /* The request would have been pending for a callback. */
        Assert(areq->callback_pending);
        return;
    }

    /* If the result is NULL or an empty slot, there's nothing more to do. */
    if (TupIsNull(slot))
    {
        /* The ending subplan wouldn't have been pending for a callback. */
        Assert(!areq->callback_pending);
        --node->as_nasyncremain;
        return;
    }

    /* Save result so we can return it. */
    Assert(node->as_nasyncresults < node->as_nasyncplans);
    node->as_asyncresults[node->as_nasyncresults++] = slot;

    /*
     * Mark the subplan that returned a result as ready for a new request.  We
     * don't launch another one here immediately because it might complete.
     */
    node->as_needrequest = bms_add_member(node->as_needrequest,
                                          areq->request_index);
}

ExecEndAppend()

void ExecEndAppend

(

AppendState *

node

)

Definition at line 395 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 109 of file nodeAppend.c.

References Append::appendplans, AppendState::appendplans, AppendState::as_asyncplans, AppendState::as_asyncrequests, AppendState::as_asyncresults, AppendState::as_begun, AppendState::as_eventset, AppendState::as_first_partial_plan, AppendState::as_nasyncplans, AppendState::as_nasyncremain, AppendState::as_nasyncresults, AppendState::as_needrequest, AppendState::as_nplans, AppendState::as_prune_state, AppendState::as_syncdone, AppendState::as_valid_asyncplans, AppendState::as_valid_subplans, AppendState::as_whichplan, Assert, Plan::async_capable, bms_add_member(), bms_add_range(), bms_next_member(), bms_num_members(), AsyncRequest::callback_pending, AppendState::choose_next_subplan, choose_next_subplan_locally(), classify_matching_subplans(), PartitionPruneState::do_exec_prune, PartitionPruneState::do_initial_prune, EState::es_epq_active, EXEC_FLAG_MARK, ExecAppend(), ExecAssignExprContext(), ExecCreatePartitionPruneState(), ExecFindInitialMatchingSubPlans(), ExecInitNode(), ExecInitResultTupleSlotTL(), PlanState::ExecProcNode, Append::first_partial_plan, i, INVALID_SUBPLAN_INDEX, list_length(), list_nth(), makeNode, palloc(), palloc0(), Append::part_prune_info, PlanState::plan, AppendState::ps, PlanState::ps_ProjInfo, AsyncRequest::request_complete, AsyncRequest::request_index, AsyncRequest::requestee, AsyncRequest::requestor, AsyncRequest::result, PlanState::resultopsfixed, PlanState::resultopsset, PlanState::state, and TTSOpsVirtual.

Referenced by ExecInitNode().

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

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

    /*
     * 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;
    appendstate->as_syncdone = false;
    appendstate->as_begun = false;

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

        /* We may need an expression context to evaluate partition exprs */
        ExecAssignExprContext(estate, &appendstate->ps);

        /* Create the working data structure for pruning. */
        prunestate = ExecCreatePartitionPruneState(&appendstate->ps,
                                                   node->part_prune_info);
        appendstate->as_prune_state = prunestate;

        /* Perform an initial partition prune, if required. */
        if (prunestate->do_initial_prune)
        {
            /* Determine which subplans survive initial pruning */
            validsubplans = ExecFindInitialMatchingSubPlans(prunestate,
                                                            list_length(node->appendplans));

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

        /*
         * When no run-time pruning is required and there's at least one
         * subplan, we can fill as_valid_subplans immediately, preventing
         * later calls to ExecFindMatchingSubPlans.
         */
        if (!prunestate->do_exec_prune && nplans > 0)
            appendstate->as_valid_subplans = bms_add_range(NULL, 0, nplans - 1);
    }
    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.
         */
        Assert(nplans > 0);
        appendstate->as_valid_subplans = validsubplans =
            bms_add_range(NULL, 0, nplans - 1);
        appendstate->as_prune_state = NULL;
    }

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

    /* node returns slots from each of its subnodes, therefore not fixed */
    appendstate->ps.resultopsset = true;
    appendstate->ps.resultopsfixed = false;

    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 = 0;
    asyncplans = NULL;
    nasyncplans = 0;
    firstvalid = nplans;
    i = -1;
    while ((i = bms_next_member(validsubplans, i)) >= 0)
    {
        Plan       *initNode = (Plan *) list_nth(node->appendplans, i);

        /*
         * Record async subplans.  When executing EvalPlanQual, we treat them
         * as sync ones; don't do this when initializing an EvalPlanQual plan
         * tree.
         */
        if (initNode->async_capable && estate->es_epq_active == NULL)
        {
            asyncplans = bms_add_member(asyncplans, j);
            nasyncplans++;
        }

        /*
         * 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);
    }

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

    /* Initialize async state */
    appendstate->as_asyncplans = asyncplans;
    appendstate->as_nasyncplans = nasyncplans;
    appendstate->as_asyncrequests = NULL;
    appendstate->as_asyncresults = NULL;
    appendstate->as_nasyncresults = 0;
    appendstate->as_nasyncremain = 0;
    appendstate->as_needrequest = NULL;
    appendstate->as_eventset = NULL;
    appendstate->as_valid_asyncplans = NULL;

    if (nasyncplans > 0)
    {
        appendstate->as_asyncrequests = (AsyncRequest **)
            palloc0(nplans * sizeof(AsyncRequest *));

        i = -1;
        while ((i = bms_next_member(asyncplans, i)) >= 0)
        {
            AsyncRequest *areq;

            areq = palloc(sizeof(AsyncRequest));
            areq->requestor = (PlanState *) appendstate;
            areq->requestee = appendplanstates[i];
            areq->request_index = i;
            areq->callback_pending = false;
            areq->request_complete = false;
            areq->result = NULL;

            appendstate->as_asyncrequests[i] = areq;
        }

        appendstate->as_asyncresults = (TupleTableSlot **)
            palloc0(nasyncplans * sizeof(TupleTableSlot *));

        if (appendstate->as_valid_subplans != NULL)
            classify_matching_subplans(appendstate);
    }

    /*
     * 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 415 of file nodeAppend.c.

References AppendState::appendplans, AppendState::as_asyncplans, AppendState::as_asyncrequests, AppendState::as_begun, AppendState::as_nasyncplans, AppendState::as_nasyncremain, AppendState::as_nasyncresults, AppendState::as_needrequest, AppendState::as_nplans, AppendState::as_prune_state, AppendState::as_syncdone, AppendState::as_valid_asyncplans, AppendState::as_valid_subplans, AppendState::as_whichplan, bms_free(), bms_next_member(), bms_overlap(), AsyncRequest::callback_pending, PlanState::chgParam, PartitionPruneState::execparamids, ExecReScan(), i, INVALID_SUBPLAN_INDEX, AppendState::ps, AsyncRequest::request_complete, AsyncRequest::result, and UpdateChangedParamSet().

Referenced by ExecReScan().

{
    int         nasyncplans = node->as_nasyncplans;
    int         i;

    /*
     * If any PARAM_EXEC Params used in pruning expressions 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->execparamids))
    {
        bms_free(node->as_valid_subplans);
        node->as_valid_subplans = NULL;
        if (nasyncplans > 0)
        {
            bms_free(node->as_valid_asyncplans);
            node->as_valid_asyncplans = 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 or by first ExecAsyncRequest.
         */
        if (subnode->chgParam == NULL)
            ExecReScan(subnode);
    }

    /* Reset async state */
    if (nasyncplans > 0)
    {
        i = -1;
        while ((i = bms_next_member(node->as_asyncplans, i)) >= 0)
        {
            AsyncRequest *areq = node->as_asyncrequests[i];

            areq->callback_pending = false;
            areq->request_complete = false;
            areq->result = NULL;
        }

        node->as_nasyncresults = 0;
        node->as_nasyncremain = 0;
        bms_free(node->as_needrequest);
        node->as_needrequest = NULL;
    }

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