nodeSetOp.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "executor/executor.h"
#include "executor/nodeSetOp.h"
#include "miscadmin.h"
#include "utils/memutils.h"
#include "utils/sortsupport.h"

Include dependency graph for nodeSetOp.c:

Go to the source code of this file.

Data Structures
struct	SetOpStatePerGroupData

Typedefs
typedef struct SetOpStatePerGroupData	SetOpStatePerGroupData
typedef SetOpStatePerGroupData *	SetOpStatePerGroup

Functions
static TupleTableSlot *	setop_retrieve_sorted (SetOpState *setopstate)
static void	setop_load_group (SetOpStatePerInput *input, PlanState *inputPlan, SetOpState *setopstate)
static int	setop_compare_slots (TupleTableSlot *s1, TupleTableSlot *s2, SetOpState *setopstate)
static void	setop_fill_hash_table (SetOpState *setopstate)
static TupleTableSlot *	setop_retrieve_hash_table (SetOpState *setopstate)
static void	build_hash_table (SetOpState *setopstate)
Size	EstimateSetOpHashTableSpace (double nentries, Size tupleWidth)
static void	set_output_count (SetOpState *setopstate, SetOpStatePerGroup pergroup)
static TupleTableSlot *	ExecSetOp (PlanState *pstate)
SetOpState *	ExecInitSetOp (SetOp *node, EState *estate, int eflags)
void	ExecEndSetOp (SetOpState *node)
void	ExecReScanSetOp (SetOpState *node)

Typedef Documentation

SetOpStatePerGroup

typedef SetOpStatePerGroupData* SetOpStatePerGroup

Definition at line 69 of file nodeSetOp.c.

SetOpStatePerGroupData

typedef struct SetOpStatePerGroupData SetOpStatePerGroupData

Function Documentation

build_hash_table()

static void build_hash_table ( SetOpState *  setopstate )

static

Definition at line 85 of file nodeSetOp.c.

{
    SetOp      *node = (SetOp *) setopstate->ps.plan;
    ExprContext *econtext = setopstate->ps.ps_ExprContext;
    TupleDesc   desc = ExecGetResultType(outerPlanState(setopstate));
 
    Assert(node->strategy == SETOP_HASHED);
 
    /*
     * If both child plans deliver the same fixed tuple slot type, we can tell
     * BuildTupleHashTable to expect that slot type as input.  Otherwise,
     * we'll pass NULL denoting that any slot type is possible.
     */
    setopstate->hashtable = BuildTupleHashTable(&setopstate->ps,
                                                desc,
                                                ExecGetCommonChildSlotOps(&setopstate->ps),
                                                node->numCols,
                                                node->cmpColIdx,
                                                setopstate->eqfuncoids,
                                                setopstate->hashfunctions,
                                                node->cmpCollations,
                                                node->numGroups,
                                                sizeof(SetOpStatePerGroupData),
                                                setopstate->ps.state->es_query_cxt,
                                                setopstate->tuplesContext,
                                                econtext->ecxt_per_tuple_memory,
                                                false);
}

References Assert, BuildTupleHashTable(), ExprContext::ecxt_per_tuple_memory, ExecGetCommonChildSlotOps(), ExecGetResultType(), fb(), SetOp::numCols, SetOp::numGroups, outerPlanState, SetOp::plan, SETOP_HASHED, and SetOp::strategy.

Referenced by ExecInitSetOp().

EstimateSetOpHashTableSpace()

Size EstimateSetOpHashTableSpace	(	double	nentries,
		Size	tupleWidth
	)

Definition at line 116 of file nodeSetOp.c.

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

References EstimateTupleHashTableSpace(), and fb().

Referenced by create_setop_path().

ExecEndSetOp()

void ExecEndSetOp

(

SetOpState *

node

)

Definition at line 692 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
	)

Definition at line 573 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

)

Definition at line 704 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().

ExecSetOp()

static TupleTableSlot * ExecSetOp ( PlanState *  pstate )

static

Definition at line 169 of file nodeSetOp.c.

{
    SetOpState *node = castNode(SetOpState, pstate);
    SetOp      *plannode = (SetOp *) node->ps.plan;
    TupleTableSlot *resultTupleSlot = node->ps.ps_ResultTupleSlot;
 
    CHECK_FOR_INTERRUPTS();
 
    /*
     * If the previously-returned tuple needs to be returned more than once,
     * keep returning it.
     */
    if (node->numOutput > 0)
    {
        node->numOutput--;
        return resultTupleSlot;
    }
 
    /* Otherwise, we're done if we are out of groups */
    if (node->setop_done)
        return NULL;
 
    /* Fetch the next tuple group according to the correct strategy */
    if (plannode->strategy == SETOP_HASHED)
    {
        if (!node->table_filled)
            setop_fill_hash_table(node);
        return setop_retrieve_hash_table(node);
    }
    else
        return setop_retrieve_sorted(node);
}

