#include "postgres.h"
#include "access/nbtree.h"
#include "executor/execdebug.h"
#include "executor/nodeMergejoin.h"
#include "miscadmin.h"
#include "utils/lsyscache.h"

Include dependency graph for nodeMergejoin.c:

Go to the source code of this file.

Data Structures
struct	MergeJoinClauseData

Macros
#define	EXEC_MJ_INITIALIZE_OUTER 1

#define	EXEC_MJ_INITIALIZE_INNER 2

#define	EXEC_MJ_JOINTUPLES 3

#define	EXEC_MJ_NEXTOUTER 4

#define	EXEC_MJ_TESTOUTER 5

#define	EXEC_MJ_NEXTINNER 6

#define	EXEC_MJ_SKIP_TEST 7

#define	EXEC_MJ_SKIPOUTER_ADVANCE 8

#define	EXEC_MJ_SKIPINNER_ADVANCE 9

#define	EXEC_MJ_ENDOUTER 10

#define	EXEC_MJ_ENDINNER 11

#define	MarkInnerTuple(innerTupleSlot, mergestate) ExecCopySlot((mergestate)->mj_MarkedTupleSlot, (innerTupleSlot))

Typedefs
typedef struct MergeJoinClauseData	MergeJoinClauseData

Enumerations
enum	MJEvalResult { MJEVAL_MATCHABLE , MJEVAL_NONMATCHABLE , MJEVAL_ENDOFJOIN }

Functions
static MergeJoinClause	MJExamineQuals (List mergeclauses, Oid mergefamilies, Oid mergecollations, int mergestrategies, bool mergenullsfirst, PlanState parent)

static MJEvalResult	MJEvalOuterValues (MergeJoinState *mergestate)

static MJEvalResult	MJEvalInnerValues (MergeJoinState mergestate, TupleTableSlot innerslot)

static int	MJCompare (MergeJoinState *mergestate)

static TupleTableSlot *	MJFillOuter (MergeJoinState *node)

static TupleTableSlot *	MJFillInner (MergeJoinState *node)

static bool	check_constant_qual (List qual, bool is_const_false)

static TupleTableSlot *	ExecMergeJoin (PlanState *pstate)

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

void	ExecEndMergeJoin (MergeJoinState *node)

void	ExecReScanMergeJoin (MergeJoinState *node)

Macro Definition Documentation

◆ EXEC_MJ_ENDINNER

#define EXEC_MJ_ENDINNER 11

Definition at line 115 of file nodeMergejoin.c.

◆ EXEC_MJ_ENDOUTER

#define EXEC_MJ_ENDOUTER 10

Definition at line 114 of file nodeMergejoin.c.

◆ EXEC_MJ_INITIALIZE_INNER

#define EXEC_MJ_INITIALIZE_INNER 2

Definition at line 106 of file nodeMergejoin.c.

◆ EXEC_MJ_INITIALIZE_OUTER

#define EXEC_MJ_INITIALIZE_OUTER 1

Definition at line 105 of file nodeMergejoin.c.

◆ EXEC_MJ_JOINTUPLES

#define EXEC_MJ_JOINTUPLES 3

Definition at line 107 of file nodeMergejoin.c.

◆ EXEC_MJ_NEXTINNER

#define EXEC_MJ_NEXTINNER 6

Definition at line 110 of file nodeMergejoin.c.

◆ EXEC_MJ_NEXTOUTER

#define EXEC_MJ_NEXTOUTER 4

Definition at line 108 of file nodeMergejoin.c.

◆ EXEC_MJ_SKIP_TEST

#define EXEC_MJ_SKIP_TEST 7

Definition at line 111 of file nodeMergejoin.c.

◆ EXEC_MJ_SKIPINNER_ADVANCE

#define EXEC_MJ_SKIPINNER_ADVANCE 9

Definition at line 113 of file nodeMergejoin.c.

◆ EXEC_MJ_SKIPOUTER_ADVANCE

#define EXEC_MJ_SKIPOUTER_ADVANCE 8

Definition at line 112 of file nodeMergejoin.c.

◆ EXEC_MJ_TESTOUTER

#define EXEC_MJ_TESTOUTER 5

Definition at line 109 of file nodeMergejoin.c.

◆ MarkInnerTuple

#define MarkInnerTuple	(	innerTupleSlot,
		mergestate
	)	ExecCopySlot((mergestate)->mj_MarkedTupleSlot, (innerTupleSlot))

Definition at line 151 of file nodeMergejoin.c.

Typedef Documentation

◆ MergeJoinClauseData

typedef struct MergeJoinClauseData MergeJoinClauseData

Enumeration Type Documentation

◆ MJEvalResult

enum MJEvalResult

Enumerator
MJEVAL_MATCHABLE
MJEVAL_NONMATCHABLE
MJEVAL_ENDOFJOIN

Definition at line 143 of file nodeMergejoin.c.

 {
     MJEVAL_MATCHABLE,           /* normal, potentially matchable tuple */
     MJEVAL_NONMATCHABLE,        /* tuple cannot join because it has a null */
     MJEVAL_ENDOFJOIN,           /* end of input (physical or effective) */
 } MJEvalResult;

Function Documentation

◆ check_constant_qual()

static bool check_constant_qual	(	List *	qual,
		bool *	is_const_false
	)

static

Definition at line 519 of file nodeMergejoin.c.

 {
     ListCell   *lc;
  
     foreach(lc, qual)
     {
         Const      *con = (Const *) lfirst(lc);
  
         if (!con || !IsA(con, Const))
             return false;
         if (con->constisnull || !DatumGetBool(con->constvalue))
             *is_const_false = true;
     }
     return true;
 }

References DatumGetBool(), IsA, and lfirst.

Referenced by ExecInitMergeJoin().

◆ ExecEndMergeJoin()

void ExecEndMergeJoin ( MergeJoinState * node )

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

Definition at line 1444 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->mergeStrategies,
                                             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;
 }

Referenced by ExecInitNode().

◆ ExecMergeJoin()

static TupleTableSlot* ExecMergeJoin ( PlanState * pstate )

static

