Push down join quals into lateral subqueries.

We don't normally push down join quals into subqueries, because that would
require creating parameterized plans. However, if the plan is already
parameterized because it's LATERAL, we might as well push down any
additional join quals, that refer the same relations that are already
referenced within the subquery.

This changes the behavior of the sublevels_up parameters to
ReplaceVarsFromTargetList(). The targetlist entries used to replace vars are
no longer offset by that amount. I'm not sure what the original thinking
on it was, but all the existing callers passed sublevels_up = 0, so I hope
this is OK.

Rebase-by: reshke <reshke@double.cloud>

Author: hlinnaka

src/backend/optimizer/path/allpaths.c

@@ -163,13 +163,12 @@ static pushdown_safe_type qual_is_pushdown_safe(Query *subquery, Index rti,
 												RestrictInfo *rinfo,
 												pushdown_safety_info *safetyInfo);
 static void subquery_push_qual(Query *subquery,
-							   RangeTblEntry *rte, Index rti, Node *qual);
+							   RangeTblEntry *rte, Index rti, Node *qual, int sublevels_up);
 static void recurse_push_qual(Node *setOp, Query *topquery,
-							  RangeTblEntry *rte, Index rti, Node *qual);
+							  RangeTblEntry *rte, Index rti, Node *qual, int sublevels_up);
 static void remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel,
 										   Bitmapset *extra_used_attrs);
 
-
 /*
  * make_one_rel
  *	  Finds all possible access paths for executing a query, returning a
@@ -2674,6 +2673,11 @@ check_and_push_window_quals(Query *subquery, Node *clause,
  * So the paths made here will be parameterized if the subquery contains
  * LATERAL references, otherwise not.  As long as that's true, there's no need
  * for a separate set_subquery_size phase: just make the paths right away.
+ *
+ * (If a subquery is LATERAL, though, we do push down join clauses that refer
+ * to relations that the subquery already references laterally.  Pushing down
+ * such quals won't make the subquery any more lateral, so there's no reason
+ * not to.)
  */
 static void
 set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
@@ -2689,6 +2693,7 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
 	Bitmapset  *run_cond_attrs = NULL;
 	ListCell   *lc;
 	char	   *plan_name;
+	List	   *pushed_down_ec_joins = NIL;
 
 	/*
 	 * Must copy the Query so that planning doesn't mess up the RTE contents
@@ -2699,8 +2704,7 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
 
 	/*
 	 * If it's a LATERAL subquery, it might contain some Vars of the current
-	 * query level, requiring it to be treated as parameterized, even though
-	 * we don't support pushing down join quals into subqueries.
+	 * query level, requiring it to be treated as parameterized.
 	 */
 	required_outer = rel->lateral_relids;
 
@@ -2739,65 +2743,140 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
 	 * pseudoconstant clauses; better to have the gating node above the
 	 * subquery.
 	 *
+	 * Join clauses are only pushed down, if the subquery is LATERAL, and
+	 * the join clause only refers to relations that the subquery already
+	 * depends on.  It might be useful to push down other join clauses, too,
+	 * but then we would need to plan the subquery multiple times, to create
+	 * parameterized paths, which seems too expensive.
+	 *
 	 * Non-pushed-down clauses will get evaluated as qpquals of the
 	 * SubqueryScan node.
 	 *
 	 * XXX Are there any cases where we want to make a policy decision not to
 	 * push down a pushable qual, because it'd result in a worse plan?
 	 */
