modify-partbounds-changes-2.patch

diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 3b2008e0f1..d35c9817cd 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -72,8 +72,13 @@ typedef struct PartitionRangeBound
 
 typedef struct PartitionMap
 {
-	int from;
-	int to;
+	int			nparts;			/* number of partitions */
+	int		   *merged_indexes;	/* indexes of merged partitions */
+	bool	   *merged;			/* flags to indicate whether partitions are
+								 * merged with non-dummy partitions */
+	bool		did_remapping;	/* did we remap partitions? */
+	int		   *old_indexes;	/* old indexes of merged partitions if
+								 * did_remapping */
 } PartitionMap;
 
 static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
@@ -115,20 +120,49 @@ static void get_range_key_properties(PartitionKey key, int keynum,
 									 Expr **keyCol,
 									 Const **lower_val, Const **upper_val);
 static List *get_range_nulltest(PartitionKey key);
-static PartitionBoundInfo partition_range_bounds_merge(
+static PartitionBoundInfo partition_range_bounds_merge(int partnatts, FmgrInfo *partsupfuncs,
+							 Oid *partcollations,
 							 RelOptInfo *outer_rel, RelOptInfo *inner_rel,
-							 List **outer_parts, List **inner_parts,
-							 JoinType jointype, int partnatts,
-							 FmgrInfo *supfuncs, Oid *collations);
+							 JoinType jointype,
+							 List **outer_parts, List **inner_parts);
 static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
 							RelOptInfo *outer_rel, RelOptInfo *inner_rel,
-							List **outer_parts, List **inner_parts,
-							JoinType jointype);
+							JoinType jointype,
+							List **outer_parts, List **inner_parts);
+static void init_partition_map(RelOptInfo *rel, PartitionMap *map);
+static void free_partition_map(PartitionMap *map);
+static int map_and_merge_partitions(PartitionMap *outer_map, PartitionMap *inner_map,
+						 int outer_part, int inner_part, int *next_index);
+static int merge_partition_with_dummy(PartitionMap *map, int index,
+						   int *next_index);
+static bool process_outer_partition(PartitionMap *outer_map,
+						PartitionMap *inner_map,
+						bool outer_has_default,
+						bool inner_has_default,
+						int outer_index,
+						int inner_default,
+						JoinType jointype,
+						char strategy,
+						int *next_index,
+						int *default_index,
+						int *merged_index);
+static bool process_inner_partition(PartitionMap *outer_map,
+						PartitionMap *inner_map,
+						bool outer_has_default,
+						bool inner_has_default,
+						int inner_index,
+						int outer_default,
+						JoinType jointype,
+						char strategy,
+						int *next_index,
+						int *default_index,
+						int *merged_index);
+static void fix_merged_indexes(PartitionMap *outer_map, PartitionMap *inner_map,
+				   int nmerged, List *merged_indexes);
 static void generate_matching_part_pairs(RelOptInfo *rel1,
 							 RelOptInfo *rel2,
-							 PartitionMap *partmaps1,
-							 PartitionMap *partmaps2,
-							 int nparts1, int nparts2,
+							 PartitionMap *map1,
+							 PartitionMap *map2,
 							 int nparts,
 							 List **matched_parts1,
 							 List **matched_parts2);
@@ -136,9 +170,6 @@ static PartitionBoundInfo build_merged_partition_bounds(char strategy,
 							  List *merged_datums, List *merged_indexes,
 							  List *merged_contents, int null_index,
 							  int default_index);
-static int map_and_merge_partitions(PartitionMap *outer_maps,
-										PartitionMap *inner_maps,
-										int index1, int index2, int *next_index);
 static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
 						  Oid *collations, PartitionRangeBound *bound1,
 						  PartitionRangeBound *bound2);
@@ -153,19 +184,21 @@ static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
 							  PartitionRangeDatumKind *next_lb_kind,
 							  List **merged_datums, List **merged_kinds,
 							  List **merged_indexes);
-static bool merge_default_partitions(PartitionBoundInfo outer_bi,
-						 PartitionBoundInfo inner_bi,
-						 PartitionMap *outer_maps,
-						 PartitionMap *inner_maps,
+static bool merge_default_partitions(PartitionMap *outer_map,
+						 PartitionMap *inner_map,
+						 bool outer_has_default,
+						 int outer_default,
+						 bool inner_has_default,
+						 int inner_default,
 						 JoinType jointype,
-						 int *next_index, int *default_index);
-static bool merge_null_partitions(PartitionBoundInfo outer_bi,
-								  PartitionBoundInfo inner_bi,
-								  PartitionMap *outer_maps,
-								  PartitionMap *inner_maps,
-								  JoinType jointype,
-								  int *next_index, int *null_index,
-								  int *default_index);
+						 int *next_index,
+						 int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+					  PartitionMap *outer_map, PartitionMap *inner_map,
+					  bool outer_has_default, bool inner_has_default,
+					  bool outer_has_null, bool inner_has_null,
+					  JoinType jointype, int *next_index,
+					  int *default_index, int *null_index);
 
 /*
  * get_qual_from_partbound
@@ -3081,8 +3114,8 @@ partition_bounds_merge(int partnatts,
 					   int16 *parttyplen, bool *parttypbyval,
 					   FmgrInfo *partsupfunc, Oid *partcollation,
 					   RelOptInfo *outer_rel, RelOptInfo *inner_rel,
-					   JoinType jointype,
-					   List **outer_parts, List **inner_parts)
+					   JoinType jointype, List **outer_parts,
+					   List **inner_parts)
 {
 	PartitionBoundInfo 	merged_bounds;
 	PartitionBoundInfo 	outer_binfo = outer_rel->boundinfo,
@@ -3110,17 +3143,22 @@ partition_bounds_merge(int partnatts,
 		case PARTITION_STRATEGY_LIST:
 			merged_bounds = partition_list_bounds_merge(partsupfunc,
 														partcollation,
-														outer_rel, inner_rel,
-														outer_parts, inner_parts,
-														jointype);
+														outer_rel,
+														inner_rel,
+														jointype,
+														outer_parts,
+														inner_parts);
 			break;
 
 		case PARTITION_STRATEGY_RANGE:
-			merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
-														 outer_parts, inner_parts,
-														 jointype, partnatts,
+			merged_bounds = partition_range_bounds_merge(partnatts,
 														 partsupfunc,
-														 partcollation);
+														 partcollation,
+														 outer_rel,
+														 inner_rel,
+														 jointype,
+														 outer_parts,
+														 inner_parts);
 			break;
 
 		default:
@@ -3335,8 +3373,6 @@ partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
 		default:
 			elog(ERROR, "unexpected join type %d", jointype);
 	}
-
-	return;
 }
 
 /*
@@ -3396,157 +3432,34 @@ partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
 	return true;
 }
 
-/*
- * handle_missing_partition
- *
- * If a range appears in one of the joining relations but not the other, a row
- * in the corresponding partition will not have any join partner in the other
- * relation, unless the other relation has a default partition. If a given list
- * value is present in one joining relation but not the other, the default
- * partition on the other side may contain that value.
- *
- * In both these cases, such an extra partition forms a joining pair with the
- * default partition, if any,  on the other side.
- *
- * If the default partition happens to be on the outer side of the join, the
- * resultant partition will act as the default partition of the join relation.
- * Otherwise the resultant partition will be associated with the range.
- *
- * When the default partition is not present in the other relation, the rows in
- * the extra partition will be included in the bounds of the join result, if it
- * appears on the outer side of the join, since all rows from the outer side
- * are included in the join result.
- *
- * This function handles all these cases.
- *
- * maps_with_missing and missing_side_default are the partition maps (See
- * partition_range/list_bounds_merge() for details) and the index of default
- * partition respectively corresponding the side with missing partition.
- *
- * maps_with_extra and extra_part are the partition maps (See
- * partition_range/list_bounds_merge() for details) and the index of extra
- * partition respectively corresponding to the side with the extra partition.
- *
- * It returns true if the matching succeeds, otherwise returns false.
- */
-static bool
-handle_missing_partition(PartitionMap *maps_with_missing,
-						 PartitionMap *maps_with_extra,
-						 int missing_side_default,
-						 int extra_part,
-						 bool missing_side_outer,
-						 bool missing_side_inner,
-						 int *next_index, int *default_index,
-						 int *merged_index)
-{
-	bool missing_has_default = (missing_side_default != -1);
-
-	if (missing_has_default)
-	{
-		*merged_index = map_and_merge_partitions(maps_with_missing,
-												 maps_with_extra,
-												 missing_side_default,
-												 extra_part,
-												 next_index);
-		if (*merged_index < 0)
-			return false;
-
-		if (missing_side_outer)
-		{
-			/*
-			 * Default partition on the outer side forms the default
-			 * partition of the join result.
-			 */
-			if (*default_index < 0)
-				*default_index = *merged_index;
-			else if(*default_index != *merged_index)
-			{
-				/*
-				 * Ended up with default partition on the outer side
-				 * being joined with multiple partitions on the inner
-				 * side. We don't support this case.
-				 */
-				return false;
-			}
-
-			/*
-			 * Since the merged partition acts as a default partition, it
-			 * doesn't need a separate index.
-			 */
-			*merged_index = -1;
-		}
-	}
-	else if (missing_side_inner)
-	{
-		/*
-		 * If this partition has already been mapped (say because we
-		 * found an overlapping range earlier), we know where does it
-		 * fit in the join result. Nothing to do in that case. Else
-		 * create a new merged partition.
-		 */
-		PartitionMap *extra_map = &maps_with_extra[extra_part];
-		if (extra_map->to < 0)
-		{
-			extra_map->to = *next_index;
-			*next_index = *next_index + 1;
-			*merged_index = extra_map->to;
-		}
-	}
-	else
-		*merged_index = -1;
-
-	return true;
-}
-
-static PartitionMap*
-init_partition_map(RelOptInfo *rel)
-{
-	int i, nparts = rel->nparts;
-	PartitionMap *map;
-
-	map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
-
-	for (i = 0; i < nparts; i++)
-	{
-		map[i].from = -1;
-		map[i].to = -1;
-	}
-
-	return map;
-}
-
 /*
  * partition_range_bounds_merge
  *
  * partition_bounds_merge()'s arm for range partitioned tables.
  */
 static PartitionBoundInfo
-partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
-							 List **outer_parts, List **inner_parts,
-							 JoinType jointype, int partnatts,
-							 FmgrInfo *partsupfuncs, Oid *partcollations)
-
+partition_range_bounds_merge(int partnatts, FmgrInfo *partsupfuncs,
+							 Oid *partcollations,
+							 RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+							 JoinType jointype,
+							 List **outer_parts, List **inner_parts)
 {
-	PartitionMap *outer_maps = NULL;
-	PartitionMap *inner_maps = NULL;
-	int			outer_part = 0;
-	int			inner_part = 0;
 	PartitionBoundInfo merged_bounds = NULL;
-	int			outer_lb_index;
-	int			inner_lb_index;
-	int			next_index;
+	PartitionBoundInfo outer_bi = outer_rel->boundinfo;
+	PartitionBoundInfo inner_bi = inner_rel->boundinfo;
+	bool		outer_has_default = partition_bound_has_default(outer_bi);
+	int			outer_default = outer_bi->default_index;
+	bool		inner_has_default = partition_bound_has_default(inner_bi);
+	int			inner_default = inner_bi->default_index;
+	PartitionMap outer_map;
+	PartitionMap inner_map;
+	int			next_index = 0;
 	int			default_index = -1;
 	List	   *merged_datums = NIL;
-	List	   *merged_indexes = NIL;
 	List	   *merged_kinds = NIL;
-	PartitionBoundInfo outer_bi = outer_rel->boundinfo,
-					   inner_bi = inner_rel->boundinfo;
-	int			inner_default = inner_bi->default_index;
-	int			outer_default = outer_bi->default_index;
-	bool		inner_has_default = partition_bound_has_default(inner_bi);
-	bool		outer_has_default = partition_bound_has_default(outer_bi);
-	int 			   outer_nparts = outer_rel->nparts,
-					   inner_nparts = inner_rel->nparts;
+	List	   *merged_indexes = NIL;
+	int			outer_lb_index;
+	int			inner_lb_index;
 
 	Assert(outer_bi->strategy == inner_bi->strategy &&
 		   outer_bi->strategy == PARTITION_STRATEGY_RANGE);
@@ -3554,8 +3467,8 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 	Assert(*outer_parts == NIL);
 	Assert(*inner_parts == NIL);
 
-	outer_maps = init_partition_map(outer_rel);
-	inner_maps = init_partition_map(inner_rel);
+	init_partition_map(outer_rel, &outer_map);
+	init_partition_map(inner_rel, &inner_map);
 
 	/*
 	 * Merge the ranges (partitions) from both sides. Every iteration compares
@@ -3566,40 +3479,30 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 	 * lb_index, for inner or outer side, keeps track of the index of lower bound
 	 * datum in PartitionBoundInfo::datums of that side.
 	 */
-	outer_lb_index = 0;
-	inner_lb_index = 0;
-	next_index = 0;
+	outer_lb_index = inner_lb_index = 0;
 	while (outer_lb_index < outer_bi->ndatums ||
 		   inner_lb_index < inner_bi->ndatums)
 	{
-		PartitionRangeBound outer_lb, outer_ub,
-							inner_lb, inner_ub,
-							*merged_lb = NULL,
-							*merged_ub = NULL;
-
+		PartitionRangeBound *merged_lb = NULL;
+		PartitionRangeBound *merged_ub = NULL;
 		int			merged_index = -1;
+		PartitionRangeBound outer_lb;
+		PartitionRangeBound outer_ub;
+		PartitionRangeBound inner_lb;
+		PartitionRangeBound inner_ub;
+		int			outer_part = -1;
+		int			inner_part = -1;
 		bool		overlap;
-		bool		finished_outer = false;
-		bool		finished_inner = false;
-
-		/* Result of bounds comparison per partition_rbound_cmp(). */
-		int			ub_cmpval;	/* Upper bounds comparison result. */
-		int			lb_cmpval;	/* Lower bounds comparison result. */
+		int			ub_cmpval;
+		int			lb_cmpval;
 
 		/* Get the range bounds of the next pair of partitions. */
 		if (outer_lb_index < outer_bi->ndatums)
 			outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
-												&outer_lb, &outer_ub);
-		else
-			finished_outer = true;
-
+													&outer_lb, &outer_ub);
 		if (inner_lb_index < inner_bi->ndatums)
 			inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
-												&inner_lb, &inner_ub);
-		else
-			finished_inner = true;
-
-		Assert(!finished_outer || !finished_inner);
+													&inner_lb, &inner_ub);
 
 		/*
 		 * We run this loop till both the sides finish. This allows to avoid
@@ -3611,13 +3514,13 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 		 * side. That way we advance the partitions on that side till all of
 		 * them are  exhausted.
 		 */
-		if (finished_outer)
+		if (outer_lb_index >= outer_bi->ndatums)
 		{
 			overlap = false;
 			ub_cmpval = 1;
 			lb_cmpval = 1;
 		}
-		else if (finished_inner)
+		else if (inner_lb_index >= inner_bi->ndatums)
 		{
 			overlap = false;
 			ub_cmpval = -1;
@@ -3641,7 +3544,7 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 								  jointype, &outer_lb, &outer_ub, &inner_lb,
 								  &inner_ub, &merged_lb, &merged_ub);
 
-			merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+			merged_index = map_and_merge_partitions(&outer_map, &inner_map,
 													outer_part, inner_part,
 													&next_index);
 
@@ -3680,6 +3583,8 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 			Assert(overlap);
 
 			/* Move to the next pair of partitions. */
+			Assert(outer_lb_index < outer_bi->ndatums);
+			Assert(inner_lb_index < inner_bi->ndatums);
 			outer_lb_index = partition_range_get_next_lb_index(outer_bi,
 															   outer_lb_index);
 			inner_lb_index = partition_range_get_next_lb_index(inner_bi,
@@ -3695,37 +3600,28 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 			}
 			else
 			{
-				/* A range missing from the inner side. */
-				bool		missing_side_outer;
-				bool		missing_side_inner;
+				if (inner_has_default || IS_OUTER_JOIN(jointype))
+				{
+					if (!process_outer_partition(&outer_map,
+												 &inner_map,
+												 outer_has_default,
+												 inner_has_default,
+												 outer_part,
+												 inner_default,
+												 jointype,
+												 outer_bi->strategy,
+												 &next_index,
+												 &default_index,
+												 &merged_index))
+						return NULL;
+				}
 
 				merged_lb = &outer_lb;
 				merged_ub = &outer_ub;
-
-				/*
-				 * For a FULL join, inner relation acts as both OUTER and INNER
-				 * relation.  For LEFT and ANTI join the inner relation acts as
-				 * INNER relation. For INNER and SEMI join OUTER and INNER
-				 * differentiation is immaterial.
-				 */
-				missing_side_inner = (jointype == JOIN_FULL ||
-									  jointype == JOIN_LEFT ||
-									  jointype == JOIN_ANTI);
-				missing_side_outer = (jointype == JOIN_FULL);
-				if (!handle_missing_partition(inner_maps,
-											  outer_maps,
-											  inner_default,
-											  outer_part,
-											  missing_side_outer,
-											  missing_side_inner,
-											  &next_index,
-											  &default_index,
-											  &merged_index))
-					return NULL;
 			}
 
 			/* Move to the next partition on the outer side. */
-			Assert(!finished_outer);
+			Assert(outer_lb_index < outer_bi->ndatums);
 			outer_lb_index = partition_range_get_next_lb_index(outer_bi,
 															   outer_lb_index);
 		}