References castNode, CHECK_FOR_INTERRUPTS, fb(), SetOpState::numOutput, PlanState::plan, SetOpState::ps, PlanState::ps_ResultTupleSlot, SetOpState::setop_done, setop_fill_hash_table(), SETOP_HASHED, setop_retrieve_hash_table(), setop_retrieve_sorted(), and SetOpState::table_filled.

Referenced by ExecInitSetOp().

set_output_count()

static void set_output_count ( SetOpState *  setopstate, SetOpStatePerGroup  pergroup  )

static

Definition at line 129 of file nodeSetOp.c.

{
    SetOp      *plannode = (SetOp *) setopstate->ps.plan;
 
    switch (plannode->cmd)
    {
        case SETOPCMD_INTERSECT:
            if (pergroup->numLeft > 0 && pergroup->numRight > 0)
                setopstate->numOutput = 1;
            else
                setopstate->numOutput = 0;
            break;
        case SETOPCMD_INTERSECT_ALL:
            setopstate->numOutput =
                (pergroup->numLeft < pergroup->numRight) ?
                pergroup->numLeft : pergroup->numRight;
            break;
        case SETOPCMD_EXCEPT:
            if (pergroup->numLeft > 0 && pergroup->numRight == 0)
                setopstate->numOutput = 1;
            else
                setopstate->numOutput = 0;
            break;
        case SETOPCMD_EXCEPT_ALL:
            setopstate->numOutput =
                (pergroup->numLeft < pergroup->numRight) ?
                0 : (pergroup->numLeft - pergroup->numRight);
            break;
        default:
            elog(ERROR, "unrecognized set op: %d", (int) plannode->cmd);
            break;
    }
}

References elog, ERROR, fb(), SetOp::plan, SETOPCMD_EXCEPT, SETOPCMD_EXCEPT_ALL, SETOPCMD_INTERSECT, and SETOPCMD_INTERSECT_ALL.

Referenced by setop_retrieve_hash_table(), and setop_retrieve_sorted().

setop_compare_slots()

static int setop_compare_slots ( TupleTableSlot *  s1, TupleTableSlot *  s2, SetOpState *  setopstate  )

static

Definition at line 387 of file nodeSetOp.c.

{
    /* We'll often need to fetch all the columns, so just do it */
    slot_getallattrs(s1);
    slot_getallattrs(s2);
    for (int nkey = 0; nkey < setopstate->numCols; nkey++)
    {
        SortSupport sortKey = setopstate->sortKeys + nkey;
        AttrNumber  attno = sortKey->ssup_attno;
        Datum       datum1 = s1->tts_values[attno - 1],
                    datum2 = s2->tts_values[attno - 1];
        bool        isNull1 = s1->tts_isnull[attno - 1],
                    isNull2 = s2->tts_isnull[attno - 1];
        int         compare;
 
        compare = ApplySortComparator(datum1, isNull1,
                                      datum2, isNull2,
                                      sortKey);
        if (compare != 0)
            return compare;
    }
    return 0;
}

References ApplySortComparator(), compare(), fb(), s1, s2, slot_getallattrs(), and SortSupportData::ssup_attno.

Referenced by setop_load_group(), and setop_retrieve_sorted().

setop_fill_hash_table()

static void setop_fill_hash_table ( SetOpState *  setopstate )

static

Definition at line 416 of file nodeSetOp.c.

