diff --git a/src/backend/optimizer/plan/analyzejoins.c b/src/backend/optimizer/plan/analyzejoins.c
index 1cdb311..bc1929c 100644
--- a/src/backend/optimizer/plan/analyzejoins.c
+++ b/src/backend/optimizer/plan/analyzejoins.c
@@ -22,20 +22,16 @@
  */
 #include "postgres.h"
 
+#include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
 #include "optimizer/joininfo.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
 #include "optimizer/planmain.h"
 #include "optimizer/var.h"
-#include "optimizer/clauses.h"
-#include "parser/parsetree.h"
-#include "optimizer/tlist.h"
-#include "nodes/nodeFuncs.h"
 
 /* local functions */
 static bool join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo);
-static bool	groupinglist_is_unique_on_restrictinfo(Query *query,
-					  List *clause_list, List *sortlist);
 static void remove_rel_from_query(PlannerInfo *root, int relid,
 					  Relids joinrelids);
 static List *remove_rel_from_joinlist(List *joinlist, int relid, int *nremoved);
@@ -153,7 +149,6 @@ join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo)
 {
 	int			innerrelid;
 	RelOptInfo *innerrel;
-	Query	   *subquery;
 	Relids		joinrelids;
 	List	   *clause_list = NIL;
 	ListCell   *l;
@@ -176,8 +171,8 @@ join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo)
 	 *    appear in the join condition with equality operators.
 	 *
 	 * The code below is written with the assumption that join removal is more
-	 * likely not to happen, for this reason there are fast paths for both of
-	 * the cases above to try to save on unnecessary processing.
+	 * likely not to happen, for this reason we try to fast path out of this
+	 * function early when possible.
 	 */
 
 	if (sjinfo->jointype != JOIN_LEFT ||
@@ -200,20 +195,7 @@ join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo)
 		if (innerrel->indexlist == NIL)
 			return false;
 	}
-	else if (innerrel->rtekind == RTE_SUBQUERY)
-	{
-		subquery = root->simple_rte_array[innerrelid]->subquery;
-
-		/*
-		 * The only means we currently use to check if the subquery is unique
-		 * are the GROUP BY and DISTINCT clause. If both of these are empty
-		 * then there's no point in going any further.
-		 */
-		if (subquery->groupClause == NIL &&
-			subquery->distinctClause == NIL)
-			return false;
-	}
-	else
+	else if (innerrel->rtekind != RTE_SUBQUERY)
 		return false; /* unsupported rtekind */
 
 	/* Compute the relid set for the join we are considering */
