generic PickyAppend for prepared statements, remove redundant EXPLAIN-related code

funbringer · funbringer · commit c4b0063a7fa0 · 2016-04-20T19:42:26.000+03:00
diff --git a/hooks.c b/hooks.c
@@ -2,6 +2,7 @@
 #include "optimizer/cost.h"
 #include "optimizer/restrictinfo.h"
 #include "hooks.h"
+#include "utils.h"
 #include "pathman.h"
 #include "pickyappend.h"
 
@@ -239,6 +240,63 @@ pathman_rel_pathlist_hook(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTb
 		rel->pathlist = NIL;
 		set_append_rel_pathlist(root, rel, rti, rte, pathkeyAsc, pathkeyDesc);
 		set_append_rel_size(root, rel, rti, rte);
+
+		foreach (lc, rel->pathlist)
+		{
+			AppendPath	   *cur_path = (AppendPath *) lfirst(lc);
+			Relids			inner_required = PATH_REQ_OUTER((Path *) cur_path);
+			ParamPathInfo  *ppi = get_appendrel_parampathinfo(rel, inner_required);
+			Path		   *inner_path;
+			ListCell	   *subpath_cell;
+			List		   *picky_quals = NIL;
+
+			if (!IsA(cur_path, AppendPath) ||
+				rel->has_eclass_joins ||
+				rel->joininfo)
+			{
+				continue;
+			}
+
+			foreach (subpath_cell, cur_path->subpaths)
+			{
+				Path			   *subpath = (Path *) lfirst(subpath_cell);
+				RelOptInfo		   *child_rel = subpath->parent;
+				List			   *quals;
+				ListCell		   *qual_cell;
+				ReplaceVarsContext	repl_var_cxt;
+
+				repl_var_cxt.child = subpath->parent;
+				repl_var_cxt.parent = rel;
+				repl_var_cxt.sublevels_up = 0;
+
+				quals = extract_actual_clauses(child_rel->baserestrictinfo, false);
+
+				/* Do not proceed if there's a rel containing quals without params */
+				if (!clause_contains_extern_params((Node *) quals))
+					break;
+
+				/* Replace child Vars with a parent rel's Var */
+				quals = (List *) replace_child_vars_with_parent_var((Node *) quals,
+																	&repl_var_cxt);
+
+				/* Combine unique 'picky' quals */
+				foreach (qual_cell, quals)
+					picky_quals = list_append_unique(picky_quals,
+													 (Node *) lfirst(qual_cell));
+			}
+
+			/*
+			 * Dismiss PickyAppend if there
+			 * are no parameterized quals
+			 */
+			if (picky_quals == NIL)
+				continue;
+
+			inner_path = create_pickyappend_path(root, cur_path,
+												 ppi, picky_quals);
+
+			add_path(rel, inner_path);
+		}
 	}
 
 	/* Invoke original hook if needed */
diff --git a/nodes_common.c b/nodes_common.c
@@ -52,7 +52,7 @@ transform_plans_into_states(PickyAppendState *scan_state,
 		 * We should ReScan this node manually since
 		 * ExecProcNode won't do this for us in this case.
 		 */
-		if (!pps->ps->chgParam)
+		if (bms_is_empty(pps->ps->chgParam))
 			ExecReScan(pps->ps);
 
 		child->content.plan_state = pps->ps;
@@ -125,22 +125,6 @@ get_partition_oids(List *ranges, int *n, PartRelationInfo *prel)
 	return result;
 }
 
-/* Compare plans by 'original_order' */
-static int
-cmp_child_scan_common_by_orig_order(const void *ap,
-									const void *bp)
-{
-	ChildScanCommon a = *(ChildScanCommon *) ap;
-	ChildScanCommon b = *(ChildScanCommon *) bp;
-
-	if (a->original_order > b->original_order)
-		return 1;
-	else if (a->original_order < b->original_order)
-		return -1;
-	else
-		return 0;
-}
-
 static void
 pack_pickyappend_private(CustomScan *cscan, PickyAppendPath *path)
 {
@@ -172,7 +156,6 @@ unpack_pickyappend_private(PickyAppendState *scan_state, CustomScan *cscan)
 	int			nchildren = list_length(custom_oids);
 	HTAB	   *children_table = scan_state->children_table;
 	HASHCTL	   *children_table_config = &scan_state->children_table_config;
-	int			i;
 
 	memset(children_table_config, 0, sizeof(HASHCTL));
 	children_table_config->keysize = sizeof(Oid);
@@ -182,7 +165,6 @@ unpack_pickyappend_private(PickyAppendState *scan_state, CustomScan *cscan)
 								 children_table_config,
 							     HASH_ELEM | HASH_BLOBS);
 
-	i = 0;
 	forboth (oid_cell, custom_oids, plan_cell, cscan->custom_plans)
 	{
 		bool				child_found;
@@ -195,7 +177,6 @@ unpack_pickyappend_private(PickyAppendState *scan_state, CustomScan *cscan)
 		Assert(!child_found); /* there should be no collisions */
 
 		child->content.plan = (Plan *) lfirst(plan_cell);
-		child->original_order = i++; /* will be used in EXPLAIN */
 	}
 
 	scan_state->children_table = children_table;
