diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 255f56b827..f332ac531f 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -1299,17 +1299,13 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
 	List	   *partial_subpaths = NIL;
 	List	   *pa_partial_subpaths = NIL;
 	List	   *pa_nonpartial_subpaths = NIL;
-	bool		partial_subpaths_valid = true;
-	bool		pa_subpaths_valid;
+	bool		pa_subpaths_valid = true;
 	List	   *all_child_pathkeys = NIL;
 	List	   *all_child_outers = NIL;
 	ListCell   *l;
 	List	   *partitioned_rels = NIL;
 	double		partial_rows = -1;
 
-	/* If appropriate, consider parallel append */
-	pa_subpaths_valid = enable_parallel_append && rel->consider_parallel;
-
 	/*
 	 * AppendPath generated for partitioned tables must record the RT indexes
 	 * of partitioned tables that are direct or indirect children of this
@@ -1366,7 +1362,6 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
 	{
 		RelOptInfo *childrel = lfirst(l);
 		ListCell   *lcp;
-		Path	   *cheapest_partial_path = NULL;
 
 		/*
 		 * For UNION ALLs with non-empty partitioned_child_rels, accumulate
@@ -1391,26 +1386,26 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
 		else
 			subpaths_valid = false;
 
-		/* Same idea, but for a partial plan. */
-		if (childrel->partial_pathlist != NIL)
-		{
-			cheapest_partial_path = linitial(childrel->partial_pathlist);
-			accumulate_append_subpath(cheapest_partial_path,
-									  &partial_subpaths, NULL);
-		}
-		else
-			partial_subpaths_valid = false;
-
 		/*
-		 * Same idea, but for a parallel append mixing partial and non-partial
-		 * paths.
+		 * We also build a set of paths for each child by trying to use the
+		 * cheapest partial path, or the cheapest parallel safe normal path
+		 * either when that is cheaper, or if parallel Append is disabled.
 		 */
 		if (pa_subpaths_valid)
 		{
 			Path	   *nppath = NULL;
+			Path	   *cheapest_partial_path = NULL;
 
-			nppath =
-				get_cheapest_parallel_safe_total_inner(childrel->pathlist);
+			/*
+			 * Only attempt to use a parallel safe subplan when parallel
+			 * append is allowed on this relation.
+			 */
+			if (enable_parallel_append && rel->consider_parallel)
+				nppath =
+					get_cheapest_parallel_safe_total_inner(childrel->pathlist);
+
+			if (childrel->partial_pathlist != NIL)
+				cheapest_partial_path = linitial(childrel->partial_pathlist);
 
 			if (cheapest_partial_path == NULL && nppath == NULL)
 			{
@@ -1525,23 +1520,25 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
 												  partitioned_rels, -1));
 
 	/*
-	 * Consider an append of unordered, unparameterized partial paths.  Make
-	 * it parallel-aware if possible.
+	 * Consider Parallel Append, or an Append with a series of parallel_safe
+	 * subpaths.
 	 */
-	if (partial_subpaths_valid && partial_subpaths != NIL)
+	if (pa_subpaths_valid)
 	{
 		AppendPath *appendpath;
 		ListCell   *lc;
 		int			parallel_workers = 0;
 
-		/* Find the highest number of workers requested for any subpath. */
-		foreach(lc, partial_subpaths)
+		/*
+		 * Find the highest number of workers requested for any partial
+		 * subpath.
+		 */
+		foreach(lc, pa_partial_subpaths)
 		{
 			Path	   *path = lfirst(lc);
 
 			parallel_workers = Max(parallel_workers, path->parallel_workers);
 		}
-		Assert(parallel_workers > 0);
 
 		/*
 		 * If the use of parallel append is permitted, always request at least
@@ -1558,11 +1555,11 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
 								   fls(list_length(live_childrels)));
 			parallel_workers = Min(parallel_workers,
 								   max_parallel_workers_per_gather);
+			Assert(parallel_workers > 0);
 		}
-		Assert(parallel_workers > 0);
 
-		/* Generate a partial append path. */
-		appendpath = create_append_path(root, rel, NIL, partial_subpaths,
+		appendpath = create_append_path(root, rel, pa_nonpartial_subpaths,
+										pa_partial_subpaths,
 										NIL, NULL, parallel_workers,
 										enable_parallel_append,
 										partitioned_rels, -1);
@@ -1573,48 +1570,6 @@ add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
 		 */
 		partial_rows = appendpath->path.rows;
 
-		/* Add the path. */
-		add_partial_path(rel, (Path *) appendpath);
-	}
-
-	/*
-	 * Consider a parallel-aware append using a mix of partial and non-partial
-	 * paths.  (This only makes sense if there's at least one child which has
-	 * a non-partial path that is substantially cheaper than any partial path;
-	 * otherwise, we should use the append path added in the previous step.)
-	 */
-	if (pa_subpaths_valid && pa_nonpartial_subpaths != NIL)
-	{
-		AppendPath *appendpath;
-		ListCell   *lc;
-		int			parallel_workers = 0;
-
-		/*
-		 * Find the highest number of workers requested for any partial
-		 * subpath.
-		 */
-		foreach(lc, pa_partial_subpaths)
-		{
-			Path	   *path = lfirst(lc);
-
-			parallel_workers = Max(parallel_workers, path->parallel_workers);
-		}
-
-		/*
-		 * Same formula here as above.  It's even more important in this
-		 * instance because the non-partial paths won't contribute anything to
-		 * the planned number of parallel workers.
-		 */
-		parallel_workers = Max(parallel_workers,
-							   fls(list_length(live_childrels)));
-		parallel_workers = Min(parallel_workers,
-							   max_parallel_workers_per_gather);
-		Assert(parallel_workers > 0);
-
-		appendpath = create_append_path(root, rel, pa_nonpartial_subpaths,
-										pa_partial_subpaths,
-										NIL, NULL, parallel_workers, true,
-										partitioned_rels, partial_rows);
 		add_partial_path(rel, (Path *) appendpath);
 	}