diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index 2d88d06358..01151cef8d 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -7836,18 +7836,17 @@ insert into utrtest values (2, 'qux');
 -- Check case where the foreign partition is a subplan target rel
 explain (verbose, costs off)
 update utrtest set a = 1 where a = 1 or a = 2 returning *;
-                                          QUERY PLAN                                          
-----------------------------------------------------------------------------------------------
+                           QUERY PLAN                            
+-----------------------------------------------------------------
  Update on public.utrtest
    Output: utrtest_1.a, utrtest_1.b
    Foreign Update on public.remp utrtest_1
    Update on public.locp utrtest_2
    ->  Foreign Update on public.remp utrtest_1
-         Remote SQL: UPDATE public.loct SET a = 1 WHERE (((a = 1) OR (a = 2))) RETURNING a, b
+         Remote SQL: UPDATE public.loct SET a = 1 RETURNING a, b
    ->  Seq Scan on public.locp utrtest_2
          Output: 1, utrtest_2.b, utrtest_2.ctid
-         Filter: ((utrtest_2.a = 1) OR (utrtest_2.a = 2))
-(9 rows)
+(8 rows)
 
 -- The new values are concatenated with ' triggered !'
 update utrtest set a = 1 where a = 1 or a = 2 returning *;
@@ -7868,8 +7867,7 @@ update utrtest set a = 1 where a = 2 returning *;
    Update on public.locp utrtest_1
    ->  Seq Scan on public.locp utrtest_1
          Output: 1, utrtest_1.b, utrtest_1.ctid
-         Filter: (utrtest_1.a = 2)
-(6 rows)
+(5 rows)
 
 -- The new values are concatenated with ' triggered !'
 update utrtest set a = 1 where a = 2 returning *;
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 52c01eb86b..15c50b9522 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -35,12 +35,14 @@
 #include "foreign/fdwapi.h"
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
 #include "nodes/supportnodes.h"
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/optimizer.h"
 #include "optimizer/plancat.h"
 #include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
 #include "parser/parse_relation.h"
 #include "parser/parsetree.h"
 #include "partitioning/partdesc.h"
@@ -70,6 +72,8 @@ static List *get_relation_constraints(PlannerInfo *root,
 									  bool include_noinherit,
 									  bool include_notnull,
 									  bool include_partition);
+static void remove_restrictions_implied_by_constraints(RelOptInfo *rel,
+													   List *given_clauses);
 static List *build_index_tlist(PlannerInfo *root, IndexOptInfo *index,
 							   Relation heapRelation);
 static List *get_relation_statistics(RelOptInfo *rel, Relation relation);
@@ -1276,13 +1280,16 @@ get_relation_constraints(PlannerInfo *root,
 	}
 
 	/*
-	 * Add partitioning constraints, if requested.
+	 * If the table is a partition, make sure we have the partition qual, and
+	 * add it to the result if requested.  (But even if it's not requested,
+	 * fetch it while we have the relcache entry open.)
 	 */
-	if (include_partition && relation->rd_rel->relispartition)
+	if (relation->rd_rel->relispartition)
 	{
 		/* make sure rel->partition_qual is set */
 		set_baserel_partition_constraint(relation, rel);
-		result = list_concat(result, rel->partition_qual);
+		if (include_partition)
+			result = list_concat(result, rel->partition_qual);
 	}
 
 	table_close(relation, NoLock);
@@ -1387,6 +1394,14 @@ get_relation_statistics(RelOptInfo *rel, Relation relation)
  * self-inconsistent restrictions, or restrictions inconsistent with the
  * relation's applicable constraints.
  *
+ * Even if the relation does need to be scanned, we may be able to remove
+ * or simplify some of its baserestrictinfo clauses on the basis that
+ * they can be proven true, or some OR arms can be proven false, using
+ * the relation's applicable constraints.  Hence, this function may also
+ * update rel->baserestrictinfo.  (It's a bit hackish to include that in
+ * this function's responsibilities, but it saves fetching the constraint
+ * expressions twice.)
+ *
  * Note: this examines only rel->relid, rel->reloptkind, and
  * rel->baserestrictinfo; therefore it can be called before filling in
  * other fields of the RelOptInfo.
@@ -1562,9 +1577,171 @@ relation_excluded_by_constraints(PlannerInfo *root,
 	if (predicate_refuted_by(safe_constraints, rel->baserestrictinfo, false))
 		return true;
 
+	/*
+	 * OK, we do need to scan the relation, but we might be able to simplify
+	 * its baserestrictinfo list.  For this purpose, we may use its partition
+	 * constraint even if that was deemed duplicative above.
+	 * (get_relation_constraints() will have set rel->partition_qual for us.)
+	 *
+	 * Unfortunately, we *cannot* use regular CHECK constraints here, because
+	 * we can only assume that those are not-FALSE, not that they are surely
+	 * TRUE.  (Partitioning constraints are constructed to be either TRUE or
+	 * FALSE, so we can make the needed proofs with them.)  We could use
+	 * attnotnull constraints, but it's not clear that those would add enough
+	 * to be worth another relcache visit.
+	 */
+	if (rel->partition_qual)
+		remove_restrictions_implied_by_constraints(rel, rel->partition_qual);
+
 	return false;
 }
 
+/*
+ * Remove or simplify any rel->baserestrictinfo clauses that are implied
+ * or refuted by the given_clauses.  Note that we assume the given
+ * clauses are known TRUE, not just that they are known not-FALSE.
+ */
+static void
+remove_restrictions_implied_by_constraints(RelOptInfo *rel,
+										   List *given_clauses)
+{
+	List	   *new_restrictions = NIL;
+	ListCell   *lc;
+
+	foreach(lc, rel->baserestrictinfo)
+	{
+		RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
+
+		if (!restriction_is_or_clause(rinfo))
+		{
+			/*
+			 * Simple clause: see if we can prove it redundant.  There's no
+			 * need to try to refute it though; we should not have got here if
+			 * that were possible.  Note: predicate_implied_by expects us to
+			 * verify that its first argument contains no volatile functions.
+			 */
+			if (contain_mutable_functions((Node *) rinfo->clause) ||
+				!predicate_implied_by(list_make1(rinfo->clause),
+									  given_clauses,
+									  false))
+				new_restrictions = lappend(new_restrictions, rinfo);
+		}
+		else
+		{
+			/*
+			 * OR clause: try to prove or refute each OR arm individually.
+			 * Refuted arms can be dropped.  If we prove any one arm true, the
+			 * whole OR is true and can be dropped in toto.
+			 */
+			List	   *or_args = ((BoolExpr *) rinfo->clause)->args;
+			List	   *new_or_args = NIL;
+			bool		or_is_true = false;
+			ListCell   *lc2;
+
+			foreach(lc2, or_args)
+			{
+				Node	   *orarg = (Node *) lfirst(lc2);
+
+				if (contain_mutable_functions(orarg))
+				{
+					/* mutable, so no proof possible */
+					new_or_args = lappend(new_or_args, orarg);
+				}
+				else if (predicate_implied_by(list_make1(orarg),
+											  given_clauses,
+											  false))
+				{
+					/* orarg is provably true, therefore the OR is as well */
+					or_is_true = true;
+					break;
+				}
+				else if (predicate_refuted_by(list_make1(orarg),
+											  given_clauses,
+											  true))
+				{
+					/* orarg is provably false-or-null, drop it */
+					continue;
+				}
+				else
+					new_or_args = lappend(new_or_args, orarg);
+			}
+
+			/* Drop constant-true OR clauses from baserestrictinfo */
+			if (or_is_true)
+				continue;
+
+			if (list_length(new_or_args) == list_length(or_args))
+			{
+				/* Needn't rebuild the RestrictInfo if we eliminated nothing */
+				new_restrictions = lappend(new_restrictions, rinfo);
+			}
+			else if (new_or_args == NIL)
+			{
+				/*
+				 * Hmm, we refuted all the arms, making the OR constant-false.
+				 * This case should be unreachable, because if this is
+				 * provable then relation_excluded_by_constraints should have
+				 * excluded the rel altogether.  Hence, don't work hard here;
+				 * if we do somehow get here, just re-use the RestrictInfo.
+				 */
+				new_restrictions = lappend(new_restrictions, rinfo);
+			}
+			else
+			{
+				/* Otherwise, build RestrictInfo(s) from the surviving arms */
+				Expr	   *newclause;
+				RestrictInfo *newrinfo;
+
+				/* Build valid clause, with OR only if needed */
+				if (list_length(new_or_args) == 1)
+					newclause = (Expr *) linitial(new_or_args);
+				else
+					newclause = make_orclause(new_or_args);
+
+				if (is_andclause(newclause))
+				{
+					/*
+					 * We must manually flatten this AND-below-OR, now that
+					 * we've removed all its sibling OR arms.  In principle,
+					 * we could now try to prune these clauses individually,
+					 * but it doesn't seem likely to be worth the effort.
+					 */
+					ListCell   *lc3;
+
+					foreach(lc3, ((BoolExpr *) newclause)->args)
+					{
+						Expr	   *andarm = (Expr *) lfirst(lc3);
+
+						newrinfo = make_restrictinfo(andarm,
+													 rinfo->is_pushed_down,
+													 rinfo->outerjoin_delayed,
+													 false,
+													 rinfo->security_level,
+													 NULL,
+													 rinfo->outer_relids,
+													 rinfo->nullable_relids);
+						new_restrictions = lappend(new_restrictions, newrinfo);
+					}
+				}
+				else
+				{
+					newrinfo = make_restrictinfo(newclause,
+												 rinfo->is_pushed_down,
+												 rinfo->outerjoin_delayed,
+												 false,
+												 rinfo->security_level,
+												 NULL,
+												 rinfo->outer_relids,
+												 rinfo->nullable_relids);
+					new_restrictions = lappend(new_restrictions, newrinfo);
+				}
+			}
+		}
+	}
+
+	rel->baserestrictinfo = new_restrictions;
+}
+
 
 /*
  * build_physical_tlist
diff --git a/src/test/regress/expected/create_table.out b/src/test/regress/expected/create_table.out
index ed8c01b8de..0c9be92af6 100644
--- a/src/test/regress/expected/create_table.out
+++ b/src/test/regress/expected/create_table.out
@@ -529,11 +529,10 @@ create table partitioned2
   partition of partitioned for values in ('(2,4)'::partitioned);
 explain (costs off)
 select * from partitioned where row(a,b)::partitioned = '(1,2)'::partitioned;
-                        QUERY PLAN                         
------------------------------------------------------------
+              QUERY PLAN              
+--------------------------------------
  Seq Scan on partitioned1 partitioned
-   Filter: (ROW(a, b)::partitioned = '(1,2)'::partitioned)
-(2 rows)
+(1 row)
 
 drop table partitioned;
 -- whole-row Var in partition key works too
@@ -545,11 +544,10 @@ create table partitioned2
   partition of partitioned for values in ('(2,4)');
 explain (costs off)
 select * from partitioned where partitioned = '(1,2)'::partitioned;
-                           QUERY PLAN                            
------------------------------------------------------------------
+              QUERY PLAN              
+--------------------------------------
  Seq Scan on partitioned1 partitioned
-   Filter: ((partitioned.*)::partitioned = '(1,2)'::partitioned)
-(2 rows)
+(1 row)
 
 \d+ partitioned1
                                Table "public.partitioned1"
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index 2b68aef654..25eafe12c1 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -1800,22 +1800,19 @@ explain (costs off) select * from list_parted where a is not null;
 ----------------------------------------------
  Append
    ->  Seq Scan on part_ab_cd list_parted_1
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on part_ef_gh list_parted_2
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on part_null_xy list_parted_3
          Filter: (a IS NOT NULL)
-(7 rows)
+(5 rows)
 
 explain (costs off) select * from list_parted where a in ('ab', 'cd', 'ef');
                         QUERY PLAN                        
 ----------------------------------------------------------
  Append
    ->  Seq Scan on part_ab_cd list_parted_1
-         Filter: ((a)::text = ANY ('{ab,cd,ef}'::text[]))
    ->  Seq Scan on part_ef_gh list_parted_2
          Filter: ((a)::text = ANY ('{ab,cd,ef}'::text[]))
-(5 rows)
+(4 rows)
 
 explain (costs off) select * from list_parted where a = 'ab' or a in (null, 'cd');
                                    QUERY PLAN                                    
@@ -1878,26 +1875,21 @@ explain (costs off) select * from range_list_parted where b = 'ab';
 ------------------------------------------------------
  Append
    ->  Seq Scan on part_1_10_ab range_list_parted_1
-         Filter: (b = 'ab'::bpchar)
    ->  Seq Scan on part_10_20_ab range_list_parted_2
-         Filter: (b = 'ab'::bpchar)
    ->  Seq Scan on part_21_30_ab range_list_parted_3
-         Filter: (b = 'ab'::bpchar)
    ->  Seq Scan on part_40_inf_ab range_list_parted_4
-         Filter: (b = 'ab'::bpchar)
-(9 rows)
+(5 rows)
 
 explain (costs off) select * from range_list_parted where a between 3 and 23 and b in ('ab');
-                           QUERY PLAN                            
------------------------------------------------------------------
+                     QUERY PLAN                      
+-----------------------------------------------------
  Append
    ->  Seq Scan on part_1_10_ab range_list_parted_1
-         Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar))
+         Filter: (a >= 3)
    ->  Seq Scan on part_10_20_ab range_list_parted_2
-         Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar))
    ->  Seq Scan on part_21_30_ab range_list_parted_3
-         Filter: ((a >= 3) AND (a <= 23) AND (b = 'ab'::bpchar))
-(7 rows)
+         Filter: (a <= 23)
+(6 rows)
 
 /* Should select no rows because range partition key cannot be null */
 explain (costs off) select * from range_list_parted where a is null;
