Some mistakes, revealed by regression tests, passed at Raspberry PI4:

1. Fix uint64 format in some output messages.
2. Input parameters conversion mistake in aqo_queries_update.
3. Unneeded routine 'get_aqo_schema'.
4. Fix type of the first parameter (counter) in aqo_cardinality_error()
   and aqo_execution_time() routines.
5. Fix aqo_data() routine.

Author: danolivo

aqo--1.4--1.5.sql

@@ -62,7 +62,7 @@ CREATE FUNCTION aqo_data (
   OUT features		double precision[][],
   OUT targets		double precision[],
   OUT reliability	double precision[],
-  OUT oids			integer[]
+  OUT oids			Oid[]
 )
 RETURNS SETOF record
 AS 'MODULE_PATHNAME', 'aqo_data'
@@ -106,7 +106,7 @@ LANGUAGE C VOLATILE;
 -- nexecs - number of executions of queries associated with this ID.
 --
 CREATE OR REPLACE FUNCTION aqo_cardinality_error(controlled boolean)
-RETURNS TABLE(num bigint, id bigint, fshash bigint, error float, nexecs bigint)
+RETURNS TABLE(num integer, id bigint, fshash bigint, error double precision, nexecs bigint)
 AS 'MODULE_PATHNAME', 'aqo_cardinality_error'
 LANGUAGE C STRICT VOLATILE;
 COMMENT ON FUNCTION aqo_cardinality_error(boolean) IS
@@ -119,7 +119,7 @@ COMMENT ON FUNCTION aqo_cardinality_error(boolean) IS
 -- Last case is possible in disabled mode with aqo.force_collect_stat = 'on'.
 --
 CREATE OR REPLACE FUNCTION aqo_execution_time(controlled boolean)
-RETURNS TABLE(num bigint, id bigint, fshash bigint, exec_time float, nexecs bigint)
+RETURNS TABLE(num integer, id bigint, fshash bigint, exec_time double precision, nexecs bigint)
 AS 'MODULE_PATHNAME', 'aqo_execution_time'
 LANGUAGE C STRICT VOLATILE;
 COMMENT ON FUNCTION aqo_execution_time(boolean) IS

aqo.c

@@ -332,52 +332,6 @@ _PG_init(void)
 	MarkGUCPrefixReserved("aqo");
 }
 
-/*
- * Return AQO schema's Oid or InvalidOid if that's not possible.
- */
-Oid
-get_aqo_schema(void)
-{
-	Oid				result;
-	Relation		rel;
-	SysScanDesc		scandesc;
-	HeapTuple		tuple;
-	ScanKeyData		entry[1];
-	Oid				ext_oid;
-
-	/* It's impossible to fetch pg_aqo's schema now */
-	if (!IsTransactionState())
-		return InvalidOid;
-
-	ext_oid = get_extension_oid("aqo", true);
-	if (ext_oid == InvalidOid)
-		return InvalidOid; /* exit if pg_aqo does not exist */
-
-	ScanKeyInit(&entry[0],
-#if PG_VERSION_NUM >= 120000
-				Anum_pg_extension_oid,
-#else
-				ObjectIdAttributeNumber,
-#endif
-				BTEqualStrategyNumber, F_OIDEQ,
-				ObjectIdGetDatum(ext_oid));
-
-	rel = relation_open(ExtensionRelationId, AccessShareLock);
-	scandesc = systable_beginscan(rel, ExtensionOidIndexId, true,
-								  NULL, 1, entry);
-	tuple = systable_getnext(scandesc);
-
-	/* We assume that there can be at most one matching tuple */
-	if (HeapTupleIsValid(tuple))
-		result = ((Form_pg_extension) GETSTRUCT(tuple))->extnamespace;
-	else
-		result = InvalidOid;
-
-	systable_endscan(scandesc);
-	relation_close(rel, AccessShareLock);
-	return result;
-}
-
 /*
  * AQO is really needed for any activity?
  */

aqo.h

@@ -294,7 +294,6 @@ extern double *selectivity_cache_find_global_relid(int clause_hash,
 												   int global_relid);
 extern void selectivity_cache_clear(void);
 
-extern Oid get_aqo_schema(void);
 extern bool IsQueryDisabled(void);
 
 extern List *cur_classes;

expected/gucs.out

@@ -69,17 +69,17 @@ SELECT obj_description('aqo_reset'::regproc::oid);
 (1 row)
 
 \df aqo_cardinality_error
-                                                                List of functions
- Schema |         Name          |                                  Result data type                                  | Argument data types | Type 
---------+-----------------------+------------------------------------------------------------------------------------+---------------------+------
- public | aqo_cardinality_error | TABLE(num bigint, id bigint, fshash bigint, error double precision, nexecs bigint) | controlled boolean  | func
+                                                                 List of functions
+ Schema |         Name          |                                  Result data type                                   | Argument data types | Type 
+--------+-----------------------+-------------------------------------------------------------------------------------+---------------------+------
+ public | aqo_cardinality_error | TABLE(num integer, id bigint, fshash bigint, error double precision, nexecs bigint) | controlled boolean  | func
 (1 row)
 
 \df aqo_execution_time
                                                                  List of functions
- Schema |        Name        |                                    Result data type                                    | Argument data types | Type 
---------+--------------------+----------------------------------------------------------------------------------------+---------------------+------
- public | aqo_execution_time | TABLE(num bigint, id bigint, fshash bigint, exec_time double precision, nexecs bigint) | controlled boolean  | func
+ Schema |        Name        |                                    Result data type                                     | Argument data types | Type 
+--------+--------------------+-----------------------------------------------------------------------------------------+---------------------+------
+ public | aqo_execution_time | TABLE(num integer, id bigint, fshash bigint, exec_time double precision, nexecs bigint) | controlled boolean  | func
 (1 row)
 
 \df aqo_drop_class