@@ -324,134 +306,76 @@ join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo)
 		return true;
 
 	/*
-	 * We can be certain that the sub query contains no duplicate values for
-	 * the join clause if item in the sub query's GROUP BY clause is also used
-	 * in the join clause using equality. This works the same way for the
-	 * DISTINCT clause. We need not pay any attention to WHERE or HAVING
-	 * clauses as these just restrict the results more and could not be the
-	 * cause of duplication in the result set. However there are a number of
-	 * pre-checks we must perform which could cause duplicate values even if
-	 * all the required columns are in the GROUP BY or DISTINCT clause.
+	 * For subqueries we should be able to remove the join if the subquery
+	 * can't produce more than 1 record which matches the outer query on the
+	 * join condition. However, there's a few pre-conditions that the subquery
+	 * must meet for it to be safe to remove:
+	 *
+	 * 1. The subquery mustn't contain a FOR UPDATE clause. Removing such a
+	 *    join would have the undesired side affect of not locking the rows.
+	 *
+	 * 2. The subquery mustn't contain any volatile functions. Removing such
+	 *    a join would cause side affects that the volatile functions may have,
+	 *    not to occur.
 	 *
-	 * NB: We must also not remove the join in the subquery contains a
-	 * FOR UDPATE clause, but we can actually skip this check as GROUP BY and
-	 * DISTINCT cannot be used at the same time as FOR UPDATE.
+	 * 3. The subquery mustn't contain any set returning functions. These can
+	 *    cause duplicate records despite the existence of a DISTINCT or
+	 *    GROUP BY clause which could otherwise make the subquery unique.
 	 */
 	if (innerrel->rtekind == RTE_SUBQUERY)
 	{
-		Assert(subquery == root->simple_rte_array[innerrelid]->subquery);
+		List	*colnos;
+		List	*opids;
+		Query	*subquery = root->simple_rte_array[innerrelid]->subquery;
 
-		/*
-		 * We cannot remove the subquery if the target list contains any set
-		 * returning functions as these may cause the query not to be unique
-		 * on the grouping columns, as per the following example:
-		 * "SELECT a.a,generate_series(1,2) FROM (VALUES(1)) a(a) GROUP BY a"
-		 */
-		if (expression_returns_set((Node *) subquery->targetList))
+		/* check point 1 */
+		if (subquery->hasForUpdate)
 			return false;
 
-		/*
-		 * Don't remove the join if the target list contains any volatile
-		 * functions. Doing so may remove desired side affects that calls
-		 * to the function may cause.
-		 */
+		/* check point 2 */
 		if (contain_volatile_functions((Node *) subquery->targetList))
 			return false;
 
-		/*
-		 * It should be safe to remove the join if all the GROUP BY expressions
-		 * have matching items in the join condition.
-		 */
-		if (subquery->groupClause != NIL &&
-			groupinglist_is_unique_on_restrictinfo(subquery, clause_list, subquery->groupClause))
-			return true;
-
-		/*
-		 * It should be safe to remove the join if all the DISTINCT column list have matching
-		 * items in the join condition.
-		 */
-		if (subquery->distinctClause != NIL &&
-			groupinglist_is_unique_on_restrictinfo(subquery, clause_list, subquery->distinctClause))
-			return true;
-	}
-
-	/*
-	 * Some day it would be nice to check for other methods of establishing
-	 * distinctness.
-	 */
-	return false;
-}
-
-/*
- * groupinglist_is_unique_on_restrictinfo
- *
- * Checks to see if all items in groupinglist also exist in rinfolist.
- * The function will return true if rinfolist is the same as or a superset
- * of groupinglist. If the groupinglist has Vars that don't exist in the rinfolist
- * then the query can't be guaranteed unique on the rinfolist columns.
- *
- * Note: The calling function must ensure that groupinglist is not NIL.
- */
-static bool
-groupinglist_is_unique_on_restrictinfo(Query *query, List *rinfolist, List *groupinglist)
-{
-	ListCell *l;
-
-	Assert(groupinglist != NIL);
-
-	/*
-	 * Loop over each groupinglist item to ensure that we have restrictinfo
-	 * item to match. We also need to ensure that the operators used in the
-	 * groupinglist matches that of the one in the restrict info.
-	 * Note that it does not matter if we have more items in the rinfolist than
-	 * we have in the groupinglist.
-	 */
-	foreach(l, groupinglist)
-	{
-		ListCell		*ri;
-		SortGroupClause *scl = (SortGroupClause *) lfirst(l);
-		TargetEntry		*sortTarget;
-		bool			 matched = false;
+		/* check point 3 */
+		if (expression_returns_set((Node *) subquery->targetList))
+			return false;
 
-		/* lookup the target list entry for the current sort sort group ref */
-		sortTarget = get_sortgroupref_tle(scl->tleSortGroupRef, query->targetList);
+		colnos = NULL;
+		opids = NULL;
 
 		/*
-		 * We can ignore constants since they have only one value and don't
-		 * affect uniqueness of results.
+		 * Build a list of varattnos that we require the subquery to be unique over.
+		 * We also build a list of the operators that are used with these vars in the
+		 * join condition so that query_is_distinct_for can check that these
+		 * operators are compatible with the GROUP BY or DISTINCT clause in the
+		 * subquery.
 		 */
-		if (IsA(sortTarget->expr, Const))
-			continue;
-
-		foreach(ri, rinfolist)
+		foreach(l, clause_list)
 		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(ri);
-			Node	   *rexpr;
+			RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
+			Var			 *var;
 
 			if (rinfo->outer_is_left)
-				rexpr = get_rightop(rinfo->clause);
-			else
-				rexpr = get_leftop(rinfo->clause);
-
-			if (IsA(rexpr, Var))
-			{
-				Var *var = (Var *)rexpr;
-
-				if (var->varattno == sortTarget->resno &&
-					scl->eqop == rinfo->hashjoinoperator)
-				{
-					matched = true;
-					break; /* match found */
-				}
-			}
+				var = (Var *) get_rightop(rinfo->clause);
 			else
-				return false;
+				var = (Var *) get_leftop(rinfo->clause);
+
+			if (!var || !IsA(var, Var) ||
+				var->varno != innerrelid)
+				continue;
+
+			colnos = lappend_int(colnos, var->varattno);
+			opids = lappend_oid(opids, rinfo->hashjoinoperator);
 		}
 
-		if (!matched)
-			return false;
+		return query_is_distinct_for(subquery, colnos, opids);
 	}