Definition at line 599 of file nodeMergejoin.c.

 {
     MergeJoinState *node = castNode(MergeJoinState, pstate);
     ExprState  *joinqual;
     ExprState  *otherqual;
     bool        qualResult;
     int         compareResult;
     PlanState  *innerPlan;
     TupleTableSlot *innerTupleSlot;
     PlanState  *outerPlan;
     TupleTableSlot *outerTupleSlot;
     ExprContext *econtext;
     bool        doFillOuter;
     bool        doFillInner;
  
     CHECK_FOR_INTERRUPTS();
  
     /*
      * get information from node
      */
     innerPlan = innerPlanState(node);
     outerPlan = outerPlanState(node);
     econtext = node->js.ps.ps_ExprContext;
     joinqual = node->js.joinqual;
     otherqual = node->js.ps.qual;
     doFillOuter = node->mj_FillOuter;
     doFillInner = node->mj_FillInner;
  
     /*
      * Reset per-tuple memory context to free any expression evaluation
      * storage allocated in the previous tuple cycle.
      */
     ResetExprContext(econtext);
  
     /*
      * ok, everything is setup.. let's go to work
      */
     for (;;)
     {
         MJ_dump(node);
  
         /*
          * get the current state of the join and do things accordingly.
          */
         switch (node->mj_JoinState)
         {
                 /*
                  * EXEC_MJ_INITIALIZE_OUTER means that this is the first time
                  * ExecMergeJoin() has been called and so we have to fetch the
                  * first matchable tuple for both outer and inner subplans. We
                  * do the outer side in INITIALIZE_OUTER state, then advance
                  * to INITIALIZE_INNER state for the inner subplan.
                  */
             case EXEC_MJ_INITIALIZE_OUTER:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_INITIALIZE_OUTER\n");
  
                 outerTupleSlot = ExecProcNode(outerPlan);
                 node->mj_OuterTupleSlot = outerTupleSlot;
  
                 /* Compute join values and check for unmatchability */
                 switch (MJEvalOuterValues(node))
                 {
                     case MJEVAL_MATCHABLE:
                         /* OK to go get the first inner tuple */
                         node->mj_JoinState = EXEC_MJ_INITIALIZE_INNER;
                         break;
                     case MJEVAL_NONMATCHABLE:
                         /* Stay in same state to fetch next outer tuple */
                         if (doFillOuter)
                         {
                             /*
                              * Generate a fake join tuple with nulls for the
                              * inner tuple, and return it if it passes the
                              * non-join quals.
                              */
                             TupleTableSlot *result;
  
                             result = MJFillOuter(node);
                             if (result)
                                 return result;
                         }
                         break;
                     case MJEVAL_ENDOFJOIN:
                         /* No more outer tuples */
                         MJ_printf("ExecMergeJoin: nothing in outer subplan\n");
                         if (doFillInner)
                         {
                             /*
                              * Need to emit right-join tuples for remaining
                              * inner tuples. We set MatchedInner = true to
                              * force the ENDOUTER state to advance inner.
                              */
                             node->mj_JoinState = EXEC_MJ_ENDOUTER;
                             node->mj_MatchedInner = true;
                             break;
                         }
                         /* Otherwise we're done. */
                         return NULL;
                 }
                 break;
  
             case EXEC_MJ_INITIALIZE_INNER:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_INITIALIZE_INNER\n");
  
                 innerTupleSlot = ExecProcNode(innerPlan);
                 node->mj_InnerTupleSlot = innerTupleSlot;
  
                 /* Compute join values and check for unmatchability */
                 switch (MJEvalInnerValues(node, innerTupleSlot))
                 {
                     case MJEVAL_MATCHABLE:
  
                         /*
                          * OK, we have the initial tuples.  Begin by skipping
                          * non-matching tuples.
                          */
                         node->mj_JoinState = EXEC_MJ_SKIP_TEST;
                         break;
                     case MJEVAL_NONMATCHABLE:
                         /* Mark before advancing, if wanted */
                         if (node->mj_ExtraMarks)
                             ExecMarkPos(innerPlan);
                         /* Stay in same state to fetch next inner tuple */
                         if (doFillInner)
                         {
                             /*
                              * Generate a fake join tuple with nulls for the
                              * outer tuple, and return it if it passes the
                              * non-join quals.
                              */
                             TupleTableSlot *result;
  
                             result = MJFillInner(node);
                             if (result)
                                 return result;
                         }
                         break;
                     case MJEVAL_ENDOFJOIN:
                         /* No more inner tuples */
                         MJ_printf("ExecMergeJoin: nothing in inner subplan\n");
                         if (doFillOuter)
                         {
                             /*
                              * Need to emit left-join tuples for all outer
                              * tuples, including the one we just fetched.  We
                              * set MatchedOuter = false to force the ENDINNER
                              * state to emit first tuple before advancing
                              * outer.
                              */
                             node->mj_JoinState = EXEC_MJ_ENDINNER;
                             node->mj_MatchedOuter = false;
                             break;
                         }
                         /* Otherwise we're done. */
                         return NULL;
                 }
                 break;
  
                 /*
                  * EXEC_MJ_JOINTUPLES means we have two tuples which satisfied
                  * the merge clause so we join them and then proceed to get
                  * the next inner tuple (EXEC_MJ_NEXTINNER).
                  */
             case EXEC_MJ_JOINTUPLES:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_JOINTUPLES\n");
  
                 /*
                  * Set the next state machine state.  The right things will
                  * happen whether we return this join tuple or just fall
                  * through to continue the state machine execution.
                  */
                 node->mj_JoinState = EXEC_MJ_NEXTINNER;
  
                 /*
                  * Check the extra qual conditions to see if we actually want
                  * to return this join tuple.  If not, can proceed with merge.
                  * We must distinguish the additional joinquals (which must
                  * pass to consider the tuples "matched" for outer-join logic)
                  * from the otherquals (which must pass before we actually
                  * return the tuple).
                  *
                  * We don't bother with a ResetExprContext here, on the
                  * assumption that we just did one while checking the merge
                  * qual.  One per tuple should be sufficient.  We do have to
                  * set up the econtext links to the tuples for ExecQual to
                  * use.
                  */
                 outerTupleSlot = node->mj_OuterTupleSlot;
                 econtext->ecxt_outertuple = outerTupleSlot;
                 innerTupleSlot = node->mj_InnerTupleSlot;
                 econtext->ecxt_innertuple = innerTupleSlot;
  
                 qualResult = (joinqual == NULL ||
                               ExecQual(joinqual, econtext));
                 MJ_DEBUG_QUAL(joinqual, qualResult);
  
                 if (qualResult)
                 {
                     node->mj_MatchedOuter = true;
                     node->mj_MatchedInner = true;
  
                     /* In an antijoin, we never return a matched tuple */
                     if (node->js.jointype == JOIN_ANTI)
                     {
                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
                         break;
                     }
  
                     /*
                      * If we only need to consider the first matching inner
                      * tuple, then advance to next outer tuple after we've
                      * processed this one.
                      */
                     if (node->js.single_match)
                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
  
                     /*
                      * In a right-antijoin, we never return a matched tuple.
                      * If it's not an inner_unique join, we need to stay on
                      * the current outer tuple to continue scanning the inner
                      * side for matches.
                      */
                     if (node->js.jointype == JOIN_RIGHT_ANTI)
                         break;
  
                     qualResult = (otherqual == NULL ||
                                   ExecQual(otherqual, econtext));
                     MJ_DEBUG_QUAL(otherqual, qualResult);
  
                     if (qualResult)
                     {
                         /*
                          * qualification succeeded.  now form the desired
                          * projection tuple and return the slot containing it.
                          */
                         MJ_printf("ExecMergeJoin: returning tuple\n");
  
                         return ExecProject(node->js.ps.ps_ProjInfo);
                     }
                     else
                         InstrCountFiltered2(node, 1);
                 }
                 else
                     InstrCountFiltered1(node, 1);
                 break;
  
                 /*
                  * EXEC_MJ_NEXTINNER means advance the inner scan to the next
                  * tuple. If the tuple is not nil, we then proceed to test it
                  * against the join qualification.
                  *
                  * Before advancing, we check to see if we must emit an
                  * outer-join fill tuple for this inner tuple.
                  */
             case EXEC_MJ_NEXTINNER:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_NEXTINNER\n");
  
                 if (doFillInner && !node->mj_MatchedInner)
                 {
                     /*
                      * Generate a fake join tuple with nulls for the outer
                      * tuple, and return it if it passes the non-join quals.
                      */
                     TupleTableSlot *result;
  
                     node->mj_MatchedInner = true;   /* do it only once */
  
                     result = MJFillInner(node);
                     if (result)
                         return result;
                 }
  
                 /*
                  * now we get the next inner tuple, if any.  If there's none,
                  * advance to next outer tuple (which may be able to join to
                  * previously marked tuples).
                  *
                  * NB: must NOT do "extraMarks" here, since we may need to
                  * return to previously marked tuples.
                  */
                 innerTupleSlot = ExecProcNode(innerPlan);
                 node->mj_InnerTupleSlot = innerTupleSlot;
                 MJ_DEBUG_PROC_NODE(innerTupleSlot);
                 node->mj_MatchedInner = false;
  
                 /* Compute join values and check for unmatchability */
                 switch (MJEvalInnerValues(node, innerTupleSlot))
                 {
                     case MJEVAL_MATCHABLE:
  
                         /*
                          * Test the new inner tuple to see if it matches
                          * outer.
                          *
                          * If they do match, then we join them and move on to
                          * the next inner tuple (EXEC_MJ_JOINTUPLES).
                          *
                          * If they do not match then advance to next outer
                          * tuple.
                          */
                         compareResult = MJCompare(node);
                         MJ_DEBUG_COMPARE(compareResult);
  
                         if (compareResult == 0)
                             node->mj_JoinState = EXEC_MJ_JOINTUPLES;
                         else if (compareResult < 0)
                             node->mj_JoinState = EXEC_MJ_NEXTOUTER;
                         else    /* compareResult > 0 should not happen */
                             elog(ERROR, "mergejoin input data is out of order");
                         break;
                     case MJEVAL_NONMATCHABLE:
  
                         /*
                          * It contains a NULL and hence can't match any outer
                          * tuple, so we can skip the comparison and assume the
                          * new tuple is greater than current outer.
                          */
                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
                         break;
                     case MJEVAL_ENDOFJOIN:
  
                         /*
                          * No more inner tuples.  However, this might be only
                          * effective and not physical end of inner plan, so
                          * force mj_InnerTupleSlot to null to make sure we
                          * don't fetch more inner tuples.  (We need this hack
                          * because we are not transiting to a state where the
                          * inner plan is assumed to be exhausted.)
                          */
                         node->mj_InnerTupleSlot = NULL;
                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
                         break;
                 }
                 break;
  
                 /*-------------------------------------------
                  * EXEC_MJ_NEXTOUTER means
                  *
                  *              outer inner
                  * outer tuple -  5     5  - marked tuple
                  *                5     5
                  *                6     6  - inner tuple
                  *                7     7
                  *
                  * we know we just bumped into the
                  * first inner tuple > current outer tuple (or possibly
                  * the end of the inner stream)
                  * so get a new outer tuple and then
                  * proceed to test it against the marked tuple
                  * (EXEC_MJ_TESTOUTER)
                  *
                  * Before advancing, we check to see if we must emit an
                  * outer-join fill tuple for this outer tuple.
                  *------------------------------------------------
                  */
             case EXEC_MJ_NEXTOUTER:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_NEXTOUTER\n");
  
                 if (doFillOuter && !node->mj_MatchedOuter)
                 {
                     /*
                      * Generate a fake join tuple with nulls for the inner
                      * tuple, and return it if it passes the non-join quals.
                      */
                     TupleTableSlot *result;
  
                     node->mj_MatchedOuter = true;   /* do it only once */
  
                     result = MJFillOuter(node);
                     if (result)
                         return result;
                 }
  
                 /*
                  * now we get the next outer tuple, if any
                  */
                 outerTupleSlot = ExecProcNode(outerPlan);
                 node->mj_OuterTupleSlot = outerTupleSlot;
                 MJ_DEBUG_PROC_NODE(outerTupleSlot);
                 node->mj_MatchedOuter = false;
  
                 /* Compute join values and check for unmatchability */
                 switch (MJEvalOuterValues(node))
                 {
                     case MJEVAL_MATCHABLE:
                         /* Go test the new tuple against the marked tuple */
                         node->mj_JoinState = EXEC_MJ_TESTOUTER;
                         break;
                     case MJEVAL_NONMATCHABLE:
                         /* Can't match, so fetch next outer tuple */
                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
                         break;
                     case MJEVAL_ENDOFJOIN:
                         /* No more outer tuples */
                         MJ_printf("ExecMergeJoin: end of outer subplan\n");
                         innerTupleSlot = node->mj_InnerTupleSlot;
                         if (doFillInner && !TupIsNull(innerTupleSlot))
                         {
                             /*
                              * Need to emit right-join tuples for remaining
                              * inner tuples.
                              */
                             node->mj_JoinState = EXEC_MJ_ENDOUTER;
                             break;
                         }
                         /* Otherwise we're done. */
                         return NULL;
                 }
                 break;
  
                 /*--------------------------------------------------------
                  * EXEC_MJ_TESTOUTER If the new outer tuple and the marked
                  * tuple satisfy the merge clause then we know we have
                  * duplicates in the outer scan so we have to restore the
                  * inner scan to the marked tuple and proceed to join the
                  * new outer tuple with the inner tuples.
                  *
                  * This is the case when
                  *                        outer inner
                  *                          4     5  - marked tuple
                  *           outer tuple -  5     5
                  *       new outer tuple -  5     5
                  *                          6     8  - inner tuple
                  *                          7    12
                  *
                  *              new outer tuple == marked tuple
                  *
                  * If the outer tuple fails the test, then we are done
                  * with the marked tuples, and we have to look for a
                  * match to the current inner tuple.  So we will
                  * proceed to skip outer tuples until outer >= inner
                  * (EXEC_MJ_SKIP_TEST).
                  *
                  *      This is the case when
                  *
                  *                        outer inner
                  *                          5     5  - marked tuple
                  *           outer tuple -  5     5
                  *       new outer tuple -  6     8  - inner tuple
                  *                          7    12
                  *
                  *              new outer tuple > marked tuple
                  *
                  *---------------------------------------------------------
                  */
             case EXEC_MJ_TESTOUTER:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_TESTOUTER\n");
  
                 /*
                  * Here we must compare the outer tuple with the marked inner
                  * tuple.  (We can ignore the result of MJEvalInnerValues,
                  * since the marked inner tuple is certainly matchable.)
                  */
                 innerTupleSlot = node->mj_MarkedTupleSlot;
                 (void) MJEvalInnerValues(node, innerTupleSlot);
  
                 compareResult = MJCompare(node);
                 MJ_DEBUG_COMPARE(compareResult);
  
                 if (compareResult == 0)
                 {
                     /*
                      * the merge clause matched so now we restore the inner
                      * scan position to the first mark, and go join that tuple
                      * (and any following ones) to the new outer.
                      *
                      * If we were able to determine mark and restore are not
                      * needed, then we don't have to back up; the current
                      * inner is already the first possible match.
                      *
                      * NOTE: we do not need to worry about the MatchedInner
                      * state for the rescanned inner tuples.  We know all of
                      * them will match this new outer tuple and therefore
                      * won't be emitted as fill tuples.  This works *only*
                      * because we require the extra joinquals to be constant
                      * when doing a right, right-anti or full join ---
                      * otherwise some of the rescanned tuples might fail the
                      * extra joinquals.  This obviously won't happen for a
                      * constant-true extra joinqual, while the constant-false
                      * case is handled by forcing the merge clause to never
                      * match, so we never get here.
                      */
                     if (!node->mj_SkipMarkRestore)
                     {
                         ExecRestrPos(innerPlan);
  
                         /*
                          * ExecRestrPos probably should give us back a new
                          * Slot, but since it doesn't, use the marked slot.
                          * (The previously returned mj_InnerTupleSlot cannot
                          * be assumed to hold the required tuple.)
                          */
                         node->mj_InnerTupleSlot = innerTupleSlot;
                         /* we need not do MJEvalInnerValues again */
                     }
  
                     node->mj_JoinState = EXEC_MJ_JOINTUPLES;
                 }
                 else if (compareResult > 0)
                 {
                     /* ----------------
                      *  if the new outer tuple didn't match the marked inner
                      *  tuple then we have a case like:
                      *
                      *           outer inner
                      *             4     4  - marked tuple
                      * new outer - 5     4
                      *             6     5  - inner tuple
                      *             7
                      *
                      *  which means that all subsequent outer tuples will be
                      *  larger than our marked inner tuples.  So we need not
                      *  revisit any of the marked tuples but can proceed to
                      *  look for a match to the current inner.  If there's
                      *  no more inners, no more matches are possible.
                      * ----------------
                      */
                     innerTupleSlot = node->mj_InnerTupleSlot;
  
                     /* reload comparison data for current inner */
                     switch (MJEvalInnerValues(node, innerTupleSlot))
                     {
                         case MJEVAL_MATCHABLE:
                             /* proceed to compare it to the current outer */
                             node->mj_JoinState = EXEC_MJ_SKIP_TEST;
                             break;
                         case MJEVAL_NONMATCHABLE:
  
                             /*
                              * current inner can't possibly match any outer;
                              * better to advance the inner scan than the
                              * outer.
                              */
                             node->mj_JoinState = EXEC_MJ_SKIPINNER_ADVANCE;
                             break;
                         case MJEVAL_ENDOFJOIN:
                             /* No more inner tuples */
                             if (doFillOuter)
                             {
                                 /*
                                  * Need to emit left-join tuples for remaining
                                  * outer tuples.
                                  */
                                 node->mj_JoinState = EXEC_MJ_ENDINNER;
                                 break;
                             }
                             /* Otherwise we're done. */
                             return NULL;
                     }
                 }
                 else            /* compareResult < 0 should not happen */
                     elog(ERROR, "mergejoin input data is out of order");
                 break;
  
                 /*----------------------------------------------------------
                  * EXEC_MJ_SKIP_TEST means compare tuples and if they do not
                  * match, skip whichever is lesser.
                  *
                  * For example:
                  *
                  *              outer inner
                  *                5     5
                  *                5     5
                  * outer tuple -  6     8  - inner tuple
                  *                7    12
                  *                8    14
                  *
                  * we have to advance the outer scan
                  * until we find the outer 8.
                  *
                  * On the other hand:
                  *
                  *              outer inner
                  *                5     5
                  *                5     5
                  * outer tuple - 12     8  - inner tuple
                  *               14    10
                  *               17    12
                  *
                  * we have to advance the inner scan
                  * until we find the inner 12.
                  *----------------------------------------------------------
                  */
             case EXEC_MJ_SKIP_TEST:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_SKIP_TEST\n");
  
                 /*
                  * before we advance, make sure the current tuples do not
                  * satisfy the mergeclauses.  If they do, then we update the
                  * marked tuple position and go join them.
                  */
                 compareResult = MJCompare(node);
                 MJ_DEBUG_COMPARE(compareResult);
  
                 if (compareResult == 0)
                 {
                     if (!node->mj_SkipMarkRestore)
                         ExecMarkPos(innerPlan);
  
                     MarkInnerTuple(node->mj_InnerTupleSlot, node);
  
                     node->mj_JoinState = EXEC_MJ_JOINTUPLES;
                 }
                 else if (compareResult < 0)
                     node->mj_JoinState = EXEC_MJ_SKIPOUTER_ADVANCE;
                 else
                     /* compareResult > 0 */
                     node->mj_JoinState = EXEC_MJ_SKIPINNER_ADVANCE;
                 break;
  
                 /*
                  * EXEC_MJ_SKIPOUTER_ADVANCE: advance over an outer tuple that
                  * is known not to join to any inner tuple.
                  *
                  * Before advancing, we check to see if we must emit an
                  * outer-join fill tuple for this outer tuple.
                  */
             case EXEC_MJ_SKIPOUTER_ADVANCE:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_SKIPOUTER_ADVANCE\n");
  
                 if (doFillOuter && !node->mj_MatchedOuter)
                 {
                     /*
                      * Generate a fake join tuple with nulls for the inner
                      * tuple, and return it if it passes the non-join quals.
                      */
                     TupleTableSlot *result;
  
                     node->mj_MatchedOuter = true;   /* do it only once */
  
                     result = MJFillOuter(node);
                     if (result)
                         return result;
                 }
  
                 /*
                  * now we get the next outer tuple, if any
                  */
                 outerTupleSlot = ExecProcNode(outerPlan);
                 node->mj_OuterTupleSlot = outerTupleSlot;
                 MJ_DEBUG_PROC_NODE(outerTupleSlot);
                 node->mj_MatchedOuter = false;
  
                 /* Compute join values and check for unmatchability */
                 switch (MJEvalOuterValues(node))
                 {
                     case MJEVAL_MATCHABLE:
                         /* Go test the new tuple against the current inner */
                         node->mj_JoinState = EXEC_MJ_SKIP_TEST;
                         break;
                     case MJEVAL_NONMATCHABLE:
                         /* Can't match, so fetch next outer tuple */
                         node->mj_JoinState = EXEC_MJ_SKIPOUTER_ADVANCE;
                         break;
                     case MJEVAL_ENDOFJOIN:
                         /* No more outer tuples */
                         MJ_printf("ExecMergeJoin: end of outer subplan\n");
                         innerTupleSlot = node->mj_InnerTupleSlot;
                         if (doFillInner && !TupIsNull(innerTupleSlot))
                         {
                             /*
                              * Need to emit right-join tuples for remaining
                              * inner tuples.
                              */
                             node->mj_JoinState = EXEC_MJ_ENDOUTER;
                             break;
                         }
                         /* Otherwise we're done. */
                         return NULL;
                 }
                 break;
  
                 /*
                  * EXEC_MJ_SKIPINNER_ADVANCE: advance over an inner tuple that
                  * is known not to join to any outer tuple.
                  *
                  * Before advancing, we check to see if we must emit an
                  * outer-join fill tuple for this inner tuple.
                  */
             case EXEC_MJ_SKIPINNER_ADVANCE:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_SKIPINNER_ADVANCE\n");
  
                 if (doFillInner && !node->mj_MatchedInner)
                 {
                     /*
                      * Generate a fake join tuple with nulls for the outer
                      * tuple, and return it if it passes the non-join quals.
                      */
                     TupleTableSlot *result;
  
                     node->mj_MatchedInner = true;   /* do it only once */
  
                     result = MJFillInner(node);
                     if (result)
                         return result;
                 }
  
                 /* Mark before advancing, if wanted */
                 if (node->mj_ExtraMarks)
                     ExecMarkPos(innerPlan);
  
                 /*
                  * now we get the next inner tuple, if any
                  */
                 innerTupleSlot = ExecProcNode(innerPlan);
                 node->mj_InnerTupleSlot = innerTupleSlot;
                 MJ_DEBUG_PROC_NODE(innerTupleSlot);
                 node->mj_MatchedInner = false;
  
                 /* Compute join values and check for unmatchability */
                 switch (MJEvalInnerValues(node, innerTupleSlot))
                 {
                     case MJEVAL_MATCHABLE:
                         /* proceed to compare it to the current outer */
                         node->mj_JoinState = EXEC_MJ_SKIP_TEST;
                         break;
                     case MJEVAL_NONMATCHABLE:
  
                         /*
                          * current inner can't possibly match any outer;
                          * better to advance the inner scan than the outer.
                          */
                         node->mj_JoinState = EXEC_MJ_SKIPINNER_ADVANCE;
                         break;
                     case MJEVAL_ENDOFJOIN:
                         /* No more inner tuples */
                         MJ_printf("ExecMergeJoin: end of inner subplan\n");
                         outerTupleSlot = node->mj_OuterTupleSlot;
                         if (doFillOuter && !TupIsNull(outerTupleSlot))
                         {
                             /*
                              * Need to emit left-join tuples for remaining
                              * outer tuples.
                              */
                             node->mj_JoinState = EXEC_MJ_ENDINNER;
                             break;
                         }
                         /* Otherwise we're done. */
                         return NULL;
                 }
                 break;
  
                 /*
                  * EXEC_MJ_ENDOUTER means we have run out of outer tuples, but
                  * are doing a right/right-anti/full join and therefore must
                  * null-fill any remaining unmatched inner tuples.
                  */
             case EXEC_MJ_ENDOUTER:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_ENDOUTER\n");
  
                 Assert(doFillInner);
  
                 if (!node->mj_MatchedInner)
                 {
                     /*
                      * Generate a fake join tuple with nulls for the outer
                      * tuple, and return it if it passes the non-join quals.
                      */
                     TupleTableSlot *result;
  
                     node->mj_MatchedInner = true;   /* do it only once */
  
                     result = MJFillInner(node);
                     if (result)
                         return result;
                 }
  
                 /* Mark before advancing, if wanted */
                 if (node->mj_ExtraMarks)
                     ExecMarkPos(innerPlan);
  
                 /*
                  * now we get the next inner tuple, if any
                  */
                 innerTupleSlot = ExecProcNode(innerPlan);
                 node->mj_InnerTupleSlot = innerTupleSlot;
                 MJ_DEBUG_PROC_NODE(innerTupleSlot);
                 node->mj_MatchedInner = false;
  
                 if (TupIsNull(innerTupleSlot))
                 {
                     MJ_printf("ExecMergeJoin: end of inner subplan\n");
                     return NULL;
                 }
  
                 /* Else remain in ENDOUTER state and process next tuple. */
                 break;
  
                 /*
                  * EXEC_MJ_ENDINNER means we have run out of inner tuples, but
                  * are doing a left/full join and therefore must null- fill
                  * any remaining unmatched outer tuples.
                  */
             case EXEC_MJ_ENDINNER:
                 MJ_printf("ExecMergeJoin: EXEC_MJ_ENDINNER\n");
  
                 Assert(doFillOuter);
  
                 if (!node->mj_MatchedOuter)
                 {
                     /*
                      * Generate a fake join tuple with nulls for the inner
                      * tuple, and return it if it passes the non-join quals.
                      */
                     TupleTableSlot *result;
  
                     node->mj_MatchedOuter = true;   /* do it only once */
  
                     result = MJFillOuter(node);
                     if (result)
                         return result;
                 }
  
                 /*
                  * now we get the next outer tuple, if any
                  */
                 outerTupleSlot = ExecProcNode(outerPlan);
                 node->mj_OuterTupleSlot = outerTupleSlot;
                 MJ_DEBUG_PROC_NODE(outerTupleSlot);
                 node->mj_MatchedOuter = false;
  
                 if (TupIsNull(outerTupleSlot))
                 {
                     MJ_printf("ExecMergeJoin: end of outer subplan\n");
                     return NULL;
                 }
  
                 /* Else remain in ENDINNER state and process next tuple. */
                 break;
  
                 /*
                  * broken state value?
                  */
             default:
                 elog(ERROR, "unrecognized mergejoin state: %d",
                      (int) node->mj_JoinState);
         }
     }
 }