-	if (rel->baserestrictinfo != NIL &&
+	if ((rel->baserestrictinfo != NIL ||
+		 (!bms_is_empty(required_outer) && (rel->joininfo || rel->has_eclass_joins))) &&
 		subquery_is_pushdown_safe(subquery, subquery, &safetyInfo))
 	{
 		/* OK to consider pushing down individual quals */
-		List	   *upperrestrictlist = NIL;
 		ListCell   *l;
+		Bitmapset *available_relids;
 
-		foreach(l, rel->baserestrictinfo)
+		if (rel->baserestrictinfo)
 		{
-			RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
-			Node	   *clause = (Node *) rinfo->clause;
+			List	   *upperrestrictlist = NIL;
 
-			if (rinfo->pseudoconstant)
-			{
-				upperrestrictlist = lappend(upperrestrictlist, rinfo);
-				continue;
-			}
 
-			switch (qual_is_pushdown_safe(subquery, rti, rinfo, &safetyInfo))
+			foreach(l, rel->baserestrictinfo)
 			{
-				case PUSHDOWN_SAFE:
-					/* Push it down */
-					subquery_push_qual(subquery, rte, rti, clause);
-					break;
+				RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
+				Node	   *clause = (Node *) rinfo->clause;			
 
-				case PUSHDOWN_WINDOWCLAUSE_RUNCOND:
+				if (rinfo->pseudoconstant)
+				{
+					upperrestrictlist = lappend(upperrestrictlist, rinfo);
+					continue;
+				}
+
+				switch (qual_is_pushdown_safe(subquery, rti, rinfo, &safetyInfo))
+				{
+					case PUSHDOWN_SAFE:
+						/* Push it down */
+						subquery_push_qual(subquery, rte, rti, clause, 0);
+						break;
+
+					case PUSHDOWN_WINDOWCLAUSE_RUNCOND:
 
-					/*
-					 * Since we can't push the qual down into the subquery,
-					 * check if it happens to reference a window function.  If
-					 * so then it might be useful to use for the WindowAgg's
-					 * runCondition.
-					 */
-					if (!subquery->hasWindowFuncs ||
-						check_and_push_window_quals(subquery, clause,
-													&run_cond_attrs))
-					{
 						/*
-						 * subquery has no window funcs or the clause is not a
-						 * suitable window run condition qual or it is, but
-						 * the original must also be kept in the upper query.
-						 */
+						* Since we can't push the qual down into the subquery,
+						* check if it happens to reference a window function.  If
+						* so then it might be useful to use for the WindowAgg's
+						* runCondition.
+						*/
+						if (!subquery->hasWindowFuncs ||
+							check_and_push_window_quals(subquery, clause,
+														&run_cond_attrs))
+						{
+							/*
+							* subquery has no window funcs or the clause is not a
+							* suitable window run condition qual or it is, but
+							* the original must also be kept in the upper query.
+							*/
+							upperrestrictlist = lappend(upperrestrictlist, rinfo);
+						}
+						break;
+
+					case PUSHDOWN_UNSAFE:
+						/* Keep it in the upper query */
 						upperrestrictlist = lappend(upperrestrictlist, rinfo);
+						break;
+				}
+			}
+		}
+
+				/*
+		 * Push down join quals, as well.  But only for LATERAL, and only for those
+		 * relations that are "required" anyway.
+		 */
+		if (!bms_is_empty(required_outer))
+		{
+			available_relids = bms_copy(required_outer);
+			available_relids = bms_add_member(available_relids, rti);
+
+			if (rel->joininfo)
+ 			{
+				ListCell   *lc;
+				List	   *upperjoinlist = NIL;
+
+				foreach(lc, rel->joininfo)
+				{
+					RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+					Node       *clause = (Node *) rinfo->clause;
+
+					if (!rinfo->pseudoconstant &&
+						bms_is_subset(rinfo->required_relids, available_relids) &&
+						qual_is_pushdown_safe(subquery, rti, clause, &safetyInfo))
+					{
+						/* Push it down */
+						subquery_push_qual(subquery, rte, rti, clause, 0);
+					}
+					else
+					{
+						/* Keep it in the upper query */
+						upperjoinlist = lappend(upperjoinlist, rinfo);
 					}
-					break;
+				}
+				rel->joininfo = upperjoinlist;
+			}
 
-				case PUSHDOWN_UNSAFE:
-					upperrestrictlist = lappend(upperrestrictlist, rinfo);
-					break;
+			if (rel->has_eclass_joins)
+			{
+				List	   *clauses;
+
+				clauses =	generate_join_implied_equalities(root,
+														 available_relids,
+														 required_outer,
+														 rel,
+														 NULL);
+
+				foreach(lc, clauses)
+				{
+					RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+					Node       *clause = (Node *) rinfo->clause;
+
+					if (!rinfo->pseudoconstant &&
+						qual_is_pushdown_safe(subquery, rti, clause, &safetyInfo))
+					{
+						/* Push it down */
+						Assert(bms_is_subset(rinfo->required_relids, available_relids));
+						subquery_push_qual(subquery, rte, rti, clause, 0);
+
+						pushed_down_ec_joins = lappend(pushed_down_ec_joins, clause);
+					}
+				}
 			}
 		}
-		rel->baserestrictinfo = upperrestrictlist;
-		/* We don't bother recomputing baserestrict_min_security */
 	}
 
 	pfree(safetyInfo.unsafeFlags);
@@ -2908,7 +2987,7 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
 		add_path(rel, (Path *)
 				 create_subqueryscan_path(root, rel, subpath,
 										  trivial_pathtarget,
-										  pathkeys, required_outer));
+										  pathkeys, required_outer, pushed_down_ec_joins));
 	}
 
 	/* If outer rel allows parallelism, do same for partial paths. */
