Rewrite aqo_execution_time in C.

Now, I guess, the extension is truly relocatable. We should check it by some tests on extension moving.

Author: danolivo

aqo--1.4--1.5.sql

@@ -75,6 +75,43 @@ CREATE VIEW aqo_queries AS SELECT * FROM aqo_queries();
 
 /* UI functions */
 
+
+CREATE FUNCTION aqo_enable_query(queryid bigint)
+RETURNS void
+AS 'MODULE_PATHNAME', 'aqo_enable_query'
+LANGUAGE C STRICT VOLATILE;
+
+CREATE FUNCTION aqo_disable_query(queryid bigint)
+RETURNS void
+AS 'MODULE_PATHNAME', 'aqo_enable_query'
+LANGUAGE C STRICT VOLATILE;
+
+CREATE FUNCTION aqo_queries_update(
+queryid bigint, fs bigint, learn_aqo bool, use_aqo bool, auto_tuning bool)
+RETURNS bool
+AS 'MODULE_PATHNAME', 'aqo_queries_update'
+LANGUAGE C VOLATILE;
+
+--
+-- Get cardinality error of queries the last time they were executed.
+-- IN:
+-- controlled - show queries executed under a control of AQO (true);
+-- executed without an AQO control, but AQO has a stat on the query (false).
+--
+-- OUT:
+-- num - sequental number. Smaller number corresponds to higher error.
+-- id - ID of a query.
+-- fshash - feature space. Usually equal to zero or ID.
+-- error - AQO error that calculated on plan nodes of the query.
+-- 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)
+AS 'MODULE_PATHNAME', 'aqo_cardinality_error'
+LANGUAGE C STRICT VOLATILE;
+COMMENT ON FUNCTION aqo_cardinality_error(boolean) IS
+'Get cardinality error of queries the last time they were executed. Order queries according to an error value.';
+
 --
 -- Show execution time of queries, for which AQO has statistics.
 -- controlled - show stat on executions where AQO was used for cardinality
@@ -83,48 +120,8 @@ CREATE VIEW aqo_queries AS SELECT * FROM aqo_queries();
 --
 CREATE OR REPLACE FUNCTION aqo_execution_time(controlled boolean)
 RETURNS TABLE(num bigint, id bigint, fshash bigint, exec_time float, nexecs bigint)
-AS $$
-BEGIN
-IF (controlled) THEN
--- Show a query execution time made with AQO support for the planner
--- cardinality estimations. Here we return result of last execution.
-RETURN QUERY
-SELECT
-row_number() OVER (ORDER BY (exectime, queryid, fs_hash) DESC) AS nn,
-queryid, fs_hash, exectime, execs
-FROM (
-SELECT
-aq.queryid AS queryid,
-aq.fs AS fs_hash,
-execution_time_with_aqo[array_length(execution_time_with_aqo, 1)] AS exectime,
-executions_with_aqo AS execs
-FROM aqo_queries aq JOIN aqo_query_stat aqs
-ON aq.queryid = aqs.queryid
-WHERE TRUE = ANY (SELECT unnest(execution_time_with_aqo) IS NOT NULL)
-) AS q1
-ORDER BY nn ASC;
-
-ELSE
--- Show a query execution time made without any AQO advise.
--- Return an average value across all executions.
-RETURN QUERY
-SELECT
-row_number() OVER (ORDER BY (exectime, queryid, fs_hash) DESC) AS nn,
-queryid, fs_hash, exectime, execs
-FROM (
-SELECT
-aq.queryid AS queryid,
-aq.fs AS fs_hash,
-(SELECT AVG(t) FROM unnest(execution_time_without_aqo) t) AS exectime,
-executions_without_aqo AS execs
-FROM aqo_queries aq JOIN aqo_query_stat aqs
-ON aq.queryid = aqs.queryid
-WHERE TRUE = ANY (SELECT unnest(execution_time_without_aqo) IS NOT NULL)
-) AS q1
-ORDER BY (nn) ASC;
-END IF;
-END;
-$$ LANGUAGE plpgsql;
+AS 'MODULE_PATHNAME', 'aqo_execution_time'
+LANGUAGE C STRICT VOLATILE;
 COMMENT ON FUNCTION aqo_execution_time(boolean) IS
 'Get execution time of queries. If controlled = true (AQO could advise cardinality estimations), show time of last execution attempt. Another case (AQO not used), return an average value of execution time across all known executions.';
 
