Bugfix. Fix omissions related to shifting from 32-bit query hash to 64-bit hash

Author: danolivo

aqo.c

@@ -311,11 +311,13 @@ get_aqo_schema(void)
  * Init userlock
  */
 void
-init_lock_tag(LOCKTAG *tag, uint32 key1, uint32 key2)
+init_lock_tag(LOCKTAG *tag, uint64 key1, int32 key2)
 {
+	uint32 key = key1 % UINT32_MAX;
+
 	tag->locktag_field1 = AQO_MODULE_MAGIC;
-	tag->locktag_field2 = key1;
-	tag->locktag_field3 = key2;
+	tag->locktag_field2 = key;
+	tag->locktag_field3 = (uint32) key2;
 	tag->locktag_field4 = 0;
 	tag->locktag_type = LOCKTAG_USERLOCK;
 	tag->locktag_lockmethodid = USER_LOCKMETHOD;

aqo.h

@@ -276,7 +276,7 @@ int get_clause_hash(Expr *clause, int nargs, int *args_hash, int *eclass_hash);
 
 
 /* Storage interaction */
-extern bool find_query(uint64 qhash, Datum *search_values, bool *search_nulls);
+extern bool find_query(uint64 qhash, QueryContextData *ctx);
 extern bool update_query(uint64 qhash, uint64 fhash,
 						 bool learn_aqo, bool use_aqo, bool auto_tuning);
 extern bool add_query_text(uint64 query_hash, const char *query_string);
@@ -335,7 +335,7 @@ extern double *selectivity_cache_find_global_relid(int clause_hash,
 extern void selectivity_cache_clear(void);
 
 extern Oid get_aqo_schema(void);
-extern void init_lock_tag(LOCKTAG *tag, uint32 key1, uint32 key2);
+extern void init_lock_tag(LOCKTAG *tag, uint64 key1, int32 key2);
 extern bool IsQueryDisabled(void);
 
 extern List *cur_classes;

auto_tuning.c

@@ -145,7 +145,7 @@ is_in_infinite_loop_cq(double *elems, int nelems)
  * this query to false.
  */
 void
-automatical_query_tuning(uint64 query_hash, QueryStat * stat)
+automatical_query_tuning(uint64 qhash, QueryStat * stat)
 {
 	double		unstability = auto_tuning_exploration;
 	double		t_aqo,
@@ -205,11 +205,11 @@ automatical_query_tuning(uint64 query_hash, QueryStat * stat)
 	}
 
 	if (num_iterations <= auto_tuning_max_iterations || p_use > 0.5)
-		update_query(query_hash,
+		update_query(qhash,
 					 query_context.fspace_hash,
 					 query_context.learn_aqo,
 					 query_context.use_aqo,
 					 true);
 	else
-		update_query(query_hash, query_context.fspace_hash, false, false, false);
+		update_query(qhash, query_context.fspace_hash, false, false, false);
 }

expected/plancache.out

@@ -33,7 +33,7 @@ BEGIN
 END $$ LANGUAGE 'plpgsql';
 -- The function shows 6 executions without an AQO support (nnex) and
 -- 4 executions with usage of an AQO knowledge base (nex). Planning time in the
--- case of AQO support (pt) is equal to '-1', because the query plan is exracted
+-- case of AQO support (pt) is equal to '-1', because the query plan is extracted
 -- from the plan cache.
 SELECT * FROM f1();
  nnex | nex |      pt       

postprocessing.c

@@ -95,7 +95,7 @@ atomic_fss_learn_step(uint64 fs, int fss, OkNNrdata *data,
 {
 	LOCKTAG		tag;
 
-	init_lock_tag(&tag, (uint32) fs, fss);
+	init_lock_tag(&tag, fs, fss);
 	LockAcquire(&tag, ExclusiveLock, false, false);
 
 	if (!load_fss_ext(fs, fss, data, NULL, !isTimedOut))
@@ -835,10 +835,9 @@ aqo_ExecutorEnd(QueryDesc *queryDesc)
 			cardinality_error = cardinality_sum_errors / cardinality_num_objects;
 		else
 			cardinality_error = -1;
-		Assert(query_context.query_hash>=0);
+
 		/* Prevent concurrent updates. */
-		init_lock_tag(&tag, (uint32) query_context.query_hash,//my code
-					 (uint32) query_context.fspace_hash);//possible here
+		init_lock_tag(&tag, query_context.query_hash, query_context.fspace_hash);
 		LockAcquire(&tag, ExclusiveLock, false, false);
 
 		if (stat != NULL)
@@ -870,7 +869,6 @@ aqo_ExecutorEnd(QueryDesc *queryDesc)
 									 &stat->executions_without_aqo);
 
 			/* Store all learn data into the AQO service relations. */
-			Assert(query_context.query_hash>=0);
 			if (!query_context.adding_query && query_context.auto_tuning)
 				automatical_query_tuning(query_context.query_hash, stat);
 
@@ -1136,7 +1134,6 @@ print_into_explain(PlannedStmt *plannedstmt, IntoClause *into,
 	 */
 	if (aqo_mode != AQO_MODE_DISABLED || force_collect_stat)
 	{
-		Assert(query_context.query_hash>=0);
 		if (aqo_show_hash)
 			ExplainPropertyInteger("Query hash", NULL,
 									query_context.query_hash, es);

preprocessing.c

@@ -175,8 +175,6 @@ aqo_planner(Query *parse,
 			ParamListInfo boundParams)
 {
 	bool		query_is_stored = false;
-	Datum		query_params[5];
-	bool		query_nulls[5] = {false, false, false, false, false};
 	LOCKTAG		tag;
 	MemoryContext oldCxt;
 
@@ -226,7 +224,7 @@ aqo_planner(Query *parse,
 									boundParams);
 	}
 
-	elog(DEBUG1, "AQO will be used for query '%s', class %ld",
+	elog(DEBUG1, "AQO will be used for query '%s', class "UINT64_FORMAT,
 		 query_string ? query_string : "null string", query_context.query_hash);
 
 	oldCxt = MemoryContextSwitchTo(AQOMemoryContext);
@@ -240,8 +238,7 @@ aqo_planner(Query *parse,
 		goto ignore_query_settings;
 	}
 
-	query_is_stored = find_query(query_context.query_hash, &query_params[0],
-															&query_nulls[0]);
+	query_is_stored = find_query(query_context.query_hash, &query_context);
 
 	if (!query_is_stored)
 	{
@@ -295,16 +292,12 @@ aqo_planner(Query *parse,
 	else /* Query class exists in a ML knowledge base. */
 	{
 		query_context.adding_query = false;
-		query_context.learn_aqo = DatumGetBool(query_params[1]);
-		query_context.use_aqo = DatumGetBool(query_params[2]);
-		query_context.fspace_hash = DatumGetInt64(query_params[3]);
-		query_context.auto_tuning = DatumGetBool(query_params[4]);
-		query_context.collect_stat = query_context.auto_tuning;
+
+		/* Other query_context fields filled in the find_query() routine. */
 
 		/*
 		 * Deactivate query if no one reason exists for usage of an AQO machinery.
 		 */
-		Assert(query_context.query_hash>=0);
 		if (!query_context.learn_aqo && !query_context.use_aqo &&
 			!query_context.auto_tuning && !force_collect_stat)
 			add_deactivated_query(query_context.query_hash);
@@ -330,7 +323,6 @@ aqo_planner(Query *parse,
 			 * In this mode we want to learn with incoming query (if it is not
 			 * suppressed manually) and collect stats.
 			 */
-			Assert(query_context.query_hash>=0);
 			query_context.collect_stat = true;
 			query_context.fspace_hash = query_context.query_hash;
 			break;
@@ -354,15 +346,13 @@ aqo_planner(Query *parse,
 		 * find-add query and query text must be atomic operation to prevent
 		 * concurrent insertions.
 		 */
-		Assert(query_context.query_hash>=0);
-		init_lock_tag(&tag, (uint32) query_context.query_hash, (uint32) 0);//my code
+		init_lock_tag(&tag, query_context.query_hash, 0);
 		LockAcquire(&tag, ExclusiveLock, false, false);
 		/*
 		 * Add query into the AQO knowledge base. To process an error with
 		 * concurrent addition from another backend we will try to restart
 		 * preprocessing routine.
 		 */
-		Assert(query_context.query_hash>=0);
 		update_query(query_context.query_hash, query_context.fspace_hash,
 					 query_context.learn_aqo, query_context.use_aqo,
 					 query_context.auto_tuning);
@@ -371,7 +361,6 @@ aqo_planner(Query *parse,
 		 * Add query text into the ML-knowledge base. Just for further
 		 * analysis. In the case of cached plans we could have NULL query text.
 		 */
-		Assert(query_context.query_hash>=0);
 		if (query_string != NULL)
 			add_query_text(query_context.query_hash, query_string);
 
@@ -385,7 +374,6 @@ aqo_planner(Query *parse,
 		 * query execution statistics in any mode.
 		 */
 		query_context.collect_stat = true;
-		Assert(query_context.query_hash>=0);
 		query_context.fspace_hash = query_context.query_hash;
 	}
 

sql/plancache.sql

@@ -37,7 +37,7 @@ END $$ LANGUAGE 'plpgsql';
 
 -- The function shows 6 executions without an AQO support (nnex) and
 -- 4 executions with usage of an AQO knowledge base (nex). Planning time in the
--- case of AQO support (pt) is equal to '-1', because the query plan is exracted
+-- case of AQO support (pt) is equal to '-1', because the query plan is extracted
 -- from the plan cache.
 SELECT * FROM f1();