212 lines
8.6 KiB
Plaintext
212 lines
8.6 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);
|
|
-- Delete a couple pages, to make the ranges empty.
|
|
DELETE FROM brin_parallel_test WHERE a BETWEEN 1000 and 1500;
|
|
-- Vacuum to remove the tuples and make the ranges actually empty.
|
|
VACUUM brin_parallel_test;
|
|
-- 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);
|
|
-- 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);
|
|
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);
|
|
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;
|