Code changes after the first step of review:

1. Improve AQO output readability.
2. Add code comments on non-portability of the AQO knowledge base.
3. Fix incorrect row values in the TAP tests for  intelligent and learn modes.
4. Add comments on probabilistic nature of convergence by execution time.
5. Introduce the auto_tuning_convergence_error AQO parameter and set its value
to 0.01 for reduce volatility of the TAP tests output.
6. Fix the bugs of the AQO update script from v1.1 to v1.2.

Author: danolivo

aqo--1.1--1.2.sql

@@ -14,7 +14,7 @@ $$ LANGUAGE plpgsql;
 DO $$
 BEGIN
 	EXECUTE format('ALTER TABLE public.aqo_data DROP CONSTRAINT %s',
-				   aqo_migrate_to_1_2_get_pk('aqo_data'::regclass),
+				   aqo_migrate_to_1_2_get_pk('public.aqo_data'::regclass),
 				   'aqo_queries_query_hash_idx');
 END
 $$;
@@ -27,7 +27,7 @@ DROP FUNCTION aqo_migrate_to_1_2_get_pk(regclass);
 --
 
 -- Show query state at the AQO knowledge base
-CREATE FUNCTION public.aqo_status(hash int)
+CREATE OR REPLACE FUNCTION public.aqo_status(hash int)
 RETURNS TABLE (
 	"learn"			BOOL,
 	"use aqo"		BOOL,
@@ -48,57 +48,58 @@ SELECT	learn_aqo,use_aqo,auto_tuning,fspace_hash,
 		to_char(execution_time_with_aqo[n3],'9.99EEEE'),
 		to_char(cardinality_error_with_aqo[n1],'9.99EEEE'),
 		executions_with_aqo
-FROM aqo_queries aq, aqo_query_stat aqs,
+FROM public.aqo_queries aq, public.aqo_query_stat aqs,
 	(SELECT array_length(n1,1) AS n1, array_length(n2,1) AS n2,
 		array_length(n3,1) AS n3, array_length(n4,1) AS n4
 	FROM
 		(SELECT cardinality_error_with_aqo		AS n1,
 				cardinality_error_without_aqo	AS n2,
 				execution_time_with_aqo			AS n3,
 				execution_time_without_aqo		AS n4
-		FROM aqo_query_stat aqs WHERE
+		FROM public.aqo_query_stat aqs WHERE
 			aqs.query_hash = $1) AS al) AS q
 WHERE (aqs.query_hash = aq.query_hash) AND
 	aqs.query_hash = $1;
 $func$ LANGUAGE SQL;
 
-CREATE FUNCTION public.aqo_enable_query(hash int)
+CREATE OR REPLACE FUNCTION public.aqo_enable_query(hash int)
 RETURNS VOID
 AS $func$
-UPDATE aqo_queries SET
+UPDATE public.aqo_queries SET
 	learn_aqo = 'true',
 	use_aqo = 'true'
 	WHERE query_hash = $1;
 $func$ LANGUAGE SQL;
 
-CREATE FUNCTION public.aqo_disable_query(hash int)
+CREATE OR REPLACE FUNCTION public.aqo_disable_query(hash int)
 RETURNS VOID
 AS $func$
-UPDATE aqo_queries SET
+UPDATE public.aqo_queries SET
 	learn_aqo = 'false',
 	use_aqo = 'false',
 	auto_tuning = 'false'
 	WHERE query_hash = $1;
 $func$ LANGUAGE SQL;
 
-CREATE FUNCTION public.aqo_clear_hist(hash int)
+CREATE OR REPLACE FUNCTION public.aqo_clear_hist(hash int)
 RETURNS VOID
 AS $func$
-DELETE FROM aqo_data WHERE fspace_hash=$1;
+DELETE FROM public.aqo_data WHERE fspace_hash=$1;
 $func$ LANGUAGE SQL;
 
 -- Show queries that contains 'Never executed' nodes at the plan.
-CREATE FUNCTION public.aqo_ne_queries()
+CREATE OR REPLACE FUNCTION public.aqo_ne_queries()
 RETURNS SETOF int
 AS $func$
-SELECT query_hash FROM aqo_query_stat aqs WHERE -1 = ANY (cardinality_error_with_aqo::double precision[]);
+SELECT query_hash FROM public.aqo_query_stat aqs
+	WHERE -1 = ANY (cardinality_error_with_aqo::double precision[]);
 $func$ LANGUAGE SQL;
 
-CREATE FUNCTION public.aqo_drop(hash int)
+CREATE OR REPLACE FUNCTION public.aqo_drop(hash int)
 RETURNS VOID
 AS $func$
-DELETE FROM aqo_queries aq WHERE (aq.query_hash = $1);
-DELETE FROM aqo_data ad WHERE (ad.fspace_hash = $1);
-DELETE FROM aqo_query_stat aq WHERE (aq.query_hash = $1);
-DELETE FROM aqo_query_texts aq WHERE (aq.query_hash = $1);
+DELETE FROM public.aqo_queries aq WHERE (aq.query_hash = $1);
+DELETE FROM public.aqo_data ad WHERE (ad.fspace_hash = $1);
+DELETE FROM public.aqo_query_stat aq WHERE (aq.query_hash = $1);
+DELETE FROM public.aqo_query_texts aq WHERE (aq.query_hash = $1);
 $func$ LANGUAGE SQL;

aqo.h

@@ -226,6 +226,7 @@ extern int	auto_tuning_window_size;
 extern double auto_tuning_exploration;
 extern int	auto_tuning_max_iterations;
 extern int	auto_tuning_infinite_loop;
+extern double auto_tuning_convergence_error;
 
 /* Machine learning parameters */
 

aqo_pg12.patch

@@ -59,7 +59,7 @@ index 92969636b7..d05b07e037 100644
 +					error = 100. * (plan->predicted_cardinality - (rows*wrkrs))
 +												/ plan->predicted_cardinality;
 +					appendStringInfo(es->str,
-+							" (AQO predicted: cardinality=%lf, error=%.0lf%%, fsspace_hash=%d)",
++					" (AQO: cardinality=%.0lf, error=%.0lf%%, fsspace_hash=%d)",
 +							plan->predicted_cardinality, error, plan->fss_hash);
 +				}
 +				else

