nodeSort.h File Reference

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

Include dependency graph for nodeSort.h:

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

Go to the source code of this file.

Functions
SortState *	ExecInitSort (Sort *node, EState *estate, int eflags)
void	ExecEndSort (SortState *node)
void	ExecSortMarkPos (SortState *node)
void	ExecSortRestrPos (SortState *node)
void	ExecReScanSort (SortState *node)
void	ExecSortEstimate (SortState *node, ParallelContext *pcxt)
void	ExecSortInitializeDSM (SortState *node, ParallelContext *pcxt)
void	ExecSortInitializeWorker (SortState *node, ParallelWorkerContext *pwcxt)
void	ExecSortRetrieveInstrumentation (SortState *node)

Function Documentation

ExecEndSort()

void ExecEndSort

(

SortState *

node

)

Definition at line 301 of file nodeSort.c.

{
    SO1_printf("ExecEndSort: %s\n",
               "shutting down sort node");
 
    /*
     * clean out the tuple table
     */
    ExecClearTuple(node->ss.ss_ScanTupleSlot);
    /* must drop pointer to sort result tuple */
    ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
    /*
     * Release tuplesort resources
     */
    if (node->tuplesortstate != NULL)
        tuplesort_end((Tuplesortstate *) node->tuplesortstate);
    node->tuplesortstate = NULL;
 
    /*
     * shut down the subplan
     */
    ExecEndNode(outerPlanState(node));
 
    SO1_printf("ExecEndSort: %s\n",
               "sort node shutdown");
}

References ExecClearTuple(), ExecEndNode(), outerPlanState, ScanState::ps, PlanState::ps_ResultTupleSlot, SO1_printf, SortState::ss, ScanState::ss_ScanTupleSlot, tuplesort_end(), and SortState::tuplesortstate.

Referenced by ExecEndNode().

ExecInitSort()

SortState* ExecInitSort	(	Sort *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 221 of file nodeSort.c.

{
    SortState  *sortstate;
    TupleDesc   outerTupDesc;
 
    SO1_printf("ExecInitSort: %s\n",
               "initializing sort node");
 
    /*
     * create state structure
     */
    sortstate = makeNode(SortState);
    sortstate->ss.ps.plan = (Plan *) node;
    sortstate->ss.ps.state = estate;
    sortstate->ss.ps.ExecProcNode = ExecSort;
 
    /*
     * We must have random access to the sort output to do backward scan or
     * mark/restore.  We also prefer to materialize the sort output if we
     * might be called on to rewind and replay it many times.
     */
    sortstate->randomAccess = (eflags & (EXEC_FLAG_REWIND |
                                         EXEC_FLAG_BACKWARD |
                                         EXEC_FLAG_MARK)) != 0;
 
    sortstate->bounded = false;
    sortstate->sort_Done = false;
    sortstate->tuplesortstate = NULL;
 
    /*
     * Miscellaneous initialization
     *
     * Sort nodes don't initialize their ExprContexts because they never call
     * ExecQual or ExecProject.
     */
 
    /*
     * initialize child nodes
     *
     * We shield the child node from the need to support REWIND, BACKWARD, or
     * MARK/RESTORE.
     */
    eflags &= ~(EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);
 
    outerPlanState(sortstate) = ExecInitNode(outerPlan(node), estate, eflags);
 
    /*
     * Initialize scan slot and type.
     */
    ExecCreateScanSlotFromOuterPlan(estate, &sortstate->ss, &TTSOpsVirtual);
 
    /*
     * Initialize return slot and type. No need to initialize projection info
     * because this node doesn't do projections.
     */
    ExecInitResultTupleSlotTL(&sortstate->ss.ps, &TTSOpsMinimalTuple);
    sortstate->ss.ps.ps_ProjInfo = NULL;
 
    outerTupDesc = ExecGetResultType(outerPlanState(sortstate));
 
    /*
     * We perform a Datum sort when we're sorting just a single column,
     * otherwise we perform a tuple sort.
     */
    if (outerTupDesc->natts == 1)
        sortstate->datumSort = true;
    else
        sortstate->datumSort = false;
 
    SO1_printf("ExecInitSort: %s\n",
               "sort node initialized");
 
    return sortstate;
}

References SortState::bounded, SortState::datumSort, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, EXEC_FLAG_REWIND, ExecCreateScanSlotFromOuterPlan(), ExecGetResultType(), ExecInitNode(), ExecInitResultTupleSlotTL(), PlanState::ExecProcNode, ExecSort(), makeNode, TupleDescData::natts, outerPlan, outerPlanState, PlanState::plan, ScanState::ps, PlanState::ps_ProjInfo, SortState::randomAccess, SO1_printf, SortState::sort_Done, SortState::ss, PlanState::state, TTSOpsMinimalTuple, TTSOpsVirtual, and SortState::tuplesortstate.

Referenced by ExecInitNode().

ExecReScanSort()

void ExecReScanSort

(

SortState *

node

)

Definition at line 369 of file nodeSort.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    /*
     * If we haven't sorted yet, just return. If outerplan's chgParam is not
     * NULL then it will be re-scanned by ExecProcNode, else no reason to
     * re-scan it at all.
     */
    if (!node->sort_Done)
        return;
 
    /* must drop pointer to sort result tuple */
    ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
    /*
     * If subnode is to be rescanned then we forget previous sort results; we
     * have to re-read the subplan and re-sort.  Also must re-sort if the
     * bounded-sort parameters changed or we didn't select randomAccess.
     *
     * Otherwise we can just rewind and rescan the sorted output.
     */
    if (outerPlan->chgParam != NULL ||
        node->bounded != node->bounded_Done ||
        node->bound != node->bound_Done ||
        !node->randomAccess)
    {
        node->sort_Done = false;
        tuplesort_end((Tuplesortstate *) node->tuplesortstate);
        node->tuplesortstate = NULL;
 
        /*
         * if chgParam of subnode is not null then plan will be re-scanned by
         * first ExecProcNode.
         */
        if (outerPlan->chgParam == NULL)
            ExecReScan(outerPlan);
    }
    else
        tuplesort_rescan((Tuplesortstate *) node->tuplesortstate);
}