@@ -152,76 +149,6 @@ LANGUAGE C STRICT VOLATILE;
 COMMENT ON FUNCTION aqo_cleanup() IS
 'Remove unneeded rows from the AQO ML storage';
 
---
--- Get cardinality error of queries the last time they were executed.
--- IN:
--- controlled - show queries executed under a control of AQO (true);
--- executed without an AQO control, but AQO has a stat on the query (false).
---
--- OUT:
--- num - sequental number. Smaller number corresponds to higher error.
--- id - ID of a query.
--- fshash - feature space. Usually equal to zero or ID.
--- error - AQO error that calculated on plan nodes of the query.
--- 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)
-AS 'MODULE_PATHNAME', 'aqo_cardinality_error'
-LANGUAGE C STRICT VOLATILE;
-COMMENT ON FUNCTION aqo_cardinality_error(boolean) IS
-'Get cardinality error of queries the last time they were executed. Order queries according to an error value.';
-
-CREATE FUNCTION aqo_status(hash bigint)
-RETURNS TABLE (
-"learn" BOOL,
-"use aqo" BOOL,
-"auto tune" BOOL,
-"fspace hash"	bigINT,
-"t_naqo" TEXT,
-"err_naqo" TEXT,
-"iters" BIGINT,
-"t_aqo" TEXT,
-"err_aqo" TEXT,
-"iters_aqo" BIGINT
-) AS $$
-SELECT	learn_aqo,use_aqo,auto_tuning,fs,
-to_char(execution_time_without_aqo[n4],'9.99EEEE'),
-to_char(cardinality_error_without_aqo[n2],'9.99EEEE'),
-executions_without_aqo,
-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,
-(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
-aqs.queryid = $1) AS al) AS q
-WHERE (aqs.queryid = aq.queryid) AND
-aqs.queryid = $1;
-$$ LANGUAGE SQL;
-
-CREATE FUNCTION aqo_enable_query(queryid bigint)
-RETURNS void
-AS 'MODULE_PATHNAME', 'aqo_enable_query'
-LANGUAGE C STRICT VOLATILE;
-
-CREATE FUNCTION aqo_disable_query(queryid bigint)
-RETURNS void
-AS 'MODULE_PATHNAME', 'aqo_enable_query'
-LANGUAGE C STRICT VOLATILE;
-
-CREATE FUNCTION aqo_queries_update(queryid bigint, fs bigint, learn_aqo bool,
-use_aqo bool, auto_tuning bool)
-RETURNS bool
-AS 'MODULE_PATHNAME', 'aqo_queries_update'
-LANGUAGE C VOLATILE;
-
 --
 -- Remove all records in the AQO storage.
 -- Return number of rows removed.

expected/schema.out

@@ -25,14 +25,16 @@ SELECT * FROM test;
 -- Check AQO service relations state after some manipulations
 -- Exclude fields with hash values from the queries. Hash is depend on
 -- nodefuncs code which is highly PostgreSQL version specific.
-SELECT query_text FROM aqo_query_texts;
+SELECT query_text FROM aqo_query_texts
+ORDER BY (md5(query_text)) DESC;
 query_text
 ---------------------------------------
 COMMON feature space (do not delete!)
 SELECT * FROM test;
 (2 rows)
 