learn_cache.c

@@ -112,11 +112,19 @@ lc_update_fss(uint64 fs, int fss, OkNNrdata *data, List *reloids)
 	ptr = (char *) hdr + sizeof(dsm_block_hdr); /* start point of variable data */
 
 	/* copy the matrix into DSM storage */
-	for (i = 0; i < aqo_K; ++i)
+
+	if (hdr->cols > 0)
 	{
-		if (i < hdr->rows)
+		for (i = 0; i < aqo_K; ++i)
+		{
+			if (i >= hdr->rows)
+				break;
+
+			if (!ptr || !data->matrix[i])
+				elog(PANIC, "Something disruptive have happened! %d, %d (%d %d)", i, hdr->rows, found, hdr->cols);
 			memcpy(ptr, data->matrix[i], sizeof(double) * hdr->cols);
-		ptr += sizeof(double) * data->cols;
+			ptr += sizeof(double) * data->cols;
+		}
 	}
 
 	/* copy targets into DSM storage */
@@ -177,7 +185,7 @@ lc_load_fss(uint64 fs, int fss, OkNNrdata *data, List **reloids)
 	Assert(fss_htab && aqo_learn_statement_timeout);
 
 	if (aqo_show_details)
-		elog(NOTICE, "[AQO] Load ML data for fs %lu, fss %d from the cache",
+		elog(NOTICE, "[AQO] Load ML data for fs "UINT64_FORMAT", fss %d from the cache",
 			 fs, fss);
 
 	LWLockAcquire(&aqo_state->lock, LW_SHARED);
@@ -213,6 +221,7 @@ init_with_dsm(OkNNrdata *data, dsm_block_hdr *hdr, List **reloids)
 	Assert(LWLockHeldByMeInMode(&aqo_state->lock, LW_EXCLUSIVE) ||
 		   LWLockHeldByMeInMode(&aqo_state->lock, LW_SHARED));
 	Assert(hdr->magic == AQO_SHARED_MAGIC);
+	Assert(hdr && ptr);
 
 	data->rows = hdr->rows;
 	data->cols = hdr->cols;
@@ -264,7 +273,7 @@ lc_flush_data(void)
 	ptr = get_dsm_all(&size);
 
 	/* Iterate through records and store them into the aqo_data table */
-	while(size > 0)
+	while (size > 0)
 	{
 		dsm_block_hdr  *hdr = (dsm_block_hdr *) ptr;
 		OkNNrdata		data;

path_utils.c

@@ -53,7 +53,7 @@ create_aqo_plan_node()
 {
 	AQOPlanNode *node = (AQOPlanNode *) newNode(sizeof(AQOPlanNode),
 															T_ExtensibleNode);
-
+	Assert(node != NULL);
 	memcpy(node, &DefaultAQOPlanNode, sizeof(AQOPlanNode));
 	node->rels = palloc(sizeof(RelSortOut));
 	node->rels->hrels = NIL;
@@ -557,6 +557,7 @@ AQOnodeCopy(struct ExtensibleNode *enew, const struct ExtensibleNode *eold)
 
 	Assert(IsA(old, ExtensibleNode));
 	Assert(strcmp(old->node.extnodename, AQO_PLAN_NODE) == 0);
+	Assert(new && old);
 
 	/* Copy static fields in one command */
 	memcpy(new, old, sizeof(AQOPlanNode));

postprocessing.c

@@ -318,7 +318,7 @@ should_learn(PlanState *ps, AQOPlanNode *node, aqo_obj_stat *ctx,
 			/* This node s*/
 			if (aqo_show_details)
 				elog(NOTICE,
-					 "[AQO] Learn on a plan node (%lu, %d), "
+					 "[AQO] Learn on a plan node ("UINT64_FORMAT", %d), "
 					"predicted rows: %.0lf, updated prediction: %.0lf",
 					 query_context.query_hash, node->fss, predicted, *nrows);
 
@@ -334,7 +334,7 @@ should_learn(PlanState *ps, AQOPlanNode *node, aqo_obj_stat *ctx,
 			if (ctx->learn && aqo_show_details &&
 				fabs(*nrows - predicted) / predicted > 0.2)
 				elog(NOTICE,
-					 "[AQO] Learn on a finished plan node (%lu, %d), "
+					 "[AQO] Learn on a finished plan node ("UINT64_FORMAT", %d), "
 					 "predicted rows: %.0lf, updated prediction: %.0lf",
 					 query_context.query_hash, node->fss, predicted, *nrows);
 
@@ -845,6 +845,7 @@ StoreToQueryEnv(QueryDesc *queryDesc)
 	enr->md.reliddesc = InvalidOid;
 	enr->md.tupdesc = NULL;
 	enr->reldata = palloc0(qcsize);
+	Assert(enr->reldata != NULL);
 	memcpy(enr->reldata, &query_context, qcsize);
 
 	if (newentry)
@@ -906,6 +907,7 @@ StorePlanInternals(QueryDesc *queryDesc)
 	enr->md.reliddesc = InvalidOid;
 	enr->md.tupdesc = NULL;
 	enr->reldata = palloc0(sizeof(int));
+	Assert(enr->reldata != NULL);
 	memcpy(enr->reldata, &njoins, sizeof(int));
 
 	if (newentry)
@@ -935,6 +937,7 @@ ExtractFromQueryEnv(QueryDesc *queryDesc)
 	if (enr == NULL)
 		return false;
 
+	Assert(enr->reldata != NULL);
 	memcpy(&query_context, enr->reldata, sizeof(QueryContextData));
 
 	return true;