Improve some dirty code about calculation of a node rows production.

Fix the problem with full plan state tree passing.
Improve AQO messaging system.

Author: danolivo

aqo_pg12.patch

@@ -1,8 +1,16 @@
 diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
-index 92969636b7..42446d4e93 100644
+index 92969636b7..d05b07e037 100644
 --- a/src/backend/commands/explain.c
 +++ b/src/backend/commands/explain.c
-@@ -46,6 +46,9 @@ ExplainOneQuery_hook_type ExplainOneQuery_hook = NULL;
+@@ -24,6 +24,7 @@
+ #include "nodes/extensible.h"
+ #include "nodes/makefuncs.h"
+ #include "nodes/nodeFuncs.h"
++#include "optimizer/cost.h"
+ #include "parser/parsetree.h"
+ #include "rewrite/rewriteHandler.h"
+ #include "storage/bufmgr.h"
+@@ -46,6 +47,9 @@ ExplainOneQuery_hook_type ExplainOneQuery_hook = NULL;
  /* Hook for plugins to get control in explain_get_index_name() */
  explain_get_index_name_hook_type explain_get_index_name_hook = NULL;
 
@@ -12,7 +20,7 @@ index 92969636b7..42446d4e93 100644
 
  /* OR-able flags for ExplainXMLTag() */
  #define X_OPENING 0
-@@ -596,6 +599,10 @@ ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es,
+@@ -596,6 +600,10 @@ ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es,
  		ExplainPropertyFloat("Execution Time", "ms", 1000.0 * totaltime, 3,
  							 es);
 
@@ -22,45 +30,41 @@ index 92969636b7..42446d4e93 100644
 +
  	ExplainCloseGroup("Query", NULL, true, es);
  }
-
-@@ -1041,6 +1048,17 @@ ExplainPreScanNode(PlanState *planstate, Bitmapset **rels_used)
-	return planstate_tree_walker(planstate, ExplainPreScanNode, rels_used);
- }
-
-+static bool
-+we_need_to_sum_tuples(const Plan *plan)
-+{
-+	if (plan->path_parallel_workers > 0 && (
-+		plan->parallel_aware || nodeTag(plan) == T_HashJoin ||
-+								nodeTag(plan) == T_MergeJoin ||
-+								nodeTag(plan) == T_NestLoop))
-+		return true;
-+	return false;
-+}
-+
- /*
-  * ExplainNode -
-  *	  Appends a description of a plan tree to es->str
-@@ -1523,6 +1541,24 @@ ExplainNode(PlanState *planstate, List *ancestors,
+ 
+@@ -1523,6 +1531,38 @@ ExplainNode(PlanState *planstate, List *ancestors,
  				appendStringInfo(es->str,
  								 " (actual rows=%.0f loops=%.0f)",
  								 rows, nloops);
++
 +#ifdef AQO_EXPLAIN
-+			if (es->verbose && plan)
++			if (es->verbose && plan && planstate->instrument)
 +			{
 +				int wrkrs = 1;
 +				double error = -1.;
 +
-+				if (planstate->worker_instrument && we_need_to_sum_tuples(plan))
-+					wrkrs += planstate->worker_instrument->num_workers;
++				if (planstate->worker_instrument && IsParallelTuplesProcessing(plan))
++				{
++					int i;
++					for (i = 0; i < planstate->worker_instrument->num_workers; i++)
++					{
++						Instrumentation *instrument = &planstate->worker_instrument->instrument[i];
++						if (instrument->nloops <= 0)
++							continue;
++						wrkrs++;
++					}
++				}
 +
 +				if (plan->predicted_cardinality > 0.)
 +				{
-+					error = 100. * (plan->predicted_cardinality-(rows*wrkrs)) / (rows * wrkrs);
++					error = 100. * (plan->predicted_cardinality - (rows*wrkrs))
++												/ plan->predicted_cardinality;
 +					appendStringInfo(es->str,
-+							" (AQO predicted: cardinality=%.0lf, error=%.0lf%%, fss=%d)",
++							" (AQO predicted: cardinality=%lf, error=%.0lf%%, fsspace_hash=%d)",
 +							plan->predicted_cardinality, error, plan->fss_hash);
 +				}
++				else
++					appendStringInfo(es->str, " (AQO not used, fsspace_hash=%d)",
++																plan->fss_hash);
 +			}
 +#endif
  		}
@@ -84,7 +88,7 @@ index 78deade89b..b1470147e9 100644
  	COPY_BITMAPSET_FIELD(allParam);
  }
 diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
-index a2a9b1f7be..bc7a69bb05 100644
+index a2a9b1f7be..4b766b9885 100644
 --- a/src/backend/optimizer/path/costsize.c
 +++ b/src/backend/optimizer/path/costsize.c
 @@ -96,6 +96,10 @@
@@ -401,7 +405,22 @@ index a2a9b1f7be..bc7a69bb05 100644
  {
  	double		nrows;
 
-@@ -5478,10 +5594,10 @@ page_size(double tuples, int width)
+@@ -5474,14 +5590,25 @@ page_size(double tuples, int width)
+ 	return ceil(relation_byte_size(tuples, width) / BLCKSZ);
+ }
+ 
++bool
++IsParallelTuplesProcessing(const Plan *plan)
++{
++	if (plan->path_parallel_workers > 0 && (
++		plan->parallel_aware || nodeTag(plan) == T_HashJoin ||
++								nodeTag(plan) == T_MergeJoin ||
++								nodeTag(plan) == T_NestLoop))
++		return true;
++	return false;
++}
++
+ /*
   * Estimate the fraction of the work that each worker will do given the
   * number of workers budgeted for the path.
   */
