nodeSetOp.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeSetOp.h:

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

Go to the source code of this file.

Functions
SetOpState *	ExecInitSetOp (SetOp *node, EState *estate, int eflags)
void	ExecEndSetOp (SetOpState *node)
void	ExecReScanSetOp (SetOpState *node)
Size	EstimateSetOpHashTableSpace (double nentries, Size tupleWidth)

Function Documentation

EstimateSetOpHashTableSpace()

Size EstimateSetOpHashTableSpace ( double  nentries, Size  tupleWidth  )

extern

Definition at line 115 of file nodeSetOp.c.

{
    return EstimateTupleHashTableSpace(nentries,
                                       tupleWidth,
                                       sizeof(SetOpStatePerGroupData));
}

References EstimateTupleHashTableSpace(), and fb().

Referenced by create_setop_path().

ExecEndSetOp()

void ExecEndSetOp ( SetOpState *  node )

extern

Definition at line 691 of file nodeSetOp.c.

{
    /* free subsidiary stuff including hashtable data */
    if (node->tuplesContext)
        MemoryContextDelete(node->tuplesContext);
 
    ExecEndNode(outerPlanState(node));
    ExecEndNode(innerPlanState(node));
}

References ExecEndNode(), innerPlanState, MemoryContextDelete(), outerPlanState, and SetOpState::tuplesContext.

Referenced by ExecEndNode().

ExecInitSetOp()

SetOpState * ExecInitSetOp ( SetOp *  node, EState *  estate, int  eflags  )

extern

Definition at line 572 of file nodeSetOp.c.

{
    SetOpState *setopstate;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    /*
     * create state structure
     */
    setopstate = makeNode(SetOpState);
    setopstate->ps.plan = (Plan *) node;
    setopstate->ps.state = estate;
    setopstate->ps.ExecProcNode = ExecSetOp;
 
    setopstate->setop_done = false;
    setopstate->numOutput = 0;
    setopstate->numCols = node->numCols;
    setopstate->need_init = true;
 
    /*
     * create expression context
     */
    ExecAssignExprContext(estate, &setopstate->ps);
 
    /*
     * If hashing, we also need a longer-lived context to store the hash
     * table.  The table can't just be kept in the per-query context because
     * we want to be able to throw it away in ExecReScanSetOp.  We can use a
     * BumpContext to save storage, because we will have no need to delete
     * individual table entries.
     */
    if (node->strategy == SETOP_HASHED)
        setopstate->tuplesContext =
            BumpContextCreate(CurrentMemoryContext,
                              "SetOp hashed tuples",
                              ALLOCSET_DEFAULT_SIZES);
 
    /*
     * initialize child nodes
     *
     * If we are hashing then the child plans do not need to handle REWIND
     * efficiently; see ExecReScanSetOp.
     */
    if (node->strategy == SETOP_HASHED)
        eflags &= ~EXEC_FLAG_REWIND;
    outerPlanState(setopstate) = ExecInitNode(outerPlan(node), estate, eflags);
    innerPlanState(setopstate) = ExecInitNode(innerPlan(node), estate, eflags);
 
    /*
     * Initialize locally-allocated slots.  In hashed mode, we just need a
     * result slot.  In sorted mode, we need one first-tuple-of-group slot for
     * each input; we use the result slot for the left input's slot and create
     * another for the right input.  (Note: the nextTupleSlot slots are not
     * ours, but just point to the last slot returned by the input plan node.)
     */
    ExecInitResultTupleSlotTL(&setopstate->ps, &TTSOpsMinimalTuple);
    if (node->strategy != SETOP_HASHED)
    {
        setopstate->leftInput.firstTupleSlot =
            setopstate->ps.ps_ResultTupleSlot;
        setopstate->rightInput.firstTupleSlot =
            ExecInitExtraTupleSlot(estate,
                                   setopstate->ps.ps_ResultTupleDesc,
                                   &TTSOpsMinimalTuple);
    }
 
    /* Setop nodes do no projections. */
    setopstate->ps.ps_ProjInfo = NULL;
 
    /*
     * Precompute fmgr lookup data for inner loop.  We need equality and
     * hashing functions to do it by hashing, while for sorting we need
     * SortSupport data.
     */
    if (node->strategy == SETOP_HASHED)
        execTuplesHashPrepare(node->numCols,
                              node->cmpOperators,
                              &setopstate->eqfuncoids,
                              &setopstate->hashfunctions);
    else
    {
        int         nkeys = node->numCols;
 
        setopstate->sortKeys = (SortSupport)
            palloc0(nkeys * sizeof(SortSupportData));
        for (int i = 0; i < nkeys; i++)
        {
            SortSupport sortKey = setopstate->sortKeys + i;
 
            sortKey->ssup_cxt = CurrentMemoryContext;
            sortKey->ssup_collation = node->cmpCollations[i];
            sortKey->ssup_nulls_first = node->cmpNullsFirst[i];
            sortKey->ssup_attno = node->cmpColIdx[i];
            /* abbreviated key conversion is not useful here */
            sortKey->abbreviate = false;
 
            PrepareSortSupportFromOrderingOp(node->cmpOperators[i], sortKey);
        }
    }
 
    /* Create a hash table if needed */
    if (node->strategy == SETOP_HASHED)
    {
        build_hash_table(setopstate);
        setopstate->table_filled = false;
    }
 
    return setopstate;
}

