mirror of
https://github.com/postgres/postgres.git
synced 2026-10-23 13:29:09 +03:00
a85b5523e6
A hash index scan whose target bucket is still being populated by a
split must read both buckets of the split: forward scans read the bucket
being populated (skipping the tuples that the split copied there) and
then the bucket being split, and backward scans read them in the
opposite order. _hash_readnext and _hash_readprev make the transition
from the first bucket to the second, but _hash_next did not: on reaching
the end of the first bucket, it ended the scan, so every matching tuple
in the second bucket was overlooked.
To fix, teach _hash_next to make the same transition, using helper
functions shared with _hash_readnext and _hash_readprev.
_hash_next only missed the transition when the last page that it read in
the first bucket had a match (otherwise _hash_readpage's loop made the
required transition). Getting wrong answers also needed a matching
tuple to be inserted into the bucket being populated _after_ the split
began. Forward scans then lost the older tuples in the bucket being
split. An incomplete split would keep the buckets in this state until
an inserter finished the split at some indeterminate later time. Note
that wrong answers didn't require an incomplete split.
Although this fix treats the bug as the omission of a required step in
_hash_next, the real problem is the way that page stepping works in
general. The logic for stepping to the next page appears both in
high-level routines like _hash_next and in low-level routines like
_hash_readnext and _hash_readprev. If anything, _hash_next already knew
too much about page stepping (cf. nbtree's _bt_next function). All of
the logic around stepping really belongs in one routine, modeled on
nbtree's _bt_steppage function, but that approach is much too invasive
for a backpatched fix.
Claude Code found this problem. The committed test case is a simplified
version of the one that it wrote to demonstrate this bug.
Oversight in commit 7c75ef57, which introduced page-at-a-time processing
of hash index scans.
Author: Peter Geoghegan <pg@bowt.ie>
Author: Amit Kapila <amit.kapila16@gmail.com>
Reviewed-by: Vignesh C <vignesh21@gmail.com>
Discussion: https://postgr.es/m/CAH2-Wz=4CJK9ysZzbzxBGGTkgAg9ib8cJyCx=9q_d1r8tf0ang@mail.gmail.com
Backpatch-through: 14
54 lines
2.2 KiB
PL/PgSQL
54 lines
2.2 KiB
PL/PgSQL
-- Test hash index scans of a bucket pair whose split is incomplete.
|
|
--
|
|
-- A scan whose target bucket is still being populated by a split must read
|
|
-- both buckets: the one being populated, skipping the tuples moved there,
|
|
-- and the one being split.
|
|
CREATE EXTENSION injection_points;
|
|
SELECT injection_points_set_local();
|
|
|
|
SELECT injection_points_attach('hash-finish-incomplete-split', 'notice');
|
|
|
|
-- Build an index on an analyzed 10-row table, so that it starts out with
|
|
-- just two buckets (metapage, two bucket pages, bitmap page). Rows with
|
|
-- v = 1 hash to bucket 0, and to bucket 2 once bucket 0 splits.
|
|
CREATE TABLE hash_split_test (v int4) WITH (autovacuum_enabled = false);
|
|
INSERT INTO hash_split_test SELECT 1 FROM generate_series(1, 10);
|
|
ANALYZE hash_split_test;
|
|
CREATE INDEX hash_split_index ON hash_split_test USING hash (v);
|
|
SELECT pg_relation_size('hash_split_index') /
|
|
current_setting('block_size')::int AS index_pages;
|
|
|
|
-- Error out during the first bucket split, leaving it incomplete
|
|
SELECT injection_points_attach('hash-split-before-relocation', 'error');
|
|
INSERT INTO hash_split_test SELECT g FROM generate_series(1000001, 1005000) g;
|
|
SELECT injection_points_detach('hash-split-before-relocation');
|
|
|
|
-- This row goes to the new bucket, which is still flagged as being populated
|
|
INSERT INTO hash_split_test VALUES (1);
|
|
|
|
-- Forward and backward index scans must find it there, plus the 10 older
|
|
-- rows that remain in bucket 0
|
|
SET enable_seqscan = off;
|
|
SET enable_bitmapscan = off;
|
|
EXPLAIN (COSTS OFF) SELECT count(*) FROM hash_split_test WHERE v = 1;
|
|
SELECT count(*) FROM hash_split_test WHERE v = 1;
|
|
BEGIN;
|
|
DECLARE c SCROLL CURSOR FOR SELECT v FROM hash_split_test WHERE v = 1;
|
|
MOVE FORWARD ALL IN c;
|
|
FETCH BACKWARD ALL FROM c;
|
|
COMMIT;
|
|
|
|
-- An insert into bucket 0 (v = 5 hashes there) finishes the split. The
|
|
-- scan must still find all 11 rows.
|
|
INSERT INTO hash_split_test VALUES (5);
|
|
SELECT count(*) FROM hash_split_test WHERE v = 1;
|
|
|
|
-- The heap agrees
|
|
SET enable_seqscan = on;
|
|
SET enable_indexscan = off;
|
|
SELECT count(*) FROM hash_split_test WHERE v = 1;
|
|
|
|
SELECT injection_points_detach('hash-finish-incomplete-split');
|
|
DROP TABLE hash_split_test;
|
|
DROP EXTENSION injection_points;
|