@@ -415,7 +434,7 @@ index a2a9b1f7be..bc7a69bb05 100644
 
  	/*
  	 * Early experience with parallel query suggests that when there is only
-@@ -5498,7 +5614,7 @@ get_parallel_divisor(Path *path)
+@@ -5498,7 +5625,7 @@ get_parallel_divisor(Path *path)
  	{
  		double		leader_contribution;
 
@@ -927,7 +946,7 @@ index 70f8b8e22b..d188c2596a 100644
  	 * Information for management of parameter-change-driven rescanning
  	 *
 diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h
-index 9b6bdbc518..4f93e222ca 100644
+index 9b6bdbc518..2a0caa6474 100644
 --- a/src/include/optimizer/cost.h
 +++ b/src/include/optimizer/cost.h
 @@ -39,6 +39,33 @@ typedef enum
@@ -998,10 +1017,11 @@ index 9b6bdbc518..4f93e222ca 100644
  extern void set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel);
  extern void set_function_size_estimates(PlannerInfo *root, RelOptInfo *rel);
  extern void set_values_size_estimates(PlannerInfo *root, RelOptInfo *rel);
-@@ -198,5 +241,6 @@ extern void set_foreign_size_estimates(PlannerInfo *root, RelOptInfo *rel);
+@@ -198,5 +241,7 @@ extern void set_foreign_size_estimates(PlannerInfo *root, RelOptInfo *rel);
  extern PathTarget *set_pathtarget_cost_width(PlannerInfo *root, PathTarget *target);
  extern double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel,
  								   Path *bitmapqual, int loop_count, Cost *cost, double *tuple);
++extern bool IsParallelTuplesProcessing(const Plan *plan);
 +extern double get_parallel_divisor(int parallel_workers);
 
  #endif							/* COST_H */

cardinality_estimation.c

@@ -1,4 +1,5 @@
 #include "aqo.h"
