mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-09-07 14:49:23 +02:00
0bd4b0689b
As explained in 4d916dd876, the test instability is caused by delayed
cleanup of deleted rows. This commit removes the DELETE, stabilizing the
test without accidentally disabling parallel builds.
The intent of the delete however was to produce empty ranges, and test
that the parallel index build populates those correctly. But there's
another way to create empty ranges - partial indexes, which does not
rely on cleanup of deleted rows.
Idea to use partial indexes by Matthias van de Meent, patch by me.
Discussion: https://postgr.es/m/95d9cd43-5a92-407c-b7e4-54cd303630fe%40enterprisedb.com
211 lines
8.5 KiB
Plaintext
211 lines
8.5 KiB
Plaintext
CREATE TABLE test1 (a int, b text);
|
|
INSERT INTO test1 VALUES (1, 'one');
|
|
CREATE INDEX test1_a_idx ON test1 USING brin (a);
|
|
SELECT brin_page_type(get_raw_page('test1_a_idx', 0));
|
|
brin_page_type
|
|
----------------
|
|
meta
|
|
(1 row)
|
|
|
|
SELECT brin_page_type(get_raw_page('test1_a_idx', 1));
|
|
brin_page_type
|
|
----------------
|
|
revmap
|
|
(1 row)
|
|
|
|
SELECT brin_page_type(get_raw_page('test1_a_idx', 2));
|
|
brin_page_type
|
|
----------------
|
|
regular
|
|
(1 row)
|
|
|
|
SELECT * FROM brin_metapage_info(get_raw_page('test1_a_idx', 0));
|
|
magic | version | pagesperrange | lastrevmappage
|
|
------------+---------+---------------+----------------
|
|
0xA8109CFA | 1 | 128 | 1
|
|
(1 row)
|
|
|
|
SELECT * FROM brin_metapage_info(get_raw_page('test1_a_idx', 1));
|
|
ERROR: page is not a BRIN page of type "metapage"
|
|
DETAIL: Expected special type 0000f091, got 0000f092.
|
|
SELECT * FROM brin_revmap_data(get_raw_page('test1_a_idx', 0)) LIMIT 5;
|
|
ERROR: page is not a BRIN page of type "revmap"
|
|
DETAIL: Expected special type 0000f092, got 0000f091.
|
|
SELECT * FROM brin_revmap_data(get_raw_page('test1_a_idx', 1)) LIMIT 5;
|
|
pages
|
|
-------
|
|
(2,1)
|
|
(0,0)
|
|
(0,0)
|
|
(0,0)
|
|
(0,0)
|
|
(5 rows)
|
|
|
|
SELECT * FROM brin_page_items(get_raw_page('test1_a_idx', 2), 'test1_a_idx')
|
|
ORDER BY blknum, attnum LIMIT 5;
|
|
itemoffset | blknum | attnum | allnulls | hasnulls | placeholder | empty | value
|
|
------------+--------+--------+----------+----------+-------------+-------+----------
|
|
1 | 0 | 1 | f | f | f | f | {1 .. 1}
|
|
(1 row)
|
|
|
|
-- Mask DETAIL messages as these are not portable across architectures.
|
|
\set VERBOSITY terse
|
|
-- Failures for non-BRIN index.
|
|
CREATE INDEX test1_a_btree ON test1 (a);
|
|
SELECT brin_page_items(get_raw_page('test1_a_btree', 0), 'test1_a_btree');
|
|
ERROR: "test1_a_btree" is not a BRIN index
|
|
SELECT brin_page_items(get_raw_page('test1_a_btree', 0), 'test1_a_idx');
|
|
ERROR: input page is not a valid BRIN page
|
|
-- Invalid special area size
|
|
SELECT brin_page_type(get_raw_page('test1', 0));
|
|
ERROR: input page is not a valid BRIN page
|
|
SELECT * FROM brin_metapage_info(get_raw_page('test1', 0));
|
|
ERROR: input page is not a valid BRIN page
|
|
SELECT * FROM brin_revmap_data(get_raw_page('test1', 0));
|
|
ERROR: input page is not a valid BRIN page
|
|
\set VERBOSITY default
|
|
-- Tests with all-zero pages.
|
|
SHOW block_size \gset
|
|
SELECT brin_page_type(decode(repeat('00', :block_size), 'hex'));
|
|
brin_page_type
|
|
----------------
|
|
|
|
(1 row)
|
|
|
|
SELECT brin_page_items(decode(repeat('00', :block_size), 'hex'), 'test1_a_idx');
|
|
brin_page_items
|
|
-----------------
|
|
(0 rows)
|
|
|
|
SELECT brin_metapage_info(decode(repeat('00', :block_size), 'hex'));
|
|
brin_metapage_info
|
|
--------------------
|
|
|
|
(1 row)
|
|
|
|
SELECT brin_revmap_data(decode(repeat('00', :block_size), 'hex'));
|
|
brin_revmap_data
|
|
------------------
|
|
|
|
(1 row)
|
|
|
|
-- Test that partial indexes have all pages, including empty ones.
|
|
CREATE TABLE test2 (a int);
|
|
INSERT INTO test2 SELECT i FROM generate_series(1,1000) s(i);
|
|
-- No rows match the index predicate, make sure the index has the right number
|
|
-- of ranges (same as number of page ranges).
|
|
CREATE INDEX ON test2 USING brin (a) WITH (pages_per_range=1) WHERE (a IS NULL);
|
|
ANALYZE test2;
|
|
-- Does the index have one summary of the relation?
|
|
SELECT (COUNT(*) = (SELECT relpages FROM pg_class WHERE relname = 'test2')) AS ranges_do_match
|
|
FROM generate_series((SELECT (lastrevmappage + 1) FROM brin_metapage_info(get_raw_page('test2_a_idx', 0))),
|
|
(SELECT (relpages - 1) FROM pg_class WHERE relname = 'test2_a_idx')) AS pages(p),
|
|
LATERAL brin_page_items(get_raw_page('test2_a_idx', p), 'test2_a_idx') AS items;
|
|
ranges_do_match
|
|
-----------------
|
|
t
|
|
(1 row)
|
|
|
|
DROP TABLE test1;
|
|
DROP TABLE test2;
|
|
-- Test that parallel index build produces the same BRIN index as serial build.
|
|
CREATE TABLE brin_parallel_test (a int, b text, c bigint) WITH (fillfactor=40);
|
|
-- Generate a table with a mix of NULLs and non-NULL values (and data suitable
|
|
-- for the different opclasses we build later).
|
|
INSERT INTO brin_parallel_test
|
|
SELECT (CASE WHEN (mod(i,231) = 0) OR (i BETWEEN 3500 AND 4000) THEN NULL ELSE i END),
|
|
(CASE WHEN (mod(i,233) = 0) OR (i BETWEEN 3750 AND 4250) THEN NULL ELSE md5(i::text) END),
|
|
(CASE WHEN (mod(i,233) = 0) OR (i BETWEEN 3850 AND 4500) THEN NULL ELSE (i/100) + mod(i,8) END)
|
|
FROM generate_series(1,5000) S(i);
|
|
-- Build an index with different opclasses - minmax, bloom and minmax-multi.
|
|
--
|
|
-- For minmax and opclass this is simple, but for minmax-multi we need to be
|
|
-- careful, because the result depends on the order in which values are added
|
|
-- to the summary, which in turn affects how are values merged etc. The order
|
|
-- of merging results from workers has similar effect. All those summaries
|
|
-- should produce correct query results, but it means we can't compare them
|
|
-- using equality (which is what EXCEPT does). To work around this issue, we
|
|
-- generated the data to only have very small number of distinct values per
|
|
-- range, so that no merging is needed. This makes the results deterministic.
|
|
-- build index without parallelism
|
|
SET max_parallel_maintenance_workers = 0;
|
|
CREATE INDEX brin_test_serial_idx ON brin_parallel_test
|
|
USING brin (a int4_minmax_ops, a int4_bloom_ops, b, c int8_minmax_multi_ops)
|
|
WITH (pages_per_range=7)
|
|
WHERE NOT (a BETWEEN 1000 and 1500);
|
|
-- build index using parallelism
|
|
--
|
|
-- Set a couple parameters to force parallel build for small table. There's a
|
|
-- requirement for table size, so disable that. Also, plan_create_index_workers
|
|
-- assumes each worker will use work_mem=32MB for sorting (which works for btree,
|
|
-- but not really for BRIN), so we set maintenance_work_mem for 4 workers.
|
|
SET min_parallel_table_scan_size = 0;
|
|
SET max_parallel_maintenance_workers = 4;
|
|
SET maintenance_work_mem = '128MB';
|
|
CREATE INDEX brin_test_parallel_idx ON brin_parallel_test
|
|
USING brin (a int4_minmax_ops, a int4_bloom_ops, b, c int8_minmax_multi_ops)
|
|
WITH (pages_per_range=7)
|
|
WHERE NOT (a BETWEEN 1000 and 1500);
|
|
SELECT relname, relpages
|
|
FROM pg_class
|
|
WHERE relname IN ('brin_test_serial_idx', 'brin_test_parallel_idx')
|
|
ORDER BY relname;
|
|
relname | relpages
|
|
------------------------+----------
|
|
brin_test_parallel_idx | 3
|
|
brin_test_serial_idx | 3
|
|
(2 rows)
|
|
|
|
-- Check that (A except B) and (B except A) is empty, which means the indexes
|
|
-- are the same.
|
|
SELECT * FROM brin_page_items(get_raw_page('brin_test_parallel_idx', 2), 'brin_test_parallel_idx')
|
|
EXCEPT
|
|
SELECT * FROM brin_page_items(get_raw_page('brin_test_serial_idx', 2), 'brin_test_serial_idx');
|
|
itemoffset | blknum | attnum | allnulls | hasnulls | placeholder | empty | value
|
|
------------+--------+--------+----------+----------+-------------+-------+-------
|
|
(0 rows)
|
|
|
|
SELECT * FROM brin_page_items(get_raw_page('brin_test_serial_idx', 2), 'brin_test_serial_idx')
|
|
EXCEPT
|
|
SELECT * FROM brin_page_items(get_raw_page('brin_test_parallel_idx', 2), 'brin_test_parallel_idx');
|
|
itemoffset | blknum | attnum | allnulls | hasnulls | placeholder | empty | value
|
|
------------+--------+--------+----------+----------+-------------+-------+-------
|
|
(0 rows)
|
|
|
|
DROP INDEX brin_test_parallel_idx;
|
|
-- force parallel build, but don't allow starting parallel workers to force
|
|
-- fallback to serial build, and repeat the checks
|
|
SET max_parallel_workers = 0;
|
|
CREATE INDEX brin_test_parallel_idx ON brin_parallel_test
|
|
USING brin (a int4_minmax_ops, a int4_bloom_ops, b, c int8_minmax_multi_ops)
|
|
WITH (pages_per_range=7)
|
|
WHERE NOT (a BETWEEN 1000 and 1500);
|
|
SELECT relname, relpages
|
|
FROM pg_class
|
|
WHERE relname IN ('brin_test_serial_idx', 'brin_test_parallel_idx')
|
|
ORDER BY relname;
|
|
relname | relpages
|
|
------------------------+----------
|
|
brin_test_parallel_idx | 3
|
|
brin_test_serial_idx | 3
|
|
(2 rows)
|
|
|
|
SELECT * FROM brin_page_items(get_raw_page('brin_test_parallel_idx', 2), 'brin_test_parallel_idx')
|
|
EXCEPT
|
|
SELECT * FROM brin_page_items(get_raw_page('brin_test_serial_idx', 2), 'brin_test_serial_idx');
|
|
itemoffset | blknum | attnum | allnulls | hasnulls | placeholder | empty | value
|
|
------------+--------+--------+----------+----------+-------------+-------+-------
|
|
(0 rows)
|
|
|
|
SELECT * FROM brin_page_items(get_raw_page('brin_test_serial_idx', 2), 'brin_test_serial_idx')
|
|
EXCEPT
|
|
SELECT * FROM brin_page_items(get_raw_page('brin_test_parallel_idx', 2), 'brin_test_parallel_idx');
|
|
itemoffset | blknum | attnum | allnulls | hasnulls | placeholder | empty | value
|
|
------------+--------+--------+----------+----------+-------------+-------+-------
|
|
(0 rows)
|
|
|
|
DROP TABLE brin_parallel_test;
|
|
RESET min_parallel_table_scan_size;
|
|
RESET max_parallel_maintenance_workers;
|
|
RESET maintenance_work_mem;
|