References Assert, castNode, CHECK_FOR_INTERRUPTS, ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, elog, ERROR, EXEC_MJ_ENDINNER, EXEC_MJ_ENDOUTER, EXEC_MJ_INITIALIZE_INNER, EXEC_MJ_INITIALIZE_OUTER, EXEC_MJ_JOINTUPLES, EXEC_MJ_NEXTINNER, EXEC_MJ_NEXTOUTER, EXEC_MJ_SKIP_TEST, EXEC_MJ_SKIPINNER_ADVANCE, EXEC_MJ_SKIPOUTER_ADVANCE, EXEC_MJ_TESTOUTER, ExecMarkPos(), ExecProcNode(), ExecProject(), ExecQual(), ExecRestrPos(), innerPlan, innerPlanState, InstrCountFiltered1, InstrCountFiltered2, JOIN_ANTI, JOIN_RIGHT_ANTI, JoinState::joinqual, JoinState::jointype, MergeJoinState::js, MarkInnerTuple, MJ_DEBUG_COMPARE, MJ_DEBUG_PROC_NODE, MJ_DEBUG_QUAL, MJ_dump, MergeJoinState::mj_ExtraMarks, MergeJoinState::mj_FillInner, MergeJoinState::mj_FillOuter, MergeJoinState::mj_InnerTupleSlot, MergeJoinState::mj_JoinState, MergeJoinState::mj_MarkedTupleSlot, MergeJoinState::mj_MatchedInner, MergeJoinState::mj_MatchedOuter, MergeJoinState::mj_OuterTupleSlot, MJ_printf, MergeJoinState::mj_SkipMarkRestore, MJCompare(), MJEVAL_ENDOFJOIN, MJEVAL_MATCHABLE, MJEVAL_NONMATCHABLE, MJEvalInnerValues(), MJEvalOuterValues(), MJFillInner(), MJFillOuter(), outerPlan, outerPlanState, JoinState::ps, PlanState::ps_ExprContext, PlanState::ps_ProjInfo, PlanState::qual, ResetExprContext, JoinState::single_match, and TupIsNull.