@@ -1912,44 +1904,34 @@ explain (costs off) select * from range_list_parted where b is null;
                    QUERY PLAN                   
 ------------------------------------------------
  Seq Scan on part_40_inf_null range_list_parted
-   Filter: (b IS NULL)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from range_list_parted where a is not null and a < 67;
                        QUERY PLAN                       
 --------------------------------------------------------
  Append
    ->  Seq Scan on part_1_10_ab range_list_parted_1
-         Filter: ((a IS NOT NULL) AND (a < 67))
    ->  Seq Scan on part_1_10_cd range_list_parted_2
-         Filter: ((a IS NOT NULL) AND (a < 67))
    ->  Seq Scan on part_10_20_ab range_list_parted_3
-         Filter: ((a IS NOT NULL) AND (a < 67))
    ->  Seq Scan on part_10_20_cd range_list_parted_4
-         Filter: ((a IS NOT NULL) AND (a < 67))
    ->  Seq Scan on part_21_30_ab range_list_parted_5
-         Filter: ((a IS NOT NULL) AND (a < 67))
    ->  Seq Scan on part_21_30_cd range_list_parted_6
-         Filter: ((a IS NOT NULL) AND (a < 67))
    ->  Seq Scan on part_40_inf_ab range_list_parted_7
-         Filter: ((a IS NOT NULL) AND (a < 67))
+         Filter: (a < 67)
    ->  Seq Scan on part_40_inf_cd range_list_parted_8
-         Filter: ((a IS NOT NULL) AND (a < 67))
+         Filter: (a < 67)
    ->  Seq Scan on part_40_inf_null range_list_parted_9
-         Filter: ((a IS NOT NULL) AND (a < 67))
-(19 rows)
+         Filter: (a < 67)
+(13 rows)
 
 explain (costs off) select * from range_list_parted where a >= 30;
                        QUERY PLAN                       
 --------------------------------------------------------
  Append
    ->  Seq Scan on part_40_inf_ab range_list_parted_1
-         Filter: (a >= 30)
    ->  Seq Scan on part_40_inf_cd range_list_parted_2
-         Filter: (a >= 30)
    ->  Seq Scan on part_40_inf_null range_list_parted_3
-         Filter: (a >= 30)
-(7 rows)
+(4 rows)
 
 drop table list_parted;
 drop table range_list_parted;
@@ -1990,7 +1972,7 @@ explain (costs off) select * from mcrparted where a = 10 and abs(b) = 5;	-- scan
    ->  Seq Scan on mcrparted1 mcrparted_1
          Filter: ((a = 10) AND (abs(b) = 5))
    ->  Seq Scan on mcrparted2 mcrparted_2
-         Filter: ((a = 10) AND (abs(b) = 5))
+         Filter: (abs(b) = 5)
    ->  Seq Scan on mcrparted_def mcrparted_3
          Filter: ((a = 10) AND (abs(b) = 5))
 (7 rows)
@@ -2022,24 +2004,19 @@ explain (costs off) select * from mcrparted where a > -1;	-- scans all partition
    ->  Seq Scan on mcrparted0 mcrparted_1
          Filter: (a > '-1'::integer)
    ->  Seq Scan on mcrparted1 mcrparted_2
-         Filter: (a > '-1'::integer)
    ->  Seq Scan on mcrparted2 mcrparted_3
-         Filter: (a > '-1'::integer)
    ->  Seq Scan on mcrparted3 mcrparted_4
-         Filter: (a > '-1'::integer)
    ->  Seq Scan on mcrparted4 mcrparted_5
-         Filter: (a > '-1'::integer)
    ->  Seq Scan on mcrparted5 mcrparted_6
-         Filter: (a > '-1'::integer)
    ->  Seq Scan on mcrparted_def mcrparted_7
          Filter: (a > '-1'::integer)
-(15 rows)
+(10 rows)
 
 explain (costs off) select * from mcrparted where a = 20 and abs(b) = 10 and c > 10;	-- scans mcrparted4
-                     QUERY PLAN                      
------------------------------------------------------
+               QUERY PLAN               
+----------------------------------------
  Seq Scan on mcrparted4 mcrparted
-   Filter: ((c > 10) AND (a = 20) AND (abs(b) = 10))
+   Filter: ((c > 10) AND (abs(b) = 10))
 (2 rows)
 
 explain (costs off) select * from mcrparted where a = 20 and c > 20; -- scans mcrparted3, mcrparte4, mcrparte5, mcrparted_def
@@ -2049,7 +2026,7 @@ explain (costs off) select * from mcrparted where a = 20 and c > 20; -- scans mc
    ->  Seq Scan on mcrparted3 mcrparted_1
          Filter: ((c > 20) AND (a = 20))
    ->  Seq Scan on mcrparted4 mcrparted_2
-         Filter: ((c > 20) AND (a = 20))
+         Filter: (c > 20)
    ->  Seq Scan on mcrparted5 mcrparted_3
          Filter: ((c > 20) AND (a = 20))
    ->  Seq Scan on mcrparted_def mcrparted_4
@@ -2069,11 +2046,11 @@ explain (costs off) select min(a), max(a) from parted_minmax where b = '12345';
    InitPlan 1 (returns $0)
      ->  Limit
            ->  Index Only Scan using parted_minmax1i on parted_minmax1 parted_minmax
-                 Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
+                 Index Cond: (b = '12345'::text)
    InitPlan 2 (returns $1)
      ->  Limit
            ->  Index Only Scan Backward using parted_minmax1i on parted_minmax1 parted_minmax_1
-                 Index Cond: ((a IS NOT NULL) AND (b = '12345'::text))
+                 Index Cond: (b = '12345'::text)
 (9 rows)
 
 select min(a), max(a) from parted_minmax where b = '12345';
@@ -2173,14 +2150,11 @@ explain (costs off) select * from mcrparted where a < 20 order by a, abs(b), c;
 -------------------------------------------------------------------------
  Append
    ->  Index Scan using mcrparted0_a_abs_c_idx on mcrparted0 mcrparted_1
-         Index Cond: (a < 20)
    ->  Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_2
-         Index Cond: (a < 20)
    ->  Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_3
-         Index Cond: (a < 20)
    ->  Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_4
          Index Cond: (a < 20)
-(9 rows)
+(6 rows)
 
 create table mclparted (a int) partition by list(a);
 create table mclparted1 partition of mclparted for values in(1);
@@ -2226,14 +2200,11 @@ explain (costs off) select * from mcrparted where a < 20 order by a, abs(b), c l
          ->  Sort
                Sort Key: mcrparted_1.a, (abs(mcrparted_1.b)), mcrparted_1.c
                ->  Seq Scan on mcrparted0 mcrparted_1
-                     Filter: (a < 20)
          ->  Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_2
-               Index Cond: (a < 20)
          ->  Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_3
-               Index Cond: (a < 20)
          ->  Index Scan using mcrparted3_a_abs_c_idx on mcrparted3 mcrparted_4
                Index Cond: (a < 20)
-(12 rows)
+(9 rows)
 
 set enable_bitmapscan = 0;
 -- Ensure Append node can be used when the partition is ordered by some
@@ -2245,8 +2216,7 @@ explain (costs off) select * from mcrparted where a = 10 order by a, abs(b), c;
    ->  Index Scan using mcrparted1_a_abs_c_idx on mcrparted1 mcrparted_1
          Index Cond: (a = 10)
    ->  Index Scan using mcrparted2_a_abs_c_idx on mcrparted2 mcrparted_2
-         Index Cond: (a = 10)
-(5 rows)
+(4 rows)
 
 reset enable_bitmapscan;
 drop table mcrparted;
@@ -2276,39 +2246,35 @@ explain (costs off) select * from bool_rp where b = true order by b,a;
 ----------------------------------------------------------------------------------
  Append
    ->  Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k bool_rp_1
-         Index Cond: (b = true)
    ->  Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k bool_rp_2
-         Index Cond: (b = true)
-(5 rows)
+(3 rows)
 
 explain (costs off) select * from bool_rp where b = false order by b,a;
                                      QUERY PLAN                                     
 ------------------------------------------------------------------------------------
  Append
    ->  Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k bool_rp_1
-         Index Cond: (b = false)
    ->  Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k bool_rp_2
-         Index Cond: (b = false)
-(5 rows)
+(3 rows)
 
 explain (costs off) select * from bool_rp where b = true order by a;
-                                    QUERY PLAN                                    
-----------------------------------------------------------------------------------
- Append
-   ->  Index Only Scan using bool_rp_true_1k_b_a_idx on bool_rp_true_1k bool_rp_1
-         Index Cond: (b = true)
-   ->  Index Only Scan using bool_rp_true_2k_b_a_idx on bool_rp_true_2k bool_rp_2
-         Index Cond: (b = true)
+                    QUERY PLAN                     
+---------------------------------------------------
+ Sort
+   Sort Key: bool_rp.a
+   ->  Append
+         ->  Seq Scan on bool_rp_true_1k bool_rp_1
+         ->  Seq Scan on bool_rp_true_2k bool_rp_2
 (5 rows)
 
 explain (costs off) select * from bool_rp where b = false order by a;
-                                     QUERY PLAN                                     
-------------------------------------------------------------------------------------
- Append
-   ->  Index Only Scan using bool_rp_false_1k_b_a_idx on bool_rp_false_1k bool_rp_1
-         Index Cond: (b = false)
-   ->  Index Only Scan using bool_rp_false_2k_b_a_idx on bool_rp_false_2k bool_rp_2
-         Index Cond: (b = false)
+                     QUERY PLAN                     
+----------------------------------------------------
+ Sort
+   Sort Key: bool_rp.a
+   ->  Append
+         ->  Seq Scan on bool_rp_false_1k bool_rp_1
+         ->  Seq Scan on bool_rp_false_2k bool_rp_2
 (5 rows)
 
 drop table bool_rp;
diff --git a/src/test/regress/expected/partition_aggregate.out b/src/test/regress/expected/partition_aggregate.out
index 45c698daf4..ebfdf15fb0 100644
--- a/src/test/regress/expected/partition_aggregate.out
+++ b/src/test/regress/expected/partition_aggregate.out
@@ -738,16 +738,13 @@ SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a LEFT JOI
                Filter: ((pagg_tab1.x > 5) OR (pagg_tab2.y < 20))
                ->  Append
                      ->  Seq Scan on pagg_tab1_p1 pagg_tab1_1
-                           Filter: (x < 20)
                      ->  Seq Scan on pagg_tab1_p2 pagg_tab1_2
-                           Filter: (x < 20)
                ->  Hash
                      ->  Append
                            ->  Seq Scan on pagg_tab2_p2 pagg_tab2_1
                                  Filter: (y > 10)
                            ->  Seq Scan on pagg_tab2_p3 pagg_tab2_2
-                                 Filter: (y > 10)
-(18 rows)
+(15 rows)
 
 SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a LEFT JOIN (SELECT * FROM pagg_tab2 WHERE y > 10) b ON a.x = b.y WHERE a.x > 5 or b.y < 20  GROUP BY a.x, b.y ORDER BY 1, 2;
  x  | y  | count 
@@ -778,16 +775,13 @@ SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a FULL JOI
                Filter: ((pagg_tab1.x > 5) OR (pagg_tab2.y < 20))
                ->  Append
                      ->  Seq Scan on pagg_tab1_p1 pagg_tab1_1
-                           Filter: (x < 20)
                      ->  Seq Scan on pagg_tab1_p2 pagg_tab1_2
-                           Filter: (x < 20)
                ->  Hash
                      ->  Append
                            ->  Seq Scan on pagg_tab2_p2 pagg_tab2_1
                                  Filter: (y > 10)
                            ->  Seq Scan on pagg_tab2_p3 pagg_tab2_2
-                                 Filter: (y > 10)
-(18 rows)
+(15 rows)
 
 SELECT a.x, b.y, count(*) FROM (SELECT * FROM pagg_tab1 WHERE x < 20) a FULL JOIN (SELECT * FROM pagg_tab2 WHERE y > 10) b ON a.x = b.y WHERE a.x > 5 or b.y < 20 GROUP BY a.x, b.y ORDER BY 1, 2;
  x  | y  | count 
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 0057f41caa..2c748aa780 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -218,14 +218,13 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
                ->  Seq Scan on prt2_p2 prt2_1
                      Filter: (b > 250)
                ->  Seq Scan on prt2_p3 prt2_2
-                     Filter: (b > 250)
          ->  Hash
                ->  Append
                      ->  Seq Scan on prt1_p1 prt1_1
-                           Filter: ((a < 450) AND (b = 0))
+                           Filter: (b = 0)
                      ->  Seq Scan on prt1_p2 prt1_2
                            Filter: ((a < 450) AND (b = 0))
-(15 rows)
+(14 rows)
 
 SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
   a  |  c   |  b  |  c   
@@ -253,7 +252,6 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
          Filter: ((prt1.b = 0) OR (prt2.a = 0))
          ->  Append
                ->  Seq Scan on prt1_p1 prt1_1
-                     Filter: (a < 450)
                ->  Seq Scan on prt1_p2 prt1_2
                      Filter: (a < 450)
          ->  Hash
