[PGPRO-7183] bring in line stable 13, 14, 15

Andrey Kazarinov · danolivo · commit 2f6f36f4c09e · 2022-12-21T09:33:19.000+05:00
Minor changes
diff --git a/Makefile b/Makefile
@@ -19,7 +19,7 @@ REGRESS_OPTS = --schedule=$(srcdir)/regress_schedule
 fdw_srcdir = $(top_srcdir)/contrib/postgres_fdw
 stat_srcdir = $(top_srcdir)/contrib/pg_stat_statements
 PG_CPPFLAGS += -I$(libpq_srcdir) -I$(fdw_srcdir) -I$(stat_srcdir)
-EXTRA_REGRESS_OPTS=--temp-config=$(top_srcdir)/$(subdir)/conf.add
+EXTRA_REGRESS_OPTS=--temp-config=$(top_srcdir)/$(subdir)/aqo.conf
 EXTRA_INSTALL = contrib/postgres_fdw contrib/pg_stat_statements
 
 DATA = aqo--1.0.sql aqo--1.0--1.1.sql aqo--1.1--1.2.sql aqo--1.2.sql \
diff --git a/README.md b/README.md
@@ -13,7 +13,10 @@ To avoid compatibility issues, the following branches in the git-repository are
 * `stable9_6`.
 * `stable11` - for PG v10 and v11.
 * `stable12` - for PG v12.
-* the `master` branch of the AQO repository correctly works with PGv13 and the PostgreSQL `master` branch.
+* `stable13` - for PG v13.
+* `stable14` - for PG v14.
+* `stable15` - for PG v15.
+* the `master` branch of the AQO repository correctly works with PGv15 and the PostgreSQL `master` branch.
 
 The module contains a patch and an extension. Patch has to be applied to the
 sources of PostgresSQL. Patch affects header files, that is why PostgreSQL
diff --git a/aqo--1.4--1.5.sql b/aqo--1.4--1.5.sql
@@ -19,6 +19,7 @@ DROP TABLE public.aqo_data CASCADE;
 DROP TABLE public.aqo_queries CASCADE;
 DROP TABLE public.aqo_query_texts CASCADE;
 DROP TABLE public.aqo_query_stat CASCADE;
+DROP FUNCTION invalidate_deactivated_queries_cache;
 
 
 /*
@@ -144,6 +145,7 @@ COMMENT ON FUNCTION aqo_drop_class(bigint) IS
 -- Returns number of deleted rows from aqo_queries and aqo_data tables.
 --
 CREATE OR REPLACE FUNCTION aqo_cleanup(OUT nfs integer, OUT nfss integer)
+RETURNS SETOF record
 AS 'MODULE_PATHNAME', 'aqo_cleanup'
 LANGUAGE C STRICT VOLATILE;
 COMMENT ON FUNCTION aqo_cleanup() IS
diff --git a/aqo.c b/aqo.c
@@ -353,7 +353,7 @@ _PG_init(void)
 	 */
 	AQOLearnMemCtx = AllocSetContextCreate(AQOTopMemCtx,
 											 "AQOLearnMemoryContext",
- 											 ALLOCSET_DEFAULT_SIZES);
+											 ALLOCSET_DEFAULT_SIZES);
 	RegisterResourceReleaseCallback(aqo_free_callback, NULL);
 	RegisterAQOPlanNodeMethods();
 
diff --git a/aqo.conf b/aqo.conf
@@ -0,0 +1,4 @@
+autovacuum = off
+shared_preload_libraries = 'postgres_fdw, aqo'
+max_parallel_maintenance_workers = 1 # switch off parallel workers because of unsteadiness
+aqo.wide_search = 'on'
diff --git a/conf.add b/conf.add
diff --git a/expected/gucs.out b/expected/gucs.out
@@ -93,7 +93,7 @@ SELECT obj_description('aqo_reset'::regproc::oid);
                                  List of functions
  Schema |    Name     | Result data type |        Argument data types        | Type 
 --------+-------------+------------------+-----------------------------------+------
- public | aqo_cleanup | record           | OUT nfs integer, OUT nfss integer | func
+ public | aqo_cleanup | SETOF record     | OUT nfs integer, OUT nfss integer | func
 (1 row)
 
 \df aqo_reset