-SELECT learn_aqo, use_aqo, auto_tuning FROM aqo_queries;
+SELECT learn_aqo, use_aqo, auto_tuning FROM aqo_queries
+ORDER BY (learn_aqo, use_aqo, auto_tuning);
 learn_aqo | use_aqo | auto_tuning
 -----------+---------+-------------
 f | f | f

expected/top_queries.out

@@ -63,17 +63,17 @@ SELECT count(*) FROM (SELECT x, y FROM t2 GROUP BY GROUPING SETS ((x,y), (x), (y
 31
 (1 row)
 
-SELECT num, to_char(error, '9.99EEEE') FROM aqo_cardinality_error(false) AS te
+SELECT to_char(error, '9.99EEEE') FROM aqo_cardinality_error(false) AS te
 WHERE te.fshash = (
 SELECT fs FROM aqo_queries
 WHERE aqo_queries.queryid = (
 SELECT aqo_query_texts.queryid FROM aqo_query_texts
 WHERE query_text = 'SELECT count(*) FROM (SELECT x, y FROM t2 GROUP BY GROUPING SETS ((x,y), (x), (y), ())) AS q1;'
 )
 );
-num | to_char
------+-----------
-1 | 1.94e+00
+to_char
+-----------
+1.94e+00
 (1 row)
 
 -- Should return zero

sql/schema.sql

@@ -21,6 +21,8 @@ SELECT * FROM test;
 -- Check AQO service relations state after some manipulations
 -- Exclude fields with hash values from the queries. Hash is depend on
 -- nodefuncs code which is highly PostgreSQL version specific.
-SELECT query_text FROM aqo_query_texts;
-SELECT learn_aqo, use_aqo, auto_tuning FROM aqo_queries;
+SELECT query_text FROM aqo_query_texts
+ORDER BY (md5(query_text)) DESC;
+SELECT learn_aqo, use_aqo, auto_tuning FROM aqo_queries
+ORDER BY (learn_aqo, use_aqo, auto_tuning);
 DROP SCHEMA IF EXISTS test1 CASCADE;

sql/top_queries.sql

@@ -33,7 +33,7 @@ CREATE TABLE t2 AS SELECT mod(gs,10) AS x, mod(gs+1,10) AS y
 SELECT count(*) FROM (SELECT x, y FROM t1 GROUP BY GROUPING SETS ((x,y), (x), (y), ())) AS q1;
 SELECT count(*) FROM (SELECT x, y FROM t2 GROUP BY GROUPING SETS ((x,y), (x), (y), ())) AS q1;
 
-SELECT num, to_char(error, '9.99EEEE') FROM aqo_cardinality_error(false) AS te
+SELECT to_char(error, '9.99EEEE') FROM aqo_cardinality_error(false) AS te
 WHERE te.fshash = (
 SELECT fs FROM aqo_queries
 WHERE aqo_queries.queryid = (

storage.c

@@ -103,6 +103,7 @@ PG_FUNCTION_INFO_V1(aqo_reset);
 PG_FUNCTION_INFO_V1(aqo_cleanup);
 PG_FUNCTION_INFO_V1(aqo_drop_class);
 PG_FUNCTION_INFO_V1(aqo_cardinality_error);
+PG_FUNCTION_INFO_V1(aqo_execution_time);
 
 
 bool
@@ -2282,7 +2283,7 @@ aqo_cardinality_error(PG_FUNCTION_ARGS)
 nexecs = controlled ? sentry->execs_with_aqo : sentry->execs_without_aqo;
 ce = controlled ? sentry->est_error_aqo : sentry->est_error;
 
-values[AQE_NN] = Int32GetDatum(counter++);
+values[AQE_NN] = Int32GetDatum(++counter);
 values[AQE_QUERYID] = Int64GetDatum(qentry->queryid);
 values[AQE_FS] = Int64GetDatum(qentry->fs);
 values[AQE_NEXECS] = Int64GetDatum(nexecs);
@@ -2296,3 +2297,107 @@ aqo_cardinality_error(PG_FUNCTION_ARGS)
 tuplestore_donestoring(tupstore);
 return (Datum) 0;
 }
+
+typedef enum {
+ET_NN = 0, ET_QUERYID, ET_FS, ET_EXECTIME, ET_NEXECS, ET_TOTAL_NCOLS
+} et_output_order;
+
+/*
+* XXX: maybe to merge with aqo_cardinality_error ?
+* XXX: Do we really want sequental number ?
+*/
+Datum
+aqo_execution_time(PG_FUNCTION_ARGS)
+{
+bool controlled = PG_GETARG_BOOL(0);
+ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+TupleDesc tupDesc;
+MemoryContext per_query_ctx;
+MemoryContext oldcontext;
+Tuplestorestate *tupstore;
+Datum values[AQE_TOTAL_NCOLS];
+bool nulls[AQE_TOTAL_NCOLS];
+HASH_SEQ_STATUS hash_seq;
+QueriesEntry *qentry;
+StatEntry *sentry;
+int counter = 0;
+
+/* check to see if caller supports us returning a tuplestore */
+if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+ereport(ERROR,
+(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+errmsg("set-valued function called in context that cannot accept a set")));
+if (!(rsinfo->allowedModes & SFRM_Materialize))
+ereport(ERROR,
+(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+errmsg("materialize mode required, but it is not allowed in this context")));
+
+/* Switch into long-lived context to construct returned data structures */
+per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+/* Build a tuple descriptor for our result type */
+if (get_call_result_type(fcinfo, NULL, &tupDesc) != TYPEFUNC_COMPOSITE)
+elog(ERROR, "return type must be a row type");
+Assert(tupDesc->natts == ET_TOTAL_NCOLS);
+
+tupstore = tuplestore_begin_heap(true, false, work_mem);
+rsinfo->returnMode = SFRM_Materialize;
+rsinfo->setResult = tupstore;
+rsinfo->setDesc = tupDesc;
+
+MemoryContextSwitchTo(oldcontext);
+
+LWLockAcquire(&aqo_state->queries_lock, LW_SHARED);
+LWLockAcquire(&aqo_state->stat_lock, LW_SHARED);
+
+hash_seq_init(&hash_seq, queries_htab);
+while ((qentry = hash_seq_search(&hash_seq)) != NULL)
+{
+bool	found;
+double *et;
+int64	nexecs;
+int nvals;
+double	tm = 0;
+
+memset(nulls, 0, ET_TOTAL_NCOLS * sizeof(nulls[0]));
+
+sentry = (StatEntry *) hash_search(stat_htab, &qentry->queryid,
+HASH_FIND, &found);
+if (!found)
+/* Statistics not found by some reason. Just go further */
+continue;
+
+nvals = controlled ? sentry->cur_stat_slot_aqo : sentry->cur_stat_slot;
+if (nvals == 0)
+/* No one stat slot filled */
+continue;
+
+nexecs = controlled ? sentry->execs_with_aqo : sentry->execs_without_aqo;
+et = controlled ? sentry->exec_time_aqo : sentry->exec_time;
+
+if (!controlled)
+{
+int i;
+/* Calculate average execution time */
+for (i = 0; i < nvals; i++)
+tm += et[i];
+tm /= nvals;
+}
+else
+tm = et[nvals - 1];
+
+values[ET_NN] = Int32GetDatum(++counter);
+values[ET_QUERYID] = Int64GetDatum(qentry->queryid);
+values[ET_FS] = Int64GetDatum(qentry->fs);
+values[ET_NEXECS] = Int64GetDatum(nexecs);
+values[ET_EXECTIME] = Float8GetDatum(tm);
+tuplestore_putvalues(tupstore, tupDesc, values, nulls);
+}
+
+LWLockRelease(&aqo_state->stat_lock);
+LWLockRelease(&aqo_state->queries_lock);
+
+tuplestore_donestoring(tupstore);
+return (Datum) 0;
+}