Referenced by ExecInitMergeJoin().

◆ ExecReScanMergeJoin()

void ExecReScanMergeJoin ( MergeJoinState * node )

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

◆ MJCompare()

static int MJCompare ( MergeJoinState * mergestate )

static

Definition at line 391 of file nodeMergejoin.c.

 {
     int         result = 0;
     bool        nulleqnull = false;
     ExprContext *econtext = mergestate->js.ps.ps_ExprContext;
     int         i;
     MemoryContext oldContext;
  
     /*
      * Call the comparison functions in short-lived context, in case they leak
      * memory.
      */
     ResetExprContext(econtext);
  
     oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
  
     for (i = 0; i < mergestate->mj_NumClauses; i++)
     {
         MergeJoinClause clause = &mergestate->mj_Clauses[i];
  
         /*
          * Special case for NULL-vs-NULL, else use standard comparison.
          */
         if (clause->lisnull && clause->risnull)
         {
             nulleqnull = true;  /* NULL "=" NULL */
             continue;
         }
  
         result = ApplySortComparator(clause->ldatum, clause->lisnull,
                                      clause->rdatum, clause->risnull,
                                      &clause->ssup);
  
         if (result != 0)
             break;
     }
  
     /*
      * If we had any NULL-vs-NULL inputs, we do not want to report that the
      * tuples are equal.  Instead, if result is still 0, change it to +1. This
      * will result in advancing the inner side of the join.
      *
      * Likewise, if there was a constant-false joinqual, do not report
      * equality.  We have to check this as part of the mergequals, else the
      * rescan logic will do the wrong thing.
      */
     if (result == 0 &&
         (nulleqnull || mergestate->mj_ConstFalseJoin))
         result = 1;
  
     MemoryContextSwitchTo(oldContext);
  
     return result;
 }

