nodeMergejoin.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeMergejoin.h:

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

Go to the source code of this file.

Functions
MergeJoinState *	ExecInitMergeJoin (MergeJoin *node, EState *estate, int eflags)
void	ExecEndMergeJoin (MergeJoinState *node)
void	ExecReScanMergeJoin (MergeJoinState *node)

Function Documentation

ExecEndMergeJoin()

void ExecEndMergeJoin ( MergeJoinState *  node )

extern

Definition at line 1636 of file nodeMergejoin.c.

{
    MJ1_printf("ExecEndMergeJoin: %s\n",
               "ending node processing");
 
    /*
     * shut down the subplans
     */
    ExecEndNode(innerPlanState(node));
    ExecEndNode(outerPlanState(node));
 
    MJ1_printf("ExecEndMergeJoin: %s\n",
               "node processing ended");
}

References ExecEndNode(), innerPlanState, MJ1_printf, and outerPlanState.

Referenced by ExecEndNode().

ExecInitMergeJoin()

MergeJoinState * ExecInitMergeJoin ( MergeJoin *  node, EState *  estate, int  eflags  )

extern

Definition at line 1439 of file nodeMergejoin.c.

{
    MergeJoinState *mergestate;
    TupleDesc   outerDesc,
                innerDesc;
    const TupleTableSlotOps *innerOps;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    MJ1_printf("ExecInitMergeJoin: %s\n",
               "initializing node");
 
    /*
     * create state structure
     */
    mergestate = makeNode(MergeJoinState);
    mergestate->js.ps.plan = (Plan *) node;
    mergestate->js.ps.state = estate;
    mergestate->js.ps.ExecProcNode = ExecMergeJoin;
    mergestate->js.jointype = node->join.jointype;
    mergestate->mj_ConstFalseJoin = false;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &mergestate->js.ps);
 
    /*
     * we need two additional econtexts in which we can compute the join
     * expressions from the left and right input tuples.  The node's regular
     * econtext won't do because it gets reset too often.
     */
    mergestate->mj_OuterEContext = CreateExprContext(estate);
    mergestate->mj_InnerEContext = CreateExprContext(estate);
 
    /*
     * initialize child nodes
     *
     * inner child must support MARK/RESTORE, unless we have detected that we
     * don't need that.  Note that skip_mark_restore must never be set if
     * there are non-mergeclause joinquals, since the logic wouldn't work.
     */
    Assert(node->join.joinqual == NIL || !node->skip_mark_restore);
    mergestate->mj_SkipMarkRestore = node->skip_mark_restore;
 
    outerPlanState(mergestate) = ExecInitNode(outerPlan(node), estate, eflags);
    outerDesc = ExecGetResultType(outerPlanState(mergestate));
    innerPlanState(mergestate) = ExecInitNode(innerPlan(node), estate,
                                              mergestate->mj_SkipMarkRestore ?
                                              eflags :
                                              (eflags | EXEC_FLAG_MARK));
    innerDesc = ExecGetResultType(innerPlanState(mergestate));
 
    /*
     * For certain types of inner child nodes, it is advantageous to issue
     * MARK every time we advance past an inner tuple we will never return to.
     * For other types, MARK on a tuple we cannot return to is a waste of
     * cycles.  Detect which case applies and set mj_ExtraMarks if we want to
     * issue "unnecessary" MARK calls.
     *
     * Currently, only Material wants the extra MARKs, and it will be helpful
     * only if eflags doesn't specify REWIND.
     *
     * Note that for IndexScan and IndexOnlyScan, it is *necessary* that we
     * not set mj_ExtraMarks; otherwise we might attempt to set a mark before
     * the first inner tuple, which they do not support.
     */
    if (IsA(innerPlan(node), Material) &&
        (eflags & EXEC_FLAG_REWIND) == 0 &&
        !mergestate->mj_SkipMarkRestore)
        mergestate->mj_ExtraMarks = true;
    else
        mergestate->mj_ExtraMarks = false;
 
    /*
     * Initialize result slot, type and projection.
     */
    ExecInitResultTupleSlotTL(&mergestate->js.ps, &TTSOpsVirtual);
    ExecAssignProjectionInfo(&mergestate->js.ps, NULL);
 
    /*
     * tuple table initialization
     */
    innerOps = ExecGetResultSlotOps(innerPlanState(mergestate), NULL);
    mergestate->mj_MarkedTupleSlot = ExecInitExtraTupleSlot(estate, innerDesc,
                                                            innerOps);
 
    /*
     * initialize child expressions
     */
    mergestate->js.ps.qual =
        ExecInitQual(node->join.plan.qual, (PlanState *) mergestate);
    mergestate->js.joinqual =
        ExecInitQual(node->join.joinqual, (PlanState *) mergestate);
    /* mergeclauses are handled below */
 
    /*
     * detect whether we need only consider the first matching inner tuple
     */
    mergestate->js.single_match = (node->join.inner_unique ||
                                   node->join.jointype == JOIN_SEMI);
 
    /* set up null tuples for outer joins, if needed */
    switch (node->join.jointype)
    {
        case JOIN_INNER:
        case JOIN_SEMI:
            mergestate->mj_FillOuter = false;
            mergestate->mj_FillInner = false;
            break;
        case JOIN_LEFT:
        case JOIN_ANTI:
            mergestate->mj_FillOuter = true;
            mergestate->mj_FillInner = false;
            mergestate->mj_NullInnerTupleSlot =
                ExecInitNullTupleSlot(estate, innerDesc, &TTSOpsVirtual);
            break;
        case JOIN_RIGHT:
        case JOIN_RIGHT_ANTI:
            mergestate->mj_FillOuter = false;
            mergestate->mj_FillInner = true;
            mergestate->mj_NullOuterTupleSlot =
                ExecInitNullTupleSlot(estate, outerDesc, &TTSOpsVirtual);
 
            /*
             * Can't handle right, right-anti or full join with non-constant
             * extra joinclauses.  This should have been caught by planner.
             */
            if (!check_constant_qual(node->join.joinqual,
                                     &mergestate->mj_ConstFalseJoin))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("RIGHT JOIN is only supported with merge-joinable join conditions")));
            break;
        case JOIN_FULL:
            mergestate->mj_FillOuter = true;
            mergestate->mj_FillInner = true;
            mergestate->mj_NullOuterTupleSlot =
                ExecInitNullTupleSlot(estate, outerDesc, &TTSOpsVirtual);
            mergestate->mj_NullInnerTupleSlot =
                ExecInitNullTupleSlot(estate, innerDesc, &TTSOpsVirtual);
 
            /*
             * Can't handle right, right-anti or full join with non-constant
             * extra joinclauses.  This should have been caught by planner.
             */
            if (!check_constant_qual(node->join.joinqual,
                                     &mergestate->mj_ConstFalseJoin))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("FULL JOIN is only supported with merge-joinable join conditions")));
            break;
        default:
            elog(ERROR, "unrecognized join type: %d",
                 (int) node->join.jointype);
    }
 
    /*
     * preprocess the merge clauses
     */
    mergestate->mj_NumClauses = list_length(node->mergeclauses);
    mergestate->mj_Clauses = MJExamineQuals(node->mergeclauses,
                                            node->mergeFamilies,
                                            node->mergeCollations,
                                            node->mergeReversals,
                                            node->mergeNullsFirst,
                                            (PlanState *) mergestate);
 
    /*
     * initialize join state
     */
    mergestate->mj_JoinState = EXEC_MJ_INITIALIZE_OUTER;
    mergestate->mj_MatchedOuter = false;
    mergestate->mj_MatchedInner = false;
    mergestate->mj_OuterTupleSlot = NULL;
    mergestate->mj_InnerTupleSlot = NULL;
 
    /*
     * initialization successful
     */
    MJ1_printf("ExecInitMergeJoin: %s\n",
               "node initialized");
 
    return mergestate;
}