{
    PlanState  *outerPlan;
    PlanState  *innerPlan;
    ExprContext *econtext = setopstate->ps.ps_ExprContext;
    bool        have_tuples = false;
 
    /*
     * get state info from node
     */
    outerPlan = outerPlanState(setopstate);
    innerPlan = innerPlanState(setopstate);
 
    /*
     * Process each outer-plan tuple, and then fetch the next one, until we
     * exhaust the outer plan.
     */
    for (;;)
    {
        TupleTableSlot *outerslot;
        TupleHashTable hashtable = setopstate->hashtable;
        TupleHashEntryData *entry;
        SetOpStatePerGroup pergroup;
        bool        isnew;
 
        outerslot = ExecProcNode(outerPlan);
        if (TupIsNull(outerslot))
            break;
        have_tuples = true;
 
        /* Find or build hashtable entry for this tuple's group */
        entry = LookupTupleHashEntry(hashtable,
                                     outerslot,
                                     &isnew, NULL);
 
        pergroup = TupleHashEntryGetAdditional(hashtable, entry);
        /* If new tuple group, initialize counts to zero */
        if (isnew)
        {
            pergroup->numLeft = 0;
            pergroup->numRight = 0;
        }
 
        /* Advance the counts */
        pergroup->numLeft++;
 
        /* Must reset expression context after each hashtable lookup */
        ResetExprContext(econtext);
    }
 
    /*
     * If the outer relation is empty, then we will emit nothing, and we don't
     * need to read the inner relation at all.
     */
    if (have_tuples)
    {
        /*
         * Process each inner-plan tuple, and then fetch the next one, until
         * we exhaust the inner plan.
         */
        for (;;)
        {
            TupleTableSlot *innerslot;
            TupleHashTable hashtable = setopstate->hashtable;
            TupleHashEntryData *entry;
 
            innerslot = ExecProcNode(innerPlan);
            if (TupIsNull(innerslot))
                break;
 
            /* For tuples not seen previously, do not make hashtable entry */
            entry = LookupTupleHashEntry(hashtable,
                                         innerslot,
                                         NULL, NULL);
 
            /* Advance the counts if entry is already present */
            if (entry)
            {
                SetOpStatePerGroup pergroup = TupleHashEntryGetAdditional(hashtable, entry);
 
                pergroup->numRight++;
            }
 
            /* Must reset expression context after each hashtable lookup */
            ResetExprContext(econtext);
        }
    }
 
    setopstate->table_filled = true;
    /* Initialize to walk the hash table */
    ResetTupleHashIterator(setopstate->hashtable, &setopstate->hashiter);
}

References ExecProcNode(), fb(), innerPlan, innerPlanState, LookupTupleHashEntry(), outerPlan, outerPlanState, ResetExprContext, ResetTupleHashIterator, TupIsNull, and TupleHashEntryGetAdditional().

Referenced by ExecSetOp().

setop_load_group()

static void setop_load_group ( SetOpStatePerInput *  input, PlanState *  inputPlan, SetOpState *  setopstate  )

static

Definition at line 340 of file nodeSetOp.c.

{
    input->needGroup = false;
 
    /* If we've exhausted this child plan, report an empty group */
    if (TupIsNull(input->nextTupleSlot))
    {
        ExecClearTuple(input->firstTupleSlot);
        input->numTuples = 0;
        return;
    }
 
    /* Make a local copy of the first tuple for comparisons */
    ExecStoreMinimalTuple(ExecCopySlotMinimalTuple(input->nextTupleSlot),
                          input->firstTupleSlot,
                          true);
    /* and count it */
    input->numTuples = 1;
 
    /* Scan till we find the end-of-group */
    for (;;)
    {
        int         cmpresult;
 
        /* Get next input tuple, if there is one */
        input->nextTupleSlot = ExecProcNode(inputPlan);
        if (TupIsNull(input->nextTupleSlot))
            break;
 
        /* There is; does it belong to same group as firstTuple? */
        cmpresult = setop_compare_slots(input->firstTupleSlot,
                                        input->nextTupleSlot,
                                        setopstate);
        Assert(cmpresult <= 0); /* else input is mis-sorted */
        if (cmpresult != 0)
            break;
 
        /* Still in same group, so count this tuple */
        input->numTuples++;
    }
}

References Assert, ExecClearTuple(), ExecCopySlotMinimalTuple(), ExecProcNode(), ExecStoreMinimalTuple(), fb(), input, setop_compare_slots(), and TupIsNull.

Referenced by setop_retrieve_sorted().

setop_retrieve_hash_table()

static TupleTableSlot * setop_retrieve_hash_table ( SetOpState *  setopstate )

static

Definition at line 513 of file nodeSetOp.c.

{
    TupleHashEntry entry;
    TupleTableSlot *resultTupleSlot;
 
    /*
     * get state info from node
     */
    resultTupleSlot = setopstate->ps.ps_ResultTupleSlot;
 
    /*
     * We loop retrieving groups until we find one we should return
     */
    while (!setopstate->setop_done)
    {
        TupleHashTable hashtable = setopstate->hashtable;
        SetOpStatePerGroup pergroup;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * Find the next entry in the hash table
         */
        entry = ScanTupleHashTable(hashtable, &setopstate->hashiter);
        if (entry == NULL)
        {
            /* No more entries in hashtable, so done */
            setopstate->setop_done = true;
            return NULL;
        }
 
        /*
         * See if we should emit any copies of this tuple, and if so return
         * the first copy.
         */
        pergroup = TupleHashEntryGetAdditional(hashtable, entry);
        set_output_count(setopstate, pergroup);
 
        if (setopstate->numOutput > 0)
        {
            setopstate->numOutput--;
            return ExecStoreMinimalTuple(TupleHashEntryGetTuple(entry),
                                         resultTupleSlot,
                                         false);
        }
    }
 
    /* No more groups */
    ExecClearTuple(resultTupleSlot);
    return NULL;
}