References ApplySortComparator(), ExprContext::ecxt_per_tuple_memory, i, MergeJoinState::js, MergeJoinClauseData::ldatum, MergeJoinClauseData::lisnull, MemoryContextSwitchTo(), MergeJoinState::mj_Clauses, MergeJoinState::mj_ConstFalseJoin, MergeJoinState::mj_NumClauses, JoinState::ps, PlanState::ps_ExprContext, MergeJoinClauseData::rdatum, ResetExprContext, MergeJoinClauseData::risnull, and MergeJoinClauseData::ssup.

Referenced by ExecMergeJoin().

◆ MJEvalInnerValues()

static MJEvalResult MJEvalInnerValues	(	MergeJoinState *	mergestate,
		TupleTableSlot *	innerslot
	)

static

Definition at line 341 of file nodeMergejoin.c.

 {
     ExprContext *econtext = mergestate->mj_InnerEContext;
     MJEvalResult result = MJEVAL_MATCHABLE;
     int         i;
     MemoryContext oldContext;
  
     /* Check for end of inner subplan */
     if (TupIsNull(innerslot))
         return MJEVAL_ENDOFJOIN;
  
     ResetExprContext(econtext);
  
     oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
  
     econtext->ecxt_innertuple = innerslot;
  
     for (i = 0; i < mergestate->mj_NumClauses; i++)
     {
         MergeJoinClause clause = &mergestate->mj_Clauses[i];
  
         clause->rdatum = ExecEvalExpr(clause->rexpr, econtext,
                                       &clause->risnull);
         if (clause->risnull)
         {
             /* match is impossible; can we end the join early? */
             if (i == 0 && !clause->ssup.ssup_nulls_first &&
                 !mergestate->mj_FillInner)
                 result = MJEVAL_ENDOFJOIN;
             else if (result == MJEVAL_MATCHABLE)
                 result = MJEVAL_NONMATCHABLE;
         }
     }
  
     MemoryContextSwitchTo(oldContext);
  
     return result;
 }