-	return true;
+
+	/*
+	 * Some day it would be nice to check for other methods of establishing
+	 * distinctness.
+	 */
+	return false;
 }
 
 /*
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index 4e05dcd..f701954 100644
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -38,7 +38,6 @@ typedef enum
 } PathCostComparison;
 
 static List *translate_sub_tlist(List *tlist, int relid);
-static bool query_is_distinct_for(Query *query, List *colnos, List *opids);
 static Oid	distinct_col_search(int colno, List *colnos, List *opids);
 
 
@@ -1465,7 +1464,7 @@ translate_sub_tlist(List *tlist, int relid)
  * should give trustworthy answers for all operators that we might need
  * to deal with here.)
  */
-static bool
+bool
 query_is_distinct_for(Query *query, List *colnos, List *opids)
 {
 	ListCell   *l;
@@ -1486,6 +1485,13 @@ query_is_distinct_for(Query *query, List *colnos, List *opids)
 			TargetEntry *tle = get_sortgroupclause_tle(sgc,
 													   query->targetList);
 
+			/*
+			 * We can ignore constants since they have only one value and don't
+			 * affect uniqueness of results.
+			 */
+			if (IsA(tle->expr, Const))
+				continue;
+
 			opid = distinct_col_search(tle->resno, colnos, opids);
 			if (!OidIsValid(opid) ||
 				!equality_ops_are_compatible(opid, sgc->eqop))
@@ -1507,6 +1513,13 @@ query_is_distinct_for(Query *query, List *colnos, List *opids)
 			TargetEntry *tle = get_sortgroupclause_tle(sgc,
 													   query->targetList);
 
+			/*
+			 * We can ignore constants since they have only one value and don't
+			 * affect uniqueness of results.
+			 */
+			if (IsA(tle->expr, Const))
+				continue;
+
 			opid = distinct_col_search(tle->resno, colnos, opids);
 			if (!OidIsValid(opid) ||
 				!equality_ops_are_compatible(opid, sgc->eqop))
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index a0bcc82..2f571f5 100644
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -67,6 +67,7 @@ extern ResultPath *create_result_path(List *quals);
 extern MaterialPath *create_material_path(RelOptInfo *rel, Path *subpath);
 extern UniquePath *create_unique_path(PlannerInfo *root, RelOptInfo *rel,
 				   Path *subpath, SpecialJoinInfo *sjinfo);
+extern bool query_is_distinct_for(Query *query, List *colnos, List *opids);
 extern Path *create_subqueryscan_path(PlannerInfo *root, RelOptInfo *rel,
 						 List *pathkeys, Relids required_outer);
 extern Path *create_functionscan_path(PlannerInfo *root, RelOptInfo *rel,