@@ -2935,7 +3014,7 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
 							 create_subqueryscan_path(root, rel, subpath,
 													  trivial_pathtarget,
 													  pathkeys,
-													  required_outer));
+													  required_outer, pushed_down_ec_joins));
 		}
 	}
 }
@@ -4505,6 +4584,13 @@ qual_is_pushdown_safe(Query *subquery, Index rti, RestrictInfo *rinfo,
 			break;
 		}
 
+		/*
+		 * In a restriction clause, all Vars must refer to subselect output
+		 * columns, but join quals will contain Vars referring to other relations.
+		 */
+		if (var->varno != rti)
+			continue;
+
 		/* Subqueries have no system columns */
 		Assert(var->varattno >= 0);
 
@@ -4543,26 +4629,32 @@ qual_is_pushdown_safe(Query *subquery, Index rti, RestrictInfo *rinfo,
  * subquery_push_qual - push down a qual that we have determined is safe
  */
 static void
-subquery_push_qual(Query *subquery, RangeTblEntry *rte, Index rti, Node *qual)
+subquery_push_qual(Query *subquery, RangeTblEntry *rte, Index rti, Node *qual, int sublevels_up)
 {
 	if (subquery->setOperations != NULL)
 	{
 		/* Recurse to push it separately to each component query */
 		recurse_push_qual(subquery->setOperations, subquery,
-						  rte, rti, qual);
+						  rte, rti, qual, sublevels_up);
 	}
 	else
 	{
 		/*
 		 * We need to replace Vars in the qual (which must refer to outputs of
 		 * the subquery) with copies of the subquery's targetlist expressions.
 		 * Note that at this point, any uplevel Vars in the qual should have
-		 * been replaced with Params, so they need no work.
+		 * been replaced with Params, so they need no work.  But in a join qual,
+		 * there can be Vars referring to other relations at the same level.
+		 * We need to increment varlevelsup of those, so that when the qual is
+		 * pushed down, they refer to the parent query.
 		 *
 		 * This step also ensures that when we are pushing into a setop tree,
 		 * each component query gets its own copy of the qual.
 		 */
-		qual = ReplaceVarsFromTargetList(qual, rti, 0, rte,
+		qual = copyObject(qual);
+		IncrementVarSublevelsUp(qual, sublevels_up + 1, 0);
+
+		qual = ReplaceVarsFromTargetList(qual, rti, sublevels_up + 1, rte,
 										 subquery->targetList,
 										 subquery->resultRelation,
 										 REPLACEVARS_REPORT_ERROR, 0,
@@ -4592,7 +4684,7 @@ subquery_push_qual(Query *subquery, RangeTblEntry *rte, Index rti, Node *qual)
  */
 static void
 recurse_push_qual(Node *setOp, Query *topquery,
-				  RangeTblEntry *rte, Index rti, Node *qual)
+				  RangeTblEntry *rte, Index rti, Node *qual, int sublevels_up)
 {
 	if (IsA(setOp, RangeTblRef))
 	{
@@ -4601,14 +4693,14 @@ recurse_push_qual(Node *setOp, Query *topquery,
 		Query	   *subquery = subrte->subquery;
 
 		Assert(subquery != NULL);
-		subquery_push_qual(subquery, rte, rti, qual);
+		subquery_push_qual(subquery, rte, rti, qual, sublevels_up + 1);
 	}
 	else if (IsA(setOp, SetOperationStmt))
 	{
 		SetOperationStmt *op = (SetOperationStmt *) setOp;
 
-		recurse_push_qual(op->larg, topquery, rte, rti, qual);
-		recurse_push_qual(op->rarg, topquery, rte, rti, qual);
+		recurse_push_qual(op->larg, topquery, rte, rti, qual, sublevels_up);
+		recurse_push_qual(op->rarg, topquery, rte, rti, qual, sublevels_up);
 	}
 	else
 	{

src/backend/optimizer/plan/createplan.c

@@ -3544,6 +3544,9 @@ create_subqueryscan_plan(PlannerInfo *root, SubqueryScanPath *best_path,
 	RelOptInfo *rel = best_path->path.parent;
 	Index		scan_relid = rel->relid;
 	Plan	   *subplan;
+	ListCell   *l;
+	List	   *qpqual;
+	List	   *sq_quals = best_path->pushed_down_ec_joins;
 
 	/* it should be a subquery base rel... */
 	Assert(scan_relid > 0);
@@ -3556,6 +3559,33 @@ create_subqueryscan_plan(PlannerInfo *root, SubqueryScanPath *best_path,
 	 */
 	subplan = create_plan(rel->subroot, best_path->subpath);
 
+	/*
+	 * If we had pushed down any join clauses to the subquery, we don't need
+	 * to re-check them in the SubqueryScan node.
+	 *
+	 * This only applies to join clauses derived from equivalence classes.
+	 * Non-join quals, and non-EC-derived join clauses are immediately removed
+	 * from 'baserestrictinfo' and 'joininfo' when they're pushed down, so we
+	 * won't need to worry about them here.
+	 */
+	qpqual = NIL;
+	foreach (l, scan_clauses)
+	{
+		RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
+
+		if (rinfo->pseudoconstant)
+			continue;			/* we may drop pseudoconstants here */
+		if (list_member_ptr(sq_quals, rinfo))
+			continue;			/* simple duplicate */
+		if (is_redundant_derived_clause(rinfo, sq_quals))
+			continue;			/* derived from same EquivalenceClass */
+		if (!contain_mutable_functions((Node *) rinfo->clause) &&
+			predicate_implied_by(list_make1(rinfo->clause), sq_quals, false))
+			continue;			/* provably implied by indexquals */
+		qpqual = lappend(qpqual, rinfo);
+	}
+	scan_clauses = qpqual;
+
 	/* Sort clauses into best execution order */
 	scan_clauses = order_qual_clauses(root, scan_clauses);
 

src/backend/optimizer/prep/prepunion.c

@@ -551,7 +551,7 @@ build_setop_child_paths(PlannerInfo *root, RelOptInfo *rel,
 															subpath,
 															trivial_tlist,
 															pathkeys,
-															NULL));
+															NULL, NIL));
 		}
 
 		/* skip dealing with sorted paths if the setop doesn't need them */
@@ -619,7 +619,7 @@ build_setop_child_paths(PlannerInfo *root, RelOptInfo *rel,
 															subpath,
 															trivial_tlist,
 															pathkeys,
-															NULL));
+															NULL, NIL));
 		}
 	}
 
@@ -642,7 +642,7 @@ build_setop_child_paths(PlannerInfo *root, RelOptInfo *rel,
 		partial_path = (Path *)
 			create_subqueryscan_path(root, rel, partial_subpath,
 									 trivial_tlist,
-									 NIL, NULL);
+									 NIL, NULL, NIL);
 		add_partial_path(rel, partial_path);
 	}