References ExprContext::ecxt_innertuple, ExprContext::ecxt_per_tuple_memory, ExecEvalExpr(), i, MemoryContextSwitchTo(), MergeJoinState::mj_Clauses, MergeJoinState::mj_FillInner, MergeJoinState::mj_InnerEContext, MergeJoinState::mj_NumClauses, MJEVAL_ENDOFJOIN, MJEVAL_MATCHABLE, MJEVAL_NONMATCHABLE, MergeJoinClauseData::rdatum, ResetExprContext, MergeJoinClauseData::rexpr, MergeJoinClauseData::risnull, MergeJoinClauseData::ssup, SortSupportData::ssup_nulls_first, and TupIsNull.

Referenced by ExecMergeJoin().

◆ MJEvalOuterValues()

static MJEvalResult MJEvalOuterValues ( MergeJoinState * mergestate )

static

Definition at line 294 of file nodeMergejoin.c.

 {
     ExprContext *econtext = mergestate->mj_OuterEContext;
     MJEvalResult result = MJEVAL_MATCHABLE;
     int         i;
     MemoryContext oldContext;
  
     /* Check for end of outer subplan */
     if (TupIsNull(mergestate->mj_OuterTupleSlot))
         return MJEVAL_ENDOFJOIN;
  
     ResetExprContext(econtext);
  
     oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
  
     econtext->ecxt_outertuple = mergestate->mj_OuterTupleSlot;
  
     for (i = 0; i < mergestate->mj_NumClauses; i++)
     {
         MergeJoinClause clause = &mergestate->mj_Clauses[i];
  
         clause->ldatum = ExecEvalExpr(clause->lexpr, econtext,
                                       &clause->lisnull);
         if (clause->lisnull)
         {
             /* match is impossible; can we end the join early? */
             if (i == 0 && !clause->ssup.ssup_nulls_first &&
                 !mergestate->mj_FillOuter)
                 result = MJEVAL_ENDOFJOIN;
             else if (result == MJEVAL_MATCHABLE)
                 result = MJEVAL_NONMATCHABLE;
         }
     }
  
     MemoryContextSwitchTo(oldContext);
  
     return result;
 }

