Teach the planner to convert EXISTS and NOT EXISTS subqueries into semi and anti joins. To do this, we put all potential expressions from the qual list and join list into the common list and check each expression one by one to see if they are suitable for transformation.

Authors: Alena Rybakina <[email protected]>
Reviewed-by: Ranier Vilela <[email protected]>, Ilia Evdokimov <[email protected]>,
	     Peter Petrov <[email protected]>

Author: Alena Rybakina

src/backend/optimizer/plan/subselect.c

@@ -1459,6 +1459,10 @@ convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink,
 	int			varno;
 	Relids		clause_varnos;
 	Relids		upper_varnos;
+	ListCell *lc;
+	List *newWhere = NIL;
+	List *all_clauses = NIL;
+	bool upper_reference_exists = false;
 
 	Assert(sublink->subLinkType == EXISTS_SUBLINK);
 
@@ -1488,32 +1492,71 @@ convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink,
 	if (!simplify_EXISTS_query(root, subselect))
 		return NULL;
 
-	/*
-	 * Separate out the WHERE clause.  (We could theoretically also remove
-	 * top-level plain JOIN/ON clauses, but it's probably not worth the
-	 * trouble.)
-	 */
-	whereClause = subselect->jointree->quals;
+	if (subselect->jointree->quals)
+		all_clauses = lappend(all_clauses, subselect->jointree->quals);
+
 	subselect->jointree->quals = NULL;
 
-	/*
-	 * The rest of the sub-select must not refer to any Vars of the parent
-	 * query.  (Vars of higher levels should be okay, though.)
-	 */
-	if (contain_vars_of_level((Node *) subselect, 1))
-		return NULL;
+	/* Gather all clauses in main list for the further consideration */
+	all_clauses = list_concat(all_clauses, subselect->jointree->fromlist);
 
 	/*
-	 * On the other hand, the WHERE clause must contain some Vars of the
-	 * parent query, else it's not gonna be a join.
+	 * We will able to remove top-level plain JOIN/ON clauses if they are not outer join.
 	 */
-	if (!contain_vars_of_level(whereClause, 1))
-		return NULL;
+	foreach (lc, all_clauses)
+	{
+		Node *je = ((Node *) lfirst(lc));
+
+		whereClause = copyObject(je);
+
+		if (IsA(whereClause, RangeTblRef))
+			continue;
+
+		if (IsA(whereClause, JoinExpr))
+		{
+			if (((JoinExpr *) whereClause)->jointype != JOIN_INNER)
+			{
+				/*
+	 			 * Clauses must not refer to any Vars of the parent
+	 			 * query.  (Vars of higher levels should be okay, though.)
+	 			 */
+				if (contain_vars_of_level(whereClause, 1))
+					return NULL;
+				else
+					continue;
+			}
+			else if (((JoinExpr *) whereClause)->quals != NULL)
+				whereClause = ((JoinExpr *) whereClause)->quals;
+		}
+
+		/*
+		* We don't risk optimizing if the WHERE clause is volatile, either.
+		*/
+		if (contain_volatile_functions(whereClause))
+			return NULL;
+
+		/*
+		* Clean up the WHERE clause by doing const-simplification etc on it.
+		*/
+		whereClause = eval_const_expressions(root, whereClause);
+		whereClause = (Node *) canonicalize_qual((Expr *) whereClause, false);
+
+		if(!IsA(whereClause, JoinExpr))
+			newWhere = lappend(newWhere, whereClause);
+		else
+			return NULL;
+
+		if (contain_vars_of_level((Node *) whereClause, 1))
+			upper_reference_exists = true;
+	}
+
+	list_free(all_clauses);
 
 	/*
-	 * We don't risk optimizing if the WHERE clause is volatile, either.
+	 * There are no WHERE clause containing some Vars of the
+	 * parent query, so it's not gonna be a join.
 	 */
-	if (contain_volatile_functions(whereClause))
+	if(!upper_reference_exists)
 		return NULL;
 
 	/*
@@ -1567,23 +1610,24 @@ convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink,
 	 */
 	rtoffset = list_length(parse->rtable);
 	OffsetVarNodes((Node *) subselect, rtoffset, 0);
-	OffsetVarNodes(whereClause, rtoffset, 0);
 
 	/*
 	 * Upper-level vars in subquery will now be one level closer to their
 	 * parent than before; in particular, anything that had been level 1
 	 * becomes level zero.
 	 */
 	IncrementVarSublevelsUp((Node *) subselect, -1, 1);
-	IncrementVarSublevelsUp(whereClause, -1, 1);
+
+	OffsetVarNodes((Node *) newWhere, rtoffset, 0);
+	IncrementVarSublevelsUp((Node *) newWhere, -1, 1);
 
 	/*
 	 * Now that the WHERE clause is adjusted to match the parent query
 	 * environment, we can easily identify all the level-zero rels it uses.
 	 * The ones <= rtoffset belong to the upper query; the ones > rtoffset do
 	 * not.
 	 */
-	clause_varnos = pull_varnos(root, whereClause);
+	clause_varnos = pull_varnos(root, (Node *) newWhere);
 	upper_varnos = NULL;
 	varno = -1;
 	while ((varno = bms_next_member(clause_varnos, varno)) >= 0)
@@ -1601,6 +1645,31 @@ convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink,
 	if (!bms_is_subset(upper_varnos, available_rels))
 		return NULL;
 
+	/*
+	 * In case of a successful attempt, replaces it with the correct condition.
+	 * We were sure that inner relations are independent, so we confidently
+	 * can replace their join condition on true.
+	 */
+	foreach(lc, subselect->jointree->fromlist)
+	{
+		Node *node = lfirst(lc);
+
+		if (IsA(node, RangeTblRef))
+			continue;
+
+		if ((IsA(node, JoinExpr) && ((JoinExpr *)node)->jointype != JOIN_INNER))
+			continue;
+
+		if (IsA(node, JoinExpr) && ((JoinExpr *) node)->quals != NULL)
+			((JoinExpr *) node)->quals = (Node *) makeConst(BOOLOID,
+																-1,
+																InvalidOid,
+																sizeof(bool),
+																(Datum) 1,
+																false,
+																true);
+	}
+
 	/*
 	 * Now we can attach the modified subquery rtable to the parent. This also
 	 * adds subquery's RTEPermissionInfos into the upper query.
@@ -1622,7 +1691,7 @@ convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink,
 		result->rarg = (Node *) subselect->jointree;
 	result->usingClause = NIL;
 	result->join_using_alias = NULL;
-	result->quals = whereClause;
+	result->quals = (Node *) make_ands_explicit(newWhere);
 	result->alias = NULL;
 	result->rtindex = 0;		/* we don't need an RTE for it */