References SortState::bound, SortState::bound_Done, SortState::bounded, SortState::bounded_Done, ExecClearTuple(), ExecReScan(), outerPlan, outerPlanState, ScanState::ps, PlanState::ps_ResultTupleSlot, SortState::randomAccess, SortState::sort_Done, SortState::ss, tuplesort_end(), tuplesort_rescan(), and SortState::tuplesortstate.

Referenced by ExecReScan().

ExecSortEstimate()

void ExecSortEstimate	(	SortState *	node,
		ParallelContext *	pcxt
	)

Definition at line 423 of file nodeSort.c.

{
    Size        size;
 
    /* don't need this if not instrumenting or no workers */
    if (!node->ss.ps.instrument || pcxt->nworkers == 0)
        return;
 
    size = mul_size(pcxt->nworkers, sizeof(TuplesortInstrumentation));
    size = add_size(size, offsetof(SharedSortInfo, sinstrument));
    shm_toc_estimate_chunk(&pcxt->estimator, size);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References add_size(), ParallelContext::estimator, PlanState::instrument, mul_size(), ParallelContext::nworkers, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, and SortState::ss.

Referenced by ExecParallelEstimate().

ExecSortInitializeDSM()

void ExecSortInitializeDSM	(	SortState *	node,
		ParallelContext *	pcxt
	)

Definition at line 444 of file nodeSort.c.

{
    Size        size;
 
    /* don't need this if not instrumenting or no workers */
    if (!node->ss.ps.instrument || pcxt->nworkers == 0)
        return;
 
    size = offsetof(SharedSortInfo, sinstrument)
        + pcxt->nworkers * sizeof(TuplesortInstrumentation);
    node->shared_info = shm_toc_allocate(pcxt->toc, size);
    /* ensure any unfilled slots will contain zeroes */
    memset(node->shared_info, 0, size);
    node->shared_info->num_workers = pcxt->nworkers;
    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id,
                   node->shared_info);
}

References PlanState::instrument, SharedSortInfo::num_workers, ParallelContext::nworkers, PlanState::plan, Plan::plan_node_id, ScanState::ps, SortState::shared_info, shm_toc_allocate(), shm_toc_insert(), SortState::ss, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

ExecSortInitializeWorker()

void ExecSortInitializeWorker	(	SortState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 469 of file nodeSort.c.

{
    node->shared_info =
        shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, true);
    node->am_worker = true;
}

References SortState::am_worker, PlanState::plan, Plan::plan_node_id, ScanState::ps, SortState::shared_info, shm_toc_lookup(), SortState::ss, and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

ExecSortMarkPos()

void ExecSortMarkPos

(

SortState *

node

)

Definition at line 336 of file nodeSort.c.

{
    /*
     * if we haven't sorted yet, just return
     */
    if (!node->sort_Done)
        return;
 
    tuplesort_markpos((Tuplesortstate *) node->tuplesortstate);
}

References SortState::sort_Done, tuplesort_markpos(), and SortState::tuplesortstate.

Referenced by ExecMarkPos().

ExecSortRestrPos()

void ExecSortRestrPos

(

SortState *

node

)

Definition at line 354 of file nodeSort.c.

{
    /*
     * if we haven't sorted yet, just return.
     */
    if (!node->sort_Done)
        return;
 
    /*
     * restore the scan to the previously marked position
     */
    tuplesort_restorepos((Tuplesortstate *) node->tuplesortstate);
}

References SortState::sort_Done, tuplesort_restorepos(), and SortState::tuplesortstate.

Referenced by ExecRestrPos().

ExecSortRetrieveInstrumentation()

void ExecSortRetrieveInstrumentation

(

SortState *

node

)

Definition at line 483 of file nodeSort.c.

{
    Size        size;
    SharedSortInfo *si;
 
    if (node->shared_info == NULL)
        return;
 
    size = offsetof(SharedSortInfo, sinstrument)
        + node->shared_info->num_workers * sizeof(TuplesortInstrumentation);
    si = palloc(size);
    memcpy(si, node->shared_info, size);
    node->shared_info = si;
}

References SharedSortInfo::num_workers, palloc(), and SortState::shared_info.

Referenced by ExecParallelRetrieveInstrumentation().