@@ -261,8 +259,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
                      ->  Seq Scan on prt2_p2 prt2_1
                            Filter: (b > 250)
                      ->  Seq Scan on prt2_p3 prt2_2
-                           Filter: (b > 250)
-(16 rows)
+(14 rows)
 
 SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
   a  |  c   |  b  |  c   
@@ -1181,7 +1178,7 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
                Sort Key: prt1.a
                ->  Append
                      ->  Seq Scan on prt1_p1 prt1_1
-                           Filter: ((a < 450) AND (b = 0))
+                           Filter: (b = 0)
                      ->  Seq Scan on prt1_p2 prt1_2
                            Filter: ((a < 450) AND (b = 0))
          ->  Sort
@@ -1190,8 +1187,7 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
                      ->  Seq Scan on prt2_p2 prt2_1
                            Filter: (b > 250)
                      ->  Seq Scan on prt2_p3 prt2_2
-                           Filter: (b > 250)
-(18 rows)
+(17 rows)
 
 SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
   a  |  b  
@@ -2197,7 +2193,7 @@ where not exists (select 1 from prtx2
  Append
    ->  Nested Loop Anti Join
          ->  Seq Scan on prtx1_1
-               Filter: ((a < 20) AND (c = 120))
+               Filter: (c = 120)
          ->  Bitmap Heap Scan on prtx2_1
                Recheck Cond: ((b = prtx1_1.b) AND (c = 123))
                Filter: (a = prtx1_1.a)
@@ -2238,7 +2234,7 @@ where not exists (select 1 from prtx2
  Append
    ->  Nested Loop Anti Join
          ->  Seq Scan on prtx1_1
-               Filter: ((a < 20) AND (c = 91))
+               Filter: (c = 91)
          ->  Bitmap Heap Scan on prtx2_1
                Recheck Cond: ((b = (prtx1_1.b + 1)) OR (c = 99))
                Filter: (a = prtx1_1.a)
@@ -3102,8 +3098,8 @@ INSERT INTO prt2_adv SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series
 ANALYZE prt2_adv;
 EXPLAIN (COSTS OFF)
 SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.a < 300 AND t1.b = 0 ORDER BY t1.a, t2.b;
-                        QUERY PLAN                         
------------------------------------------------------------
+                      QUERY PLAN                      
+------------------------------------------------------
  Sort
    Sort Key: t1.a
    ->  Append
@@ -3112,13 +3108,13 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a =
                ->  Seq Scan on prt2_adv_p1 t2_1
                ->  Hash
                      ->  Seq Scan on prt1_adv_p1 t1_1
-                           Filter: ((a < 300) AND (b = 0))
+                           Filter: (b = 0)
          ->  Hash Join
                Hash Cond: (t2_2.b = t1_2.a)
                ->  Seq Scan on prt2_adv_p2 t2_2
                ->  Hash
                      ->  Seq Scan on prt1_adv_p2 t1_2
-                           Filter: ((a < 300) AND (b = 0))
+                           Filter: (b = 0)
 (15 rows)
 
 SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.a < 300 AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -3141,8 +3137,8 @@ CREATE TABLE prt2_adv_default PARTITION OF prt2_adv DEFAULT;
 ANALYZE prt2_adv;
 EXPLAIN (COSTS OFF)
 SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.a >= 100 AND t1.a < 300 AND t1.b = 0 ORDER BY t1.a, t2.b;
-                                QUERY PLAN                                
---------------------------------------------------------------------------
+                      QUERY PLAN                      
+------------------------------------------------------
  Sort
    Sort Key: t1.a
    ->  Append
@@ -3151,13 +3147,13 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a =
                ->  Seq Scan on prt2_adv_p1 t2_1
                ->  Hash
                      ->  Seq Scan on prt1_adv_p1 t1_1
-                           Filter: ((a >= 100) AND (a < 300) AND (b = 0))
+                           Filter: (b = 0)
          ->  Hash Join
                Hash Cond: (t2_2.b = t1_2.a)
                ->  Seq Scan on prt2_adv_p2 t2_2
                ->  Hash
                      ->  Seq Scan on prt1_adv_p2 t1_2
-                           Filter: ((a >= 100) AND (a < 300) AND (b = 0))
+                           Filter: (b = 0)
 (15 rows)
 
 SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.a >= 100 AND t1.a < 300 AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -4456,7 +4452,7 @@ SELECT t1.a, t1.c, t2.a, t2.c FROM plt1_adv t1 INNER JOIN plt2_adv t2 ON (t1.a =
                ->  Seq Scan on plt2_adv_p3 t2_1
                ->  Hash
                      ->  Seq Scan on plt1_adv_p3 t1_1
-                           Filter: ((b < 10) AND (c = ANY ('{0003,0004,0005}'::text[])))
+                           Filter: (b < 10)
          ->  Hash Join
                Hash Cond: ((t2_2.a = t1_2.a) AND (t2_2.c = t1_2.c))
                ->  Seq Scan on plt2_adv_p4 t2_2
@@ -4509,7 +4505,7 @@ SELECT t1.a, t1.c, t2.a, t2.c FROM plt1_adv t1 INNER JOIN plt2_adv t2 ON (t1.a =
                ->  Seq Scan on plt2_adv_p3 t2_1
                ->  Hash
                      ->  Seq Scan on plt1_adv_p3 t1_1
-                           Filter: ((b < 10) AND (c = ANY ('{0003,0004,0005}'::text[])))
+                           Filter: (b < 10)
          ->  Hash Join
                Hash Cond: ((t2_2.a = t1_2.a) AND (t2_2.c = t1_2.c))
                ->  Seq Scan on plt2_adv_p4 t2_2
@@ -4699,7 +4695,7 @@ SELECT t1.*, t2.* FROM alpha t1 INNER JOIN beta t2 ON (t1.a = t2.a AND t1.b = t2
          ->  Hash Join
                Hash Cond: ((t1_1.a = t2_1.a) AND (t1_1.b = t2_1.b))
                ->  Seq Scan on alpha_neg_p1 t1_1
-                     Filter: ((b >= 125) AND (b < 225))
+                     Filter: (b >= 125)
                ->  Hash
                      ->  Seq Scan on beta_neg_p1 t2_1
          ->  Hash Join
@@ -4707,7 +4703,7 @@ SELECT t1.*, t2.* FROM alpha t1 INNER JOIN beta t2 ON (t1.a = t2.a AND t1.b = t2
                ->  Seq Scan on beta_neg_p2 t2_2
                ->  Hash
                      ->  Seq Scan on alpha_neg_p2 t1_2
-                           Filter: ((b >= 125) AND (b < 225))
+                           Filter: (b < 225)
          ->  Hash Join
                Hash Cond: ((t2_4.a = t1_4.a) AND (t2_4.b = t1_4.b))
                ->  Append
@@ -4771,8 +4767,8 @@ SELECT t1.*, t2.* FROM alpha t1 INNER JOIN beta t2 ON (t1.a = t2.a AND t1.b = t2
 
 EXPLAIN (COSTS OFF)
 SELECT t1.*, t2.* FROM alpha t1 INNER JOIN beta t2 ON (t1.a = t2.a AND t1.c = t2.c) WHERE ((t1.b >= 100 AND t1.b < 110) OR (t1.b >= 200 AND t1.b < 210)) AND ((t2.b >= 100 AND t2.b < 110) OR (t2.b >= 200 AND t2.b < 210)) AND t1.c IN ('0004', '0009') ORDER BY t1.a, t1.b, t2.b;
-                                                              QUERY PLAN                                                              
---------------------------------------------------------------------------------------------------------------------------------------
+                                                           QUERY PLAN                                                           
+--------------------------------------------------------------------------------------------------------------------------------
  Sort
    Sort Key: t1.a, t1.b, t2.b
    ->  Append
@@ -4780,15 +4776,15 @@ SELECT t1.*, t2.* FROM alpha t1 INNER JOIN beta t2 ON (t1.a = t2.a AND t1.c = t2
                Hash Cond: ((t1_2.a = t2_2.a) AND (t1_2.c = t2_2.c))
                ->  Append
                      ->  Seq Scan on alpha_neg_p1 t1_2
-                           Filter: ((c = ANY ('{0004,0009}'::text[])) AND (((b >= 100) AND (b < 110)) OR ((b >= 200) AND (b < 210))))
+                           Filter: ((b >= 100) AND (b < 110) AND (c = ANY ('{0004,0009}'::text[])))
                      ->  Seq Scan on alpha_neg_p2 t1_3
-                           Filter: ((c = ANY ('{0004,0009}'::text[])) AND (((b >= 100) AND (b < 110)) OR ((b >= 200) AND (b < 210))))
+                           Filter: ((b >= 200) AND (b < 210) AND (c = ANY ('{0004,0009}'::text[])))
                ->  Hash
                      ->  Append
                            ->  Seq Scan on beta_neg_p1 t2_2
-                                 Filter: (((b >= 100) AND (b < 110)) OR ((b >= 200) AND (b < 210)))
+                                 Filter: ((b >= 100) AND (b < 110))
                            ->  Seq Scan on beta_neg_p2 t2_3
-                                 Filter: (((b >= 100) AND (b < 110)) OR ((b >= 200) AND (b < 210)))
+                                 Filter: ((b >= 200) AND (b < 210))
          ->  Nested Loop
                Join Filter: ((t1_4.a = t2_4.a) AND (t1_4.c = t2_4.c))
                ->  Seq Scan on alpha_pos_p2 t1_4
@@ -4834,17 +4830,17 @@ SELECT t1.*, t2.* FROM alpha t1 INNER JOIN beta t2 ON (t1.a = t2.a AND t1.b = t2
          ->  Hash Join
                Hash Cond: ((t1_1.a = t2_1.a) AND (t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
                ->  Seq Scan on alpha_neg_p1 t1_1
-                     Filter: ((c = ANY ('{0004,0009}'::text[])) AND (((b >= 100) AND (b < 110)) OR ((b >= 200) AND (b < 210))))
+                     Filter: ((b >= 100) AND (b < 110) AND (c = ANY ('{0004,0009}'::text[])))
                ->  Hash
                      ->  Seq Scan on beta_neg_p1 t2_1
-                           Filter: (((b >= 100) AND (b < 110)) OR ((b >= 200) AND (b < 210)))
+                           Filter: ((b >= 100) AND (b < 110))
          ->  Hash Join
                Hash Cond: ((t1_2.a = t2_2.a) AND (t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
                ->  Seq Scan on alpha_neg_p2 t1_2
-                     Filter: ((c = ANY ('{0004,0009}'::text[])) AND (((b >= 100) AND (b < 110)) OR ((b >= 200) AND (b < 210))))
+                     Filter: ((b >= 200) AND (b < 210) AND (c = ANY ('{0004,0009}'::text[])))
                ->  Hash
                      ->  Seq Scan on beta_neg_p2 t2_2
-                           Filter: (((b >= 100) AND (b < 110)) OR ((b >= 200) AND (b < 210)))
+                           Filter: ((b >= 200) AND (b < 210))
          ->  Nested Loop
                Join Filter: ((t1_3.a = t2_3.a) AND (t1_3.b = t2_3.b) AND (t1_3.c = t2_3.c))
                ->  Seq Scan on alpha_pos_p2 t1_3
diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out
index c72a6d051f..85f536b143 100644
--- a/src/test/regress/expected/partition_prune.out
+++ b/src/test/regress/expected/partition_prune.out
@@ -27,22 +27,20 @@ explain (costs off) select * from lp where a > 'a' and a < 'd';
 -----------------------------------------------------------
  Append
    ->  Seq Scan on lp_bc lp_1
-         Filter: ((a > 'a'::bpchar) AND (a < 'd'::bpchar))
    ->  Seq Scan on lp_default lp_2
          Filter: ((a > 'a'::bpchar) AND (a < 'd'::bpchar))
-(5 rows)
+(4 rows)
 
 explain (costs off) select * from lp where a > 'a' and a <= 'd';
                          QUERY PLAN                         
 ------------------------------------------------------------
  Append
    ->  Seq Scan on lp_ad lp_1
-         Filter: ((a > 'a'::bpchar) AND (a <= 'd'::bpchar))
+         Filter: (a > 'a'::bpchar)
    ->  Seq Scan on lp_bc lp_2
-         Filter: ((a > 'a'::bpchar) AND (a <= 'd'::bpchar))
    ->  Seq Scan on lp_default lp_3
          Filter: ((a > 'a'::bpchar) AND (a <= 'd'::bpchar))
-(7 rows)
+(6 rows)
 
 explain (costs off) select * from lp where a = 'a';
          QUERY PLAN          
@@ -63,85 +61,67 @@ explain (costs off) select * from lp where a is not null;
 -----------------------------------
  Append
    ->  Seq Scan on lp_ad lp_1
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on lp_bc lp_2
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on lp_ef lp_3
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on lp_g lp_4
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on lp_default lp_5
-         Filter: (a IS NOT NULL)
-(11 rows)
+(6 rows)
 
 explain (costs off) select * from lp where a is null;
        QUERY PLAN       
 ------------------------
  Seq Scan on lp_null lp
-   Filter: (a IS NULL)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from lp where a = 'a' or a = 'c';
-                        QUERY PLAN                        
-----------------------------------------------------------
+            QUERY PLAN             
+-----------------------------------
  Append
    ->  Seq Scan on lp_ad lp_1
-         Filter: ((a = 'a'::bpchar) OR (a = 'c'::bpchar))
+         Filter: (a = 'a'::bpchar)
    ->  Seq Scan on lp_bc lp_2
-         Filter: ((a = 'a'::bpchar) OR (a = 'c'::bpchar))
+         Filter: (a = 'c'::bpchar)
 (5 rows)
 
 explain (costs off) select * from lp where a is not null and (a = 'a' or a = 'c');
-                                   QUERY PLAN                                   
---------------------------------------------------------------------------------
+            QUERY PLAN             
+-----------------------------------
  Append
    ->  Seq Scan on lp_ad lp_1
-         Filter: ((a IS NOT NULL) AND ((a = 'a'::bpchar) OR (a = 'c'::bpchar)))
+         Filter: (a = 'a'::bpchar)
    ->  Seq Scan on lp_bc lp_2
-         Filter: ((a IS NOT NULL) AND ((a = 'a'::bpchar) OR (a = 'c'::bpchar)))
+         Filter: (a = 'c'::bpchar)
 (5 rows)
 
 explain (costs off) select * from lp where a <> 'g';
-             QUERY PLAN             
-------------------------------------
+            QUERY PLAN             
+-----------------------------------
  Append
    ->  Seq Scan on lp_ad lp_1
-         Filter: (a <> 'g'::bpchar)
    ->  Seq Scan on lp_bc lp_2
-         Filter: (a <> 'g'::bpchar)
    ->  Seq Scan on lp_ef lp_3
-         Filter: (a <> 'g'::bpchar)
    ->  Seq Scan on lp_default lp_4
-         Filter: (a <> 'g'::bpchar)
-(9 rows)
+(5 rows)
 
 explain (costs off) select * from lp where a <> 'a' and a <> 'd';
-                         QUERY PLAN                          
--------------------------------------------------------------
+            QUERY PLAN             
+-----------------------------------
  Append
    ->  Seq Scan on lp_bc lp_1
-         Filter: ((a <> 'a'::bpchar) AND (a <> 'd'::bpchar))
    ->  Seq Scan on lp_ef lp_2
-         Filter: ((a <> 'a'::bpchar) AND (a <> 'd'::bpchar))
    ->  Seq Scan on lp_g lp_3
-         Filter: ((a <> 'a'::bpchar) AND (a <> 'd'::bpchar))
    ->  Seq Scan on lp_default lp_4
-         Filter: ((a <> 'a'::bpchar) AND (a <> 'd'::bpchar))
-(9 rows)
+(5 rows)
 
 explain (costs off) select * from lp where a not in ('a', 'd');
-                   QUERY PLAN                   
-------------------------------------------------
+            QUERY PLAN             
+-----------------------------------
  Append
    ->  Seq Scan on lp_bc lp_1
-         Filter: (a <> ALL ('{a,d}'::bpchar[]))
    ->  Seq Scan on lp_ef lp_2
-         Filter: (a <> ALL ('{a,d}'::bpchar[]))
    ->  Seq Scan on lp_g lp_3
-         Filter: (a <> ALL ('{a,d}'::bpchar[]))
    ->  Seq Scan on lp_default lp_4
-         Filter: (a <> ALL ('{a,d}'::bpchar[]))
-(9 rows)
+(5 rows)
 
 -- collation matches the partitioning collation, pruning works
 create table coll_pruning (a text collate "C") partition by list (a);
@@ -152,8 +132,7 @@ explain (costs off) select * from coll_pruning where a collate "C" = 'a' collate
                QUERY PLAN                
 -----------------------------------------
  Seq Scan on coll_pruning_a coll_pruning
-   Filter: (a = 'a'::text COLLATE "C")
-(2 rows)
+(1 row)
 
 -- collation doesn't match the partitioning collation, no pruning occurs
 explain (costs off) select * from coll_pruning where a collate "POSIX" = 'a' collate "POSIX";
@@ -193,25 +172,22 @@ explain (costs off) select * from rlp where a < 1;
       QUERY PLAN      
 ----------------------
  Seq Scan on rlp1 rlp
-   Filter: (a < 1)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from rlp where 1 > a;	/* commuted */
       QUERY PLAN      
 ----------------------
  Seq Scan on rlp1 rlp
-   Filter: (1 > a)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from rlp where a <= 1;
           QUERY PLAN          
 ------------------------------
  Append
    ->  Seq Scan on rlp1 rlp_1
-         Filter: (a <= 1)
    ->  Seq Scan on rlp2 rlp_2
          Filter: (a <= 1)
-(5 rows)
+(4 rows)
 
 explain (costs off) select * from rlp where a = 1;
       QUERY PLAN      
@@ -268,65 +244,47 @@ explain (costs off) select * from rlp where a <= 10;
 ---------------------------------------------
  Append
    ->  Seq Scan on rlp1 rlp_1
-         Filter: (a <= 10)
    ->  Seq Scan on rlp2 rlp_2
-         Filter: (a <= 10)
    ->  Seq Scan on rlp_default_10 rlp_3
-         Filter: (a <= 10)
    ->  Seq Scan on rlp_default_default rlp_4
          Filter: (a <= 10)
-(9 rows)
+(6 rows)
 
 explain (costs off) select * from rlp where a > 10;
                   QUERY PLAN                  
 ----------------------------------------------
  Append
    ->  Seq Scan on rlp3abcd rlp_1
-         Filter: (a > 10)
    ->  Seq Scan on rlp3efgh rlp_2
-         Filter: (a > 10)
    ->  Seq Scan on rlp3nullxy rlp_3
-         Filter: (a > 10)
    ->  Seq Scan on rlp3_default rlp_4
-         Filter: (a > 10)
    ->  Seq Scan on rlp4_1 rlp_5
-         Filter: (a > 10)
    ->  Seq Scan on rlp4_2 rlp_6
-         Filter: (a > 10)
    ->  Seq Scan on rlp4_default rlp_7
-         Filter: (a > 10)
    ->  Seq Scan on rlp5_1 rlp_8
-         Filter: (a > 10)
    ->  Seq Scan on rlp5_default rlp_9
-         Filter: (a > 10)
    ->  Seq Scan on rlp_default_30 rlp_10
-         Filter: (a > 10)
    ->  Seq Scan on rlp_default_default rlp_11
          Filter: (a > 10)
-(23 rows)
+(13 rows)
 
 explain (costs off) select * from rlp where a < 15;
                  QUERY PLAN                  
 ---------------------------------------------
  Append
    ->  Seq Scan on rlp1 rlp_1
-         Filter: (a < 15)
    ->  Seq Scan on rlp2 rlp_2
-         Filter: (a < 15)
    ->  Seq Scan on rlp_default_10 rlp_3
-         Filter: (a < 15)
    ->  Seq Scan on rlp_default_default rlp_4
          Filter: (a < 15)
-(9 rows)
+(6 rows)
 
 explain (costs off) select * from rlp where a <= 15;
                  QUERY PLAN                  
 ---------------------------------------------
  Append
    ->  Seq Scan on rlp1 rlp_1
-         Filter: (a <= 15)
    ->  Seq Scan on rlp2 rlp_2
-         Filter: (a <= 15)
    ->  Seq Scan on rlp3abcd rlp_3
          Filter: (a <= 15)
    ->  Seq Scan on rlp3efgh rlp_4
@@ -336,10 +294,9 @@ explain (costs off) select * from rlp where a <= 15;
    ->  Seq Scan on rlp3_default rlp_6
          Filter: (a <= 15)
    ->  Seq Scan on rlp_default_10 rlp_7
-         Filter: (a <= 15)
    ->  Seq Scan on rlp_default_default rlp_8
          Filter: (a <= 15)
-(17 rows)
+(14 rows)
 
 explain (costs off) select * from rlp where a > 15 and b = 'ab';
                        QUERY PLAN                        
@@ -348,17 +305,17 @@ explain (costs off) select * from rlp where a > 15 and b = 'ab';
    ->  Seq Scan on rlp3abcd rlp_1
          Filter: ((a > 15) AND ((b)::text = 'ab'::text))
    ->  Seq Scan on rlp4_1 rlp_2
-         Filter: ((a > 15) AND ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp4_2 rlp_3
-         Filter: ((a > 15) AND ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp4_default rlp_4
-         Filter: ((a > 15) AND ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp5_1 rlp_5
-         Filter: ((a > 15) AND ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp5_default rlp_6
-         Filter: ((a > 15) AND ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp_default_30 rlp_7
-         Filter: ((a > 15) AND ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp_default_default rlp_8
          Filter: ((a > 15) AND ((b)::text = 'ab'::text))
 (17 rows)
@@ -413,106 +370,77 @@ explain (costs off) select * from rlp where a = 16 and b is not null;
 ------------------------------------------------
  Append
    ->  Seq Scan on rlp3abcd rlp_1
-         Filter: ((b IS NOT NULL) AND (a = 16))
+         Filter: (a = 16)
    ->  Seq Scan on rlp3efgh rlp_2
-         Filter: ((b IS NOT NULL) AND (a = 16))
+         Filter: (a = 16)
    ->  Seq Scan on rlp3nullxy rlp_3
          Filter: ((b IS NOT NULL) AND (a = 16))
    ->  Seq Scan on rlp3_default rlp_4
-         Filter: ((b IS NOT NULL) AND (a = 16))
+         Filter: (a = 16)
 (9 rows)
 
 explain (costs off) select * from rlp where a is null;
             QUERY PLAN            
 ----------------------------------
  Seq Scan on rlp_default_null rlp
-   Filter: (a IS NULL)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from rlp where a is not null;
                   QUERY PLAN                  
 ----------------------------------------------
  Append
    ->  Seq Scan on rlp1 rlp_1
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp2 rlp_2
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp3abcd rlp_3
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp3efgh rlp_4
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp3nullxy rlp_5
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp3_default rlp_6
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp4_1 rlp_7
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp4_2 rlp_8
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp4_default rlp_9
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp5_1 rlp_10
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp5_default rlp_11
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp_default_10 rlp_12
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp_default_30 rlp_13
-         Filter: (a IS NOT NULL)
    ->  Seq Scan on rlp_default_default rlp_14
-         Filter: (a IS NOT NULL)
-(29 rows)
+(15 rows)
 
 explain (costs off) select * from rlp where a > 30;
                  QUERY PLAN                  
 ---------------------------------------------
  Append
    ->  Seq Scan on rlp5_1 rlp_1
-         Filter: (a > 30)
    ->  Seq Scan on rlp5_default rlp_2
-         Filter: (a > 30)
    ->  Seq Scan on rlp_default_default rlp_3
          Filter: (a > 30)
-(7 rows)
+(5 rows)
 
 explain (costs off) select * from rlp where a = 30;	/* only default is scanned */
            QUERY PLAN           
 --------------------------------
  Seq Scan on rlp_default_30 rlp
-   Filter: (a = 30)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from rlp where a <= 31;
                   QUERY PLAN                  
 ----------------------------------------------
  Append
    ->  Seq Scan on rlp1 rlp_1
-         Filter: (a <= 31)
    ->  Seq Scan on rlp2 rlp_2
-         Filter: (a <= 31)
    ->  Seq Scan on rlp3abcd rlp_3
-         Filter: (a <= 31)
    ->  Seq Scan on rlp3efgh rlp_4
-         Filter: (a <= 31)
    ->  Seq Scan on rlp3nullxy rlp_5
-         Filter: (a <= 31)
    ->  Seq Scan on rlp3_default rlp_6
-         Filter: (a <= 31)
    ->  Seq Scan on rlp4_1 rlp_7
-         Filter: (a <= 31)
    ->  Seq Scan on rlp4_2 rlp_8
-         Filter: (a <= 31)
    ->  Seq Scan on rlp4_default rlp_9
-         Filter: (a <= 31)
    ->  Seq Scan on rlp5_1 rlp_10
          Filter: (a <= 31)
    ->  Seq Scan on rlp_default_10 rlp_11
-         Filter: (a <= 31)
    ->  Seq Scan on rlp_default_30 rlp_12
-         Filter: (a <= 31)
    ->  Seq Scan on rlp_default_default rlp_13
          Filter: (a <= 31)
-(27 rows)
+(16 rows)
 
 explain (costs off) select * from rlp where a = 1 or a = 7;
            QUERY PLAN           
@@ -526,39 +454,39 @@ explain (costs off) select * from rlp where a = 1 or b = 'ab';
 -------------------------------------------------------
  Append
    ->  Seq Scan on rlp1 rlp_1
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp2 rlp_2
          Filter: ((a = 1) OR ((b)::text = 'ab'::text))
    ->  Seq Scan on rlp3abcd rlp_3
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp4_1 rlp_4
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp4_2 rlp_5
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp4_default rlp_6
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp5_1 rlp_7
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp5_default rlp_8
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp_default_10 rlp_9
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp_default_30 rlp_10
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp_default_null rlp_11
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
    ->  Seq Scan on rlp_default_default rlp_12
-         Filter: ((a = 1) OR ((b)::text = 'ab'::text))
+         Filter: ((b)::text = 'ab'::text)
 (25 rows)
 
 explain (costs off) select * from rlp where a > 20 and a < 27;
-               QUERY PLAN                
------------------------------------------
+           QUERY PLAN           
+--------------------------------
  Append
    ->  Seq Scan on rlp4_1 rlp_1
-         Filter: ((a > 20) AND (a < 27))
+         Filter: (a > 20)
    ->  Seq Scan on rlp4_2 rlp_2
-         Filter: ((a > 20) AND (a < 27))
+         Filter: (a < 27)
 (5 rows)
 
 explain (costs off) select * from rlp where a = 29;
@@ -575,34 +503,30 @@ explain (costs off) select * from rlp where a >= 29;
    ->  Seq Scan on rlp4_default rlp_1
          Filter: (a >= 29)
    ->  Seq Scan on rlp5_1 rlp_2
-         Filter: (a >= 29)
    ->  Seq Scan on rlp5_default rlp_3
-         Filter: (a >= 29)
    ->  Seq Scan on rlp_default_30 rlp_4
-         Filter: (a >= 29)
    ->  Seq Scan on rlp_default_default rlp_5
          Filter: (a >= 29)
-(11 rows)
+(8 rows)
 
 explain (costs off) select * from rlp where a < 1 or (a > 20 and a < 25);
-                      QUERY PLAN                      
-------------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Append
    ->  Seq Scan on rlp1 rlp_1
-         Filter: ((a < 1) OR ((a > 20) AND (a < 25)))
    ->  Seq Scan on rlp4_1 rlp_2
-         Filter: ((a < 1) OR ((a > 20) AND (a < 25)))
-(5 rows)
+         Filter: ((a > 20) AND (a < 25))
+(4 rows)
 
 -- where clause contradicts sub-partition's constraint
 explain (costs off) select * from rlp where a = 20 or a = 40;
-               QUERY PLAN               
-----------------------------------------
+              QUERY PLAN              
+--------------------------------------
  Append
    ->  Seq Scan on rlp4_1 rlp_1
-         Filter: ((a = 20) OR (a = 40))
+         Filter: (a = 20)
    ->  Seq Scan on rlp5_default rlp_2
-         Filter: ((a = 20) OR (a = 40))
+         Filter: (a = 40)
 (5 rows)
 
 explain (costs off) select * from rlp3 where a = 20;   /* empty */
@@ -614,39 +538,28 @@ explain (costs off) select * from rlp3 where a = 20;   /* empty */
 
 -- redundant clauses are eliminated
 explain (costs off) select * from rlp where a > 1 and a = 10;	/* only default */
-            QUERY PLAN            
-----------------------------------
+           QUERY PLAN           
+--------------------------------
  Seq Scan on rlp_default_10 rlp
-   Filter: ((a > 1) AND (a = 10))
-(2 rows)
+(1 row)
 
 explain (costs off) select * from rlp where a > 1 and a >=15;	/* rlp3 onwards, including default */
                   QUERY PLAN                  
 ----------------------------------------------
  Append
    ->  Seq Scan on rlp3abcd rlp_1
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp3efgh rlp_2
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp3nullxy rlp_3
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp3_default rlp_4
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp4_1 rlp_5
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp4_2 rlp_6
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp4_default rlp_7
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp5_1 rlp_8
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp5_default rlp_9
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp_default_30 rlp_10
-         Filter: ((a > 1) AND (a >= 15))
    ->  Seq Scan on rlp_default_default rlp_11
          Filter: ((a > 1) AND (a >= 15))
-(23 rows)
+(13 rows)
 
 explain (costs off) select * from rlp where a = 1 and a = 3;	/* empty */
         QUERY PLAN        
@@ -656,19 +569,19 @@ explain (costs off) select * from rlp where a = 1 and a = 3;	/* empty */
 (2 rows)
 
 explain (costs off) select * from rlp where (a = 1 and a = 3) or (a > 1 and a = 15);
-                            QUERY PLAN                             
--------------------------------------------------------------------
+               QUERY PLAN               
+----------------------------------------
  Append
    ->  Seq Scan on rlp2 rlp_1
-         Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
+         Filter: ((a = 1) AND (a = 3))
    ->  Seq Scan on rlp3abcd rlp_2
-         Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
+         Filter: ((a > 1) AND (a = 15))
    ->  Seq Scan on rlp3efgh rlp_3
-         Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
+         Filter: ((a > 1) AND (a = 15))
    ->  Seq Scan on rlp3nullxy rlp_4
-         Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
+         Filter: ((a > 1) AND (a = 15))
    ->  Seq Scan on rlp3_default rlp_5
-         Filter: (((a = 1) AND (a = 3)) OR ((a > 1) AND (a = 15)))
+         Filter: ((a > 1) AND (a = 15))
 (11 rows)
 
 -- multi-column keys
@@ -733,28 +646,23 @@ explain (costs off) select * from mc3p where a = 10 and abs(b) between 5 and 35;
    ->  Seq Scan on mc3p1 mc3p_1
          Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
    ->  Seq Scan on mc3p2 mc3p_2
-         Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
    ->  Seq Scan on mc3p3 mc3p_3
-         Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
    ->  Seq Scan on mc3p4 mc3p_4
-         Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
+         Filter: (abs(b) <= 35)
    ->  Seq Scan on mc3p_default mc3p_5
          Filter: ((a = 10) AND (abs(b) >= 5) AND (abs(b) <= 35))
-(11 rows)
+(9 rows)
 
 explain (costs off) select * from mc3p where a > 10;
               QUERY PLAN               
 ---------------------------------------
  Append
    ->  Seq Scan on mc3p5 mc3p_1
-         Filter: (a > 10)
    ->  Seq Scan on mc3p6 mc3p_2
-         Filter: (a > 10)
    ->  Seq Scan on mc3p7 mc3p_3
-         Filter: (a > 10)
    ->  Seq Scan on mc3p_default mc3p_4
          Filter: (a > 10)
-(9 rows)
+(6 rows)
 
 explain (costs off) select * from mc3p where a >= 10;
               QUERY PLAN               
@@ -763,43 +671,36 @@ explain (costs off) select * from mc3p where a >= 10;
    ->  Seq Scan on mc3p1 mc3p_1
          Filter: (a >= 10)
    ->  Seq Scan on mc3p2 mc3p_2
-         Filter: (a >= 10)
    ->  Seq Scan on mc3p3 mc3p_3
-         Filter: (a >= 10)
    ->  Seq Scan on mc3p4 mc3p_4
-         Filter: (a >= 10)
    ->  Seq Scan on mc3p5 mc3p_5
-         Filter: (a >= 10)
    ->  Seq Scan on mc3p6 mc3p_6
-         Filter: (a >= 10)
    ->  Seq Scan on mc3p7 mc3p_7
-         Filter: (a >= 10)
    ->  Seq Scan on mc3p_default mc3p_8
          Filter: (a >= 10)
-(17 rows)
+(11 rows)
 
 explain (costs off) select * from mc3p where a < 10;
               QUERY PLAN               
 ---------------------------------------
  Append
    ->  Seq Scan on mc3p0 mc3p_1
-         Filter: (a < 10)
    ->  Seq Scan on mc3p1 mc3p_2
          Filter: (a < 10)
    ->  Seq Scan on mc3p_default mc3p_3
          Filter: (a < 10)
-(7 rows)
+(6 rows)
 
 explain (costs off) select * from mc3p where a <= 10 and abs(b) < 10;
                   QUERY PLAN                   
 -----------------------------------------------
  Append
    ->  Seq Scan on mc3p0 mc3p_1
-         Filter: ((a <= 10) AND (abs(b) < 10))
+         Filter: (abs(b) < 10)
    ->  Seq Scan on mc3p1 mc3p_2
-         Filter: ((a <= 10) AND (abs(b) < 10))
+         Filter: (abs(b) < 10)
    ->  Seq Scan on mc3p2 mc3p_3
-         Filter: ((a <= 10) AND (abs(b) < 10))
+         Filter: (abs(b) < 10)
    ->  Seq Scan on mc3p_default mc3p_4
          Filter: ((a <= 10) AND (abs(b) < 10))
 (9 rows)
@@ -812,10 +713,10 @@ explain (costs off) select * from mc3p where a = 11 and abs(b) = 0;
 (2 rows)
 
 explain (costs off) select * from mc3p where a = 20 and abs(b) = 10 and c = 100;
-                      QUERY PLAN                      
-------------------------------------------------------
+               QUERY PLAN                
+-----------------------------------------
  Seq Scan on mc3p6 mc3p
-   Filter: ((a = 20) AND (c = 100) AND (abs(b) = 10))
+   Filter: ((c = 100) AND (abs(b) = 10))
 (2 rows)
 
 explain (costs off) select * from mc3p where a > 20;
@@ -835,23 +736,21 @@ explain (costs off) select * from mc3p where a >= 20;
    ->  Seq Scan on mc3p5 mc3p_1
          Filter: (a >= 20)
    ->  Seq Scan on mc3p6 mc3p_2
-         Filter: (a >= 20)
    ->  Seq Scan on mc3p7 mc3p_3
-         Filter: (a >= 20)
    ->  Seq Scan on mc3p_default mc3p_4
          Filter: (a >= 20)
-(9 rows)
+(7 rows)
 
 explain (costs off) select * from mc3p where (a = 1 and abs(b) = 1 and c = 1) or (a = 10 and abs(b) = 5 and c = 10) or (a > 11 and a < 20);
                                                            QUERY PLAN                                                            
 ---------------------------------------------------------------------------------------------------------------------------------
  Append
    ->  Seq Scan on mc3p1 mc3p_1
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)))
+         Filter: ((a = 1) AND (c = 1) AND (abs(b) = 1))
    ->  Seq Scan on mc3p2 mc3p_2
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)))
+         Filter: ((a = 10) AND (c = 10) AND (abs(b) = 5))
    ->  Seq Scan on mc3p5 mc3p_3
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)))
+         Filter: ((a > 11) AND (a < 20))
    ->  Seq Scan on mc3p_default mc3p_4
          Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)))
 (9 rows)
@@ -861,13 +760,13 @@ explain (costs off) select * from mc3p where (a = 1 and abs(b) = 1 and c = 1) or
 --------------------------------------------------------------------------------------------------------------------------------------------
  Append
    ->  Seq Scan on mc3p0 mc3p_1
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
+         Filter: (a < 1)
    ->  Seq Scan on mc3p1 mc3p_2
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
+         Filter: ((a = 1) AND (c = 1) AND (abs(b) = 1))
    ->  Seq Scan on mc3p2 mc3p_3
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
+         Filter: ((a = 10) AND (c = 10) AND (abs(b) = 5))
    ->  Seq Scan on mc3p5 mc3p_4
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
+         Filter: ((a > 11) AND (a < 20))
    ->  Seq Scan on mc3p_default mc3p_5
          Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1))
 (11 rows)
@@ -877,13 +776,13 @@ explain (costs off) select * from mc3p where (a = 1 and abs(b) = 1 and c = 1) or
 -------------------------------------------------------------------------------------------------------------------------------------------------------
  Append
    ->  Seq Scan on mc3p0 mc3p_1
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
+         Filter: ((a < 1) OR (a = 1))
    ->  Seq Scan on mc3p1 mc3p_2
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
+         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR (a = 1))
    ->  Seq Scan on mc3p2 mc3p_3
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
+         Filter: ((a = 10) AND (c = 10) AND (abs(b) = 5))
    ->  Seq Scan on mc3p5 mc3p_4
-         Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
+         Filter: ((a > 11) AND (a < 20))
    ->  Seq Scan on mc3p_default mc3p_5
          Filter: (((a = 1) AND (abs(b) = 1) AND (c = 1)) OR ((a = 10) AND (abs(b) = 5) AND (c = 10)) OR ((a > 11) AND (a < 20)) OR (a < 1) OR (a = 1))
 (11 rows)
@@ -897,17 +796,17 @@ explain (costs off) select * from mc3p where a = 1 or abs(b) = 1 or c = 1;
    ->  Seq Scan on mc3p1 mc3p_2
          Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
    ->  Seq Scan on mc3p2 mc3p_3
-         Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
+         Filter: (c = 1)
    ->  Seq Scan on mc3p3 mc3p_4
          Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
    ->  Seq Scan on mc3p4 mc3p_5
-         Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
+         Filter: (c = 1)
    ->  Seq Scan on mc3p5 mc3p_6
-         Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
+         Filter: ((abs(b) = 1) OR (c = 1))
    ->  Seq Scan on mc3p6 mc3p_7
-         Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
+         Filter: (c = 1)
    ->  Seq Scan on mc3p7 mc3p_8
-         Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
+         Filter: ((abs(b) = 1) OR (c = 1))
    ->  Seq Scan on mc3p_default mc3p_9
          Filter: ((a = 1) OR (abs(b) = 1) OR (c = 1))
 (19 rows)
@@ -917,29 +816,28 @@ explain (costs off) select * from mc3p where (a = 1 and abs(b) = 1) or (a = 10 a
 ------------------------------------------------------------------------------
  Append
    ->  Seq Scan on mc3p0 mc3p_1
-         Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
+         Filter: ((a = 1) AND (abs(b) = 1))
    ->  Seq Scan on mc3p1 mc3p_2
-         Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
+         Filter: ((a = 1) AND (abs(b) = 1))
    ->  Seq Scan on mc3p2 mc3p_3
-         Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
+         Filter: ((a = 10) AND (abs(b) = 10))
    ->  Seq Scan on mc3p3 mc3p_4
-         Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
    ->  Seq Scan on mc3p4 mc3p_5
-         Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
+         Filter: ((a = 10) AND (abs(b) = 10))
    ->  Seq Scan on mc3p_default mc3p_6
          Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 10)))
-(13 rows)
+(12 rows)
 
 explain (costs off) select * from mc3p where (a = 1 and abs(b) = 1) or (a = 10 and abs(b) = 9);
                                  QUERY PLAN                                  
 -----------------------------------------------------------------------------
  Append
    ->  Seq Scan on mc3p0 mc3p_1
-         Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 9)))
+         Filter: ((a = 1) AND (abs(b) = 1))
    ->  Seq Scan on mc3p1 mc3p_2