@@ -333,6 +314,18 @@ begin_append_common(CustomScanState *node, EState *estate, int eflags)
 	scan_state->plan_state_table = plan_state_table;
 	scan_state->custom_expr_states = (List *) ExecInitExpr((Expr *) scan_state->custom_exprs,
 														   (PlanState *) scan_state);
+
+	/*
+	 * ExecProcNode() won't ReScan plans without params, do this
+	 * provided that there are no external PARAM_EXEC params.
+	 *
+	 * rescan_append_common is required for prepared statements,
+	 * but at the same time we don't want it to be called several
+	 * times within a single run (for example, ExecNestLoop calls
+	 * ExecReScan itself)
+	 */
+	if (!node->ss.ps.chgParam && bms_is_empty(node->ss.ps.plan->extParam))
+		rescan_append_common(node);
 }
 
 void
@@ -391,47 +384,5 @@ rescan_append_common(CustomScanState *node)
 void
 explain_append_common(CustomScanState *node, HTAB* children_table, ExplainState *es)
 {
-	/* Construct excess PlanStates */
-	if (!es->analyze)
-	{
-		int					allocated = 10;
-		int					used = 0;
-		ChildScanCommon	   *custom_ps = palloc(allocated * sizeof(ChildScanCommon));
-		ChildScanCommon		child;
-		HASH_SEQ_STATUS		seqstat;
-		int					i;
-
-		/* There can't be any nodes since we're not scanning anything */
-		Assert(!node->custom_ps);
-
-		hash_seq_init(&seqstat, children_table);
-
-		while ((child = (ChildScanCommon) hash_seq_search(&seqstat)))
-		{
-			if (allocated <= used)
-			{
-				allocated *= 2;
-				custom_ps = repalloc(custom_ps, allocated * sizeof(ChildScanCommon));
-			}
-
-			custom_ps[used++] = child;
-		}
-
-		/*
-		 * We have to restore the original plan order
-		 * which has been lost within the hash table
-		 */
-		qsort(custom_ps, used, sizeof(ChildScanCommon),
-			  cmp_child_scan_common_by_orig_order);
-
-		/*
-		 * These PlanStates will be used by EXPLAIN,
-		 * arrangeappend_end will destroy them eventually
-		 */
-		for (i = 0; i < used; i++)
-			node->custom_ps = lappend(node->custom_ps,
-									  ExecInitNode(custom_ps[i]->content.plan,
-												   node->ss.ps.state,
-												   0));
-	}
+	/* Nothing to do here */
 }
diff --git a/nodes_common.h b/nodes_common.h
@@ -24,8 +24,6 @@ typedef struct
 		Plan	   *plan;
 		PlanState  *plan_state;
 	}			content;
-
-	int			original_order;		/* for sorting in EXPLAIN */
 } ChildScanCommonData;
 
 typedef ChildScanCommonData *ChildScanCommon;
diff --git a/utils.c b/utils.c
@@ -2,6 +2,7 @@
 #include "nodes/nodeFuncs.h"
 #include "parser/parse_param.h"
 #include "utils/builtins.h"
+#include "rewrite/rewriteManip.h"
 
 
 static bool clause_contains_extern_params_walker(Node *node, void *context);
@@ -31,3 +32,30 @@ clause_contains_extern_params_walker(Node *node, void *context)
 								  clause_contains_extern_params_walker,
 								  context);
 }
+
+static Node *
+replace_child_var(Var *var, replace_rte_variables_context *context)
+{
+	ReplaceVarsContext *cxt = (ReplaceVarsContext *) context->callback_arg;
+	Var				   *new_var;
+
+	new_var = makeNode(Var);
+	memcpy(new_var, var, sizeof(Var));
+
+	/*
+	 * Replace a partition's Var with a Var
+	 * pointing to the PickyAppend's results
+	 */
+	new_var->varno = cxt->parent->relid;
+	new_var->location = -1;
+	new_var->varnoold = 0;
+
+	return (Node *) new_var;
+}
+
+Node *
+replace_child_vars_with_parent_var(Node *node, ReplaceVarsContext *context)
+{
+	return replace_rte_variables(node, context->child->relid, context->sublevels_up,
+								 replace_child_var, (void *) context, NULL);
+}
diff --git a/utils.h b/utils.h
@@ -2,8 +2,19 @@
 #define UTILS_H
 
 #include "postgres.h"
+#include "nodes/relation.h"
 #include "nodes/nodeFuncs.h"
 
+typedef struct
+{
+	RelOptInfo *child;
+	RelOptInfo *parent;
+	int			sublevels_up;
+} ReplaceVarsContext;
+
 bool clause_contains_extern_params(Node *clause);
 
+Node * replace_child_vars_with_parent_var(Node *node,
+										  ReplaceVarsContext *context);
+
 #endif