diff --git a/expected/look_a_like.out b/expected/look_a_like.out
@@ -25,8 +25,7 @@ $$ LANGUAGE PLPGSQL;
 -- in the next queries with the same fss_hash
 SELECT str AS result
 FROM expln('
-SELECT x FROM A where x = 5;') AS str
-WHERE str NOT LIKE 'Query Identifier%';
+SELECT x FROM A where x = 5;') AS str;
                      result                     
 ------------------------------------------------
  Seq Scan on public.a (actual rows=100 loops=1)
@@ -42,7 +41,6 @@ WHERE str NOT LIKE 'Query Identifier%';
 SELECT str AS result
 FROM expln('
 SELECT x FROM A,B WHERE x = 5 AND A.x = B.y;') AS str
-WHERE str NOT LIKE 'Query Identifier%'
 ; -- Find cardinality for SCAN A(x=5) from a neighbour class, created by the
                          result                         
 --------------------------------------------------------
@@ -68,7 +66,6 @@ WHERE str NOT LIKE 'Query Identifier%'
 SELECT str AS result
 FROM expln('
 SELECT x, sum(x) FROM A,B WHERE y = 5 AND A.x = B.y group by(x);') AS str
-WHERE str NOT LIKE 'Query Identifier%'
 ; -- Find the JOIN cardinality from a neighbour class.
                             result                            
 --------------------------------------------------------------
@@ -97,8 +94,7 @@ WHERE str NOT LIKE 'Query Identifier%'
 -- cardinality 100 in the first Seq Scan on a
 SELECT str AS result
 FROM expln('
-SELECT x, sum(x) FROM A WHERE x = 5 group by(x);') AS str
-WHERE str NOT LIKE 'Query Identifier%';
+SELECT x, sum(x) FROM A WHERE x = 5 group by(x);') AS str;
                         result                        
 ------------------------------------------------------
  GroupAggregate (actual rows=1 loops=1)
@@ -120,7 +116,7 @@ WHERE str NOT LIKE 'Query Identifier%';
 SELECT str AS result
 FROM expln('
 SELECT x FROM A where x < 10 group by(x);') AS str
-WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
+WHERE str NOT LIKE '%Memory%';
                         result                         
 -------------------------------------------------------
  HashAggregate (actual rows=10 loops=1)
@@ -140,7 +136,7 @@ WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
 SELECT str AS result
 FROM expln('
 SELECT x,y FROM A,B WHERE x < 10 AND A.x = B.y;') AS str
-WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
+WHERE str NOT LIKE '%Memory%';
                            result                            
 -------------------------------------------------------------
  Merge Join (actual rows=100000 loops=1)
@@ -169,7 +165,7 @@ WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
 SELECT str AS result
 FROM expln('
 SELECT x FROM A,B where x < 10 and y > 10 group by(x);') AS str
-WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
+WHERE str NOT LIKE '%Memory%';
                           result                          
 ----------------------------------------------------------
  HashAggregate (actual rows=0 loops=1)
@@ -200,7 +196,7 @@ WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
 SELECT str AS result
 FROM expln('
 SELECT x,y FROM A,B WHERE x < 10 and y > 10 AND A.x = B.y;') AS str
-WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%'
+WHERE str NOT LIKE '%Memory%'
 ;
                           result                          
 ----------------------------------------------------------
diff --git a/expected/unsupported.out b/expected/unsupported.out
@@ -9,7 +9,7 @@ CREATE TABLE t1 AS SELECT mod(gs,10) AS x, mod(gs+1,10) AS y
 	FROM generate_series(1,1000) AS gs;
 ANALYZE t, t1;
 --
--- Do not support HAVING clause for now.
+-- Do not support HAVING clauses for now.
 --
 SELECT count(*) FROM (SELECT * FROM t GROUP BY (x) HAVING x > 3) AS q1;
  count 
@@ -34,6 +34,24 @@ EXPLAIN (COSTS OFF)
  JOINS: 0
 (11 rows)
 
+SELECT str FROM expln('
+EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF)
+	SELECT * FROM t GROUP BY (x) HAVING x > 3;
+') AS str WHERE str NOT LIKE '%Memory Usage%';
+                      str                      
+-----------------------------------------------
+ HashAggregate (actual rows=17 loops=1)
+   AQO not used
+   Group Key: x
+   ->  Seq Scan on t (actual rows=801 loops=1)
+         AQO: rows=801, error=0%
+         Filter: (x > 3)
+         Rows Removed by Filter: 199
+ Using aqo: true
+ AQO mode: LEARN
+ JOINS: 0
+(10 rows)
+
 --
 -- Doesn't estimates GROUP BY clause
 --
@@ -582,24 +600,28 @@ ORDER BY (md5(query_text),error) DESC;
  0.000 | EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF)                                         +
        |         SELECT count(*) FROM t WHERE (SELECT avg(x) FROM t t0 WHERE t0.x = t.x) =             +
        |         (SELECT avg(x) FROM t t0 WHERE t0.x = t.x);
+ 0.106 |                                                                                               +
+       | EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF)                                         +
+       |         SELECT * FROM t GROUP BY (x) HAVING x > 3;                                            +
+       | 
  0.000 | SELECT count(*) FROM                                                                          +
        |         (SELECT * FROM t WHERE x % 3 < (SELECT avg(x) FROM t t0 WHERE t0.x = t.x)) AS q1      +
        |                 JOIN                                                                          +
        |         (SELECT * FROM t WHERE x % 3 < (SELECT avg(x) FROM t t0 WHERE t0.x <> t.x)) AS q2     +
        |                 ON q1.x = q2.x+1;
-(12 rows)
+(13 rows)
 
 DROP TABLE t,t1 CASCADE; -- delete all tables used in the test
 SELECT count(*) FROM aqo_data; -- Just to detect some changes in the logic. May some false positives really bother us here?
  count 
 -------
-    42
+    44
 (1 row)
 
 SELECT * FROM aqo_cleanup();
  nfs | nfss 
 -----+------
-  12 |   42
+  13 |   44
 (1 row)
 
 SELECT count(*) FROM aqo_data; -- No one row should be returned
diff --git a/learn_cache.c b/learn_cache.c
@@ -227,7 +227,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);
+	Assert(hdr && ptr && hdr->rows > 0);
 
 	data->rows = hdr->rows;
 	data->cols = hdr->cols;
@@ -245,6 +245,12 @@ init_with_dsm(OkNNrdata *data, dsm_block_hdr *hdr, List **reloids)
 		}
 	}
 
+	/*
+	 * Kludge code. But we should rewrite this code because now all knowledge
+	 * base lives in non-transactional shared memory.
+	 */
+	ptr = (char *) hdr + sizeof(dsm_block_hdr) + (sizeof(double) * data->cols * aqo_K);
+
 	memcpy(data->targets, ptr, sizeof(double) * hdr->rows);
 	ptr += sizeof(double) * aqo_K;
 	memcpy(data->rfactors, ptr, sizeof(double) * hdr->rows);
@@ -261,7 +267,7 @@ init_with_dsm(OkNNrdata *data, dsm_block_hdr *hdr, List **reloids)
 		return calculate_size(hdr->cols, *reloids);
 	}
 
-	/* It is just read operation. No any interest in size calculation. */
+	/* It is just a read operation. No any interest in size calculation. */
 	return 0;
 }
 
@@ -293,7 +299,7 @@ lc_flush_data(void)
 		aqo_data_store(hdr->key.fs, hdr->key.fss, &data, reloids);
 
 		if (!hash_search(fss_htab, (void *) &hdr->key, HASH_REMOVE, NULL))
-			elog(ERROR, "[AQO] Flush: local ML cache is corrupted.");
+			elog(PANIC, "[AQO] Flush: local ML cache is corrupted.");
 	}
 
 	reset_dsm_cache();
