nodeGatherMerge.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeGatherMerge.h:

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

Go to the source code of this file.

Functions
GatherMergeState *	ExecInitGatherMerge (GatherMerge *node, EState *estate, int eflags)
void	ExecEndGatherMerge (GatherMergeState *node)
void	ExecReScanGatherMerge (GatherMergeState *node)
void	ExecShutdownGatherMerge (GatherMergeState *node)

Function Documentation

ExecEndGatherMerge()

void ExecEndGatherMerge

(

GatherMergeState *

node

)

Definition at line 284 of file nodeGatherMerge.c.

{
    ExecEndNode(outerPlanState(node));  /* let children clean up first */
    ExecShutdownGatherMerge(node);
}

References ExecEndNode(), ExecShutdownGatherMerge(), and outerPlanState.

Referenced by ExecEndNode().

ExecInitGatherMerge()

GatherMergeState* ExecInitGatherMerge	(	GatherMerge *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 67 of file nodeGatherMerge.c.

{
    GatherMergeState *gm_state;
    Plan       *outerNode;
    TupleDesc   tupDesc;
 
    /* Gather merge node doesn't have innerPlan node. */
    Assert(innerPlan(node) == NULL);
 
    /*
     * create state structure
     */
    gm_state = makeNode(GatherMergeState);
    gm_state->ps.plan = (Plan *) node;
    gm_state->ps.state = estate;
    gm_state->ps.ExecProcNode = ExecGatherMerge;
 
    gm_state->initialized = false;
    gm_state->gm_initialized = false;
    gm_state->tuples_needed = -1;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &gm_state->ps);
 
    /*
     * GatherMerge doesn't support checking a qual (it's always more efficient
     * to do it in the child node).
     */
    Assert(!node->plan.qual);
 
    /*
     * now initialize outer plan
     */
    outerNode = outerPlan(node);
    outerPlanState(gm_state) = ExecInitNode(outerNode, estate, eflags);
 
    /*
     * Leader may access ExecProcNode result directly (if
     * need_to_scan_locally), or from workers via tuple queue.  So we can't
     * trivially rely on the slot type being fixed for expressions evaluated
     * within this node.
     */
    gm_state->ps.outeropsset = true;
    gm_state->ps.outeropsfixed = false;
 
    /*
     * Store the tuple descriptor into gather merge state, so we can use it
     * while initializing the gather merge slots.
     */
    tupDesc = ExecGetResultType(outerPlanState(gm_state));
    gm_state->tupDesc = tupDesc;
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&gm_state->ps);
    ExecConditionalAssignProjectionInfo(&gm_state->ps, tupDesc, OUTER_VAR);
 
    /*
     * Without projections result slot type is not trivially known, see
     * comment above.
     */
    if (gm_state->ps.ps_ProjInfo == NULL)
    {
        gm_state->ps.resultopsset = true;
        gm_state->ps.resultopsfixed = false;
    }
 
    /*
     * initialize sort-key information
     */
    if (node->numCols)
    {
        int         i;
 
        gm_state->gm_nkeys = node->numCols;
        gm_state->gm_sortkeys =
            palloc0(sizeof(SortSupportData) * node->numCols);
 
        for (i = 0; i < node->numCols; i++)
        {
            SortSupport sortKey = gm_state->gm_sortkeys + i;
 
            sortKey->ssup_cxt = CurrentMemoryContext;
            sortKey->ssup_collation = node->collations[i];
            sortKey->ssup_nulls_first = node->nullsFirst[i];
            sortKey->ssup_attno = node->sortColIdx[i];
 
            /*
             * We don't perform abbreviated key conversion here, for the same
             * reasons that it isn't used in MergeAppend
             */
            sortKey->abbreviate = false;
 
            PrepareSortSupportFromOrderingOp(node->sortOperators[i], sortKey);
        }
    }
 
    /* Now allocate the workspace for gather merge */
    gather_merge_setup(gm_state);
 
    return gm_state;
}

References SortSupportData::abbreviate, Assert, CurrentMemoryContext, ExecAssignExprContext(), ExecConditionalAssignProjectionInfo(), ExecGatherMerge(), ExecGetResultType(), ExecInitNode(), ExecInitResultTypeTL(), PlanState::ExecProcNode, gather_merge_setup(), GatherMergeState::gm_initialized, GatherMergeState::gm_nkeys, GatherMergeState::gm_sortkeys, i, GatherMergeState::initialized, innerPlan, makeNode, GatherMerge::numCols, OUTER_VAR, PlanState::outeropsfixed, PlanState::outeropsset, outerPlan, outerPlanState, palloc0(), PlanState::plan, GatherMerge::plan, PrepareSortSupportFromOrderingOp(), GatherMergeState::ps, PlanState::ps_ProjInfo, Plan::qual, PlanState::resultopsfixed, PlanState::resultopsset, SortSupportData::ssup_attno, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, SortSupportData::ssup_nulls_first, PlanState::state, GatherMergeState::tupDesc, and GatherMergeState::tuples_needed.

Referenced by ExecInitNode().

ExecReScanGatherMerge()

void ExecReScanGatherMerge

(

GatherMergeState *

node

)

Definition at line 334 of file nodeGatherMerge.c.

{
    GatherMerge *gm = (GatherMerge *) node->ps.plan;
    PlanState  *outerPlan = outerPlanState(node);
 
    /* Make sure any existing workers are gracefully shut down */
    ExecShutdownGatherMergeWorkers(node);
 
    /* Free any unused tuples, so we don't leak memory across rescans */
    gather_merge_clear_tuples(node);
 
    /* Mark node so that shared state will be rebuilt at next call */
    node->initialized = false;
    node->gm_initialized = false;
 
    /*
     * Set child node's chgParam to tell it that the next scan might deliver a
     * different set of rows within the leader process.  (The overall rowset
     * shouldn't change, but the leader process's subset might; hence nodes
     * between here and the parallel table scan node mustn't optimize on the
     * assumption of an unchanging rowset.)
     */
    if (gm->rescan_param >= 0)
        outerPlan->chgParam = bms_add_member(outerPlan->chgParam,
                                             gm->rescan_param);
 
    /*
     * If chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.  Note: because this does nothing if we have a
     * rescan_param, it's currently guaranteed that parallel-aware child nodes
     * will not see a ReScan call until after they get a ReInitializeDSM call.
     * That ordering might not be something to rely on, though.  A good rule
     * of thumb is that ReInitializeDSM should reset only shared state, ReScan
     * should reset only local state, and anything that depends on both of
     * those steps being finished must wait until the first ExecProcNode call.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
}

References bms_add_member(), ExecReScan(), ExecShutdownGatherMergeWorkers(), gather_merge_clear_tuples(), GatherMergeState::gm_initialized, GatherMergeState::initialized, outerPlan, outerPlanState, PlanState::plan, GatherMergeState::ps, and GatherMerge::rescan_param.

Referenced by ExecReScan().

ExecShutdownGatherMerge()

void ExecShutdownGatherMerge

(

GatherMergeState *

node

)

Definition at line 297 of file nodeGatherMerge.c.

{
    ExecShutdownGatherMergeWorkers(node);
 
    /* Now destroy the parallel context. */
    if (node->pei != NULL)
    {
        ExecParallelCleanup(node->pei);
        node->pei = NULL;
    }
}

References ExecParallelCleanup(), ExecShutdownGatherMergeWorkers(), and GatherMergeState::pei.

Referenced by ExecEndGatherMerge(), and ExecShutdownNode_walker().