auto_tuning.c

@@ -9,6 +9,12 @@
  *
  *****************************************************************************/
 
+/*
+ * Auto tuning criteria criteria of an query convergence by overall cardinality
+ * of plan nodes.
+ */
+double auto_tuning_convergence_error = 0.01;
+
 static double get_mean(double *elems, int nelems);
 static double get_estimation(double *elems, int nelems);
 static bool is_stable(double *elems, int nelems);
@@ -52,7 +58,7 @@ get_estimation(double *elems, int nelems)
 }
 
 /*
- * Checks whether the series is stable with absolute or relative error 0.1.
+ * Checks whether the series is stable with absolute or relative error.
  */
 bool
 is_stable(double *elems, int nelems)
@@ -65,15 +71,15 @@ is_stable(double *elems, int nelems)
 	est = get_mean(elems, nelems - 1);
 	last = elems[nelems - 1];
 
-	return (est * 1.1 > last || est + 0.1 > last) &&
-		   (est * 0.9 < last || est - 0.1 < last);
+	return (est * (1. + auto_tuning_convergence_error) > last || est + auto_tuning_convergence_error > last) &&
+		   (est * (1. - auto_tuning_max_error) < last || est - auto_tuning_max_error < last);
 }
 
 /*
  * Tests whether cardinality qualities series is converged, i. e. learning
  * process may be considered as finished.
  * Now it checks whether the cardinality quality stopped decreasing with
- * absolute or relative error 0.1.
+ * absolute or relative error.
  */
 bool
 converged_cq(double *elems, int nelems)