@@ -3740,38 +3636,28 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 			}
 			else
 			{
-				/* A range missing from the outer side. */
-				bool		missing_side_outer;
-				bool		missing_side_inner;
+				if (outer_has_default || jointype == JOIN_FULL)
+				{
+					if (!process_inner_partition(&outer_map,
+												 &inner_map,
+												 outer_has_default,
+												 inner_has_default,
+												 inner_part,
+												 outer_default,
+												 jointype,
+												 outer_bi->strategy,
+												 &next_index,
+												 &default_index,
+												 &merged_index))
+						return NULL;
+				}
 
 				merged_lb = &inner_lb;
 				merged_ub = &inner_ub;
-
-				/*
-				 * For a FULL join, outer relation acts as both OUTER and INNER
-				 * relation.  For LEFT and ANTI join the outer relation acts as
-				 * OUTER relation. For INNER and SEMI join OUTER and INNER
-				 * differentiation is immaterial.
-				 */
-				missing_side_outer = (jointype == JOIN_FULL ||
-									  jointype == JOIN_LEFT ||
-									  jointype == JOIN_ANTI);
-				missing_side_inner = (jointype == JOIN_FULL);
-
-				if (!handle_missing_partition(outer_maps,
-											  inner_maps,
-											  outer_default,
-											  inner_part,
-											  missing_side_outer,
-											  missing_side_inner,
-											  &next_index,
-											  &default_index,
-											  &merged_index))
-					return NULL;
 			}
 
 			/* Move to the next partition on the inner side. */
-			Assert (!finished_inner);
+			Assert(inner_lb_index < inner_bi->ndatums);
 			inner_lb_index = partition_range_get_next_lb_index(inner_bi,
 															   inner_lb_index);
 		}
@@ -3802,16 +3688,28 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 		merged_indexes = lappend_int(merged_indexes, merged_index);
 	}
 
-	if (!merge_default_partitions(outer_bi, inner_bi,
-										  outer_maps, inner_maps,
-										  jointype, &next_index,
-										  &default_index))
-		return NULL;
+	/* Merge default partitions if any. */
+	if (outer_has_default || inner_has_default)
+	{
+		if (!merge_default_partitions(&outer_map,
+									  &inner_map,
+									  outer_has_default,
+									  outer_default,
+									  inner_has_default,
+									  inner_default,
+									  jointype,
+									  &next_index,
+									  &default_index))
+			return NULL;
+	}
+	else
+		Assert(default_index == -1);
+
+	Assert(!outer_map.did_remapping && !inner_map.did_remapping);
 
 	/* Use maps to match partition from the joining relations. */
 	generate_matching_part_pairs(outer_rel, inner_rel,
-								 outer_maps, inner_maps,
-								 outer_nparts, inner_nparts,
+								 &outer_map, &inner_map,
 								 next_index,
 								 outer_parts, inner_parts);
 
@@ -3828,6 +3726,8 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 	}
 
 	/* Free any memory we used in this function. */
+	free_partition_map(&outer_map);
+	free_partition_map(&inner_map);
 	list_free(merged_datums);
 	list_free(merged_indexes);
 	list_free(merged_kinds);
@@ -3844,27 +3744,27 @@ partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
 static PartitionBoundInfo
 partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 							RelOptInfo *outer_rel, RelOptInfo *inner_rel,
-							List **outer_parts, List **inner_parts,
-							JoinType jointype)
+							JoinType jointype,
+							List **outer_parts, List **inner_parts)
 {
-	PartitionMap *outer_maps = NULL;
-	PartitionMap *inner_maps = NULL;
-	int			cnto;
-	int			cnti;
-	List	   *merged_datums = NIL;
-	List	   *merged_indexes = NIL;
+	PartitionBoundInfo merged_bounds = NULL;
+	PartitionBoundInfo outer_bi = outer_rel->boundinfo;
+	PartitionBoundInfo inner_bi = inner_rel->boundinfo;
+	bool		outer_has_default = partition_bound_has_default(outer_bi);
+	int			outer_default = outer_bi->default_index;
+	bool		inner_has_default = partition_bound_has_default(inner_bi);
+	int			inner_default = inner_bi->default_index;
+	bool		outer_has_null = partition_bound_accepts_nulls(outer_bi);
+	bool		inner_has_null = partition_bound_accepts_nulls(inner_bi);
+	PartitionMap outer_map;
+	PartitionMap inner_map;
 	int			next_index = 0;
 	int			null_index = -1;
 	int			default_index = -1;
-	PartitionBoundInfo merged_bounds = NULL;
-	PartitionBoundInfo outer_bi = outer_rel->boundinfo,
-					   inner_bi = inner_rel->boundinfo;
-	int			      *outer_indexes = outer_bi->indexes;
-	int			      *inner_indexes = inner_bi->indexes;
-	int				   outer_default = outer_bi->default_index;
-	int				   inner_default = inner_bi->default_index;
-	int 			   outer_nparts = outer_rel->nparts,
-					   inner_nparts = inner_rel->nparts;
+	List	   *merged_datums = NIL;
+	List	   *merged_indexes = NIL;
+	int			cnto;
+	int			cnti;
 
 	Assert(*outer_parts == NIL);
 	Assert(*inner_parts == NIL);
@@ -3875,8 +3775,8 @@ partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 	/* List partitions do not require unbounded ranges. */
 	Assert(!outer_bi->kind && !inner_bi->kind);
 
-	outer_maps = init_partition_map(outer_rel);
-	inner_maps = init_partition_map(inner_rel);
+	init_partition_map(outer_rel, &outer_map);
+	init_partition_map(inner_rel, &inner_map);
 
 	/*
 	 * Merge the list value datums from both sides. Every iteration compares a
@@ -3888,15 +3788,15 @@ partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 	cnto = cnti = 0;
 	while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
 	{
+		Datum	   *merged_datum = NULL;
+		int			merged_index = -1;
 		Datum	   *odatums;
 		Datum	   *idatums;
-		int			o_index;
-		int			i_index;
 		int			cmpval;
-		int			merged_index = -1;
-		Datum	   *merged_datum;
-		bool		finished_inner;
-		bool		finished_outer;
+
+		/* Get the list datums of the next pair of partitions. */
+		odatums = cnto < outer_bi->ndatums ? outer_bi->datums[cnto] : NULL;
+		idatums = cnti < inner_bi->ndatums ? inner_bi->datums[cnti] : NULL;
 
 		/*
 		 * We run this loop till both the sides finish. This allows to avoid
@@ -3908,51 +3808,23 @@ partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 		 * its datums are exhausted.
 		 */
 		if (cnto >= outer_bi->ndatums)
-		{
-			finished_outer = true;
-			odatums = NULL;
-			o_index = -1;
-		}
-		else
-		{
-			finished_outer = false;
-			odatums = outer_bi->datums[cnto];
-			o_index = outer_indexes[cnto];
-		}
-
-		if (cnti >= inner_bi->ndatums)
-		{
-			finished_inner = true;
-			idatums = NULL;
-			i_index = -1;
-		}
-		else
-		{
-			finished_inner = false;
-			idatums = inner_bi->datums[cnti];
-			i_index = inner_indexes[cnti];
-		}
-
-		/* If we exhausted both the sides, we won't enter the loop. */
-		Assert(!finished_inner || !finished_outer);
-
-		if (finished_outer)
 			cmpval = 1;
-		else if (finished_inner)
+		else if (cnti >= inner_bi->ndatums)
 			cmpval = -1;
 		else
 		{
-			/* Every list datum should map to a valid partition index. */
-			Assert(o_index >= 0 && i_index >= 0 &&
-				   odatums != NULL && idatums != NULL);
-
+			Assert(odatums != NULL && idatums != NULL);
 			cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
 													 partcollation[0],
-													 odatums[0], idatums[0]));
+													 odatums[0],
+													 idatums[0]));
 		}
 
 		if (cmpval == 0)
 		{
+			int			o_index = outer_bi->indexes[cnto];
+			int			i_index = inner_bi->indexes[cnti];
+
 			/*
 			 * Datums match. Rows on either side with these datums as partition
 			 * key value will join and will be part of the partition of the
@@ -3962,7 +3834,8 @@ partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 			 * partition containing it.
 			 */
 			merged_datum = odatums;
-			merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+			Assert(o_index >= 0 && i_index >= 0);
+			merged_index = map_and_merge_partitions(&outer_map, &inner_map,
 													o_index, i_index,
 													&next_index);
 
@@ -3975,74 +3848,61 @@ partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 		}
 		else if (cmpval < 0)
 		{
-			bool		missing_side_outer;
-			bool		missing_side_inner;
+			Assert(cnto < outer_bi->ndatums);
 
 			/* A datum missing from the inner side. */
-			merged_index = -1;
 			merged_datum = odatums;
 
-			/*
-			 * For a FULL join, inner relation acts as both OUTER and INNER
-			 * relation.  For LEFT and ANTI join the inner relation acts as
-			 * INNER relation. For INNER and SEMI join OUTER and INNER
-			 * differentiation is immaterial.
-			 */
-			missing_side_inner = (jointype == JOIN_FULL ||
-								  jointype == JOIN_LEFT ||
-								  jointype == JOIN_ANTI);
-			missing_side_outer = (jointype == JOIN_FULL);
-
-			if (!handle_missing_partition(inner_maps,
-										  outer_maps,
-										  inner_default,
-										  o_index,
-										  missing_side_outer,
-										  missing_side_inner,
-										  &next_index,
-										  &default_index,
-										  &merged_index))
-				return NULL;
+			if (inner_has_default || IS_OUTER_JOIN(jointype))
+			{
+				int			o_index = outer_bi->indexes[cnto];
+
+				Assert(o_index >= 0);
+				if (!process_outer_partition(&outer_map,
+											 &inner_map,
+											 outer_has_default,
+											 inner_has_default,
+											 o_index,
+											 inner_default,
+											 jointype,
+											 outer_bi->strategy,
+											 &next_index,
+											 &default_index,
+											 &merged_index))
+					return NULL;
+			}
 
 			/* Move to the next datum on the outer side. */
-			Assert(!finished_outer);
 			cnto++;
 		}
 		else
 		{
-			bool		missing_side_outer;
-			bool		missing_side_inner;
-
 			Assert(cmpval > 0);
+			Assert(cnti < inner_bi->ndatums);
 
 			/* A datum missing from the outer side. */
-			merged_index = -1;
 			merged_datum = idatums;
 
-			/*
-			 * For a FULL join, outer relation acts as both OUTER and INNER
-			 * relation.  For LEFT and ANTI join the outer relation acts as
-			 * OUTER relation. For INNER and SEMI join OUTER and INNER
-			 * differentiation is immaterial.
-			 */
-			missing_side_outer = (jointype == JOIN_FULL ||
-								  jointype == JOIN_LEFT ||
-								  jointype == JOIN_ANTI);
-			missing_side_inner = (jointype == JOIN_FULL);
-
-			if (!handle_missing_partition(outer_maps,
-										  inner_maps,
-										  outer_default,
-										  i_index,
-										  missing_side_outer,
-										  missing_side_inner,
-										  &next_index,
-										  &default_index,
-										  &merged_index))
-				return NULL;
+			if (outer_has_default || jointype == JOIN_FULL)
+			{
+				int			i_index = inner_bi->indexes[cnti];
+
+				Assert(i_index >= 0);
+				if (!process_inner_partition(&outer_map,
+											 &inner_map,
+											 outer_has_default,
+											 inner_has_default,
+											 i_index,
+											 outer_default,
+											 jointype,
+											 outer_bi->strategy,
+											 &next_index,
+											 &default_index,
+											 &merged_index))
+					return NULL;
+			}
 
-			/* Move to the next datum on the right side. */
-			Assert(!finished_inner);
+			/* Move to the next datum on the inner side. */
 			cnti++;
 		}
 