References CHECK_FOR_INTERRUPTS, ExecClearTuple(), ExecStoreMinimalTuple(), fb(), ScanTupleHashTable, set_output_count(), TupleHashEntryGetAdditional(), and TupleHashEntryGetTuple().

Referenced by ExecSetOp().

setop_retrieve_sorted()

static TupleTableSlot * setop_retrieve_sorted ( SetOpState *  setopstate )

static

Definition at line 206 of file nodeSetOp.c.

{
    PlanState  *outerPlan;
    PlanState  *innerPlan;
    TupleTableSlot *resultTupleSlot;
 
    /*
     * get state info from node
     */
    outerPlan = outerPlanState(setopstate);
    innerPlan = innerPlanState(setopstate);
    resultTupleSlot = setopstate->ps.ps_ResultTupleSlot;
 
    /*
     * If first time through, establish the invariant that setop_load_group
     * expects: each side's nextTupleSlot is the next output from the child
     * plan, or empty if there is no more output from it.
     */
    if (setopstate->need_init)
    {
        setopstate->need_init = false;
 
        setopstate->leftInput.nextTupleSlot = ExecProcNode(outerPlan);
 
        /*
         * If the outer relation is empty, then we will emit nothing, and we
         * don't need to read the inner relation at all.
         */
        if (TupIsNull(setopstate->leftInput.nextTupleSlot))
        {
            setopstate->setop_done = true;
            return NULL;
        }
 
        setopstate->rightInput.nextTupleSlot = ExecProcNode(innerPlan);
 
        /* Set flags that we've not completed either side's group */
        setopstate->leftInput.needGroup = true;
        setopstate->rightInput.needGroup = true;
    }
 
    /*
     * We loop retrieving groups until we find one we should return
     */
    while (!setopstate->setop_done)
    {
        int         cmpresult;
        SetOpStatePerGroupData pergroup;
 
        /*
         * Fetch the rest of the current outer group, if we didn't already.
         */
        if (setopstate->leftInput.needGroup)
            setop_load_group(&setopstate->leftInput, outerPlan, setopstate);
 
        /*
         * If no more outer groups, we're done, and don't need to look at any
         * more of the inner relation.
         */
        if (setopstate->leftInput.numTuples == 0)
        {
            setopstate->setop_done = true;
            break;
        }
 
        /*
         * Fetch the rest of the current inner group, if we didn't already.
         */
        if (setopstate->rightInput.needGroup)
            setop_load_group(&setopstate->rightInput, innerPlan, setopstate);
 
        /*
         * Determine whether we have matching groups on both sides (this is
         * basically like the core logic of a merge join).
         */
        if (setopstate->rightInput.numTuples == 0)
            cmpresult = -1;     /* as though left input is lesser */
        else
            cmpresult = setop_compare_slots(setopstate->leftInput.firstTupleSlot,
                                            setopstate->rightInput.firstTupleSlot,
                                            setopstate);
 
        if (cmpresult < 0)
        {
            /* Left group is first, and has no right matches */
            pergroup.numLeft = setopstate->leftInput.numTuples;
            pergroup.numRight = 0;
            /* We'll need another left group next time */
            setopstate->leftInput.needGroup = true;
        }
        else if (cmpresult == 0)
        {
            /* We have matching groups */
            pergroup.numLeft = setopstate->leftInput.numTuples;
            pergroup.numRight = setopstate->rightInput.numTuples;
            /* We'll need to read from both sides next time */
            setopstate->leftInput.needGroup = true;
            setopstate->rightInput.needGroup = true;
        }
        else
        {
            /* Right group has no left matches, so we can ignore it */
            setopstate->rightInput.needGroup = true;
            continue;
        }
 
        /*
         * Done scanning these input tuple groups.  See if we should emit any
         * copies of result tuple, and if so return the first copy.  (Note
         * that the result tuple is the same as the left input's firstTuple
         * slot.)
         */
        set_output_count(setopstate, &pergroup);
 
        if (setopstate->numOutput > 0)
        {
            setopstate->numOutput--;
            return resultTupleSlot;
        }
    }
 
    /* No more groups */
    ExecClearTuple(resultTupleSlot);
    return NULL;
}

References ExecClearTuple(), ExecProcNode(), fb(), innerPlan, innerPlanState, outerPlan, outerPlanState, set_output_count(), setop_compare_slots(), setop_load_group(), and TupIsNull.

Referenced by ExecSetOp().