-         Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 9)))
+         Filter: ((a = 1) AND (abs(b) = 1))
    ->  Seq Scan on mc3p2 mc3p_3
-         Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 9)))
+         Filter: ((a = 10) AND (abs(b) = 9))
    ->  Seq Scan on mc3p_default mc3p_4
          Filter: (((a = 1) AND (abs(b) = 1)) OR ((a = 10) AND (abs(b) = 9)))
 (9 rows)
@@ -958,21 +856,17 @@ explain (costs off) select * from mc2p where a < 2;
 ---------------------------------------
  Append
    ->  Seq Scan on mc2p0 mc2p_1
-         Filter: (a < 2)
    ->  Seq Scan on mc2p1 mc2p_2
-         Filter: (a < 2)
    ->  Seq Scan on mc2p2 mc2p_3
-         Filter: (a < 2)
    ->  Seq Scan on mc2p_default mc2p_4
          Filter: (a < 2)
-(9 rows)
+(6 rows)
 
 explain (costs off) select * from mc2p where a = 2 and b < 1;
-           QUERY PLAN            
----------------------------------
+       QUERY PLAN       
+------------------------
  Seq Scan on mc2p3 mc2p
-   Filter: ((b < 1) AND (a = 2))
-(2 rows)
+(1 row)
 
 explain (costs off) select * from mc2p where a > 1;
               QUERY PLAN               