+#include "optimizer/optimizer.h"
 
 /*****************************************************************************
  *
@@ -53,5 +54,5 @@ predict_for_relation(List *restrict_clauses, List *selectivities, List *relids,
 	if (result < 0)
 		return -1;
 	else
-		return exp(result);
+		return clamp_row_est(exp(result));
 }

postprocessing.c

@@ -1,5 +1,6 @@
 #include "aqo.h"
 #include "access/parallel.h"
+#include "optimizer/optimizer.h"
 #include "utils/queryenvironment.h"
 
 /*****************************************************************************
@@ -184,17 +185,6 @@ restore_selectivities(List *clauselist,
 	return lst;
 }
 
-static bool
-we_need_to_sum_tuples(const Plan *plan)
-{
-	if (plan->path_parallel_workers > 0 && (
-		plan->parallel_aware || nodeTag(plan) == T_HashJoin ||
-								nodeTag(plan) == T_MergeJoin ||
-								nodeTag(plan) == T_NestLoop))
-		return true;
-	return false;
-}
-
 /*
  * Walks over obtained PlanState tree, collects relation objects with their
  * clauses, selectivities and relids and passes each object to learn_sample.
@@ -210,8 +200,9 @@ static bool
 learnOnPlanState(PlanState *p, void *context)
 {
 	aqo_obj_stat *ctx = (aqo_obj_stat *) context;
+	aqo_obj_stat SubplanCtx = {NIL, NIL, NIL};
 
-	planstate_tree_walker(p, learnOnPlanState, context);
+	planstate_tree_walker(p, learnOnPlanState, (void *) &SubplanCtx);
 
 	/*
 	 * Some nodes inserts after planning step (See T_Hash node type).
@@ -225,9 +216,11 @@ learnOnPlanState(PlanState *p, void *context)
 												  p->plan->path_relids,
 												  p->plan->path_jointype,
 												  p->plan->was_parametrized);
-		ctx->selectivities = list_concat(ctx->selectivities, cur_selectivities);
-		ctx->clauselist = list_concat(ctx->clauselist,
+		SubplanCtx.selectivities = list_concat(SubplanCtx.selectivities,
+															cur_selectivities);
+		SubplanCtx.clauselist = list_concat(SubplanCtx.clauselist,
 											list_copy(p->plan->path_clauses));
+
 		if (p->plan->path_relids != NIL)
 			/*
 			 * This plan can be stored as cached plan. In the case we will have
@@ -246,7 +239,7 @@ learnOnPlanState(PlanState *p, void *context)
 			if (p->instrument->nloops > 0.)
 			{
 				/* If we can strongly calculate produced rows, do it. */
-				if (p->worker_instrument && we_need_to_sum_tuples(p->plan))
+				if (p->worker_instrument && IsParallelTuplesProcessing(p->plan))
 				{
 					double wnloops = 0.;
 					double wntuples = 0.;
@@ -256,6 +249,10 @@ learnOnPlanState(PlanState *p, void *context)
 					{
 						double t = p->worker_instrument->instrument[i].ntuples;
 						double l = p->worker_instrument->instrument[i].nloops;
+
+						if (l <= 0)
+							continue;
+
 						wntuples += t;
 						wnloops += l;
 						learn_rows += t/l;
@@ -268,7 +265,8 @@ learnOnPlanState(PlanState *p, void *context)
 											(p->instrument->nloops - wnloops);
 				}
 				else
-					/* We don't have any workers. */
+					/* This node does not required to sum tuples of each worker
+					 * to calculate produced rows.  */
 					learn_rows = p->instrument->ntuples / p->instrument->nloops;
 
 				if (p->plan->predicted_cardinality > 0.)
@@ -283,8 +281,7 @@ learnOnPlanState(PlanState *p, void *context)
 					predicted = p->plan->plan_rows;
 
 				/* It is needed for correct exp(result) calculation. */
-				if (learn_rows < 1.)
-					learn_rows = 1.;
+				learn_rows = clamp_row_est(learn_rows);
 			}
 			else
 			{
@@ -297,15 +294,20 @@ learnOnPlanState(PlanState *p, void *context)
 			}
 
 			/*
-			 * Some execution logic optimizations can lead to the situation
-			 * than a subtree will never be visited.
+			 * A subtree was not visited. In this case we can not teach AQO
+			 * because ntuples value is equal to 0 and we will got learn rows == 1.
+			 * It is false teaching, because at another place of a plan
+			 * scanning of the node may produce many tuples.
 			 */
-			if (!(p->instrument->ntuples <= 0. && p->instrument->nloops <= 0.))
-				learn_sample(ctx->clauselist, ctx->selectivities,
-										ctx->relidslist, learn_rows, predicted);
+			if (p->instrument->nloops >= 1)
+				learn_sample(SubplanCtx.clauselist, SubplanCtx.selectivities,
+								p->plan->path_relids, learn_rows, predicted);
 		}
 	}
 
+	ctx->clauselist = list_concat(ctx->clauselist, SubplanCtx.clauselist);
+	ctx->selectivities = list_concat(ctx->selectivities,
+												SubplanCtx.selectivities);
 	return false;
 }
 
@@ -429,6 +431,9 @@ aqo_ExecutorEnd(QueryDesc *queryDesc)
 		cardinality_num_objects = 0;
 
 		learnOnPlanState(queryDesc->planstate, (void *) &ctx);
+		list_free(ctx.clauselist);
+		list_free(ctx.relidslist);
+		list_free(ctx.selectivities);
 	}
 
 	if (query_context.collect_stat)