diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 1b68ab1b82..cf396856a9 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -1790,6 +1790,8 @@ perform_pruning_base_step(PartitionPruneContext *context,
 	Datum		values[PARTITION_MAX_KEYS];
 	FmgrInfo	partsupfunc[PARTITION_MAX_KEYS];
 
+	Assert(list_length(opstep->exprs) == list_length(opstep->cmpfns));
+
 	nvalues = 0;
 	lc1 = list_head(opstep->exprs);
 	lc2 = list_head(opstep->cmpfns);
@@ -1830,8 +1832,6 @@ perform_pruning_base_step(PartitionPruneContext *context,
 				 * than the one cached in the PartitionKey, we'll need to
 				 * look up the FmgrInfo.
 				 */
-				if (lc2 == NULL)
-					elog(ERROR, "incomplete cmpfnids list in pruning step");
 				cmpfn = lfirst_oid(lc2);
 				Assert(OidIsValid(cmpfn));
 				if (cmpfn != context->partsupfunc[keyno].fn_oid)
@@ -1879,6 +1879,8 @@ perform_pruning_base_step(PartitionPruneContext *context,
 /*
  * perform_pruning_base_step_ne
  *		Returns indexes of partitions obtained by executing 'nestep'.
+ *
+ * Note this pruning method is only supported by LIST partitioning.
  */
 static Bitmapset *
 perform_pruning_base_step_ne(PartitionPruneContext *context,
@@ -1893,6 +1895,9 @@ perform_pruning_base_step_ne(PartitionPruneContext *context,
 	int			n_ne_datums = list_length(nestep->exprs),
 				i;
 
+	Assert(context->strategy == PARTITION_STRATEGY_LIST);
+	Assert(list_length(nestep->exprs) == list_length(nestep->cmpfns));
+
 	/*
 	 * Apply not-equal clauses.  This only applies in the list
 	 * partitioning case as this is the only partition type where
@@ -1905,8 +1910,7 @@ perform_pruning_base_step_ne(PartitionPruneContext *context,
 	 * Some datums may require different comparison function than
 	 * the default partitioning-specific one.
 	 */
-	partsupfunc = (FmgrInfo **)
-	palloc(n_ne_datums * sizeof(FmgrInfo *));
+	partsupfunc = (FmgrInfo **) palloc(n_ne_datums * sizeof(FmgrInfo *));
 
 	i = 0;
 	forboth(lc1, nestep->exprs, lc2, nestep->cmpfns)
@@ -1933,14 +1937,15 @@ perform_pruning_base_step_ne(PartitionPruneContext *context,
 			}
 			else
 				partsupfunc[i] = &context->partsupfunc[0];
-		}
 
-		ne_datums[i++] = datum;
+			ne_datums[i++] = datum;
+		}
 	}
 
 	excluded_parts = get_partitions_excluded_by_ne_datums(context, ne_datums, i,
 													  partsupfunc);
 	pfree(ne_datums);
+	pfree(partsupfunc);
 
 	/* All partitions apart from those in excluded_parts match */
 	result = bms_add_range(NULL, 0, context->nparts - 1);
@@ -2280,7 +2285,7 @@ get_partitions_for_keys_range(PartitionPruneContext *context,
 			{
 				if (nvalues == partnatts)
 				{
-					/* There can only be one partition. */
+					/* There can only be zero or one matching partitions. */
 					if (partindices[off + 1] >= 0)
 						return bms_make_singleton(partindices[off + 1]);
 					else if (partition_bound_has_default(boundinfo))
@@ -2535,7 +2540,8 @@ get_partitions_excluded_by_ne_datums(PartitionPruneContext *context,
 
 	/*
 	 * We can only do this exclusion for list partitions because that's the
-	 * only case where we require all values to explicitly specified.
+	 * only case where we require all values to explicitly specified in the
+	 * partition boundinfo.
 	 */
 	Assert(context->strategy == PARTITION_STRATEGY_LIST);
 	Assert(context->partnatts == 1);
@@ -2569,6 +2575,12 @@ get_partitions_excluded_by_ne_datums(PartitionPruneContext *context,
 	 * counted all this, we can eliminate any partition where the number of
 	 * datums found in the query matches the number of datums allowed in the
 	 * partition.
+	 *
+	 * It might seem like we can skip attempting pruning any partitions here
+	 * if we found no not-equal clauses which match any partitions above, but
+	 * because we previously ensured these clauses are strict we may be able
+	 * to at least eliminate the NULL partition, providing that partition does
+	 * not also allow any non-NULL values.
 	 */
 	if (!bms_is_empty(foundoffsets))
 	{
@@ -2579,6 +2591,13 @@ get_partitions_excluded_by_ne_datums(PartitionPruneContext *context,
 			datums_in_query[boundinfo->indexes[i]]++;
 	}
 
+	/*
+	 * We can't prune anything if there's no foundoffsets and no NULL
+	 * partition.
+	 */
+	else if (!partition_bound_accepts_nulls(boundinfo))
+		return NULL;
+
 	/*
 	 * Now, in a single pass over all the datums, count the number of datums
 	 * permitted in each partition.
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 6dd525323c..26c5281385 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -2158,6 +2158,7 @@ _copyPartitionPruneStepOpNe(const PartitionPruneStepOpNe *from)
 	PartitionPruneStepOpNe *newnode = makeNode(PartitionPruneStepOpNe);
 
 	COPY_NODE_FIELD(exprs);
+	COPY_NODE_FIELD(cmpfns);
 
 	return newnode;
 }
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 00d6252552..2cb7f086b7 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -1483,8 +1483,9 @@ inheritance_planner(PlannerInfo *root)
 			continue;
 
 		/* Add the current parent's RT index to the partitioned rels set. */
-		partitioned_relids = bms_add_member(partitioned_relids,
-											appinfo->parent_relid);
+		if (partitioned_relids)
+			partitioned_relids = bms_add_member(partitioned_relids,
+												appinfo->parent_relid);
 
 		/*
 		 * If this is the first non-excluded child, its post-planning rtable
diff --git a/src/backend/optimizer/util/partprune.c b/src/backend/optimizer/util/partprune.c
index 7dfd8fdcaf..e2d8fdb2a2 100644
--- a/src/backend/optimizer/util/partprune.c
+++ b/src/backend/optimizer/util/partprune.c
@@ -758,8 +758,8 @@ generate_pruning_steps_from_opexprs(PartitionScheme part_scheme,
 		}
 
 		/*
-		 * If we've decided that clauses for subsequent partition keys would't
-		 * be useful for pruning, don't look.
+		 * If we've decided that clauses for subsequent partition keys
+		 * wouldn't be useful for pruning, don't look.
 		 */
 		if (!consider_next_key)
 			break;
@@ -895,9 +895,9 @@ generate_pruning_steps_from_opexprs(PartitionScheme part_scheme,
 					ListCell *lc1;
 
 					/*
-					 * Locate the clause for the greatest column (whic may not
-					 * be the last partition key column).  Actually, the last
-					 * element of eq_clauses must give us what we need.
+					 * Locate the clause for the greatest column (which may
+					 * not be the last partition key column).  Actually, the
+					 * last element of eq_clauses must give us what we need.
 					 */
 					pc = llast(eq_clauses);
 
@@ -994,7 +994,7 @@ generate_pruning_steps_from_opexprs(PartitionScheme part_scheme,
  *
  * Return value:
  *
- *	one of PARTCLAUSE_MATCH_* enum values if the clause is successfully
+ *	One of PARTCLAUSE_MATCH_* enum values if the clause is successfully
  *	matched to the partition key.  If it is PARTCLAUSE_MATCH_CONTRADICT, then
  *	this means the clause is self-contradictory (which can happen only if it's
  *	a BoolExpr whose arguments may be self-contradictory)
@@ -1065,6 +1065,7 @@ match_clause_to_partition_key(RelOptInfo *rel,
 		Oid			commutator = InvalidOid,
 					negator = InvalidOid;
 		Oid			cmpfn;
+		Oid			exprtype;
 
 		leftop = (Expr *) get_leftop(clause);
 		if (IsA(leftop, RelabelType))
@@ -1152,7 +1153,8 @@ match_clause_to_partition_key(RelOptInfo *rel,
 		}
 
 		/* Check if we're going to need a cross-type comparison function. */
-		if (exprType((Node *) expr) != part_scheme->partopcintype[partkeyidx])
+		exprtype = exprType((Node *) expr);
+		if (exprtype != part_scheme->partopcintype[partkeyidx])
 		{
 			int	procnum = (part_scheme->strategy == PARTITION_STRATEGY_HASH)
 							? HASHEXTENDED_PROC
@@ -1160,7 +1162,7 @@ match_clause_to_partition_key(RelOptInfo *rel,
 
 			cmpfn = get_opfamily_proc(part_scheme->partopfamily[partkeyidx],
 									  part_scheme->partopcintype[partkeyidx],
-									  exprType((Node *) expr), procnum);
+									  exprtype, procnum);
 			/* If we couldn't find one, we cannot use this expression. */
 			if (!OidIsValid(cmpfn))
 				return PARTCLAUSE_UNSUPPORTED;
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 959964ba13..a0345a0abf 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1528,10 +1528,10 @@ typedef struct PartitionPruneStep
  * where partnatts is the number of partition key columns.  'opstrategy' is the
  * strategy of the operator in the clause matched to the last partition key.
  * 'exprs' contains expressions which comprise the look-up key to be passed to
- * the partition bound search function.  'cmpfnids' contains the OIDs of
+ * the partition bound search function.  'cmpfns' contains the OIDs of
  * comparison function used to compare aforementioned expressions with
- * partition bounds.  Both 'exprs' and 'cmpfns' contain up to partnatts
- * elements.
+ * partition bounds.  Both 'exprs' and 'cmpfns' contain the same number of
+ * items up to partnatts items.
  *
  * Once we find the offset of a partition bound using the look-up key, we
  * determine which partitions to include in the result based on the value of
@@ -1563,9 +1563,9 @@ typedef struct PartitionPruneStepOp
  *							OpExpr clauses each containing a <> operator
  *
  * This is a special form of PartitionPruneStepOp, where each of the
- * expressions in 'expr' is compared using a <> operator.  To prune a given
+ * expressions in 'exprs' is compared using a <> operator.  To prune a given
  * partition, we must check if each of the values it allows matches the value
- * of one of the expressions in 'expr' using the corresponding comparison
+ * of one of the expressions in 'exprs' using the corresponding comparison
  * function in 'cmpfns'.
  *
  * Note: Since we must consider every possible value of the partition key a