LCOV - code coverage report
Current view: top level - src/backend/executor - nodeMergejoin.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 430 453 94.9 %
Date: 2024-07-19 16:11:31 Functions: 11 11 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * nodeMergejoin.c
       4             :  *    routines supporting merge joins
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/executor/nodeMergejoin.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : /*
      16             :  * INTERFACE ROUTINES
      17             :  *      ExecMergeJoin           mergejoin outer and inner relations.
      18             :  *      ExecInitMergeJoin       creates and initializes run time states
      19             :  *      ExecEndMergeJoin        cleans up the node.
      20             :  *
      21             :  * NOTES
      22             :  *
      23             :  *      Merge-join is done by joining the inner and outer tuples satisfying
      24             :  *      join clauses of the form ((= outerKey innerKey) ...).
      25             :  *      The join clause list is provided by the query planner and may contain
      26             :  *      more than one (= outerKey innerKey) clause (for composite sort key).
      27             :  *
      28             :  *      However, the query executor needs to know whether an outer
      29             :  *      tuple is "greater/smaller" than an inner tuple so that it can
      30             :  *      "synchronize" the two relations. For example, consider the following
      31             :  *      relations:
      32             :  *
      33             :  *              outer: (0 ^1 1 2 5 5 5 6 6 7)   current tuple: 1
      34             :  *              inner: (1 ^3 5 5 5 5 6)         current tuple: 3
      35             :  *
      36             :  *      To continue the merge-join, the executor needs to scan both inner
      37             :  *      and outer relations till the matching tuples 5. It needs to know
      38             :  *      that currently inner tuple 3 is "greater" than outer tuple 1 and
      39             :  *      therefore it should scan the outer relation first to find a
      40             :  *      matching tuple and so on.
      41             :  *
      42             :  *      Therefore, rather than directly executing the merge join clauses,
      43             :  *      we evaluate the left and right key expressions separately and then
      44             :  *      compare the columns one at a time (see MJCompare).  The planner
      45             :  *      passes us enough information about the sort ordering of the inputs
      46             :  *      to allow us to determine how to make the comparison.  We may use the
      47             :  *      appropriate btree comparison function, since Postgres' only notion
      48             :  *      of ordering is specified by btree opfamilies.
      49             :  *
      50             :  *
      51             :  *      Consider the above relations and suppose that the executor has
      52             :  *      just joined the first outer "5" with the last inner "5". The
      53             :  *      next step is of course to join the second outer "5" with all
      54             :  *      the inner "5's". This requires repositioning the inner "cursor"
      55             :  *      to point at the first inner "5". This is done by "marking" the
      56             :  *      first inner 5 so we can restore the "cursor" to it before joining
      57             :  *      with the second outer 5. The access method interface provides
      58             :  *      routines to mark and restore to a tuple.
      59             :  *
      60             :  *
      61             :  *      Essential operation of the merge join algorithm is as follows:
      62             :  *
      63             :  *      Join {
      64             :  *          get initial outer and inner tuples              INITIALIZE
      65             :  *          do forever {
      66             :  *              while (outer != inner) {                    SKIP_TEST
      67             :  *                  if (outer < inner)
      68             :  *                      advance outer                       SKIPOUTER_ADVANCE
      69             :  *                  else
      70             :  *                      advance inner                       SKIPINNER_ADVANCE
      71             :  *              }
      72             :  *              mark inner position                         SKIP_TEST
      73             :  *              do forever {
      74             :  *                  while (outer == inner) {
      75             :  *                      join tuples                         JOINTUPLES
      76             :  *                      advance inner position              NEXTINNER
      77             :  *                  }
      78             :  *                  advance outer position                  NEXTOUTER
      79             :  *                  if (outer == mark)                      TESTOUTER
      80             :  *                      restore inner position to mark      TESTOUTER
      81             :  *                  else
      82             :  *                      break   // return to top of outer loop
      83             :  *              }
      84             :  *          }
      85             :  *      }
      86             :  *
      87             :  *      The merge join operation is coded in the fashion
      88             :  *      of a state machine.  At each state, we do something and then
      89             :  *      proceed to another state.  This state is stored in the node's
      90             :  *      execution state information and is preserved across calls to
      91             :  *      ExecMergeJoin. -cim 10/31/89
      92             :  */
      93             : #include "postgres.h"
      94             : 
      95             : #include "access/nbtree.h"
      96             : #include "executor/execdebug.h"
      97             : #include "executor/nodeMergejoin.h"
      98             : #include "miscadmin.h"
      99             : #include "utils/lsyscache.h"
     100             : 
     101             : 
     102             : /*
     103             :  * States of the ExecMergeJoin state machine
     104             :  */
     105             : #define EXEC_MJ_INITIALIZE_OUTER        1
     106             : #define EXEC_MJ_INITIALIZE_INNER        2
     107             : #define EXEC_MJ_JOINTUPLES              3
     108             : #define EXEC_MJ_NEXTOUTER               4
     109             : #define EXEC_MJ_TESTOUTER               5
     110             : #define EXEC_MJ_NEXTINNER               6
     111             : #define EXEC_MJ_SKIP_TEST               7
     112             : #define EXEC_MJ_SKIPOUTER_ADVANCE       8
     113             : #define EXEC_MJ_SKIPINNER_ADVANCE       9
     114             : #define EXEC_MJ_ENDOUTER                10
     115             : #define EXEC_MJ_ENDINNER                11
     116             : 
     117             : /*
     118             :  * Runtime data for each mergejoin clause
     119             :  */
     120             : typedef struct MergeJoinClauseData
     121             : {
     122             :     /* Executable expression trees */
     123             :     ExprState  *lexpr;          /* left-hand (outer) input expression */
     124             :     ExprState  *rexpr;          /* right-hand (inner) input expression */
     125             : 
     126             :     /*
     127             :      * If we have a current left or right input tuple, the values of the
     128             :      * expressions are loaded into these fields:
     129             :      */
     130             :     Datum       ldatum;         /* current left-hand value */
     131             :     Datum       rdatum;         /* current right-hand value */
     132             :     bool        lisnull;        /* and their isnull flags */
     133             :     bool        risnull;
     134             : 
     135             :     /*
     136             :      * Everything we need to know to compare the left and right values is
     137             :      * stored here.
     138             :      */
     139             :     SortSupportData ssup;
     140             : }           MergeJoinClauseData;
     141             : 
     142             : /* Result type for MJEvalOuterValues and MJEvalInnerValues */
     143             : typedef enum
     144             : {
     145             :     MJEVAL_MATCHABLE,           /* normal, potentially matchable tuple */
     146             :     MJEVAL_NONMATCHABLE,        /* tuple cannot join because it has a null */
     147             :     MJEVAL_ENDOFJOIN,           /* end of input (physical or effective) */
     148             : } MJEvalResult;
     149             : 
     150             : 
     151             : #define MarkInnerTuple(innerTupleSlot, mergestate) \
     152             :     ExecCopySlot((mergestate)->mj_MarkedTupleSlot, (innerTupleSlot))
     153             : 
     154             : 
     155             : /*
     156             :  * MJExamineQuals
     157             :  *
     158             :  * This deconstructs the list of mergejoinable expressions, which is given
     159             :  * to us by the planner in the form of a list of "leftexpr = rightexpr"
     160             :  * expression trees in the order matching the sort columns of the inputs.
     161             :  * We build an array of MergeJoinClause structs containing the information
     162             :  * we will need at runtime.  Each struct essentially tells us how to compare
     163             :  * the two expressions from the original clause.
     164             :  *
     165             :  * In addition to the expressions themselves, the planner passes the btree
     166             :  * opfamily OID, collation OID, btree strategy number (BTLessStrategyNumber or
     167             :  * BTGreaterStrategyNumber), and nulls-first flag that identify the intended
     168             :  * sort ordering for each merge key.  The mergejoinable operator is an
     169             :  * equality operator in the opfamily, and the two inputs are guaranteed to be
     170             :  * ordered in either increasing or decreasing (respectively) order according
     171             :  * to the opfamily and collation, with nulls at the indicated end of the range.
     172             :  * This allows us to obtain the needed comparison function from the opfamily.
     173             :  */
     174             : static MergeJoinClause
     175        6798 : MJExamineQuals(List *mergeclauses,
     176             :                Oid *mergefamilies,
     177             :                Oid *mergecollations,
     178             :                int *mergestrategies,
     179             :                bool *mergenullsfirst,
     180             :                PlanState *parent)
     181             : {
     182             :     MergeJoinClause clauses;
     183        6798 :     int         nClauses = list_length(mergeclauses);
     184             :     int         iClause;
     185             :     ListCell   *cl;
     186             : 
     187        6798 :     clauses = (MergeJoinClause) palloc0(nClauses * sizeof(MergeJoinClauseData));
     188             : 
     189        6798 :     iClause = 0;
     190       14322 :     foreach(cl, mergeclauses)
     191             :     {
     192        7524 :         OpExpr     *qual = (OpExpr *) lfirst(cl);
     193        7524 :         MergeJoinClause clause = &clauses[iClause];
     194        7524 :         Oid         opfamily = mergefamilies[iClause];
     195        7524 :         Oid         collation = mergecollations[iClause];
     196        7524 :         StrategyNumber opstrategy = mergestrategies[iClause];
     197        7524 :         bool        nulls_first = mergenullsfirst[iClause];
     198             :         int         op_strategy;
     199             :         Oid         op_lefttype;
     200             :         Oid         op_righttype;
     201             :         Oid         sortfunc;
     202             : 
     203        7524 :         if (!IsA(qual, OpExpr))
     204           0 :             elog(ERROR, "mergejoin clause is not an OpExpr");
     205             : 
     206             :         /*
     207             :          * Prepare the input expressions for execution.
     208             :          */
     209        7524 :         clause->lexpr = ExecInitExpr((Expr *) linitial(qual->args), parent);
     210        7524 :         clause->rexpr = ExecInitExpr((Expr *) lsecond(qual->args), parent);
     211             : 
     212             :         /* Set up sort support data */
     213        7524 :         clause->ssup.ssup_cxt = CurrentMemoryContext;
     214        7524 :         clause->ssup.ssup_collation = collation;
     215        7524 :         if (opstrategy == BTLessStrategyNumber)
     216        7482 :             clause->ssup.ssup_reverse = false;
     217          42 :         else if (opstrategy == BTGreaterStrategyNumber)
     218          42 :             clause->ssup.ssup_reverse = true;
     219             :         else                    /* planner screwed up */
     220           0 :             elog(ERROR, "unsupported mergejoin strategy %d", opstrategy);
     221        7524 :         clause->ssup.ssup_nulls_first = nulls_first;
     222             : 
     223             :         /* Extract the operator's declared left/right datatypes */
     224        7524 :         get_op_opfamily_properties(qual->opno, opfamily, false,
     225             :                                    &op_strategy,
     226             :                                    &op_lefttype,
     227             :                                    &op_righttype);
     228        7524 :         if (op_strategy != BTEqualStrategyNumber)   /* should not happen */
     229           0 :             elog(ERROR, "cannot merge using non-equality operator %u",
     230             :                  qual->opno);
     231             : 
     232             :         /*
     233             :          * sortsupport routine must know if abbreviation optimization is
     234             :          * applicable in principle.  It is never applicable for merge joins
     235             :          * because there is no convenient opportunity to convert to
     236             :          * alternative representation.
     237             :          */
     238        7524 :         clause->ssup.abbreviate = false;
     239             : 
     240             :         /* And get the matching support or comparison function */
     241             :         Assert(clause->ssup.comparator == NULL);
     242        7524 :         sortfunc = get_opfamily_proc(opfamily,
     243             :                                      op_lefttype,
     244             :                                      op_righttype,
     245             :                                      BTSORTSUPPORT_PROC);
     246        7524 :         if (OidIsValid(sortfunc))
     247             :         {
     248             :             /* The sort support function can provide a comparator */
     249        7090 :             OidFunctionCall1(sortfunc, PointerGetDatum(&clause->ssup));
     250             :         }
     251        7524 :         if (clause->ssup.comparator == NULL)
     252             :         {
     253             :             /* support not available, get comparison func */
     254         434 :             sortfunc = get_opfamily_proc(opfamily,
     255             :                                          op_lefttype,
     256             :                                          op_righttype,
     257             :                                          BTORDER_PROC);
     258         434 :             if (!OidIsValid(sortfunc))  /* should not happen */
     259           0 :                 elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
     260             :                      BTORDER_PROC, op_lefttype, op_righttype, opfamily);
     261             :             /* We'll use a shim to call the old-style btree comparator */
     262         434 :             PrepareSortSupportComparisonShim(sortfunc, &clause->ssup);
     263             :         }
     264             : 
     265        7524 :         iClause++;
     266             :     }
     267             : 
     268        6798 :     return clauses;
     269             : }
     270             : 
     271             : /*
     272             :  * MJEvalOuterValues
     273             :  *
     274             :  * Compute the values of the mergejoined expressions for the current
     275             :  * outer tuple.  We also detect whether it's impossible for the current
     276             :  * outer tuple to match anything --- this is true if it yields a NULL
     277             :  * input, since we assume mergejoin operators are strict.  If the NULL
     278             :  * is in the first join column, and that column sorts nulls last, then
     279             :  * we can further conclude that no following tuple can match anything
     280             :  * either, since they must all have nulls in the first column.  However,
     281             :  * that case is only interesting if we're not in FillOuter mode, else
     282             :  * we have to visit all the tuples anyway.
     283             :  *
     284             :  * For the convenience of callers, we also make this routine responsible
     285             :  * for testing for end-of-input (null outer tuple), and returning
     286             :  * MJEVAL_ENDOFJOIN when that's seen.  This allows the same code to be used
     287             :  * for both real end-of-input and the effective end-of-input represented by
     288             :  * a first-column NULL.
     289             :  *
     290             :  * We evaluate the values in OuterEContext, which can be reset each
     291             :  * time we move to a new tuple.
     292             :  */
     293             : static MJEvalResult
     294     1846484 : MJEvalOuterValues(MergeJoinState *mergestate)
     295             : {
     296     1846484 :     ExprContext *econtext = mergestate->mj_OuterEContext;
     297     1846484 :     MJEvalResult result = MJEVAL_MATCHABLE;
     298             :     int         i;
     299             :     MemoryContext oldContext;
     300             : 
     301             :     /* Check for end of outer subplan */
     302     1846484 :     if (TupIsNull(mergestate->mj_OuterTupleSlot))
     303        2210 :         return MJEVAL_ENDOFJOIN;
     304             : 
     305     1844274 :     ResetExprContext(econtext);
     306             : 
     307     1844274 :     oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
     308             : 
     309     1844274 :     econtext->ecxt_outertuple = mergestate->mj_OuterTupleSlot;
     310             : 
     311     4003086 :     for (i = 0; i < mergestate->mj_NumClauses; i++)
     312             :     {
     313     2158812 :         MergeJoinClause clause = &mergestate->mj_Clauses[i];
     314             : 
     315     2158812 :         clause->ldatum = ExecEvalExpr(clause->lexpr, econtext,
     316             :                                       &clause->lisnull);
     317     2158812 :         if (clause->lisnull)
     318             :         {
     319             :             /* match is impossible; can we end the join early? */
     320          36 :             if (i == 0 && !clause->ssup.ssup_nulls_first &&
     321          12 :                 !mergestate->mj_FillOuter)
     322           0 :                 result = MJEVAL_ENDOFJOIN;
     323          36 :             else if (result == MJEVAL_MATCHABLE)
     324          30 :                 result = MJEVAL_NONMATCHABLE;
     325             :         }
     326             :     }
     327             : 
     328     1844274 :     MemoryContextSwitchTo(oldContext);
     329             : 
     330     1844274 :     return result;
     331             : }
     332             : 
     333             : /*
     334             :  * MJEvalInnerValues
     335             :  *
     336             :  * Same as above, but for the inner tuple.  Here, we have to be prepared
     337             :  * to load data from either the true current inner, or the marked inner,
     338             :  * so caller must tell us which slot to load from.
     339             :  */
     340             : static MJEvalResult
     341     4987914 : MJEvalInnerValues(MergeJoinState *mergestate, TupleTableSlot *innerslot)
     342             : {
     343     4987914 :     ExprContext *econtext = mergestate->mj_InnerEContext;
     344     4987914 :     MJEvalResult result = MJEVAL_MATCHABLE;
     345             :     int         i;
     346             :     MemoryContext oldContext;
     347             : 
     348             :     /* Check for end of inner subplan */
     349     4987914 :     if (TupIsNull(innerslot))
     350        7760 :         return MJEVAL_ENDOFJOIN;
     351             : 
     352     4980154 :     ResetExprContext(econtext);
     353             : 
     354     4980154 :     oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
     355             : 
     356     4980154 :     econtext->ecxt_innertuple = innerslot;
     357             : 
     358    10076464 :     for (i = 0; i < mergestate->mj_NumClauses; i++)
     359             :     {
     360     5096310 :         MergeJoinClause clause = &mergestate->mj_Clauses[i];
     361             : 
     362     5096310 :         clause->rdatum = ExecEvalExpr(clause->rexpr, econtext,
     363             :                                       &clause->risnull);
     364     5096310 :         if (clause->risnull)
     365             :         {
     366             :             /* match is impossible; can we end the join early? */
     367         192 :             if (i == 0 && !clause->ssup.ssup_nulls_first &&
     368         156 :                 !mergestate->mj_FillInner)
     369          84 :                 result = MJEVAL_ENDOFJOIN;
     370         108 :             else if (result == MJEVAL_MATCHABLE)
     371          96 :                 result = MJEVAL_NONMATCHABLE;
     372             :         }
     373             :     }
     374             : 
     375     4980154 :     MemoryContextSwitchTo(oldContext);
     376             : 
     377     4980154 :     return result;
     378             : }
     379             : 
     380             : /*
     381             :  * MJCompare
     382             :  *
     383             :  * Compare the mergejoinable values of the current two input tuples
     384             :  * and return 0 if they are equal (ie, the mergejoin equalities all
     385             :  * succeed), >0 if outer > inner, <0 if outer < inner.
     386             :  *
     387             :  * MJEvalOuterValues and MJEvalInnerValues must already have been called
     388             :  * for the current outer and inner tuples, respectively.
     389             :  */
     390             : static int
     391     5914724 : MJCompare(MergeJoinState *mergestate)
     392             : {
     393     5914724 :     int         result = 0;
     394     5914724 :     bool        nulleqnull = false;
     395     5914724 :     ExprContext *econtext = mergestate->js.ps.ps_ExprContext;
     396             :     int         i;
     397             :     MemoryContext oldContext;
     398             : 
     399             :     /*
     400             :      * Call the comparison functions in short-lived context, in case they leak
     401             :      * memory.
     402             :      */
     403     5914724 :     ResetExprContext(econtext);
     404             : 
     405     5914724 :     oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
     406             : 
     407     9190998 :     for (i = 0; i < mergestate->mj_NumClauses; i++)
     408             :     {
     409     6026514 :         MergeJoinClause clause = &mergestate->mj_Clauses[i];
     410             : 
     411             :         /*
     412             :          * Special case for NULL-vs-NULL, else use standard comparison.
     413             :          */
     414     6026514 :         if (clause->lisnull && clause->risnull)
     415             :         {
     416           0 :             nulleqnull = true;  /* NULL "=" NULL */
     417           0 :             continue;
     418             :         }
     419             : 
     420     6026514 :         result = ApplySortComparator(clause->ldatum, clause->lisnull,
     421     6026514 :                                      clause->rdatum, clause->risnull,
     422     6026514 :                                      &clause->ssup);
     423             : 
     424     6026514 :         if (result != 0)
     425     2750240 :             break;
     426             :     }
     427             : 
     428             :     /*
     429             :      * If we had any NULL-vs-NULL inputs, we do not want to report that the
     430             :      * tuples are equal.  Instead, if result is still 0, change it to +1. This
     431             :      * will result in advancing the inner side of the join.
     432             :      *
     433             :      * Likewise, if there was a constant-false joinqual, do not report
     434             :      * equality.  We have to check this as part of the mergequals, else the
     435             :      * rescan logic will do the wrong thing.
     436             :      */
     437     5914724 :     if (result == 0 &&
     438     3164484 :         (nulleqnull || mergestate->mj_ConstFalseJoin))
     439          48 :         result = 1;
     440             : 
     441     5914724 :     MemoryContextSwitchTo(oldContext);
     442             : 
     443     5914724 :     return result;
     444             : }
     445             : 
     446             : 
     447             : /*
     448             :  * Generate a fake join tuple with nulls for the inner tuple,
     449             :  * and return it if it passes the non-join quals.
     450             :  */
     451             : static TupleTableSlot *
     452      278676 : MJFillOuter(MergeJoinState *node)
     453             : {
     454      278676 :     ExprContext *econtext = node->js.ps.ps_ExprContext;
     455      278676 :     ExprState  *otherqual = node->js.ps.qual;
     456             : 
     457      278676 :     ResetExprContext(econtext);
     458             : 
     459      278676 :     econtext->ecxt_outertuple = node->mj_OuterTupleSlot;
     460      278676 :     econtext->ecxt_innertuple = node->mj_NullInnerTupleSlot;
     461             : 
     462      278676 :     if (ExecQual(otherqual, econtext))
     463             :     {
     464             :         /*
     465             :          * qualification succeeded.  now form the desired projection tuple and
     466             :          * return the slot containing it.
     467             :          */
     468             :         MJ_printf("ExecMergeJoin: returning outer fill tuple\n");
     469             : 
     470      275272 :         return ExecProject(node->js.ps.ps_ProjInfo);
     471             :     }
     472             :     else
     473        3404 :         InstrCountFiltered2(node, 1);
     474             : 
     475        3404 :     return NULL;
     476             : }
     477             : 
     478             : /*
     479             :  * Generate a fake join tuple with nulls for the outer tuple,
     480             :  * and return it if it passes the non-join quals.
     481             :  */
     482             : static TupleTableSlot *
     483        4482 : MJFillInner(MergeJoinState *node)
     484             : {
     485        4482 :     ExprContext *econtext = node->js.ps.ps_ExprContext;
     486        4482 :     ExprState  *otherqual = node->js.ps.qual;
     487             : 
     488        4482 :     ResetExprContext(econtext);
     489             : 
     490        4482 :     econtext->ecxt_outertuple = node->mj_NullOuterTupleSlot;
     491        4482 :     econtext->ecxt_innertuple = node->mj_InnerTupleSlot;
     492             : 
     493        4482 :     if (ExecQual(otherqual, econtext))
     494             :     {
     495             :         /*
     496             :          * qualification succeeded.  now form the desired projection tuple and
     497             :          * return the slot containing it.
     498             :          */
     499             :         MJ_printf("ExecMergeJoin: returning inner fill tuple\n");
     500             : 
     501        3900 :         return ExecProject(node->js.ps.ps_ProjInfo);
     502             :     }
     503             :     else
     504         582 :         InstrCountFiltered2(node, 1);
     505             : 
     506         582 :     return NULL;
     507             : }
     508             : 
     509             : 
     510             : /*
     511             :  * Check that a qual condition is constant true or constant false.
     512             :  * If it is constant false (or null), set *is_const_false to true.
     513             :  *
     514             :  * Constant true would normally be represented by a NIL list, but we allow an
     515             :  * actual bool Const as well.  We do expect that the planner will have thrown
     516             :  * away any non-constant terms that have been ANDed with a constant false.
     517             :  */
     518             : static bool
     519        3168 : check_constant_qual(List *qual, bool *is_const_false)
     520             : {
     521             :     ListCell   *lc;
     522             : 
     523        3180 :     foreach(lc, qual)
     524             :     {
     525          12 :         Const      *con = (Const *) lfirst(lc);
     526             : 
     527          12 :         if (!con || !IsA(con, Const))
     528           0 :             return false;
     529          12 :         if (con->constisnull || !DatumGetBool(con->constvalue))
     530          12 :             *is_const_false = true;
     531             :     }
     532        3168 :     return true;
     533             : }
     534             : 
     535             : 
     536             : /* ----------------------------------------------------------------
     537             :  *      ExecMergeTupleDump
     538             :  *
     539             :  *      This function is called through the MJ_dump() macro
     540             :  *      when EXEC_MERGEJOINDEBUG is defined
     541             :  * ----------------------------------------------------------------
     542             :  */
     543             : #ifdef EXEC_MERGEJOINDEBUG
     544             : 
     545             : static void
     546             : ExecMergeTupleDumpOuter(MergeJoinState *mergestate)
     547             : {
     548             :     TupleTableSlot *outerSlot = mergestate->mj_OuterTupleSlot;
     549             : 
     550             :     printf("==== outer tuple ====\n");
     551             :     if (TupIsNull(outerSlot))
     552             :         printf("(nil)\n");
     553             :     else
     554             :         MJ_debugtup(outerSlot);
     555             : }
     556             : 
     557             : static void
     558             : ExecMergeTupleDumpInner(MergeJoinState *mergestate)
     559             : {
     560             :     TupleTableSlot *innerSlot = mergestate->mj_InnerTupleSlot;
     561             : 
     562             :     printf("==== inner tuple ====\n");
     563             :     if (TupIsNull(innerSlot))
     564             :         printf("(nil)\n");
     565             :     else
     566             :         MJ_debugtup(innerSlot);
     567             : }
     568             : 
     569             : static void
     570             : ExecMergeTupleDumpMarked(MergeJoinState *mergestate)
     571             : {
     572             :     TupleTableSlot *markedSlot = mergestate->mj_MarkedTupleSlot;
     573             : 
     574             :     printf("==== marked tuple ====\n");
     575             :     if (TupIsNull(markedSlot))
     576             :         printf("(nil)\n");
     577             :     else
     578             :         MJ_debugtup(markedSlot);
     579             : }
     580             : 
     581             : static void
     582             : ExecMergeTupleDump(MergeJoinState *mergestate)
     583             : {
     584             :     printf("******** ExecMergeTupleDump ********\n");
     585             : 
     586             :     ExecMergeTupleDumpOuter(mergestate);
     587             :     ExecMergeTupleDumpInner(mergestate);
     588             :     ExecMergeTupleDumpMarked(mergestate);
     589             : 
     590             :     printf("********\n");
     591             : }
     592             : #endif
     593             : 
     594             : /* ----------------------------------------------------------------
     595             :  *      ExecMergeJoin
     596             :  * ----------------------------------------------------------------
     597             :  */
     598             : static TupleTableSlot *
     599     2656682 : ExecMergeJoin(PlanState *pstate)
     600             : {
     601     2656682 :     MergeJoinState *node = castNode(MergeJoinState, pstate);
     602             :     ExprState  *joinqual;
     603             :     ExprState  *otherqual;
     604             :     bool        qualResult;
     605             :     int         compareResult;
     606             :     PlanState  *innerPlan;
     607             :     TupleTableSlot *innerTupleSlot;
     608             :     PlanState  *outerPlan;
     609             :     TupleTableSlot *outerTupleSlot;
     610             :     ExprContext *econtext;
     611             :     bool        doFillOuter;
     612             :     bool        doFillInner;
     613             : 
     614     2656682 :     CHECK_FOR_INTERRUPTS();
     615             : 
     616             :     /*
     617             :      * get information from node
     618             :      */
     619     2656682 :     innerPlan = innerPlanState(node);
     620     2656682 :     outerPlan = outerPlanState(node);
     621     2656682 :     econtext = node->js.ps.ps_ExprContext;
     622     2656682 :     joinqual = node->js.joinqual;
     623     2656682 :     otherqual = node->js.ps.qual;
     624     2656682 :     doFillOuter = node->mj_FillOuter;
     625     2656682 :     doFillInner = node->mj_FillInner;
     626             : 
     627             :     /*
     628             :      * Reset per-tuple memory context to free any expression evaluation
     629             :      * storage allocated in the previous tuple cycle.
     630             :      */
     631     2656682 :     ResetExprContext(econtext);
     632             : 
     633             :     /*
     634             :      * ok, everything is setup.. let's go to work
     635             :      */
     636             :     for (;;)
     637             :     {
     638             :         MJ_dump(node);
     639             : 
     640             :         /*
     641             :          * get the current state of the join and do things accordingly.
     642             :          */
     643    11522262 :         switch (node->mj_JoinState)
     644             :         {
     645             :                 /*
     646             :                  * EXEC_MJ_INITIALIZE_OUTER means that this is the first time
     647             :                  * ExecMergeJoin() has been called and so we have to fetch the
     648             :                  * first matchable tuple for both outer and inner subplans. We
     649             :                  * do the outer side in INITIALIZE_OUTER state, then advance
     650             :                  * to INITIALIZE_INNER state for the inner subplan.
     651             :                  */
     652        6500 :             case EXEC_MJ_INITIALIZE_OUTER:
     653             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_INITIALIZE_OUTER\n");
     654             : 
     655        6500 :                 outerTupleSlot = ExecProcNode(outerPlan);
     656        6500 :                 node->mj_OuterTupleSlot = outerTupleSlot;
     657             : 
     658             :                 /* Compute join values and check for unmatchability */
     659        6500 :                 switch (MJEvalOuterValues(node))
     660             :                 {
     661        6288 :                     case MJEVAL_MATCHABLE:
     662             :                         /* OK to go get the first inner tuple */
     663        6288 :                         node->mj_JoinState = EXEC_MJ_INITIALIZE_INNER;
     664        6288 :                         break;
     665          12 :                     case MJEVAL_NONMATCHABLE:
     666             :                         /* Stay in same state to fetch next outer tuple */
     667          12 :                         if (doFillOuter)
     668             :                         {
     669             :                             /*
     670             :                              * Generate a fake join tuple with nulls for the
     671             :                              * inner tuple, and return it if it passes the
     672             :                              * non-join quals.
     673             :                              */
     674             :                             TupleTableSlot *result;
     675             : 
     676          12 :                             result = MJFillOuter(node);
     677          12 :                             if (result)
     678          12 :                                 return result;
     679             :                         }
     680           0 :                         break;
     681         200 :                     case MJEVAL_ENDOFJOIN:
     682             :                         /* No more outer tuples */
     683             :                         MJ_printf("ExecMergeJoin: nothing in outer subplan\n");
     684         200 :                         if (doFillInner)
     685             :                         {
     686             :                             /*
     687             :                              * Need to emit right-join tuples for remaining
     688             :                              * inner tuples. We set MatchedInner = true to
     689             :                              * force the ENDOUTER state to advance inner.
     690             :                              */
     691         138 :                             node->mj_JoinState = EXEC_MJ_ENDOUTER;
     692         138 :                             node->mj_MatchedInner = true;
     693         138 :                             break;
     694             :                         }
     695             :                         /* Otherwise we're done. */
     696          62 :                         return NULL;
     697             :                 }
     698        6426 :                 break;
     699             : 
     700        6300 :             case EXEC_MJ_INITIALIZE_INNER:
     701             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_INITIALIZE_INNER\n");
     702             : 
     703        6300 :                 innerTupleSlot = ExecProcNode(innerPlan);
     704        6300 :                 node->mj_InnerTupleSlot = innerTupleSlot;
     705             : 
     706             :                 /* Compute join values and check for unmatchability */
     707        6300 :                 switch (MJEvalInnerValues(node, innerTupleSlot))
     708             :                 {
     709        5092 :                     case MJEVAL_MATCHABLE:
     710             : 
     711             :                         /*
     712             :                          * OK, we have the initial tuples.  Begin by skipping
     713             :                          * non-matching tuples.
     714             :                          */
     715        5092 :                         node->mj_JoinState = EXEC_MJ_SKIP_TEST;
     716        5092 :                         break;
     717          24 :                     case MJEVAL_NONMATCHABLE:
     718             :                         /* Mark before advancing, if wanted */
     719          24 :                         if (node->mj_ExtraMarks)
     720           0 :                             ExecMarkPos(innerPlan);
     721             :                         /* Stay in same state to fetch next inner tuple */
     722          24 :                         if (doFillInner)
     723             :                         {
     724             :                             /*
     725             :                              * Generate a fake join tuple with nulls for the
     726             :                              * outer tuple, and return it if it passes the
     727             :                              * non-join quals.
     728             :                              */
     729             :                             TupleTableSlot *result;
     730             : 
     731          24 :                             result = MJFillInner(node);
     732          24 :                             if (result)
     733          24 :                                 return result;
     734             :                         }
     735           0 :                         break;
     736        1184 :                     case MJEVAL_ENDOFJOIN:
     737             :                         /* No more inner tuples */
     738             :                         MJ_printf("ExecMergeJoin: nothing in inner subplan\n");
     739        1184 :                         if (doFillOuter)
     740             :                         {
     741             :                             /*
     742             :                              * Need to emit left-join tuples for all outer
     743             :                              * tuples, including the one we just fetched.  We
     744             :                              * set MatchedOuter = false to force the ENDINNER
     745             :                              * state to emit first tuple before advancing
     746             :                              * outer.
     747             :                              */
     748          36 :                             node->mj_JoinState = EXEC_MJ_ENDINNER;
     749          36 :                             node->mj_MatchedOuter = false;
     750          36 :                             break;
     751             :                         }
     752             :                         /* Otherwise we're done. */
     753        1148 :                         return NULL;
     754             :                 }
     755        5128 :                 break;
     756             : 
     757             :                 /*
     758             :                  * EXEC_MJ_JOINTUPLES means we have two tuples which satisfied
     759             :                  * the merge clause so we join them and then proceed to get
     760             :                  * the next inner tuple (EXEC_MJ_NEXTINNER).
     761             :                  */
     762     3164436 :             case EXEC_MJ_JOINTUPLES:
     763             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_JOINTUPLES\n");
     764             : 
     765             :                 /*
     766             :                  * Set the next state machine state.  The right things will
     767             :                  * happen whether we return this join tuple or just fall
     768             :                  * through to continue the state machine execution.
     769             :                  */
     770     3164436 :                 node->mj_JoinState = EXEC_MJ_NEXTINNER;
     771             : 
     772             :                 /*
     773             :                  * Check the extra qual conditions to see if we actually want
     774             :                  * to return this join tuple.  If not, can proceed with merge.
     775             :                  * We must distinguish the additional joinquals (which must
     776             :                  * pass to consider the tuples "matched" for outer-join logic)
     777             :                  * from the otherquals (which must pass before we actually
     778             :                  * return the tuple).
     779             :                  *
     780             :                  * We don't bother with a ResetExprContext here, on the
     781             :                  * assumption that we just did one while checking the merge
     782             :                  * qual.  One per tuple should be sufficient.  We do have to
     783             :                  * set up the econtext links to the tuples for ExecQual to
     784             :                  * use.
     785             :                  */
     786     3164436 :                 outerTupleSlot = node->mj_OuterTupleSlot;
     787     3164436 :                 econtext->ecxt_outertuple = outerTupleSlot;
     788     3164436 :                 innerTupleSlot = node->mj_InnerTupleSlot;
     789     3164436 :                 econtext->ecxt_innertuple = innerTupleSlot;
     790             : 
     791     3604126 :                 qualResult = (joinqual == NULL ||
     792      439690 :                               ExecQual(joinqual, econtext));
     793             :                 MJ_DEBUG_QUAL(joinqual, qualResult);
     794             : 
     795     3164436 :                 if (qualResult)
     796             :                 {
     797     2727026 :                     node->mj_MatchedOuter = true;
     798     2727026 :                     node->mj_MatchedInner = true;
     799             : 
     800             :                     /* In an antijoin, we never return a matched tuple */
     801     2727026 :                     if (node->js.jointype == JOIN_ANTI)
     802             :                     {
     803       37006 :                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
     804       37006 :                         break;
     805             :                     }
     806             : 
     807             :                     /*
     808             :                      * If we only need to consider the first matching inner
     809             :                      * tuple, then advance to next outer tuple after we've
     810             :                      * processed this one.
     811             :                      */
     812     2690020 :                     if (node->js.single_match)
     813       29874 :                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
     814             : 
     815             :                     /*
     816             :                      * In a right-antijoin, we never return a matched tuple.
     817             :                      * If it's not an inner_unique join, we need to stay on
     818             :                      * the current outer tuple to continue scanning the inner
     819             :                      * side for matches.
     820             :                      */
     821     2690020 :                     if (node->js.jointype == JOIN_RIGHT_ANTI)
     822       40144 :                         break;
     823             : 
     824     2933066 :                     qualResult = (otherqual == NULL ||
     825      283190 :                                   ExecQual(otherqual, econtext));
     826             :                     MJ_DEBUG_QUAL(otherqual, qualResult);
     827             : 
     828     2649876 :                     if (qualResult)
     829             :                     {
     830             :                         /*
     831             :                          * qualification succeeded.  now form the desired
     832             :                          * projection tuple and return the slot containing it.
     833             :                          */
     834             :                         MJ_printf("ExecMergeJoin: returning tuple\n");
     835             : 
     836     2371110 :                         return ExecProject(node->js.ps.ps_ProjInfo);
     837             :                     }
     838             :                     else
     839      278766 :                         InstrCountFiltered2(node, 1);
     840             :                 }
     841             :                 else
     842      437410 :                     InstrCountFiltered1(node, 1);
     843      716176 :                 break;
     844             : 
     845             :                 /*
     846             :                  * EXEC_MJ_NEXTINNER means advance the inner scan to the next
     847             :                  * tuple. If the tuple is not nil, we then proceed to test it
     848             :                  * against the join qualification.
     849             :                  *
     850             :                  * Before advancing, we check to see if we must emit an
     851             :                  * outer-join fill tuple for this inner tuple.
     852             :                  */
     853     3097552 :             case EXEC_MJ_NEXTINNER:
     854             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_NEXTINNER\n");
     855             : 
     856     3097552 :                 if (doFillInner && !node->mj_MatchedInner)
     857             :                 {
     858             :                     /*
     859             :                      * Generate a fake join tuple with nulls for the outer
     860             :                      * tuple, and return it if it passes the non-join quals.
     861             :                      */
     862             :                     TupleTableSlot *result;
     863             : 
     864           0 :                     node->mj_MatchedInner = true;    /* do it only once */
     865             : 
     866           0 :                     result = MJFillInner(node);
     867           0 :                     if (result)
     868           0 :                         return result;
     869             :                 }
     870             : 
     871             :                 /*
     872             :                  * now we get the next inner tuple, if any.  If there's none,
     873             :                  * advance to next outer tuple (which may be able to join to
     874             :                  * previously marked tuples).
     875             :                  *
     876             :                  * NB: must NOT do "extraMarks" here, since we may need to
     877             :                  * return to previously marked tuples.
     878             :                  */
     879     3097552 :                 innerTupleSlot = ExecProcNode(innerPlan);
     880     3097552 :                 node->mj_InnerTupleSlot = innerTupleSlot;
     881             :                 MJ_DEBUG_PROC_NODE(innerTupleSlot);
     882     3097552 :                 node->mj_MatchedInner = false;
     883             : 
     884             :                 /* Compute join values and check for unmatchability */
     885     3097552 :                 switch (MJEvalInnerValues(node, innerTupleSlot))
     886             :                 {
     887     3093882 :                     case MJEVAL_MATCHABLE:
     888             : 
     889             :                         /*
     890             :                          * Test the new inner tuple to see if it matches
     891             :                          * outer.
     892             :                          *
     893             :                          * If they do match, then we join them and move on to
     894             :                          * the next inner tuple (EXEC_MJ_JOINTUPLES).
     895             :                          *
     896             :                          * If they do not match then advance to next outer
     897             :                          * tuple.
     898             :                          */
     899     3093882 :                         compareResult = MJCompare(node);
     900             :                         MJ_DEBUG_COMPARE(compareResult);
     901             : 
     902     3093882 :                         if (compareResult == 0)
     903     2259532 :                             node->mj_JoinState = EXEC_MJ_JOINTUPLES;
     904      834350 :                         else if (compareResult < 0)
     905      834350 :                             node->mj_JoinState = EXEC_MJ_NEXTOUTER;
     906             :                         else    /* compareResult > 0 should not happen */
     907           0 :                             elog(ERROR, "mergejoin input data is out of order");
     908     3093882 :                         break;
     909          24 :                     case MJEVAL_NONMATCHABLE:
     910             : 
     911             :                         /*
     912             :                          * It contains a NULL and hence can't match any outer
     913             :                          * tuple, so we can skip the comparison and assume the
     914             :                          * new tuple is greater than current outer.
     915             :                          */
     916          24 :                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
     917          24 :                         break;
     918        3646 :                     case MJEVAL_ENDOFJOIN:
     919             : 
     920             :                         /*
     921             :                          * No more inner tuples.  However, this might be only
     922             :                          * effective and not physical end of inner plan, so
     923             :                          * force mj_InnerTupleSlot to null to make sure we
     924             :                          * don't fetch more inner tuples.  (We need this hack
     925             :                          * because we are not transiting to a state where the
     926             :                          * inner plan is assumed to be exhausted.)
     927             :                          */
     928        3646 :                         node->mj_InnerTupleSlot = NULL;
     929        3646 :                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
     930        3646 :                         break;
     931             :                 }
     932     3097552 :                 break;
     933             : 
     934             :                 /*-------------------------------------------
     935             :                  * EXEC_MJ_NEXTOUTER means
     936             :                  *
     937             :                  *              outer inner
     938             :                  * outer tuple -  5     5  - marked tuple
     939             :                  *                5     5
     940             :                  *                6     6  - inner tuple
     941             :                  *                7     7
     942             :                  *
     943             :                  * we know we just bumped into the
     944             :                  * first inner tuple > current outer tuple (or possibly
     945             :                  * the end of the inner stream)
     946             :                  * so get a new outer tuple and then
     947             :                  * proceed to test it against the marked tuple
     948             :                  * (EXEC_MJ_TESTOUTER)
     949             :                  *
     950             :                  * Before advancing, we check to see if we must emit an
     951             :                  * outer-join fill tuple for this outer tuple.
     952             :                  *------------------------------------------------
     953             :                  */
     954      968260 :             case EXEC_MJ_NEXTOUTER:
     955             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_NEXTOUTER\n");
     956             : 
     957      968260 :                 if (doFillOuter && !node->mj_MatchedOuter)
     958             :                 {
     959             :                     /*
     960             :                      * Generate a fake join tuple with nulls for the inner
     961             :                      * tuple, and return it if it passes the non-join quals.
     962             :                      */
     963             :                     TupleTableSlot *result;
     964             : 
     965       63406 :                     node->mj_MatchedOuter = true;    /* do it only once */
     966             : 
     967       63406 :                     result = MJFillOuter(node);
     968       63406 :                     if (result)
     969       63406 :                         return result;
     970             :                 }
     971             : 
     972             :                 /*
     973             :                  * now we get the next outer tuple, if any
     974             :                  */
     975      904854 :                 outerTupleSlot = ExecProcNode(outerPlan);
     976      904854 :                 node->mj_OuterTupleSlot = outerTupleSlot;
     977             :                 MJ_DEBUG_PROC_NODE(outerTupleSlot);
     978      904854 :                 node->mj_MatchedOuter = false;
     979             : 
     980             :                 /* Compute join values and check for unmatchability */
     981      904854 :                 switch (MJEvalOuterValues(node))
     982             :                 {
     983      903206 :                     case MJEVAL_MATCHABLE:
     984             :                         /* Go test the new tuple against the marked tuple */
     985      903206 :                         node->mj_JoinState = EXEC_MJ_TESTOUTER;
     986      903206 :                         break;
     987          12 :                     case MJEVAL_NONMATCHABLE:
     988             :                         /* Can't match, so fetch next outer tuple */
     989          12 :                         node->mj_JoinState = EXEC_MJ_NEXTOUTER;
     990          12 :                         break;
     991        1636 :                     case MJEVAL_ENDOFJOIN:
     992             :                         /* No more outer tuples */
     993             :                         MJ_printf("ExecMergeJoin: end of outer subplan\n");
     994        1636 :                         innerTupleSlot = node->mj_InnerTupleSlot;
     995        1636 :                         if (doFillInner && !TupIsNull(innerTupleSlot))
     996             :                         {
     997             :                             /*
     998             :                              * Need to emit right-join tuples for remaining
     999             :                              * inner tuples.
    1000             :                              */
    1001          48 :                             node->mj_JoinState = EXEC_MJ_ENDOUTER;
    1002          48 :                             break;
    1003             :                         }
    1004             :                         /* Otherwise we're done. */
    1005        1588 :                         return NULL;
    1006             :                 }
    1007      903266 :                 break;
    1008             : 
    1009             :                 /*--------------------------------------------------------
    1010             :                  * EXEC_MJ_TESTOUTER If the new outer tuple and the marked
    1011             :                  * tuple satisfy the merge clause then we know we have
    1012             :                  * duplicates in the outer scan so we have to restore the
    1013             :                  * inner scan to the marked tuple and proceed to join the
    1014             :                  * new outer tuple with the inner tuples.
    1015             :                  *
    1016             :                  * This is the case when
    1017             :                  *                        outer inner
    1018             :                  *                          4     5  - marked tuple
    1019             :                  *           outer tuple -  5     5
    1020             :                  *       new outer tuple -  5     5
    1021             :                  *                          6     8  - inner tuple
    1022             :                  *                          7    12
    1023             :                  *
    1024             :                  *              new outer tuple == marked tuple
    1025             :                  *
    1026             :                  * If the outer tuple fails the test, then we are done
    1027             :                  * with the marked tuples, and we have to look for a
    1028             :                  * match to the current inner tuple.  So we will
    1029             :                  * proceed to skip outer tuples until outer >= inner
    1030             :                  * (EXEC_MJ_SKIP_TEST).
    1031             :                  *
    1032             :                  *      This is the case when
    1033             :                  *
    1034             :                  *                        outer inner
    1035             :                  *                          5     5  - marked tuple
    1036             :                  *           outer tuple -  5     5
    1037             :                  *       new outer tuple -  6     8  - inner tuple
    1038             :                  *                          7    12
    1039             :                  *
    1040             :                  *              new outer tuple > marked tuple
    1041             :                  *
    1042             :                  *---------------------------------------------------------
    1043             :                  */
    1044      903206 :             case EXEC_MJ_TESTOUTER:
    1045             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_TESTOUTER\n");
    1046             : 
    1047             :                 /*
    1048             :                  * Here we must compare the outer tuple with the marked inner
    1049             :                  * tuple.  (We can ignore the result of MJEvalInnerValues,
    1050             :                  * since the marked inner tuple is certainly matchable.)
    1051             :                  */
    1052      903206 :                 innerTupleSlot = node->mj_MarkedTupleSlot;
    1053      903206 :                 (void) MJEvalInnerValues(node, innerTupleSlot);
    1054             : 
    1055      903206 :                 compareResult = MJCompare(node);
    1056             :                 MJ_DEBUG_COMPARE(compareResult);
    1057             : 
    1058      903206 :                 if (compareResult == 0)
    1059             :                 {
    1060             :                     /*
    1061             :                      * the merge clause matched so now we restore the inner
    1062             :                      * scan position to the first mark, and go join that tuple
    1063             :                      * (and any following ones) to the new outer.
    1064             :                      *
    1065             :                      * If we were able to determine mark and restore are not
    1066             :                      * needed, then we don't have to back up; the current
    1067             :                      * inner is already the first possible match.
    1068             :                      *
    1069             :                      * NOTE: we do not need to worry about the MatchedInner
    1070             :                      * state for the rescanned inner tuples.  We know all of
    1071             :                      * them will match this new outer tuple and therefore
    1072             :                      * won't be emitted as fill tuples.  This works *only*
    1073             :                      * because we require the extra joinquals to be constant
    1074             :                      * when doing a right, right-anti or full join ---
    1075             :                      * otherwise some of the rescanned tuples might fail the
    1076             :                      * extra joinquals.  This obviously won't happen for a
    1077             :                      * constant-true extra joinqual, while the constant-false
    1078             :                      * case is handled by forcing the merge clause to never
    1079             :                      * match, so we never get here.
    1080             :                      */
    1081      160598 :                     if (!node->mj_SkipMarkRestore)
    1082             :                     {
    1083      137908 :                         ExecRestrPos(innerPlan);
    1084             : 
    1085             :                         /*
    1086             :                          * ExecRestrPos probably should give us back a new
    1087             :                          * Slot, but since it doesn't, use the marked slot.
    1088             :                          * (The previously returned mj_InnerTupleSlot cannot
    1089             :                          * be assumed to hold the required tuple.)
    1090             :                          */
    1091      137908 :                         node->mj_InnerTupleSlot = innerTupleSlot;
    1092             :                         /* we need not do MJEvalInnerValues again */
    1093             :                     }
    1094             : 
    1095      160598 :                     node->mj_JoinState = EXEC_MJ_JOINTUPLES;
    1096             :                 }
    1097      742608 :                 else if (compareResult > 0)
    1098             :                 {
    1099             :                     /* ----------------
    1100             :                      *  if the new outer tuple didn't match the marked inner
    1101             :                      *  tuple then we have a case like:
    1102             :                      *
    1103             :                      *           outer inner
    1104             :                      *             4     4  - marked tuple
    1105             :                      * new outer - 5     4
    1106             :                      *             6     5  - inner tuple
    1107             :                      *             7
    1108             :                      *
    1109             :                      *  which means that all subsequent outer tuples will be
    1110             :                      *  larger than our marked inner tuples.  So we need not
    1111             :                      *  revisit any of the marked tuples but can proceed to
    1112             :                      *  look for a match to the current inner.  If there's
    1113             :                      *  no more inners, no more matches are possible.
    1114             :                      * ----------------
    1115             :                      */
    1116      742608 :                     innerTupleSlot = node->mj_InnerTupleSlot;
    1117             : 
    1118             :                     /* reload comparison data for current inner */
    1119      742608 :                     switch (MJEvalInnerValues(node, innerTupleSlot))
    1120             :                     {
    1121      741940 :                         case MJEVAL_MATCHABLE:
    1122             :                             /* proceed to compare it to the current outer */
    1123      741940 :                             node->mj_JoinState = EXEC_MJ_SKIP_TEST;
    1124      741940 :                             break;
    1125          24 :                         case MJEVAL_NONMATCHABLE:
    1126             : 
    1127             :                             /*
    1128             :                              * current inner can't possibly match any outer;
    1129             :                              * better to advance the inner scan than the
    1130             :                              * outer.
    1131             :                              */
    1132          24 :                             node->mj_JoinState = EXEC_MJ_SKIPINNER_ADVANCE;
    1133          24 :                             break;
    1134         644 :                         case MJEVAL_ENDOFJOIN:
    1135             :                             /* No more inner tuples */
    1136         644 :                             if (doFillOuter)
    1137             :                             {
    1138             :                                 /*
    1139             :                                  * Need to emit left-join tuples for remaining
    1140             :                                  * outer tuples.
    1141             :                                  */
    1142         160 :                                 node->mj_JoinState = EXEC_MJ_ENDINNER;
    1143         160 :                                 break;
    1144             :                             }
    1145             :                             /* Otherwise we're done. */
    1146         484 :                             return NULL;
    1147             :                     }
    1148      742124 :                 }
    1149             :                 else            /* compareResult < 0 should not happen */
    1150           0 :                     elog(ERROR, "mergejoin input data is out of order");
    1151      902722 :                 break;
    1152             : 
    1153             :                 /*----------------------------------------------------------
    1154             :                  * EXEC_MJ_SKIP_TEST means compare tuples and if they do not
    1155             :                  * match, skip whichever is lesser.
    1156             :                  *
    1157             :                  * For example:
    1158             :                  *
    1159             :                  *              outer inner
    1160             :                  *                5     5
    1161             :                  *                5     5
    1162             :                  * outer tuple -  6     8  - inner tuple
    1163             :                  *                7    12
    1164             :                  *                8    14
    1165             :                  *
    1166             :                  * we have to advance the outer scan
    1167             :                  * until we find the outer 8.
    1168             :                  *
    1169             :                  * On the other hand:
    1170             :                  *
    1171             :                  *              outer inner
    1172             :                  *                5     5
    1173             :                  *                5     5
    1174             :                  * outer tuple - 12     8  - inner tuple
    1175             :                  *               14    10
    1176             :                  *               17    12
    1177             :                  *
    1178             :                  * we have to advance the inner scan
    1179             :                  * until we find the inner 12.
    1180             :                  *----------------------------------------------------------
    1181             :                  */
    1182     1917636 :             case EXEC_MJ_SKIP_TEST:
    1183             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_SKIP_TEST\n");
    1184             : 
    1185             :                 /*
    1186             :                  * before we advance, make sure the current tuples do not
    1187             :                  * satisfy the mergeclauses.  If they do, then we update the
    1188             :                  * marked tuple position and go join them.
    1189             :                  */
    1190     1917636 :                 compareResult = MJCompare(node);
    1191             :                 MJ_DEBUG_COMPARE(compareResult);
    1192             : 
    1193     1917636 :                 if (compareResult == 0)
    1194             :                 {
    1195      744306 :                     if (!node->mj_SkipMarkRestore)
    1196      704504 :                         ExecMarkPos(innerPlan);
    1197             : 
    1198      744306 :                     MarkInnerTuple(node->mj_InnerTupleSlot, node);
    1199             : 
    1200      744306 :                     node->mj_JoinState = EXEC_MJ_JOINTUPLES;
    1201             :                 }
    1202     1173330 :                 else if (compareResult < 0)
    1203      935130 :                     node->mj_JoinState = EXEC_MJ_SKIPOUTER_ADVANCE;
    1204             :                 else
    1205             :                     /* compareResult > 0 */
    1206      238200 :                     node->mj_JoinState = EXEC_MJ_SKIPINNER_ADVANCE;
    1207     1917636 :                 break;
    1208             : 
    1209             :                 /*
    1210             :                  * EXEC_MJ_SKIPOUTER_ADVANCE: advance over an outer tuple that
    1211             :                  * is known not to join to any inner tuple.
    1212             :                  *
    1213             :                  * Before advancing, we check to see if we must emit an
    1214             :                  * outer-join fill tuple for this outer tuple.
    1215             :                  */
    1216     1078362 :             case EXEC_MJ_SKIPOUTER_ADVANCE:
    1217             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_SKIPOUTER_ADVANCE\n");
    1218             : 
    1219     1078362 :                 if (doFillOuter && !node->mj_MatchedOuter)
    1220             :                 {
    1221             :                     /*
    1222             :                      * Generate a fake join tuple with nulls for the inner
    1223             :                      * tuple, and return it if it passes the non-join quals.
    1224             :                      */
    1225             :                     TupleTableSlot *result;
    1226             : 
    1227      146508 :                     node->mj_MatchedOuter = true;    /* do it only once */
    1228             : 
    1229      146508 :                     result = MJFillOuter(node);
    1230      146508 :                     if (result)
    1231      143232 :                         return result;
    1232             :                 }
    1233             : 
    1234             :                 /*
    1235             :                  * now we get the next outer tuple, if any
    1236             :                  */
    1237      935130 :                 outerTupleSlot = ExecProcNode(outerPlan);
    1238      935130 :                 node->mj_OuterTupleSlot = outerTupleSlot;
    1239             :                 MJ_DEBUG_PROC_NODE(outerTupleSlot);
    1240      935130 :                 node->mj_MatchedOuter = false;
    1241             : 
    1242             :                 /* Compute join values and check for unmatchability */
    1243      935130 :                 switch (MJEvalOuterValues(node))
    1244             :                 {
    1245      934750 :                     case MJEVAL_MATCHABLE:
    1246             :                         /* Go test the new tuple against the current inner */
    1247      934750 :                         node->mj_JoinState = EXEC_MJ_SKIP_TEST;
    1248      934750 :                         break;
    1249           6 :                     case MJEVAL_NONMATCHABLE:
    1250             :                         /* Can't match, so fetch next outer tuple */
    1251           6 :                         node->mj_JoinState = EXEC_MJ_SKIPOUTER_ADVANCE;
    1252           6 :                         break;
    1253         374 :                     case MJEVAL_ENDOFJOIN:
    1254             :                         /* No more outer tuples */
    1255             :                         MJ_printf("ExecMergeJoin: end of outer subplan\n");
    1256         374 :                         innerTupleSlot = node->mj_InnerTupleSlot;
    1257         374 :                         if (doFillInner && !TupIsNull(innerTupleSlot))
    1258             :                         {
    1259             :                             /*
    1260             :                              * Need to emit right-join tuples for remaining
    1261             :                              * inner tuples.
    1262             :                              */
    1263          90 :                             node->mj_JoinState = EXEC_MJ_ENDOUTER;
    1264          90 :                             break;
    1265             :                         }
    1266             :                         /* Otherwise we're done. */
    1267         284 :                         return NULL;
    1268             :                 }
    1269      934846 :                 break;
    1270             : 
    1271             :                 /*
    1272             :                  * EXEC_MJ_SKIPINNER_ADVANCE: advance over an inner tuple that
    1273             :                  * is known not to join to any outer tuple.
    1274             :                  *
    1275             :                  * Before advancing, we check to see if we must emit an
    1276             :                  * outer-join fill tuple for this inner tuple.
    1277             :                  */
    1278      241746 :             case EXEC_MJ_SKIPINNER_ADVANCE:
    1279             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_SKIPINNER_ADVANCE\n");
    1280             : 
    1281      241746 :                 if (doFillInner && !node->mj_MatchedInner)
    1282             :                 {
    1283             :                     /*
    1284             :                      * Generate a fake join tuple with nulls for the outer
    1285             :                      * tuple, and return it if it passes the non-join quals.
    1286             :                      */
    1287             :                     TupleTableSlot *result;
    1288             : 
    1289        4074 :                     node->mj_MatchedInner = true;    /* do it only once */
    1290             : 
    1291        4074 :                     result = MJFillInner(node);
    1292        4074 :                     if (result)
    1293        3498 :                         return result;
    1294             :                 }
    1295             : 
    1296             :                 /* Mark before advancing, if wanted */
    1297      238248 :                 if (node->mj_ExtraMarks)
    1298          96 :                     ExecMarkPos(innerPlan);
    1299             : 
    1300             :                 /*
    1301             :                  * now we get the next inner tuple, if any
    1302             :                  */
    1303      238248 :                 innerTupleSlot = ExecProcNode(innerPlan);
    1304      238248 :                 node->mj_InnerTupleSlot = innerTupleSlot;
    1305             :                 MJ_DEBUG_PROC_NODE(innerTupleSlot);
    1306      238248 :                 node->mj_MatchedInner = false;
    1307             : 
    1308             :                 /* Compute join values and check for unmatchability */
    1309      238248 :                 switch (MJEvalInnerValues(node, innerTupleSlot))
    1310             :                 {
    1311      235854 :                     case MJEVAL_MATCHABLE:
    1312             :                         /* proceed to compare it to the current outer */
    1313      235854 :                         node->mj_JoinState = EXEC_MJ_SKIP_TEST;
    1314      235854 :                         break;
    1315          24 :                     case MJEVAL_NONMATCHABLE:
    1316             : 
    1317             :                         /*
    1318             :                          * current inner can't possibly match any outer;
    1319             :                          * better to advance the inner scan than the outer.
    1320             :                          */
    1321          24 :                         node->mj_JoinState = EXEC_MJ_SKIPINNER_ADVANCE;
    1322          24 :                         break;
    1323        2370 :                     case MJEVAL_ENDOFJOIN:
    1324             :                         /* No more inner tuples */
    1325             :                         MJ_printf("ExecMergeJoin: end of inner subplan\n");
    1326        2370 :                         outerTupleSlot = node->mj_OuterTupleSlot;
    1327        2370 :                         if (doFillOuter && !TupIsNull(outerTupleSlot))
    1328             :                         {
    1329             :                             /*
    1330             :                              * Need to emit left-join tuples for remaining
    1331             :                              * outer tuples.
    1332             :                              */
    1333         554 :                             node->mj_JoinState = EXEC_MJ_ENDINNER;
    1334         554 :                             break;
    1335             :                         }
    1336             :                         /* Otherwise we're done. */
    1337        1816 :                         return NULL;
    1338             :                 }
    1339      236432 :                 break;
    1340             : 
    1341             :                 /*
    1342             :                  * EXEC_MJ_ENDOUTER means we have run out of outer tuples, but
    1343             :                  * are doing a right/right-anti/full join and therefore must
    1344             :                  * null-fill any remaining unmatched inner tuples.
    1345             :                  */
    1346         894 :             case EXEC_MJ_ENDOUTER:
    1347             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_ENDOUTER\n");
    1348             : 
    1349             :                 Assert(doFillInner);
    1350             : 
    1351         894 :                 if (!node->mj_MatchedInner)
    1352             :                 {
    1353             :                     /*
    1354             :                      * Generate a fake join tuple with nulls for the outer
    1355             :                      * tuple, and return it if it passes the non-join quals.
    1356             :                      */
    1357             :                     TupleTableSlot *result;
    1358             : 
    1359         384 :                     node->mj_MatchedInner = true;    /* do it only once */
    1360             : 
    1361         384 :                     result = MJFillInner(node);
    1362         384 :                     if (result)
    1363         378 :                         return result;
    1364             :                 }
    1365             : 
    1366             :                 /* Mark before advancing, if wanted */
    1367         516 :                 if (node->mj_ExtraMarks)
    1368          72 :                     ExecMarkPos(innerPlan);
    1369             : 
    1370             :                 /*
    1371             :                  * now we get the next inner tuple, if any
    1372             :                  */
    1373         516 :                 innerTupleSlot = ExecProcNode(innerPlan);
    1374         516 :                 node->mj_InnerTupleSlot = innerTupleSlot;
    1375             :                 MJ_DEBUG_PROC_NODE(innerTupleSlot);
    1376         516 :                 node->mj_MatchedInner = false;
    1377             : 
    1378         516 :                 if (TupIsNull(innerTupleSlot))
    1379             :                 {
    1380             :                     MJ_printf("ExecMergeJoin: end of inner subplan\n");
    1381         270 :                     return NULL;
    1382             :                 }
    1383             : 
    1384             :                 /* Else remain in ENDOUTER state and process next tuple. */
    1385         246 :                 break;
    1386             : 
    1387             :                 /*
    1388             :                  * EXEC_MJ_ENDINNER means we have run out of inner tuples, but
    1389             :                  * are doing a left/full join and therefore must null- fill
    1390             :                  * any remaining unmatched outer tuples.
    1391             :                  */
    1392      137370 :             case EXEC_MJ_ENDINNER:
    1393             :                 MJ_printf("ExecMergeJoin: EXEC_MJ_ENDINNER\n");
    1394             : 
    1395             :                 Assert(doFillOuter);
    1396             : 
    1397      137370 :                 if (!node->mj_MatchedOuter)
    1398             :                 {
    1399             :                     /*
    1400             :                      * Generate a fake join tuple with nulls for the inner
    1401             :                      * tuple, and return it if it passes the non-join quals.
    1402             :                      */
    1403             :                     TupleTableSlot *result;
    1404             : 
    1405       68750 :                     node->mj_MatchedOuter = true;    /* do it only once */
    1406             : 
    1407       68750 :                     result = MJFillOuter(node);
    1408       68750 :                     if (result)
    1409       68622 :                         return result;
    1410             :                 }
    1411             : 
    1412             :                 /*
    1413             :                  * now we get the next outer tuple, if any
    1414             :                  */
    1415       68748 :                 outerTupleSlot = ExecProcNode(outerPlan);
    1416       68748 :                 node->mj_OuterTupleSlot = outerTupleSlot;
    1417             :                 MJ_DEBUG_PROC_NODE(outerTupleSlot);
    1418       68748 :                 node->mj_MatchedOuter = false;
    1419             : 
    1420       68748 :                 if (TupIsNull(outerTupleSlot))
    1421             :                 {
    1422             :                     MJ_printf("ExecMergeJoin: end of outer subplan\n");
    1423         748 :                     return NULL;
    1424             :                 }
    1425             : 
    1426             :                 /* Else remain in ENDINNER state and process next tuple. */
    1427       68000 :                 break;
    1428             : 
    1429             :                 /*
    1430             :                  * broken state value?
    1431             :                  */
    1432           0 :             default:
    1433           0 :                 elog(ERROR, "unrecognized mergejoin state: %d",
    1434             :                      (int) node->mj_JoinState);
    1435             :         }
    1436             :     }
    1437             : }
    1438             : 
    1439             : /* ----------------------------------------------------------------
    1440             :  *      ExecInitMergeJoin
    1441             :  * ----------------------------------------------------------------
    1442             :  */
    1443             : MergeJoinState *
    1444        6798 : ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags)
    1445             : {
    1446             :     MergeJoinState *mergestate;
    1447             :     TupleDesc   outerDesc,
    1448             :                 innerDesc;
    1449             :     const TupleTableSlotOps *innerOps;
    1450             : 
    1451             :     /* check for unsupported flags */
    1452             :     Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
    1453             : 
    1454             :     MJ1_printf("ExecInitMergeJoin: %s\n",
    1455             :                "initializing node");
    1456             : 
    1457             :     /*
    1458             :      * create state structure
    1459             :      */
    1460        6798 :     mergestate = makeNode(MergeJoinState);
    1461        6798 :     mergestate->js.ps.plan = (Plan *) node;
    1462        6798 :     mergestate->js.ps.state = estate;
    1463        6798 :     mergestate->js.ps.ExecProcNode = ExecMergeJoin;
    1464        6798 :     mergestate->js.jointype = node->join.jointype;
    1465        6798 :     mergestate->mj_ConstFalseJoin = false;
    1466             : 
    1467             :     /*
    1468             :      * Miscellaneous initialization
    1469             :      *
    1470             :      * create expression context for node
    1471             :      */
    1472        6798 :     ExecAssignExprContext(estate, &mergestate->js.ps);
    1473             : 
    1474             :     /*
    1475             :      * we need two additional econtexts in which we can compute the join
    1476             :      * expressions from the left and right input tuples.  The node's regular
    1477             :      * econtext won't do because it gets reset too often.
    1478             :      */
    1479        6798 :     mergestate->mj_OuterEContext = CreateExprContext(estate);
    1480        6798 :     mergestate->mj_InnerEContext = CreateExprContext(estate);
    1481             : 
    1482             :     /*
    1483             :      * initialize child nodes
    1484             :      *
    1485             :      * inner child must support MARK/RESTORE, unless we have detected that we
    1486             :      * don't need that.  Note that skip_mark_restore must never be set if
    1487             :      * there are non-mergeclause joinquals, since the logic wouldn't work.
    1488             :      */
    1489             :     Assert(node->join.joinqual == NIL || !node->skip_mark_restore);
    1490        6798 :     mergestate->mj_SkipMarkRestore = node->skip_mark_restore;
    1491             : 
    1492        6798 :     outerPlanState(mergestate) = ExecInitNode(outerPlan(node), estate, eflags);
    1493        6798 :     outerDesc = ExecGetResultType(outerPlanState(mergestate));
    1494        6798 :     innerPlanState(mergestate) = ExecInitNode(innerPlan(node), estate,
    1495        6798 :                                               mergestate->mj_SkipMarkRestore ?
    1496             :                                               eflags :
    1497             :                                               (eflags | EXEC_FLAG_MARK));
    1498        6798 :     innerDesc = ExecGetResultType(innerPlanState(mergestate));
    1499             : 
    1500             :     /*
    1501             :      * For certain types of inner child nodes, it is advantageous to issue
    1502             :      * MARK every time we advance past an inner tuple we will never return to.
    1503             :      * For other types, MARK on a tuple we cannot return to is a waste of
    1504             :      * cycles.  Detect which case applies and set mj_ExtraMarks if we want to
    1505             :      * issue "unnecessary" MARK calls.
    1506             :      *
    1507             :      * Currently, only Material wants the extra MARKs, and it will be helpful
    1508             :      * only if eflags doesn't specify REWIND.
    1509             :      *
    1510             :      * Note that for IndexScan and IndexOnlyScan, it is *necessary* that we
    1511             :      * not set mj_ExtraMarks; otherwise we might attempt to set a mark before
    1512             :      * the first inner tuple, which they do not support.
    1513             :      */
    1514        6798 :     if (IsA(innerPlan(node), Material) &&
    1515         152 :         (eflags & EXEC_FLAG_REWIND) == 0 &&
    1516         152 :         !mergestate->mj_SkipMarkRestore)
    1517         152 :         mergestate->mj_ExtraMarks = true;
    1518             :     else
    1519        6646 :         mergestate->mj_ExtraMarks = false;
    1520             : 
    1521             :     /*
    1522             :      * Initialize result slot, type and projection.
    1523             :      */
    1524        6798 :     ExecInitResultTupleSlotTL(&mergestate->js.ps, &TTSOpsVirtual);
    1525        6798 :     ExecAssignProjectionInfo(&mergestate->js.ps, NULL);
    1526             : 
    1527             :     /*
    1528             :      * tuple table initialization
    1529             :      */
    1530        6798 :     innerOps = ExecGetResultSlotOps(innerPlanState(mergestate), NULL);
    1531        6798 :     mergestate->mj_MarkedTupleSlot = ExecInitExtraTupleSlot(estate, innerDesc,
    1532             :                                                             innerOps);
    1533             : 
    1534             :     /*
    1535             :      * initialize child expressions
    1536             :      */
    1537        6798 :     mergestate->js.ps.qual =
    1538        6798 :         ExecInitQual(node->join.plan.qual, (PlanState *) mergestate);
    1539        6798 :     mergestate->js.joinqual =
    1540        6798 :         ExecInitQual(node->join.joinqual, (PlanState *) mergestate);
    1541             :     /* mergeclauses are handled below */
    1542             : 
    1543             :     /*
    1544             :      * detect whether we need only consider the first matching inner tuple
    1545             :      */
    1546       12460 :     mergestate->js.single_match = (node->join.inner_unique ||
    1547        5662 :                                    node->join.jointype == JOIN_SEMI);
    1548             : 
    1549             :     /* set up null tuples for outer joins, if needed */
    1550        6798 :     switch (node->join.jointype)
    1551             :     {
    1552        2040 :         case JOIN_INNER:
    1553             :         case JOIN_SEMI:
    1554        2040 :             mergestate->mj_FillOuter = false;
    1555        2040 :             mergestate->mj_FillInner = false;
    1556        2040 :             break;
    1557        1590 :         case JOIN_LEFT:
    1558             :         case JOIN_ANTI:
    1559        1590 :             mergestate->mj_FillOuter = true;
    1560        1590 :             mergestate->mj_FillInner = false;
    1561        1590 :             mergestate->mj_NullInnerTupleSlot =
    1562        1590 :                 ExecInitNullTupleSlot(estate, innerDesc, &TTSOpsVirtual);
    1563        1590 :             break;
    1564        2886 :         case JOIN_RIGHT:
    1565             :         case JOIN_RIGHT_ANTI:
    1566        2886 :             mergestate->mj_FillOuter = false;
    1567        2886 :             mergestate->mj_FillInner = true;
    1568        2886 :             mergestate->mj_NullOuterTupleSlot =
    1569        2886 :                 ExecInitNullTupleSlot(estate, outerDesc, &TTSOpsVirtual);
    1570             : 
    1571             :             /*
    1572             :              * Can't handle right, right-anti or full join with non-constant
    1573             :              * extra joinclauses.  This should have been caught by planner.
    1574             :              */
    1575        2886 :             if (!check_constant_qual(node->join.joinqual,
    1576             :                                      &mergestate->mj_ConstFalseJoin))
    1577           0 :                 ereport(ERROR,
    1578             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1579             :                          errmsg("RIGHT JOIN is only supported with merge-joinable join conditions")));
    1580        2886 :             break;
    1581         282 :         case JOIN_FULL:
    1582         282 :             mergestate->mj_FillOuter = true;
    1583         282 :             mergestate->mj_FillInner = true;
    1584         282 :             mergestate->mj_NullOuterTupleSlot =
    1585         282 :                 ExecInitNullTupleSlot(estate, outerDesc, &TTSOpsVirtual);
    1586         282 :             mergestate->mj_NullInnerTupleSlot =
    1587         282 :                 ExecInitNullTupleSlot(estate, innerDesc, &TTSOpsVirtual);
    1588             : 
    1589             :             /*
    1590             :              * Can't handle right, right-anti or full join with non-constant
    1591             :              * extra joinclauses.  This should have been caught by planner.
    1592             :              */
    1593         282 :             if (!check_constant_qual(node->join.joinqual,
    1594             :                                      &mergestate->mj_ConstFalseJoin))
    1595           0 :                 ereport(ERROR,
    1596             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1597             :                          errmsg("FULL JOIN is only supported with merge-joinable join conditions")));
    1598         282 :             break;
    1599           0 :         default:
    1600           0 :             elog(ERROR, "unrecognized join type: %d",
    1601             :                  (int) node->join.jointype);
    1602             :     }
    1603             : 
    1604             :     /*
    1605             :      * preprocess the merge clauses
    1606             :      */
    1607        6798 :     mergestate->mj_NumClauses = list_length(node->mergeclauses);
    1608        6798 :     mergestate->mj_Clauses = MJExamineQuals(node->mergeclauses,
    1609             :                                             node->mergeFamilies,
    1610             :                                             node->mergeCollations,
    1611             :                                             node->mergeStrategies,
    1612             :                                             node->mergeNullsFirst,
    1613             :                                             (PlanState *) mergestate);
    1614             : 
    1615             :     /*
    1616             :      * initialize join state
    1617             :      */
    1618        6798 :     mergestate->mj_JoinState = EXEC_MJ_INITIALIZE_OUTER;
    1619        6798 :     mergestate->mj_MatchedOuter = false;
    1620        6798 :     mergestate->mj_MatchedInner = false;
    1621        6798 :     mergestate->mj_OuterTupleSlot = NULL;
    1622        6798 :     mergestate->mj_InnerTupleSlot = NULL;
    1623             : 
    1624             :     /*
    1625             :      * initialization successful
    1626             :      */
    1627             :     MJ1_printf("ExecInitMergeJoin: %s\n",
    1628             :                "node initialized");
    1629             : 
    1630        6798 :     return mergestate;
    1631             : }
    1632             : 
    1633             : /* ----------------------------------------------------------------
    1634             :  *      ExecEndMergeJoin
    1635             :  *
    1636             :  * old comments
    1637             :  *      frees storage allocated through C routines.
    1638             :  * ----------------------------------------------------------------
    1639             :  */
    1640             : void
    1641        6792 : ExecEndMergeJoin(MergeJoinState *node)
    1642             : {
    1643             :     MJ1_printf("ExecEndMergeJoin: %s\n",
    1644             :                "ending node processing");
    1645             : 
    1646             :     /*
    1647             :      * shut down the subplans
    1648             :      */
    1649        6792 :     ExecEndNode(innerPlanState(node));
    1650        6792 :     ExecEndNode(outerPlanState(node));
    1651             : 
    1652             :     MJ1_printf("ExecEndMergeJoin: %s\n",
    1653             :                "node processing ended");
    1654        6792 : }
    1655             : 
    1656             : void
    1657         478 : ExecReScanMergeJoin(MergeJoinState *node)
    1658             : {
    1659         478 :     PlanState  *outerPlan = outerPlanState(node);
    1660         478 :     PlanState  *innerPlan = innerPlanState(node);
    1661             : 
    1662         478 :     ExecClearTuple(node->mj_MarkedTupleSlot);
    1663             : 
    1664         478 :     node->mj_JoinState = EXEC_MJ_INITIALIZE_OUTER;
    1665         478 :     node->mj_MatchedOuter = false;
    1666         478 :     node->mj_MatchedInner = false;
    1667         478 :     node->mj_OuterTupleSlot = NULL;
    1668         478 :     node->mj_InnerTupleSlot = NULL;
    1669             : 
    1670             :     /*
    1671             :      * if chgParam of subnodes is not null then plans will be re-scanned by
    1672             :      * first ExecProcNode.
    1673             :      */
    1674         478 :     if (outerPlan->chgParam == NULL)
    1675         462 :         ExecReScan(outerPlan);
    1676         478 :     if (innerPlan->chgParam == NULL)
    1677          12 :         ExecReScan(innerPlan);
    1678         478 : }

Generated by: LCOV version 1.14