@@ -147,6 +153,11 @@ automatical_query_tuning(int query_hash, QueryStat * stat)
 		query_context.use_aqo = true;
 	else
 	{
+		/*
+		 * Query is converged by cardinality error. Now AQO checks convergence
+		 * by execution time. It is volatile, probabilistic part of code.
+		 * XXX: this logic of auto tuning may be reworked later.
+		 */
 		t_aqo = get_estimation(stat->execution_time_with_aqo,
 							   stat->execution_time_with_aqo_size) +
 			get_estimation(stat->planning_time_with_aqo,

expected/aqo_intelligent.out

@@ -476,9 +476,9 @@ FROM aqo_test1 AS t1, aqo_test1 AS t2, aqo_test1 AS t3
 WHERE t1.a = t2.b AND t2.a = t3.b;
                                   QUERY PLAN                                   
 -------------------------------------------------------------------------------
- Hash Join  (cost=2.90..4.65 rows=20 width=12)
+ Hash Join  (cost=2.90..4.64 rows=18 width=12)
    Hash Cond: (t2.a = t3.b)
-   ->  Hash Join  (cost=1.45..2.92 rows=20 width=8)
+   ->  Hash Join  (cost=1.45..2.92 rows=19 width=8)
          Hash Cond: (t1.a = t2.b)
          ->  Seq Scan on aqo_test1 t1  (cost=0.00..1.20 rows=20 width=4)
          ->  Hash  (cost=1.20..1.20 rows=20 width=8)
@@ -492,11 +492,11 @@ FROM aqo_test1 AS t1, aqo_test1 AS t2, aqo_test1 AS t3, aqo_test1 AS t4
 WHERE t1.a = t2.b AND t2.a = t3.b AND t3.a = t4.b;
                                      QUERY PLAN                                      
 -------------------------------------------------------------------------------------
- Hash Join  (cost=4.35..6.37 rows=20 width=16)
+ Hash Join  (cost=4.35..6.33 rows=17 width=16)
    Hash Cond: (t3.a = t4.b)
-   ->  Hash Join  (cost=2.90..4.65 rows=20 width=12)
+   ->  Hash Join  (cost=2.90..4.64 rows=18 width=12)
          Hash Cond: (t2.a = t3.b)
-         ->  Hash Join  (cost=1.45..2.92 rows=20 width=8)
+         ->  Hash Join  (cost=1.45..2.92 rows=19 width=8)
                Hash Cond: (t1.a = t2.b)
                ->  Seq Scan on aqo_test1 t1  (cost=0.00..1.20 rows=20 width=4)
                ->  Hash  (cost=1.20..1.20 rows=20 width=8)
@@ -507,37 +507,6 @@ WHERE t1.a = t2.b AND t2.a = t3.b AND t3.a = t4.b;
          ->  Seq Scan on aqo_test1 t4  (cost=0.00..1.20 rows=20 width=8)
 (13 rows)
 
-EXPLAIN verbose SELECT t1.a AS a, t2.a AS b, t3.a AS c, t4.a AS d
-FROM aqo_test1 AS t1, aqo_test1 AS t2, aqo_test1 AS t3, aqo_test1 AS t4
-WHERE t1.a = t2.b AND t2.a = t3.b AND t3.a = t4.b;
-                                         QUERY PLAN                                         
---------------------------------------------------------------------------------------------
- Hash Join  (cost=4.35..6.37 rows=20 width=16)
-   Output: t1.a, t2.a, t3.a, t4.a
-   Hash Cond: (t3.a = t4.b)
-   ->  Hash Join  (cost=2.90..4.65 rows=20 width=12)
-         Output: t1.a, t2.a, t3.a
-         Hash Cond: (t2.a = t3.b)
-         ->  Hash Join  (cost=1.45..2.92 rows=20 width=8)
-               Output: t1.a, t2.a
-               Hash Cond: (t1.a = t2.b)
-               ->  Seq Scan on public.aqo_test1 t1  (cost=0.00..1.20 rows=20 width=4)
-                     Output: t1.a, t1.b
-               ->  Hash  (cost=1.20..1.20 rows=20 width=8)
-                     Output: t2.a, t2.b
-                     ->  Seq Scan on public.aqo_test1 t2  (cost=0.00..1.20 rows=20 width=8)
-                           Output: t2.a, t2.b
-         ->  Hash  (cost=1.20..1.20 rows=20 width=8)
-               Output: t3.a, t3.b
-               ->  Seq Scan on public.aqo_test1 t3  (cost=0.00..1.20 rows=20 width=8)
-                     Output: t3.a, t3.b
-   ->  Hash  (cost=1.20..1.20 rows=20 width=8)
-         Output: t4.a, t4.b
-         ->  Seq Scan on public.aqo_test1 t4  (cost=0.00..1.20 rows=20 width=8)
-               Output: t4.a, t4.b
- Using aqo: true
-(24 rows)
-
 DROP INDEX aqo_test0_idx_a;
 DROP TABLE aqo_test0;
 DROP INDEX aqo_test1_idx_a;

expected/aqo_learn.out

@@ -395,9 +395,9 @@ FROM aqo_test1 AS t1, aqo_test1 AS t2, aqo_test1 AS t3
 WHERE t1.a = t2.b AND t2.a = t3.b;
                                   QUERY PLAN                                   
 -------------------------------------------------------------------------------
- Hash Join  (cost=2.90..4.65 rows=20 width=12)
+ Hash Join  (cost=2.90..4.64 rows=18 width=12)
    Hash Cond: (t2.a = t3.b)
-   ->  Hash Join  (cost=1.45..2.92 rows=20 width=8)
+   ->  Hash Join  (cost=1.45..2.92 rows=19 width=8)
          Hash Cond: (t1.a = t2.b)
          ->  Seq Scan on aqo_test1 t1  (cost=0.00..1.20 rows=20 width=4)
          ->  Hash  (cost=1.20..1.20 rows=20 width=8)
@@ -411,11 +411,11 @@ FROM aqo_test1 AS t1, aqo_test1 AS t2, aqo_test1 AS t3, aqo_test1 AS t4
 WHERE t1.a = t2.b AND t2.a = t3.b AND t3.a = t4.b;
                                      QUERY PLAN                                      
 -------------------------------------------------------------------------------------
- Hash Join  (cost=4.35..6.37 rows=20 width=16)
+ Hash Join  (cost=4.35..6.33 rows=17 width=16)
    Hash Cond: (t3.a = t4.b)
-   ->  Hash Join  (cost=2.90..4.65 rows=20 width=12)
+   ->  Hash Join  (cost=2.90..4.64 rows=18 width=12)
          Hash Cond: (t2.a = t3.b)
-         ->  Hash Join  (cost=1.45..2.92 rows=20 width=8)
+         ->  Hash Join  (cost=1.45..2.92 rows=19 width=8)
                Hash Cond: (t1.a = t2.b)
                ->  Seq Scan on aqo_test1 t1  (cost=0.00..1.20 rows=20 width=4)
                ->  Hash  (cost=1.20..1.20 rows=20 width=8)

hash.c

@@ -45,6 +45,8 @@ static bool clause_is_eq_clause(Expr *clause);
 /*
  * Computes hash for given query.
  * Hash is supposed to be constant-insensitive.
+ * XXX: Hashing depend on Oids of database objects. It is restrict usability of
+ * the AQO knowledge base by current database at current Postgres instance.
  */
 int
 get_query_hash(Query *parse, const char *query_text)
@@ -149,7 +151,11 @@ get_fss_for_object(List *clauselist, List *selectivities, List *relidslist,
 	*nfeatures = n - sh;
 	(*features) = repalloc(*features, (*nfeatures) * sizeof(**features));
 
-	/* Generate feature subspace hash */
+	/*
+	 * Generate feature subspace hash.
+	 * XXX: Remember! that relidslist_hash isn't portable between postgres
+	 * instances.
+	 */
 	clauses_hash = get_int_array_hash(sorted_clauses, *nfeatures);
 	eclasses_hash = get_int_array_hash(eclass_hash, nargs);
 	relidslist_hash = get_relidslist_hash(relidslist);

machine_learning.c

@@ -96,12 +96,12 @@ double
 OkNNr_predict(int nrows, int ncols, double **matrix, const double *targets,
 			  double *features)
 {
-	double	   distances[aqo_K];
-	int			i;
-	int		   idx[aqo_K]; /* indexes of nearest neighbors */
-	double	   w[aqo_K];
-	double		w_sum;
-	double		result = 0;
+	double	distances[aqo_K];
+	int		i;
+	int		idx[aqo_K]; /* indexes of nearest neighbors */
+	double	w[aqo_K];
+	double	w_sum;
+	double	result = 0;
 
 	for (i = 0; i < nrows; ++i)
 		distances[i] = fs_distance(matrix[i], features, ncols);

sql/aqo_intelligent.sql

@@ -207,10 +207,6 @@ EXPLAIN SELECT t1.a AS a, t2.a AS b, t3.a AS c, t4.a AS d
 FROM aqo_test1 AS t1, aqo_test1 AS t2, aqo_test1 AS t3, aqo_test1 AS t4
 WHERE t1.a = t2.b AND t2.a = t3.b AND t3.a = t4.b;
 
-EXPLAIN verbose SELECT t1.a AS a, t2.a AS b, t3.a AS c, t4.a AS d
-FROM aqo_test1 AS t1, aqo_test1 AS t2, aqo_test1 AS t3, aqo_test1 AS t4
-WHERE t1.a = t2.b AND t2.a = t3.b AND t3.a = t4.b;
-
 DROP INDEX aqo_test0_idx_a;
 DROP TABLE aqo_test0;
 

utils.c

@@ -99,18 +99,18 @@ palloc_query_stat(void)
 	MemoryContext	oldCxt;
 
 	oldCxt = MemoryContextSwitchTo(AQOMemoryContext);
-	res = palloc0(sizeof(*res));
-	res->execution_time_with_aqo = palloc(aqo_stat_size *
+	res = palloc0(sizeof(QueryStat));
+	res->execution_time_with_aqo = palloc0(aqo_stat_size *
 								sizeof(res->execution_time_with_aqo[0]));
-	res->execution_time_without_aqo = palloc(aqo_stat_size *
+	res->execution_time_without_aqo = palloc0(aqo_stat_size *
 								sizeof(res->execution_time_without_aqo[0]));
-	res->planning_time_with_aqo = palloc(aqo_stat_size *
+	res->planning_time_with_aqo = palloc0(aqo_stat_size *
 								sizeof(res->planning_time_with_aqo[0]));
-	res->planning_time_without_aqo = palloc(aqo_stat_size *
+	res->planning_time_without_aqo = palloc0(aqo_stat_size *
 								sizeof(res->planning_time_without_aqo[0]));
-	res->cardinality_error_with_aqo = palloc(aqo_stat_size *
+	res->cardinality_error_with_aqo = palloc0(aqo_stat_size *
 								sizeof(res->cardinality_error_with_aqo[0]));
-	res->cardinality_error_without_aqo = palloc(aqo_stat_size *
+	res->cardinality_error_without_aqo = palloc0(aqo_stat_size *
 								sizeof(res->cardinality_error_without_aqo[0]));
 	MemoryContextSwitchTo(oldCxt);