@@ -981,14 +875,11 @@ explain (costs off) select * from mc2p where a > 1;
    ->  Seq Scan on mc2p2 mc2p_1
          Filter: (a > 1)
    ->  Seq Scan on mc2p3 mc2p_2
-         Filter: (a > 1)
    ->  Seq Scan on mc2p4 mc2p_3
-         Filter: (a > 1)
    ->  Seq Scan on mc2p5 mc2p_4
-         Filter: (a > 1)
    ->  Seq Scan on mc2p_default mc2p_5
          Filter: (a > 1)
-(11 rows)
+(8 rows)
 
 explain (costs off) select * from mc2p where a = 1 and b > 1;
            QUERY PLAN            
@@ -1052,15 +943,13 @@ explain (costs off) select * from boolpart where a = false;
            QUERY PLAN            
 ---------------------------------
  Seq Scan on boolpart_f boolpart
-   Filter: (NOT a)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from boolpart where not a = false;
            QUERY PLAN            
 ---------------------------------
  Seq Scan on boolpart_t boolpart
-   Filter: a
-(2 rows)
+(1 row)
 
 explain (costs off) select * from boolpart where a is true or a is not true;
                     QUERY PLAN                    
@@ -1069,7 +958,7 @@ explain (costs off) select * from boolpart where a is true or a is not true;
    ->  Seq Scan on boolpart_f boolpart_1
          Filter: ((a IS TRUE) OR (a IS NOT TRUE))
    ->  Seq Scan on boolpart_t boolpart_2