References ExprContext::ecxt_outertuple, ExprContext::ecxt_per_tuple_memory, ExecEvalExpr(), i, MergeJoinClauseData::ldatum, MergeJoinClauseData::lexpr, MergeJoinClauseData::lisnull, MemoryContextSwitchTo(), MergeJoinState::mj_Clauses, MergeJoinState::mj_FillOuter, MergeJoinState::mj_NumClauses, MergeJoinState::mj_OuterEContext, MergeJoinState::mj_OuterTupleSlot, MJEVAL_ENDOFJOIN, MJEVAL_MATCHABLE, MJEVAL_NONMATCHABLE, ResetExprContext, MergeJoinClauseData::ssup, SortSupportData::ssup_nulls_first, and TupIsNull.

Referenced by ExecMergeJoin().

◆ MJExamineQuals()

static MergeJoinClause MJExamineQuals	(	List *	mergeclauses,
		Oid *	mergefamilies,
		Oid *	mergecollations,
		int *	mergestrategies,
		bool *	mergenullsfirst,
		PlanState *	parent
	)

static

Definition at line 175 of file nodeMergejoin.c.

 {
     MergeJoinClause clauses;
     int         nClauses = list_length(mergeclauses);
     int         iClause;
     ListCell   *cl;
  
     clauses = (MergeJoinClause) palloc0(nClauses * sizeof(MergeJoinClauseData));
  
     iClause = 0;
     foreach(cl, mergeclauses)
     {
         OpExpr     *qual = (OpExpr *) lfirst(cl);
         MergeJoinClause clause = &clauses[iClause];
         Oid         opfamily = mergefamilies[iClause];
         Oid         collation = mergecollations[iClause];
         StrategyNumber opstrategy = mergestrategies[iClause];
         bool        nulls_first = mergenullsfirst[iClause];
         int         op_strategy;
         Oid         op_lefttype;
         Oid         op_righttype;
         Oid         sortfunc;
  
         if (!IsA(qual, OpExpr))
             elog(ERROR, "mergejoin clause is not an OpExpr");
  
         /*
          * Prepare the input expressions for execution.
          */
         clause->lexpr = ExecInitExpr((Expr *) linitial(qual->args), parent);
         clause->rexpr = ExecInitExpr((Expr *) lsecond(qual->args), parent);
  
         /* Set up sort support data */
         clause->ssup.ssup_cxt = CurrentMemoryContext;
         clause->ssup.ssup_collation = collation;
         if (opstrategy == BTLessStrategyNumber)
             clause->ssup.ssup_reverse = false;
         else if (opstrategy == BTGreaterStrategyNumber)
             clause->ssup.ssup_reverse = true;
         else                    /* planner screwed up */
             elog(ERROR, "unsupported mergejoin strategy %d", opstrategy);
         clause->ssup.ssup_nulls_first = nulls_first;
  
         /* Extract the operator's declared left/right datatypes */
         get_op_opfamily_properties(qual->opno, opfamily, false,
                                    &op_strategy,
                                    &op_lefttype,
                                    &op_righttype);
         if (op_strategy != BTEqualStrategyNumber)   /* should not happen */
             elog(ERROR, "cannot merge using non-equality operator %u",
                  qual->opno);
  
         /*
          * sortsupport routine must know if abbreviation optimization is
          * applicable in principle.  It is never applicable for merge joins
          * because there is no convenient opportunity to convert to
          * alternative representation.
          */
         clause->ssup.abbreviate = false;
  
         /* And get the matching support or comparison function */
         Assert(clause->ssup.comparator == NULL);
         sortfunc = get_opfamily_proc(opfamily,
                                      op_lefttype,
                                      op_righttype,
                                      BTSORTSUPPORT_PROC);
         if (OidIsValid(sortfunc))
         {
             /* The sort support function can provide a comparator */
             OidFunctionCall1(sortfunc, PointerGetDatum(&clause->ssup));
         }
         if (clause->ssup.comparator == NULL)
         {
             /* support not available, get comparison func */
             sortfunc = get_opfamily_proc(opfamily,
                                          op_lefttype,
                                          op_righttype,
                                          BTORDER_PROC);
             if (!OidIsValid(sortfunc))  /* should not happen */
                 elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
                      BTORDER_PROC, op_lefttype, op_righttype, opfamily);
             /* We'll use a shim to call the old-style btree comparator */
             PrepareSortSupportComparisonShim(sortfunc, &clause->ssup);
         }
  
         iClause++;
     }
  
     return clauses;
 }