@@ -4057,22 +3917,43 @@ partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 		}
 	}
 
-	if (!merge_null_partitions(outer_bi, inner_bi,
-							   outer_maps, inner_maps,
-							   jointype, &next_index, &null_index,
-							   &default_index))
-		return NULL;
+	/* Merge null partitions if any. */
+	if (outer_has_null || inner_has_null)
+	{
+		if (!merge_null_partitions(outer_bi, inner_bi,
+								   &outer_map, &inner_map,
+								   outer_has_default, inner_has_default,
+								   outer_has_null, inner_has_null,
+								   jointype, &next_index, &default_index,
+								   &null_index))
+			return NULL;
+	}
+	else
+		Assert(null_index == -1);
 
-	if (!merge_default_partitions(outer_bi, inner_bi,
-								  outer_maps, inner_maps,
-								  jointype, &next_index,
-								  &default_index))
-		return NULL;
+	/* Merge default partitions if any. */
+	if (outer_has_default || inner_has_default)
+	{
+		if (!merge_default_partitions(&outer_map, &inner_map,
+									  outer_has_default, outer_default,
+									  inner_has_default, inner_default,
+									  jointype, &next_index, &default_index))
+			return NULL;
+	}
+	else
+		Assert(default_index == -1);
+
+	/* Fix the merged_indexes list if necessary. */
+	if (outer_map.did_remapping || inner_map.did_remapping)
+	{
+		Assert(jointype == JOIN_FULL);
+		fix_merged_indexes(&outer_map, &inner_map,
+						   next_index, merged_indexes);
+	}
 
 	/* Use maps to match partition from the joining relations. */
 	generate_matching_part_pairs(outer_rel, inner_rel,
-								 outer_maps, inner_maps,
-								 outer_nparts, inner_nparts,
+								 &outer_map, &inner_map,
 								 next_index,
 								 outer_parts, inner_parts);
 
@@ -4080,7 +3961,7 @@ partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 	if (*outer_parts && *inner_parts)
 	{
 		Assert(list_length(*outer_parts) == list_length(*inner_parts));
-		Assert(list_length(*outer_parts) == next_index);
+		Assert(list_length(*outer_parts) <= next_index);
 		merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
 													  merged_datums,
 													  merged_indexes, NIL,
@@ -4088,6 +3969,8 @@ partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 	}
 
 	/* Free up all extra memory before returning from this function. */
+	free_partition_map(&outer_map);
+	free_partition_map(&inner_map);
 	list_free(merged_datums);
 	list_free(merged_indexes);
 
@@ -4095,132 +3978,408 @@ partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
 }
 
 /*
- * map_and_merge_partitions
- *
- * If the two given partitions (given by index1 and index2 resp.) are
- * already mapped to each other return the index of corresponding partition in
- * the merged set of partitions.  If they do not have a merged partition
- * associated with them, assign a new merged partition index.  If the
- * partitions are already mapped and their mapped partitions are different from
- * each other, they can not be merged, so return -1.
- *
- * partmaps1[i] gives the mapping of partitions for both relations. It
- * describes which partition of relation 2 matches ith partition of relation 1,
- * and which partition in the merged set matches ith partition of relation 1
- * maps to. Similarly for partmap2.
+ * init_partition_map
  *
- * index1 and index2 are the indexes of matching partition from respective
- * relations.
- *
- * *next_index is used and incremented when the given partitions require a new
- * merged partition.
+ * Initialize a PartitionMap struct for given relation.
  */