-         Filter: ((a IS TRUE) OR (a IS NOT TRUE))
+         Filter: (a IS TRUE)
 (5 rows)
 
 explain (costs off) select * from boolpart where a is not true;
@@ -1117,10 +1006,10 @@ create table boolrangep_ff1 partition of boolrangep for values from ('false', 'f
 create table boolrangep_ff2 partition of boolrangep for values from ('false', 'false', 50) to ('false', 'false', 100);
 -- try a more complex case that's been known to trip up pruning in the past
 explain (costs off)  select * from boolrangep where not a and not b and c = 25;
-                  QUERY PLAN                  
-----------------------------------------------
+              QUERY PLAN               
+---------------------------------------
  Seq Scan on boolrangep_ff1 boolrangep
-   Filter: ((NOT a) AND (NOT b) AND (c = 25))
+   Filter: (c = 25)
 (2 rows)
 
 -- test scalar-to-array operators
@@ -1189,21 +1078,18 @@ explain (costs off) select * from coercepart where a !~ all ('{ab,bc}');
 (7 rows)
 
 explain (costs off) select * from coercepart where a = any ('{ab,bc}');
-                      QUERY PLAN                       
--------------------------------------------------------
+                  QUERY PLAN                  
+----------------------------------------------
  Append
    ->  Seq Scan on coercepart_ab coercepart_1
-         Filter: ((a)::text = ANY ('{ab,bc}'::text[]))
    ->  Seq Scan on coercepart_bc coercepart_2
-         Filter: ((a)::text = ANY ('{ab,bc}'::text[]))
-(5 rows)
+(3 rows)
 
 explain (costs off) select * from coercepart where a = any ('{ab,null}');
-                    QUERY PLAN                     
----------------------------------------------------
+              QUERY PLAN              
+--------------------------------------
  Seq Scan on coercepart_ab coercepart
-   Filter: ((a)::text = ANY ('{ab,NULL}'::text[]))
-(2 rows)
+(1 row)
 
 explain (costs off) select * from coercepart where a = any (null::text[]);
         QUERY PLAN        
@@ -1213,11 +1099,10 @@ explain (costs off) select * from coercepart where a = any (null::text[]);
 (2 rows)
 
 explain (costs off) select * from coercepart where a = all ('{ab}');
-                  QUERY PLAN                  
-----------------------------------------------
+              QUERY PLAN              
+--------------------------------------
  Seq Scan on coercepart_ab coercepart
-   Filter: ((a)::text = ALL ('{ab}'::text[]))
-(2 rows)
+(1 row)
 
 explain (costs off) select * from coercepart where a = all ('{ab,bc}');
         QUERY PLAN        
@@ -1289,7 +1174,6 @@ explain (costs off) select * from mc2p t1, lateral (select count(*) from mc3p t2
  Nested Loop
    ->  Append
          ->  Seq Scan on mc2p1 t1_1
-               Filter: (a = 1)
          ->  Seq Scan on mc2p2 t1_2
                Filter: (a = 1)
          ->  Seq Scan on mc2p_default t1_3
@@ -1314,7 +1198,7 @@ explain (costs off) select * from mc2p t1, lateral (select count(*) from mc3p t2
                      Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
                ->  Seq Scan on mc3p_default t2_9
                      Filter: ((a = t1.b) AND (c = 1) AND (abs(b) = 1))
-(28 rows)
+(27 rows)
 
 -- pruning should work fine, because values for a prefix of keys (a, b) are
 -- available
@@ -1324,7 +1208,6 @@ explain (costs off) select * from mc2p t1, lateral (select count(*) from mc3p t2
  Nested Loop
    ->  Append
          ->  Seq Scan on mc2p1 t1_1
-               Filter: (a = 1)
          ->  Seq Scan on mc2p2 t1_2
                Filter: (a = 1)
          ->  Seq Scan on mc2p_default t1_3
@@ -1337,7 +1220,7 @@ explain (costs off) select * from mc2p t1, lateral (select count(*) from mc3p t2
                      Filter: ((c = t1.b) AND (a = 1) AND (abs(b) = 1))
                ->  Seq Scan on mc3p_default t2_3
                      Filter: ((c = t1.b) AND (a = 1) AND (abs(b) = 1))
-(16 rows)
+(15 rows)
 
 -- also here, because values for all keys are provided
 explain (costs off) select * from mc2p t1, lateral (select count(*) from mc3p t2 where t2.a = 1 and abs(t2.b) = 1 and t2.c = 1) s where t1.a = 1;
@@ -1349,12 +1232,11 @@ explain (costs off) select * from mc2p t1, lateral (select count(*) from mc3p t2
                Filter: ((a = 1) AND (c = 1) AND (abs(b) = 1))
    ->  Append
          ->  Seq Scan on mc2p1 t1_1
-               Filter: (a = 1)
          ->  Seq Scan on mc2p2 t1_2
                Filter: (a = 1)
          ->  Seq Scan on mc2p_default t1_3
                Filter: (a = 1)
-(11 rows)
+(10 rows)
 
 --
 -- pruning with clauses containing <> operator
@@ -1369,24 +1251,21 @@ explain (costs off) select * from rp where a <> 1;
 ----------------------------
  Append
    ->  Seq Scan on rp0 rp_1
-         Filter: (a <> 1)
    ->  Seq Scan on rp1 rp_2
          Filter: (a <> 1)
    ->  Seq Scan on rp2 rp_3
-         Filter: (a <> 1)
-(7 rows)
+(5 rows)
 
 explain (costs off) select * from rp where a <> 1 and a <> 2;
-               QUERY PLAN                
------------------------------------------
+         QUERY PLAN         
+----------------------------
  Append
    ->  Seq Scan on rp0 rp_1
-         Filter: ((a <> 1) AND (a <> 2))
    ->  Seq Scan on rp1 rp_2
-         Filter: ((a <> 1) AND (a <> 2))
+         Filter: (a <> 1)
    ->  Seq Scan on rp2 rp_3
-         Filter: ((a <> 1) AND (a <> 2))
-(7 rows)
+         Filter: (a <> 2)
+(6 rows)
 
 -- null partition should be eliminated due to strict <> clause.
 explain (costs off) select * from lp where a <> 'a';
@@ -1396,14 +1275,10 @@ explain (costs off) select * from lp where a <> 'a';
    ->  Seq Scan on lp_ad lp_1
          Filter: (a <> 'a'::bpchar)
    ->  Seq Scan on lp_bc lp_2
-         Filter: (a <> 'a'::bpchar)
    ->  Seq Scan on lp_ef lp_3
-         Filter: (a <> 'a'::bpchar)
    ->  Seq Scan on lp_g lp_4
-         Filter: (a <> 'a'::bpchar)
    ->  Seq Scan on lp_default lp_5
-         Filter: (a <> 'a'::bpchar)
-(11 rows)
+(7 rows)
 
 -- ensure we detect contradictions in clauses; a can't be NULL and NOT NULL.
 explain (costs off) select * from lp where a <> 'a' and a is null;
@@ -1414,32 +1289,27 @@ explain (costs off) select * from lp where a <> 'a' and a is null;
 (2 rows)
 
 explain (costs off) select * from lp where (a <> 'a' and a <> 'd') or a is null;
-                                  QUERY PLAN                                  
-------------------------------------------------------------------------------
+            QUERY PLAN             
+-----------------------------------
  Append
    ->  Seq Scan on lp_bc lp_1
-         Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
    ->  Seq Scan on lp_ef lp_2
-         Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
    ->  Seq Scan on lp_g lp_3
-         Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
    ->  Seq Scan on lp_null lp_4
-         Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
    ->  Seq Scan on lp_default lp_5
-         Filter: (((a <> 'a'::bpchar) AND (a <> 'd'::bpchar)) OR (a IS NULL))
-(11 rows)
+(6 rows)
 
 -- check that it also works for a partitioned table that's not root,
 -- which in this case are partitions of rlp that are themselves
 -- list-partitioned on b
 explain (costs off) select * from rlp where a = 15 and b <> 'ab' and b <> 'cd' and b <> 'xy' and b is not null;
-                                                                QUERY PLAN                                                                
-------------------------------------------------------------------------------------------------------------------------------------------
+              QUERY PLAN              
+--------------------------------------
  Append
    ->  Seq Scan on rlp3efgh rlp_1
-         Filter: ((b IS NOT NULL) AND ((b)::text <> 'ab'::text) AND ((b)::text <> 'cd'::text) AND ((b)::text <> 'xy'::text) AND (a = 15))
+         Filter: (a = 15)
    ->  Seq Scan on rlp3_default rlp_2
-         Filter: ((b IS NOT NULL) AND ((b)::text <> 'ab'::text) AND ((b)::text <> 'cd'::text) AND ((b)::text <> 'xy'::text) AND (a = 15))
+         Filter: (a = 15)
 (5 rows)
 
 --
@@ -1780,9 +1650,9 @@ explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 2);
  Append (actual rows=0 loops=1)
    Subplans Removed: 4
    ->  Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
-         Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
+         Filter: ((a >= $1) AND (a <= $2))
    ->  Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
-         Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
+         Filter: ((a >= $1) AND (a <= $2))
 (6 rows)
 
 explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 4);
@@ -1791,13 +1661,13 @@ explain (analyze, costs off, summary off, timing off) execute ab_q1 (2, 4);
  Append (actual rows=0 loops=1)
    Subplans Removed: 2
    ->  Seq Scan on ab_a2_b1 ab_1 (actual rows=0 loops=1)
-         Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
+         Filter: ((a >= $1) AND (a <= $2))
    ->  Seq Scan on ab_a2_b2 ab_2 (actual rows=0 loops=1)
-         Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
+         Filter: ((a >= $1) AND (a <= $2))
    ->  Seq Scan on ab_a3_b1 ab_3 (actual rows=0 loops=1)
-         Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
+         Filter: ((a >= $1) AND (a <= $2))
    ->  Seq Scan on ab_a3_b2 ab_4 (actual rows=0 loops=1)
-         Filter: ((a >= $1) AND (a <= $2) AND (b < 3))
+         Filter: ((a >= $1) AND (a <= $2))
 (10 rows)
 
 -- Ensure a mix of PARAM_EXTERN and PARAM_EXEC Params work together at
@@ -1952,11 +1822,11 @@ select explain_parallel_append('execute ab_q4 (2, 2)');
                ->  Parallel Append (actual rows=N loops=N)
                      Subplans Removed: 6
                      ->  Parallel Seq Scan on ab_a2_b1 ab_1 (actual rows=N loops=N)
-                           Filter: ((a >= $1) AND (a <= $2) AND (b < 4))
+                           Filter: ((a >= $1) AND (a <= $2))
                      ->  Parallel Seq Scan on ab_a2_b2 ab_2 (actual rows=N loops=N)
-                           Filter: ((a >= $1) AND (a <= $2) AND (b < 4))
+                           Filter: ((a >= $1) AND (a <= $2))
                      ->  Parallel Seq Scan on ab_a2_b3 ab_3 (actual rows=N loops=N)
-                           Filter: ((a >= $1) AND (a <= $2) AND (b < 4))
+                           Filter: ((a >= $1) AND (a <= $2))
 (13 rows)
 
 -- Test run-time pruning with IN lists.
@@ -1973,11 +1843,11 @@ select explain_parallel_append('execute ab_q5 (1, 1, 1)');
                ->  Parallel Append (actual rows=N loops=N)
                      Subplans Removed: 6
                      ->  Parallel Seq Scan on ab_a1_b1 ab_1 (actual rows=N loops=N)
-                           Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
+                           Filter: (a = ANY (ARRAY[$1, $2, $3]))
                      ->  Parallel Seq Scan on ab_a1_b2 ab_2 (actual rows=N loops=N)
-                           Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
+                           Filter: (a = ANY (ARRAY[$1, $2, $3]))
                      ->  Parallel Seq Scan on ab_a1_b3 ab_3 (actual rows=N loops=N)
-                           Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
+                           Filter: (a = ANY (ARRAY[$1, $2, $3]))
 (13 rows)
 
 select explain_parallel_append('execute ab_q5 (2, 3, 3)');
@@ -1991,17 +1861,17 @@ select explain_parallel_append('execute ab_q5 (2, 3, 3)');
                ->  Parallel Append (actual rows=N loops=N)
                      Subplans Removed: 3
                      ->  Parallel Seq Scan on ab_a2_b1 ab_1 (actual rows=N loops=N)
-                           Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
+                           Filter: (a = ANY (ARRAY[$1, $2, $3]))
                      ->  Parallel Seq Scan on ab_a2_b2 ab_2 (actual rows=N loops=N)
-                           Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
+                           Filter: (a = ANY (ARRAY[$1, $2, $3]))
                      ->  Parallel Seq Scan on ab_a2_b3 ab_3 (actual rows=N loops=N)
-                           Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
+                           Filter: (a = ANY (ARRAY[$1, $2, $3]))
                      ->  Parallel Seq Scan on ab_a3_b1 ab_4 (actual rows=N loops=N)
-                           Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
+                           Filter: (a = ANY (ARRAY[$1, $2, $3]))
                      ->  Parallel Seq Scan on ab_a3_b2 ab_5 (actual rows=N loops=N)
-                           Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
+                           Filter: (a = ANY (ARRAY[$1, $2, $3]))
                      ->  Parallel Seq Scan on ab_a3_b3 ab_6 (actual rows=N loops=N)
-                           Filter: ((b < 4) AND (a = ANY (ARRAY[$1, $2, $3])))
+                           Filter: (a = ANY (ARRAY[$1, $2, $3]))
 (19 rows)
 
 -- Try some params whose values do not belong to any partition.
@@ -2019,9 +1889,9 @@ select explain_parallel_append('execute ab_q5 (33, 44, 55)');
 
 -- Test Parallel Append with PARAM_EXEC Params
 select explain_parallel_append('select count(*) from ab where (a = (select 1) or a = (select 3)) and b = 2');
-                           explain_parallel_append                            
-------------------------------------------------------------------------------
- Aggregate (actual rows=N loops=N)
+                              explain_parallel_append                               
+------------------------------------------------------------------------------------
+ Finalize Aggregate (actual rows=N loops=N)
    InitPlan 1 (returns $0)
      ->  Result (actual rows=N loops=N)
    InitPlan 2 (returns $1)
@@ -2030,14 +1900,15 @@ select explain_parallel_append('select count(*) from ab where (a = (select 1) or
          Workers Planned: 2
          Params Evaluated: $0, $1
          Workers Launched: N
-         ->  Parallel Append (actual rows=N loops=N)
-               ->  Parallel Seq Scan on ab_a1_b2 ab_1 (actual rows=N loops=N)
-                     Filter: ((b = 2) AND ((a = $0) OR (a = $1)))
-               ->  Parallel Seq Scan on ab_a2_b2 ab_2 (never executed)
-                     Filter: ((b = 2) AND ((a = $0) OR (a = $1)))
-               ->  Parallel Seq Scan on ab_a3_b2 ab_3 (actual rows=N loops=N)
-                     Filter: ((b = 2) AND ((a = $0) OR (a = $1)))
-(16 rows)
+         ->  Partial Aggregate (actual rows=N loops=N)
+               ->  Parallel Append (actual rows=N loops=N)
+                     ->  Parallel Seq Scan on ab_a1_b2 ab_1 (actual rows=N loops=N)
+                           Filter: ((a = $0) OR (a = $1))
+                     ->  Parallel Seq Scan on ab_a2_b2 ab_2 (never executed)
+                           Filter: ((a = $0) OR (a = $1))
+                     ->  Parallel Seq Scan on ab_a3_b2 ab_3 (actual rows=N loops=N)
+                           Filter: ((a = $0) OR (a = $1))
+(17 rows)
 
 -- Test pruning during parallel nested loop query
 create table lprt_a (a int not null);
@@ -2291,27 +2162,18 @@ select * from ab where a = (select max(a) from lprt_a) and b = (select max(a)-1
 -- Test run-time partition pruning with UNION ALL parents
 explain (analyze, costs off, summary off, timing off)
 select * from (select * from ab where a = 1 union all select * from ab) ab where b = (select 1);
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                           QUERY PLAN                           
+----------------------------------------------------------------
  Append (actual rows=0 loops=1)
    InitPlan 1 (returns $0)
      ->  Result (actual rows=1 loops=1)
    ->  Append (actual rows=0 loops=1)
-         ->  Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0 loops=1)
-               Recheck Cond: (a = 1)
+         ->  Seq Scan on ab_a1_b1 ab_11 (actual rows=0 loops=1)
                Filter: (b = $0)
-               ->  Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
-                     Index Cond: (a = 1)
-         ->  Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
-               Recheck Cond: (a = 1)
+         ->  Seq Scan on ab_a1_b2 ab_12 (never executed)
                Filter: (b = $0)
-               ->  Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
-                     Index Cond: (a = 1)
-         ->  Bitmap Heap Scan on ab_a1_b3 ab_13 (never executed)
-               Recheck Cond: (a = 1)
+         ->  Seq Scan on ab_a1_b3 ab_13 (never executed)
                Filter: (b = $0)
-               ->  Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
-                     Index Cond: (a = 1)
    ->  Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
          Filter: (b = $0)
    ->  Seq Scan on ab_a1_b2 ab_2 (never executed)
@@ -2330,32 +2192,23 @@ select * from (select * from ab where a = 1 union all select * from ab) ab where
          Filter: (b = $0)
    ->  Seq Scan on ab_a3_b3 ab_9 (never executed)
          Filter: (b = $0)
-(37 rows)
+(28 rows)
 
 -- A case containing a UNION ALL with a non-partitioned child.
 explain (analyze, costs off, summary off, timing off)
 select * from (select * from ab where a = 1 union all (values(10,5)) union all select * from ab) ab where b = (select 1);
-                                  QUERY PLAN                                   
--------------------------------------------------------------------------------
+                           QUERY PLAN                           
+----------------------------------------------------------------
  Append (actual rows=0 loops=1)
    InitPlan 1 (returns $0)
      ->  Result (actual rows=1 loops=1)
    ->  Append (actual rows=0 loops=1)
-         ->  Bitmap Heap Scan on ab_a1_b1 ab_11 (actual rows=0 loops=1)
-               Recheck Cond: (a = 1)
+         ->  Seq Scan on ab_a1_b1 ab_11 (actual rows=0 loops=1)
                Filter: (b = $0)
-               ->  Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
-                     Index Cond: (a = 1)
-         ->  Bitmap Heap Scan on ab_a1_b2 ab_12 (never executed)
-               Recheck Cond: (a = 1)
+         ->  Seq Scan on ab_a1_b2 ab_12 (never executed)
                Filter: (b = $0)
-               ->  Bitmap Index Scan on ab_a1_b2_a_idx (never executed)
-                     Index Cond: (a = 1)
-         ->  Bitmap Heap Scan on ab_a1_b3 ab_13 (never executed)
-               Recheck Cond: (a = 1)
+         ->  Seq Scan on ab_a1_b3 ab_13 (never executed)
                Filter: (b = $0)
-               ->  Bitmap Index Scan on ab_a1_b3_a_idx (never executed)
-                     Index Cond: (a = 1)
    ->  Result (actual rows=0 loops=1)
          One-Time Filter: (5 = $0)
    ->  Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
@@ -2376,7 +2229,7 @@ select * from (select * from ab where a = 1 union all (values(10,5)) union all s
          Filter: (b = $0)
    ->  Seq Scan on ab_a3_b3 ab_9 (never executed)
          Filter: (b = $0)
-(39 rows)
+(30 rows)
 
 -- Another UNION ALL test, but containing a mix of exec init and exec run-time pruning.
 create table xy_1 (x int, y int);
@@ -2435,74 +2288,34 @@ deallocate ab_q6;
 insert into ab values (1,2);
 explain (analyze, costs off, summary off, timing off)
 update ab_a1 set b = 3 from ab where ab.a = 1 and ab.a = ab_a1.a;
-                                     QUERY PLAN                                      
--------------------------------------------------------------------------------------
+                               QUERY PLAN                               
+------------------------------------------------------------------------
  Update on ab_a1 (actual rows=0 loops=1)
    Update on ab_a1_b1 ab_a1_1
    Update on ab_a1_b2 ab_a1_2
    Update on ab_a1_b3 ab_a1_3
    ->  Nested Loop (actual rows=0 loops=1)
          ->  Append (actual rows=1 loops=1)
-               ->  Bitmap Heap Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
-                     Recheck Cond: (a = 1)
-                     ->  Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
-                           Index Cond: (a = 1)
-               ->  Bitmap Heap Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
-                     Recheck Cond: (a = 1)
-                     Heap Blocks: exact=1
-                     ->  Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1)
-                           Index Cond: (a = 1)
-               ->  Bitmap Heap Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
-                     Recheck Cond: (a = 1)
-                     ->  Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=0 loops=1)
-                           Index Cond: (a = 1)
+               ->  Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
+               ->  Seq Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
+               ->  Seq Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
          ->  Materialize (actual rows=0 loops=1)
-               ->  Bitmap Heap Scan on ab_a1_b1 ab_a1_1 (actual rows=0 loops=1)
-                     Recheck Cond: (a = 1)
-                     ->  Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
-                           Index Cond: (a = 1)
+               ->  Seq Scan on ab_a1_b1 ab_a1_1 (actual rows=0 loops=1)
    ->  Nested Loop (actual rows=1 loops=1)
          ->  Append (actual rows=1 loops=1)
-               ->  Bitmap Heap Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
-                     Recheck Cond: (a = 1)
-                     ->  Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
-                           Index Cond: (a = 1)
-               ->  Bitmap Heap Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
-                     Recheck Cond: (a = 1)
-                     Heap Blocks: exact=1
-                     ->  Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1)
-                           Index Cond: (a = 1)
-               ->  Bitmap Heap Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
-                     Recheck Cond: (a = 1)
-                     ->  Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1)
-                           Index Cond: (a = 1)
+               ->  Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
+               ->  Seq Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
+               ->  Seq Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
          ->  Materialize (actual rows=1 loops=1)
-               ->  Bitmap Heap Scan on ab_a1_b2 ab_a1_2 (actual rows=1 loops=1)
-                     Recheck Cond: (a = 1)
-                     Heap Blocks: exact=1
-                     ->  Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1)
-                           Index Cond: (a = 1)
+               ->  Seq Scan on ab_a1_b2 ab_a1_2 (actual rows=1 loops=1)
    ->  Nested Loop (actual rows=0 loops=1)
          ->  Append (actual rows=1 loops=1)
-               ->  Bitmap Heap Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
-                     Recheck Cond: (a = 1)
-                     ->  Bitmap Index Scan on ab_a1_b1_a_idx (actual rows=0 loops=1)
-                           Index Cond: (a = 1)
-               ->  Bitmap Heap Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
-                     Recheck Cond: (a = 1)
-                     Heap Blocks: exact=1
-                     ->  Bitmap Index Scan on ab_a1_b2_a_idx (actual rows=1 loops=1)
-                           Index Cond: (a = 1)
-               ->  Bitmap Heap Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
-                     Recheck Cond: (a = 1)
-                     ->  Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1)
-                           Index Cond: (a = 1)
+               ->  Seq Scan on ab_a1_b1 ab_1 (actual rows=0 loops=1)
+               ->  Seq Scan on ab_a1_b2 ab_2 (actual rows=1 loops=1)
+               ->  Seq Scan on ab_a1_b3 ab_3 (actual rows=0 loops=1)
          ->  Materialize (actual rows=0 loops=1)