References Assert, check_constant_qual(), CreateExprContext(), elog, ereport, errcode(), errmsg(), ERROR, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, EXEC_FLAG_REWIND, EXEC_MJ_INITIALIZE_OUTER, ExecAssignExprContext(), ExecAssignProjectionInfo(), ExecGetResultSlotOps(), ExecGetResultType(), ExecInitExtraTupleSlot(), ExecInitNode(), ExecInitNullTupleSlot(), ExecInitQual(), ExecInitResultTupleSlotTL(), ExecMergeJoin(), fb(), Join::inner_unique, innerPlan, innerPlanState, IsA, MergeJoin::join, JOIN_ANTI, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, JOIN_RIGHT_ANTI, JOIN_SEMI, Join::joinqual, Join::jointype, list_length(), makeNode, MergeJoin::mergeclauses, MJ1_printf, MJExamineQuals(), NIL, outerPlan, outerPlanState, MergeJoin::skip_mark_restore, and TTSOpsVirtual.

Referenced by ExecInitNode().

ExecReScanMergeJoin()

void ExecReScanMergeJoin ( MergeJoinState *  node )

extern

Definition at line 1652 of file nodeMergejoin.c.

{
    PlanState  *outerPlan = outerPlanState(node);
    PlanState  *innerPlan = innerPlanState(node);
 
    ExecClearTuple(node->mj_MarkedTupleSlot);
 
    node->mj_JoinState = EXEC_MJ_INITIALIZE_OUTER;
    node->mj_MatchedOuter = false;
    node->mj_MatchedInner = false;
    node->mj_OuterTupleSlot = NULL;
    node->mj_InnerTupleSlot = NULL;
 
    /*
     * if chgParam of subnodes is not null then plans will be re-scanned by
     * first ExecProcNode.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
    if (innerPlan->chgParam == NULL)
        ExecReScan(innerPlan);
}

References EXEC_MJ_INITIALIZE_OUTER, ExecClearTuple(), ExecReScan(), fb(), innerPlan, innerPlanState, MergeJoinState::mj_InnerTupleSlot, MergeJoinState::mj_JoinState, MergeJoinState::mj_MarkedTupleSlot, MergeJoinState::mj_MatchedInner, MergeJoinState::mj_MatchedOuter, MergeJoinState::mj_OuterTupleSlot, outerPlan, and outerPlanState.

Referenced by ExecReScan().