-
-static int
-map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
-						 int index1, int index2, int *next_index)
+static void
+init_partition_map(RelOptInfo *rel, PartitionMap *map)
 {
-	PartitionMap 	*partmap1 = &partmaps1[index1];
-	PartitionMap 	*partmap2 = &partmaps2[index2];
-	int				merged_index;
+	int			nparts = rel->nparts;
+	int			i;
 
-	/*
-	 * If both the partitions are not mapped to each other, update the
-	 * maps.
-	 */
-	if (partmap1->from < 0 && partmap2->from < 0)
+	map->nparts = nparts;
+	map->merged_indexes = (int *) palloc(sizeof(int) * nparts);
+	map->merged = (bool *) palloc(sizeof(bool) * nparts);
+	map->did_remapping = false;
+	map->old_indexes = (int *) palloc(sizeof(int) * nparts);
+	for (i = 0; i < nparts; i++)
 	{
-		partmap1->from = index2;
-		partmap2->from = index1;
+		map->merged_indexes[i] = map->old_indexes[i] = -1;
+		map->merged[i] = false;
 	}
+}
+
+/*
+ * free_partition_map
+ */
+static void
+free_partition_map(PartitionMap *map)
+{
+	pfree(map->merged_indexes);
+	pfree(map->merged);
+	pfree(map->old_indexes);
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * *next_index is incremented when creating a new merged partition associated
+ * with the given partitions.
+ */
+static int
+map_and_merge_partitions(PartitionMap *outer_map, PartitionMap *inner_map,
+						 int outer_index, int inner_index, int *next_index)
+{
+	int 		outer_merged_index;
+	bool 		outer_merged;
+	int 		inner_merged_index;
+	bool 		inner_merged;
+
+	Assert(outer_index >= 0 && outer_index < outer_map->nparts);
+	outer_merged_index = outer_map->merged_indexes[outer_index];
+	outer_merged = outer_map->merged[outer_index];
+	Assert(inner_index >= 0 && inner_index < inner_map->nparts);
+	inner_merged_index = inner_map->merged_indexes[inner_index];
+	inner_merged = inner_map->merged[inner_index];
 
 	/*
-	 * If the given to partitions map to each other, find the corresponding
-	 * merged partition index .
+	 * Handle cases where both partitions are mapped to merged partitions.
 	 */
-	if (partmap1->from == index2 && partmap2->from == index1)
+	if (outer_merged_index >= 0 && inner_merged_index >= 0)
 	{
 		/*
-		 * If both the partitions are mapped to the same merged partition, get
-		 * the index of merged partition.
+		 * If the mereged partitions are the same, no need to do anything;
+		 * return the index of the merged partition.  Otherwise, if both
+		 * partitions are merged with dummy partitions, re-merge them; map
+		 * them to the merged partition with the smaller of the two merged
+		 * indexes and return the smaller index.  Otherwise they can't be
+		 * merged, so return -1.
 		 */
-		if (partmap1->to == partmap2->to)
+		if (outer_merged_index == inner_merged_index)
+		{
+			Assert(outer_merged);
+			Assert(inner_merged);
+			return outer_merged_index;
+		}
+		if (!outer_merged && !inner_merged)
 		{
-			merged_index = partmap1->to;
-
 			/*
-			 * If the given two partitions do not have a merged partition
-			 * associated with them, allocate a new merged partition.
+			 * Note that we will fix the larger index that have been added to
+			 * the merged_indexes list so far in fix_merged_indexes().
 			 */
-			if (merged_index < 0)
+			if (outer_merged_index < inner_merged_index)
+			{
+				outer_map->merged[outer_index] = true;
+				inner_map->merged_indexes[inner_index] = outer_merged_index;
+				inner_map->merged[inner_index] = true;
+				inner_map->did_remapping = true;
+				inner_map->old_indexes[inner_index] = inner_merged_index;
+				return outer_merged_index;
+			}
+			else
 			{
-				merged_index = *next_index;
-				*next_index = *next_index + 1;
-				partmap1->to = merged_index;
-				partmap2->to = merged_index;
+				inner_map->merged[inner_index] = true;
+				outer_map->merged_indexes[outer_index] = inner_merged_index;
+				outer_map->merged[outer_index] = true;
+				outer_map->did_remapping = true;
+				outer_map->old_indexes[outer_index] = outer_merged_index;
+				return inner_merged_index;
 			}
 		}
+		return -1;
+	}
+
+	/* At least one partition isn't mapped to a merged partition. */
+	Assert(outer_merged_index == -1 || inner_merged_index == -1);
+
+	/*
+	 * If neither of partitions isn't mapped, assign them a new merged
+	 * partition and return the index of the merged partition.  Otherwise, if
+	 * one of partitions is merged with a dummy relation (and the other isn't
+	 * merged), re-merge it with the other, with the same index, and return
+	 * the index.  Otherwise they can't be merged, so return -1.
+	 */
+	if (outer_merged_index == -1 && inner_merged_index == -1)
+	{
+		int 		merged_index = *next_index;
+
+		Assert(!outer_merged);
+		Assert(!inner_merged);
+		outer_map->merged_indexes[outer_index] = merged_index;
+		outer_map->merged[outer_index] = true;
+		inner_map->merged_indexes[inner_index] = merged_index;
+		inner_map->merged[inner_index] = true;
+		*next_index = *next_index + 1;
+		return merged_index;
+	}
+	if (outer_merged_index >= 0 && !outer_map->merged[outer_index])
+	{
+		Assert(inner_merged_index == -1);
+		Assert(!inner_merged);
+		inner_map->merged_indexes[inner_index] = outer_merged_index;
+		inner_map->merged[inner_index] = true;
+		outer_map->merged[outer_index] = true;
+		return outer_merged_index;
+	}
+	if (inner_merged_index >= 0 && !inner_map->merged[inner_index])
+	{
+		Assert(outer_merged_index == -1);
+		Assert(!outer_merged);
+		outer_map->merged_indexes[outer_index] = inner_merged_index;
+		outer_map->merged[outer_index] = true;
+		inner_map->merged[inner_index] = true;
+		return inner_merged_index;
+	}
+	return -1;
+}
+
+/*
+ * merge_partition_with_dummy
+ *
+ * *next_index is incremented.
+ */
+static int
+merge_partition_with_dummy(PartitionMap *map, int index, int *next_index)
+{
+	int 		merged_index = *next_index;
+
+	Assert(index >= 0 && index < map->nparts);
+	Assert(map->merged_indexes[index] == -1);
+	Assert(!map->merged[index]);
+	map->merged_indexes[index] = merged_index;
+	/* Leave the merged flag alone! */
+	*next_index = *next_index + 1;
+	return merged_index;
+}
+
+/*
+ * process_outer_partition
+ *
+ * Determine the merged partition associated with the given outer partition.
+ *
+ * *next_index is incremented when creating a new merged partition associated
+ * with the given outer partition.
+ */
+static bool
+process_outer_partition(PartitionMap *outer_map,
+						PartitionMap *inner_map,
+						bool outer_has_default,
+						bool inner_has_default,
+						int outer_index,
+						int inner_default,
+						JoinType jointype,
+						char strategy,
+						int *next_index,
+						int *default_index,
+						int *merged_index)
+{
+	Assert(outer_index >= 0);
+
+	/*
+	 * If the inner side has the default partition, the outer partition has to
+	 * be joined with the default partition; try merging them.  Otherwise, we
+	 * should in an outer join, in which case the outer partition has to be
+	 * scanned all the way anyway; if the outer partition is already mapped to
+	 * a merged partition, get it, otherwise create a new merged partition by
+	 * merging the outer partition with a dummy partition.
+	 */
+	if (inner_has_default)
+	{
+		Assert(inner_default >= 0);
+
+		/*
+		 * If the outer side has the default partition as well, we need to
+		 * merge the default partitions (see merge_default_partitions()); give
+		 * up on it.
+		 */
+		if (outer_has_default)
+			return false;
+
+		*merged_index = map_and_merge_partitions(outer_map, inner_map,
+												 outer_index, inner_default,
+												 next_index);
+		if (*merged_index == -1)
+			return false;
 
 		/*
-		 * If partition from one relation was mapped to a merged partition but
-		 * not the partition from the other relation, map the same merged
-		 * partition to the partition from other relation, since matching
-		 * partitions map to the same merged partition.
+		 * If this is a FULL join, the merged partition would act as the
+		 * default partition of the join; record the index in *default_index
+		 * if not done yet.
 		 */
-		else if (partmap1->to >= 0 && partmap2->to < 0)
+		if (jointype == JOIN_FULL)
 		{
-			partmap2->to = partmap1->to;
-			merged_index = partmap1->to;
+			if (*default_index == -1)
+				*default_index = *merged_index;
+			else
+				Assert(*merged_index == *default_index);
+			/* Don't add this index to the list of merged indexes. */
+			*merged_index = -1;
 		}
-		else if (partmap1->to < 0 && partmap2->to >= 0)
+	}
+	else
+	{
+		Assert(IS_OUTER_JOIN(jointype));
+		Assert(jointype != JOIN_RIGHT);
+
+		/*
+		 * In range partitioning, if the given outer partition is already
+		 * merged (eg, because we found an overlapping range earlier), we know
+		 * where it fits in the join result; nothing to do in that case.  Else
+		 * create a new merged partition.
+		 */
+		if (outer_map->merged_indexes[outer_index] >= 0)
 		{
-			partmap1->to = partmap2->to;
-			merged_index = partmap2->to;
+			if (strategy == PARTITION_STRATEGY_LIST)
+				*merged_index = outer_map->merged_indexes[outer_index];
+			else
+			{
+				Assert(strategy == PARTITION_STRATEGY_RANGE);
+				*merged_index = -1;
+			}
 		}
 		else
-		{
-			Assert(partmap1->to != partmap2->to &&
-				   partmap1->to >= 0 && partmap2->to >= 0);
+			*merged_index = merge_partition_with_dummy(outer_map, outer_index,
+													   next_index);
+	}
+	return true;
+}
 
-			/*
-			 * Both the partitions map to different merged partitions. This
-			 * means that multiple partitions from one relation matches to one
-			 * partition from the other relation. Partition-wise join does not
-			 * handle this case right now, since it requires ganging multiple
-			 * partitions together (into one RelOptInfo).
-			 */
-			merged_index = -1;
+/*
+ * process_inner_partition
+ *
+ * Determine the merged partition associated with the given inner partition.
+ *
+ * *next_index is incremented when creating a new merged partition associated
+ * with the given inner partition.
+ */
+static bool
+process_inner_partition(PartitionMap *outer_map,
+						PartitionMap *inner_map,
+						bool outer_has_default,
+						bool inner_has_default,
+						int inner_index,
+						int outer_default,
+						JoinType jointype,
+						char strategy,
+						int *next_index,
+						int *default_index,
+						int *merged_index)
+{
+	Assert(inner_index >= 0);
+
+	/*
+	 * If the outer side has the default partition, the inner partition has to
+	 * be joined with the default partition; try merging them.  Otherwise, we
+	 * should in an FULL join, in which case the inner partition has to be
+	 * scanned all the way anyway; if the inner partition is already mapped to
+	 * a merged partition, get it, otherwise create a new merged partition by
+	 * merging the inner partition with a dummy partition.
+	 */
+	if (outer_has_default)
+	{
+		Assert(outer_default >= 0);
+
+		/*
+		 * If the inner side has the default partition as well, we need to
+		 * merge the default partitions (see merge_default_partitions()); give
+		 * up on it.
+		 */
+		if (inner_has_default)
+			return false;
+
+		*merged_index = map_and_merge_partitions(outer_map, inner_map,
+												 outer_default, inner_index,
+												 next_index);
+		if (*merged_index == -1)
+			return false;
+
+		/*
+		 * If this is an outer join, the merged partition would act as the
+		 * default partition of the join; record the index in *default_index
+		 * if not done yet.
+		 */
+		if (jointype == JOIN_LEFT || jointype == JOIN_ANTI ||
+			jointype == JOIN_FULL)
+		{
+			if (*default_index == -1)
+				*default_index = *merged_index;
+			else
+				Assert(*merged_index == *default_index);
+			/* Don't add this index to the list of merged indexes. */
+			*merged_index = -1;
 		}
 	}
 	else
 	{
+		Assert(jointype == JOIN_FULL);
+
 		/*
-		 * Multiple partitions from one relation map to one partition from the
-		 * other relation. Partition-wise join does not handle this case right
-		 * now, since it requires ganging multiple partitions together (into
-		 * one RelOptInfo).
+		 * In range partitioning, if the given inner partition is already
+		 * merged (eg, because we found an overlapping range earlier), we know
+		 * where it fits in the join result; nothing to do in that case.  Else
+		 * create a new merged partition.
 		 */
-		merged_index = -1;
+		if (inner_map->merged_indexes[inner_index] >= 0)
+		{
+			if (strategy == PARTITION_STRATEGY_LIST)
+				*merged_index = inner_map->merged_indexes[inner_index];
+			else
+			{
+				Assert(strategy == PARTITION_STRATEGY_RANGE);
+				*merged_index = -1;
+			}
+		}
+		else
+			*merged_index = merge_partition_with_dummy(inner_map, inner_index,
+													   next_index);
 	}
+	return true;
+}
 
-	return merged_index;
+/*
+ * fix_merged_indexes
+ */
+static void
+fix_merged_indexes(PartitionMap *outer_map, PartitionMap *inner_map,
+				   int nmerged, List *merged_indexes)
+{
+	int		   *new_indexes;
+	int			merged_index;
+	int			i;
+	ListCell   *lc;
+
+	new_indexes = (int *) palloc(sizeof(int) * nmerged);
+	for (i = 0; i < nmerged; i++)
+		new_indexes[i] = -1;
+
+	/* Build the mapping of old merged indexes to new merged indexes. */
+	if (outer_map->did_remapping)
+	{
+		for (i = 0; i < outer_map->nparts; i++)
+		{
+			merged_index = outer_map->old_indexes[i];
+			if (merged_index >= 0)
+				new_indexes[merged_index] = outer_map->merged_indexes[i];
+		}
+	}
+	if (inner_map->did_remapping)
+	{
+		for (i = 0; i < inner_map->nparts; i++)
+		{
+			merged_index = inner_map->old_indexes[i];
+			if (merged_index >= 0)
+				new_indexes[merged_index] = inner_map->merged_indexes[i];
+		}
+	}
+
+	/* Fix the merged_indexes list using the mapping. */
+	foreach(lc, merged_indexes)
+	{
+		merged_index = lfirst_int(lc);
+		Assert(merged_index >= 0);
+		if (new_indexes[merged_index] >= 0)
+			lfirst_int(lc) = new_indexes[merged_index];
+	}
+
+	pfree(new_indexes);
 }
 
 /*
  * generate_matching_part_pairs
  *
- * partmaps1 map each partition from either side of the join to a merged
- * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
- * partition of first relation maps. Similarly for partmap2. If
- * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
- * partitions.
- *
- * Given these maps this function produces the list pairs of partitions which
- * when joined produce the merged partitions in the order of merged partition
- * indexes.
- *
- * nparts1 and nparts2 are the number of partitions of the joining relations
- * resp.
+ * This function produces the list pairs of partitions which produce merged
+ * partitions in the order of merged partition indexes.
  *
  * nparts is the number of merged partitions.
  *
@@ -4230,15 +4389,20 @@ map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
  */
 static void
 generate_matching_part_pairs(RelOptInfo *rel1, RelOptInfo *rel2,
-							 PartitionMap *partmaps1, PartitionMap *partmaps2,
-							 int nparts1, int nparts2, int nparts,
+							 PartitionMap *map1, PartitionMap *map2,
+							 int nparts,
 							 List **matched_parts1, List **matched_parts2)
 {
+	int			nparts1 = map1->nparts;
+	int			nparts2 = map2->nparts;
 	int		   *matching1,
 			   *matching2;
 	int 		i;
 	int			max_nparts;
 
+	Assert(map1->nparts == rel1->nparts);
+	Assert(map2->nparts == rel2->nparts);
+
 	*matched_parts1 = NIL;
 	*matched_parts2 = NIL;
 
@@ -4253,23 +4417,22 @@ generate_matching_part_pairs(RelOptInfo *rel1, RelOptInfo *rel2,
 	{
 		if (i < nparts1)
 		{
-			PartitionMap outer_map = partmaps1[i];
+			int 		merged_index = map1->merged_indexes[i];
 
-			if (outer_map.to >= 0)
+			if (merged_index >= 0)
 			{
-				Assert(outer_map.to < nparts);
-				matching1[outer_map.to] = i;
+				Assert(merged_index < nparts);
+				matching1[merged_index] = i;
 			}
 		}
-
 		if (i < nparts2)
 		{
-			PartitionMap inner_map = partmaps2[i];
+			int 		merged_index = map2->merged_indexes[i];
 
-			if (inner_map.to >= 0)
+			if (merged_index >= 0)
 			{
-				Assert(inner_map.to < nparts);
-				matching2[inner_map.to] = i;
+				Assert(merged_index < nparts);
+				matching2[merged_index] = i;
 			}
 		}
 	}
@@ -4279,8 +4442,8 @@ generate_matching_part_pairs(RelOptInfo *rel1, RelOptInfo *rel2,
 		int			part1 = matching1[i];
 		int			part2 = matching2[i];
 
-		/* At least one of the partitions should exist. */
-		Assert(part1 >= 0 || part2 >= 0);
+		if (part1 == -1 && part2 == -1)
+			continue;
 
 		*matched_parts1 = lappend(*matched_parts1,
 								  part1 >= 0 ? rel1->part_rels[part1] : NULL);
@@ -4356,57 +4519,53 @@ build_merged_partition_bounds(char strategy, List *merged_datums,
  * appear in the join result, so create a default merged partition.
  */
 static bool
-merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
-						 PartitionMap *outer_maps, PartitionMap *inner_maps,
-						 JoinType jointype, int *next_index, int *default_index)
+merge_default_partitions(PartitionMap *outer_map, PartitionMap *inner_map,
+						 bool outer_has_default, int outer_default,
+						 bool inner_has_default, int inner_default,
+						 JoinType jointype, int *next_index,
+						 int *default_index)
 {
-	int				outer_default = outer_bi->default_index;
-	int				inner_default = inner_bi->default_index;
-	bool			outer_has_default = partition_bound_has_default(outer_bi);
-	bool			inner_has_default = partition_bound_has_default(inner_bi);
-	bool			merged = true;
-	PartitionMap 	*outer_default_map = NULL;
-	PartitionMap 	*inner_default_map = NULL;
+	Assert(outer_has_default || inner_has_default);
 
-	if (outer_has_default)
-		outer_default_map = &outer_maps[outer_default];
-
-	if (inner_has_default)
-		inner_default_map = &inner_maps[inner_default];
-
-	if (!outer_has_default && !inner_has_default)
-		Assert(*default_index < 0);
-	else if (outer_default_map != NULL && inner_default_map == NULL)
+	if (outer_has_default && !inner_has_default)
 	{
 		if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
 			jointype == JOIN_ANTI)
 		{
-			if (outer_default_map->to < 0)
+			int			merged_index;
+
+			Assert(outer_default >= 0 && outer_default < outer_map->nparts);
+			merged_index = outer_map->merged_indexes[outer_default];
+			if (merged_index == -1)
 			{
-				outer_default_map->to = *next_index;
-				*next_index = *next_index + 1;
-				Assert(*default_index < 0);
-				*default_index = outer_default_map->to;
+				Assert(*default_index == -1);
+				*default_index = merge_partition_with_dummy(outer_map,
+															outer_default,
+															next_index);
 			}
 			else
-				Assert(*default_index == outer_default_map->to);
+				Assert(*default_index == merged_index);
 		}
 		else
 			Assert(*default_index < 0);
 	}
-	else if (outer_default_map == NULL && inner_default_map != NULL)
+	else if (!outer_has_default && inner_has_default)
 	{
 		if (jointype == JOIN_FULL)
 		{
-			if (inner_default_map->to < 0)
+			int			merged_index;
+
+			Assert(inner_default >= 0 && inner_default < inner_map->nparts);
+			merged_index = inner_map->merged_indexes[inner_default];
+			if (merged_index == -1)
 			{
-				inner_default_map->to = *next_index;
-				*next_index = *next_index + 1;
-				Assert(*default_index < 0);
-				*default_index = inner_default_map->to;
+				Assert(*default_index == -1);
+				*default_index = merge_partition_with_dummy(inner_map,
+															inner_default,
+															next_index);
 			}
 			else
-				Assert(*default_index == inner_default_map->to);
+				Assert(*default_index == merged_index);
 		}
 		else
 			Assert(*default_index < 0);
@@ -4415,15 +4574,16 @@ merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_b
 	{
 		Assert(outer_has_default && inner_has_default);
 
-		*default_index = map_and_merge_partitions(outer_maps, inner_maps,
-												  outer_default, inner_default,
+		*default_index = map_and_merge_partitions(outer_map,
+												  inner_map,
+												  outer_default,
+												  inner_default,
 												  next_index);
-
-		if (*default_index < 0)
-			merged = false;
+		if (*default_index == -1)
+			return false;
 	}
 
-	return merged;
+	return true;
 }
 
 /*
@@ -4443,101 +4603,80 @@ merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_b
  */
 static bool
 merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
-					  PartitionMap *outer_maps, PartitionMap *inner_maps,
+					  PartitionMap *outer_map, PartitionMap *inner_map,
+					  bool outer_has_default, bool inner_has_default,
+					  bool outer_has_null, bool inner_has_null,
 					  JoinType jointype, int *next_index,
-					  int *null_index, int *default_index)
+					  int *default_index, int *null_index)
 {
-	bool		outer_has_null = partition_bound_accepts_nulls(outer_bi);
-	bool		inner_has_null = partition_bound_accepts_nulls(inner_bi);
-	int			outer_ni = outer_bi->null_index;
-	int			inner_ni = inner_bi->null_index;
-	int			outer_default = outer_bi->default_index;
-	int			inner_default = inner_bi->default_index;
-	bool		merged = true;
+	Assert(outer_has_null || inner_has_null);
+	Assert(*null_index == -1);
 
-	if (!outer_has_null && !inner_has_null)
-		Assert(*null_index < 0);
-	else if (outer_has_null && !inner_has_null)
+	if (outer_has_null && !inner_has_null)
 	{
 		int			merged_index = -1;
-		bool		missing_side_outer;
-		bool		missing_side_inner;
-
-		/*
-		 * For a FULL join, inner relation acts as both OUTER and INNER
-		 * relation.  For LEFT and ANTI join the inner relation acts as
-		 * INNER relation. For INNER and SEMI join OUTER and INNER
-		 * differentiation is immaterial.
-		 */
-		missing_side_inner = (jointype == JOIN_FULL ||
-							  jointype == JOIN_LEFT ||
-							  jointype == JOIN_ANTI);
-		missing_side_outer = (jointype == JOIN_FULL);
-
-		merged = handle_missing_partition(inner_maps,
-										  outer_maps,
-										  inner_default,
-										  outer_ni,
-										  missing_side_outer,
-										  missing_side_inner, next_index,
-										  default_index, &merged_index);
-		*null_index = merged_index;
 
 		/*
 		 * If the NULL partition was missing from the inner side of the join,
-		 * the partition of the join to which the outer null partition maps
-		 * will contain the NULL values and thus becomes the NULL partition of
+		 * the partition of the join to which the NULL partition matches will
+		 * contain the NULL values and thus become the NULL partition of the
 		 * the join.
 		 */
-		if (missing_side_inner)
-			*null_index = outer_maps[outer_ni].to;
+		if (inner_has_default || IS_OUTER_JOIN(jointype))
+		{
+			if (!process_outer_partition(outer_map,
+										 inner_map,
+										 outer_has_default,
+										 inner_has_default,
+										 outer_bi->null_index,
+										 inner_bi->default_index,
+										 jointype,
+										 outer_bi->strategy,
+										 next_index,
+										 default_index,
+										 &merged_index))
+				return false;
+		}
+		*null_index = merged_index;
 	}
 	else if (!outer_has_null && inner_has_null)
 	{
 		int			merged_index = -1;
-		bool		missing_side_outer;
-		bool		missing_side_inner;
 
 		/*
-		 * For a FULL join, outer relation acts as both OUTER and INNER
-		 * relation.  For LEFT and ANTI join the outer relation acts as OUTER
-		 * relation. For INNER and SEMI join OUTER and INNER differentiation is
-		 * immaterial.
-		 */
-		missing_side_outer = (jointype == JOIN_FULL ||
-							  jointype == JOIN_LEFT ||
-							  jointype == JOIN_ANTI);
-		missing_side_inner = (jointype == JOIN_FULL);
-		merged = handle_missing_partition(outer_maps,
-										  inner_maps,
-										  outer_default,
-										  inner_ni,
-										  missing_side_outer,
-										  missing_side_inner,
-										  next_index, default_index,
-										  &merged_index);
-		*null_index = merged_index;
-
-		/*
-		 * If the NULL partition was missing from the inner side of the join,
-		 * the partition of the join, to which the outer side null partition maps,
-		 * will contain the NULL values and thus becomes the NULL partition of
+		 * If the NULL partition was missing from the outer side of the join,
+		 * the partition of the join to which the NULL partition matches will
+		 * contain the NULL values and thus become the NULL partition of the
 		 * the join.
 		 */
-		if (missing_side_inner)
-			*null_index = inner_maps[inner_ni].to;
+		if (outer_has_default || jointype == JOIN_FULL)
+		{
+			if (!process_inner_partition(outer_map,
+										 inner_map,
+										 outer_has_default,
+										 inner_has_default,
+										 inner_bi->null_index,
+										 outer_bi->default_index,
+										 jointype,
+										 outer_bi->strategy,
+										 next_index,
+										 default_index,
+										 &merged_index))
+				return false;
+		}
+		*null_index = merged_index;
 	}
 	else
 	{
 		/* Both the relations have NULL partitions, try merging them. */
-		*null_index = map_and_merge_partitions(outer_maps,
-											   inner_maps,
-											   outer_ni,
-											   inner_ni,
+		*null_index = map_and_merge_partitions(outer_map,
+											   inner_map,
+											   outer_bi->null_index,
+											   inner_bi->null_index,
 											   next_index);
-		if (*null_index < 0)
-			merged = false;
+		if (*null_index == -1)
+			return false;
 	}
 
-	return merged;
+	return true;
 }
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index b5b5c8a260..89f0c6a9ee 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -4769,3 +4769,182 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
                            Filter: (b = 0)
 (23 rows)
 
+DROP TABLE plt1;
+DROP TABLE plt2;
+CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0002');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt1 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i WHERE i % 5 IN (0, 2, 3, 4);
+ANALYZE plt1;
+CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0001', '0002');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt2 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i WHERE i % 5 IN (1, 2, 3, 4);
+ANALYZE plt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON (t1.c = t2.c) WHERE COALESCE(t1.a, 0) % 5 != 3 AND COALESCE(t1.a, 0) % 5 != 4 ORDER BY t1.c, t1.a, t2.a;
+                                          QUERY PLAN                                           
+-----------------------------------------------------------------------------------------------
+ Sort
+   Sort Key: t1.c, t1.a, t2.a
+   ->  Append
+         ->  Hash Full Join
+               Hash Cond: (t1.c = t2.c)
+               Filter: (((COALESCE(t1.a, 0) % 5) <> 3) AND ((COALESCE(t1.a, 0) % 5) <> 4))
+               ->  Seq Scan on plt1_p1 t1
+               ->  Hash
+                     ->  Seq Scan on plt2_p1 t2
+         ->  Hash Full Join
+               Hash Cond: (t1_1.c = t2_1.c)
+               Filter: (((COALESCE(t1_1.a, 0) % 5) <> 3) AND ((COALESCE(t1_1.a, 0) % 5) <> 4))
+               ->  Seq Scan on plt1_p2 t1_1
+               ->  Hash
+                     ->  Seq Scan on plt2_p2 t2_1
+(15 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON (t1.c = t2.c) WHERE COALESCE(t1.a, 0) % 5 != 3 AND COALESCE(t1.a, 0) % 5 != 4 ORDER BY t1.c, t1.a, t2.a;
+ a  |  c   | a  |  c   
+----+------+----+------
+  0 | 0000 |    | 
+  5 | 0000 |    | 
+ 10 | 0000 |    | 
+ 15 | 0000 |    | 
+ 20 | 0000 |    | 
+  2 | 0002 |  2 | 0002
+  2 | 0002 |  7 | 0002
+  2 | 0002 | 12 | 0002
+  2 | 0002 | 17 | 0002
+  2 | 0002 | 22 | 0002
+  7 | 0002 |  2 | 0002
+  7 | 0002 |  7 | 0002
+  7 | 0002 | 12 | 0002
+  7 | 0002 | 17 | 0002
+  7 | 0002 | 22 | 0002
+ 12 | 0002 |  2 | 0002
+ 12 | 0002 |  7 | 0002
+ 12 | 0002 | 12 | 0002
+ 12 | 0002 | 17 | 0002
+ 12 | 0002 | 22 | 0002
+ 17 | 0002 |  2 | 0002
+ 17 | 0002 |  7 | 0002
+ 17 | 0002 | 12 | 0002
+ 17 | 0002 | 17 | 0002
+ 17 | 0002 | 22 | 0002
+ 22 | 0002 |  2 | 0002
+ 22 | 0002 |  7 | 0002
+ 22 | 0002 | 12 | 0002
+ 22 | 0002 | 17 | 0002
+ 22 | 0002 | 22 | 0002
+    |      |  1 | 0001
+    |      |  6 | 0001
+    |      | 11 | 0001
+    |      | 16 | 0001
+    |      | 21 | 0001
+(35 rows)
+
+DROP TABLE plt1;
+DROP TABLE plt2;
+CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0001', '0002');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt1 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i;
+ANALYZE plt1;
+CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt2 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i WHERE i % 5 IN (2, 3, 4);
+ANALYZE plt2;
+CREATE TABLE plt3 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt3_p1 PARTITION OF plt3 FOR VALUES IN ('0001');
+CREATE TABLE plt3_p2 PARTITION OF plt3 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt3 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i WHERE i % 5 IN (1, 3, 4);
+ANALYZE plt3;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON (t1.c = t2.c)) FULL JOIN plt3 t3 ON (t1.c = t3.c) WHERE COALESCE(t1.a, 0) % 5 != 3 AND coalesce(t1.a, 0) % 5 != 4 ORDER BY t1.c, t1.a, t2.a, t3.a;
+                                          QUERY PLAN                                           
+-----------------------------------------------------------------------------------------------
+ Sort
+   Sort Key: t1.c, t1.a, t2.a, t3.a
+   ->  Append
+         ->  Hash Full Join
+               Hash Cond: (t1.c = t3.c)
+               Filter: (((COALESCE(t1.a, 0) % 5) <> 3) AND ((COALESCE(t1.a, 0) % 5) <> 4))
+               ->  Hash Left Join
+                     Hash Cond: (t1.c = t2.c)
+                     ->  Seq Scan on plt1_p1 t1
+                     ->  Hash
+                           ->  Seq Scan on plt2_p1 t2
+               ->  Hash
+                     ->  Seq Scan on plt3_p1 t3
+         ->  Hash Full Join
+               Hash Cond: (t1_1.c = t3_1.c)
+               Filter: (((COALESCE(t1_1.a, 0) % 5) <> 3) AND ((COALESCE(t1_1.a, 0) % 5) <> 4))
+               ->  Hash Left Join
+                     Hash Cond: (t1_1.c = t2_1.c)
+                     ->  Seq Scan on plt1_p2 t1_1
+                     ->  Hash
+                           ->  Seq Scan on plt2_p2 t2_1
+               ->  Hash
+                     ->  Seq Scan on plt3_p2 t3_1
+(23 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON (t1.c = t2.c)) FULL JOIN plt3 t3 ON (t1.c = t3.c) WHERE COALESCE(t1.a, 0) % 5 != 3 AND coalesce(t1.a, 0) % 5 != 4 ORDER BY t1.c, t1.a, t2.a, t3.a;
+ a  |  c   | a  |  c   | a  |  c   
+----+------+----+------+----+------
+  0 | 0000 |    |      |    | 
+  5 | 0000 |    |      |    | 
+ 10 | 0000 |    |      |    | 
+ 15 | 0000 |    |      |    | 
+ 20 | 0000 |    |      |    | 
+  1 | 0001 |    |      |  1 | 0001
+  1 | 0001 |    |      |  6 | 0001
+  1 | 0001 |    |      | 11 | 0001
+  1 | 0001 |    |      | 16 | 0001
+  1 | 0001 |    |      | 21 | 0001
+  6 | 0001 |    |      |  1 | 0001
+  6 | 0001 |    |      |  6 | 0001
+  6 | 0001 |    |      | 11 | 0001
+  6 | 0001 |    |      | 16 | 0001
+  6 | 0001 |    |      | 21 | 0001
+ 11 | 0001 |    |      |  1 | 0001
+ 11 | 0001 |    |      |  6 | 0001
+ 11 | 0001 |    |      | 11 | 0001
+ 11 | 0001 |    |      | 16 | 0001
+ 11 | 0001 |    |      | 21 | 0001
+ 16 | 0001 |    |      |  1 | 0001
+ 16 | 0001 |    |      |  6 | 0001
+ 16 | 0001 |    |      | 11 | 0001
+ 16 | 0001 |    |      | 16 | 0001
+ 16 | 0001 |    |      | 21 | 0001
+ 21 | 0001 |    |      |  1 | 0001
+ 21 | 0001 |    |      |  6 | 0001
+ 21 | 0001 |    |      | 11 | 0001
+ 21 | 0001 |    |      | 16 | 0001
+ 21 | 0001 |    |      | 21 | 0001
+  2 | 0002 |  2 | 0002 |    | 
+  2 | 0002 |  7 | 0002 |    | 
+  2 | 0002 | 12 | 0002 |    | 
+  2 | 0002 | 17 | 0002 |    | 
+  2 | 0002 | 22 | 0002 |    | 
+  7 | 0002 |  2 | 0002 |    | 
+  7 | 0002 |  7 | 0002 |    | 
+  7 | 0002 | 12 | 0002 |    | 
+  7 | 0002 | 17 | 0002 |    | 
+  7 | 0002 | 22 | 0002 |    | 
+ 12 | 0002 |  2 | 0002 |    | 
+ 12 | 0002 |  7 | 0002 |    | 
+ 12 | 0002 | 12 | 0002 |    | 
+ 12 | 0002 | 17 | 0002 |    | 
+ 12 | 0002 | 22 | 0002 |    | 
+ 17 | 0002 |  2 | 0002 |    | 
+ 17 | 0002 |  7 | 0002 |    | 
+ 17 | 0002 | 12 | 0002 |    | 
+ 17 | 0002 | 17 | 0002 |    | 
+ 17 | 0002 | 22 | 0002 |    | 
+ 22 | 0002 |  2 | 0002 |    | 
+ 22 | 0002 |  7 | 0002 |    | 
+ 22 | 0002 | 12 | 0002 |    | 
+ 22 | 0002 | 17 | 0002 |    | 
+ 22 | 0002 | 22 | 0002 |    | 
+(55 rows)
+
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index 34ae92135f..b0ab002eee 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -800,3 +800,47 @@ ANALYZE prt2;
 
 EXPLAIN (COSTS OFF)
 SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+DROP TABLE plt1;
+DROP TABLE plt2;
+
+CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0002');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt1 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i WHERE i % 5 IN (0, 2, 3, 4);
+ANALYZE plt1;
+
+CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0001', '0002');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt2 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i WHERE i % 5 IN (1, 2, 3, 4);
+ANALYZE plt2;
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON (t1.c = t2.c) WHERE COALESCE(t1.a, 0) % 5 != 3 AND COALESCE(t1.a, 0) % 5 != 4 ORDER BY t1.c, t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON (t1.c = t2.c) WHERE COALESCE(t1.a, 0) % 5 != 3 AND COALESCE(t1.a, 0) % 5 != 4 ORDER BY t1.c, t1.a, t2.a;
+
+DROP TABLE plt1;
+DROP TABLE plt2;
+
+CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0001', '0002');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt1 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i;
+ANALYZE plt1;
+
+CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt2 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i WHERE i % 5 IN (2, 3, 4);
+ANALYZE plt2;
+
+CREATE TABLE plt3 (a int, b int, c text) PARTITION BY LIST(c);
+CREATE TABLE plt3_p1 PARTITION OF plt3 FOR VALUES IN ('0001');
+CREATE TABLE plt3_p2 PARTITION OF plt3 FOR VALUES IN ('0003', '0004');
+INSERT INTO plt3 SELECT i, i, to_char(i % 5, 'FM0000') FROM generate_series(0, 24) i WHERE i % 5 IN (1, 3, 4);
+ANALYZE plt3;
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON (t1.c = t2.c)) FULL JOIN plt3 t3 ON (t1.c = t3.c) WHERE COALESCE(t1.a, 0) % 5 != 3 AND coalesce(t1.a, 0) % 5 != 4 ORDER BY t1.c, t1.a, t2.a, t3.a;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON (t1.c = t2.c)) FULL JOIN plt3 t3 ON (t1.c = t3.c) WHERE COALESCE(t1.a, 0) % 5 != 3 AND coalesce(t1.a, 0) % 5 != 4 ORDER BY t1.c, t1.a, t2.a, t3.a;