References ALLOCSET_DEFAULT_SIZES, Assert, build_hash_table(), BumpContextCreate(), CurrentMemoryContext, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecInitExtraTupleSlot(), ExecInitNode(), ExecInitResultTupleSlotTL(), ExecSetOp(), execTuplesHashPrepare(), fb(), i, innerPlan, innerPlanState, makeNode, SetOp::numCols, outerPlan, outerPlanState, palloc0(), PrepareSortSupportFromOrderingOp(), SETOP_HASHED, SortSupportData::ssup_cxt, SetOp::strategy, and TTSOpsMinimalTuple.

Referenced by ExecInitNode().

ExecReScanSetOp()

void ExecReScanSetOp ( SetOpState *  node )

extern

Definition at line 703 of file nodeSetOp.c.

{
    PlanState  *outerPlan = outerPlanState(node);
    PlanState  *innerPlan = innerPlanState(node);
 
    ExecClearTuple(node->ps.ps_ResultTupleSlot);
    node->setop_done = false;
    node->numOutput = 0;
 
    if (((SetOp *) node->ps.plan)->strategy == SETOP_HASHED)
    {
        /*
         * In the hashed case, if we haven't yet built the hash table then we
         * can just return; nothing done yet, so nothing to undo. If subnode's
         * chgParam is not NULL then it will be re-scanned by ExecProcNode,
         * else no reason to re-scan it at all.
         */
        if (!node->table_filled)
            return;
 
        /*
         * If we do have the hash table and the subplans do not have any
         * parameter changes, then we can just rescan the existing hash table;
         * no need to build it again.
         */
        if (outerPlan->chgParam == NULL && innerPlan->chgParam == NULL)
        {
            ResetTupleHashIterator(node->hashtable, &node->hashiter);
            return;
        }
 
        /* Else, we must rebuild the hashtable */
        ResetTupleHashTable(node->hashtable);
        node->table_filled = false;
    }
    else
    {
        /* Need to re-read first input from each side */
        node->need_init = true;
    }
 
    /*
     * if chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
    if (innerPlan->chgParam == NULL)
        ExecReScan(innerPlan);
}

References ExecClearTuple(), ExecReScan(), fb(), SetOpState::hashiter, SetOpState::hashtable, innerPlan, innerPlanState, SetOpState::need_init, SetOpState::numOutput, outerPlan, outerPlanState, PlanState::plan, SetOpState::ps, PlanState::ps_ResultTupleSlot, ResetTupleHashIterator, ResetTupleHashTable(), SetOpState::setop_done, SETOP_HASHED, and SetOpState::table_filled.

Referenced by ExecReScan().