-               ->  Bitmap Heap Scan on ab_a1_b3 ab_a1_3 (actual rows=0 loops=1)
-                     Recheck Cond: (a = 1)
-                     ->  Bitmap Index Scan on ab_a1_b3_a_idx (actual rows=1 loops=1)
-                           Index Cond: (a = 1)
-(65 rows)
+               ->  Seq Scan on ab_a1_b3 ab_a1_3 (actual rows=0 loops=1)
+(25 rows)
 
 table ab;
  a | b 
@@ -3013,9 +2826,9 @@ select * from mc3p where a < 3 and abs(b) = 1;
 --------------------------------------------------------
  Append (actual rows=3 loops=1)
    ->  Seq Scan on mc3p0 mc3p_1 (actual rows=1 loops=1)
-         Filter: ((a < 3) AND (abs(b) = 1))
+         Filter: (abs(b) = 1)
    ->  Seq Scan on mc3p1 mc3p_2 (actual rows=1 loops=1)
-         Filter: ((a < 3) AND (abs(b) = 1))
+         Filter: (abs(b) = 1)
    ->  Seq Scan on mc3p2 mc3p_3 (actual rows=1 loops=1)
          Filter: ((a < 3) AND (abs(b) = 1))
 (7 rows)
@@ -3210,8 +3023,7 @@ explain (costs off) select * from pp_arrpart where a = '{1}';
              QUERY PLAN             
 ------------------------------------
  Seq Scan on pp_arrpart1 pp_arrpart
