Invert and rename flag variable to improve code readability.

No change in functionality.  Per discussion with Robert.

diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c
index 54257c05c50b784e6fe5130183c33b1de8f923d9..7147536429dcb3f7296b158da7cee56ad83e8c9a 100644 (file)
--- a/src/backend/optimizer/path/joinpath.c
+++ b/src/backend/optimizer/path/joinpath.c
@@ -42,7 +42,7 @@ static List *select_mergejoin_clauses(PlannerInfo *root,
                                                 RelOptInfo *innerrel,
                                                 List *restrictlist,
                                                 JoinType jointype,
-                                                bool *have_nonmergeable_clause);
+                                                bool *mergejoin_allowed);
 
 
 /*
@@ -78,7 +78,7 @@ add_paths_to_joinrel(PlannerInfo *root,
                                         List *restrictlist)
 {
        List       *mergeclause_list = NIL;
-       bool            have_nonmergeable_clause = false;
+       bool            mergejoin_allowed = true;
 
        /*
         * Find potential mergejoin clauses.  We can skip this if we are not
@@ -93,13 +93,13 @@ add_paths_to_joinrel(PlannerInfo *root,
                                                                                                        innerrel,
                                                                                                        restrictlist,
                                                                                                        jointype,
-                                                                                                       &have_nonmergeable_clause);
+                                                                                                       &mergejoin_allowed);
 
        /*
         * 1. Consider mergejoin paths where both relations must be explicitly
         * sorted.  Skip this if we can't mergejoin.
         */
-       if (!have_nonmergeable_clause)
+       if (mergejoin_allowed)
                sort_inner_and_outer(root, joinrel, outerrel, innerrel,
                                                         restrictlist, mergeclause_list, jointype, sjinfo);
 
@@ -108,9 +108,9 @@ add_paths_to_joinrel(PlannerInfo *root,
         * sorted. This includes both nestloops and mergejoins where the outer
         * path is already ordered.  Again, skip this if we can't mergejoin.
         * (That's okay because we know that nestloop can't handle right/full
-        * joins at all, so it wouldn't work in those cases either.)
+        * joins at all, so it wouldn't work in the prohibited cases either.)
         */
-       if (!have_nonmergeable_clause)
+       if (mergejoin_allowed)
                match_unsorted_outer(root, joinrel, outerrel, innerrel,
                                                         restrictlist, mergeclause_list, jointype, sjinfo);
 
@@ -127,7 +127,7 @@ add_paths_to_joinrel(PlannerInfo *root,
         * those made by match_unsorted_outer when add_paths_to_joinrel() is
         * invoked with the two rels given in the other order.
         */
-       if (!have_nonmergeable_clause)
+       if (mergejoin_allowed)
                match_unsorted_inner(root, joinrel, outerrel, innerrel,
                                                         restrictlist, mergeclause_list, jointype, sjinfo);
 #endif
@@ -927,10 +927,14 @@ best_appendrel_indexscan(PlannerInfo *root, RelOptInfo *rel,
  *       Select mergejoin clauses that are usable for a particular join.
  *       Returns a list of RestrictInfo nodes for those clauses.
  *
- * *have_nonmergeable_clause is set TRUE if this is a right/full join and
- * there are nonmergejoinable join clauses.  The executor's mergejoin
- * machinery cannot handle such cases, so we have to avoid generating a
- * mergejoin plan.
+ * *mergejoin_allowed is normally set to TRUE, but it is set to FALSE if
+ * this is a right/full join and there are nonmergejoinable join clauses.
+ * The executor's mergejoin machinery cannot handle such cases, so we have
+ * to avoid generating a mergejoin plan.  (Note that this flag does NOT
+ * consider whether there are actually any mergejoinable clauses.  This is
+ * correct because in some cases we need to build a clauseless mergejoin.
+ * Simply returning NIL is therefore not enough to distinguish safe from
+ * unsafe cases.)
  *
  * We also mark each selected RestrictInfo to show which side is currently
  * being considered as outer.  These are transient markings that are only
@@ -947,14 +951,13 @@ select_mergejoin_clauses(PlannerInfo *root,
                                                 RelOptInfo *innerrel,
                                                 List *restrictlist,
                                                 JoinType jointype,
-                                                bool *have_nonmergeable_clause)
+                                                bool *mergejoin_allowed)
 {
        List       *result_list = NIL;
        bool            isouterjoin = IS_OUTER_JOIN(jointype);
+       bool            have_nonmergeable_joinclause = false;
        ListCell   *l;
 
-       *have_nonmergeable_clause = false;
-
        foreach(l, restrictlist)
        {
                RestrictInfo *restrictinfo = (RestrictInfo *) lfirst(l);
@@ -962,7 +965,7 @@ select_mergejoin_clauses(PlannerInfo *root,
                /*
                 * If processing an outer join, only use its own join clauses in the
                 * merge.  For inner joins we can use pushed-down clauses too. (Note:
-                * we don't set have_nonmergeable_clause here because pushed-down
+                * we don't set have_nonmergeable_joinclause here because pushed-down
                 * clauses will become otherquals not joinquals.)
                 */
                if (isouterjoin && restrictinfo->is_pushed_down)
@@ -979,7 +982,7 @@ select_mergejoin_clauses(PlannerInfo *root,
                         * FALSE.)
                         */
                        if (!restrictinfo->clause || !IsA(restrictinfo->clause, Const))
-                               *have_nonmergeable_clause = true;
+                               have_nonmergeable_joinclause = true;
                        continue;                       /* not mergejoinable */
                }
 
@@ -988,7 +991,7 @@ select_mergejoin_clauses(PlannerInfo *root,
                 */
                if (!clause_sides_match_join(restrictinfo, outerrel, innerrel))
                {
-                       *have_nonmergeable_clause = true;
+                       have_nonmergeable_joinclause = true;
                        continue;                       /* no good for these input relations */
                }
 
@@ -1017,7 +1020,7 @@ select_mergejoin_clauses(PlannerInfo *root,
                if (EC_MUST_BE_REDUNDANT(restrictinfo->left_ec) ||
                        EC_MUST_BE_REDUNDANT(restrictinfo->right_ec))
                {
-                       *have_nonmergeable_clause = true;
+                       have_nonmergeable_joinclause = true;
                        continue;                       /* can't handle redundant eclasses */
                }
 
@@ -1025,18 +1028,16 @@ select_mergejoin_clauses(PlannerInfo *root,
        }
 
        /*
-        * If it is not a right/full join then we don't need to insist on all the
-        * joinclauses being mergejoinable, so reset the flag.  This simplifies
-        * the logic in add_paths_to_joinrel.
+        * Report whether mergejoin is allowed (see comment at top of function).
         */
        switch (jointype)
        {
                case JOIN_RIGHT:
                case JOIN_FULL:
+                       *mergejoin_allowed = !have_nonmergeable_joinclause;
                        break;
                default:
-                       /* otherwise, it's OK to have nonmergeable join quals */
-                       *have_nonmergeable_clause = false;
+                       *mergejoin_allowed = true;
                        break;
        }