References SortSupportData::abbreviate, OpExpr::args, Assert, BTEqualStrategyNumber, BTGreaterStrategyNumber, BTLessStrategyNumber, BTORDER_PROC, BTSORTSUPPORT_PROC, SortSupportData::comparator, CurrentMemoryContext, elog, ERROR, ExecInitExpr(), get_op_opfamily_properties(), get_opfamily_proc(), IsA, MergeJoinClauseData::lexpr, lfirst, linitial, list_length(), lsecond, OidFunctionCall1, OidIsValid, OpExpr::opno, palloc0(), PointerGetDatum(), PrepareSortSupportComparisonShim(), MergeJoinClauseData::rexpr, MergeJoinClauseData::ssup, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, SortSupportData::ssup_nulls_first, and SortSupportData::ssup_reverse.

Referenced by ExecInitMergeJoin().

◆ MJFillInner()

static TupleTableSlot* MJFillInner ( MergeJoinState * node )

static

Definition at line 483 of file nodeMergejoin.c.

 {
     ExprContext *econtext = node->js.ps.ps_ExprContext;
     ExprState  *otherqual = node->js.ps.qual;
  
     ResetExprContext(econtext);
  
     econtext->ecxt_outertuple = node->mj_NullOuterTupleSlot;
     econtext->ecxt_innertuple = node->mj_InnerTupleSlot;
  
     if (ExecQual(otherqual, econtext))
     {
         /*
          * qualification succeeded.  now form the desired projection tuple and
          * return the slot containing it.
          */
         MJ_printf("ExecMergeJoin: returning inner fill tuple\n");
  
         return ExecProject(node->js.ps.ps_ProjInfo);
     }
     else
         InstrCountFiltered2(node, 1);
  
     return NULL;
 }

References ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, ExecProject(), ExecQual(), InstrCountFiltered2, MergeJoinState::js, MergeJoinState::mj_InnerTupleSlot, MergeJoinState::mj_NullOuterTupleSlot, MJ_printf, JoinState::ps, PlanState::ps_ExprContext, PlanState::ps_ProjInfo, PlanState::qual, and ResetExprContext.

Referenced by ExecMergeJoin().

◆ MJFillOuter()

static TupleTableSlot* MJFillOuter ( MergeJoinState * node )

static

Definition at line 452 of file nodeMergejoin.c.

 {
     ExprContext *econtext = node->js.ps.ps_ExprContext;
     ExprState  *otherqual = node->js.ps.qual;
  
     ResetExprContext(econtext);
  
     econtext->ecxt_outertuple = node->mj_OuterTupleSlot;
     econtext->ecxt_innertuple = node->mj_NullInnerTupleSlot;
  
     if (ExecQual(otherqual, econtext))
     {
         /*
          * qualification succeeded.  now form the desired projection tuple and
          * return the slot containing it.
          */
         MJ_printf("ExecMergeJoin: returning outer fill tuple\n");
  
         return ExecProject(node->js.ps.ps_ProjInfo);
     }
     else
         InstrCountFiltered2(node, 1);
  
     return NULL;
 }

References ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, ExecProject(), ExecQual(), InstrCountFiltered2, MergeJoinState::js, MergeJoinState::mj_NullInnerTupleSlot, MergeJoinState::mj_OuterTupleSlot, MJ_printf, JoinState::ps, PlanState::ps_ExprContext, PlanState::ps_ProjInfo, PlanState::qual, and ResetExprContext.

Referenced by ExecMergeJoin().

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ EXEC_MJ_ENDINNER

◆ EXEC_MJ_ENDOUTER

◆ EXEC_MJ_INITIALIZE_INNER

◆ EXEC_MJ_INITIALIZE_OUTER

◆ EXEC_MJ_JOINTUPLES

◆ EXEC_MJ_NEXTINNER

◆ EXEC_MJ_NEXTOUTER

◆ EXEC_MJ_SKIP_TEST

◆ EXEC_MJ_SKIPINNER_ADVANCE

◆ EXEC_MJ_SKIPOUTER_ADVANCE

◆ EXEC_MJ_TESTOUTER

◆ MarkInnerTuple

Typedef Documentation

◆ MergeJoinClauseData

Enumeration Type Documentation

◆ MJEvalResult

Function Documentation

◆ check_constant_qual()

◆ ExecEndMergeJoin()

◆ ExecInitMergeJoin()

◆ ExecMergeJoin()

◆ ExecReScanMergeJoin()

◆ MJCompare()

◆ MJEvalInnerValues()

◆ MJEvalOuterValues()

◆ MJExamineQuals()

◆ MJFillInner()

◆ MJFillOuter()