@@ -323,7 +329,7 @@ lc_assign_hook(bool newval, void *extra)
 	while ((entry = (htab_entry *) hash_seq_search(&status)) != NULL)
 	{
 		if (!hash_search(fss_htab, (void *) &entry->key, HASH_REMOVE, NULL))
-			elog(ERROR, "[AQO] The local ML cache is corrupted.");
+			elog(PANIC, "[AQO] The local ML cache is corrupted.");
 	}
 	LWLockRelease(&aqo_state->lock);
 }
diff --git a/postprocessing.c b/postprocessing.c
@@ -636,6 +636,13 @@ set_timeout_if_need(QueryDesc *queryDesc)
 {
 	TimestampTz	fin_time;
 
+	if (IsParallelWorker())
+		/*
+		 * AQO timeout should stop only main worker. Other workers would be
+		* terminated by a regular ERROR machinery.
+		*/
+		return false;
+
 	if (!get_timeout_active(STATEMENT_TIMEOUT) || !aqo_learn_statement_timeout)
 		return false;
 
diff --git a/regress_schedule b/regress_schedule
@@ -10,6 +10,7 @@ test: gucs
 test: forced_stat_collection
 test: unsupported
 test: clean_aqo_data
+test: parallel_workers
 test: plancache
 # Performance-dependent test. Can be ignored if executes in containers or on slow machines
 ignore: statement_timeout
diff --git a/sql/aqo_fdw.sql b/sql/aqo_fdw.sql
@@ -6,6 +6,7 @@
 
 CREATE EXTENSION aqo;
 CREATE EXTENSION postgres_fdw;
+
 SET aqo.mode = 'learn';
 SET aqo.show_details = 'true'; -- show AQO info for each node and entire query.
 SET aqo.show_hash = 'false'; -- a hash value is system-depended. Ignore it.
diff --git a/sql/look_a_like.sql b/sql/look_a_like.sql
@@ -28,45 +28,41 @@ $$ LANGUAGE PLPGSQL;
 -- in the next queries with the same fss_hash
 SELECT str AS result
 FROM expln('
-SELECT x FROM A where x = 5;') AS str
-WHERE str NOT LIKE 'Query Identifier%';
+SELECT x FROM A where x = 5;') AS str;
 
 SELECT str AS result
 FROM expln('
 SELECT x FROM A,B WHERE x = 5 AND A.x = B.y;') AS str
-WHERE str NOT LIKE 'Query Identifier%'
 ; -- Find cardinality for SCAN A(x=5) from a neighbour class, created by the
 -- query, executed above.
 
 SELECT str AS result
 FROM expln('
 SELECT x, sum(x) FROM A,B WHERE y = 5 AND A.x = B.y group by(x);') AS str
-WHERE str NOT LIKE 'Query Identifier%'
 ; -- Find the JOIN cardinality from a neighbour class.
 
 -- cardinality 100 in the first Seq Scan on a
 SELECT str AS result
 FROM expln('
-SELECT x, sum(x) FROM A WHERE x = 5 group by(x);') AS str
-WHERE str NOT LIKE 'Query Identifier%';
+SELECT x, sum(x) FROM A WHERE x = 5 group by(x);') AS str;
 
 -- no one predicted rows. we use knowledge cardinalities of the query
 -- in the next queries with the same fss_hash
 SELECT str AS result
 FROM expln('
 SELECT x FROM A where x < 10 group by(x);') AS str
-WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
+WHERE str NOT LIKE '%Memory%';
 -- cardinality 1000 in Seq Scan on a
 SELECT str AS result
 FROM expln('
 SELECT x,y FROM A,B WHERE x < 10 AND A.x = B.y;') AS str
-WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
+WHERE str NOT LIKE '%Memory%';
 
 -- cardinality 100 in Seq Scan on a and Seq Scan on b
 SELECT str AS result
 FROM expln('
 SELECT x FROM A,B where x < 10 and y > 10 group by(x);') AS str
-WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
+WHERE str NOT LIKE '%Memory%';
 
 --
 -- TODO:
@@ -75,7 +71,7 @@ WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%';
 SELECT str AS result
 FROM expln('
 SELECT x,y FROM A,B WHERE x < 10 and y > 10 AND A.x = B.y;') AS str
-WHERE str NOT LIKE 'Query Identifier%' and str NOT LIKE '%Memory%'
+WHERE str NOT LIKE '%Memory%'
 ;
 
 RESET enable_material;
diff --git a/sql/unsupported.sql b/sql/unsupported.sql
@@ -12,12 +12,17 @@ CREATE TABLE t1 AS SELECT mod(gs,10) AS x, mod(gs+1,10) AS y
 ANALYZE t, t1;
 
 --
--- Do not support HAVING clause for now.
+-- Do not support HAVING clauses for now.
 --
 SELECT count(*) FROM (SELECT * FROM t GROUP BY (x) HAVING x > 3) AS q1;
 EXPLAIN (COSTS OFF)
 	SELECT count(*) FROM (SELECT * FROM t GROUP BY (x) HAVING x > 3) AS q1;
 
+SELECT str FROM expln('
+EXPLAIN (ANALYZE, COSTS OFF, SUMMARY OFF, TIMING OFF)
+	SELECT * FROM t GROUP BY (x) HAVING x > 3;
+') AS str WHERE str NOT LIKE '%Memory Usage%';
+
 --
 -- Doesn't estimates GROUP BY clause
 --
diff --git a/storage.c b/storage.c
diff --git a/storage.h b/storage.h

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ init_with_dsm(OkNNrdata data, dsm_block_hdr hdr, List **reloids)`
`227`	`227`	`Assert(LWLockHeldByMeInMode(&aqo_state->lock, LW_EXCLUSIVE) \|\|`
`228`	`228`	`LWLockHeldByMeInMode(&aqo_state->lock, LW_SHARED));`
`229`	`229`	`Assert(hdr->magic == AQO_SHARED_MAGIC);`
`230`		`- Assert(hdr && ptr);`
	`230`	`+ Assert(hdr && ptr && hdr->rows > 0);`
`231`	`231`
`232`	`232`	`data->rows = hdr->rows;`
`233`	`233`	`data->cols = hdr->cols;`
`@@ -245,6 +245,12 @@ init_with_dsm(OkNNrdata data, dsm_block_hdr hdr, List **reloids)`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`
	`248`	`+ /*`
	`249`	`+ * Kludge code. But we should rewrite this code because now all knowledge`
	`250`	`+ * base lives in non-transactional shared memory.`
	`251`	`+ */`
	`252`	`+ ptr = (char ) hdr + sizeof(dsm_block_hdr) + (sizeof(double) data->cols * aqo_K);`
	`253`	`+`
`248`	`254`	`memcpy(data->targets, ptr, sizeof(double) * hdr->rows);`
`249`	`255`	`ptr += sizeof(double) * aqo_K;`
`250`	`256`	`memcpy(data->rfactors, ptr, sizeof(double) * hdr->rows);`
`@@ -261,7 +267,7 @@ init_with_dsm(OkNNrdata data, dsm_block_hdr hdr, List **reloids)`
`261`	`267`	`return calculate_size(hdr->cols, *reloids);`
`262`	`268`	`}`
`263`	`269`
`264`		`- /* It is just read operation. No any interest in size calculation. */`
	`270`	`+ /* It is just a read operation. No any interest in size calculation. */`
`265`	`271`	`return 0;`
`266`	`272`	`}`
`267`	`273`
`@@ -293,7 +299,7 @@ lc_flush_data(void)`
`293`	`299`	`aqo_data_store(hdr->key.fs, hdr->key.fss, &data, reloids);`
`294`	`300`
`295`	`301`	`if (!hash_search(fss_htab, (void *) &hdr->key, HASH_REMOVE, NULL))`
`296`		`- elog(ERROR, "[AQO] Flush: local ML cache is corrupted.");`
	`302`	`+ elog(PANIC, "[AQO] Flush: local ML cache is corrupted.");`
`297`	`303`	`}`
`298`	`304`
`299`	`305`	`reset_dsm_cache();`
`@@ -323,7 +329,7 @@ lc_assign_hook(bool newval, void *extra)`
`323`	`329`	`while ((entry = (htab_entry *) hash_seq_search(&status)) != NULL)`
`324`	`330`	`{`
`325`	`331`	`if (!hash_search(fss_htab, (void *) &entry->key, HASH_REMOVE, NULL))`
`326`		`- elog(ERROR, "[AQO] The local ML cache is corrupted.");`
	`332`	`+ elog(PANIC, "[AQO] The local ML cache is corrupted.");`
`327`	`333`	`}`
`328`	`334`	`LWLockRelease(&aqo_state->lock);`
`329`	`335`	`}`