-   Filter: (a = '{1}'::integer[])
-(2 rows)
+(1 row)
 
 explain (costs off) select * from pp_arrpart where a = '{1, 2}';
         QUERY PLAN        
@@ -3221,14 +3033,13 @@ explain (costs off) select * from pp_arrpart where a = '{1, 2}';
 (2 rows)
 
 explain (costs off) select * from pp_arrpart where a in ('{4, 5}', '{1}');
-                              QUERY PLAN                              
-----------------------------------------------------------------------
+                 QUERY PLAN                 
+--------------------------------------------
  Append
    ->  Seq Scan on pp_arrpart1 pp_arrpart_1
-         Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[]))
    ->  Seq Scan on pp_arrpart2 pp_arrpart_2
-         Filter: ((a = '{4,5}'::integer[]) OR (a = '{1}'::integer[]))
-(5 rows)
+         Filter: (a = '{4,5}'::integer[])
+(4 rows)
 
 explain (costs off) update pp_arrpart set a = a where a = '{1}';
                  QUERY PLAN                 
@@ -3236,8 +3047,7 @@ explain (costs off) update pp_arrpart set a = a where a = '{1}';
  Update on pp_arrpart
    Update on pp_arrpart1 pp_arrpart_1
    ->  Seq Scan on pp_arrpart1 pp_arrpart_1
-         Filter: (a = '{1}'::integer[])
-(4 rows)
+(3 rows)
 
 explain (costs off) delete from pp_arrpart where a = '{1}';
                  QUERY PLAN                 
@@ -3245,8 +3055,7 @@ explain (costs off) delete from pp_arrpart where a = '{1}';
  Delete on pp_arrpart
    Delete on pp_arrpart1 pp_arrpart_1
    ->  Seq Scan on pp_arrpart1 pp_arrpart_1
-         Filter: (a = '{1}'::integer[])
-(4 rows)
+(3 rows)
 
 drop table pp_arrpart;
 -- array type hash partition key
@@ -3296,8 +3105,7 @@ explain (costs off) select * from pp_enumpart where a = 'blue';
                 QUERY PLAN                
 ------------------------------------------
  Seq Scan on pp_enumpart_blue pp_enumpart
-   Filter: (a = 'blue'::pp_colors)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from pp_enumpart where a = 'black';
         QUERY PLAN        
@@ -3317,8 +3125,7 @@ explain (costs off) select * from pp_recpart where a = '(1,1)'::pp_rectype;
               QUERY PLAN              
 --------------------------------------
  Seq Scan on pp_recpart_11 pp_recpart
-   Filter: (a = '(1,1)'::pp_rectype)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from pp_recpart where a = '(1,2)'::pp_rectype;
         QUERY PLAN        
@@ -3337,8 +3144,7 @@ explain (costs off) select * from pp_intrangepart where a = '[1,2]'::int4range;
                   QUERY PLAN                   
 -----------------------------------------------
  Seq Scan on pp_intrangepart12 pp_intrangepart
-   Filter: (a = '[1,3)'::int4range)
-(2 rows)
+(1 row)
 
 explain (costs off) select * from pp_intrangepart where a = '(1,2)'::int4range;
         QUERY PLAN        
@@ -3358,8 +3164,7 @@ explain (costs off) select * from pp_lp where a = 1;
         QUERY PLAN        
 --------------------------
  Seq Scan on pp_lp1 pp_lp
-   Filter: (a = 1)
-(2 rows)
+(1 row)
 
 explain (costs off) update pp_lp set value = 10 where a = 1;
             QUERY PLAN            
@@ -3367,8 +3172,7 @@ explain (costs off) update pp_lp set value = 10 where a = 1;
  Update on pp_lp
    Update on pp_lp1 pp_lp_1
    ->  Seq Scan on pp_lp1 pp_lp_1
-         Filter: (a = 1)
-(4 rows)
+(3 rows)
 
 explain (costs off) delete from pp_lp where a = 1;
             QUERY PLAN            
@@ -3376,8 +3180,7 @@ explain (costs off) delete from pp_lp where a = 1;
  Delete on pp_lp
    Delete on pp_lp1 pp_lp_1
    ->  Seq Scan on pp_lp1 pp_lp_1
-         Filter: (a = 1)
-(4 rows)
+(3 rows)
 
 set enable_partition_pruning = off;
 set constraint_exclusion = 'partition'; -- this should not affect the result.
@@ -3386,10 +3189,9 @@ explain (costs off) select * from pp_lp where a = 1;
 ----------------------------------
  Append
    ->  Seq Scan on pp_lp1 pp_lp_1
-         Filter: (a = 1)
    ->  Seq Scan on pp_lp2 pp_lp_2
          Filter: (a = 1)
-(5 rows)
+(4 rows)
 
 explain (costs off) update pp_lp set value = 10 where a = 1;
             QUERY PLAN            
@@ -3398,10 +3200,9 @@ explain (costs off) update pp_lp set value = 10 where a = 1;
    Update on pp_lp1 pp_lp_1
    Update on pp_lp2 pp_lp_2
    ->  Seq Scan on pp_lp1 pp_lp_1
-         Filter: (a = 1)
    ->  Seq Scan on pp_lp2 pp_lp_2
          Filter: (a = 1)
-(7 rows)
+(6 rows)
 
 explain (costs off) delete from pp_lp where a = 1;
             QUERY PLAN            
@@ -3410,10 +3211,9 @@ explain (costs off) delete from pp_lp where a = 1;
    Delete on pp_lp1 pp_lp_1
    Delete on pp_lp2 pp_lp_2
    ->  Seq Scan on pp_lp1 pp_lp_1
-         Filter: (a = 1)
    ->  Seq Scan on pp_lp2 pp_lp_2
          Filter: (a = 1)
-(7 rows)
+(6 rows)
 
 set constraint_exclusion = 'off'; -- this should not affect the result.
 explain (costs off) select * from pp_lp where a = 1;
@@ -3553,15 +3353,15 @@ from (
       select 1, 1, 1
      ) s(a, b, c)
 where s.a = 1 and s.b = 1 and s.c = (select 1);
-                     QUERY PLAN                     
-----------------------------------------------------
+               QUERY PLAN               
+----------------------------------------
  Append
    InitPlan 1 (returns $0)
      ->  Result
    ->  Seq Scan on p1 p
-         Filter: ((a = 1) AND (b = 1) AND (c = $0))
+         Filter: ((b = 1) AND (c = $0))
    ->  Seq Scan on q111 q1
-         Filter: ((a = 1) AND (b = 1) AND (c = $0))
+         Filter: (c = $0)
    ->  Result
          One-Time Filter: (1 = $0)
 (9 rows)
@@ -3782,10 +3582,10 @@ create table rp_prefix_test1_p2 partition of rp_prefix_test1 for values from (2,
 -- Don't call get_steps_using_prefix() with the last partition key b plus
 -- an empty prefix
 explain (costs off) select * from rp_prefix_test1 where a <= 1 and b = 'a';
-                    QUERY PLAN                    
---------------------------------------------------
+                   QUERY PLAN                   
+------------------------------------------------
  Seq Scan on rp_prefix_test1_p1 rp_prefix_test1
-   Filter: ((a <= 1) AND ((b)::text = 'a'::text))
+   Filter: ((b)::text = 'a'::text)
 (2 rows)
 
 create table rp_prefix_test2 (a int, b int, c int) partition by range(a, b, c);
@@ -3797,8 +3597,7 @@ explain (costs off) select * from rp_prefix_test2 where a <= 1 and b = 1 and c >
                    QUERY PLAN                   
 ------------------------------------------------
  Seq Scan on rp_prefix_test2_p1 rp_prefix_test2
-   Filter: ((a <= 1) AND (c >= 0) AND (b = 1))
-(2 rows)
+(1 row)
 
 create table rp_prefix_test3 (a int, b int, c int, d int) partition by range(a, b, c, d);
 create table rp_prefix_test3_p1 partition of rp_prefix_test3 for values from (1, 1, 1, 0) to (1, 1, 1, 10);
@@ -3806,21 +3605,19 @@ create table rp_prefix_test3_p2 partition of rp_prefix_test3 for values from (2,
 -- Test that get_steps_using_prefix() handles a prefix that contains multiple
 -- clauses for the partition key b (ie, b >= 1 and b >= 2)
 explain (costs off) select * from rp_prefix_test3 where a >= 1 and b >= 1 and b >= 2 and c >= 2 and d >= 0;
-                                QUERY PLAN                                
---------------------------------------------------------------------------
+                   QUERY PLAN                   
+------------------------------------------------
  Seq Scan on rp_prefix_test3_p2 rp_prefix_test3
-   Filter: ((a >= 1) AND (b >= 1) AND (b >= 2) AND (c >= 2) AND (d >= 0))
-(2 rows)
+(1 row)
 
 -- Test that get_steps_using_prefix() handles a prefix that contains multiple
 -- clauses for the partition key b (ie, b >= 1 and b = 2)  (This also tests
 -- that the caller arranges clauses in that prefix in the required order)
 explain (costs off) select * from rp_prefix_test3 where a >= 1 and b >= 1 and b = 2 and c = 2 and d >= 0;
-                               QUERY PLAN                               
-------------------------------------------------------------------------
+                   QUERY PLAN                   
+------------------------------------------------
  Seq Scan on rp_prefix_test3_p2 rp_prefix_test3
-   Filter: ((a >= 1) AND (b >= 1) AND (d >= 0) AND (b = 2) AND (c = 2))
-(2 rows)
+(1 row)
 
 create table hp_prefix_test (a int, b int, c int, d int) partition by hash (a part_test_int4_ops, b part_test_int4_ops, c part_test_int4_ops, d part_test_int4_ops);
 create table hp_prefix_test_p1 partition of hp_prefix_test for values with (modulus 2, remainder 0);
diff --git a/src/test/regress/expected/rowsecurity.out b/src/test/regress/expected/rowsecurity.out
index 9506aaef82..3309d26c87 100644
--- a/src/test/regress/expected/rowsecurity.out
+++ b/src/test/regress/expected/rowsecurity.out
@@ -1057,10 +1057,10 @@ NOTICE:  f_leak => awesome science fiction
 (4 rows)
 
 EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
-                          QUERY PLAN                          
---------------------------------------------------------------
+                     QUERY PLAN                     
+----------------------------------------------------
  Seq Scan on part_document_fiction part_document
-   Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle))
+   Filter: ((dlevel <= $0) AND f_leak(dtitle))
    InitPlan 1 (returns $0)
      ->  Index Scan using uaccount_pkey on uaccount
            Index Cond: (pguser = CURRENT_USER)
@@ -1135,10 +1135,10 @@ NOTICE:  f_leak => awesome science fiction
 (4 rows)
 
 EXPLAIN (COSTS OFF) SELECT * FROM part_document WHERE f_leak(dtitle);
-                          QUERY PLAN                          
---------------------------------------------------------------
+                     QUERY PLAN                     
+----------------------------------------------------
  Seq Scan on part_document_fiction part_document
-   Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle))
+   Filter: ((dlevel <= $0) AND f_leak(dtitle))
    InitPlan 1 (returns $0)
      ->  Index Scan using uaccount_pkey on uaccount
            Index Cond: (pguser = CURRENT_USER)
diff --git a/src/test/regress/expected/update.out b/src/test/regress/expected/update.out
index bf939d79f6..0d821ade5b 100644
--- a/src/test/regress/expected/update.out
+++ b/src/test/regress/expected/update.out
@@ -327,12 +327,10 @@ EXPLAIN (costs off) UPDATE range_parted set c = c - 50 WHERE c > 97;
    ->  Seq Scan on part_c_1_100 range_parted_4
          Filter: (c > '97'::numeric)
    ->  Seq Scan on part_d_1_15 range_parted_5
-         Filter: (c > '97'::numeric)
    ->  Seq Scan on part_d_15_20 range_parted_6
-         Filter: (c > '97'::numeric)
    ->  Seq Scan on part_b_20_b_30 range_parted_7
          Filter: (c > '97'::numeric)
-(22 rows)
+(20 rows)
 
 -- fail, row movement happens only within the partition subtree.
 UPDATE part_c_100_200 set c = c - 20, d = c WHERE c = 105;
